diff --git a/bin/asli.ml b/bin/asli.ml
index b2c1c14c..2eaca0c8 100644
--- a/bin/asli.ml
+++ b/bin/asli.ml
@@ -11,6 +11,7 @@ open LibASL
 
 open Asl_ast
 open Value
+open Symbolic
 open Eval
 open Asl_utils
 
@@ -39,8 +40,8 @@ let help_msg = [
     {|:? :help                       Show this help message|};
     {|:elf <file>                    Load an ELF file|};
     {|:opcode <instr-set> <int>      Decode and execute opcode|};
-    {|:sem <instr-set> <int>         Decode and print opcode semantics|};
-    {|:ast <instr-set> <int> [file]  Decode and write opcode semantics to stdout or a file, in a structured ast format|};
+    {|:sem <instr-set> <bits>        Decode and print opcode semantics|};
+    {|:ast <instr-set> <bits> [file] Decode and write opcode semantics to stdout or a file, in a structured ast format|};
     {|:gen <instr-set> <regex>       Generate an offline lifter using the given backend|};
     {|      [backend] [pc-option] [dir]|};
     {|:project <file>                Execute ASLi commands in <file>|};
@@ -186,17 +187,16 @@ let rec process_command (tcenv: TC.Env.t) (cpu: Cpu.cpu) (fname: string) (input0
         ) encodings;
     | [":sem"; iset; opcode] ->
         let cpu' = Cpu.mkCPU cpu.env cpu.denv in
-        let op = Z.of_string opcode in
-        Printf.printf "Decoding instruction %s %s\n" iset (Z.format "%x" op);
-        cpu'.sem iset op
+        Printf.printf "Decoding instruction %s %s\n" iset opcode;
+        cpu'.sem iset opcode
     | ":ast" :: iset :: opcode :: rest when List.length rest <= 1 ->
-        let op = Z.of_string opcode in
+        let op = sym_bits_of_string opcode in
         let decoder = Eval.Env.getDecoder cpu.env (Ident iset) in
         let chan_opt = Option.map open_out (List.nth_opt rest 0) in
         let chan = Option.value chan_opt ~default:stdout in
         List.iter
             (fun s -> Printf.fprintf chan "%s\n" (Utils.to_string (PP.pp_raw_stmt s)))
-            (Dis.dis_decode_entry cpu.env cpu.denv decoder op);
+            (Dis.dis_decode_entry_sym cpu.env cpu.denv decoder op);
         Option.iter close_out chan_opt
     | ":gen" :: iset :: id :: rest when List.length rest <= 3 ->
         let backend_str = Option.value List.(nth_opt rest 0) ~default:"ocaml" in
diff --git a/libASL/cpu.ml b/libASL/cpu.ml
index e649940f..62c85cdd 100644
--- a/libASL/cpu.ml
+++ b/libASL/cpu.ml
@@ -8,6 +8,7 @@
 module AST = Asl_ast
 
 open Asl_utils
+open Symbolic
 
 type gen_backend =
     | Ocaml
@@ -25,7 +26,7 @@ type cpu = {
     setPC    : Primops.bigint -> unit;
     elfwrite : Int64.t -> char -> unit;
     opcode   : string -> Primops.bigint -> unit;
-    sem      : string -> Primops.bigint -> unit;
+    sem      : string -> string -> unit;
     gen      : string -> string -> bool -> gen_backend -> string -> unit;
 }
 
@@ -55,12 +56,16 @@ let mkCPU (env : Eval.Env.t) (denv: Dis.env): cpu =
         let decoder = Eval.Env.getDecoder env (Ident iset) in
         Eval.eval_decode_case AST.Unknown env decoder opcode
 
-    and sem (iset: string) (opcode: Primops.bigint): unit =
+    and sem (iset: string) (opcode: string): unit =
         let decoder = Eval.Env.getDecoder env (Ident iset) in
+
+        (* Parse symbolic opcode *)
+        let op = sym_bits_of_string opcode in
+        
         List.iter
             (fun s -> Printf.printf "%s\n" (pp_stmt s))
-            (Dis.dis_decode_entry env denv decoder opcode)
-
+            (Dis.dis_decode_entry_sym env denv decoder op)
+        
     and gen (iset: string) (pat: string) (include_pc: bool) (backend: gen_backend) (dir: string): unit =
         if not (Sys.file_exists dir) then failwith ("Can't find target dir " ^ dir);
 
diff --git a/libASL/cpu.mli b/libASL/cpu.mli
index 54801332..2c7407ee 100644
--- a/libASL/cpu.mli
+++ b/libASL/cpu.mli
@@ -21,7 +21,7 @@ type cpu = {
     setPC    : Primops.bigint -> unit;
     elfwrite : Int64.t -> char -> unit;
     opcode   : string -> Primops.bigint -> unit;
-    sem      : string -> Primops.bigint -> unit;
+    sem      : string -> string -> unit;
     gen      : string -> string -> bool -> gen_backend -> string -> unit;
 }
 
diff --git a/libASL/dis.ml b/libASL/dis.ml
index 521cb9c2..1ccf763a 100644
--- a/libASL/dis.ml
+++ b/libASL/dis.ml
@@ -14,7 +14,6 @@ module TC   = Tcheck
 open AST
 open Asl_utils
 open Value
-
 open Symbolic
 
 module StringCmp = struct
@@ -1417,24 +1416,27 @@ and dis_stmt' (x: AST.stmt): unit rws =
         DisEnv.write [Stmt_Assert(expr_false, loc)]
     )
 
-let dis_encoding (x: encoding) (op: Primops.bigint): (stmt list option) rws =
+let dis_encoding (x: encoding) (op: sym): (stmt list option) rws =
     let Encoding_Block (nm, iset, fields, opcode, guard, unpreds, b, loc) = x in
     (* todo: consider checking iset *)
     (* Printf.printf "Checking opcode match %s == %s\n" (Utils.to_string (PP.pp_opcode_value opcode)) (pp_value op); *)
-    match Eval.eval_opcode_guard loc opcode op with
-    | Some op ->
+    let ok = (match opcode with
+    | Opcode_Bits b -> sym_eq     loc op (Val (from_bitsLit b))
+    | Opcode_Mask m -> sym_inmask loc op (to_mask loc (from_maskLit m))
+    ) in
+    if (bool_of_sym ok) then begin
         if !Eval.trace_instruction then Printf.printf "TRACE: instruction %s\n" (pprint_ident nm);
 
         let@ () = DisEnv.traverse_ (function (IField_Field (f, lo, wd)) ->
-            let v = extract_bits' loc op lo wd in
-            if !Eval.trace_instruction then Printf.printf "      %s = %s\n" (pprint_ident f) (pp_value v);
-            declare_assign_var Unknown (val_type v) f (Val v)
+            let s = sym_extract_bits loc op (sym_of_int lo) (sym_of_int wd) in
+            if !Eval.trace_instruction then Printf.printf "      %s = %s\n" (pprint_ident f) (pp_sym s);
+            declare_assign_var Unknown (sym_type s) f s
         ) fields in
 
         let@ guard' = dis_expr loc guard in
         if to_bool loc (sym_value_unsafe guard') then begin
             List.iter (fun (i, b) ->
-                if eval_eq loc (extract_bits' loc op i 1) (from_bitsLit b) then
+                if eval_eq loc (sym_value_unsafe (sym_extract_bits loc op (sym_of_int i) (sym_of_int 1))) (from_bitsLit b) then
                     raise (Throw (loc, Exc_Unpredictable))
             ) unpreds;
             (* dis_encoding: we cannot guarantee that these statements are fully evaluated. *)
@@ -1442,28 +1444,36 @@ let dis_encoding (x: encoding) (op: Primops.bigint): (stmt list option) rws =
         end else begin
             DisEnv.pure None
         end
-    | None -> DisEnv.pure None
-
-let dis_decode_slice (loc: l) (x: decode_slice) (op: Primops.bigint): value rws =
+    end else begin
+        DisEnv.pure None
+    end
+
+let rec dis_decode_pattern (loc: AST.l) (x: decode_pattern) (op: sym): sym =
+    match x with
+    | DecoderPattern_Bits     b -> sym_eq     loc op (Val (from_bitsLit b))
+    | DecoderPattern_Mask     m -> sym_inmask loc op (to_mask loc (from_maskLit m))
+    | DecoderPattern_Wildcard _ -> sym_true
+    | DecoderPattern_Not      p -> sym_not_bool loc (dis_decode_pattern loc p op)
+    
+let dis_decode_slice (loc: l) (x: decode_slice) (op: sym): sym rws =
     (match x with
     | DecoderSlice_Slice (lo, wd) ->
-        let op = Value.from_bitsInt (lo+wd) op in
-        DisEnv.pure @@ extract_bits' loc op lo wd
+        (*let op = Value.from_bitsInt (lo+wd) op in*)
+        DisEnv.pure @@ sym_extract_bits loc op (sym_of_int lo) (sym_of_int wd)
     | DecoderSlice_FieldName f ->
-        (* assumes expression always evaluates to concrete value. *)
-        let+ _,f' = DisEnv.getVar loc f in sym_value_unsafe f'
+        let+ _,f' = DisEnv.getVar loc f in f'
     | DecoderSlice_Concat fs ->
         (* assumes expression always evaluates to concrete value. *)
         let+ fs' = DisEnv.traverse (DisEnv.getVar loc) fs in
-        eval_concat loc (List.map (fun (_,s) -> sym_value_unsafe s) fs')
+        sym_concat loc (List.map (fun (t,s) -> (width_of_type loc t, s)) fs')
     )
 
 (* Duplicate of eval_decode_case modified to print rather than eval *)
-let rec dis_decode_case (loc: AST.l) (x: decode_case) (op: Primops.bigint): string rws =
+let rec dis_decode_case (loc: AST.l) (x: decode_case) (op: sym): string rws =
     let body = dis_decode_case' loc x op in
     if no_debug() then body
     else DisEnv.scope loc "dis_decode_case" (pp_decode_case x) Fun.id body
-and dis_decode_case' (loc: AST.l) (x: decode_case) (op: Primops.bigint): string rws =
+and dis_decode_case' (loc: AST.l) (x: decode_case) (op: sym): string rws =
     (match x with
     | DecoderCase_Case (ss, alts, loc) ->
             let@ vs = DisEnv.traverse (fun s -> dis_decode_slice loc s op) ss in
@@ -1482,12 +1492,12 @@ and dis_decode_case' (loc: AST.l) (x: decode_case) (op: Primops.bigint): string
     )
 
 (* Duplicate of eval_decode_alt modified to print rather than eval *)
-and dis_decode_alt (loc: l) (x: decode_alt) (vs: value list) (op: Primops.bigint): string option rws =
-    let body = dis_decode_alt' loc x vs op in
+and dis_decode_alt (loc: l) (x: decode_alt) (ss: sym list) (op: sym): string option rws =
+    let body = dis_decode_alt' loc x ss op in
     if no_debug() then body
     else DisEnv.scope loc "dis_decode_alt" (pp_decode_alt x) Option.(fold ~none:"(unmatched)" ~some:Fun.id) body
-and dis_decode_alt' (loc: AST.l) (DecoderAlt_Alt (ps, b)) (vs: value list) (op: Primops.bigint): string option rws =
-    if List.for_all2 (Eval.eval_decode_pattern loc) ps vs then
+and dis_decode_alt' (loc: AST.l) (DecoderAlt_Alt (ps, b)) (ss: sym list) (op: sym): string option rws =
+    if List.for_all2 (fun p s -> (bool_of_sym (dis_decode_pattern loc p s))) ps ss then
         (match b with
         | DecoderBody_UNPRED loc -> raise (Throw (loc, Exc_Unpredictable))
         | DecoderBody_UNALLOC loc -> raise (Throw (loc, Exc_Undefined))
@@ -1529,9 +1539,8 @@ and dis_decode_alt' (loc: AST.l) (DecoderAlt_Alt (ps, b)) (vs: value list) (op:
         | DecoderBody_Decoder (fs, c, loc) ->
                 let@ () = DisEnv.modify (LocalEnv.addLevel) in
                 let@ () = DisEnv.traverse_ (function (IField_Field (f, lo, wd)) ->
-                    let op = Value.from_bitsInt (lo+wd) op in
-                    let v = extract_bits' loc op lo wd in
-                    declare_assign_var loc (val_type v) f (Val v)
+                    let s = sym_extract_bits loc op (sym_of_int lo) (sym_of_int wd) in
+                    declare_assign_var loc (sym_type s) f s
                 ) fs
                 in
                 let@ result = dis_decode_case loc c op in
@@ -1553,10 +1562,15 @@ let enum_types env i =
     | _ -> None
 
 (* Actually perform dis *)
-let dis_core ~(config:config) ((lenv,globals): env) (decode: decode_case) (op: Primops.bigint): string * stmt list =
+let dis_core ~(config:config) ((lenv,globals): env) (decode: decode_case) (op: sym_bits): string * stmt list =
     let DecoderCase_Case (_,_,loc) = decode in
-    let lenv = {lenv with trace = ["dis_core", "0x" ^ Z.format "%08x" op, Unknown]} in
-    let (enc,lenv',stmts) = (dis_decode_case loc decode op) config lenv in
+
+    (* Declare symbolic fields as globals *)
+    let fields = fields_of_sym_bits op in
+    let field_names = List.map fst fields in
+    let globals = List.fold_left (fun idents name -> IdentSet.add name idents) globals field_names in
+
+    let (enc,lenv',stmts) = (dis_decode_case loc decode (sym_of_sym_bits op) config lenv) in
     let varentries = List.(concat @@ map (fun vars -> StringMap.(bindings (map fst vars))) lenv.locals) in
     let bindings = Asl_utils.Bindings.of_seq @@ List.to_seq @@ List.map (fun (x,y) -> (Ident x,y)) varentries in
     (* List.iter (fun (v,t) -> Printf.printf ("%s:%s\n") v (pp_type t)) varentries; *)
@@ -1566,7 +1580,7 @@ let dis_core ~(config:config) ((lenv,globals): env) (decode: decode_case) (op: P
     let stmts' = Transforms.FixRedefinitions.run (globals : IdentSet.t) stmts' in
     let stmts' = Transforms.StatefulIntToBits.run (enum_types config.eval_env) stmts' in
     let stmts' = Transforms.IntToBits.ints_to_bits stmts' in
-    let stmts' = Transforms.CommonSubExprElim.do_transform stmts' in
+    let stmts' = Transforms.CommonSubExprElim.do_transform stmts' globals in
     let stmts' = Transforms.CopyProp.copyProp stmts' in
     let stmts' = Transforms.RedundantSlice.do_transform bindings stmts' in
     let stmts' = Transforms.RemoveUnused.remove_unused globals @@ stmts' in
@@ -1591,7 +1605,7 @@ let dis_core ~(config:config) ((lenv,globals): env) (decode: decode_case) (op: P
    This is a complete hack, but it is nicer to make the loop unrolling decision during
    partial evaluation, rather than having to unroll after we know vectorization failed.
  *)
-let dis_decode_entry_with_inst (env: Eval.Env.t) ((lenv,globals): env) (decode: decode_case) (op: Primops.bigint): string * stmt list =
+let dis_decode_entry_with_inst (env: Eval.Env.t) ((lenv,globals): env) (decode: decode_case) (op: sym_bits): string * stmt list =
   let max_upper_bound = Z.of_int64 Int64.max_int in
   let config = { eval_env = env ; unroll_bound=max_upper_bound } in
   let stmts = match !Symbolic.use_vectoriser with
@@ -1605,9 +1619,12 @@ let dis_decode_entry_with_inst (env: Eval.Env.t) ((lenv,globals): env) (decode:
         RASL_check.AllowedLanguageConstructs.check_stmts_exc (snd stmts);
     stmts
 
-let dis_decode_entry (env: Eval.Env.t) ((lenv,globals): env) (decode: decode_case) (op: Primops.bigint): stmt list =
+let dis_decode_entry_sym (env: Eval.Env.t) ((lenv,globals): env) (decode: decode_case) (op: sym_bits): stmt list =
   snd @@ dis_decode_entry_with_inst env (lenv,globals) decode op
 
+let dis_decode_entry (env: Eval.Env.t) ((lenv,globals): env) (decode: decode_case) (op: Primops.bigint): stmt list =
+    dis_decode_entry_sym env (lenv,globals) decode (sym_bits_of_bv (Primops.prim_cvt_int_bits (Z.of_int 32) op))
+
 let build_env (env: Eval.Env.t): env =
     let env = Eval.Env.freeze env in
     let lenv = LocalEnv.init env in
@@ -1655,4 +1672,5 @@ let retrieveDisassembly ?(address:string option) (env: Eval.Env.t) (lenv: env) (
     let lenv = match address with
     | Some v -> setPC env lenv (Z.of_string v)
     | None -> lenv in
-    dis_decode_entry env lenv decoder (Z.of_string opcode)
+    let op = sym_bits_of_string opcode in
+    dis_decode_entry_sym env lenv decoder op
diff --git a/libASL/symbolic.ml b/libASL/symbolic.ml
index cd918094..25c82809 100644
--- a/libASL/symbolic.ml
+++ b/libASL/symbolic.ml
@@ -180,6 +180,11 @@ let int_of_sym (e: sym): int =
   | Exp e        -> int_of_expr e
   | _ -> failwith @@ "int_of_sym: cannot coerce to int " ^ pp_sym e
 
+let bool_of_sym (s: sym): bool =
+  match s with
+  | Val (VBool b) -> b
+  | _ -> failwith @@ "bool_of_sym: cannot coerce to bool " ^ pp_sym s  
+  
 let sym_of_tuple (loc: AST.l) (v: sym): sym list  =
   match v with
   | Val (VTuple vs) -> (List.map (fun v -> Val v) vs)
@@ -277,21 +282,8 @@ let rec sym_eq_int loc x y =
 
 let sym_le_int   = prim_binop "le_int"
 
-let sym_eq_bits  = prim_binop "eq_bits"
-
 let sym_eq_real  = prim_binop "eq_real"
 
-let sym_eq (loc: AST.l) (x: sym) (y: sym): sym =
-  (match (x,y) with
-  | (Val x,Val y) -> Val (from_bool (eval_eq loc x y))
-  | (Exp _,Val v) | (Val v, Exp _) ->
-      (match v with
-      | VBits _ -> sym_eq_bits loc x y
-      | VInt _
-      | VEnum _ -> sym_eq_int loc x y
-      | VReal _ -> sym_eq_real loc x y
-      | _ -> failwith @@ "sym_eq: unknown value type " ^ (pp_sym x) ^ " " ^ (pp_sym y))
-  | (_,_) -> failwith "sym_eq: insufficient info to resolve type")
 
 let rec is_pure_exp (e: expr) =
   match e with
@@ -445,15 +437,6 @@ let sym_not_bits loc w (x: sym) =
   | Val x -> Val (VBits (prim_not_bits (to_bits loc x)))
   | _ -> Exp (Expr_TApply (FIdent ("not_bits", 0), [w], [sym_expr x]) )
 
-let sym_and_bits loc w (x: sym) (y: sym) =
-  match x, y with
-  | Val x, Val y -> Val (VBits (prim_and_bits (to_bits loc x) (to_bits loc y)))
-  | Val x, y when is_zero_bits x -> Val x
-  | x, Val y when is_zero_bits y -> Val y
-  | Val x, y when is_one_bits x -> y
-  | x, Val y when is_one_bits y -> x
-  | _ -> Exp (Expr_TApply (FIdent ("and_bits", 0), [w], [sym_expr x; sym_expr y]) )
-
 let sym_add_bits loc w (x: sym) (y: sym) =
   match x, y with
   | Val x, Val y -> Val (VBits (prim_add_bits (to_bits loc x) (to_bits loc y)))
@@ -461,34 +444,6 @@ let sym_add_bits loc w (x: sym) (y: sym) =
   | x, Val y when is_zero_bits y -> x
   | _ -> Exp (Expr_TApply (FIdent ("add_bits", 0), [w], [sym_expr x; sym_expr y]) )
 
-let sym_inmask loc v mask =
-  match v with
-  | Val x -> Val (VBool (prim_in_mask (to_bits loc x) mask))
-  | Exp e ->
-      let n = mask.n in
-      let ne = Expr_LitInt (string_of_int n) in
-      let m = Val (VBits {v = mask.m; n}) in
-      let v = Val (VBits {v = mask.v; n}) in
-      sym_eq_bits loc (sym_and_bits loc ne (Exp e) m) v
-
-let rec sym_or_bits loc w (x: sym) (y: sym) =
-  match x, y with
-  | Val x, Val y -> Val (VBits (prim_or_bits (to_bits loc x) (to_bits loc y)))
-  | Val x, y when is_one_bits x -> Val x
-  | x, Val y when is_one_bits y -> Val y
-  | Val x, y when is_zero_bits x -> y
-  | x, Val y when is_zero_bits y -> x
-  (* (a /\ b) \/ !a ~> b \/ !a *)
-  | Exp (Expr_TApply (FIdent ("and_bits", 0), _, [a; x])), Exp (Expr_TApply (FIdent ("not_bits", 0), _, [a'])) when a = a' ->
-      sym_or_bits loc w (sym_of_expr x) y
-  | _ -> Exp (Expr_TApply (FIdent ("or_bits", 0), [w], [sym_expr x; sym_expr y]) )
-
-(** Construct a ITE expression from bitvector operations. Expects arguments to be 1 bit wide. *)
-let sym_ite_bits loc (b: sym) (x: sym) (y: sym) =
-  let w = Expr_LitInt "1" in
-  let b = sym_cvt_bool_bv loc b in
-  let nb = sym_not_bits loc w b in
-  sym_or_bits loc w (sym_and_bits loc w b x) (sym_and_bits loc w nb y)
 
 let int_expr i = Expr_LitInt (string_of_int i)
 
@@ -614,7 +569,7 @@ and sym_slice (loc: l) (x: sym) (lo: int) (wd: int): sym =
     | _ -> Exp slice_expr)
 
 (** Wrapper around sym_slice to handle cases of symbolic slice bounds *)
-let sym_extract_bits loc v i w =
+and sym_extract_bits loc v i w =
   match (v, i, w) with
   (* Constant slice *)
   | _, Val i', Val w' ->
@@ -627,6 +582,73 @@ let sym_extract_bits loc v i w =
       Exp (Expr_Slices (e, [Slice_LoWd (sym_expr lo, sym_expr wd')]))
   | _ -> Exp (Expr_Slices (sym_expr v, [Slice_LoWd (sym_expr i, sym_expr w)]))
 
+and sym_and_bits loc w (x: sym) (y: sym) =
+  match x, y with
+  | Val x, Val y -> Val (VBits (prim_and_bits (to_bits loc x) (to_bits loc y)))
+  | Val x, y when is_zero_bits x -> Val x
+  | x, Val y when is_zero_bits y -> Val y
+  | Val x, y when is_one_bits x -> y
+  | x, Val y when is_one_bits y -> x
+  | (Exp (Expr_TApply (FIdent ("append_bits", 0), [Expr_LitInt lw; Expr_LitInt rw], [l; r])), y) ->
+    let lw' = int_of_string lw in
+    let rw' = int_of_string rw in
+    let yl = sym_slice loc y rw' lw' in
+    let yr = sym_slice loc y 0 rw' in
+    let l' = sym_and_bits loc (expr_of_int lw') (sym_of_expr l) yl in
+    let r' = sym_and_bits loc (expr_of_int rw') (sym_of_expr r) yr in
+    sym_append_bits loc lw' rw' l' r'
+  | _ -> Exp (Expr_TApply (FIdent ("and_bits", 0), [w], [sym_expr x; sym_expr y]) )
+
+and sym_or_bits loc w (x: sym) (y: sym) =
+  match x, y with
+  | Val x, Val y -> Val (VBits (prim_or_bits (to_bits loc x) (to_bits loc y)))
+  | Val x, y when is_one_bits x -> Val x
+  | x, Val y when is_one_bits y -> Val y
+  | Val x, y when is_zero_bits x -> y
+  | x, Val y when is_zero_bits y -> x
+  | _ -> Exp (Expr_TApply (FIdent ("or_bits", 0), [w], [sym_expr x; sym_expr y]) )
+
+and sym_eq_bits loc (x: sym) (y: sym) =
+  match x, y with
+  | Val x, Val y -> Val (VBool (prim_eq_bits (to_bits loc x) (to_bits loc y)))
+  | (Exp (Expr_TApply (FIdent ("append_bits", 0), [lw; rw], [l; r])), y) ->
+    let lw' = sym_of_expr lw in
+    let rw' = sym_of_expr rw in
+    let yl = sym_extract_bits loc y rw' lw' in
+    let yr = sym_extract_bits loc y (sym_of_int 0) rw' in
+    let l' = sym_eq_bits loc (sym_of_expr l) yl in
+    let r' = sym_eq_bits loc (sym_of_expr r) yr in
+    sym_and_bool loc l' r'
+  | _ -> prim_binop "eq_bits" loc x y
+
+and sym_inmask loc v mask =
+  match v with
+  | Val x -> Val (VBool (prim_in_mask (to_bits loc x) mask))
+  | Exp e ->
+      let n = mask.n in
+      let ne = Expr_LitInt (string_of_int n) in
+      let m = Val (VBits {v = mask.m; n}) in
+      let v = Val (VBits {v = mask.v; n}) in
+      sym_eq_bits loc (sym_and_bits loc ne (Exp e) m) v
+
+and sym_eq (loc: AST.l) (x: sym) (y: sym): sym =
+  (match (x,y) with
+  | (Val x,Val y) -> Val (from_bool (eval_eq loc x y))
+  | (Exp _,Val v) | (Val v, Exp _) ->
+      (match v with
+      | VBits _ -> sym_eq_bits loc x y
+      | VInt _
+      | VEnum _ -> sym_eq_int loc x y
+      | VReal _ -> sym_eq_real loc x y
+      | _ -> failwith @@ "sym_eq: unknown value type " ^ (pp_sym x) ^ " " ^ (pp_sym y))
+  | (_,_) -> failwith "sym_eq: insufficient info to resolve type")
+
+(** Construct a ITE expression from bitvector operations. Expects arguments to be 1 bit wide. *)
+let sym_ite_bits loc (b: sym) (x: sym) (y: sym) =
+  let w = Expr_LitInt "1" in
+  let b = sym_cvt_bool_bv loc b in
+  let nb = sym_not_bits loc w b in
+  sym_or_bits loc w (sym_and_bits loc w b x) (sym_and_bits loc w nb y)
 let sym_zero_extend num_zeros old_width e =
   match sym_append_bits Unknown num_zeros old_width (Val (val_zeros num_zeros)) e with
   | Val v -> Val v
@@ -932,6 +954,7 @@ let rec expr_access_chain (x: expr) (a: access_chain list): expr =
   | (SymIndex e)::a -> expr_access_chain (Expr_Array(x,e)) a
   | [] -> x)
 
+
 (****************************************************************)
 (** {2 Function and Expression Purity}                          *)
 (****************************************************************)
@@ -1042,3 +1065,60 @@ let rec is_pure e =
   | Expr_Field(e,_) -> is_pure e
   | Expr_Array(e,i) -> is_pure e && is_pure i
   | _ -> false
+
+
+(* Segment of a symbolic bitvector *)
+type segment
+  = SegmentBits of bitvector
+  | SegmentField of ident * int
+
+(* Symbolic bitvector *)
+type sym_bits = segment list
+
+let segment_expr_of_string (s: string) (bits: int option): segment =
+  if (String.starts_with ~prefix:"0x" s) then
+    let litbits = (String.length s - 2) * 4 in
+    let bits' = Option.value bits ~default:litbits in
+    SegmentBits (Primops.prim_cvt_int_bits (Z.of_int bits') (Z.of_string s))
+  else match bits with
+  | Some bits -> SegmentField ((Ident s), bits)
+  | None -> failwith ("variable segment must have a concrete width")
+
+let segment_of_string (s: string): segment =
+  match String.split_on_char ':' s with
+  | [expr; bits] ->
+    segment_expr_of_string expr (Some (int_of_string bits))
+  | [expr] ->
+    segment_expr_of_string expr None
+  | _ -> failwith ("invalid opcode segment")
+
+let sym_bits_of_string (s: string): sym_bits =
+  List.map segment_of_string (String.split_on_char '|' s)
+
+let sym_bits_of_bv (bv: Primops.bitvector): sym_bits =
+  [SegmentBits bv]
+
+let sym_of_segment (s: segment): sym =
+  match s with
+  | SegmentBits b -> Val (VBits b)
+  | SegmentField (f, w) -> Exp (Expr_Var f)
+
+let segment_width (s: segment): int =
+  match s with
+  | SegmentBits b -> b.n
+  | SegmentField (_, w) -> w
+  
+let sym_of_sym_bits (s: sym_bits): sym =
+  let segs = List.map (fun seg -> (sym_of_segment seg, segment_width seg)) s in
+  let init = (Val (VBits empty_bits), 0) in
+  let (s, _) = List.fold_left (fun (x, xw) (y, yw) -> (sym_append_bits Unknown xw yw x y, xw+yw)) init segs in
+  s
+
+let field_of_segment (s: segment): (ident * int) option =
+  match s with
+  | SegmentBits _ -> None
+  | SegmentField (f, w) -> Some (f, w)
+
+(* Extract the fields from a symbolic bitvector *)
+let fields_of_sym_bits (s: sym_bits): (ident * int) list =
+  List.filter_map field_of_segment s
diff --git a/libASL/testing.ml b/libASL/testing.ml
index 13d991e2..02f3b2a5 100644
--- a/libASL/testing.ml
+++ b/libASL/testing.ml
@@ -4,6 +4,7 @@ module Env = Eval.Env
 open AST
 open Value
 open Asl_utils
+open Symbolic
 
 (****************************************************************
  * Opcode decoding without evaluation.
diff --git a/libASL/transforms.ml b/libASL/transforms.ml
index faff8c41..a14ca5ff 100644
--- a/libASL/transforms.ml
+++ b/libASL/transforms.ml
@@ -1542,7 +1542,7 @@ module CommonSubExprElim = struct
     | Some t -> t
     | None -> raise (CSEError ("Can't infer type of strange expr: " ^ (pp_expr e)))
 
-  let insert_into_stmts (xs: stmt list) (x: stmt): (stmt list) =
+  let insert_into_stmts (xs: stmt list) (x: stmt) (predefined: IdentSet.t): (stmt list) =
     let rec move_after_stmts (head: stmt list) (tail: stmt list) (targets: IdentSet.t) (found: IdentSet.t) =
       if IdentSet.subset targets found then
         (head, tail)
@@ -1564,11 +1564,11 @@ module CommonSubExprElim = struct
         not (Str.string_match (Str.regexp "Cse") s 0)
       | _ -> false
     ) (fv_stmt x) in
-    let lists = move_after_stmts [] xs targets (IdentSet.empty) in
+    let lists = move_after_stmts [] xs targets predefined in
 
     (fst lists) @ [x] @ (snd lists)
 
-  let apply_knowledge (xs: stmt list) (knowledge: expr list) (repl): (stmt list) =
+  let apply_knowledge (xs: stmt list) (knowledge: expr list) (repl) (predefined: IdentSet.t): (stmt list) =
     let rec add_exprs_num (xs: stmt list) (k: expr list) (id: int) =
       match k with
       | [] -> xs
@@ -1580,7 +1580,7 @@ module CommonSubExprElim = struct
         let () = repl#add (Ident(new_var_name)) head in
         (* Do replacement in our remaining eliminate-able expressions
            to ensure that they will continue to match correctly *)
-        add_exprs_num (insert_into_stmts xs new_stmt) (visit_exprs repl tail) (id+1)
+        add_exprs_num (insert_into_stmts xs new_stmt predefined) (visit_exprs repl tail) (id+1)
     in
     add_exprs_num xs knowledge 0
 
@@ -1589,7 +1589,7 @@ module CommonSubExprElim = struct
       gain_info_pass xs knowledge (n+1)
     )
 
-  let do_transform (xs: stmt list): stmt list =
+  let do_transform (xs: stmt list) (predefined: IdentSet.t): stmt list =
     let const_visitor = new gather_consts in
     let _ = visit_stmts const_visitor xs in
 
@@ -1597,7 +1597,7 @@ module CommonSubExprElim = struct
     let expression_replacer = new replace_all_instances in
 
     let xs = visit_stmts expression_visitor xs in
-    let xs = apply_knowledge xs expression_visitor#get_info expression_replacer in
+    let xs = apply_knowledge xs expression_visitor#get_info expression_replacer predefined in
     let xs = visit_stmts expression_replacer xs in
     xs
 end
diff --git a/tests/aslt/test_cntlm.t b/tests/aslt/test_cntlm.t
index 733abf8a..2e79f6ae 100644
--- a/tests/aslt/test_cntlm.t
+++ b/tests/aslt/test_cntlm.t
@@ -42749,14 +42749,14 @@ strip opcode information before passing to antlr.
   Stmt_ConstDecl(Type_Bits(1),"ITESimp_0",Expr_Field(Expr_Var("PSTATE"),"Z"))
   Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"V"),Expr_TApply("and_bits.0",[1],[Expr_Var("ITESimp_0");Expr_TApply("not_bits.0",[1],[Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("eq_bits.0",[64],[Expr_TApply("SignExtend.0",[32;64],[Expr_Var("Cse0__5");64]);Expr_TApply("add_bits.0",[64],[Expr_TApply("SignExtend.0",[32;64],[Expr_Slices(Expr_Array(Expr_Var("_R"),0),[Slice_LoWd(0,32)]);64]);'0000000000000000000000000000000000000000000000000000000000000001'])])])])]))
   Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"C"),Expr_TApply("and_bits.0",[1],[Expr_Var("ITESimp_0");Expr_TApply("not_bits.0",[1],[Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("eq_bits.0",[64],[Expr_TApply("ZeroExtend.0",[32;64],[Expr_Var("Cse0__5");64]);Expr_TApply("add_bits.0",[64],[Expr_TApply("ZeroExtend.0",[32;64],[Expr_Slices(Expr_Array(Expr_Var("_R"),0),[Slice_LoWd(0,32)]);64]);'0000000000000000000000000000000000000000000000000000000000000001'])])])])]))
-  Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"Z"),Expr_TApply("or_bits.0",[1],[Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("eq_bits.0",[32],[Expr_Var("Cse0__5");'00000000000000000000000000000000'])]);Expr_TApply("not_bits.0",[1],[Expr_Var("ITESimp_0")])]))
+  Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"Z"),Expr_TApply("or_bits.0",[1],[Expr_TApply("and_bits.0",[1],[Expr_Var("ITESimp_0");Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("eq_bits.0",[32],[Expr_Var("Cse0__5");'00000000000000000000000000000000'])])]);Expr_TApply("not_bits.0",[1],[Expr_Var("ITESimp_0")])]))
   Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"N"),Expr_TApply("and_bits.0",[1],[Expr_Var("ITESimp_0");Expr_Slices(Expr_Var("Cse0__5"),[Slice_LoWd(31,1)])]))
   "0x3a410ac4"
   Stmt_ConstDecl(Type_Bits(32),"Cse0__5",Expr_TApply("add_bits.0",[32],[Expr_Slices(Expr_Array(Expr_Var("_R"),22),[Slice_LoWd(0,32)]);'00000000000000000000000000000001']))
   Stmt_ConstDecl(Type_Bits(1),"ITESimp_0",Expr_Field(Expr_Var("PSTATE"),"Z"))
   Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"V"),Expr_TApply("and_bits.0",[1],[Expr_Var("ITESimp_0");Expr_TApply("not_bits.0",[1],[Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("eq_bits.0",[64],[Expr_TApply("SignExtend.0",[32;64],[Expr_Var("Cse0__5");64]);Expr_TApply("add_bits.0",[64],[Expr_TApply("SignExtend.0",[32;64],[Expr_Slices(Expr_Array(Expr_Var("_R"),22),[Slice_LoWd(0,32)]);64]);'0000000000000000000000000000000000000000000000000000000000000001'])])])])]))
   Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"C"),Expr_TApply("and_bits.0",[1],[Expr_Var("ITESimp_0");Expr_TApply("not_bits.0",[1],[Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("eq_bits.0",[64],[Expr_TApply("ZeroExtend.0",[32;64],[Expr_Var("Cse0__5");64]);Expr_TApply("add_bits.0",[64],[Expr_TApply("ZeroExtend.0",[32;64],[Expr_Slices(Expr_Array(Expr_Var("_R"),22),[Slice_LoWd(0,32)]);64]);'0000000000000000000000000000000000000000000000000000000000000001'])])])])]))
-  Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"Z"),Expr_TApply("or_bits.0",[1],[Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("eq_bits.0",[32],[Expr_Var("Cse0__5");'00000000000000000000000000000000'])]);Expr_TApply("not_bits.0",[1],[Expr_Var("ITESimp_0")])]))
+  Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"Z"),Expr_TApply("or_bits.0",[1],[Expr_TApply("and_bits.0",[1],[Expr_Var("ITESimp_0");Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("eq_bits.0",[32],[Expr_Var("Cse0__5");'00000000000000000000000000000000'])])]);Expr_TApply("not_bits.0",[1],[Expr_Var("ITESimp_0")])]))
   Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"N"),Expr_TApply("and_bits.0",[1],[Expr_Var("ITESimp_0");Expr_Slices(Expr_Var("Cse0__5"),[Slice_LoWd(31,1)])]))
   "0x3a410b20"
   Stmt_ConstDecl(Type_Bits(32),"Cse0__5",Expr_TApply("add_bits.0",[32],[Expr_Slices(Expr_Array(Expr_Var("_R"),25),[Slice_LoWd(0,32)]);'00000000000000000000000000000001']))
@@ -42770,21 +42770,21 @@ strip opcode information before passing to antlr.
   Stmt_ConstDecl(Type_Bits(1),"ITESimp_0",Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("not_bool.0",[],[Expr_TApply("eq_bits.0",[1],[Expr_Field(Expr_Var("PSTATE"),"Z");'1'])])]))
   Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"V"),Expr_TApply("and_bits.0",[1],[Expr_Var("ITESimp_0");Expr_TApply("not_bits.0",[1],[Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("eq_bits.0",[64],[Expr_TApply("SignExtend.0",[32;64],[Expr_Var("Cse0__5");64]);Expr_TApply("add_bits.0",[64],[Expr_TApply("SignExtend.0",[32;64],[Expr_Slices(Expr_Array(Expr_Var("_R"),1),[Slice_LoWd(0,32)]);64]);'0000000000000000000000000000000000000000000000000000000000000001'])])])])]))
   Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"C"),Expr_TApply("and_bits.0",[1],[Expr_Var("ITESimp_0");Expr_TApply("not_bits.0",[1],[Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("eq_bits.0",[64],[Expr_TApply("ZeroExtend.0",[32;64],[Expr_Var("Cse0__5");64]);Expr_TApply("add_bits.0",[64],[Expr_TApply("ZeroExtend.0",[32;64],[Expr_Slices(Expr_Array(Expr_Var("_R"),1),[Slice_LoWd(0,32)]);64]);'0000000000000000000000000000000000000000000000000000000000000001'])])])])]))
-  Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"Z"),Expr_TApply("or_bits.0",[1],[Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("eq_bits.0",[32],[Expr_Var("Cse0__5");'00000000000000000000000000000000'])]);Expr_TApply("not_bits.0",[1],[Expr_Var("ITESimp_0")])]))
+  Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"Z"),Expr_TApply("or_bits.0",[1],[Expr_TApply("and_bits.0",[1],[Expr_Var("ITESimp_0");Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("eq_bits.0",[32],[Expr_Var("Cse0__5");'00000000000000000000000000000000'])])]);Expr_TApply("not_bits.0",[1],[Expr_Var("ITESimp_0")])]))
   Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"N"),Expr_TApply("and_bits.0",[1],[Expr_Var("ITESimp_0");Expr_Slices(Expr_Var("Cse0__5"),[Slice_LoWd(31,1)])]))
   "0x3a411aa4"
   Stmt_ConstDecl(Type_Bits(32),"Cse0__5",Expr_TApply("add_bits.0",[32],[Expr_Slices(Expr_Array(Expr_Var("_R"),21),[Slice_LoWd(0,32)]);'00000000000000000000000000000001']))
   Stmt_ConstDecl(Type_Bits(1),"ITESimp_0",Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("not_bool.0",[],[Expr_TApply("eq_bits.0",[1],[Expr_Field(Expr_Var("PSTATE"),"Z");'1'])])]))
   Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"V"),Expr_TApply("and_bits.0",[1],[Expr_Var("ITESimp_0");Expr_TApply("not_bits.0",[1],[Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("eq_bits.0",[64],[Expr_TApply("SignExtend.0",[32;64],[Expr_Var("Cse0__5");64]);Expr_TApply("add_bits.0",[64],[Expr_TApply("SignExtend.0",[32;64],[Expr_Slices(Expr_Array(Expr_Var("_R"),21),[Slice_LoWd(0,32)]);64]);'0000000000000000000000000000000000000000000000000000000000000001'])])])])]))
   Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"C"),Expr_TApply("and_bits.0",[1],[Expr_Var("ITESimp_0");Expr_TApply("not_bits.0",[1],[Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("eq_bits.0",[64],[Expr_TApply("ZeroExtend.0",[32;64],[Expr_Var("Cse0__5");64]);Expr_TApply("add_bits.0",[64],[Expr_TApply("ZeroExtend.0",[32;64],[Expr_Slices(Expr_Array(Expr_Var("_R"),21),[Slice_LoWd(0,32)]);64]);'0000000000000000000000000000000000000000000000000000000000000001'])])])])]))
-  Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"Z"),Expr_TApply("or_bits.0",[1],[Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("eq_bits.0",[32],[Expr_Var("Cse0__5");'00000000000000000000000000000000'])]);Expr_TApply("not_bits.0",[1],[Expr_Var("ITESimp_0")])]))
+  Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"Z"),Expr_TApply("or_bits.0",[1],[Expr_TApply("and_bits.0",[1],[Expr_Var("ITESimp_0");Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("eq_bits.0",[32],[Expr_Var("Cse0__5");'00000000000000000000000000000000'])])]);Expr_TApply("not_bits.0",[1],[Expr_Var("ITESimp_0")])]))
   Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"N"),Expr_TApply("and_bits.0",[1],[Expr_Var("ITESimp_0");Expr_Slices(Expr_Var("Cse0__5"),[Slice_LoWd(31,1)])]))
   "0x3a411ac4"
   Stmt_ConstDecl(Type_Bits(32),"Cse0__5",Expr_TApply("add_bits.0",[32],[Expr_Slices(Expr_Array(Expr_Var("_R"),22),[Slice_LoWd(0,32)]);'00000000000000000000000000000001']))
   Stmt_ConstDecl(Type_Bits(1),"ITESimp_0",Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("not_bool.0",[],[Expr_TApply("eq_bits.0",[1],[Expr_Field(Expr_Var("PSTATE"),"Z");'1'])])]))
   Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"V"),Expr_TApply("and_bits.0",[1],[Expr_Var("ITESimp_0");Expr_TApply("not_bits.0",[1],[Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("eq_bits.0",[64],[Expr_TApply("SignExtend.0",[32;64],[Expr_Var("Cse0__5");64]);Expr_TApply("add_bits.0",[64],[Expr_TApply("SignExtend.0",[32;64],[Expr_Slices(Expr_Array(Expr_Var("_R"),22),[Slice_LoWd(0,32)]);64]);'0000000000000000000000000000000000000000000000000000000000000001'])])])])]))
   Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"C"),Expr_TApply("and_bits.0",[1],[Expr_Var("ITESimp_0");Expr_TApply("not_bits.0",[1],[Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("eq_bits.0",[64],[Expr_TApply("ZeroExtend.0",[32;64],[Expr_Var("Cse0__5");64]);Expr_TApply("add_bits.0",[64],[Expr_TApply("ZeroExtend.0",[32;64],[Expr_Slices(Expr_Array(Expr_Var("_R"),22),[Slice_LoWd(0,32)]);64]);'0000000000000000000000000000000000000000000000000000000000000001'])])])])]))
-  Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"Z"),Expr_TApply("or_bits.0",[1],[Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("eq_bits.0",[32],[Expr_Var("Cse0__5");'00000000000000000000000000000000'])]);Expr_TApply("not_bits.0",[1],[Expr_Var("ITESimp_0")])]))
+  Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"Z"),Expr_TApply("or_bits.0",[1],[Expr_TApply("and_bits.0",[1],[Expr_Var("ITESimp_0");Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("eq_bits.0",[32],[Expr_Var("Cse0__5");'00000000000000000000000000000000'])])]);Expr_TApply("not_bits.0",[1],[Expr_Var("ITESimp_0")])]))
   Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"N"),Expr_TApply("and_bits.0",[1],[Expr_Var("ITESimp_0");Expr_Slices(Expr_Var("Cse0__5"),[Slice_LoWd(31,1)])]))
   "0x3c206820"
   Stmt_TCall("Mem.set.0",[1],[Expr_TApply("add_bits.0",[64],[Expr_Array(Expr_Var("_R"),1);Expr_Array(Expr_Var("_R"),0)]);1;1;Expr_Slices(Expr_Array(Expr_Var("_Z"),0),[Slice_LoWd(0,8)])])
@@ -86635,25 +86635,25 @@ strip opcode information before passing to antlr.
   Stmt_ConstDecl(Type_Bits(1),"ITESimp_0",Expr_Field(Expr_Var("PSTATE"),"Z"))
   Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"V"),'0')
   Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"C"),Expr_Var("ITESimp_0"))
-  Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"Z"),Expr_TApply("or_bits.0",[1],[Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("eq_bits.0",[32],[Expr_Slices(Expr_Array(Expr_Var("_R"),0),[Slice_LoWd(0,32)]);'00000000000000000000000000000000'])]);Expr_TApply("not_bits.0",[1],[Expr_Var("ITESimp_0")])]))
+  Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"Z"),Expr_TApply("or_bits.0",[1],[Expr_TApply("and_bits.0",[1],[Expr_Var("ITESimp_0");Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("eq_bits.0",[32],[Expr_Slices(Expr_Array(Expr_Var("_R"),0),[Slice_LoWd(0,32)]);'00000000000000000000000000000000'])])]);Expr_TApply("not_bits.0",[1],[Expr_Var("ITESimp_0")])]))
   Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"N"),Expr_TApply("and_bits.0",[1],[Expr_Var("ITESimp_0");Expr_Slices(Expr_Array(Expr_Var("_R"),0),[Slice_LoWd(31,1)])]))
   "0x7a400824"
   Stmt_ConstDecl(Type_Bits(1),"ITESimp_0",Expr_Field(Expr_Var("PSTATE"),"Z"))
   Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"V"),'0')
   Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"C"),Expr_Var("ITESimp_0"))
-  Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"Z"),Expr_TApply("or_bits.0",[1],[Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("eq_bits.0",[32],[Expr_Slices(Expr_Array(Expr_Var("_R"),1),[Slice_LoWd(0,32)]);'00000000000000000000000000000000'])]);Expr_TApply("not_bits.0",[1],[Expr_Var("ITESimp_0")])]))
+  Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"Z"),Expr_TApply("or_bits.0",[1],[Expr_TApply("and_bits.0",[1],[Expr_Var("ITESimp_0");Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("eq_bits.0",[32],[Expr_Slices(Expr_Array(Expr_Var("_R"),1),[Slice_LoWd(0,32)]);'00000000000000000000000000000000'])])]);Expr_TApply("not_bits.0",[1],[Expr_Var("ITESimp_0")])]))
   Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"N"),Expr_TApply("and_bits.0",[1],[Expr_Var("ITESimp_0");Expr_Slices(Expr_Array(Expr_Var("_R"),1),[Slice_LoWd(31,1)])]))
   "0x7a400844"
   Stmt_ConstDecl(Type_Bits(1),"ITESimp_0",Expr_Field(Expr_Var("PSTATE"),"Z"))
   Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"V"),'0')
   Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"C"),Expr_Var("ITESimp_0"))
-  Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"Z"),Expr_TApply("or_bits.0",[1],[Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("eq_bits.0",[32],[Expr_Slices(Expr_Array(Expr_Var("_R"),2),[Slice_LoWd(0,32)]);'00000000000000000000000000000000'])]);Expr_TApply("not_bits.0",[1],[Expr_Var("ITESimp_0")])]))
+  Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"Z"),Expr_TApply("or_bits.0",[1],[Expr_TApply("and_bits.0",[1],[Expr_Var("ITESimp_0");Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("eq_bits.0",[32],[Expr_Slices(Expr_Array(Expr_Var("_R"),2),[Slice_LoWd(0,32)]);'00000000000000000000000000000000'])])]);Expr_TApply("not_bits.0",[1],[Expr_Var("ITESimp_0")])]))
   Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"N"),Expr_TApply("and_bits.0",[1],[Expr_Var("ITESimp_0");Expr_Slices(Expr_Array(Expr_Var("_R"),2),[Slice_LoWd(31,1)])]))
   "0x7a400884"
   Stmt_ConstDecl(Type_Bits(1),"ITESimp_0",Expr_Field(Expr_Var("PSTATE"),"Z"))
   Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"V"),'0')
   Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"C"),Expr_Var("ITESimp_0"))
-  Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"Z"),Expr_TApply("or_bits.0",[1],[Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("eq_bits.0",[32],[Expr_Slices(Expr_Array(Expr_Var("_R"),4),[Slice_LoWd(0,32)]);'00000000000000000000000000000000'])]);Expr_TApply("not_bits.0",[1],[Expr_Var("ITESimp_0")])]))
+  Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"Z"),Expr_TApply("or_bits.0",[1],[Expr_TApply("and_bits.0",[1],[Expr_Var("ITESimp_0");Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("eq_bits.0",[32],[Expr_Slices(Expr_Array(Expr_Var("_R"),4),[Slice_LoWd(0,32)]);'00000000000000000000000000000000'])])]);Expr_TApply("not_bits.0",[1],[Expr_Var("ITESimp_0")])]))
   Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"N"),Expr_TApply("and_bits.0",[1],[Expr_Var("ITESimp_0");Expr_Slices(Expr_Array(Expr_Var("_R"),4),[Slice_LoWd(31,1)])]))
   "0x7a400a80"
   Stmt_ConstDecl(Type_Bits(1),"ITESimp_0",Expr_Field(Expr_Var("PSTATE"),"Z"))
@@ -86671,7 +86671,7 @@ strip opcode information before passing to antlr.
   Stmt_ConstDecl(Type_Bits(1),"ITESimp_0",Expr_Field(Expr_Var("PSTATE"),"Z"))
   Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"V"),'0')
   Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"C"),Expr_Var("ITESimp_0"))
-  Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"Z"),Expr_TApply("or_bits.0",[1],[Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("eq_bits.0",[32],[Expr_Slices(Expr_Array(Expr_Var("_R"),23),[Slice_LoWd(0,32)]);'00000000000000000000000000000000'])]);Expr_TApply("not_bits.0",[1],[Expr_Var("ITESimp_0")])]))
+  Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"Z"),Expr_TApply("or_bits.0",[1],[Expr_TApply("and_bits.0",[1],[Expr_Var("ITESimp_0");Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("eq_bits.0",[32],[Expr_Slices(Expr_Array(Expr_Var("_R"),23),[Slice_LoWd(0,32)]);'00000000000000000000000000000000'])])]);Expr_TApply("not_bits.0",[1],[Expr_Var("ITESimp_0")])]))
   Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"N"),Expr_TApply("and_bits.0",[1],[Expr_Var("ITESimp_0");Expr_Slices(Expr_Array(Expr_Var("_R"),23),[Slice_LoWd(31,1)])]))
   "0x7a401024"
   Stmt_ConstDecl(Type_Bits(32),"Cse2__5",Expr_TApply("not_bits.0",[32],[Expr_Slices(Expr_Array(Expr_Var("_R"),0),[Slice_LoWd(0,32)])]))
@@ -86679,7 +86679,7 @@ strip opcode information before passing to antlr.
   Stmt_ConstDecl(Type_Bits(1),"ITESimp_0",Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("not_bool.0",[],[Expr_TApply("eq_bits.0",[1],[Expr_Field(Expr_Var("PSTATE"),"Z");'1'])])]))
   Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"V"),Expr_TApply("and_bits.0",[1],[Expr_Var("ITESimp_0");Expr_TApply("not_bits.0",[1],[Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("eq_bits.0",[64],[Expr_TApply("SignExtend.0",[32;64],[Expr_TApply("add_bits.0",[32],[Expr_Var("Cse0__5");'00000000000000000000000000000001']);64]);Expr_TApply("add_bits.0",[64],[Expr_TApply("add_bits.0",[64],[Expr_TApply("SignExtend.0",[32;64],[Expr_Slices(Expr_Array(Expr_Var("_R"),1),[Slice_LoWd(0,32)]);64]);Expr_TApply("SignExtend.0",[32;64],[Expr_Var("Cse2__5");64])]);'0000000000000000000000000000000000000000000000000000000000000001'])])])])]))
   Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"C"),Expr_TApply("and_bits.0",[1],[Expr_Var("ITESimp_0");Expr_TApply("not_bits.0",[1],[Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("eq_bits.0",[64],[Expr_TApply("ZeroExtend.0",[32;64],[Expr_TApply("add_bits.0",[32],[Expr_Var("Cse0__5");'00000000000000000000000000000001']);64]);Expr_TApply("add_bits.0",[64],[Expr_TApply("add_bits.0",[64],[Expr_TApply("ZeroExtend.0",[32;64],[Expr_Slices(Expr_Array(Expr_Var("_R"),1),[Slice_LoWd(0,32)]);64]);Expr_TApply("ZeroExtend.0",[32;64],[Expr_Var("Cse2__5");64])]);'0000000000000000000000000000000000000000000000000000000000000001'])])])])]))
-  Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"Z"),Expr_TApply("or_bits.0",[1],[Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("eq_bits.0",[32],[Expr_TApply("add_bits.0",[32],[Expr_Var("Cse0__5");'00000000000000000000000000000001']);'00000000000000000000000000000000'])]);Expr_TApply("not_bits.0",[1],[Expr_Var("ITESimp_0")])]))
+  Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"Z"),Expr_TApply("or_bits.0",[1],[Expr_TApply("and_bits.0",[1],[Expr_Var("ITESimp_0");Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("eq_bits.0",[32],[Expr_TApply("add_bits.0",[32],[Expr_Var("Cse0__5");'00000000000000000000000000000001']);'00000000000000000000000000000000'])])]);Expr_TApply("not_bits.0",[1],[Expr_Var("ITESimp_0")])]))
   Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"N"),Expr_TApply("and_bits.0",[1],[Expr_Var("ITESimp_0");Expr_Slices(Expr_TApply("add_bits.0",[32],[Expr_Var("Cse0__5");'00000000000000000000000000000001']),[Slice_LoWd(31,1)])]))
   "0x7a401800"
   Stmt_ConstDecl(Type_Bits(1),"ITESimp_0",Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("not_bool.0",[],[Expr_TApply("eq_bits.0",[1],[Expr_Field(Expr_Var("PSTATE"),"Z");'1'])])]))
@@ -86691,13 +86691,13 @@ strip opcode information before passing to antlr.
   Stmt_ConstDecl(Type_Bits(1),"ITESimp_0",Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("not_bool.0",[],[Expr_TApply("eq_bits.0",[1],[Expr_Field(Expr_Var("PSTATE"),"Z");'1'])])]))
   Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"V"),'0')
   Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"C"),Expr_Var("ITESimp_0"))
-  Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"Z"),Expr_TApply("or_bits.0",[1],[Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("eq_bits.0",[32],[Expr_Slices(Expr_Array(Expr_Var("_R"),0),[Slice_LoWd(0,32)]);'00000000000000000000000000000000'])]);Expr_TApply("not_bits.0",[1],[Expr_Var("ITESimp_0")])]))
+  Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"Z"),Expr_TApply("or_bits.0",[1],[Expr_TApply("and_bits.0",[1],[Expr_Var("ITESimp_0");Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("eq_bits.0",[32],[Expr_Slices(Expr_Array(Expr_Var("_R"),0),[Slice_LoWd(0,32)]);'00000000000000000000000000000000'])])]);Expr_TApply("not_bits.0",[1],[Expr_Var("ITESimp_0")])]))
   Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"N"),Expr_TApply("and_bits.0",[1],[Expr_Var("ITESimp_0");Expr_Slices(Expr_Array(Expr_Var("_R"),0),[Slice_LoWd(31,1)])]))
   "0x7a401824"
   Stmt_ConstDecl(Type_Bits(1),"ITESimp_0",Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("not_bool.0",[],[Expr_TApply("eq_bits.0",[1],[Expr_Field(Expr_Var("PSTATE"),"Z");'1'])])]))
   Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"V"),'0')
   Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"C"),Expr_Var("ITESimp_0"))
-  Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"Z"),Expr_TApply("or_bits.0",[1],[Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("eq_bits.0",[32],[Expr_Slices(Expr_Array(Expr_Var("_R"),1),[Slice_LoWd(0,32)]);'00000000000000000000000000000000'])]);Expr_TApply("not_bits.0",[1],[Expr_Var("ITESimp_0")])]))
+  Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"Z"),Expr_TApply("or_bits.0",[1],[Expr_TApply("and_bits.0",[1],[Expr_Var("ITESimp_0");Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("eq_bits.0",[32],[Expr_Slices(Expr_Array(Expr_Var("_R"),1),[Slice_LoWd(0,32)]);'00000000000000000000000000000000'])])]);Expr_TApply("not_bits.0",[1],[Expr_Var("ITESimp_0")])]))
   Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"N"),Expr_TApply("and_bits.0",[1],[Expr_Var("ITESimp_0");Expr_Slices(Expr_Array(Expr_Var("_R"),1),[Slice_LoWd(31,1)])]))
   "0x7a401840"
   Stmt_ConstDecl(Type_Bits(1),"ITESimp_0",Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("not_bool.0",[],[Expr_TApply("eq_bits.0",[1],[Expr_Field(Expr_Var("PSTATE"),"Z");'1'])])]))
@@ -86709,31 +86709,31 @@ strip opcode information before passing to antlr.
   Stmt_ConstDecl(Type_Bits(1),"ITESimp_0",Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("not_bool.0",[],[Expr_TApply("eq_bits.0",[1],[Expr_Field(Expr_Var("PSTATE"),"Z");'1'])])]))
   Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"V"),'0')
   Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"C"),Expr_Var("ITESimp_0"))
-  Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"Z"),Expr_TApply("or_bits.0",[1],[Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("eq_bits.0",[32],[Expr_Slices(Expr_Array(Expr_Var("_R"),2),[Slice_LoWd(0,32)]);'00000000000000000000000000000000'])]);Expr_TApply("not_bits.0",[1],[Expr_Var("ITESimp_0")])]))
+  Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"Z"),Expr_TApply("or_bits.0",[1],[Expr_TApply("and_bits.0",[1],[Expr_Var("ITESimp_0");Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("eq_bits.0",[32],[Expr_Slices(Expr_Array(Expr_Var("_R"),2),[Slice_LoWd(0,32)]);'00000000000000000000000000000000'])])]);Expr_TApply("not_bits.0",[1],[Expr_Var("ITESimp_0")])]))
   Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"N"),Expr_TApply("and_bits.0",[1],[Expr_Var("ITESimp_0");Expr_Slices(Expr_Array(Expr_Var("_R"),2),[Slice_LoWd(31,1)])]))
   "0x7a401864"
   Stmt_ConstDecl(Type_Bits(1),"ITESimp_0",Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("not_bool.0",[],[Expr_TApply("eq_bits.0",[1],[Expr_Field(Expr_Var("PSTATE"),"Z");'1'])])]))
   Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"V"),'0')
   Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"C"),Expr_Var("ITESimp_0"))
-  Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"Z"),Expr_TApply("or_bits.0",[1],[Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("eq_bits.0",[32],[Expr_Slices(Expr_Array(Expr_Var("_R"),3),[Slice_LoWd(0,32)]);'00000000000000000000000000000000'])]);Expr_TApply("not_bits.0",[1],[Expr_Var("ITESimp_0")])]))
+  Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"Z"),Expr_TApply("or_bits.0",[1],[Expr_TApply("and_bits.0",[1],[Expr_Var("ITESimp_0");Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("eq_bits.0",[32],[Expr_Slices(Expr_Array(Expr_Var("_R"),3),[Slice_LoWd(0,32)]);'00000000000000000000000000000000'])])]);Expr_TApply("not_bits.0",[1],[Expr_Var("ITESimp_0")])]))
   Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"N"),Expr_TApply("and_bits.0",[1],[Expr_Var("ITESimp_0");Expr_Slices(Expr_Array(Expr_Var("_R"),3),[Slice_LoWd(31,1)])]))
   "0x7a401884"
   Stmt_ConstDecl(Type_Bits(1),"ITESimp_0",Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("not_bool.0",[],[Expr_TApply("eq_bits.0",[1],[Expr_Field(Expr_Var("PSTATE"),"Z");'1'])])]))
   Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"V"),'0')
   Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"C"),Expr_Var("ITESimp_0"))
-  Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"Z"),Expr_TApply("or_bits.0",[1],[Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("eq_bits.0",[32],[Expr_Slices(Expr_Array(Expr_Var("_R"),4),[Slice_LoWd(0,32)]);'00000000000000000000000000000000'])]);Expr_TApply("not_bits.0",[1],[Expr_Var("ITESimp_0")])]))
+  Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"Z"),Expr_TApply("or_bits.0",[1],[Expr_TApply("and_bits.0",[1],[Expr_Var("ITESimp_0");Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("eq_bits.0",[32],[Expr_Slices(Expr_Array(Expr_Var("_R"),4),[Slice_LoWd(0,32)]);'00000000000000000000000000000000'])])]);Expr_TApply("not_bits.0",[1],[Expr_Var("ITESimp_0")])]))
   Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"N"),Expr_TApply("and_bits.0",[1],[Expr_Var("ITESimp_0");Expr_Slices(Expr_Array(Expr_Var("_R"),4),[Slice_LoWd(31,1)])]))
   "0x7a401a64"
   Stmt_ConstDecl(Type_Bits(1),"ITESimp_0",Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("not_bool.0",[],[Expr_TApply("eq_bits.0",[1],[Expr_Field(Expr_Var("PSTATE"),"Z");'1'])])]))
   Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"V"),'0')
   Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"C"),Expr_Var("ITESimp_0"))
-  Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"Z"),Expr_TApply("or_bits.0",[1],[Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("eq_bits.0",[32],[Expr_Slices(Expr_Array(Expr_Var("_R"),19),[Slice_LoWd(0,32)]);'00000000000000000000000000000000'])]);Expr_TApply("not_bits.0",[1],[Expr_Var("ITESimp_0")])]))
+  Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"Z"),Expr_TApply("or_bits.0",[1],[Expr_TApply("and_bits.0",[1],[Expr_Var("ITESimp_0");Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("eq_bits.0",[32],[Expr_Slices(Expr_Array(Expr_Var("_R"),19),[Slice_LoWd(0,32)]);'00000000000000000000000000000000'])])]);Expr_TApply("not_bits.0",[1],[Expr_Var("ITESimp_0")])]))
   Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"N"),Expr_TApply("and_bits.0",[1],[Expr_Var("ITESimp_0");Expr_Slices(Expr_Array(Expr_Var("_R"),19),[Slice_LoWd(31,1)])]))
   "0x7a401a84"
   Stmt_ConstDecl(Type_Bits(1),"ITESimp_0",Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("not_bool.0",[],[Expr_TApply("eq_bits.0",[1],[Expr_Field(Expr_Var("PSTATE"),"Z");'1'])])]))
   Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"V"),'0')
   Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"C"),Expr_Var("ITESimp_0"))
-  Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"Z"),Expr_TApply("or_bits.0",[1],[Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("eq_bits.0",[32],[Expr_Slices(Expr_Array(Expr_Var("_R"),20),[Slice_LoWd(0,32)]);'00000000000000000000000000000000'])]);Expr_TApply("not_bits.0",[1],[Expr_Var("ITESimp_0")])]))
+  Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"Z"),Expr_TApply("or_bits.0",[1],[Expr_TApply("and_bits.0",[1],[Expr_Var("ITESimp_0");Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("eq_bits.0",[32],[Expr_Slices(Expr_Array(Expr_Var("_R"),20),[Slice_LoWd(0,32)]);'00000000000000000000000000000000'])])]);Expr_TApply("not_bits.0",[1],[Expr_Var("ITESimp_0")])]))
   Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"N"),Expr_TApply("and_bits.0",[1],[Expr_Var("ITESimp_0");Expr_Slices(Expr_Array(Expr_Var("_R"),20),[Slice_LoWd(31,1)])]))
   "0x7a401ac1"
   Stmt_ConstDecl(Type_Bits(1),"ITESimp_0",Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("not_bool.0",[],[Expr_TApply("eq_bits.0",[1],[Expr_Field(Expr_Var("PSTATE"),"Z");'1'])])]))
@@ -86745,14 +86745,14 @@ strip opcode information before passing to antlr.
   Stmt_ConstDecl(Type_Bits(1),"ITESimp_0",Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("not_bool.0",[],[Expr_TApply("eq_bits.0",[1],[Expr_Field(Expr_Var("PSTATE"),"Z");'1'])])]))
   Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"V"),'0')
   Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"C"),Expr_Var("ITESimp_0"))
-  Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"Z"),Expr_TApply("or_bits.0",[1],[Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("eq_bits.0",[32],[Expr_Slices(Expr_Array(Expr_Var("_R"),23),[Slice_LoWd(0,32)]);'00000000000000000000000000000000'])]);Expr_TApply("not_bits.0",[1],[Expr_Var("ITESimp_0")])]))
+  Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"Z"),Expr_TApply("or_bits.0",[1],[Expr_TApply("and_bits.0",[1],[Expr_Var("ITESimp_0");Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("eq_bits.0",[32],[Expr_Slices(Expr_Array(Expr_Var("_R"),23),[Slice_LoWd(0,32)]);'00000000000000000000000000000000'])])]);Expr_TApply("not_bits.0",[1],[Expr_Var("ITESimp_0")])]))
   Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"N"),Expr_TApply("and_bits.0",[1],[Expr_Var("ITESimp_0");Expr_Slices(Expr_Array(Expr_Var("_R"),23),[Slice_LoWd(31,1)])]))
   "0x7a402062"
   Stmt_ConstDecl(Type_Bits(32),"Cse2__5",Expr_TApply("not_bits.0",[32],[Expr_Slices(Expr_Array(Expr_Var("_R"),0),[Slice_LoWd(0,32)])]))
   Stmt_ConstDecl(Type_Bits(32),"Cse0__5",Expr_TApply("add_bits.0",[32],[Expr_Slices(Expr_Array(Expr_Var("_R"),3),[Slice_LoWd(0,32)]);Expr_TApply("not_bits.0",[32],[Expr_Slices(Expr_Array(Expr_Var("_R"),0),[Slice_LoWd(0,32)])])]))
   Stmt_ConstDecl(Type_Bits(1),"ITESimp_0",Expr_Field(Expr_Var("PSTATE"),"C"))
   Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"V"),Expr_TApply("and_bits.0",[1],[Expr_Var("ITESimp_0");Expr_TApply("not_bits.0",[1],[Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("eq_bits.0",[64],[Expr_TApply("SignExtend.0",[32;64],[Expr_TApply("add_bits.0",[32],[Expr_Var("Cse0__5");'00000000000000000000000000000001']);64]);Expr_TApply("add_bits.0",[64],[Expr_TApply("add_bits.0",[64],[Expr_TApply("SignExtend.0",[32;64],[Expr_Slices(Expr_Array(Expr_Var("_R"),3),[Slice_LoWd(0,32)]);64]);Expr_TApply("SignExtend.0",[32;64],[Expr_Var("Cse2__5");64])]);'0000000000000000000000000000000000000000000000000000000000000001'])])])])]))
-  Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"C"),Expr_TApply("or_bits.0",[1],[Expr_TApply("not_bits.0",[1],[Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("eq_bits.0",[64],[Expr_TApply("ZeroExtend.0",[32;64],[Expr_TApply("add_bits.0",[32],[Expr_Var("Cse0__5");'00000000000000000000000000000001']);64]);Expr_TApply("add_bits.0",[64],[Expr_TApply("add_bits.0",[64],[Expr_TApply("ZeroExtend.0",[32;64],[Expr_Slices(Expr_Array(Expr_Var("_R"),3),[Slice_LoWd(0,32)]);64]);Expr_TApply("ZeroExtend.0",[32;64],[Expr_Var("Cse2__5");64])]);'0000000000000000000000000000000000000000000000000000000000000001'])])])]);Expr_TApply("not_bits.0",[1],[Expr_Var("ITESimp_0")])]))
+  Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"C"),Expr_TApply("or_bits.0",[1],[Expr_TApply("and_bits.0",[1],[Expr_Var("ITESimp_0");Expr_TApply("not_bits.0",[1],[Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("eq_bits.0",[64],[Expr_TApply("ZeroExtend.0",[32;64],[Expr_TApply("add_bits.0",[32],[Expr_Var("Cse0__5");'00000000000000000000000000000001']);64]);Expr_TApply("add_bits.0",[64],[Expr_TApply("add_bits.0",[64],[Expr_TApply("ZeroExtend.0",[32;64],[Expr_Slices(Expr_Array(Expr_Var("_R"),3),[Slice_LoWd(0,32)]);64]);Expr_TApply("ZeroExtend.0",[32;64],[Expr_Var("Cse2__5");64])]);'0000000000000000000000000000000000000000000000000000000000000001'])])])])]);Expr_TApply("not_bits.0",[1],[Expr_Var("ITESimp_0")])]))
   Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"Z"),Expr_TApply("and_bits.0",[1],[Expr_Var("ITESimp_0");Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("eq_bits.0",[32],[Expr_TApply("add_bits.0",[32],[Expr_Var("Cse0__5");'00000000000000000000000000000001']);'00000000000000000000000000000000'])])]))
   Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"N"),Expr_TApply("and_bits.0",[1],[Expr_Var("ITESimp_0");Expr_Slices(Expr_TApply("add_bits.0",[32],[Expr_Var("Cse0__5");'00000000000000000000000000000001']),[Slice_LoWd(31,1)])]))
   "0x7a408044"
@@ -86761,7 +86761,7 @@ strip opcode information before passing to antlr.
   Stmt_ConstDecl(Type_Bits(1),"ITESimp_0",Expr_TApply("and_bits.0",[1],[Expr_Field(Expr_Var("PSTATE"),"C");Expr_TApply("not_bits.0",[1],[Expr_Field(Expr_Var("PSTATE"),"Z")])]))
   Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"V"),Expr_TApply("and_bits.0",[1],[Expr_Var("ITESimp_0");Expr_TApply("not_bits.0",[1],[Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("eq_bits.0",[64],[Expr_TApply("SignExtend.0",[32;64],[Expr_TApply("add_bits.0",[32],[Expr_Var("Cse0__5");'00000000000000000000000000000001']);64]);Expr_TApply("add_bits.0",[64],[Expr_TApply("add_bits.0",[64],[Expr_TApply("SignExtend.0",[32;64],[Expr_Slices(Expr_Array(Expr_Var("_R"),2),[Slice_LoWd(0,32)]);64]);Expr_TApply("SignExtend.0",[32;64],[Expr_Var("Cse2__5");64])]);'0000000000000000000000000000000000000000000000000000000000000001'])])])])]))
   Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"C"),Expr_TApply("and_bits.0",[1],[Expr_Var("ITESimp_0");Expr_TApply("not_bits.0",[1],[Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("eq_bits.0",[64],[Expr_TApply("ZeroExtend.0",[32;64],[Expr_TApply("add_bits.0",[32],[Expr_Var("Cse0__5");'00000000000000000000000000000001']);64]);Expr_TApply("add_bits.0",[64],[Expr_TApply("add_bits.0",[64],[Expr_TApply("ZeroExtend.0",[32;64],[Expr_Slices(Expr_Array(Expr_Var("_R"),2),[Slice_LoWd(0,32)]);64]);Expr_TApply("ZeroExtend.0",[32;64],[Expr_Var("Cse2__5");64])]);'0000000000000000000000000000000000000000000000000000000000000001'])])])])]))
-  Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"Z"),Expr_TApply("or_bits.0",[1],[Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("eq_bits.0",[32],[Expr_TApply("add_bits.0",[32],[Expr_Var("Cse0__5");'00000000000000000000000000000001']);'00000000000000000000000000000000'])]);Expr_TApply("not_bits.0",[1],[Expr_Var("ITESimp_0")])]))
+  Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"Z"),Expr_TApply("or_bits.0",[1],[Expr_TApply("and_bits.0",[1],[Expr_Var("ITESimp_0");Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("eq_bits.0",[32],[Expr_TApply("add_bits.0",[32],[Expr_Var("Cse0__5");'00000000000000000000000000000001']);'00000000000000000000000000000000'])])]);Expr_TApply("not_bits.0",[1],[Expr_Var("ITESimp_0")])]))
   Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"N"),Expr_TApply("and_bits.0",[1],[Expr_Var("ITESimp_0");Expr_Slices(Expr_TApply("add_bits.0",[32],[Expr_Var("Cse0__5");'00000000000000000000000000000001']),[Slice_LoWd(31,1)])]))
   "0x7a409020"
   Stmt_ConstDecl(Type_Bits(32),"Cse2__5",Expr_TApply("not_bits.0",[32],[Expr_Slices(Expr_Array(Expr_Var("_R"),0),[Slice_LoWd(0,32)])]))
@@ -86783,7 +86783,7 @@ strip opcode information before passing to antlr.
   Stmt_ConstDecl(Type_Bits(1),"ITESimp_0",Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("not_bool.0",[],[Expr_TApply("and_bool.0",[],[Expr_TApply("eq_bits.0",[1],[Expr_Field(Expr_Var("PSTATE"),"C");'1']);Expr_TApply("eq_bits.0",[1],[Expr_Field(Expr_Var("PSTATE"),"Z");'0'])])])]))
   Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"V"),'0')
   Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"C"),Expr_Var("ITESimp_0"))
-  Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"Z"),Expr_TApply("or_bits.0",[1],[Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("eq_bits.0",[32],[Expr_Slices(Expr_Array(Expr_Var("_R"),21),[Slice_LoWd(0,32)]);'00000000000000000000000000000000'])]);Expr_TApply("not_bits.0",[1],[Expr_Var("ITESimp_0")])]))
+  Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"Z"),Expr_TApply("or_bits.0",[1],[Expr_TApply("and_bits.0",[1],[Expr_Var("ITESimp_0");Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("eq_bits.0",[32],[Expr_Slices(Expr_Array(Expr_Var("_R"),21),[Slice_LoWd(0,32)]);'00000000000000000000000000000000'])])]);Expr_TApply("not_bits.0",[1],[Expr_Var("ITESimp_0")])]))
   Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"N"),Expr_TApply("and_bits.0",[1],[Expr_Var("ITESimp_0");Expr_Slices(Expr_Array(Expr_Var("_R"),21),[Slice_LoWd(31,1)])]))
   "0x7a40a020"
   Stmt_ConstDecl(Type_Bits(32),"Cse2__5",Expr_TApply("not_bits.0",[32],[Expr_Slices(Expr_Array(Expr_Var("_R"),0),[Slice_LoWd(0,32)])]))
@@ -86805,13 +86805,13 @@ strip opcode information before passing to antlr.
   Stmt_ConstDecl(Type_Bits(1),"ITESimp_0",Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("eq_bits.0",[1],[Expr_Field(Expr_Var("PSTATE"),"N");Expr_Field(Expr_Var("PSTATE"),"V")])]))
   Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"V"),'0')
   Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"C"),Expr_Var("ITESimp_0"))
-  Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"Z"),Expr_TApply("or_bits.0",[1],[Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("eq_bits.0",[32],[Expr_Slices(Expr_Array(Expr_Var("_R"),27),[Slice_LoWd(0,32)]);'00000000000000000000000000000000'])]);Expr_TApply("not_bits.0",[1],[Expr_Var("ITESimp_0")])]))
+  Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"Z"),Expr_TApply("or_bits.0",[1],[Expr_TApply("and_bits.0",[1],[Expr_Var("ITESimp_0");Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("eq_bits.0",[32],[Expr_Slices(Expr_Array(Expr_Var("_R"),27),[Slice_LoWd(0,32)]);'00000000000000000000000000000000'])])]);Expr_TApply("not_bits.0",[1],[Expr_Var("ITESimp_0")])]))
   Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"N"),Expr_TApply("and_bits.0",[1],[Expr_Var("ITESimp_0");Expr_Slices(Expr_Array(Expr_Var("_R"),27),[Slice_LoWd(31,1)])]))
   "0x7a40c804"
   Stmt_ConstDecl(Type_Bits(1),"ITESimp_0",Expr_TApply("and_bits.0",[1],[Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("eq_bits.0",[1],[Expr_Field(Expr_Var("PSTATE"),"N");Expr_Field(Expr_Var("PSTATE"),"V")])]);Expr_TApply("not_bits.0",[1],[Expr_Field(Expr_Var("PSTATE"),"Z")])]))
   Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"V"),'0')
   Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"C"),Expr_Var("ITESimp_0"))
-  Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"Z"),Expr_TApply("or_bits.0",[1],[Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("eq_bits.0",[32],[Expr_Slices(Expr_Array(Expr_Var("_R"),0),[Slice_LoWd(0,32)]);'00000000000000000000000000000000'])]);Expr_TApply("not_bits.0",[1],[Expr_Var("ITESimp_0")])]))
+  Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"Z"),Expr_TApply("or_bits.0",[1],[Expr_TApply("and_bits.0",[1],[Expr_Var("ITESimp_0");Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("eq_bits.0",[32],[Expr_Slices(Expr_Array(Expr_Var("_R"),0),[Slice_LoWd(0,32)]);'00000000000000000000000000000000'])])]);Expr_TApply("not_bits.0",[1],[Expr_Var("ITESimp_0")])]))
   Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"N"),Expr_TApply("and_bits.0",[1],[Expr_Var("ITESimp_0");Expr_Slices(Expr_Array(Expr_Var("_R"),0),[Slice_LoWd(31,1)])]))
   "0x7a40d040"
   Stmt_ConstDecl(Type_Bits(32),"Cse2__5",Expr_TApply("not_bits.0",[32],[Expr_Slices(Expr_Array(Expr_Var("_R"),0),[Slice_LoWd(0,32)])]))
@@ -86850,7 +86850,7 @@ strip opcode information before passing to antlr.
   Stmt_ConstDecl(Type_Bits(32),"Cse0__5",Expr_TApply("add_bits.0",[32],[Expr_Slices(Expr_Array(Expr_Var("_R"),0),[Slice_LoWd(0,32)]);Expr_TApply("not_bits.0",[32],[Expr_Slices(Expr_Array(Expr_Var("_R"),1),[Slice_LoWd(0,32)])])]))
   Stmt_ConstDecl(Type_Bits(1),"ITESimp_0",Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("not_bool.0",[],[Expr_TApply("eq_bits.0",[1],[Expr_Field(Expr_Var("PSTATE"),"Z");'1'])])]))
   Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"V"),Expr_TApply("and_bits.0",[1],[Expr_Var("ITESimp_0");Expr_TApply("not_bits.0",[1],[Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("eq_bits.0",[64],[Expr_TApply("SignExtend.0",[32;64],[Expr_TApply("add_bits.0",[32],[Expr_Var("Cse0__5");'00000000000000000000000000000001']);64]);Expr_TApply("add_bits.0",[64],[Expr_TApply("add_bits.0",[64],[Expr_TApply("SignExtend.0",[32;64],[Expr_Slices(Expr_Array(Expr_Var("_R"),0),[Slice_LoWd(0,32)]);64]);Expr_TApply("SignExtend.0",[32;64],[Expr_Var("Cse2__5");64])]);'0000000000000000000000000000000000000000000000000000000000000001'])])])])]))
-  Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"C"),Expr_TApply("or_bits.0",[1],[Expr_TApply("not_bits.0",[1],[Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("eq_bits.0",[64],[Expr_TApply("ZeroExtend.0",[32;64],[Expr_TApply("add_bits.0",[32],[Expr_Var("Cse0__5");'00000000000000000000000000000001']);64]);Expr_TApply("add_bits.0",[64],[Expr_TApply("add_bits.0",[64],[Expr_TApply("ZeroExtend.0",[32;64],[Expr_Slices(Expr_Array(Expr_Var("_R"),0),[Slice_LoWd(0,32)]);64]);Expr_TApply("ZeroExtend.0",[32;64],[Expr_Var("Cse2__5");64])]);'0000000000000000000000000000000000000000000000000000000000000001'])])])]);Expr_TApply("not_bits.0",[1],[Expr_Var("ITESimp_0")])]))
+  Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"C"),Expr_TApply("or_bits.0",[1],[Expr_TApply("and_bits.0",[1],[Expr_Var("ITESimp_0");Expr_TApply("not_bits.0",[1],[Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("eq_bits.0",[64],[Expr_TApply("ZeroExtend.0",[32;64],[Expr_TApply("add_bits.0",[32],[Expr_Var("Cse0__5");'00000000000000000000000000000001']);64]);Expr_TApply("add_bits.0",[64],[Expr_TApply("add_bits.0",[64],[Expr_TApply("ZeroExtend.0",[32;64],[Expr_Slices(Expr_Array(Expr_Var("_R"),0),[Slice_LoWd(0,32)]);64]);Expr_TApply("ZeroExtend.0",[32;64],[Expr_Var("Cse2__5");64])]);'0000000000000000000000000000000000000000000000000000000000000001'])])])])]);Expr_TApply("not_bits.0",[1],[Expr_Var("ITESimp_0")])]))
   Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"Z"),Expr_TApply("and_bits.0",[1],[Expr_Var("ITESimp_0");Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("eq_bits.0",[32],[Expr_TApply("add_bits.0",[32],[Expr_Var("Cse0__5");'00000000000000000000000000000001']);'00000000000000000000000000000000'])])]))
   Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"N"),Expr_TApply("and_bits.0",[1],[Expr_Var("ITESimp_0");Expr_Slices(Expr_TApply("add_bits.0",[32],[Expr_Var("Cse0__5");'00000000000000000000000000000001']),[Slice_LoWd(31,1)])]))
   "0x7a411004"
@@ -86859,7 +86859,7 @@ strip opcode information before passing to antlr.
   Stmt_ConstDecl(Type_Bits(1),"ITESimp_0",Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("not_bool.0",[],[Expr_TApply("eq_bits.0",[1],[Expr_Field(Expr_Var("PSTATE"),"Z");'1'])])]))
   Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"V"),Expr_TApply("and_bits.0",[1],[Expr_Var("ITESimp_0");Expr_TApply("not_bits.0",[1],[Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("eq_bits.0",[64],[Expr_TApply("SignExtend.0",[32;64],[Expr_TApply("add_bits.0",[32],[Expr_Var("Cse0__5");'00000000000000000000000000000001']);64]);Expr_TApply("add_bits.0",[64],[Expr_TApply("add_bits.0",[64],[Expr_TApply("SignExtend.0",[32;64],[Expr_Slices(Expr_Array(Expr_Var("_R"),0),[Slice_LoWd(0,32)]);64]);Expr_TApply("SignExtend.0",[32;64],[Expr_Var("Cse2__5");64])]);'0000000000000000000000000000000000000000000000000000000000000001'])])])])]))
   Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"C"),Expr_TApply("and_bits.0",[1],[Expr_Var("ITESimp_0");Expr_TApply("not_bits.0",[1],[Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("eq_bits.0",[64],[Expr_TApply("ZeroExtend.0",[32;64],[Expr_TApply("add_bits.0",[32],[Expr_Var("Cse0__5");'00000000000000000000000000000001']);64]);Expr_TApply("add_bits.0",[64],[Expr_TApply("add_bits.0",[64],[Expr_TApply("ZeroExtend.0",[32;64],[Expr_Slices(Expr_Array(Expr_Var("_R"),0),[Slice_LoWd(0,32)]);64]);Expr_TApply("ZeroExtend.0",[32;64],[Expr_Var("Cse2__5");64])]);'0000000000000000000000000000000000000000000000000000000000000001'])])])])]))
-  Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"Z"),Expr_TApply("or_bits.0",[1],[Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("eq_bits.0",[32],[Expr_TApply("add_bits.0",[32],[Expr_Var("Cse0__5");'00000000000000000000000000000001']);'00000000000000000000000000000000'])]);Expr_TApply("not_bits.0",[1],[Expr_Var("ITESimp_0")])]))
+  Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"Z"),Expr_TApply("or_bits.0",[1],[Expr_TApply("and_bits.0",[1],[Expr_Var("ITESimp_0");Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("eq_bits.0",[32],[Expr_TApply("add_bits.0",[32],[Expr_Var("Cse0__5");'00000000000000000000000000000001']);'00000000000000000000000000000000'])])]);Expr_TApply("not_bits.0",[1],[Expr_Var("ITESimp_0")])]))
   Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"N"),Expr_TApply("and_bits.0",[1],[Expr_Var("ITESimp_0");Expr_Slices(Expr_TApply("add_bits.0",[32],[Expr_Var("Cse0__5");'00000000000000000000000000000001']),[Slice_LoWd(31,1)])]))
   "0x7a411040"
   Stmt_ConstDecl(Type_Bits(32),"Cse2__5",Expr_TApply("not_bits.0",[32],[Expr_Slices(Expr_Array(Expr_Var("_R"),1),[Slice_LoWd(0,32)])]))
@@ -86875,14 +86875,14 @@ strip opcode information before passing to antlr.
   Stmt_ConstDecl(Type_Bits(1),"ITESimp_0",Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("not_bool.0",[],[Expr_TApply("eq_bits.0",[1],[Expr_Field(Expr_Var("PSTATE"),"Z");'1'])])]))
   Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"V"),Expr_TApply("and_bits.0",[1],[Expr_Var("ITESimp_0");Expr_TApply("not_bits.0",[1],[Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("eq_bits.0",[64],[Expr_TApply("SignExtend.0",[32;64],[Expr_TApply("add_bits.0",[32],[Expr_Var("Cse0__5");'00000000000000000000000000000001']);64]);Expr_TApply("add_bits.0",[64],[Expr_TApply("add_bits.0",[64],[Expr_TApply("SignExtend.0",[32;64],[Expr_Slices(Expr_Array(Expr_Var("_R"),2),[Slice_LoWd(0,32)]);64]);Expr_TApply("SignExtend.0",[32;64],[Expr_Var("Cse2__5");64])]);'0000000000000000000000000000000000000000000000000000000000000001'])])])])]))
   Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"C"),Expr_TApply("and_bits.0",[1],[Expr_Var("ITESimp_0");Expr_TApply("not_bits.0",[1],[Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("eq_bits.0",[64],[Expr_TApply("ZeroExtend.0",[32;64],[Expr_TApply("add_bits.0",[32],[Expr_Var("Cse0__5");'00000000000000000000000000000001']);64]);Expr_TApply("add_bits.0",[64],[Expr_TApply("add_bits.0",[64],[Expr_TApply("ZeroExtend.0",[32;64],[Expr_Slices(Expr_Array(Expr_Var("_R"),2),[Slice_LoWd(0,32)]);64]);Expr_TApply("ZeroExtend.0",[32;64],[Expr_Var("Cse2__5");64])]);'0000000000000000000000000000000000000000000000000000000000000001'])])])])]))
-  Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"Z"),Expr_TApply("or_bits.0",[1],[Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("eq_bits.0",[32],[Expr_TApply("add_bits.0",[32],[Expr_Var("Cse0__5");'00000000000000000000000000000001']);'00000000000000000000000000000000'])]);Expr_TApply("not_bits.0",[1],[Expr_Var("ITESimp_0")])]))
+  Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"Z"),Expr_TApply("or_bits.0",[1],[Expr_TApply("and_bits.0",[1],[Expr_Var("ITESimp_0");Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("eq_bits.0",[32],[Expr_TApply("add_bits.0",[32],[Expr_Var("Cse0__5");'00000000000000000000000000000001']);'00000000000000000000000000000000'])])]);Expr_TApply("not_bits.0",[1],[Expr_Var("ITESimp_0")])]))
   Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"N"),Expr_TApply("and_bits.0",[1],[Expr_Var("ITESimp_0");Expr_Slices(Expr_TApply("add_bits.0",[32],[Expr_Var("Cse0__5");'00000000000000000000000000000001']),[Slice_LoWd(31,1)])]))
   "0x7a411804"
   Stmt_ConstDecl(Type_Bits(32),"Cse0__5",Expr_TApply("add_bits.0",[32],[Expr_Slices(Expr_Array(Expr_Var("_R"),0),[Slice_LoWd(0,32)]);'11111111111111111111111111111111']))
   Stmt_ConstDecl(Type_Bits(1),"ITESimp_0",Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("not_bool.0",[],[Expr_TApply("eq_bits.0",[1],[Expr_Field(Expr_Var("PSTATE"),"Z");'1'])])]))
   Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"V"),Expr_TApply("and_bits.0",[1],[Expr_Var("ITESimp_0");Expr_TApply("not_bits.0",[1],[Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("eq_bits.0",[64],[Expr_TApply("SignExtend.0",[32;64],[Expr_Var("Cse0__5");64]);Expr_TApply("add_bits.0",[64],[Expr_TApply("SignExtend.0",[32;64],[Expr_Slices(Expr_Array(Expr_Var("_R"),0),[Slice_LoWd(0,32)]);64]);'1111111111111111111111111111111111111111111111111111111111111111'])])])])]))
   Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"C"),Expr_TApply("and_bits.0",[1],[Expr_Var("ITESimp_0");Expr_TApply("not_bits.0",[1],[Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("eq_bits.0",[64],[Expr_TApply("ZeroExtend.0",[32;64],[Expr_Var("Cse0__5");64]);Expr_TApply("add_bits.0",[64],[Expr_TApply("ZeroExtend.0",[32;64],[Expr_Slices(Expr_Array(Expr_Var("_R"),0),[Slice_LoWd(0,32)]);64]);'0000000000000000000000000000000011111111111111111111111111111111'])])])])]))
-  Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"Z"),Expr_TApply("or_bits.0",[1],[Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("eq_bits.0",[32],[Expr_Var("Cse0__5");'00000000000000000000000000000000'])]);Expr_TApply("not_bits.0",[1],[Expr_Var("ITESimp_0")])]))
+  Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"Z"),Expr_TApply("or_bits.0",[1],[Expr_TApply("and_bits.0",[1],[Expr_Var("ITESimp_0");Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("eq_bits.0",[32],[Expr_Var("Cse0__5");'00000000000000000000000000000000'])])]);Expr_TApply("not_bits.0",[1],[Expr_Var("ITESimp_0")])]))
   Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"N"),Expr_TApply("and_bits.0",[1],[Expr_Var("ITESimp_0");Expr_Slices(Expr_Var("Cse0__5"),[Slice_LoWd(31,1)])]))
   "0x7a411820"
   Stmt_ConstDecl(Type_Bits(32),"Cse0__5",Expr_TApply("add_bits.0",[32],[Expr_Slices(Expr_Array(Expr_Var("_R"),1),[Slice_LoWd(0,32)]);'11111111111111111111111111111111']))
@@ -86905,14 +86905,14 @@ strip opcode information before passing to antlr.
   Stmt_ConstDecl(Type_Bits(1),"ITESimp_0",Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("eq_bits.0",[1],[Expr_Field(Expr_Var("PSTATE"),"N");Expr_Field(Expr_Var("PSTATE"),"V")])]))
   Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"V"),Expr_TApply("and_bits.0",[1],[Expr_Var("ITESimp_0");Expr_TApply("not_bits.0",[1],[Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("eq_bits.0",[64],[Expr_TApply("SignExtend.0",[32;64],[Expr_TApply("add_bits.0",[32],[Expr_Var("Cse0__5");'00000000000000000000000000000001']);64]);Expr_TApply("add_bits.0",[64],[Expr_TApply("add_bits.0",[64],[Expr_TApply("SignExtend.0",[32;64],[Expr_Slices(Expr_Array(Expr_Var("_R"),6),[Slice_LoWd(0,32)]);64]);Expr_TApply("SignExtend.0",[32;64],[Expr_Var("Cse2__5");64])]);'0000000000000000000000000000000000000000000000000000000000000001'])])])])]))
   Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"C"),Expr_TApply("and_bits.0",[1],[Expr_Var("ITESimp_0");Expr_TApply("not_bits.0",[1],[Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("eq_bits.0",[64],[Expr_TApply("ZeroExtend.0",[32;64],[Expr_TApply("add_bits.0",[32],[Expr_Var("Cse0__5");'00000000000000000000000000000001']);64]);Expr_TApply("add_bits.0",[64],[Expr_TApply("add_bits.0",[64],[Expr_TApply("ZeroExtend.0",[32;64],[Expr_Slices(Expr_Array(Expr_Var("_R"),6),[Slice_LoWd(0,32)]);64]);Expr_TApply("ZeroExtend.0",[32;64],[Expr_Var("Cse2__5");64])]);'0000000000000000000000000000000000000000000000000000000000000001'])])])])]))
-  Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"Z"),Expr_TApply("or_bits.0",[1],[Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("eq_bits.0",[32],[Expr_TApply("add_bits.0",[32],[Expr_Var("Cse0__5");'00000000000000000000000000000001']);'00000000000000000000000000000000'])]);Expr_TApply("not_bits.0",[1],[Expr_Var("ITESimp_0")])]))
+  Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"Z"),Expr_TApply("or_bits.0",[1],[Expr_TApply("and_bits.0",[1],[Expr_Var("ITESimp_0");Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("eq_bits.0",[32],[Expr_TApply("add_bits.0",[32],[Expr_Var("Cse0__5");'00000000000000000000000000000001']);'00000000000000000000000000000000'])])]);Expr_TApply("not_bits.0",[1],[Expr_Var("ITESimp_0")])]))
   Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"N"),Expr_TApply("and_bits.0",[1],[Expr_Var("ITESimp_0");Expr_Slices(Expr_TApply("add_bits.0",[32],[Expr_Var("Cse0__5");'00000000000000000000000000000001']),[Slice_LoWd(31,1)])]))
   "0x7a41c944"
   Stmt_ConstDecl(Type_Bits(32),"Cse0__5",Expr_TApply("add_bits.0",[32],[Expr_Slices(Expr_Array(Expr_Var("_R"),10),[Slice_LoWd(0,32)]);'11111111111111111111111111111111']))
   Stmt_ConstDecl(Type_Bits(1),"ITESimp_0",Expr_TApply("and_bits.0",[1],[Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("eq_bits.0",[1],[Expr_Field(Expr_Var("PSTATE"),"N");Expr_Field(Expr_Var("PSTATE"),"V")])]);Expr_TApply("not_bits.0",[1],[Expr_Field(Expr_Var("PSTATE"),"Z")])]))
   Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"V"),Expr_TApply("and_bits.0",[1],[Expr_Var("ITESimp_0");Expr_TApply("not_bits.0",[1],[Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("eq_bits.0",[64],[Expr_TApply("SignExtend.0",[32;64],[Expr_Var("Cse0__5");64]);Expr_TApply("add_bits.0",[64],[Expr_TApply("SignExtend.0",[32;64],[Expr_Slices(Expr_Array(Expr_Var("_R"),10),[Slice_LoWd(0,32)]);64]);'1111111111111111111111111111111111111111111111111111111111111111'])])])])]))
   Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"C"),Expr_TApply("and_bits.0",[1],[Expr_Var("ITESimp_0");Expr_TApply("not_bits.0",[1],[Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("eq_bits.0",[64],[Expr_TApply("ZeroExtend.0",[32;64],[Expr_Var("Cse0__5");64]);Expr_TApply("add_bits.0",[64],[Expr_TApply("ZeroExtend.0",[32;64],[Expr_Slices(Expr_Array(Expr_Var("_R"),10),[Slice_LoWd(0,32)]);64]);'0000000000000000000000000000000011111111111111111111111111111111'])])])])]))
-  Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"Z"),Expr_TApply("or_bits.0",[1],[Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("eq_bits.0",[32],[Expr_Var("Cse0__5");'00000000000000000000000000000000'])]);Expr_TApply("not_bits.0",[1],[Expr_Var("ITESimp_0")])]))
+  Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"Z"),Expr_TApply("or_bits.0",[1],[Expr_TApply("and_bits.0",[1],[Expr_Var("ITESimp_0");Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("eq_bits.0",[32],[Expr_Var("Cse0__5");'00000000000000000000000000000000'])])]);Expr_TApply("not_bits.0",[1],[Expr_Var("ITESimp_0")])]))
   Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"N"),Expr_TApply("and_bits.0",[1],[Expr_Var("ITESimp_0");Expr_Slices(Expr_Var("Cse0__5"),[Slice_LoWd(31,1)])]))
   "0x7a420800"
   Stmt_ConstDecl(Type_Bits(32),"Cse0__5",Expr_TApply("add_bits.0",[32],[Expr_Slices(Expr_Array(Expr_Var("_R"),0),[Slice_LoWd(0,32)]);'11111111111111111111111111111110']))
@@ -86941,7 +86941,7 @@ strip opcode information before passing to antlr.
   Stmt_ConstDecl(Type_Bits(1),"ITESimp_0",Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("not_bool.0",[],[Expr_TApply("eq_bits.0",[1],[Expr_Field(Expr_Var("PSTATE"),"Z");'1'])])]))
   Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"V"),Expr_TApply("and_bits.0",[1],[Expr_Var("ITESimp_0");Expr_TApply("not_bits.0",[1],[Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("eq_bits.0",[64],[Expr_TApply("SignExtend.0",[32;64],[Expr_TApply("add_bits.0",[32],[Expr_Var("Cse0__5");'00000000000000000000000000000001']);64]);Expr_TApply("add_bits.0",[64],[Expr_TApply("add_bits.0",[64],[Expr_TApply("SignExtend.0",[32;64],[Expr_Slices(Expr_Array(Expr_Var("_R"),0),[Slice_LoWd(0,32)]);64]);Expr_TApply("SignExtend.0",[32;64],[Expr_Var("Cse2__5");64])]);'0000000000000000000000000000000000000000000000000000000000000001'])])])])]))
   Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"C"),Expr_TApply("and_bits.0",[1],[Expr_Var("ITESimp_0");Expr_TApply("not_bits.0",[1],[Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("eq_bits.0",[64],[Expr_TApply("ZeroExtend.0",[32;64],[Expr_TApply("add_bits.0",[32],[Expr_Var("Cse0__5");'00000000000000000000000000000001']);64]);Expr_TApply("add_bits.0",[64],[Expr_TApply("add_bits.0",[64],[Expr_TApply("ZeroExtend.0",[32;64],[Expr_Slices(Expr_Array(Expr_Var("_R"),0),[Slice_LoWd(0,32)]);64]);Expr_TApply("ZeroExtend.0",[32;64],[Expr_Var("Cse2__5");64])]);'0000000000000000000000000000000000000000000000000000000000000001'])])])])]))
-  Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"Z"),Expr_TApply("or_bits.0",[1],[Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("eq_bits.0",[32],[Expr_TApply("add_bits.0",[32],[Expr_Var("Cse0__5");'00000000000000000000000000000001']);'00000000000000000000000000000000'])]);Expr_TApply("not_bits.0",[1],[Expr_Var("ITESimp_0")])]))
+  Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"Z"),Expr_TApply("or_bits.0",[1],[Expr_TApply("and_bits.0",[1],[Expr_Var("ITESimp_0");Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("eq_bits.0",[32],[Expr_TApply("add_bits.0",[32],[Expr_Var("Cse0__5");'00000000000000000000000000000001']);'00000000000000000000000000000000'])])]);Expr_TApply("not_bits.0",[1],[Expr_Var("ITESimp_0")])]))
   Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"N"),Expr_TApply("and_bits.0",[1],[Expr_Var("ITESimp_0");Expr_Slices(Expr_TApply("add_bits.0",[32],[Expr_Var("Cse0__5");'00000000000000000000000000000001']),[Slice_LoWd(31,1)])]))
   "0x7a421024"
   Stmt_ConstDecl(Type_Bits(32),"Cse2__5",Expr_TApply("not_bits.0",[32],[Expr_Slices(Expr_Array(Expr_Var("_R"),2),[Slice_LoWd(0,32)])]))
@@ -86949,7 +86949,7 @@ strip opcode information before passing to antlr.
   Stmt_ConstDecl(Type_Bits(1),"ITESimp_0",Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("not_bool.0",[],[Expr_TApply("eq_bits.0",[1],[Expr_Field(Expr_Var("PSTATE"),"Z");'1'])])]))
   Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"V"),Expr_TApply("and_bits.0",[1],[Expr_Var("ITESimp_0");Expr_TApply("not_bits.0",[1],[Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("eq_bits.0",[64],[Expr_TApply("SignExtend.0",[32;64],[Expr_TApply("add_bits.0",[32],[Expr_Var("Cse0__5");'00000000000000000000000000000001']);64]);Expr_TApply("add_bits.0",[64],[Expr_TApply("add_bits.0",[64],[Expr_TApply("SignExtend.0",[32;64],[Expr_Slices(Expr_Array(Expr_Var("_R"),1),[Slice_LoWd(0,32)]);64]);Expr_TApply("SignExtend.0",[32;64],[Expr_Var("Cse2__5");64])]);'0000000000000000000000000000000000000000000000000000000000000001'])])])])]))
   Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"C"),Expr_TApply("and_bits.0",[1],[Expr_Var("ITESimp_0");Expr_TApply("not_bits.0",[1],[Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("eq_bits.0",[64],[Expr_TApply("ZeroExtend.0",[32;64],[Expr_TApply("add_bits.0",[32],[Expr_Var("Cse0__5");'00000000000000000000000000000001']);64]);Expr_TApply("add_bits.0",[64],[Expr_TApply("add_bits.0",[64],[Expr_TApply("ZeroExtend.0",[32;64],[Expr_Slices(Expr_Array(Expr_Var("_R"),1),[Slice_LoWd(0,32)]);64]);Expr_TApply("ZeroExtend.0",[32;64],[Expr_Var("Cse2__5");64])]);'0000000000000000000000000000000000000000000000000000000000000001'])])])])]))
-  Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"Z"),Expr_TApply("or_bits.0",[1],[Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("eq_bits.0",[32],[Expr_TApply("add_bits.0",[32],[Expr_Var("Cse0__5");'00000000000000000000000000000001']);'00000000000000000000000000000000'])]);Expr_TApply("not_bits.0",[1],[Expr_Var("ITESimp_0")])]))
+  Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"Z"),Expr_TApply("or_bits.0",[1],[Expr_TApply("and_bits.0",[1],[Expr_Var("ITESimp_0");Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("eq_bits.0",[32],[Expr_TApply("add_bits.0",[32],[Expr_Var("Cse0__5");'00000000000000000000000000000001']);'00000000000000000000000000000000'])])]);Expr_TApply("not_bits.0",[1],[Expr_Var("ITESimp_0")])]))
   Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"N"),Expr_TApply("and_bits.0",[1],[Expr_Var("ITESimp_0");Expr_Slices(Expr_TApply("add_bits.0",[32],[Expr_Var("Cse0__5");'00000000000000000000000000000001']),[Slice_LoWd(31,1)])]))
   "0x7a421800"
   Stmt_ConstDecl(Type_Bits(32),"Cse0__5",Expr_TApply("add_bits.0",[32],[Expr_Slices(Expr_Array(Expr_Var("_R"),0),[Slice_LoWd(0,32)]);'11111111111111111111111111111110']))
@@ -86964,13 +86964,13 @@ strip opcode information before passing to antlr.
   Stmt_ConstDecl(Type_Bits(1),"ITESimp_0",Expr_TApply("and_bits.0",[1],[Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("eq_bits.0",[1],[Expr_Field(Expr_Var("PSTATE"),"N");Expr_Field(Expr_Var("PSTATE"),"V")])]);Expr_TApply("not_bits.0",[1],[Expr_Field(Expr_Var("PSTATE"),"Z")])]))
   Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"V"),Expr_TApply("and_bits.0",[1],[Expr_Var("ITESimp_0");Expr_TApply("not_bits.0",[1],[Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("eq_bits.0",[64],[Expr_TApply("SignExtend.0",[32;64],[Expr_TApply("add_bits.0",[32],[Expr_Var("Cse0__5");'00000000000000000000000000000001']);64]);Expr_TApply("add_bits.0",[64],[Expr_TApply("add_bits.0",[64],[Expr_TApply("SignExtend.0",[32;64],[Expr_Slices(Expr_Array(Expr_Var("_R"),26),[Slice_LoWd(0,32)]);64]);Expr_TApply("SignExtend.0",[32;64],[Expr_Var("Cse2__5");64])]);'0000000000000000000000000000000000000000000000000000000000000001'])])])])]))
   Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"C"),Expr_TApply("and_bits.0",[1],[Expr_Var("ITESimp_0");Expr_TApply("not_bits.0",[1],[Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("eq_bits.0",[64],[Expr_TApply("ZeroExtend.0",[32;64],[Expr_TApply("add_bits.0",[32],[Expr_Var("Cse0__5");'00000000000000000000000000000001']);64]);Expr_TApply("add_bits.0",[64],[Expr_TApply("add_bits.0",[64],[Expr_TApply("ZeroExtend.0",[32;64],[Expr_Slices(Expr_Array(Expr_Var("_R"),26),[Slice_LoWd(0,32)]);64]);Expr_TApply("ZeroExtend.0",[32;64],[Expr_Var("Cse2__5");64])]);'0000000000000000000000000000000000000000000000000000000000000001'])])])])]))
-  Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"Z"),Expr_TApply("or_bits.0",[1],[Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("eq_bits.0",[32],[Expr_TApply("add_bits.0",[32],[Expr_Var("Cse0__5");'00000000000000000000000000000001']);'00000000000000000000000000000000'])]);Expr_TApply("not_bits.0",[1],[Expr_Var("ITESimp_0")])]))
+  Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"Z"),Expr_TApply("or_bits.0",[1],[Expr_TApply("and_bits.0",[1],[Expr_Var("ITESimp_0");Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("eq_bits.0",[32],[Expr_TApply("add_bits.0",[32],[Expr_Var("Cse0__5");'00000000000000000000000000000001']);'00000000000000000000000000000000'])])]);Expr_TApply("not_bits.0",[1],[Expr_Var("ITESimp_0")])]))
   Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"N"),Expr_TApply("and_bits.0",[1],[Expr_Var("ITESimp_0");Expr_Slices(Expr_TApply("add_bits.0",[32],[Expr_Var("Cse0__5");'00000000000000000000000000000001']),[Slice_LoWd(31,1)])]))
   "0x7a42d121"
   Stmt_ConstDecl(Type_Bits(32),"Cse2__5",Expr_TApply("not_bits.0",[32],[Expr_Slices(Expr_Array(Expr_Var("_R"),2),[Slice_LoWd(0,32)])]))
   Stmt_ConstDecl(Type_Bits(32),"Cse0__5",Expr_TApply("add_bits.0",[32],[Expr_Slices(Expr_Array(Expr_Var("_R"),9),[Slice_LoWd(0,32)]);Expr_TApply("not_bits.0",[32],[Expr_Slices(Expr_Array(Expr_Var("_R"),2),[Slice_LoWd(0,32)])])]))
   Stmt_ConstDecl(Type_Bits(1),"ITESimp_0",Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("not_bool.0",[],[Expr_TApply("and_bool.0",[],[Expr_TApply("eq_bits.0",[1],[Expr_Field(Expr_Var("PSTATE"),"N");Expr_Field(Expr_Var("PSTATE"),"V")]);Expr_TApply("eq_bits.0",[1],[Expr_Field(Expr_Var("PSTATE"),"Z");'0'])])])]))
-  Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"V"),Expr_TApply("or_bits.0",[1],[Expr_TApply("not_bits.0",[1],[Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("eq_bits.0",[64],[Expr_TApply("SignExtend.0",[32;64],[Expr_TApply("add_bits.0",[32],[Expr_Var("Cse0__5");'00000000000000000000000000000001']);64]);Expr_TApply("add_bits.0",[64],[Expr_TApply("add_bits.0",[64],[Expr_TApply("SignExtend.0",[32;64],[Expr_Slices(Expr_Array(Expr_Var("_R"),9),[Slice_LoWd(0,32)]);64]);Expr_TApply("SignExtend.0",[32;64],[Expr_Var("Cse2__5");64])]);'0000000000000000000000000000000000000000000000000000000000000001'])])])]);Expr_TApply("not_bits.0",[1],[Expr_Var("ITESimp_0")])]))
+  Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"V"),Expr_TApply("or_bits.0",[1],[Expr_TApply("and_bits.0",[1],[Expr_Var("ITESimp_0");Expr_TApply("not_bits.0",[1],[Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("eq_bits.0",[64],[Expr_TApply("SignExtend.0",[32;64],[Expr_TApply("add_bits.0",[32],[Expr_Var("Cse0__5");'00000000000000000000000000000001']);64]);Expr_TApply("add_bits.0",[64],[Expr_TApply("add_bits.0",[64],[Expr_TApply("SignExtend.0",[32;64],[Expr_Slices(Expr_Array(Expr_Var("_R"),9),[Slice_LoWd(0,32)]);64]);Expr_TApply("SignExtend.0",[32;64],[Expr_Var("Cse2__5");64])]);'0000000000000000000000000000000000000000000000000000000000000001'])])])])]);Expr_TApply("not_bits.0",[1],[Expr_Var("ITESimp_0")])]))
   Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"C"),Expr_TApply("and_bits.0",[1],[Expr_Var("ITESimp_0");Expr_TApply("not_bits.0",[1],[Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("eq_bits.0",[64],[Expr_TApply("ZeroExtend.0",[32;64],[Expr_TApply("add_bits.0",[32],[Expr_Var("Cse0__5");'00000000000000000000000000000001']);64]);Expr_TApply("add_bits.0",[64],[Expr_TApply("add_bits.0",[64],[Expr_TApply("ZeroExtend.0",[32;64],[Expr_Slices(Expr_Array(Expr_Var("_R"),9),[Slice_LoWd(0,32)]);64]);Expr_TApply("ZeroExtend.0",[32;64],[Expr_Var("Cse2__5");64])]);'0000000000000000000000000000000000000000000000000000000000000001'])])])])]))
   Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"Z"),Expr_TApply("and_bits.0",[1],[Expr_Var("ITESimp_0");Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("eq_bits.0",[32],[Expr_TApply("add_bits.0",[32],[Expr_Var("Cse0__5");'00000000000000000000000000000001']);'00000000000000000000000000000000'])])]))
   Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"N"),Expr_TApply("and_bits.0",[1],[Expr_Var("ITESimp_0");Expr_Slices(Expr_TApply("add_bits.0",[32],[Expr_Var("Cse0__5");'00000000000000000000000000000001']),[Slice_LoWd(31,1)])]))
@@ -86980,7 +86980,7 @@ strip opcode information before passing to antlr.
   Stmt_ConstDecl(Type_Bits(1),"ITESimp_0",Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("not_bool.0",[],[Expr_TApply("eq_bits.0",[1],[Expr_Field(Expr_Var("PSTATE"),"Z");'1'])])]))
   Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"V"),Expr_TApply("and_bits.0",[1],[Expr_Var("ITESimp_0");Expr_TApply("not_bits.0",[1],[Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("eq_bits.0",[64],[Expr_TApply("SignExtend.0",[32;64],[Expr_TApply("add_bits.0",[32],[Expr_Var("Cse0__5");'00000000000000000000000000000001']);64]);Expr_TApply("add_bits.0",[64],[Expr_TApply("add_bits.0",[64],[Expr_TApply("SignExtend.0",[32;64],[Expr_Slices(Expr_Array(Expr_Var("_R"),0),[Slice_LoWd(0,32)]);64]);Expr_TApply("SignExtend.0",[32;64],[Expr_Var("Cse2__5");64])]);'0000000000000000000000000000000000000000000000000000000000000001'])])])])]))
   Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"C"),Expr_TApply("and_bits.0",[1],[Expr_Var("ITESimp_0");Expr_TApply("not_bits.0",[1],[Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("eq_bits.0",[64],[Expr_TApply("ZeroExtend.0",[32;64],[Expr_TApply("add_bits.0",[32],[Expr_Var("Cse0__5");'00000000000000000000000000000001']);64]);Expr_TApply("add_bits.0",[64],[Expr_TApply("add_bits.0",[64],[Expr_TApply("ZeroExtend.0",[32;64],[Expr_Slices(Expr_Array(Expr_Var("_R"),0),[Slice_LoWd(0,32)]);64]);Expr_TApply("ZeroExtend.0",[32;64],[Expr_Var("Cse2__5");64])]);'0000000000000000000000000000000000000000000000000000000000000001'])])])])]))
-  Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"Z"),Expr_TApply("or_bits.0",[1],[Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("eq_bits.0",[32],[Expr_TApply("add_bits.0",[32],[Expr_Var("Cse0__5");'00000000000000000000000000000001']);'00000000000000000000000000000000'])]);Expr_TApply("not_bits.0",[1],[Expr_Var("ITESimp_0")])]))
+  Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"Z"),Expr_TApply("or_bits.0",[1],[Expr_TApply("and_bits.0",[1],[Expr_Var("ITESimp_0");Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("eq_bits.0",[32],[Expr_TApply("add_bits.0",[32],[Expr_Var("Cse0__5");'00000000000000000000000000000001']);'00000000000000000000000000000000'])])]);Expr_TApply("not_bits.0",[1],[Expr_Var("ITESimp_0")])]))
   Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"N"),Expr_TApply("and_bits.0",[1],[Expr_Var("ITESimp_0");Expr_Slices(Expr_TApply("add_bits.0",[32],[Expr_Var("Cse0__5");'00000000000000000000000000000001']),[Slice_LoWd(31,1)])]))
   "0x7a431264"
   Stmt_ConstDecl(Type_Bits(32),"Cse2__5",Expr_TApply("not_bits.0",[32],[Expr_Slices(Expr_Array(Expr_Var("_R"),3),[Slice_LoWd(0,32)])]))
@@ -86988,14 +86988,14 @@ strip opcode information before passing to antlr.
   Stmt_ConstDecl(Type_Bits(1),"ITESimp_0",Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("not_bool.0",[],[Expr_TApply("eq_bits.0",[1],[Expr_Field(Expr_Var("PSTATE"),"Z");'1'])])]))
   Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"V"),Expr_TApply("and_bits.0",[1],[Expr_Var("ITESimp_0");Expr_TApply("not_bits.0",[1],[Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("eq_bits.0",[64],[Expr_TApply("SignExtend.0",[32;64],[Expr_TApply("add_bits.0",[32],[Expr_Var("Cse0__5");'00000000000000000000000000000001']);64]);Expr_TApply("add_bits.0",[64],[Expr_TApply("add_bits.0",[64],[Expr_TApply("SignExtend.0",[32;64],[Expr_Slices(Expr_Array(Expr_Var("_R"),19),[Slice_LoWd(0,32)]);64]);Expr_TApply("SignExtend.0",[32;64],[Expr_Var("Cse2__5");64])]);'0000000000000000000000000000000000000000000000000000000000000001'])])])])]))
   Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"C"),Expr_TApply("and_bits.0",[1],[Expr_Var("ITESimp_0");Expr_TApply("not_bits.0",[1],[Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("eq_bits.0",[64],[Expr_TApply("ZeroExtend.0",[32;64],[Expr_TApply("add_bits.0",[32],[Expr_Var("Cse0__5");'00000000000000000000000000000001']);64]);Expr_TApply("add_bits.0",[64],[Expr_TApply("add_bits.0",[64],[Expr_TApply("ZeroExtend.0",[32;64],[Expr_Slices(Expr_Array(Expr_Var("_R"),19),[Slice_LoWd(0,32)]);64]);Expr_TApply("ZeroExtend.0",[32;64],[Expr_Var("Cse2__5");64])]);'0000000000000000000000000000000000000000000000000000000000000001'])])])])]))
-  Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"Z"),Expr_TApply("or_bits.0",[1],[Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("eq_bits.0",[32],[Expr_TApply("add_bits.0",[32],[Expr_Var("Cse0__5");'00000000000000000000000000000001']);'00000000000000000000000000000000'])]);Expr_TApply("not_bits.0",[1],[Expr_Var("ITESimp_0")])]))
+  Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"Z"),Expr_TApply("or_bits.0",[1],[Expr_TApply("and_bits.0",[1],[Expr_Var("ITESimp_0");Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("eq_bits.0",[32],[Expr_TApply("add_bits.0",[32],[Expr_Var("Cse0__5");'00000000000000000000000000000001']);'00000000000000000000000000000000'])])]);Expr_TApply("not_bits.0",[1],[Expr_Var("ITESimp_0")])]))
   Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"N"),Expr_TApply("and_bits.0",[1],[Expr_Var("ITESimp_0");Expr_Slices(Expr_TApply("add_bits.0",[32],[Expr_Var("Cse0__5");'00000000000000000000000000000001']),[Slice_LoWd(31,1)])]))
   "0x7a441804"
   Stmt_ConstDecl(Type_Bits(32),"Cse0__5",Expr_TApply("add_bits.0",[32],[Expr_Slices(Expr_Array(Expr_Var("_R"),0),[Slice_LoWd(0,32)]);'11111111111111111111111111111100']))
   Stmt_ConstDecl(Type_Bits(1),"ITESimp_0",Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("not_bool.0",[],[Expr_TApply("eq_bits.0",[1],[Expr_Field(Expr_Var("PSTATE"),"Z");'1'])])]))
   Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"V"),Expr_TApply("and_bits.0",[1],[Expr_Var("ITESimp_0");Expr_TApply("not_bits.0",[1],[Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("eq_bits.0",[64],[Expr_TApply("SignExtend.0",[32;64],[Expr_Var("Cse0__5");64]);Expr_TApply("add_bits.0",[64],[Expr_TApply("SignExtend.0",[32;64],[Expr_Slices(Expr_Array(Expr_Var("_R"),0),[Slice_LoWd(0,32)]);64]);'1111111111111111111111111111111111111111111111111111111111111100'])])])])]))
   Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"C"),Expr_TApply("and_bits.0",[1],[Expr_Var("ITESimp_0");Expr_TApply("not_bits.0",[1],[Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("eq_bits.0",[64],[Expr_TApply("ZeroExtend.0",[32;64],[Expr_Var("Cse0__5");64]);Expr_TApply("add_bits.0",[64],[Expr_TApply("ZeroExtend.0",[32;64],[Expr_Slices(Expr_Array(Expr_Var("_R"),0),[Slice_LoWd(0,32)]);64]);'0000000000000000000000000000000011111111111111111111111111111100'])])])])]))
-  Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"Z"),Expr_TApply("or_bits.0",[1],[Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("eq_bits.0",[32],[Expr_Var("Cse0__5");'00000000000000000000000000000000'])]);Expr_TApply("not_bits.0",[1],[Expr_Var("ITESimp_0")])]))
+  Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"Z"),Expr_TApply("or_bits.0",[1],[Expr_TApply("and_bits.0",[1],[Expr_Var("ITESimp_0");Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("eq_bits.0",[32],[Expr_Var("Cse0__5");'00000000000000000000000000000000'])])]);Expr_TApply("not_bits.0",[1],[Expr_Var("ITESimp_0")])]))
   Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"N"),Expr_TApply("and_bits.0",[1],[Expr_Var("ITESimp_0");Expr_Slices(Expr_Var("Cse0__5"),[Slice_LoWd(31,1)])]))
   "0x7a46a000"
   Stmt_ConstDecl(Type_Bits(32),"Cse2__5",Expr_TApply("not_bits.0",[32],[Expr_Slices(Expr_Array(Expr_Var("_R"),6),[Slice_LoWd(0,32)])]))
@@ -87031,14 +87031,14 @@ strip opcode information before passing to antlr.
   Stmt_ConstDecl(Type_Bits(1),"ITESimp_0",Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("not_bool.0",[],[Expr_TApply("eq_bits.0",[1],[Expr_Field(Expr_Var("PSTATE"),"Z");'1'])])]))
   Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"V"),Expr_TApply("and_bits.0",[1],[Expr_Var("ITESimp_0");Expr_TApply("not_bits.0",[1],[Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("eq_bits.0",[64],[Expr_TApply("SignExtend.0",[32;64],[Expr_Var("Cse0__5");64]);Expr_TApply("add_bits.0",[64],[Expr_TApply("SignExtend.0",[32;64],[Expr_Slices(Expr_Array(Expr_Var("_R"),0),[Slice_LoWd(0,32)]);64]);'1111111111111111111111111111111111111111111111111111111111110111'])])])])]))
   Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"C"),Expr_TApply("and_bits.0",[1],[Expr_Var("ITESimp_0");Expr_TApply("not_bits.0",[1],[Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("eq_bits.0",[64],[Expr_TApply("ZeroExtend.0",[32;64],[Expr_Var("Cse0__5");64]);Expr_TApply("add_bits.0",[64],[Expr_TApply("ZeroExtend.0",[32;64],[Expr_Slices(Expr_Array(Expr_Var("_R"),0),[Slice_LoWd(0,32)]);64]);'0000000000000000000000000000000011111111111111111111111111110111'])])])])]))
-  Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"Z"),Expr_TApply("or_bits.0",[1],[Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("eq_bits.0",[32],[Expr_Var("Cse0__5");'00000000000000000000000000000000'])]);Expr_TApply("not_bits.0",[1],[Expr_Var("ITESimp_0")])]))
+  Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"Z"),Expr_TApply("or_bits.0",[1],[Expr_TApply("and_bits.0",[1],[Expr_Var("ITESimp_0");Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("eq_bits.0",[32],[Expr_Var("Cse0__5");'00000000000000000000000000000000'])])]);Expr_TApply("not_bits.0",[1],[Expr_Var("ITESimp_0")])]))
   Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"N"),Expr_TApply("and_bits.0",[1],[Expr_Var("ITESimp_0");Expr_Slices(Expr_Var("Cse0__5"),[Slice_LoWd(31,1)])]))
   "0x7a4a1804"
   Stmt_ConstDecl(Type_Bits(32),"Cse0__5",Expr_TApply("add_bits.0",[32],[Expr_Slices(Expr_Array(Expr_Var("_R"),0),[Slice_LoWd(0,32)]);'11111111111111111111111111110110']))
   Stmt_ConstDecl(Type_Bits(1),"ITESimp_0",Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("not_bool.0",[],[Expr_TApply("eq_bits.0",[1],[Expr_Field(Expr_Var("PSTATE"),"Z");'1'])])]))
   Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"V"),Expr_TApply("and_bits.0",[1],[Expr_Var("ITESimp_0");Expr_TApply("not_bits.0",[1],[Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("eq_bits.0",[64],[Expr_TApply("SignExtend.0",[32;64],[Expr_Var("Cse0__5");64]);Expr_TApply("add_bits.0",[64],[Expr_TApply("SignExtend.0",[32;64],[Expr_Slices(Expr_Array(Expr_Var("_R"),0),[Slice_LoWd(0,32)]);64]);'1111111111111111111111111111111111111111111111111111111111110110'])])])])]))
   Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"C"),Expr_TApply("and_bits.0",[1],[Expr_Var("ITESimp_0");Expr_TApply("not_bits.0",[1],[Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("eq_bits.0",[64],[Expr_TApply("ZeroExtend.0",[32;64],[Expr_Var("Cse0__5");64]);Expr_TApply("add_bits.0",[64],[Expr_TApply("ZeroExtend.0",[32;64],[Expr_Slices(Expr_Array(Expr_Var("_R"),0),[Slice_LoWd(0,32)]);64]);'0000000000000000000000000000000011111111111111111111111111110110'])])])])]))
-  Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"Z"),Expr_TApply("or_bits.0",[1],[Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("eq_bits.0",[32],[Expr_Var("Cse0__5");'00000000000000000000000000000000'])]);Expr_TApply("not_bits.0",[1],[Expr_Var("ITESimp_0")])]))
+  Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"Z"),Expr_TApply("or_bits.0",[1],[Expr_TApply("and_bits.0",[1],[Expr_Var("ITESimp_0");Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("eq_bits.0",[32],[Expr_Var("Cse0__5");'00000000000000000000000000000000'])])]);Expr_TApply("not_bits.0",[1],[Expr_Var("ITESimp_0")])]))
   Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"N"),Expr_TApply("and_bits.0",[1],[Expr_Var("ITESimp_0");Expr_Slices(Expr_Var("Cse0__5"),[Slice_LoWd(31,1)])]))
   "0x7a4a1840"
   Stmt_ConstDecl(Type_Bits(32),"Cse0__5",Expr_TApply("add_bits.0",[32],[Expr_Slices(Expr_Array(Expr_Var("_R"),2),[Slice_LoWd(0,32)]);'11111111111111111111111111110110']))
@@ -87052,14 +87052,14 @@ strip opcode information before passing to antlr.
   Stmt_ConstDecl(Type_Bits(1),"ITESimp_0",Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("not_bool.0",[],[Expr_TApply("eq_bits.0",[1],[Expr_Field(Expr_Var("PSTATE"),"Z");'1'])])]))
   Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"V"),Expr_TApply("and_bits.0",[1],[Expr_Var("ITESimp_0");Expr_TApply("not_bits.0",[1],[Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("eq_bits.0",[64],[Expr_TApply("SignExtend.0",[32;64],[Expr_Var("Cse0__5");64]);Expr_TApply("add_bits.0",[64],[Expr_TApply("SignExtend.0",[32;64],[Expr_Slices(Expr_Array(Expr_Var("_R"),4),[Slice_LoWd(0,32)]);64]);'1111111111111111111111111111111111111111111111111111111111110110'])])])])]))
   Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"C"),Expr_TApply("and_bits.0",[1],[Expr_Var("ITESimp_0");Expr_TApply("not_bits.0",[1],[Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("eq_bits.0",[64],[Expr_TApply("ZeroExtend.0",[32;64],[Expr_Var("Cse0__5");64]);Expr_TApply("add_bits.0",[64],[Expr_TApply("ZeroExtend.0",[32;64],[Expr_Slices(Expr_Array(Expr_Var("_R"),4),[Slice_LoWd(0,32)]);64]);'0000000000000000000000000000000011111111111111111111111111110110'])])])])]))
-  Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"Z"),Expr_TApply("or_bits.0",[1],[Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("eq_bits.0",[32],[Expr_Var("Cse0__5");'00000000000000000000000000000000'])]);Expr_TApply("not_bits.0",[1],[Expr_Var("ITESimp_0")])]))
+  Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"Z"),Expr_TApply("or_bits.0",[1],[Expr_TApply("and_bits.0",[1],[Expr_Var("ITESimp_0");Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("eq_bits.0",[32],[Expr_Var("Cse0__5");'00000000000000000000000000000000'])])]);Expr_TApply("not_bits.0",[1],[Expr_Var("ITESimp_0")])]))
   Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"N"),Expr_TApply("and_bits.0",[1],[Expr_Var("ITESimp_0");Expr_Slices(Expr_Var("Cse0__5"),[Slice_LoWd(31,1)])]))
   "0x7a4a1b04"
   Stmt_ConstDecl(Type_Bits(32),"Cse0__5",Expr_TApply("add_bits.0",[32],[Expr_Slices(Expr_Array(Expr_Var("_R"),24),[Slice_LoWd(0,32)]);'11111111111111111111111111110110']))
   Stmt_ConstDecl(Type_Bits(1),"ITESimp_0",Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("not_bool.0",[],[Expr_TApply("eq_bits.0",[1],[Expr_Field(Expr_Var("PSTATE"),"Z");'1'])])]))
   Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"V"),Expr_TApply("and_bits.0",[1],[Expr_Var("ITESimp_0");Expr_TApply("not_bits.0",[1],[Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("eq_bits.0",[64],[Expr_TApply("SignExtend.0",[32;64],[Expr_Var("Cse0__5");64]);Expr_TApply("add_bits.0",[64],[Expr_TApply("SignExtend.0",[32;64],[Expr_Slices(Expr_Array(Expr_Var("_R"),24),[Slice_LoWd(0,32)]);64]);'1111111111111111111111111111111111111111111111111111111111110110'])])])])]))
   Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"C"),Expr_TApply("and_bits.0",[1],[Expr_Var("ITESimp_0");Expr_TApply("not_bits.0",[1],[Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("eq_bits.0",[64],[Expr_TApply("ZeroExtend.0",[32;64],[Expr_Var("Cse0__5");64]);Expr_TApply("add_bits.0",[64],[Expr_TApply("ZeroExtend.0",[32;64],[Expr_Slices(Expr_Array(Expr_Var("_R"),24),[Slice_LoWd(0,32)]);64]);'0000000000000000000000000000000011111111111111111111111111110110'])])])])]))
-  Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"Z"),Expr_TApply("or_bits.0",[1],[Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("eq_bits.0",[32],[Expr_Var("Cse0__5");'00000000000000000000000000000000'])]);Expr_TApply("not_bits.0",[1],[Expr_Var("ITESimp_0")])]))
+  Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"Z"),Expr_TApply("or_bits.0",[1],[Expr_TApply("and_bits.0",[1],[Expr_Var("ITESimp_0");Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("eq_bits.0",[32],[Expr_Var("Cse0__5");'00000000000000000000000000000000'])])]);Expr_TApply("not_bits.0",[1],[Expr_Var("ITESimp_0")])]))
   Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"N"),Expr_TApply("and_bits.0",[1],[Expr_Var("ITESimp_0");Expr_Slices(Expr_Var("Cse0__5"),[Slice_LoWd(31,1)])]))
   "0x7a4a8a60"
   Stmt_ConstDecl(Type_Bits(32),"Cse0__5",Expr_TApply("add_bits.0",[32],[Expr_Slices(Expr_Array(Expr_Var("_R"),19),[Slice_LoWd(0,32)]);'11111111111111111111111111110110']))
@@ -87081,56 +87081,56 @@ strip opcode information before passing to antlr.
   Stmt_ConstDecl(Type_Bits(1),"ITESimp_0",Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("not_bool.0",[],[Expr_TApply("eq_bits.0",[1],[Expr_Field(Expr_Var("PSTATE"),"Z");'1'])])]))
   Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"V"),Expr_TApply("and_bits.0",[1],[Expr_Var("ITESimp_0");Expr_TApply("not_bits.0",[1],[Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("eq_bits.0",[64],[Expr_TApply("SignExtend.0",[32;64],[Expr_TApply("add_bits.0",[32],[Expr_Var("Cse0__5");'00000000000000000000000000000001']);64]);Expr_TApply("add_bits.0",[64],[Expr_TApply("add_bits.0",[64],[Expr_TApply("SignExtend.0",[32;64],[Expr_Slices(Expr_Array(Expr_Var("_R"),1),[Slice_LoWd(0,32)]);64]);Expr_TApply("SignExtend.0",[32;64],[Expr_Var("Cse2__5");64])]);'0000000000000000000000000000000000000000000000000000000000000001'])])])])]))
   Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"C"),Expr_TApply("and_bits.0",[1],[Expr_Var("ITESimp_0");Expr_TApply("not_bits.0",[1],[Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("eq_bits.0",[64],[Expr_TApply("ZeroExtend.0",[32;64],[Expr_TApply("add_bits.0",[32],[Expr_Var("Cse0__5");'00000000000000000000000000000001']);64]);Expr_TApply("add_bits.0",[64],[Expr_TApply("add_bits.0",[64],[Expr_TApply("ZeroExtend.0",[32;64],[Expr_Slices(Expr_Array(Expr_Var("_R"),1),[Slice_LoWd(0,32)]);64]);Expr_TApply("ZeroExtend.0",[32;64],[Expr_Var("Cse2__5");64])]);'0000000000000000000000000000000000000000000000000000000000000001'])])])])]))
-  Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"Z"),Expr_TApply("or_bits.0",[1],[Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("eq_bits.0",[32],[Expr_TApply("add_bits.0",[32],[Expr_Var("Cse0__5");'00000000000000000000000000000001']);'00000000000000000000000000000000'])]);Expr_TApply("not_bits.0",[1],[Expr_Var("ITESimp_0")])]))
+  Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"Z"),Expr_TApply("or_bits.0",[1],[Expr_TApply("and_bits.0",[1],[Expr_Var("ITESimp_0");Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("eq_bits.0",[32],[Expr_TApply("add_bits.0",[32],[Expr_Var("Cse0__5");'00000000000000000000000000000001']);'00000000000000000000000000000000'])])]);Expr_TApply("not_bits.0",[1],[Expr_Var("ITESimp_0")])]))
   Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"N"),Expr_TApply("and_bits.0",[1],[Expr_Var("ITESimp_0");Expr_Slices(Expr_TApply("add_bits.0",[32],[Expr_Var("Cse0__5");'00000000000000000000000000000001']),[Slice_LoWd(31,1)])]))
   "0x7a4b1804"
   Stmt_ConstDecl(Type_Bits(32),"Cse0__5",Expr_TApply("add_bits.0",[32],[Expr_Slices(Expr_Array(Expr_Var("_R"),0),[Slice_LoWd(0,32)]);'11111111111111111111111111110101']))
   Stmt_ConstDecl(Type_Bits(1),"ITESimp_0",Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("not_bool.0",[],[Expr_TApply("eq_bits.0",[1],[Expr_Field(Expr_Var("PSTATE"),"Z");'1'])])]))
   Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"V"),Expr_TApply("and_bits.0",[1],[Expr_Var("ITESimp_0");Expr_TApply("not_bits.0",[1],[Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("eq_bits.0",[64],[Expr_TApply("SignExtend.0",[32;64],[Expr_Var("Cse0__5");64]);Expr_TApply("add_bits.0",[64],[Expr_TApply("SignExtend.0",[32;64],[Expr_Slices(Expr_Array(Expr_Var("_R"),0),[Slice_LoWd(0,32)]);64]);'1111111111111111111111111111111111111111111111111111111111110101'])])])])]))
   Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"C"),Expr_TApply("and_bits.0",[1],[Expr_Var("ITESimp_0");Expr_TApply("not_bits.0",[1],[Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("eq_bits.0",[64],[Expr_TApply("ZeroExtend.0",[32;64],[Expr_Var("Cse0__5");64]);Expr_TApply("add_bits.0",[64],[Expr_TApply("ZeroExtend.0",[32;64],[Expr_Slices(Expr_Array(Expr_Var("_R"),0),[Slice_LoWd(0,32)]);64]);'0000000000000000000000000000000011111111111111111111111111110101'])])])])]))
-  Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"Z"),Expr_TApply("or_bits.0",[1],[Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("eq_bits.0",[32],[Expr_Var("Cse0__5");'00000000000000000000000000000000'])]);Expr_TApply("not_bits.0",[1],[Expr_Var("ITESimp_0")])]))
+  Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"Z"),Expr_TApply("or_bits.0",[1],[Expr_TApply("and_bits.0",[1],[Expr_Var("ITESimp_0");Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("eq_bits.0",[32],[Expr_Var("Cse0__5");'00000000000000000000000000000000'])])]);Expr_TApply("not_bits.0",[1],[Expr_Var("ITESimp_0")])]))
   Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"N"),Expr_TApply("and_bits.0",[1],[Expr_Var("ITESimp_0");Expr_Slices(Expr_Var("Cse0__5"),[Slice_LoWd(31,1)])]))
   "0x7a4d1804"
   Stmt_ConstDecl(Type_Bits(32),"Cse0__5",Expr_TApply("add_bits.0",[32],[Expr_Slices(Expr_Array(Expr_Var("_R"),0),[Slice_LoWd(0,32)]);'11111111111111111111111111110011']))
   Stmt_ConstDecl(Type_Bits(1),"ITESimp_0",Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("not_bool.0",[],[Expr_TApply("eq_bits.0",[1],[Expr_Field(Expr_Var("PSTATE"),"Z");'1'])])]))
   Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"V"),Expr_TApply("and_bits.0",[1],[Expr_Var("ITESimp_0");Expr_TApply("not_bits.0",[1],[Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("eq_bits.0",[64],[Expr_TApply("SignExtend.0",[32;64],[Expr_Var("Cse0__5");64]);Expr_TApply("add_bits.0",[64],[Expr_TApply("SignExtend.0",[32;64],[Expr_Slices(Expr_Array(Expr_Var("_R"),0),[Slice_LoWd(0,32)]);64]);'1111111111111111111111111111111111111111111111111111111111110011'])])])])]))
   Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"C"),Expr_TApply("and_bits.0",[1],[Expr_Var("ITESimp_0");Expr_TApply("not_bits.0",[1],[Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("eq_bits.0",[64],[Expr_TApply("ZeroExtend.0",[32;64],[Expr_Var("Cse0__5");64]);Expr_TApply("add_bits.0",[64],[Expr_TApply("ZeroExtend.0",[32;64],[Expr_Slices(Expr_Array(Expr_Var("_R"),0),[Slice_LoWd(0,32)]);64]);'0000000000000000000000000000000011111111111111111111111111110011'])])])])]))
-  Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"Z"),Expr_TApply("or_bits.0",[1],[Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("eq_bits.0",[32],[Expr_Var("Cse0__5");'00000000000000000000000000000000'])]);Expr_TApply("not_bits.0",[1],[Expr_Var("ITESimp_0")])]))
+  Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"Z"),Expr_TApply("or_bits.0",[1],[Expr_TApply("and_bits.0",[1],[Expr_Var("ITESimp_0");Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("eq_bits.0",[32],[Expr_Var("Cse0__5");'00000000000000000000000000000000'])])]);Expr_TApply("not_bits.0",[1],[Expr_Var("ITESimp_0")])]))
   Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"N"),Expr_TApply("and_bits.0",[1],[Expr_Var("ITESimp_0");Expr_Slices(Expr_Var("Cse0__5"),[Slice_LoWd(31,1)])]))
   "0x7a4d1824"
   Stmt_ConstDecl(Type_Bits(32),"Cse0__5",Expr_TApply("add_bits.0",[32],[Expr_Slices(Expr_Array(Expr_Var("_R"),1),[Slice_LoWd(0,32)]);'11111111111111111111111111110011']))
   Stmt_ConstDecl(Type_Bits(1),"ITESimp_0",Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("not_bool.0",[],[Expr_TApply("eq_bits.0",[1],[Expr_Field(Expr_Var("PSTATE"),"Z");'1'])])]))
   Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"V"),Expr_TApply("and_bits.0",[1],[Expr_Var("ITESimp_0");Expr_TApply("not_bits.0",[1],[Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("eq_bits.0",[64],[Expr_TApply("SignExtend.0",[32;64],[Expr_Var("Cse0__5");64]);Expr_TApply("add_bits.0",[64],[Expr_TApply("SignExtend.0",[32;64],[Expr_Slices(Expr_Array(Expr_Var("_R"),1),[Slice_LoWd(0,32)]);64]);'1111111111111111111111111111111111111111111111111111111111110011'])])])])]))
   Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"C"),Expr_TApply("and_bits.0",[1],[Expr_Var("ITESimp_0");Expr_TApply("not_bits.0",[1],[Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("eq_bits.0",[64],[Expr_TApply("ZeroExtend.0",[32;64],[Expr_Var("Cse0__5");64]);Expr_TApply("add_bits.0",[64],[Expr_TApply("ZeroExtend.0",[32;64],[Expr_Slices(Expr_Array(Expr_Var("_R"),1),[Slice_LoWd(0,32)]);64]);'0000000000000000000000000000000011111111111111111111111111110011'])])])])]))
-  Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"Z"),Expr_TApply("or_bits.0",[1],[Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("eq_bits.0",[32],[Expr_Var("Cse0__5");'00000000000000000000000000000000'])]);Expr_TApply("not_bits.0",[1],[Expr_Var("ITESimp_0")])]))
+  Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"Z"),Expr_TApply("or_bits.0",[1],[Expr_TApply("and_bits.0",[1],[Expr_Var("ITESimp_0");Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("eq_bits.0",[32],[Expr_Var("Cse0__5");'00000000000000000000000000000000'])])]);Expr_TApply("not_bits.0",[1],[Expr_Var("ITESimp_0")])]))
   Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"N"),Expr_TApply("and_bits.0",[1],[Expr_Var("ITESimp_0");Expr_Slices(Expr_Var("Cse0__5"),[Slice_LoWd(31,1)])]))
   "0x7a4d1844"
   Stmt_ConstDecl(Type_Bits(32),"Cse0__5",Expr_TApply("add_bits.0",[32],[Expr_Slices(Expr_Array(Expr_Var("_R"),2),[Slice_LoWd(0,32)]);'11111111111111111111111111110011']))
   Stmt_ConstDecl(Type_Bits(1),"ITESimp_0",Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("not_bool.0",[],[Expr_TApply("eq_bits.0",[1],[Expr_Field(Expr_Var("PSTATE"),"Z");'1'])])]))
   Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"V"),Expr_TApply("and_bits.0",[1],[Expr_Var("ITESimp_0");Expr_TApply("not_bits.0",[1],[Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("eq_bits.0",[64],[Expr_TApply("SignExtend.0",[32;64],[Expr_Var("Cse0__5");64]);Expr_TApply("add_bits.0",[64],[Expr_TApply("SignExtend.0",[32;64],[Expr_Slices(Expr_Array(Expr_Var("_R"),2),[Slice_LoWd(0,32)]);64]);'1111111111111111111111111111111111111111111111111111111111110011'])])])])]))
   Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"C"),Expr_TApply("and_bits.0",[1],[Expr_Var("ITESimp_0");Expr_TApply("not_bits.0",[1],[Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("eq_bits.0",[64],[Expr_TApply("ZeroExtend.0",[32;64],[Expr_Var("Cse0__5");64]);Expr_TApply("add_bits.0",[64],[Expr_TApply("ZeroExtend.0",[32;64],[Expr_Slices(Expr_Array(Expr_Var("_R"),2),[Slice_LoWd(0,32)]);64]);'0000000000000000000000000000000011111111111111111111111111110011'])])])])]))
-  Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"Z"),Expr_TApply("or_bits.0",[1],[Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("eq_bits.0",[32],[Expr_Var("Cse0__5");'00000000000000000000000000000000'])]);Expr_TApply("not_bits.0",[1],[Expr_Var("ITESimp_0")])]))
+  Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"Z"),Expr_TApply("or_bits.0",[1],[Expr_TApply("and_bits.0",[1],[Expr_Var("ITESimp_0");Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("eq_bits.0",[32],[Expr_Var("Cse0__5");'00000000000000000000000000000000'])])]);Expr_TApply("not_bits.0",[1],[Expr_Var("ITESimp_0")])]))
   Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"N"),Expr_TApply("and_bits.0",[1],[Expr_Var("ITESimp_0");Expr_Slices(Expr_Var("Cse0__5"),[Slice_LoWd(31,1)])]))
   "0x7a4d1884"
   Stmt_ConstDecl(Type_Bits(32),"Cse0__5",Expr_TApply("add_bits.0",[32],[Expr_Slices(Expr_Array(Expr_Var("_R"),4),[Slice_LoWd(0,32)]);'11111111111111111111111111110011']))
   Stmt_ConstDecl(Type_Bits(1),"ITESimp_0",Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("not_bool.0",[],[Expr_TApply("eq_bits.0",[1],[Expr_Field(Expr_Var("PSTATE"),"Z");'1'])])]))
   Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"V"),Expr_TApply("and_bits.0",[1],[Expr_Var("ITESimp_0");Expr_TApply("not_bits.0",[1],[Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("eq_bits.0",[64],[Expr_TApply("SignExtend.0",[32;64],[Expr_Var("Cse0__5");64]);Expr_TApply("add_bits.0",[64],[Expr_TApply("SignExtend.0",[32;64],[Expr_Slices(Expr_Array(Expr_Var("_R"),4),[Slice_LoWd(0,32)]);64]);'1111111111111111111111111111111111111111111111111111111111110011'])])])])]))
   Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"C"),Expr_TApply("and_bits.0",[1],[Expr_Var("ITESimp_0");Expr_TApply("not_bits.0",[1],[Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("eq_bits.0",[64],[Expr_TApply("ZeroExtend.0",[32;64],[Expr_Var("Cse0__5");64]);Expr_TApply("add_bits.0",[64],[Expr_TApply("ZeroExtend.0",[32;64],[Expr_Slices(Expr_Array(Expr_Var("_R"),4),[Slice_LoWd(0,32)]);64]);'0000000000000000000000000000000011111111111111111111111111110011'])])])])]))
-  Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"Z"),Expr_TApply("or_bits.0",[1],[Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("eq_bits.0",[32],[Expr_Var("Cse0__5");'00000000000000000000000000000000'])]);Expr_TApply("not_bits.0",[1],[Expr_Var("ITESimp_0")])]))
+  Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"Z"),Expr_TApply("or_bits.0",[1],[Expr_TApply("and_bits.0",[1],[Expr_Var("ITESimp_0");Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("eq_bits.0",[32],[Expr_Var("Cse0__5");'00000000000000000000000000000000'])])]);Expr_TApply("not_bits.0",[1],[Expr_Var("ITESimp_0")])]))
   Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"N"),Expr_TApply("and_bits.0",[1],[Expr_Var("ITESimp_0");Expr_Slices(Expr_Var("Cse0__5"),[Slice_LoWd(31,1)])]))
   "0x7a4d1aa4"
   Stmt_ConstDecl(Type_Bits(32),"Cse0__5",Expr_TApply("add_bits.0",[32],[Expr_Slices(Expr_Array(Expr_Var("_R"),21),[Slice_LoWd(0,32)]);'11111111111111111111111111110011']))
   Stmt_ConstDecl(Type_Bits(1),"ITESimp_0",Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("not_bool.0",[],[Expr_TApply("eq_bits.0",[1],[Expr_Field(Expr_Var("PSTATE"),"Z");'1'])])]))
   Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"V"),Expr_TApply("and_bits.0",[1],[Expr_Var("ITESimp_0");Expr_TApply("not_bits.0",[1],[Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("eq_bits.0",[64],[Expr_TApply("SignExtend.0",[32;64],[Expr_Var("Cse0__5");64]);Expr_TApply("add_bits.0",[64],[Expr_TApply("SignExtend.0",[32;64],[Expr_Slices(Expr_Array(Expr_Var("_R"),21),[Slice_LoWd(0,32)]);64]);'1111111111111111111111111111111111111111111111111111111111110011'])])])])]))
   Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"C"),Expr_TApply("and_bits.0",[1],[Expr_Var("ITESimp_0");Expr_TApply("not_bits.0",[1],[Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("eq_bits.0",[64],[Expr_TApply("ZeroExtend.0",[32;64],[Expr_Var("Cse0__5");64]);Expr_TApply("add_bits.0",[64],[Expr_TApply("ZeroExtend.0",[32;64],[Expr_Slices(Expr_Array(Expr_Var("_R"),21),[Slice_LoWd(0,32)]);64]);'0000000000000000000000000000000011111111111111111111111111110011'])])])])]))
-  Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"Z"),Expr_TApply("or_bits.0",[1],[Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("eq_bits.0",[32],[Expr_Var("Cse0__5");'00000000000000000000000000000000'])]);Expr_TApply("not_bits.0",[1],[Expr_Var("ITESimp_0")])]))
+  Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"Z"),Expr_TApply("or_bits.0",[1],[Expr_TApply("and_bits.0",[1],[Expr_Var("ITESimp_0");Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("eq_bits.0",[32],[Expr_Var("Cse0__5");'00000000000000000000000000000000'])])]);Expr_TApply("not_bits.0",[1],[Expr_Var("ITESimp_0")])]))
   Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"N"),Expr_TApply("and_bits.0",[1],[Expr_Var("ITESimp_0");Expr_Slices(Expr_Var("Cse0__5"),[Slice_LoWd(31,1)])]))
   "0x7a4d1b64"
   Stmt_ConstDecl(Type_Bits(32),"Cse0__5",Expr_TApply("add_bits.0",[32],[Expr_Slices(Expr_Array(Expr_Var("_R"),27),[Slice_LoWd(0,32)]);'11111111111111111111111111110011']))
   Stmt_ConstDecl(Type_Bits(1),"ITESimp_0",Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("not_bool.0",[],[Expr_TApply("eq_bits.0",[1],[Expr_Field(Expr_Var("PSTATE"),"Z");'1'])])]))
   Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"V"),Expr_TApply("and_bits.0",[1],[Expr_Var("ITESimp_0");Expr_TApply("not_bits.0",[1],[Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("eq_bits.0",[64],[Expr_TApply("SignExtend.0",[32;64],[Expr_Var("Cse0__5");64]);Expr_TApply("add_bits.0",[64],[Expr_TApply("SignExtend.0",[32;64],[Expr_Slices(Expr_Array(Expr_Var("_R"),27),[Slice_LoWd(0,32)]);64]);'1111111111111111111111111111111111111111111111111111111111110011'])])])])]))
   Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"C"),Expr_TApply("and_bits.0",[1],[Expr_Var("ITESimp_0");Expr_TApply("not_bits.0",[1],[Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("eq_bits.0",[64],[Expr_TApply("ZeroExtend.0",[32;64],[Expr_Var("Cse0__5");64]);Expr_TApply("add_bits.0",[64],[Expr_TApply("ZeroExtend.0",[32;64],[Expr_Slices(Expr_Array(Expr_Var("_R"),27),[Slice_LoWd(0,32)]);64]);'0000000000000000000000000000000011111111111111111111111111110011'])])])])]))
-  Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"Z"),Expr_TApply("or_bits.0",[1],[Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("eq_bits.0",[32],[Expr_Var("Cse0__5");'00000000000000000000000000000000'])]);Expr_TApply("not_bits.0",[1],[Expr_Var("ITESimp_0")])]))
+  Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"Z"),Expr_TApply("or_bits.0",[1],[Expr_TApply("and_bits.0",[1],[Expr_Var("ITESimp_0");Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("eq_bits.0",[32],[Expr_Var("Cse0__5");'00000000000000000000000000000000'])])]);Expr_TApply("not_bits.0",[1],[Expr_Var("ITESimp_0")])]))
   Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"N"),Expr_TApply("and_bits.0",[1],[Expr_Var("ITESimp_0");Expr_Slices(Expr_Var("Cse0__5"),[Slice_LoWd(31,1)])]))
   "0x7a531324"
   Stmt_ConstDecl(Type_Bits(32),"Cse2__5",Expr_TApply("not_bits.0",[32],[Expr_Slices(Expr_Array(Expr_Var("_R"),19),[Slice_LoWd(0,32)])]))
@@ -87138,7 +87138,7 @@ strip opcode information before passing to antlr.
   Stmt_ConstDecl(Type_Bits(1),"ITESimp_0",Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("not_bool.0",[],[Expr_TApply("eq_bits.0",[1],[Expr_Field(Expr_Var("PSTATE"),"Z");'1'])])]))
   Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"V"),Expr_TApply("and_bits.0",[1],[Expr_Var("ITESimp_0");Expr_TApply("not_bits.0",[1],[Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("eq_bits.0",[64],[Expr_TApply("SignExtend.0",[32;64],[Expr_TApply("add_bits.0",[32],[Expr_Var("Cse0__5");'00000000000000000000000000000001']);64]);Expr_TApply("add_bits.0",[64],[Expr_TApply("add_bits.0",[64],[Expr_TApply("SignExtend.0",[32;64],[Expr_Slices(Expr_Array(Expr_Var("_R"),25),[Slice_LoWd(0,32)]);64]);Expr_TApply("SignExtend.0",[32;64],[Expr_Var("Cse2__5");64])]);'0000000000000000000000000000000000000000000000000000000000000001'])])])])]))
   Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"C"),Expr_TApply("and_bits.0",[1],[Expr_Var("ITESimp_0");Expr_TApply("not_bits.0",[1],[Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("eq_bits.0",[64],[Expr_TApply("ZeroExtend.0",[32;64],[Expr_TApply("add_bits.0",[32],[Expr_Var("Cse0__5");'00000000000000000000000000000001']);64]);Expr_TApply("add_bits.0",[64],[Expr_TApply("add_bits.0",[64],[Expr_TApply("ZeroExtend.0",[32;64],[Expr_Slices(Expr_Array(Expr_Var("_R"),25),[Slice_LoWd(0,32)]);64]);Expr_TApply("ZeroExtend.0",[32;64],[Expr_Var("Cse2__5");64])]);'0000000000000000000000000000000000000000000000000000000000000001'])])])])]))
-  Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"Z"),Expr_TApply("or_bits.0",[1],[Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("eq_bits.0",[32],[Expr_TApply("add_bits.0",[32],[Expr_Var("Cse0__5");'00000000000000000000000000000001']);'00000000000000000000000000000000'])]);Expr_TApply("not_bits.0",[1],[Expr_Var("ITESimp_0")])]))
+  Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"Z"),Expr_TApply("or_bits.0",[1],[Expr_TApply("and_bits.0",[1],[Expr_Var("ITESimp_0");Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("eq_bits.0",[32],[Expr_TApply("add_bits.0",[32],[Expr_Var("Cse0__5");'00000000000000000000000000000001']);'00000000000000000000000000000000'])])]);Expr_TApply("not_bits.0",[1],[Expr_Var("ITESimp_0")])]))
   Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"N"),Expr_TApply("and_bits.0",[1],[Expr_Var("ITESimp_0");Expr_Slices(Expr_TApply("add_bits.0",[32],[Expr_Var("Cse0__5");'00000000000000000000000000000001']),[Slice_LoWd(31,1)])]))
   "0x7a540364"
   Stmt_ConstDecl(Type_Bits(32),"Cse2__5",Expr_TApply("not_bits.0",[32],[Expr_Slices(Expr_Array(Expr_Var("_R"),20),[Slice_LoWd(0,32)])]))
@@ -87146,7 +87146,7 @@ strip opcode information before passing to antlr.
   Stmt_ConstDecl(Type_Bits(1),"ITESimp_0",Expr_Field(Expr_Var("PSTATE"),"Z"))
   Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"V"),Expr_TApply("and_bits.0",[1],[Expr_Var("ITESimp_0");Expr_TApply("not_bits.0",[1],[Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("eq_bits.0",[64],[Expr_TApply("SignExtend.0",[32;64],[Expr_TApply("add_bits.0",[32],[Expr_Var("Cse0__5");'00000000000000000000000000000001']);64]);Expr_TApply("add_bits.0",[64],[Expr_TApply("add_bits.0",[64],[Expr_TApply("SignExtend.0",[32;64],[Expr_Slices(Expr_Array(Expr_Var("_R"),27),[Slice_LoWd(0,32)]);64]);Expr_TApply("SignExtend.0",[32;64],[Expr_Var("Cse2__5");64])]);'0000000000000000000000000000000000000000000000000000000000000001'])])])])]))
   Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"C"),Expr_TApply("and_bits.0",[1],[Expr_Var("ITESimp_0");Expr_TApply("not_bits.0",[1],[Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("eq_bits.0",[64],[Expr_TApply("ZeroExtend.0",[32;64],[Expr_TApply("add_bits.0",[32],[Expr_Var("Cse0__5");'00000000000000000000000000000001']);64]);Expr_TApply("add_bits.0",[64],[Expr_TApply("add_bits.0",[64],[Expr_TApply("ZeroExtend.0",[32;64],[Expr_Slices(Expr_Array(Expr_Var("_R"),27),[Slice_LoWd(0,32)]);64]);Expr_TApply("ZeroExtend.0",[32;64],[Expr_Var("Cse2__5");64])]);'0000000000000000000000000000000000000000000000000000000000000001'])])])])]))
-  Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"Z"),Expr_TApply("or_bits.0",[1],[Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("eq_bits.0",[32],[Expr_TApply("add_bits.0",[32],[Expr_Var("Cse0__5");'00000000000000000000000000000001']);'00000000000000000000000000000000'])]);Expr_TApply("not_bits.0",[1],[Expr_Var("ITESimp_0")])]))
+  Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"Z"),Expr_TApply("or_bits.0",[1],[Expr_TApply("and_bits.0",[1],[Expr_Var("ITESimp_0");Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("eq_bits.0",[32],[Expr_TApply("add_bits.0",[32],[Expr_Var("Cse0__5");'00000000000000000000000000000001']);'00000000000000000000000000000000'])])]);Expr_TApply("not_bits.0",[1],[Expr_Var("ITESimp_0")])]))
   Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"N"),Expr_TApply("and_bits.0",[1],[Expr_Var("ITESimp_0");Expr_Slices(Expr_TApply("add_bits.0",[32],[Expr_Var("Cse0__5");'00000000000000000000000000000001']),[Slice_LoWd(31,1)])]))
   "0x7a555300"
   Stmt_ConstDecl(Type_Bits(32),"Cse2__5",Expr_TApply("not_bits.0",[32],[Expr_Slices(Expr_Array(Expr_Var("_R"),21),[Slice_LoWd(0,32)])]))
@@ -87162,7 +87162,7 @@ strip opcode information before passing to antlr.
   Stmt_ConstDecl(Type_Bits(1),"ITESimp_0",Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("not_bool.0",[],[Expr_TApply("eq_bits.0",[1],[Expr_Field(Expr_Var("PSTATE"),"N");Expr_Field(Expr_Var("PSTATE"),"V")])])]))
   Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"V"),Expr_TApply("and_bits.0",[1],[Expr_Var("ITESimp_0");Expr_TApply("not_bits.0",[1],[Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("eq_bits.0",[64],[Expr_TApply("SignExtend.0",[32;64],[Expr_TApply("add_bits.0",[32],[Expr_Var("Cse0__5");'00000000000000000000000000000001']);64]);Expr_TApply("add_bits.0",[64],[Expr_TApply("add_bits.0",[64],[Expr_TApply("SignExtend.0",[32;64],[Expr_Slices(Expr_Array(Expr_Var("_R"),23),[Slice_LoWd(0,32)]);64]);Expr_TApply("SignExtend.0",[32;64],[Expr_Var("Cse2__5");64])]);'0000000000000000000000000000000000000000000000000000000000000001'])])])])]))
   Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"C"),Expr_TApply("and_bits.0",[1],[Expr_Var("ITESimp_0");Expr_TApply("not_bits.0",[1],[Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("eq_bits.0",[64],[Expr_TApply("ZeroExtend.0",[32;64],[Expr_TApply("add_bits.0",[32],[Expr_Var("Cse0__5");'00000000000000000000000000000001']);64]);Expr_TApply("add_bits.0",[64],[Expr_TApply("add_bits.0",[64],[Expr_TApply("ZeroExtend.0",[32;64],[Expr_Slices(Expr_Array(Expr_Var("_R"),23),[Slice_LoWd(0,32)]);64]);Expr_TApply("ZeroExtend.0",[32;64],[Expr_Var("Cse2__5");64])]);'0000000000000000000000000000000000000000000000000000000000000001'])])])])]))
-  Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"Z"),Expr_TApply("or_bits.0",[1],[Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("eq_bits.0",[32],[Expr_TApply("add_bits.0",[32],[Expr_Var("Cse0__5");'00000000000000000000000000000001']);'00000000000000000000000000000000'])]);Expr_TApply("not_bits.0",[1],[Expr_Var("ITESimp_0")])]))
+  Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"Z"),Expr_TApply("or_bits.0",[1],[Expr_TApply("and_bits.0",[1],[Expr_Var("ITESimp_0");Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("eq_bits.0",[32],[Expr_TApply("add_bits.0",[32],[Expr_Var("Cse0__5");'00000000000000000000000000000001']);'00000000000000000000000000000000'])])]);Expr_TApply("not_bits.0",[1],[Expr_Var("ITESimp_0")])]))
   Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"N"),Expr_TApply("and_bits.0",[1],[Expr_Var("ITESimp_0");Expr_Slices(Expr_TApply("add_bits.0",[32],[Expr_Var("Cse0__5");'00000000000000000000000000000001']),[Slice_LoWd(31,1)])]))
   "0x7a561004"
   Stmt_ConstDecl(Type_Bits(32),"Cse2__5",Expr_TApply("not_bits.0",[32],[Expr_Slices(Expr_Array(Expr_Var("_R"),22),[Slice_LoWd(0,32)])]))
@@ -87170,7 +87170,7 @@ strip opcode information before passing to antlr.
   Stmt_ConstDecl(Type_Bits(1),"ITESimp_0",Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("not_bool.0",[],[Expr_TApply("eq_bits.0",[1],[Expr_Field(Expr_Var("PSTATE"),"Z");'1'])])]))
   Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"V"),Expr_TApply("and_bits.0",[1],[Expr_Var("ITESimp_0");Expr_TApply("not_bits.0",[1],[Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("eq_bits.0",[64],[Expr_TApply("SignExtend.0",[32;64],[Expr_TApply("add_bits.0",[32],[Expr_Var("Cse0__5");'00000000000000000000000000000001']);64]);Expr_TApply("add_bits.0",[64],[Expr_TApply("add_bits.0",[64],[Expr_TApply("SignExtend.0",[32;64],[Expr_Slices(Expr_Array(Expr_Var("_R"),0),[Slice_LoWd(0,32)]);64]);Expr_TApply("SignExtend.0",[32;64],[Expr_Var("Cse2__5");64])]);'0000000000000000000000000000000000000000000000000000000000000001'])])])])]))
   Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"C"),Expr_TApply("and_bits.0",[1],[Expr_Var("ITESimp_0");Expr_TApply("not_bits.0",[1],[Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("eq_bits.0",[64],[Expr_TApply("ZeroExtend.0",[32;64],[Expr_TApply("add_bits.0",[32],[Expr_Var("Cse0__5");'00000000000000000000000000000001']);64]);Expr_TApply("add_bits.0",[64],[Expr_TApply("add_bits.0",[64],[Expr_TApply("ZeroExtend.0",[32;64],[Expr_Slices(Expr_Array(Expr_Var("_R"),0),[Slice_LoWd(0,32)]);64]);Expr_TApply("ZeroExtend.0",[32;64],[Expr_Var("Cse2__5");64])]);'0000000000000000000000000000000000000000000000000000000000000001'])])])])]))
-  Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"Z"),Expr_TApply("or_bits.0",[1],[Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("eq_bits.0",[32],[Expr_TApply("add_bits.0",[32],[Expr_Var("Cse0__5");'00000000000000000000000000000001']);'00000000000000000000000000000000'])]);Expr_TApply("not_bits.0",[1],[Expr_Var("ITESimp_0")])]))
+  Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"Z"),Expr_TApply("or_bits.0",[1],[Expr_TApply("and_bits.0",[1],[Expr_Var("ITESimp_0");Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("eq_bits.0",[32],[Expr_TApply("add_bits.0",[32],[Expr_Var("Cse0__5");'00000000000000000000000000000001']);'00000000000000000000000000000000'])])]);Expr_TApply("not_bits.0",[1],[Expr_Var("ITESimp_0")])]))
   Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"N"),Expr_TApply("and_bits.0",[1],[Expr_Var("ITESimp_0");Expr_Slices(Expr_TApply("add_bits.0",[32],[Expr_Var("Cse0__5");'00000000000000000000000000000001']),[Slice_LoWd(31,1)])]))
   "0x7a561284"
   Stmt_ConstDecl(Type_Bits(32),"Cse2__5",Expr_TApply("not_bits.0",[32],[Expr_Slices(Expr_Array(Expr_Var("_R"),22),[Slice_LoWd(0,32)])]))
@@ -87178,14 +87178,14 @@ strip opcode information before passing to antlr.
   Stmt_ConstDecl(Type_Bits(1),"ITESimp_0",Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("not_bool.0",[],[Expr_TApply("eq_bits.0",[1],[Expr_Field(Expr_Var("PSTATE"),"Z");'1'])])]))
   Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"V"),Expr_TApply("and_bits.0",[1],[Expr_Var("ITESimp_0");Expr_TApply("not_bits.0",[1],[Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("eq_bits.0",[64],[Expr_TApply("SignExtend.0",[32;64],[Expr_TApply("add_bits.0",[32],[Expr_Var("Cse0__5");'00000000000000000000000000000001']);64]);Expr_TApply("add_bits.0",[64],[Expr_TApply("add_bits.0",[64],[Expr_TApply("SignExtend.0",[32;64],[Expr_Slices(Expr_Array(Expr_Var("_R"),20),[Slice_LoWd(0,32)]);64]);Expr_TApply("SignExtend.0",[32;64],[Expr_Var("Cse2__5");64])]);'0000000000000000000000000000000000000000000000000000000000000001'])])])])]))
   Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"C"),Expr_TApply("and_bits.0",[1],[Expr_Var("ITESimp_0");Expr_TApply("not_bits.0",[1],[Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("eq_bits.0",[64],[Expr_TApply("ZeroExtend.0",[32;64],[Expr_TApply("add_bits.0",[32],[Expr_Var("Cse0__5");'00000000000000000000000000000001']);64]);Expr_TApply("add_bits.0",[64],[Expr_TApply("add_bits.0",[64],[Expr_TApply("ZeroExtend.0",[32;64],[Expr_Slices(Expr_Array(Expr_Var("_R"),20),[Slice_LoWd(0,32)]);64]);Expr_TApply("ZeroExtend.0",[32;64],[Expr_Var("Cse2__5");64])]);'0000000000000000000000000000000000000000000000000000000000000001'])])])])]))
-  Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"Z"),Expr_TApply("or_bits.0",[1],[Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("eq_bits.0",[32],[Expr_TApply("add_bits.0",[32],[Expr_Var("Cse0__5");'00000000000000000000000000000001']);'00000000000000000000000000000000'])]);Expr_TApply("not_bits.0",[1],[Expr_Var("ITESimp_0")])]))
+  Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"Z"),Expr_TApply("or_bits.0",[1],[Expr_TApply("and_bits.0",[1],[Expr_Var("ITESimp_0");Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("eq_bits.0",[32],[Expr_TApply("add_bits.0",[32],[Expr_Var("Cse0__5");'00000000000000000000000000000001']);'00000000000000000000000000000000'])])]);Expr_TApply("not_bits.0",[1],[Expr_Var("ITESimp_0")])]))
   Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"N"),Expr_TApply("and_bits.0",[1],[Expr_Var("ITESimp_0");Expr_Slices(Expr_TApply("add_bits.0",[32],[Expr_Var("Cse0__5");'00000000000000000000000000000001']),[Slice_LoWd(31,1)])]))
   "0x7a569282"
   Stmt_ConstDecl(Type_Bits(32),"Cse2__5",Expr_TApply("not_bits.0",[32],[Expr_Slices(Expr_Array(Expr_Var("_R"),22),[Slice_LoWd(0,32)])]))
   Stmt_ConstDecl(Type_Bits(32),"Cse0__5",Expr_TApply("add_bits.0",[32],[Expr_Slices(Expr_Array(Expr_Var("_R"),20),[Slice_LoWd(0,32)]);Expr_TApply("not_bits.0",[32],[Expr_Slices(Expr_Array(Expr_Var("_R"),22),[Slice_LoWd(0,32)])])]))
   Stmt_ConstDecl(Type_Bits(1),"ITESimp_0",Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("not_bool.0",[],[Expr_TApply("and_bool.0",[],[Expr_TApply("eq_bits.0",[1],[Expr_Field(Expr_Var("PSTATE"),"C");'1']);Expr_TApply("eq_bits.0",[1],[Expr_Field(Expr_Var("PSTATE"),"Z");'0'])])])]))
   Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"V"),Expr_TApply("and_bits.0",[1],[Expr_Var("ITESimp_0");Expr_TApply("not_bits.0",[1],[Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("eq_bits.0",[64],[Expr_TApply("SignExtend.0",[32;64],[Expr_TApply("add_bits.0",[32],[Expr_Var("Cse0__5");'00000000000000000000000000000001']);64]);Expr_TApply("add_bits.0",[64],[Expr_TApply("add_bits.0",[64],[Expr_TApply("SignExtend.0",[32;64],[Expr_Slices(Expr_Array(Expr_Var("_R"),20),[Slice_LoWd(0,32)]);64]);Expr_TApply("SignExtend.0",[32;64],[Expr_Var("Cse2__5");64])]);'0000000000000000000000000000000000000000000000000000000000000001'])])])])]))
-  Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"C"),Expr_TApply("or_bits.0",[1],[Expr_TApply("not_bits.0",[1],[Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("eq_bits.0",[64],[Expr_TApply("ZeroExtend.0",[32;64],[Expr_TApply("add_bits.0",[32],[Expr_Var("Cse0__5");'00000000000000000000000000000001']);64]);Expr_TApply("add_bits.0",[64],[Expr_TApply("add_bits.0",[64],[Expr_TApply("ZeroExtend.0",[32;64],[Expr_Slices(Expr_Array(Expr_Var("_R"),20),[Slice_LoWd(0,32)]);64]);Expr_TApply("ZeroExtend.0",[32;64],[Expr_Var("Cse2__5");64])]);'0000000000000000000000000000000000000000000000000000000000000001'])])])]);Expr_TApply("not_bits.0",[1],[Expr_Var("ITESimp_0")])]))
+  Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"C"),Expr_TApply("or_bits.0",[1],[Expr_TApply("and_bits.0",[1],[Expr_Var("ITESimp_0");Expr_TApply("not_bits.0",[1],[Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("eq_bits.0",[64],[Expr_TApply("ZeroExtend.0",[32;64],[Expr_TApply("add_bits.0",[32],[Expr_Var("Cse0__5");'00000000000000000000000000000001']);64]);Expr_TApply("add_bits.0",[64],[Expr_TApply("add_bits.0",[64],[Expr_TApply("ZeroExtend.0",[32;64],[Expr_Slices(Expr_Array(Expr_Var("_R"),20),[Slice_LoWd(0,32)]);64]);Expr_TApply("ZeroExtend.0",[32;64],[Expr_Var("Cse2__5");64])]);'0000000000000000000000000000000000000000000000000000000000000001'])])])])]);Expr_TApply("not_bits.0",[1],[Expr_Var("ITESimp_0")])]))
   Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"Z"),Expr_TApply("and_bits.0",[1],[Expr_Var("ITESimp_0");Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("eq_bits.0",[32],[Expr_TApply("add_bits.0",[32],[Expr_Var("Cse0__5");'00000000000000000000000000000001']);'00000000000000000000000000000000'])])]))
   Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"N"),Expr_TApply("and_bits.0",[1],[Expr_Var("ITESimp_0");Expr_Slices(Expr_TApply("add_bits.0",[32],[Expr_Var("Cse0__5");'00000000000000000000000000000001']),[Slice_LoWd(31,1)])]))
   "0x7a581060"
@@ -87210,7 +87210,7 @@ strip opcode information before passing to antlr.
   Stmt_ConstDecl(Type_Bits(1),"ITESimp_0",Expr_TApply("and_bits.0",[1],[Expr_Field(Expr_Var("PSTATE"),"C");Expr_TApply("not_bits.0",[1],[Expr_Field(Expr_Var("PSTATE"),"Z")])]))
   Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"V"),Expr_TApply("and_bits.0",[1],[Expr_Var("ITESimp_0");Expr_TApply("not_bits.0",[1],[Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("eq_bits.0",[64],[Expr_TApply("SignExtend.0",[32;64],[Expr_TApply("add_bits.0",[32],[Expr_Var("Cse0__5");'00000000000000000000000000000001']);64]);Expr_TApply("add_bits.0",[64],[Expr_TApply("add_bits.0",[64],[Expr_TApply("SignExtend.0",[32;64],[Expr_Slices(Expr_Array(Expr_Var("_R"),27),[Slice_LoWd(0,32)]);64]);Expr_TApply("SignExtend.0",[32;64],[Expr_Var("Cse2__5");64])]);'0000000000000000000000000000000000000000000000000000000000000001'])])])])]))
   Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"C"),Expr_TApply("and_bits.0",[1],[Expr_Var("ITESimp_0");Expr_TApply("not_bits.0",[1],[Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("eq_bits.0",[64],[Expr_TApply("ZeroExtend.0",[32;64],[Expr_TApply("add_bits.0",[32],[Expr_Var("Cse0__5");'00000000000000000000000000000001']);64]);Expr_TApply("add_bits.0",[64],[Expr_TApply("add_bits.0",[64],[Expr_TApply("ZeroExtend.0",[32;64],[Expr_Slices(Expr_Array(Expr_Var("_R"),27),[Slice_LoWd(0,32)]);64]);Expr_TApply("ZeroExtend.0",[32;64],[Expr_Var("Cse2__5");64])]);'0000000000000000000000000000000000000000000000000000000000000001'])])])])]))
-  Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"Z"),Expr_TApply("or_bits.0",[1],[Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("eq_bits.0",[32],[Expr_TApply("add_bits.0",[32],[Expr_Var("Cse0__5");'00000000000000000000000000000001']);'00000000000000000000000000000000'])]);Expr_TApply("not_bits.0",[1],[Expr_Var("ITESimp_0")])]))
+  Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"Z"),Expr_TApply("or_bits.0",[1],[Expr_TApply("and_bits.0",[1],[Expr_Var("ITESimp_0");Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("eq_bits.0",[32],[Expr_TApply("add_bits.0",[32],[Expr_Var("Cse0__5");'00000000000000000000000000000001']);'00000000000000000000000000000000'])])]);Expr_TApply("not_bits.0",[1],[Expr_Var("ITESimp_0")])]))
   Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"N"),Expr_TApply("and_bits.0",[1],[Expr_Var("ITESimp_0");Expr_Slices(Expr_TApply("add_bits.0",[32],[Expr_Var("Cse0__5");'00000000000000000000000000000001']),[Slice_LoWd(31,1)])]))
   "0x7a590040"
   Stmt_ConstDecl(Type_Bits(32),"Cse2__5",Expr_TApply("not_bits.0",[32],[Expr_Slices(Expr_Array(Expr_Var("_R"),25),[Slice_LoWd(0,32)])]))
@@ -87225,7 +87225,7 @@ strip opcode information before passing to antlr.
   Stmt_ConstDecl(Type_Bits(32),"Cse0__5",Expr_TApply("add_bits.0",[32],[Expr_Slices(Expr_Array(Expr_Var("_R"),20),[Slice_LoWd(0,32)]);Expr_TApply("not_bits.0",[32],[Expr_Slices(Expr_Array(Expr_Var("_R"),25),[Slice_LoWd(0,32)])])]))
   Stmt_ConstDecl(Type_Bits(1),"ITESimp_0",Expr_Field(Expr_Var("PSTATE"),"Z"))
   Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"V"),Expr_TApply("and_bits.0",[1],[Expr_Var("ITESimp_0");Expr_TApply("not_bits.0",[1],[Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("eq_bits.0",[64],[Expr_TApply("SignExtend.0",[32;64],[Expr_TApply("add_bits.0",[32],[Expr_Var("Cse0__5");'00000000000000000000000000000001']);64]);Expr_TApply("add_bits.0",[64],[Expr_TApply("add_bits.0",[64],[Expr_TApply("SignExtend.0",[32;64],[Expr_Slices(Expr_Array(Expr_Var("_R"),20),[Slice_LoWd(0,32)]);64]);Expr_TApply("SignExtend.0",[32;64],[Expr_Var("Cse2__5");64])]);'0000000000000000000000000000000000000000000000000000000000000001'])])])])]))
-  Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"C"),Expr_TApply("or_bits.0",[1],[Expr_TApply("not_bits.0",[1],[Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("eq_bits.0",[64],[Expr_TApply("ZeroExtend.0",[32;64],[Expr_TApply("add_bits.0",[32],[Expr_Var("Cse0__5");'00000000000000000000000000000001']);64]);Expr_TApply("add_bits.0",[64],[Expr_TApply("add_bits.0",[64],[Expr_TApply("ZeroExtend.0",[32;64],[Expr_Slices(Expr_Array(Expr_Var("_R"),20),[Slice_LoWd(0,32)]);64]);Expr_TApply("ZeroExtend.0",[32;64],[Expr_Var("Cse2__5");64])]);'0000000000000000000000000000000000000000000000000000000000000001'])])])]);Expr_TApply("not_bits.0",[1],[Expr_Var("ITESimp_0")])]))
+  Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"C"),Expr_TApply("or_bits.0",[1],[Expr_TApply("and_bits.0",[1],[Expr_Var("ITESimp_0");Expr_TApply("not_bits.0",[1],[Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("eq_bits.0",[64],[Expr_TApply("ZeroExtend.0",[32;64],[Expr_TApply("add_bits.0",[32],[Expr_Var("Cse0__5");'00000000000000000000000000000001']);64]);Expr_TApply("add_bits.0",[64],[Expr_TApply("add_bits.0",[64],[Expr_TApply("ZeroExtend.0",[32;64],[Expr_Slices(Expr_Array(Expr_Var("_R"),20),[Slice_LoWd(0,32)]);64]);Expr_TApply("ZeroExtend.0",[32;64],[Expr_Var("Cse2__5");64])]);'0000000000000000000000000000000000000000000000000000000000000001'])])])])]);Expr_TApply("not_bits.0",[1],[Expr_Var("ITESimp_0")])]))
   Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"Z"),Expr_TApply("and_bits.0",[1],[Expr_Var("ITESimp_0");Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("eq_bits.0",[32],[Expr_TApply("add_bits.0",[32],[Expr_Var("Cse0__5");'00000000000000000000000000000001']);'00000000000000000000000000000000'])])]))
   Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"N"),Expr_TApply("and_bits.0",[1],[Expr_Var("ITESimp_0");Expr_Slices(Expr_TApply("add_bits.0",[32],[Expr_Var("Cse0__5");'00000000000000000000000000000001']),[Slice_LoWd(31,1)])]))
   "0x7a5a8020"
@@ -87242,7 +87242,7 @@ strip opcode information before passing to antlr.
   Stmt_ConstDecl(Type_Bits(1),"ITESimp_0",Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("not_bool.0",[],[Expr_TApply("and_bool.0",[],[Expr_TApply("eq_bits.0",[1],[Expr_Field(Expr_Var("PSTATE"),"N");Expr_Field(Expr_Var("PSTATE"),"V")]);Expr_TApply("eq_bits.0",[1],[Expr_Field(Expr_Var("PSTATE"),"Z");'0'])])])]))
   Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"V"),Expr_TApply("and_bits.0",[1],[Expr_Var("ITESimp_0");Expr_TApply("not_bits.0",[1],[Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("eq_bits.0",[64],[Expr_TApply("SignExtend.0",[32;64],[Expr_TApply("add_bits.0",[32],[Expr_Var("Cse0__5");'00000000000000000000000000000001']);64]);Expr_TApply("add_bits.0",[64],[Expr_TApply("add_bits.0",[64],[Expr_TApply("SignExtend.0",[32;64],[Expr_Slices(Expr_Array(Expr_Var("_R"),25),[Slice_LoWd(0,32)]);64]);Expr_TApply("SignExtend.0",[32;64],[Expr_Var("Cse2__5");64])]);'0000000000000000000000000000000000000000000000000000000000000001'])])])])]))
   Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"C"),Expr_TApply("and_bits.0",[1],[Expr_Var("ITESimp_0");Expr_TApply("not_bits.0",[1],[Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("eq_bits.0",[64],[Expr_TApply("ZeroExtend.0",[32;64],[Expr_TApply("add_bits.0",[32],[Expr_Var("Cse0__5");'00000000000000000000000000000001']);64]);Expr_TApply("add_bits.0",[64],[Expr_TApply("add_bits.0",[64],[Expr_TApply("ZeroExtend.0",[32;64],[Expr_Slices(Expr_Array(Expr_Var("_R"),25),[Slice_LoWd(0,32)]);64]);Expr_TApply("ZeroExtend.0",[32;64],[Expr_Var("Cse2__5");64])]);'0000000000000000000000000000000000000000000000000000000000000001'])])])])]))
-  Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"Z"),Expr_TApply("or_bits.0",[1],[Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("eq_bits.0",[32],[Expr_TApply("add_bits.0",[32],[Expr_Var("Cse0__5");'00000000000000000000000000000001']);'00000000000000000000000000000000'])]);Expr_TApply("not_bits.0",[1],[Expr_Var("ITESimp_0")])]))
+  Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"Z"),Expr_TApply("or_bits.0",[1],[Expr_TApply("and_bits.0",[1],[Expr_Var("ITESimp_0");Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("eq_bits.0",[32],[Expr_TApply("add_bits.0",[32],[Expr_Var("Cse0__5");'00000000000000000000000000000001']);'00000000000000000000000000000000'])])]);Expr_TApply("not_bits.0",[1],[Expr_Var("ITESimp_0")])]))
   Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"N"),Expr_TApply("and_bits.0",[1],[Expr_Var("ITESimp_0");Expr_Slices(Expr_TApply("add_bits.0",[32],[Expr_Var("Cse0__5");'00000000000000000000000000000001']),[Slice_LoWd(31,1)])]))
   "0x7a5c0364"
   Stmt_ConstDecl(Type_Bits(32),"Cse2__5",Expr_TApply("not_bits.0",[32],[Expr_Slices(Expr_Array(Expr_Var("_R"),28),[Slice_LoWd(0,32)])]))
@@ -87250,7 +87250,7 @@ strip opcode information before passing to antlr.
   Stmt_ConstDecl(Type_Bits(1),"ITESimp_0",Expr_Field(Expr_Var("PSTATE"),"Z"))
   Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"V"),Expr_TApply("and_bits.0",[1],[Expr_Var("ITESimp_0");Expr_TApply("not_bits.0",[1],[Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("eq_bits.0",[64],[Expr_TApply("SignExtend.0",[32;64],[Expr_TApply("add_bits.0",[32],[Expr_Var("Cse0__5");'00000000000000000000000000000001']);64]);Expr_TApply("add_bits.0",[64],[Expr_TApply("add_bits.0",[64],[Expr_TApply("SignExtend.0",[32;64],[Expr_Slices(Expr_Array(Expr_Var("_R"),27),[Slice_LoWd(0,32)]);64]);Expr_TApply("SignExtend.0",[32;64],[Expr_Var("Cse2__5");64])]);'0000000000000000000000000000000000000000000000000000000000000001'])])])])]))
   Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"C"),Expr_TApply("and_bits.0",[1],[Expr_Var("ITESimp_0");Expr_TApply("not_bits.0",[1],[Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("eq_bits.0",[64],[Expr_TApply("ZeroExtend.0",[32;64],[Expr_TApply("add_bits.0",[32],[Expr_Var("Cse0__5");'00000000000000000000000000000001']);64]);Expr_TApply("add_bits.0",[64],[Expr_TApply("add_bits.0",[64],[Expr_TApply("ZeroExtend.0",[32;64],[Expr_Slices(Expr_Array(Expr_Var("_R"),27),[Slice_LoWd(0,32)]);64]);Expr_TApply("ZeroExtend.0",[32;64],[Expr_Var("Cse2__5");64])]);'0000000000000000000000000000000000000000000000000000000000000001'])])])])]))
-  Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"Z"),Expr_TApply("or_bits.0",[1],[Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("eq_bits.0",[32],[Expr_TApply("add_bits.0",[32],[Expr_Var("Cse0__5");'00000000000000000000000000000001']);'00000000000000000000000000000000'])]);Expr_TApply("not_bits.0",[1],[Expr_Var("ITESimp_0")])]))
+  Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"Z"),Expr_TApply("or_bits.0",[1],[Expr_TApply("and_bits.0",[1],[Expr_Var("ITESimp_0");Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("eq_bits.0",[32],[Expr_TApply("add_bits.0",[32],[Expr_Var("Cse0__5");'00000000000000000000000000000001']);'00000000000000000000000000000000'])])]);Expr_TApply("not_bits.0",[1],[Expr_Var("ITESimp_0")])]))
   Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"N"),Expr_TApply("and_bits.0",[1],[Expr_Var("ITESimp_0");Expr_Slices(Expr_TApply("add_bits.0",[32],[Expr_Var("Cse0__5");'00000000000000000000000000000001']),[Slice_LoWd(31,1)])]))
   "0x7a5f1820"
   Stmt_ConstDecl(Type_Bits(32),"Cse0__5",Expr_TApply("add_bits.0",[32],[Expr_Slices(Expr_Array(Expr_Var("_R"),1),[Slice_LoWd(0,32)]);'11111111111111111111111111100001']))
@@ -148591,14 +148591,14 @@ strip opcode information before passing to antlr.
   Stmt_ConstDecl(Type_Bits(1),"ITESimp_0",Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("not_bool.0",[],[Expr_TApply("eq_bits.0",[1],[Expr_Field(Expr_Var("PSTATE"),"Z");'1'])])]))
   Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"V"),Expr_TApply("and_bits.0",[1],[Expr_Var("ITESimp_0");Expr_TApply("not_bits.0",[1],[Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("eq_bits.0",[128],[Expr_TApply("SignExtend.0",[64;128],[Expr_Var("Cse0__5");128]);Expr_TApply("add_bits.0",[128],[Expr_TApply("SignExtend.0",[64;128],[Expr_Array(Expr_Var("_R"),0);128]);'00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001'])])])])]))
   Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"C"),Expr_TApply("and_bits.0",[1],[Expr_Var("ITESimp_0");Expr_TApply("not_bits.0",[1],[Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("eq_bits.0",[128],[Expr_TApply("ZeroExtend.0",[64;128],[Expr_Var("Cse0__5");128]);Expr_TApply("add_bits.0",[128],[Expr_TApply("ZeroExtend.0",[64;128],[Expr_Array(Expr_Var("_R"),0);128]);'00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001'])])])])]))
-  Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"Z"),Expr_TApply("or_bits.0",[1],[Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("eq_bits.0",[64],[Expr_Var("Cse0__5");'0000000000000000000000000000000000000000000000000000000000000000'])]);Expr_TApply("not_bits.0",[1],[Expr_Var("ITESimp_0")])]))
+  Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"Z"),Expr_TApply("or_bits.0",[1],[Expr_TApply("and_bits.0",[1],[Expr_Var("ITESimp_0");Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("eq_bits.0",[64],[Expr_Var("Cse0__5");'0000000000000000000000000000000000000000000000000000000000000000'])])]);Expr_TApply("not_bits.0",[1],[Expr_Var("ITESimp_0")])]))
   Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"N"),Expr_TApply("and_bits.0",[1],[Expr_Var("ITESimp_0");Expr_Slices(Expr_Var("Cse0__5"),[Slice_LoWd(63,1)])]))
   "0xba411a64"
   Stmt_ConstDecl(Type_Bits(64),"Cse0__5",Expr_TApply("add_bits.0",[64],[Expr_Array(Expr_Var("_R"),19);'0000000000000000000000000000000000000000000000000000000000000001']))
   Stmt_ConstDecl(Type_Bits(1),"ITESimp_0",Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("not_bool.0",[],[Expr_TApply("eq_bits.0",[1],[Expr_Field(Expr_Var("PSTATE"),"Z");'1'])])]))
   Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"V"),Expr_TApply("and_bits.0",[1],[Expr_Var("ITESimp_0");Expr_TApply("not_bits.0",[1],[Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("eq_bits.0",[128],[Expr_TApply("SignExtend.0",[64;128],[Expr_Var("Cse0__5");128]);Expr_TApply("add_bits.0",[128],[Expr_TApply("SignExtend.0",[64;128],[Expr_Array(Expr_Var("_R"),19);128]);'00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001'])])])])]))
   Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"C"),Expr_TApply("and_bits.0",[1],[Expr_Var("ITESimp_0");Expr_TApply("not_bits.0",[1],[Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("eq_bits.0",[128],[Expr_TApply("ZeroExtend.0",[64;128],[Expr_Var("Cse0__5");128]);Expr_TApply("add_bits.0",[128],[Expr_TApply("ZeroExtend.0",[64;128],[Expr_Array(Expr_Var("_R"),19);128]);'00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001'])])])])]))
-  Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"Z"),Expr_TApply("or_bits.0",[1],[Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("eq_bits.0",[64],[Expr_Var("Cse0__5");'0000000000000000000000000000000000000000000000000000000000000000'])]);Expr_TApply("not_bits.0",[1],[Expr_Var("ITESimp_0")])]))
+  Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"Z"),Expr_TApply("or_bits.0",[1],[Expr_TApply("and_bits.0",[1],[Expr_Var("ITESimp_0");Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("eq_bits.0",[64],[Expr_Var("Cse0__5");'0000000000000000000000000000000000000000000000000000000000000000'])])]);Expr_TApply("not_bits.0",[1],[Expr_Var("ITESimp_0")])]))
   Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"N"),Expr_TApply("and_bits.0",[1],[Expr_Var("ITESimp_0");Expr_Slices(Expr_Var("Cse0__5"),[Slice_LoWd(63,1)])]))
   "0xbd000680"
   Stmt_TCall("Mem.set.0",[4],[Expr_TApply("add_bits.0",[64],[Expr_Array(Expr_Var("_R"),20);'0000000000000000000000000000000000000000000000000000000000000100']);4;1;Expr_Slices(Expr_Array(Expr_Var("_Z"),0),[Slice_LoWd(0,32)])])
@@ -161950,7 +161950,7 @@ strip opcode information before passing to antlr.
   Stmt_ConstDecl(Type_Bits(1),"ITESimp_0",Expr_Field(Expr_Var("PSTATE"),"Z"))
   Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"V"),'0')
   Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"C"),Expr_Var("ITESimp_0"))
-  Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"Z"),Expr_TApply("or_bits.0",[1],[Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("eq_bits.0",[64],[Expr_Array(Expr_Var("_R"),1);'0000000000000000000000000000000000000000000000000000000000000000'])]);Expr_TApply("not_bits.0",[1],[Expr_Var("ITESimp_0")])]))
+  Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"Z"),Expr_TApply("or_bits.0",[1],[Expr_TApply("and_bits.0",[1],[Expr_Var("ITESimp_0");Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("eq_bits.0",[64],[Expr_Array(Expr_Var("_R"),1);'0000000000000000000000000000000000000000000000000000000000000000'])])]);Expr_TApply("not_bits.0",[1],[Expr_Var("ITESimp_0")])]))
   Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"N"),Expr_TApply("and_bits.0",[1],[Expr_Var("ITESimp_0");Expr_Slices(Expr_Array(Expr_Var("_R"),1),[Slice_LoWd(63,1)])]))
   "0xfa400840"
   Stmt_ConstDecl(Type_Bits(1),"ITESimp_0",Expr_Field(Expr_Var("PSTATE"),"Z"))
@@ -161962,31 +161962,31 @@ strip opcode information before passing to antlr.
   Stmt_ConstDecl(Type_Bits(1),"ITESimp_0",Expr_Field(Expr_Var("PSTATE"),"Z"))
   Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"V"),'0')
   Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"C"),Expr_Var("ITESimp_0"))
-  Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"Z"),Expr_TApply("or_bits.0",[1],[Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("eq_bits.0",[64],[Expr_Array(Expr_Var("_R"),3);'0000000000000000000000000000000000000000000000000000000000000000'])]);Expr_TApply("not_bits.0",[1],[Expr_Var("ITESimp_0")])]))
+  Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"Z"),Expr_TApply("or_bits.0",[1],[Expr_TApply("and_bits.0",[1],[Expr_Var("ITESimp_0");Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("eq_bits.0",[64],[Expr_Array(Expr_Var("_R"),3);'0000000000000000000000000000000000000000000000000000000000000000'])])]);Expr_TApply("not_bits.0",[1],[Expr_Var("ITESimp_0")])]))
   Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"N"),Expr_TApply("and_bits.0",[1],[Expr_Var("ITESimp_0");Expr_Slices(Expr_Array(Expr_Var("_R"),3),[Slice_LoWd(63,1)])]))
   "0xfa400a64"
   Stmt_ConstDecl(Type_Bits(1),"ITESimp_0",Expr_Field(Expr_Var("PSTATE"),"Z"))
   Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"V"),'0')
   Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"C"),Expr_Var("ITESimp_0"))
-  Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"Z"),Expr_TApply("or_bits.0",[1],[Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("eq_bits.0",[64],[Expr_Array(Expr_Var("_R"),19);'0000000000000000000000000000000000000000000000000000000000000000'])]);Expr_TApply("not_bits.0",[1],[Expr_Var("ITESimp_0")])]))
+  Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"Z"),Expr_TApply("or_bits.0",[1],[Expr_TApply("and_bits.0",[1],[Expr_Var("ITESimp_0");Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("eq_bits.0",[64],[Expr_Array(Expr_Var("_R"),19);'0000000000000000000000000000000000000000000000000000000000000000'])])]);Expr_TApply("not_bits.0",[1],[Expr_Var("ITESimp_0")])]))
   Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"N"),Expr_TApply("and_bits.0",[1],[Expr_Var("ITESimp_0");Expr_Slices(Expr_Array(Expr_Var("_R"),19),[Slice_LoWd(63,1)])]))
   "0xfa400a84"
   Stmt_ConstDecl(Type_Bits(1),"ITESimp_0",Expr_Field(Expr_Var("PSTATE"),"Z"))
   Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"V"),'0')
   Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"C"),Expr_Var("ITESimp_0"))
-  Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"Z"),Expr_TApply("or_bits.0",[1],[Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("eq_bits.0",[64],[Expr_Array(Expr_Var("_R"),20);'0000000000000000000000000000000000000000000000000000000000000000'])]);Expr_TApply("not_bits.0",[1],[Expr_Var("ITESimp_0")])]))
+  Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"Z"),Expr_TApply("or_bits.0",[1],[Expr_TApply("and_bits.0",[1],[Expr_Var("ITESimp_0");Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("eq_bits.0",[64],[Expr_Array(Expr_Var("_R"),20);'0000000000000000000000000000000000000000000000000000000000000000'])])]);Expr_TApply("not_bits.0",[1],[Expr_Var("ITESimp_0")])]))
   Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"N"),Expr_TApply("and_bits.0",[1],[Expr_Var("ITESimp_0");Expr_Slices(Expr_Array(Expr_Var("_R"),20),[Slice_LoWd(63,1)])]))
   "0xfa400aa4"
   Stmt_ConstDecl(Type_Bits(1),"ITESimp_0",Expr_Field(Expr_Var("PSTATE"),"Z"))
   Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"V"),'0')
   Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"C"),Expr_Var("ITESimp_0"))
-  Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"Z"),Expr_TApply("or_bits.0",[1],[Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("eq_bits.0",[64],[Expr_Array(Expr_Var("_R"),21);'0000000000000000000000000000000000000000000000000000000000000000'])]);Expr_TApply("not_bits.0",[1],[Expr_Var("ITESimp_0")])]))
+  Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"Z"),Expr_TApply("or_bits.0",[1],[Expr_TApply("and_bits.0",[1],[Expr_Var("ITESimp_0");Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("eq_bits.0",[64],[Expr_Array(Expr_Var("_R"),21);'0000000000000000000000000000000000000000000000000000000000000000'])])]);Expr_TApply("not_bits.0",[1],[Expr_Var("ITESimp_0")])]))
   Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"N"),Expr_TApply("and_bits.0",[1],[Expr_Var("ITESimp_0");Expr_Slices(Expr_Array(Expr_Var("_R"),21),[Slice_LoWd(63,1)])]))
   "0xfa400b04"
   Stmt_ConstDecl(Type_Bits(1),"ITESimp_0",Expr_Field(Expr_Var("PSTATE"),"Z"))
   Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"V"),'0')
   Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"C"),Expr_Var("ITESimp_0"))
-  Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"Z"),Expr_TApply("or_bits.0",[1],[Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("eq_bits.0",[64],[Expr_Array(Expr_Var("_R"),24);'0000000000000000000000000000000000000000000000000000000000000000'])]);Expr_TApply("not_bits.0",[1],[Expr_Var("ITESimp_0")])]))
+  Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"Z"),Expr_TApply("or_bits.0",[1],[Expr_TApply("and_bits.0",[1],[Expr_Var("ITESimp_0");Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("eq_bits.0",[64],[Expr_Array(Expr_Var("_R"),24);'0000000000000000000000000000000000000000000000000000000000000000'])])]);Expr_TApply("not_bits.0",[1],[Expr_Var("ITESimp_0")])]))
   Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"N"),Expr_TApply("and_bits.0",[1],[Expr_Var("ITESimp_0");Expr_Slices(Expr_Array(Expr_Var("_R"),24),[Slice_LoWd(63,1)])]))
   "0xfa401040"
   Stmt_ConstDecl(Type_Bits(64),"Cse2__5",Expr_TApply("not_bits.0",[64],[Expr_Array(Expr_Var("_R"),0)]))
@@ -162000,55 +162000,55 @@ strip opcode information before passing to antlr.
   Stmt_ConstDecl(Type_Bits(1),"ITESimp_0",Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("not_bool.0",[],[Expr_TApply("eq_bits.0",[1],[Expr_Field(Expr_Var("PSTATE"),"Z");'1'])])]))
   Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"V"),'0')
   Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"C"),Expr_Var("ITESimp_0"))
-  Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"Z"),Expr_TApply("or_bits.0",[1],[Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("eq_bits.0",[64],[Expr_Array(Expr_Var("_R"),0);'0000000000000000000000000000000000000000000000000000000000000000'])]);Expr_TApply("not_bits.0",[1],[Expr_Var("ITESimp_0")])]))
+  Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"Z"),Expr_TApply("or_bits.0",[1],[Expr_TApply("and_bits.0",[1],[Expr_Var("ITESimp_0");Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("eq_bits.0",[64],[Expr_Array(Expr_Var("_R"),0);'0000000000000000000000000000000000000000000000000000000000000000'])])]);Expr_TApply("not_bits.0",[1],[Expr_Var("ITESimp_0")])]))
   Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"N"),Expr_TApply("and_bits.0",[1],[Expr_Var("ITESimp_0");Expr_Slices(Expr_Array(Expr_Var("_R"),0),[Slice_LoWd(63,1)])]))
   "0xfa401824"
   Stmt_ConstDecl(Type_Bits(1),"ITESimp_0",Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("not_bool.0",[],[Expr_TApply("eq_bits.0",[1],[Expr_Field(Expr_Var("PSTATE"),"Z");'1'])])]))
   Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"V"),'0')
   Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"C"),Expr_Var("ITESimp_0"))
-  Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"Z"),Expr_TApply("or_bits.0",[1],[Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("eq_bits.0",[64],[Expr_Array(Expr_Var("_R"),1);'0000000000000000000000000000000000000000000000000000000000000000'])]);Expr_TApply("not_bits.0",[1],[Expr_Var("ITESimp_0")])]))
+  Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"Z"),Expr_TApply("or_bits.0",[1],[Expr_TApply("and_bits.0",[1],[Expr_Var("ITESimp_0");Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("eq_bits.0",[64],[Expr_Array(Expr_Var("_R"),1);'0000000000000000000000000000000000000000000000000000000000000000'])])]);Expr_TApply("not_bits.0",[1],[Expr_Var("ITESimp_0")])]))
   Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"N"),Expr_TApply("and_bits.0",[1],[Expr_Var("ITESimp_0");Expr_Slices(Expr_Array(Expr_Var("_R"),1),[Slice_LoWd(63,1)])]))
   "0xfa401844"
   Stmt_ConstDecl(Type_Bits(1),"ITESimp_0",Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("not_bool.0",[],[Expr_TApply("eq_bits.0",[1],[Expr_Field(Expr_Var("PSTATE"),"Z");'1'])])]))
   Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"V"),'0')
   Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"C"),Expr_Var("ITESimp_0"))
-  Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"Z"),Expr_TApply("or_bits.0",[1],[Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("eq_bits.0",[64],[Expr_Array(Expr_Var("_R"),2);'0000000000000000000000000000000000000000000000000000000000000000'])]);Expr_TApply("not_bits.0",[1],[Expr_Var("ITESimp_0")])]))
+  Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"Z"),Expr_TApply("or_bits.0",[1],[Expr_TApply("and_bits.0",[1],[Expr_Var("ITESimp_0");Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("eq_bits.0",[64],[Expr_Array(Expr_Var("_R"),2);'0000000000000000000000000000000000000000000000000000000000000000'])])]);Expr_TApply("not_bits.0",[1],[Expr_Var("ITESimp_0")])]))
   Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"N"),Expr_TApply("and_bits.0",[1],[Expr_Var("ITESimp_0");Expr_Slices(Expr_Array(Expr_Var("_R"),2),[Slice_LoWd(63,1)])]))
   "0xfa401864"
   Stmt_ConstDecl(Type_Bits(1),"ITESimp_0",Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("not_bool.0",[],[Expr_TApply("eq_bits.0",[1],[Expr_Field(Expr_Var("PSTATE"),"Z");'1'])])]))
   Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"V"),'0')
   Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"C"),Expr_Var("ITESimp_0"))
-  Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"Z"),Expr_TApply("or_bits.0",[1],[Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("eq_bits.0",[64],[Expr_Array(Expr_Var("_R"),3);'0000000000000000000000000000000000000000000000000000000000000000'])]);Expr_TApply("not_bits.0",[1],[Expr_Var("ITESimp_0")])]))
+  Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"Z"),Expr_TApply("or_bits.0",[1],[Expr_TApply("and_bits.0",[1],[Expr_Var("ITESimp_0");Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("eq_bits.0",[64],[Expr_Array(Expr_Var("_R"),3);'0000000000000000000000000000000000000000000000000000000000000000'])])]);Expr_TApply("not_bits.0",[1],[Expr_Var("ITESimp_0")])]))
   Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"N"),Expr_TApply("and_bits.0",[1],[Expr_Var("ITESimp_0");Expr_Slices(Expr_Array(Expr_Var("_R"),3),[Slice_LoWd(63,1)])]))
   "0xfa401a84"
   Stmt_ConstDecl(Type_Bits(1),"ITESimp_0",Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("not_bool.0",[],[Expr_TApply("eq_bits.0",[1],[Expr_Field(Expr_Var("PSTATE"),"Z");'1'])])]))
   Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"V"),'0')
   Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"C"),Expr_Var("ITESimp_0"))
-  Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"Z"),Expr_TApply("or_bits.0",[1],[Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("eq_bits.0",[64],[Expr_Array(Expr_Var("_R"),20);'0000000000000000000000000000000000000000000000000000000000000000'])]);Expr_TApply("not_bits.0",[1],[Expr_Var("ITESimp_0")])]))
+  Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"Z"),Expr_TApply("or_bits.0",[1],[Expr_TApply("and_bits.0",[1],[Expr_Var("ITESimp_0");Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("eq_bits.0",[64],[Expr_Array(Expr_Var("_R"),20);'0000000000000000000000000000000000000000000000000000000000000000'])])]);Expr_TApply("not_bits.0",[1],[Expr_Var("ITESimp_0")])]))
   Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"N"),Expr_TApply("and_bits.0",[1],[Expr_Var("ITESimp_0");Expr_Slices(Expr_Array(Expr_Var("_R"),20),[Slice_LoWd(63,1)])]))
   "0xfa401aa4"
   Stmt_ConstDecl(Type_Bits(1),"ITESimp_0",Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("not_bool.0",[],[Expr_TApply("eq_bits.0",[1],[Expr_Field(Expr_Var("PSTATE"),"Z");'1'])])]))
   Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"V"),'0')
   Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"C"),Expr_Var("ITESimp_0"))
-  Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"Z"),Expr_TApply("or_bits.0",[1],[Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("eq_bits.0",[64],[Expr_Array(Expr_Var("_R"),21);'0000000000000000000000000000000000000000000000000000000000000000'])]);Expr_TApply("not_bits.0",[1],[Expr_Var("ITESimp_0")])]))
+  Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"Z"),Expr_TApply("or_bits.0",[1],[Expr_TApply("and_bits.0",[1],[Expr_Var("ITESimp_0");Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("eq_bits.0",[64],[Expr_Array(Expr_Var("_R"),21);'0000000000000000000000000000000000000000000000000000000000000000'])])]);Expr_TApply("not_bits.0",[1],[Expr_Var("ITESimp_0")])]))
   Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"N"),Expr_TApply("and_bits.0",[1],[Expr_Var("ITESimp_0");Expr_Slices(Expr_Array(Expr_Var("_R"),21),[Slice_LoWd(63,1)])]))
   "0xfa401ac4"
   Stmt_ConstDecl(Type_Bits(1),"ITESimp_0",Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("not_bool.0",[],[Expr_TApply("eq_bits.0",[1],[Expr_Field(Expr_Var("PSTATE"),"Z");'1'])])]))
   Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"V"),'0')
   Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"C"),Expr_Var("ITESimp_0"))
-  Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"Z"),Expr_TApply("or_bits.0",[1],[Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("eq_bits.0",[64],[Expr_Array(Expr_Var("_R"),22);'0000000000000000000000000000000000000000000000000000000000000000'])]);Expr_TApply("not_bits.0",[1],[Expr_Var("ITESimp_0")])]))
+  Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"Z"),Expr_TApply("or_bits.0",[1],[Expr_TApply("and_bits.0",[1],[Expr_Var("ITESimp_0");Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("eq_bits.0",[64],[Expr_Array(Expr_Var("_R"),22);'0000000000000000000000000000000000000000000000000000000000000000'])])]);Expr_TApply("not_bits.0",[1],[Expr_Var("ITESimp_0")])]))
   Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"N"),Expr_TApply("and_bits.0",[1],[Expr_Var("ITESimp_0");Expr_Slices(Expr_Array(Expr_Var("_R"),22),[Slice_LoWd(63,1)])]))
   "0xfa401ae4"
   Stmt_ConstDecl(Type_Bits(1),"ITESimp_0",Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("not_bool.0",[],[Expr_TApply("eq_bits.0",[1],[Expr_Field(Expr_Var("PSTATE"),"Z");'1'])])]))
   Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"V"),'0')
   Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"C"),Expr_Var("ITESimp_0"))
-  Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"Z"),Expr_TApply("or_bits.0",[1],[Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("eq_bits.0",[64],[Expr_Array(Expr_Var("_R"),23);'0000000000000000000000000000000000000000000000000000000000000000'])]);Expr_TApply("not_bits.0",[1],[Expr_Var("ITESimp_0")])]))
+  Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"Z"),Expr_TApply("or_bits.0",[1],[Expr_TApply("and_bits.0",[1],[Expr_Var("ITESimp_0");Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("eq_bits.0",[64],[Expr_Array(Expr_Var("_R"),23);'0000000000000000000000000000000000000000000000000000000000000000'])])]);Expr_TApply("not_bits.0",[1],[Expr_Var("ITESimp_0")])]))
   Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"N"),Expr_TApply("and_bits.0",[1],[Expr_Var("ITESimp_0");Expr_Slices(Expr_Array(Expr_Var("_R"),23),[Slice_LoWd(63,1)])]))
   "0xfa401b24"
   Stmt_ConstDecl(Type_Bits(1),"ITESimp_0",Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("not_bool.0",[],[Expr_TApply("eq_bits.0",[1],[Expr_Field(Expr_Var("PSTATE"),"Z");'1'])])]))
   Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"V"),'0')
   Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"C"),Expr_Var("ITESimp_0"))
-  Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"Z"),Expr_TApply("or_bits.0",[1],[Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("eq_bits.0",[64],[Expr_Array(Expr_Var("_R"),25);'0000000000000000000000000000000000000000000000000000000000000000'])]);Expr_TApply("not_bits.0",[1],[Expr_Var("ITESimp_0")])]))
+  Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"Z"),Expr_TApply("or_bits.0",[1],[Expr_TApply("and_bits.0",[1],[Expr_Var("ITESimp_0");Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("eq_bits.0",[64],[Expr_Array(Expr_Var("_R"),25);'0000000000000000000000000000000000000000000000000000000000000000'])])]);Expr_TApply("not_bits.0",[1],[Expr_Var("ITESimp_0")])]))
   Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"N"),Expr_TApply("and_bits.0",[1],[Expr_Var("ITESimp_0");Expr_Slices(Expr_Array(Expr_Var("_R"),25),[Slice_LoWd(63,1)])]))
   "0xfa408260"
   Stmt_ConstDecl(Type_Bits(64),"Cse2__5",Expr_TApply("not_bits.0",[64],[Expr_Array(Expr_Var("_R"),0)]))
@@ -162070,7 +162070,7 @@ strip opcode information before passing to antlr.
   Stmt_ConstDecl(Type_Bits(1),"ITESimp_0",Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("eq_bits.0",[1],[Expr_Field(Expr_Var("PSTATE"),"N");Expr_Field(Expr_Var("PSTATE"),"V")])]))
   Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"V"),'0')
   Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"C"),Expr_Var("ITESimp_0"))
-  Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"Z"),Expr_TApply("or_bits.0",[1],[Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("eq_bits.0",[64],[Expr_Array(Expr_Var("_R"),0);'0000000000000000000000000000000000000000000000000000000000000000'])]);Expr_TApply("not_bits.0",[1],[Expr_Var("ITESimp_0")])]))
+  Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"Z"),Expr_TApply("or_bits.0",[1],[Expr_TApply("and_bits.0",[1],[Expr_Var("ITESimp_0");Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("eq_bits.0",[64],[Expr_Array(Expr_Var("_R"),0);'0000000000000000000000000000000000000000000000000000000000000000'])])]);Expr_TApply("not_bits.0",[1],[Expr_Var("ITESimp_0")])]))
   Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"N"),Expr_TApply("and_bits.0",[1],[Expr_Var("ITESimp_0");Expr_Slices(Expr_Array(Expr_Var("_R"),0),[Slice_LoWd(63,1)])]))
   "0xfa40a860"
   Stmt_ConstDecl(Type_Bits(1),"ITESimp_0",Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("eq_bits.0",[1],[Expr_Field(Expr_Var("PSTATE"),"N");Expr_Field(Expr_Var("PSTATE"),"V")])]))
@@ -162083,7 +162083,7 @@ strip opcode information before passing to antlr.
   Stmt_ConstDecl(Type_Bits(64),"Cse0__5",Expr_TApply("add_bits.0",[64],[Expr_Array(Expr_Var("_R"),1);Expr_TApply("not_bits.0",[64],[Expr_Array(Expr_Var("_R"),2)])]))
   Stmt_ConstDecl(Type_Bits(1),"ITESimp_0",Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("not_bool.0",[],[Expr_TApply("eq_bits.0",[1],[Expr_Field(Expr_Var("PSTATE"),"Z");'1'])])]))
   Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"V"),Expr_TApply("and_bits.0",[1],[Expr_Var("ITESimp_0");Expr_TApply("not_bits.0",[1],[Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("eq_bits.0",[128],[Expr_TApply("SignExtend.0",[64;128],[Expr_TApply("add_bits.0",[64],[Expr_Var("Cse0__5");'0000000000000000000000000000000000000000000000000000000000000001']);128]);Expr_TApply("add_bits.0",[128],[Expr_TApply("add_bits.0",[128],[Expr_TApply("SignExtend.0",[64;128],[Expr_Array(Expr_Var("_R"),1);128]);Expr_TApply("SignExtend.0",[64;128],[Expr_Var("Cse2__5");128])]);'00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001'])])])])]))
-  Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"C"),Expr_TApply("or_bits.0",[1],[Expr_TApply("not_bits.0",[1],[Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("eq_bits.0",[128],[Expr_TApply("ZeroExtend.0",[64;128],[Expr_TApply("add_bits.0",[64],[Expr_Var("Cse0__5");'0000000000000000000000000000000000000000000000000000000000000001']);128]);Expr_TApply("add_bits.0",[128],[Expr_TApply("add_bits.0",[128],[Expr_TApply("ZeroExtend.0",[64;128],[Expr_Array(Expr_Var("_R"),1);128]);Expr_TApply("ZeroExtend.0",[64;128],[Expr_Var("Cse2__5");128])]);'00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001'])])])]);Expr_TApply("not_bits.0",[1],[Expr_Var("ITESimp_0")])]))
+  Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"C"),Expr_TApply("or_bits.0",[1],[Expr_TApply("and_bits.0",[1],[Expr_Var("ITESimp_0");Expr_TApply("not_bits.0",[1],[Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("eq_bits.0",[128],[Expr_TApply("ZeroExtend.0",[64;128],[Expr_TApply("add_bits.0",[64],[Expr_Var("Cse0__5");'0000000000000000000000000000000000000000000000000000000000000001']);128]);Expr_TApply("add_bits.0",[128],[Expr_TApply("add_bits.0",[128],[Expr_TApply("ZeroExtend.0",[64;128],[Expr_Array(Expr_Var("_R"),1);128]);Expr_TApply("ZeroExtend.0",[64;128],[Expr_Var("Cse2__5");128])]);'00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001'])])])])]);Expr_TApply("not_bits.0",[1],[Expr_Var("ITESimp_0")])]))
   Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"Z"),Expr_TApply("and_bits.0",[1],[Expr_Var("ITESimp_0");Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("eq_bits.0",[64],[Expr_TApply("add_bits.0",[64],[Expr_Var("Cse0__5");'0000000000000000000000000000000000000000000000000000000000000001']);'0000000000000000000000000000000000000000000000000000000000000000'])])]))
   Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"N"),Expr_TApply("and_bits.0",[1],[Expr_Var("ITESimp_0");Expr_Slices(Expr_TApply("add_bits.0",[64],[Expr_Var("Cse0__5");'0000000000000000000000000000000000000000000000000000000000000001']),[Slice_LoWd(63,1)])]))
   "0xfa422082"
@@ -162091,7 +162091,7 @@ strip opcode information before passing to antlr.
   Stmt_ConstDecl(Type_Bits(64),"Cse0__5",Expr_TApply("add_bits.0",[64],[Expr_Array(Expr_Var("_R"),4);Expr_TApply("not_bits.0",[64],[Expr_Array(Expr_Var("_R"),2)])]))
   Stmt_ConstDecl(Type_Bits(1),"ITESimp_0",Expr_Field(Expr_Var("PSTATE"),"C"))
   Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"V"),Expr_TApply("and_bits.0",[1],[Expr_Var("ITESimp_0");Expr_TApply("not_bits.0",[1],[Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("eq_bits.0",[128],[Expr_TApply("SignExtend.0",[64;128],[Expr_TApply("add_bits.0",[64],[Expr_Var("Cse0__5");'0000000000000000000000000000000000000000000000000000000000000001']);128]);Expr_TApply("add_bits.0",[128],[Expr_TApply("add_bits.0",[128],[Expr_TApply("SignExtend.0",[64;128],[Expr_Array(Expr_Var("_R"),4);128]);Expr_TApply("SignExtend.0",[64;128],[Expr_Var("Cse2__5");128])]);'00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001'])])])])]))
-  Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"C"),Expr_TApply("or_bits.0",[1],[Expr_TApply("not_bits.0",[1],[Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("eq_bits.0",[128],[Expr_TApply("ZeroExtend.0",[64;128],[Expr_TApply("add_bits.0",[64],[Expr_Var("Cse0__5");'0000000000000000000000000000000000000000000000000000000000000001']);128]);Expr_TApply("add_bits.0",[128],[Expr_TApply("add_bits.0",[128],[Expr_TApply("ZeroExtend.0",[64;128],[Expr_Array(Expr_Var("_R"),4);128]);Expr_TApply("ZeroExtend.0",[64;128],[Expr_Var("Cse2__5");128])]);'00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001'])])])]);Expr_TApply("not_bits.0",[1],[Expr_Var("ITESimp_0")])]))
+  Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"C"),Expr_TApply("or_bits.0",[1],[Expr_TApply("and_bits.0",[1],[Expr_Var("ITESimp_0");Expr_TApply("not_bits.0",[1],[Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("eq_bits.0",[128],[Expr_TApply("ZeroExtend.0",[64;128],[Expr_TApply("add_bits.0",[64],[Expr_Var("Cse0__5");'0000000000000000000000000000000000000000000000000000000000000001']);128]);Expr_TApply("add_bits.0",[128],[Expr_TApply("add_bits.0",[128],[Expr_TApply("ZeroExtend.0",[64;128],[Expr_Array(Expr_Var("_R"),4);128]);Expr_TApply("ZeroExtend.0",[64;128],[Expr_Var("Cse2__5");128])]);'00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001'])])])])]);Expr_TApply("not_bits.0",[1],[Expr_Var("ITESimp_0")])]))
   Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"Z"),Expr_TApply("and_bits.0",[1],[Expr_Var("ITESimp_0");Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("eq_bits.0",[64],[Expr_TApply("add_bits.0",[64],[Expr_Var("Cse0__5");'0000000000000000000000000000000000000000000000000000000000000001']);'0000000000000000000000000000000000000000000000000000000000000000'])])]))
   Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"N"),Expr_TApply("and_bits.0",[1],[Expr_Var("ITESimp_0");Expr_Slices(Expr_TApply("add_bits.0",[64],[Expr_Var("Cse0__5");'0000000000000000000000000000000000000000000000000000000000000001']),[Slice_LoWd(63,1)])]))
   "0xfa429060"
@@ -162106,7 +162106,7 @@ strip opcode information before passing to antlr.
   Stmt_ConstDecl(Type_Bits(64),"Cse0__5",Expr_TApply("add_bits.0",[64],[Expr_Array(Expr_Var("_R"),23);'1111111111111111111111111111111111111111111111111111111111111110']))
   Stmt_ConstDecl(Type_Bits(1),"ITESimp_0",Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("not_bool.0",[],[Expr_TApply("and_bool.0",[],[Expr_TApply("eq_bits.0",[1],[Expr_Field(Expr_Var("PSTATE"),"C");'1']);Expr_TApply("eq_bits.0",[1],[Expr_Field(Expr_Var("PSTATE"),"Z");'0'])])])]))
   Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"V"),Expr_TApply("and_bits.0",[1],[Expr_Var("ITESimp_0");Expr_TApply("not_bits.0",[1],[Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("eq_bits.0",[128],[Expr_TApply("SignExtend.0",[64;128],[Expr_Var("Cse0__5");128]);Expr_TApply("add_bits.0",[128],[Expr_TApply("SignExtend.0",[64;128],[Expr_Array(Expr_Var("_R"),23);128]);'11111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111110'])])])])]))
-  Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"C"),Expr_TApply("or_bits.0",[1],[Expr_TApply("not_bits.0",[1],[Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("eq_bits.0",[128],[Expr_TApply("ZeroExtend.0",[64;128],[Expr_Var("Cse0__5");128]);Expr_TApply("add_bits.0",[128],[Expr_TApply("ZeroExtend.0",[64;128],[Expr_Array(Expr_Var("_R"),23);128]);'00000000000000000000000000000000000000000000000000000000000000001111111111111111111111111111111111111111111111111111111111111110'])])])]);Expr_TApply("not_bits.0",[1],[Expr_Var("ITESimp_0")])]))
+  Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"C"),Expr_TApply("or_bits.0",[1],[Expr_TApply("and_bits.0",[1],[Expr_Var("ITESimp_0");Expr_TApply("not_bits.0",[1],[Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("eq_bits.0",[128],[Expr_TApply("ZeroExtend.0",[64;128],[Expr_Var("Cse0__5");128]);Expr_TApply("add_bits.0",[128],[Expr_TApply("ZeroExtend.0",[64;128],[Expr_Array(Expr_Var("_R"),23);128]);'00000000000000000000000000000000000000000000000000000000000000001111111111111111111111111111111111111111111111111111111111111110'])])])])]);Expr_TApply("not_bits.0",[1],[Expr_Var("ITESimp_0")])]))
   Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"Z"),Expr_TApply("and_bits.0",[1],[Expr_Var("ITESimp_0");Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("eq_bits.0",[64],[Expr_Var("Cse0__5");'0000000000000000000000000000000000000000000000000000000000000000'])])]))
   Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"N"),Expr_TApply("and_bits.0",[1],[Expr_Var("ITESimp_0");Expr_Slices(Expr_Var("Cse0__5"),[Slice_LoWd(63,1)])]))
   "0xfa431324"
@@ -162115,7 +162115,7 @@ strip opcode information before passing to antlr.
   Stmt_ConstDecl(Type_Bits(1),"ITESimp_0",Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("not_bool.0",[],[Expr_TApply("eq_bits.0",[1],[Expr_Field(Expr_Var("PSTATE"),"Z");'1'])])]))
   Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"V"),Expr_TApply("and_bits.0",[1],[Expr_Var("ITESimp_0");Expr_TApply("not_bits.0",[1],[Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("eq_bits.0",[128],[Expr_TApply("SignExtend.0",[64;128],[Expr_TApply("add_bits.0",[64],[Expr_Var("Cse0__5");'0000000000000000000000000000000000000000000000000000000000000001']);128]);Expr_TApply("add_bits.0",[128],[Expr_TApply("add_bits.0",[128],[Expr_TApply("SignExtend.0",[64;128],[Expr_Array(Expr_Var("_R"),25);128]);Expr_TApply("SignExtend.0",[64;128],[Expr_Var("Cse2__5");128])]);'00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001'])])])])]))
   Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"C"),Expr_TApply("and_bits.0",[1],[Expr_Var("ITESimp_0");Expr_TApply("not_bits.0",[1],[Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("eq_bits.0",[128],[Expr_TApply("ZeroExtend.0",[64;128],[Expr_TApply("add_bits.0",[64],[Expr_Var("Cse0__5");'0000000000000000000000000000000000000000000000000000000000000001']);128]);Expr_TApply("add_bits.0",[128],[Expr_TApply("add_bits.0",[128],[Expr_TApply("ZeroExtend.0",[64;128],[Expr_Array(Expr_Var("_R"),25);128]);Expr_TApply("ZeroExtend.0",[64;128],[Expr_Var("Cse2__5");128])]);'00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001'])])])])]))
-  Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"Z"),Expr_TApply("or_bits.0",[1],[Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("eq_bits.0",[64],[Expr_TApply("add_bits.0",[64],[Expr_Var("Cse0__5");'0000000000000000000000000000000000000000000000000000000000000001']);'0000000000000000000000000000000000000000000000000000000000000000'])]);Expr_TApply("not_bits.0",[1],[Expr_Var("ITESimp_0")])]))
+  Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"Z"),Expr_TApply("or_bits.0",[1],[Expr_TApply("and_bits.0",[1],[Expr_Var("ITESimp_0");Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("eq_bits.0",[64],[Expr_TApply("add_bits.0",[64],[Expr_Var("Cse0__5");'0000000000000000000000000000000000000000000000000000000000000001']);'0000000000000000000000000000000000000000000000000000000000000000'])])]);Expr_TApply("not_bits.0",[1],[Expr_Var("ITESimp_0")])]))
   Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"N"),Expr_TApply("and_bits.0",[1],[Expr_Var("ITESimp_0");Expr_Slices(Expr_TApply("add_bits.0",[64],[Expr_Var("Cse0__5");'0000000000000000000000000000000000000000000000000000000000000001']),[Slice_LoWd(63,1)])]))
   "0xfa4390a0"
   Stmt_ConstDecl(Type_Bits(64),"Cse2__5",Expr_TApply("not_bits.0",[64],[Expr_Array(Expr_Var("_R"),3)]))
@@ -162160,7 +162160,7 @@ strip opcode information before passing to antlr.
   Stmt_ConstDecl(Type_Bits(64),"Cse0__5",Expr_TApply("add_bits.0",[64],[Expr_Array(Expr_Var("_R"),2);Expr_TApply("not_bits.0",[64],[Expr_Array(Expr_Var("_R"),19)])]))
   Stmt_ConstDecl(Type_Bits(1),"ITESimp_0",Expr_Field(Expr_Var("PSTATE"),"C"))
   Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"V"),Expr_TApply("and_bits.0",[1],[Expr_Var("ITESimp_0");Expr_TApply("not_bits.0",[1],[Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("eq_bits.0",[128],[Expr_TApply("SignExtend.0",[64;128],[Expr_TApply("add_bits.0",[64],[Expr_Var("Cse0__5");'0000000000000000000000000000000000000000000000000000000000000001']);128]);Expr_TApply("add_bits.0",[128],[Expr_TApply("add_bits.0",[128],[Expr_TApply("SignExtend.0",[64;128],[Expr_Array(Expr_Var("_R"),2);128]);Expr_TApply("SignExtend.0",[64;128],[Expr_Var("Cse2__5");128])]);'00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001'])])])])]))
-  Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"C"),Expr_TApply("or_bits.0",[1],[Expr_TApply("not_bits.0",[1],[Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("eq_bits.0",[128],[Expr_TApply("ZeroExtend.0",[64;128],[Expr_TApply("add_bits.0",[64],[Expr_Var("Cse0__5");'0000000000000000000000000000000000000000000000000000000000000001']);128]);Expr_TApply("add_bits.0",[128],[Expr_TApply("add_bits.0",[128],[Expr_TApply("ZeroExtend.0",[64;128],[Expr_Array(Expr_Var("_R"),2);128]);Expr_TApply("ZeroExtend.0",[64;128],[Expr_Var("Cse2__5");128])]);'00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001'])])])]);Expr_TApply("not_bits.0",[1],[Expr_Var("ITESimp_0")])]))
+  Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"C"),Expr_TApply("or_bits.0",[1],[Expr_TApply("and_bits.0",[1],[Expr_Var("ITESimp_0");Expr_TApply("not_bits.0",[1],[Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("eq_bits.0",[128],[Expr_TApply("ZeroExtend.0",[64;128],[Expr_TApply("add_bits.0",[64],[Expr_Var("Cse0__5");'0000000000000000000000000000000000000000000000000000000000000001']);128]);Expr_TApply("add_bits.0",[128],[Expr_TApply("add_bits.0",[128],[Expr_TApply("ZeroExtend.0",[64;128],[Expr_Array(Expr_Var("_R"),2);128]);Expr_TApply("ZeroExtend.0",[64;128],[Expr_Var("Cse2__5");128])]);'00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001'])])])])]);Expr_TApply("not_bits.0",[1],[Expr_Var("ITESimp_0")])]))
   Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"Z"),Expr_TApply("and_bits.0",[1],[Expr_Var("ITESimp_0");Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("eq_bits.0",[64],[Expr_TApply("add_bits.0",[64],[Expr_Var("Cse0__5");'0000000000000000000000000000000000000000000000000000000000000001']);'0000000000000000000000000000000000000000000000000000000000000000'])])]))
   Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"N"),Expr_TApply("and_bits.0",[1],[Expr_Var("ITESimp_0");Expr_Slices(Expr_TApply("add_bits.0",[64],[Expr_Var("Cse0__5");'0000000000000000000000000000000000000000000000000000000000000001']),[Slice_LoWd(63,1)])]))
   "0xfa5322e2"
@@ -162168,7 +162168,7 @@ strip opcode information before passing to antlr.
   Stmt_ConstDecl(Type_Bits(64),"Cse0__5",Expr_TApply("add_bits.0",[64],[Expr_Array(Expr_Var("_R"),23);Expr_TApply("not_bits.0",[64],[Expr_Array(Expr_Var("_R"),19)])]))
   Stmt_ConstDecl(Type_Bits(1),"ITESimp_0",Expr_Field(Expr_Var("PSTATE"),"C"))
   Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"V"),Expr_TApply("and_bits.0",[1],[Expr_Var("ITESimp_0");Expr_TApply("not_bits.0",[1],[Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("eq_bits.0",[128],[Expr_TApply("SignExtend.0",[64;128],[Expr_TApply("add_bits.0",[64],[Expr_Var("Cse0__5");'0000000000000000000000000000000000000000000000000000000000000001']);128]);Expr_TApply("add_bits.0",[128],[Expr_TApply("add_bits.0",[128],[Expr_TApply("SignExtend.0",[64;128],[Expr_Array(Expr_Var("_R"),23);128]);Expr_TApply("SignExtend.0",[64;128],[Expr_Var("Cse2__5");128])]);'00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001'])])])])]))
-  Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"C"),Expr_TApply("or_bits.0",[1],[Expr_TApply("not_bits.0",[1],[Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("eq_bits.0",[128],[Expr_TApply("ZeroExtend.0",[64;128],[Expr_TApply("add_bits.0",[64],[Expr_Var("Cse0__5");'0000000000000000000000000000000000000000000000000000000000000001']);128]);Expr_TApply("add_bits.0",[128],[Expr_TApply("add_bits.0",[128],[Expr_TApply("ZeroExtend.0",[64;128],[Expr_Array(Expr_Var("_R"),23);128]);Expr_TApply("ZeroExtend.0",[64;128],[Expr_Var("Cse2__5");128])]);'00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001'])])])]);Expr_TApply("not_bits.0",[1],[Expr_Var("ITESimp_0")])]))
+  Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"C"),Expr_TApply("or_bits.0",[1],[Expr_TApply("and_bits.0",[1],[Expr_Var("ITESimp_0");Expr_TApply("not_bits.0",[1],[Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("eq_bits.0",[128],[Expr_TApply("ZeroExtend.0",[64;128],[Expr_TApply("add_bits.0",[64],[Expr_Var("Cse0__5");'0000000000000000000000000000000000000000000000000000000000000001']);128]);Expr_TApply("add_bits.0",[128],[Expr_TApply("add_bits.0",[128],[Expr_TApply("ZeroExtend.0",[64;128],[Expr_Array(Expr_Var("_R"),23);128]);Expr_TApply("ZeroExtend.0",[64;128],[Expr_Var("Cse2__5");128])]);'00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001'])])])])]);Expr_TApply("not_bits.0",[1],[Expr_Var("ITESimp_0")])]))
   Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"Z"),Expr_TApply("and_bits.0",[1],[Expr_Var("ITESimp_0");Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("eq_bits.0",[64],[Expr_TApply("add_bits.0",[64],[Expr_Var("Cse0__5");'0000000000000000000000000000000000000000000000000000000000000001']);'0000000000000000000000000000000000000000000000000000000000000000'])])]))
   Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"N"),Expr_TApply("and_bits.0",[1],[Expr_Var("ITESimp_0");Expr_Slices(Expr_TApply("add_bits.0",[64],[Expr_Var("Cse0__5");'0000000000000000000000000000000000000000000000000000000000000001']),[Slice_LoWd(63,1)])]))
   "0xfa539020"
@@ -162192,7 +162192,7 @@ strip opcode information before passing to antlr.
   Stmt_ConstDecl(Type_Bits(64),"Cse0__5",Expr_TApply("add_bits.0",[64],[Expr_Array(Expr_Var("_R"),22);Expr_TApply("not_bits.0",[64],[Expr_Array(Expr_Var("_R"),21)])]))
   Stmt_ConstDecl(Type_Bits(1),"ITESimp_0",Expr_Field(Expr_Var("PSTATE"),"Z"))
   Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"V"),Expr_TApply("and_bits.0",[1],[Expr_Var("ITESimp_0");Expr_TApply("not_bits.0",[1],[Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("eq_bits.0",[128],[Expr_TApply("SignExtend.0",[64;128],[Expr_TApply("add_bits.0",[64],[Expr_Var("Cse0__5");'0000000000000000000000000000000000000000000000000000000000000001']);128]);Expr_TApply("add_bits.0",[128],[Expr_TApply("add_bits.0",[128],[Expr_TApply("SignExtend.0",[64;128],[Expr_Array(Expr_Var("_R"),22);128]);Expr_TApply("SignExtend.0",[64;128],[Expr_Var("Cse2__5");128])]);'00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001'])])])])]))
-  Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"C"),Expr_TApply("or_bits.0",[1],[Expr_TApply("not_bits.0",[1],[Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("eq_bits.0",[128],[Expr_TApply("ZeroExtend.0",[64;128],[Expr_TApply("add_bits.0",[64],[Expr_Var("Cse0__5");'0000000000000000000000000000000000000000000000000000000000000001']);128]);Expr_TApply("add_bits.0",[128],[Expr_TApply("add_bits.0",[128],[Expr_TApply("ZeroExtend.0",[64;128],[Expr_Array(Expr_Var("_R"),22);128]);Expr_TApply("ZeroExtend.0",[64;128],[Expr_Var("Cse2__5");128])]);'00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001'])])])]);Expr_TApply("not_bits.0",[1],[Expr_Var("ITESimp_0")])]))
+  Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"C"),Expr_TApply("or_bits.0",[1],[Expr_TApply("and_bits.0",[1],[Expr_Var("ITESimp_0");Expr_TApply("not_bits.0",[1],[Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("eq_bits.0",[128],[Expr_TApply("ZeroExtend.0",[64;128],[Expr_TApply("add_bits.0",[64],[Expr_Var("Cse0__5");'0000000000000000000000000000000000000000000000000000000000000001']);128]);Expr_TApply("add_bits.0",[128],[Expr_TApply("add_bits.0",[128],[Expr_TApply("ZeroExtend.0",[64;128],[Expr_Array(Expr_Var("_R"),22);128]);Expr_TApply("ZeroExtend.0",[64;128],[Expr_Var("Cse2__5");128])]);'00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001'])])])])]);Expr_TApply("not_bits.0",[1],[Expr_Var("ITESimp_0")])]))
   Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"Z"),Expr_TApply("and_bits.0",[1],[Expr_Var("ITESimp_0");Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("eq_bits.0",[64],[Expr_TApply("add_bits.0",[64],[Expr_Var("Cse0__5");'0000000000000000000000000000000000000000000000000000000000000001']);'0000000000000000000000000000000000000000000000000000000000000000'])])]))
   Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"N"),Expr_TApply("and_bits.0",[1],[Expr_Var("ITESimp_0");Expr_Slices(Expr_TApply("add_bits.0",[64],[Expr_Var("Cse0__5");'0000000000000000000000000000000000000000000000000000000000000001']),[Slice_LoWd(63,1)])]))
   "0xfa551360"
@@ -162224,7 +162224,7 @@ strip opcode information before passing to antlr.
   Stmt_ConstDecl(Type_Bits(64),"Cse0__5",Expr_TApply("add_bits.0",[64],[Expr_Array(Expr_Var("_R"),20);Expr_TApply("not_bits.0",[64],[Expr_Array(Expr_Var("_R"),26)])]))
   Stmt_ConstDecl(Type_Bits(1),"ITESimp_0",Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("not_bool.0",[],[Expr_TApply("eq_bits.0",[1],[Expr_Field(Expr_Var("PSTATE"),"C");'1'])])]))
   Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"V"),Expr_TApply("and_bits.0",[1],[Expr_Var("ITESimp_0");Expr_TApply("not_bits.0",[1],[Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("eq_bits.0",[128],[Expr_TApply("SignExtend.0",[64;128],[Expr_TApply("add_bits.0",[64],[Expr_Var("Cse0__5");'0000000000000000000000000000000000000000000000000000000000000001']);128]);Expr_TApply("add_bits.0",[128],[Expr_TApply("add_bits.0",[128],[Expr_TApply("SignExtend.0",[64;128],[Expr_Array(Expr_Var("_R"),20);128]);Expr_TApply("SignExtend.0",[64;128],[Expr_Var("Cse2__5");128])]);'00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001'])])])])]))
-  Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"C"),Expr_TApply("or_bits.0",[1],[Expr_TApply("not_bits.0",[1],[Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("eq_bits.0",[128],[Expr_TApply("ZeroExtend.0",[64;128],[Expr_TApply("add_bits.0",[64],[Expr_Var("Cse0__5");'0000000000000000000000000000000000000000000000000000000000000001']);128]);Expr_TApply("add_bits.0",[128],[Expr_TApply("add_bits.0",[128],[Expr_TApply("ZeroExtend.0",[64;128],[Expr_Array(Expr_Var("_R"),20);128]);Expr_TApply("ZeroExtend.0",[64;128],[Expr_Var("Cse2__5");128])]);'00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001'])])])]);Expr_TApply("not_bits.0",[1],[Expr_Var("ITESimp_0")])]))
+  Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"C"),Expr_TApply("or_bits.0",[1],[Expr_TApply("and_bits.0",[1],[Expr_Var("ITESimp_0");Expr_TApply("not_bits.0",[1],[Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("eq_bits.0",[128],[Expr_TApply("ZeroExtend.0",[64;128],[Expr_TApply("add_bits.0",[64],[Expr_Var("Cse0__5");'0000000000000000000000000000000000000000000000000000000000000001']);128]);Expr_TApply("add_bits.0",[128],[Expr_TApply("add_bits.0",[128],[Expr_TApply("ZeroExtend.0",[64;128],[Expr_Array(Expr_Var("_R"),20);128]);Expr_TApply("ZeroExtend.0",[64;128],[Expr_Var("Cse2__5");128])]);'00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001'])])])])]);Expr_TApply("not_bits.0",[1],[Expr_Var("ITESimp_0")])]))
   Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"Z"),Expr_TApply("and_bits.0",[1],[Expr_Var("ITESimp_0");Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("eq_bits.0",[64],[Expr_TApply("add_bits.0",[64],[Expr_Var("Cse0__5");'0000000000000000000000000000000000000000000000000000000000000001']);'0000000000000000000000000000000000000000000000000000000000000000'])])]))
   Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"N"),Expr_TApply("and_bits.0",[1],[Expr_Var("ITESimp_0");Expr_Slices(Expr_TApply("add_bits.0",[64],[Expr_Var("Cse0__5");'0000000000000000000000000000000000000000000000000000000000000001']),[Slice_LoWd(63,1)])]))
   "0xfc0243e0"
diff --git a/tests/aslt/test_cntlm_vec.t b/tests/aslt/test_cntlm_vec.t
index d153b5ae..5ed9e489 100644
--- a/tests/aslt/test_cntlm_vec.t
+++ b/tests/aslt/test_cntlm_vec.t
@@ -7,129 +7,129 @@
 
   $ cat stmts
   "0x0e011800"
-  Decoding instruction A64 e011800
+  Decoding instruction A64 0x0e011800
   constant bits ( 128 ) Exp8__5 = __array _Z [ 0 ] ;
   constant bits ( 128 ) Exp10__5 = __array _Z [ 1 ] ;
   bits ( 64 ) result__4 ;
   result__4 = shuffle_vec.0 {{ 8,8,8 }} ( Exp10__5 [ 0 +: 64 ],Exp8__5 [ 0 +: 64 ],'0000000000000000000000000000111000000000000000000000000000001100000000000000000000000000000010100000000000000000000000000000100000000000000000000000000000000110000000000000000000000000000001000000000000000000000000000000001000000000000000000000000000000000' ) ;
   __array _Z [ 0 ] = ZeroExtend.0 {{ 64,128 }} ( result__4,128 ) ;
   "0x0e040ea8"
-  Decoding instruction A64 e040ea8
+  Decoding instruction A64 0x0e040ea8
   constant bits ( 64 ) Exp6__5 = __array _R [ 21 ] ;
   bits ( 64 ) result__4 ;
   result__4 = replicate_bits.0 {{ 32,2 }} ( Exp6__5 [ 0 +: 32 ],2 ) ;
   __array _Z [ 8 ] = ZeroExtend.0 {{ 64,128 }} ( result__4,128 ) ;
   "0x0e211c00"
-  Decoding instruction A64 e211c00
+  Decoding instruction A64 0x0e211c00
   __array _Z [ 0 ] = ZeroExtend.0 {{ 64,128 }} ( and_bits.0 {{ 64 }} ( __array _Z [ 0 ] [ 0 +: 64 ],__array _Z [ 1 ] [ 0 +: 64 ] ),128 ) ;
   "0x0ea00800"
-  Decoding instruction A64 ea00800
+  Decoding instruction A64 0x0ea00800
   bits ( 64 ) result__4 ;
   __array _Z [ 0 ] = ZeroExtend.0 {{ 64,128 }} ( Elem.set.0 {{ 64,32 }} ( Elem.set.0 {{ 64,32 }} ( result__4,1,32,Elem.read.0 {{ 64,32 }} ( __array _Z [ 0 ] [ 0 +: 64 ],0,32 ) ),0,32,Elem.read.0 {{ 64,32 }} ( __array _Z [ 0 ] [ 0 +: 64 ],1,32 ) ),128 ) ;
   "0x0ea00801"
-  Decoding instruction A64 ea00801
+  Decoding instruction A64 0x0ea00801
   bits ( 64 ) result__4 ;
   __array _Z [ 1 ] = ZeroExtend.0 {{ 64,128 }} ( Elem.set.0 {{ 64,32 }} ( Elem.set.0 {{ 64,32 }} ( result__4,1,32,Elem.read.0 {{ 64,32 }} ( __array _Z [ 0 ] [ 0 +: 64 ],0,32 ) ),0,32,Elem.read.0 {{ 64,32 }} ( __array _Z [ 0 ] [ 0 +: 64 ],1,32 ) ),128 ) ;
   "0x0ea03020"
-  Decoding instruction A64 ea03020
+  Decoding instruction A64 0x0ea03020
   constant bits ( 128 ) Exp8__5 = __array _Z [ 1 ] ;
   constant bits ( 128 ) Exp11__6 = __array _Z [ 0 ] ;
   bits ( 128 ) result__4 ;
   result__4 = sub_vec.0 {{ 2,64 }} ( trunc_vec.0 {{ 2,64,128 }} ( scast_vec.0 {{ 2,128,64 }} ( Exp8__5 [ 0 +: 128 ],2,128 ),2,64 ),trunc_vec.0 {{ 2,64,128 }} ( scast_vec.0 {{ 2,128,32 }} ( Exp11__6 [ 0 +: 64 ],2,128 ),2,64 ),2 ) ;
   __array _Z [ 0 ] = result__4 ;
   "0x0ea18508"
-  Decoding instruction A64 ea18508
+  Decoding instruction A64 0x0ea18508
   constant bits ( 128 ) Exp7__5 = __array _Z [ 8 ] ;
   constant bits ( 128 ) Exp9__5 = __array _Z [ 1 ] ;
   bits ( 64 ) result__4 ;
   result__4 = add_vec.0 {{ 2,32 }} ( Exp7__5 [ 0 +: 64 ],Exp9__5 [ 0 +: 64 ],2 ) ;
   __array _Z [ 8 ] = ZeroExtend.0 {{ 64,128 }} ( result__4,128 ) ;
   "0x0ea48400"
-  Decoding instruction A64 ea48400
+  Decoding instruction A64 0x0ea48400
   constant bits ( 128 ) Exp7__5 = __array _Z [ 0 ] ;
   constant bits ( 128 ) Exp9__5 = __array _Z [ 4 ] ;
   bits ( 64 ) result__4 ;
   result__4 = add_vec.0 {{ 2,32 }} ( Exp7__5 [ 0 +: 64 ],Exp9__5 [ 0 +: 64 ],2 ) ;
   __array _Z [ 0 ] = ZeroExtend.0 {{ 64,128 }} ( result__4,128 ) ;
   "0x0f000420"
-  Decoding instruction A64 f000420
+  Decoding instruction A64 0x0f000420
   __array _Z [ 0 ] = '00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000001' ;
   "0x0f000428"
-  Decoding instruction A64 f000428
+  Decoding instruction A64 0x0f000428
   __array _Z [ 8 ] = '00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000001' ;
   "0x0f07e7c1"
-  Decoding instruction A64 f07e7c1
+  Decoding instruction A64 0x0f07e7c1
   __array _Z [ 1 ] = '00000000000000000000000000000000000000000000000000000000000000001111111011111110111111101111111011111110111111101111111011111110' ;
   "0x0f20a402"
-  Decoding instruction A64 f20a402
+  Decoding instruction A64 0x0f20a402
   constant bits ( 128 ) Exp9__6 = __array _Z [ 0 ] ;
   bits ( 128 ) result__4 ;
   result__4 = scast_vec.0 {{ 2,64,32 }} ( Exp9__6 [ 0 +: 64 ],2,64 ) ;
   __array _Z [ 2 ] = result__4 ;
   "0x0f20a423"
-  Decoding instruction A64 f20a423
+  Decoding instruction A64 0x0f20a423
   constant bits ( 128 ) Exp9__6 = __array _Z [ 1 ] ;
   bits ( 128 ) result__4 ;
   result__4 = scast_vec.0 {{ 2,64,32 }} ( Exp9__6 [ 0 +: 64 ],2,64 ) ;
   __array _Z [ 3 ] = result__4 ;
   "0x2e200800"
-  Decoding instruction A64 2e200800
+  Decoding instruction A64 0x2e200800
   bits ( 64 ) result__4 ;
   __array _Z [ 0 ] = ZeroExtend.0 {{ 64,128 }} ( Elem.set.0 {{ 64,8 }} ( Elem.set.0 {{ 64,8 }} ( Elem.set.0 {{ 64,8 }} ( Elem.set.0 {{ 64,8 }} ( Elem.set.0 {{ 64,8 }} ( Elem.set.0 {{ 64,8 }} ( Elem.set.0 {{ 64,8 }} ( Elem.set.0 {{ 64,8 }} ( result__4,3,8,Elem.read.0 {{ 64,8 }} ( __array _Z [ 0 ] [ 0 +: 64 ],0,8 ) ),2,8,Elem.read.0 {{ 64,8 }} ( __array _Z [ 0 ] [ 0 +: 64 ],1,8 ) ),1,8,Elem.read.0 {{ 64,8 }} ( __array _Z [ 0 ] [ 0 +: 64 ],2,8 ) ),0,8,Elem.read.0 {{ 64,8 }} ( __array _Z [ 0 ] [ 0 +: 64 ],3,8 ) ),7,8,Elem.read.0 {{ 64,8 }} ( __array _Z [ 0 ] [ 0 +: 64 ],4,8 ) ),6,8,Elem.read.0 {{ 64,8 }} ( __array _Z [ 0 ] [ 0 +: 64 ],5,8 ) ),5,8,Elem.read.0 {{ 64,8 }} ( __array _Z [ 0 ] [ 0 +: 64 ],6,8 ) ),4,8,Elem.read.0 {{ 64,8 }} ( __array _Z [ 0 ] [ 0 +: 64 ],7,8 ) ),128 ) ;
   "0x2e200820"
-  Decoding instruction A64 2e200820
+  Decoding instruction A64 0x2e200820
   bits ( 64 ) result__4 ;
   __array _Z [ 0 ] = ZeroExtend.0 {{ 64,128 }} ( Elem.set.0 {{ 64,8 }} ( Elem.set.0 {{ 64,8 }} ( Elem.set.0 {{ 64,8 }} ( Elem.set.0 {{ 64,8 }} ( Elem.set.0 {{ 64,8 }} ( Elem.set.0 {{ 64,8 }} ( Elem.set.0 {{ 64,8 }} ( Elem.set.0 {{ 64,8 }} ( result__4,3,8,Elem.read.0 {{ 64,8 }} ( __array _Z [ 1 ] [ 0 +: 64 ],0,8 ) ),2,8,Elem.read.0 {{ 64,8 }} ( __array _Z [ 1 ] [ 0 +: 64 ],1,8 ) ),1,8,Elem.read.0 {{ 64,8 }} ( __array _Z [ 1 ] [ 0 +: 64 ],2,8 ) ),0,8,Elem.read.0 {{ 64,8 }} ( __array _Z [ 1 ] [ 0 +: 64 ],3,8 ) ),7,8,Elem.read.0 {{ 64,8 }} ( __array _Z [ 1 ] [ 0 +: 64 ],4,8 ) ),6,8,Elem.read.0 {{ 64,8 }} ( __array _Z [ 1 ] [ 0 +: 64 ],5,8 ) ),5,8,Elem.read.0 {{ 64,8 }} ( __array _Z [ 1 ] [ 0 +: 64 ],6,8 ) ),4,8,Elem.read.0 {{ 64,8 }} ( __array _Z [ 1 ] [ 0 +: 64 ],7,8 ) ),128 ) ;
   "0x2e211c00"
-  Decoding instruction A64 2e211c00
+  Decoding instruction A64 0x2e211c00
   __array _Z [ 0 ] = ZeroExtend.0 {{ 64,128 }} ( eor_bits.0 {{ 64 }} ( __array _Z [ 1 ] [ 0 +: 64 ],eor_bits.0 {{ 64 }} ( '0000000000000000000000000000000000000000000000000000000000000000',__array _Z [ 0 ] [ 0 +: 64 ] ) ),128 ) ;
   "0x2f000400"
-  Decoding instruction A64 2f000400
+  Decoding instruction A64 0x2f000400
   __array _Z [ 0 ] = '00000000000000000000000000000000000000000000000000000000000000001111111111111111111111111111111111111111111111111111111111111111' ;
   "0x2f03d7e0"
-  Decoding instruction A64 2f03d7e0
+  Decoding instruction A64 0x2f03d7e0
   __array _Z [ 0 ] = '00000000000000000000000000000000000000000000000000000000000000001111111110000000000000000000000011111111100000000000000000000000' ;
   "0x2f044400"
-  Decoding instruction A64 2f044400
+  Decoding instruction A64 0x2f044400
   __array _Z [ 0 ] = '00000000000000000000000000000000000000000000000000000000000000001111111101111111111111111111111111111111011111111111111111111111' ;
   "0x2f280400"
-  Decoding instruction A64 2f280400
+  Decoding instruction A64 0x2f280400
   constant bits ( 128 ) Exp7__5 = __array _Z [ 0 ] ;
   bits ( 64 ) result__4 ;
   result__4 = add_vec.0 {{ 2,32 }} ( '0000000000000000000000000000000000000000000000000000000000000000',trunc_vec.0 {{ 2,32,64 }} ( asr_vec.0 {{ 2,64 }} ( zcast_vec.0 {{ 2,64,32 }} ( Exp7__5 [ 0 +: 64 ],2,64 ),scast_vec.0 {{ 2,64,16 }} ( replicate_bits.0 {{ 16,2 }} ( '0000000000011000',2 ),2,64 ),2 ),2,32 ),2 ) ;
   __array _Z [ 0 ] = ZeroExtend.0 {{ 64,128 }} ( result__4,128 ) ;
   "0x2f280424"
-  Decoding instruction A64 2f280424
+  Decoding instruction A64 0x2f280424
   constant bits ( 128 ) Exp7__5 = __array _Z [ 1 ] ;
   bits ( 64 ) result__4 ;
   result__4 = add_vec.0 {{ 2,32 }} ( '0000000000000000000000000000000000000000000000000000000000000000',trunc_vec.0 {{ 2,32,64 }} ( asr_vec.0 {{ 2,64 }} ( zcast_vec.0 {{ 2,64,32 }} ( Exp7__5 [ 0 +: 64 ],2,64 ),scast_vec.0 {{ 2,64,16 }} ( replicate_bits.0 {{ 16,2 }} ( '0000000000011000',2 ),2,64 ),2 ),2,32 ),2 ) ;
   __array _Z [ 4 ] = ZeroExtend.0 {{ 64,128 }} ( result__4,128 ) ;
   "0x2f300423"
-  Decoding instruction A64 2f300423
+  Decoding instruction A64 0x2f300423
   constant bits ( 128 ) Exp7__5 = __array _Z [ 1 ] ;
   bits ( 64 ) result__4 ;
   result__4 = add_vec.0 {{ 2,32 }} ( '0000000000000000000000000000000000000000000000000000000000000000',trunc_vec.0 {{ 2,32,64 }} ( asr_vec.0 {{ 2,64 }} ( zcast_vec.0 {{ 2,64,32 }} ( Exp7__5 [ 0 +: 64 ],2,64 ),scast_vec.0 {{ 2,64,16 }} ( replicate_bits.0 {{ 16,2 }} ( '0000000000010000',2 ),2,64 ),2 ),2,32 ),2 ) ;
   __array _Z [ 3 ] = ZeroExtend.0 {{ 64,128 }} ( result__4,128 ) ;
   "0x2f300446"
-  Decoding instruction A64 2f300446
+  Decoding instruction A64 0x2f300446
   constant bits ( 128 ) Exp7__5 = __array _Z [ 2 ] ;
   bits ( 64 ) result__4 ;
   result__4 = add_vec.0 {{ 2,32 }} ( '0000000000000000000000000000000000000000000000000000000000000000',trunc_vec.0 {{ 2,32,64 }} ( asr_vec.0 {{ 2,64 }} ( zcast_vec.0 {{ 2,64,32 }} ( Exp7__5 [ 0 +: 64 ],2,64 ),scast_vec.0 {{ 2,64,16 }} ( replicate_bits.0 {{ 16,2 }} ( '0000000000010000',2 ),2,64 ),2 ),2,32 ),2 ) ;
   __array _Z [ 6 ] = ZeroExtend.0 {{ 64,128 }} ( result__4,128 ) ;
   "0x2f380422"
-  Decoding instruction A64 2f380422
+  Decoding instruction A64 0x2f380422
   constant bits ( 128 ) Exp7__5 = __array _Z [ 1 ] ;
   bits ( 64 ) result__4 ;
   result__4 = add_vec.0 {{ 2,32 }} ( '0000000000000000000000000000000000000000000000000000000000000000',trunc_vec.0 {{ 2,32,64 }} ( asr_vec.0 {{ 2,64 }} ( zcast_vec.0 {{ 2,64,32 }} ( Exp7__5 [ 0 +: 64 ],2,64 ),scast_vec.0 {{ 2,64,8 }} ( replicate_bits.0 {{ 8,2 }} ( '00001000',2 ),2,64 ),2 ),2,32 ),2 ) ;
   __array _Z [ 2 ] = ZeroExtend.0 {{ 64,128 }} ( result__4,128 ) ;
   "0x2f380445"
-  Decoding instruction A64 2f380445
+  Decoding instruction A64 0x2f380445
   constant bits ( 128 ) Exp7__5 = __array _Z [ 2 ] ;
   bits ( 64 ) result__4 ;
   result__4 = add_vec.0 {{ 2,32 }} ( '0000000000000000000000000000000000000000000000000000000000000000',trunc_vec.0 {{ 2,32,64 }} ( asr_vec.0 {{ 2,64 }} ( zcast_vec.0 {{ 2,64,32 }} ( Exp7__5 [ 0 +: 64 ],2,64 ),scast_vec.0 {{ 2,64,8 }} ( replicate_bits.0 {{ 8,2 }} ( '00001000',2 ),2,64 ),2 ),2,32 ),2 ) ;
   __array _Z [ 5 ] = ZeroExtend.0 {{ 64,128 }} ( result__4,128 ) ;
   "0x4cdf0860"
-  Decoding instruction A64 4cdf0860
+  Decoding instruction A64 0x4cdf0860
   constant bits ( 32 ) Exp12__5 = Mem.read.0 {{ 4 }} ( __array _R [ 3 ],4,1 ) ;
   __array _Z [ 0 ] = Elem.set.0 {{ 128,32 }} ( __array _Z [ 0 ],0,32,Exp12__5 ) ;
   constant bits ( 32 ) Exp20__5 = Mem.read.0 {{ 4 }} ( add_bits.0 {{ 64 }} ( __array _R [ 3 ],'0000000000000000000000000000000000000000000000000000000000000100' ),4,1 ) ;
@@ -164,7 +164,7 @@
   __array _Z [ 3 ] = Elem.set.0 {{ 128,32 }} ( __array _Z [ 3 ],3,32,Exp132__5 ) ;
   __array _R [ 3 ] = add_bits.0 {{ 64 }} ( __array _R [ 3 ],'0000000000000000000000000000000000000000000000000000000001000000' ) ;
   "0x4cdf8000"
-  Decoding instruction A64 4cdf8000
+  Decoding instruction A64 0x4cdf8000
   constant bits ( 8 ) Exp12__5 = Mem.read.0 {{ 1 }} ( __array _R [ 0 ],1,1 ) ;
   __array _Z [ 0 ] = Elem.set.0 {{ 128,8 }} ( __array _Z [ 0 ],0,8,Exp12__5 ) ;
   constant bits ( 8 ) Exp20__5 = Mem.read.0 {{ 1 }} ( add_bits.0 {{ 64 }} ( __array _R [ 0 ],'0000000000000000000000000000000000000000000000000000000000000001' ),1,1 ) ;
@@ -231,7 +231,7 @@
   __array _Z [ 1 ] = Elem.set.0 {{ 128,8 }} ( __array _Z [ 1 ],15,8,Exp260__5 ) ;
   __array _R [ 0 ] = add_bits.0 {{ 64 }} ( __array _R [ 0 ],'0000000000000000000000000000000000000000000000000000000000100000' ) ;
   "0x4cdf8800"
-  Decoding instruction A64 4cdf8800
+  Decoding instruction A64 0x4cdf8800
   constant bits ( 32 ) Exp12__5 = Mem.read.0 {{ 4 }} ( __array _R [ 0 ],4,1 ) ;
   __array _Z [ 0 ] = Elem.set.0 {{ 128,32 }} ( __array _Z [ 0 ],0,32,Exp12__5 ) ;
   constant bits ( 32 ) Exp20__5 = Mem.read.0 {{ 4 }} ( add_bits.0 {{ 64 }} ( __array _R [ 0 ],'0000000000000000000000000000000000000000000000000000000000000100' ),4,1 ) ;
@@ -250,23 +250,23 @@
   __array _Z [ 1 ] = Elem.set.0 {{ 128,32 }} ( __array _Z [ 1 ],3,32,Exp68__5 ) ;
   __array _R [ 0 ] = add_bits.0 {{ 64 }} ( __array _R [ 0 ],'0000000000000000000000000000000000000000000000000000000000100000' ) ;
   "0x4d408660"
-  Decoding instruction A64 4d408660
+  Decoding instruction A64 0x4d408660
   constant bits ( 64 ) Exp13__5 = Mem.read.0 {{ 8 }} ( __array _R [ 19 ],8,1 ) ;
   __array _Z [ 0 ] = Elem.set.0 {{ 128,64 }} ( __array _Z [ 0 ],1,64,Exp13__5 ) ;
   "0x4e031c40"
-  Decoding instruction A64 4e031c40
+  Decoding instruction A64 0x4e031c40
   __array _Z [ 0 ] = Elem.set.0 {{ 128,8 }} ( __array _Z [ 0 ],1,8,__array _R [ 2 ] [ 0 +: 8 ] ) ;
   "0x4e040ea0"
-  Decoding instruction A64 4e040ea0
+  Decoding instruction A64 0x4e040ea0
   constant bits ( 64 ) Exp6__5 = __array _R [ 21 ] ;
   bits ( 128 ) result__4 ;
   result__4 = replicate_bits.0 {{ 32,4 }} ( Exp6__5 [ 0 +: 32 ],4 ) ;
   __array _Z [ 0 ] = result__4 ;
   "0x4e051ce0"
-  Decoding instruction A64 4e051ce0
+  Decoding instruction A64 0x4e051ce0
   __array _Z [ 0 ] = Elem.set.0 {{ 128,8 }} ( __array _Z [ 0 ],2,8,__array _R [ 7 ] [ 0 +: 8 ] ) ;
   "0x4e052042"
-  Decoding instruction A64 4e052042
+  Decoding instruction A64 0x4e052042
   bits ( 128 ) result__4 ;
   constant bits ( 256 ) Cse0__5 = append_bits.0 {{ 128,128 }} ( __array _Z [ 3 ],__array _Z [ 2 ] ) ;
   result__4 = '00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000' ;
@@ -320,34 +320,34 @@
   }
   __array _Z [ 2 ] = result__4 ;
   "0x4e071c00"
-  Decoding instruction A64 4e071c00
+  Decoding instruction A64 0x4e071c00
   __array _Z [ 0 ] = Elem.set.0 {{ 128,8 }} ( __array _Z [ 0 ],3,8,__array _R [ 0 ] [ 0 +: 8 ] ) ;
   "0x4e071cc0"
-  Decoding instruction A64 4e071cc0
+  Decoding instruction A64 0x4e071cc0
   __array _Z [ 0 ] = Elem.set.0 {{ 128,8 }} ( __array _Z [ 0 ],3,8,__array _R [ 6 ] [ 0 +: 8 ] ) ;
   "0x4e080401"
-  Decoding instruction A64 4e080401
+  Decoding instruction A64 0x4e080401
   constant bits ( 128 ) Exp7__5 = __array _Z [ 0 ] ;
   bits ( 128 ) result__4 ;
   result__4 = replicate_bits.0 {{ 64,2 }} ( Elem.read.0 {{ 64,64 }} ( Exp7__5 [ 0 +: 64 ],0,64 ),2 ) ;
   __array _Z [ 1 ] = result__4 ;
   "0x4e091ca0"
-  Decoding instruction A64 4e091ca0
+  Decoding instruction A64 0x4e091ca0
   __array _Z [ 0 ] = Elem.set.0 {{ 128,8 }} ( __array _Z [ 0 ],4,8,__array _R [ 5 ] [ 0 +: 8 ] ) ;
   "0x4e0b1c80"
-  Decoding instruction A64 4e0b1c80
+  Decoding instruction A64 0x4e0b1c80
   __array _Z [ 0 ] = Elem.set.0 {{ 128,8 }} ( __array _Z [ 0 ],5,8,__array _R [ 4 ] [ 0 +: 8 ] ) ;
   "0x4e0d1c40"
-  Decoding instruction A64 4e0d1c40
+  Decoding instruction A64 0x4e0d1c40
   __array _Z [ 0 ] = Elem.set.0 {{ 128,8 }} ( __array _Z [ 0 ],6,8,__array _R [ 2 ] [ 0 +: 8 ] ) ;
   "0x4e0f1c60"
-  Decoding instruction A64 4e0f1c60
+  Decoding instruction A64 0x4e0f1c60
   __array _Z [ 0 ] = Elem.set.0 {{ 128,8 }} ( __array _Z [ 0 ],7,8,__array _R [ 3 ] [ 0 +: 8 ] ) ;
   "0x4e211ca1"
-  Decoding instruction A64 4e211ca1
+  Decoding instruction A64 0x4e211ca1
   __array _Z [ 1 ] = and_bits.0 {{ 128 }} ( __array _Z [ 5 ],__array _Z [ 1 ] ) ;
   "0x4e61d800"
-  Decoding instruction A64 4e61d800
+  Decoding instruction A64 0x4e61d800
   bits ( 128 ) result__4 ;
   bits ( 4 ) FPDecodeRounding9__6 ;
   FPDecodeRounding9__6 = ZeroExtend.0 {{ 2,4 }} ( FPCR [ 22 +: 2 ],4 ) ;
@@ -355,7 +355,7 @@
   constant bits ( 64 ) Exp13__5 = FixedToFP.0 {{ 64,64 }} ( Elem.read.0 {{ 128,64 }} ( __array _Z [ 0 ],1,64 ),0,FALSE,FPCR,cvt_bits_uint.0 {{ 4 }} ( FPDecodeRounding9__6 ) ) ;
   __array _Z [ 0 ] = Elem.set.0 {{ 128,64 }} ( Elem.set.0 {{ 128,64 }} ( result__4,0,64,Exp12__5 ),1,64,Exp13__5 ) ;
   "0x4e61d821"
-  Decoding instruction A64 4e61d821
+  Decoding instruction A64 0x4e61d821
   bits ( 128 ) result__4 ;
   bits ( 4 ) FPDecodeRounding9__6 ;
   FPDecodeRounding9__6 = ZeroExtend.0 {{ 2,4 }} ( FPCR [ 22 +: 2 ],4 ) ;
@@ -363,7 +363,7 @@
   constant bits ( 64 ) Exp13__5 = FixedToFP.0 {{ 64,64 }} ( Elem.read.0 {{ 128,64 }} ( __array _Z [ 1 ],1,64 ),0,FALSE,FPCR,cvt_bits_uint.0 {{ 4 }} ( FPDecodeRounding9__6 ) ) ;
   __array _Z [ 1 ] = Elem.set.0 {{ 128,64 }} ( Elem.set.0 {{ 128,64 }} ( result__4,0,64,Exp12__5 ),1,64,Exp13__5 ) ;
   "0x4e61d842"
-  Decoding instruction A64 4e61d842
+  Decoding instruction A64 0x4e61d842
   bits ( 128 ) result__4 ;
   bits ( 4 ) FPDecodeRounding9__6 ;
   FPDecodeRounding9__6 = ZeroExtend.0 {{ 2,4 }} ( FPCR [ 22 +: 2 ],4 ) ;
@@ -371,7 +371,7 @@
   constant bits ( 64 ) Exp13__5 = FixedToFP.0 {{ 64,64 }} ( Elem.read.0 {{ 128,64 }} ( __array _Z [ 2 ],1,64 ),0,FALSE,FPCR,cvt_bits_uint.0 {{ 4 }} ( FPDecodeRounding9__6 ) ) ;
   __array _Z [ 2 ] = Elem.set.0 {{ 128,64 }} ( Elem.set.0 {{ 128,64 }} ( result__4,0,64,Exp12__5 ),1,64,Exp13__5 ) ;
   "0x4e61d863"
-  Decoding instruction A64 4e61d863
+  Decoding instruction A64 0x4e61d863
   bits ( 128 ) result__4 ;
   bits ( 4 ) FPDecodeRounding9__6 ;
   FPDecodeRounding9__6 = ZeroExtend.0 {{ 2,4 }} ( FPCR [ 22 +: 2 ],4 ) ;
@@ -379,168 +379,168 @@
   constant bits ( 64 ) Exp13__5 = FixedToFP.0 {{ 64,64 }} ( Elem.read.0 {{ 128,64 }} ( __array _Z [ 3 ],1,64 ),0,FALSE,FPCR,cvt_bits_uint.0 {{ 4 }} ( FPDecodeRounding9__6 ) ) ;
   __array _Z [ 3 ] = Elem.set.0 {{ 128,64 }} ( Elem.set.0 {{ 128,64 }} ( result__4,0,64,Exp12__5 ),1,64,Exp13__5 ) ;
   "0x4ea11c23"
-  Decoding instruction A64 4ea11c23
+  Decoding instruction A64 0x4ea11c23
   __array _Z [ 3 ] = or_bits.0 {{ 128 }} ( __array _Z [ 1 ],__array _Z [ 1 ] ) ;
   "0x4ea28400"
-  Decoding instruction A64 4ea28400
+  Decoding instruction A64 0x4ea28400
   constant bits ( 128 ) Exp7__5 = __array _Z [ 0 ] ;
   constant bits ( 128 ) Exp9__5 = __array _Z [ 2 ] ;
   bits ( 128 ) result__4 ;
   result__4 = add_vec.0 {{ 4,32 }} ( Exp7__5 [ 0 +: 128 ],Exp9__5 [ 0 +: 128 ],4 ) ;
   __array _Z [ 0 ] = result__4 ;
   "0x4ee08484"
-  Decoding instruction A64 4ee08484
+  Decoding instruction A64 0x4ee08484
   constant bits ( 128 ) Exp7__5 = __array _Z [ 4 ] ;
   constant bits ( 128 ) Exp9__5 = __array _Z [ 0 ] ;
   bits ( 128 ) result__4 ;
   result__4 = add_vec.0 {{ 2,64 }} ( Exp7__5 [ 0 +: 128 ],Exp9__5 [ 0 +: 128 ],2 ) ;
   __array _Z [ 4 ] = result__4 ;
   "0x4ee08c00"
-  Decoding instruction A64 4ee08c00
+  Decoding instruction A64 0x4ee08c00
   constant bits ( 128 ) Exp7__5 = __array _Z [ 0 ] ;
   constant bits ( 128 ) Exp9__5 = __array _Z [ 0 ] ;
   bits ( 128 ) result__4 ;
   result__4 = ite_vec.0 {{ 2,64 }} ( select_vec.0 {{ 2,2,1 }} ( not_bits.0 {{ 2 }} ( eq_vec.0 {{ 2,64 }} ( and_bits.0 {{ 128 }} ( Exp7__5 [ 0 +: 128 ],Exp9__5 [ 0 +: 128 ] ),replicate_bits.0 {{ 64,2 }} ( '0000000000000000000000000000000000000000000000000000000000000000',2 ),2 ) ),'0000000000000000000000000000000100000000000000000000000000000000' ),replicate_bits.0 {{ 64,2 }} ( '1111111111111111111111111111111111111111111111111111111111111111',2 ),replicate_bits.0 {{ 64,2 }} ( '0000000000000000000000000000000000000000000000000000000000000000',2 ),2 ) ;
   __array _Z [ 0 ] = result__4 ;
   "0x4ee28420"
-  Decoding instruction A64 4ee28420
+  Decoding instruction A64 0x4ee28420
   constant bits ( 128 ) Exp7__5 = __array _Z [ 1 ] ;
   constant bits ( 128 ) Exp9__5 = __array _Z [ 2 ] ;
   bits ( 128 ) result__4 ;
   result__4 = add_vec.0 {{ 2,64 }} ( Exp7__5 [ 0 +: 128 ],Exp9__5 [ 0 +: 128 ],2 ) ;
   __array _Z [ 0 ] = result__4 ;
   "0x4f000400"
-  Decoding instruction A64 4f000400
+  Decoding instruction A64 0x4f000400
   __array _Z [ 0 ] = '00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000' ;
   "0x4f000401"
-  Decoding instruction A64 4f000401
+  Decoding instruction A64 0x4f000401
   __array _Z [ 1 ] = '00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000' ;
   "0x4f000404"
-  Decoding instruction A64 4f000404
+  Decoding instruction A64 0x4f000404
   __array _Z [ 4 ] = '00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000' ;
   "0x4f0004e6"
-  Decoding instruction A64 4f0004e6
+  Decoding instruction A64 0x4f0004e6
   __array _Z [ 6 ] = '00000000000000000000000000000111000000000000000000000000000001110000000000000000000000000000011100000000000000000000000000000111' ;
   "0x4f01e6c0"
-  Decoding instruction A64 4f01e6c0
+  Decoding instruction A64 0x4f01e6c0
   __array _Z [ 0 ] = '00110110001101100011011000110110001101100011011000110110001101100011011000110110001101100011011000110110001101100011011000110110' ;
   "0x4f02e780"
-  Decoding instruction A64 4f02e780
+  Decoding instruction A64 0x4f02e780
   __array _Z [ 0 ] = '01011100010111000101110001011100010111000101110001011100010111000101110001011100010111000101110001011100010111000101110001011100' ;
   "0x4f20a400"
-  Decoding instruction A64 4f20a400
+  Decoding instruction A64 0x4f20a400
   constant bits ( 128 ) Exp9__6 = __array _Z [ 0 ] ;
   bits ( 128 ) result__4 ;
   result__4 = scast_vec.0 {{ 2,64,32 }} ( Exp9__6 [ 64 +: 64 ],2,64 ) ;
   __array _Z [ 0 ] = result__4 ;
   "0x4f20a401"
-  Decoding instruction A64 4f20a401
+  Decoding instruction A64 0x4f20a401
   constant bits ( 128 ) Exp9__6 = __array _Z [ 0 ] ;
   bits ( 128 ) result__4 ;
   result__4 = scast_vec.0 {{ 2,64,32 }} ( Exp9__6 [ 64 +: 64 ],2,64 ) ;
   __array _Z [ 1 ] = result__4 ;
   "0x4f20a421"
-  Decoding instruction A64 4f20a421
+  Decoding instruction A64 0x4f20a421
   constant bits ( 128 ) Exp9__6 = __array _Z [ 1 ] ;
   bits ( 128 ) result__4 ;
   result__4 = scast_vec.0 {{ 2,64,32 }} ( Exp9__6 [ 64 +: 64 ],2,64 ) ;
   __array _Z [ 1 ] = result__4 ;
   "0x5ef1b820"
-  Decoding instruction A64 5ef1b820
+  Decoding instruction A64 0x5ef1b820
   __array _Z [ 0 ] = ZeroExtend.0 {{ 64,128 }} ( add_bits.0 {{ 64 }} ( __array _Z [ 1 ] [ 0 +: 64 ],__array _Z [ 1 ] [ 64 +: 64 ] ),128 ) ;
   "0x5ef1b880"
-  Decoding instruction A64 5ef1b880
+  Decoding instruction A64 0x5ef1b880
   __array _Z [ 0 ] = ZeroExtend.0 {{ 64,128 }} ( add_bits.0 {{ 64 }} ( __array _Z [ 4 ] [ 0 +: 64 ],__array _Z [ 4 ] [ 64 +: 64 ] ),128 ) ;
   "0x6e030460"
-  Decoding instruction A64 6e030460
+  Decoding instruction A64 0x6e030460
   __array _Z [ 0 ] = Elem.set.0 {{ 128,8 }} ( __array _Z [ 0 ],1,8,Elem.read.0 {{ 64,8 }} ( __array _Z [ 3 ] [ 0 +: 64 ],0,8 ) ) ;
   "0x6e0304c0"
-  Decoding instruction A64 6e0304c0
+  Decoding instruction A64 0x6e0304c0
   __array _Z [ 0 ] = Elem.set.0 {{ 128,8 }} ( __array _Z [ 0 ],1,8,Elem.read.0 {{ 64,8 }} ( __array _Z [ 6 ] [ 0 +: 64 ],0,8 ) ) ;
   "0x6e050440"
-  Decoding instruction A64 6e050440
+  Decoding instruction A64 0x6e050440
   __array _Z [ 0 ] = Elem.set.0 {{ 128,8 }} ( __array _Z [ 0 ],2,8,Elem.read.0 {{ 64,8 }} ( __array _Z [ 2 ] [ 0 +: 64 ],0,8 ) ) ;
   "0x6e0504a0"
-  Decoding instruction A64 6e0504a0
+  Decoding instruction A64 0x6e0504a0
   __array _Z [ 0 ] = Elem.set.0 {{ 128,8 }} ( __array _Z [ 0 ],2,8,Elem.read.0 {{ 64,8 }} ( __array _Z [ 5 ] [ 0 +: 64 ],0,8 ) ) ;
   "0x6e070420"
-  Decoding instruction A64 6e070420
+  Decoding instruction A64 0x6e070420
   __array _Z [ 0 ] = Elem.set.0 {{ 128,8 }} ( __array _Z [ 0 ],3,8,Elem.read.0 {{ 64,8 }} ( __array _Z [ 1 ] [ 0 +: 64 ],0,8 ) ) ;
   "0x6e090480"
-  Decoding instruction A64 6e090480
+  Decoding instruction A64 0x6e090480
   __array _Z [ 0 ] = Elem.set.0 {{ 128,8 }} ( __array _Z [ 0 ],4,8,Elem.read.0 {{ 64,8 }} ( __array _Z [ 4 ] [ 0 +: 64 ],0,8 ) ) ;
   "0x6e090680"
-  Decoding instruction A64 6e090680
+  Decoding instruction A64 0x6e090680
   __array _Z [ 0 ] = Elem.set.0 {{ 128,8 }} ( __array _Z [ 0 ],4,8,Elem.read.0 {{ 64,8 }} ( __array _Z [ 20 ] [ 0 +: 64 ],0,8 ) ) ;
   "0x6e0b0460"
-  Decoding instruction A64 6e0b0460
+  Decoding instruction A64 0x6e0b0460
   __array _Z [ 0 ] = Elem.set.0 {{ 128,8 }} ( __array _Z [ 0 ],5,8,Elem.read.0 {{ 64,8 }} ( __array _Z [ 3 ] [ 0 +: 64 ],0,8 ) ) ;
   "0x6e0b0660"
-  Decoding instruction A64 6e0b0660
+  Decoding instruction A64 0x6e0b0660
   __array _Z [ 0 ] = Elem.set.0 {{ 128,8 }} ( __array _Z [ 0 ],5,8,Elem.read.0 {{ 64,8 }} ( __array _Z [ 19 ] [ 0 +: 64 ],0,8 ) ) ;
   "0x6e0d0440"
-  Decoding instruction A64 6e0d0440
+  Decoding instruction A64 0x6e0d0440
   __array _Z [ 0 ] = Elem.set.0 {{ 128,8 }} ( __array _Z [ 0 ],6,8,Elem.read.0 {{ 64,8 }} ( __array _Z [ 2 ] [ 0 +: 64 ],0,8 ) ) ;
   "0x6e0d0640"
-  Decoding instruction A64 6e0d0640
+  Decoding instruction A64 0x6e0d0640
   __array _Z [ 0 ] = Elem.set.0 {{ 128,8 }} ( __array _Z [ 0 ],6,8,Elem.read.0 {{ 64,8 }} ( __array _Z [ 18 ] [ 0 +: 64 ],0,8 ) ) ;
   "0x6e0f0420"
-  Decoding instruction A64 6e0f0420
+  Decoding instruction A64 0x6e0f0420
   __array _Z [ 0 ] = Elem.set.0 {{ 128,8 }} ( __array _Z [ 0 ],7,8,Elem.read.0 {{ 64,8 }} ( __array _Z [ 1 ] [ 0 +: 64 ],0,8 ) ) ;
   "0x6e0f0620"
-  Decoding instruction A64 6e0f0620
+  Decoding instruction A64 0x6e0f0620
   __array _Z [ 0 ] = Elem.set.0 {{ 128,8 }} ( __array _Z [ 0 ],7,8,Elem.read.0 {{ 64,8 }} ( __array _Z [ 17 ] [ 0 +: 64 ],0,8 ) ) ;
   "0x6e110600"
-  Decoding instruction A64 6e110600
+  Decoding instruction A64 0x6e110600
   __array _Z [ 0 ] = Elem.set.0 {{ 128,8 }} ( __array _Z [ 0 ],8,8,Elem.read.0 {{ 64,8 }} ( __array _Z [ 16 ] [ 0 +: 64 ],0,8 ) ) ;
   "0x6e1304e0"
-  Decoding instruction A64 6e1304e0
+  Decoding instruction A64 0x6e1304e0
   __array _Z [ 0 ] = Elem.set.0 {{ 128,8 }} ( __array _Z [ 0 ],9,8,Elem.read.0 {{ 64,8 }} ( __array _Z [ 7 ] [ 0 +: 64 ],0,8 ) ) ;
   "0x6e1504c0"
-  Decoding instruction A64 6e1504c0
+  Decoding instruction A64 0x6e1504c0
   __array _Z [ 0 ] = Elem.set.0 {{ 128,8 }} ( __array _Z [ 0 ],10,8,Elem.read.0 {{ 64,8 }} ( __array _Z [ 6 ] [ 0 +: 64 ],0,8 ) ) ;
   "0x6e1704a0"
-  Decoding instruction A64 6e1704a0
+  Decoding instruction A64 0x6e1704a0
   __array _Z [ 0 ] = Elem.set.0 {{ 128,8 }} ( __array _Z [ 0 ],11,8,Elem.read.0 {{ 64,8 }} ( __array _Z [ 5 ] [ 0 +: 64 ],0,8 ) ) ;
   "0x6e190480"
-  Decoding instruction A64 6e190480
+  Decoding instruction A64 0x6e190480
   __array _Z [ 0 ] = Elem.set.0 {{ 128,8 }} ( __array _Z [ 0 ],12,8,Elem.read.0 {{ 64,8 }} ( __array _Z [ 4 ] [ 0 +: 64 ],0,8 ) ) ;
   "0x6e1b0460"
-  Decoding instruction A64 6e1b0460
+  Decoding instruction A64 0x6e1b0460
   __array _Z [ 0 ] = Elem.set.0 {{ 128,8 }} ( __array _Z [ 0 ],13,8,Elem.read.0 {{ 64,8 }} ( __array _Z [ 3 ] [ 0 +: 64 ],0,8 ) ) ;
   "0x6e1d0440"
-  Decoding instruction A64 6e1d0440
+  Decoding instruction A64 0x6e1d0440
   __array _Z [ 0 ] = Elem.set.0 {{ 128,8 }} ( __array _Z [ 0 ],14,8,Elem.read.0 {{ 64,8 }} ( __array _Z [ 2 ] [ 0 +: 64 ],0,8 ) ) ;
   "0x6e1f0420"
-  Decoding instruction A64 6e1f0420
+  Decoding instruction A64 0x6e1f0420
   __array _Z [ 0 ] = Elem.set.0 {{ 128,8 }} ( __array _Z [ 0 ],15,8,Elem.read.0 {{ 64,8 }} ( __array _Z [ 1 ] [ 0 +: 64 ],0,8 ) ) ;
   "0x6e200800"
-  Decoding instruction A64 6e200800
+  Decoding instruction A64 0x6e200800
   bits ( 128 ) result__4 ;
   __array _Z [ 0 ] = Elem.set.0 {{ 128,8 }} ( Elem.set.0 {{ 128,8 }} ( Elem.set.0 {{ 128,8 }} ( Elem.set.0 {{ 128,8 }} ( Elem.set.0 {{ 128,8 }} ( Elem.set.0 {{ 128,8 }} ( Elem.set.0 {{ 128,8 }} ( Elem.set.0 {{ 128,8 }} ( Elem.set.0 {{ 128,8 }} ( Elem.set.0 {{ 128,8 }} ( Elem.set.0 {{ 128,8 }} ( Elem.set.0 {{ 128,8 }} ( Elem.set.0 {{ 128,8 }} ( Elem.set.0 {{ 128,8 }} ( Elem.set.0 {{ 128,8 }} ( Elem.set.0 {{ 128,8 }} ( result__4,3,8,Elem.read.0 {{ 128,8 }} ( __array _Z [ 0 ],0,8 ) ),2,8,Elem.read.0 {{ 128,8 }} ( __array _Z [ 0 ],1,8 ) ),1,8,Elem.read.0 {{ 128,8 }} ( __array _Z [ 0 ],2,8 ) ),0,8,Elem.read.0 {{ 128,8 }} ( __array _Z [ 0 ],3,8 ) ),7,8,Elem.read.0 {{ 128,8 }} ( __array _Z [ 0 ],4,8 ) ),6,8,Elem.read.0 {{ 128,8 }} ( __array _Z [ 0 ],5,8 ) ),5,8,Elem.read.0 {{ 128,8 }} ( __array _Z [ 0 ],6,8 ) ),4,8,Elem.read.0 {{ 128,8 }} ( __array _Z [ 0 ],7,8 ) ),11,8,Elem.read.0 {{ 128,8 }} ( __array _Z [ 0 ],8,8 ) ),10,8,Elem.read.0 {{ 128,8 }} ( __array _Z [ 0 ],9,8 ) ),9,8,Elem.read.0 {{ 128,8 }} ( __array _Z [ 0 ],10,8 ) ),8,8,Elem.read.0 {{ 128,8 }} ( __array _Z [ 0 ],11,8 ) ),15,8,Elem.read.0 {{ 128,8 }} ( __array _Z [ 0 ],12,8 ) ),14,8,Elem.read.0 {{ 128,8 }} ( __array _Z [ 0 ],13,8 ) ),13,8,Elem.read.0 {{ 128,8 }} ( __array _Z [ 0 ],14,8 ) ),12,8,Elem.read.0 {{ 128,8 }} ( __array _Z [ 0 ],15,8 ) ) ;
   "0x6e205800"
-  Decoding instruction A64 6e205800
+  Decoding instruction A64 0x6e205800
   constant bits ( 128 ) Exp4__5 = __array _Z [ 0 ] ;
   bits ( 128 ) result__4 ;
   result__4 = select_vec.0 {{ 16,16,8 }} ( not_bits.0 {{ 128 }} ( Exp4__5 [ 0 +: 128 ] ),'00000000000000000000000000001111000000000000000000000000000011100000000000000000000000000000110100000000000000000000000000001100000000000000000000000000000010110000000000000000000000000000101000000000000000000000000000001001000000000000000000000000000010000000000000000000000000000000011100000000000000000000000000000110000000000000000000000000000001010000000000000000000000000000010000000000000000000000000000000011000000000000000000000000000000100000000000000000000000000000000100000000000000000000000000000000' ) ;
   __array _Z [ 0 ] = result__4 ;
   "0x6e211c00"
-  Decoding instruction A64 6e211c00
+  Decoding instruction A64 0x6e211c00
   __array _Z [ 0 ] = eor_bits.0 {{ 128 }} ( __array _Z [ 1 ],eor_bits.0 {{ 128 }} ( '00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000',__array _Z [ 0 ] ) ) ;
   "0x6ea68c00"
-  Decoding instruction A64 6ea68c00
+  Decoding instruction A64 0x6ea68c00
   constant bits ( 128 ) Exp7__5 = __array _Z [ 0 ] ;
   constant bits ( 128 ) Exp9__5 = __array _Z [ 6 ] ;
   bits ( 128 ) result__4 ;
   result__4 = ite_vec.0 {{ 4,32 }} ( eq_vec.0 {{ 4,32 }} ( Exp7__5 [ 0 +: 128 ],Exp9__5 [ 0 +: 128 ],4 ),replicate_bits.0 {{ 32,4 }} ( '11111111111111111111111111111111',4 ),replicate_bits.0 {{ 32,4 }} ( '00000000000000000000000000000000',4 ),4 ) ;
   __array _Z [ 0 ] = result__4 ;
   "0x6ee08421"
-  Decoding instruction A64 6ee08421
+  Decoding instruction A64 0x6ee08421
   constant bits ( 128 ) Exp7__5 = __array _Z [ 1 ] ;
   constant bits ( 128 ) Exp9__5 = __array _Z [ 0 ] ;
   bits ( 128 ) result__4 ;
   result__4 = sub_vec.0 {{ 2,64 }} ( Exp7__5 [ 0 +: 128 ],Exp9__5 [ 0 +: 128 ],2 ) ;
   __array _Z [ 1 ] = result__4 ;
   "0x6f000400"
-  Decoding instruction A64 6f000400
+  Decoding instruction A64 0x6f000400
   __array _Z [ 0 ] = '11111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111' ;
diff --git a/tests/aslt/test_dis.t b/tests/aslt/test_dis.t
index e8de7496..ce8e0507 100644
--- a/tests/aslt/test_dis.t
+++ b/tests/aslt/test_dis.t
@@ -7,7 +7,7 @@ run asli with these commands
   "
   0xab030041
   "
-  Decoding instruction A64 ab030041
+  Decoding instruction A64 0xab030041
   constant bits ( 64 ) Cse0__5 = add_bits.0 {{ 64 }} ( __array _R [ 2 ],__array _R [ 3 ] ) ;
   PSTATE . V = not_bits.0 {{ 1 }} ( cvt_bool_bv.0 {{  }} ( eq_bits.0 {{ 128 }} ( SignExtend.0 {{ 64,128 }} ( Cse0__5,128 ),add_bits.0 {{ 128 }} ( SignExtend.0 {{ 64,128 }} ( __array _R [ 2 ],128 ),SignExtend.0 {{ 64,128 }} ( __array _R [ 3 ],128 ) ) ) ) ) ;
   PSTATE . C = not_bits.0 {{ 1 }} ( cvt_bool_bv.0 {{  }} ( eq_bits.0 {{ 128 }} ( ZeroExtend.0 {{ 64,128 }} ( Cse0__5,128 ),add_bits.0 {{ 128 }} ( ZeroExtend.0 {{ 64,128 }} ( __array _R [ 2 ],128 ),ZeroExtend.0 {{ 64,128 }} ( __array _R [ 3 ],128 ) ) ) ) ) ;
@@ -24,14 +24,14 @@ run asli with these commands
   "
   0xd10083ff
   "
-  Decoding instruction A64 d10083ff
+  Decoding instruction A64 0xd10083ff
   SP_EL0 = add_bits.0 {{ 64 }} ( SP_EL0,'1111111111111111111111111111111111111111111111111111111111100000' ) ;
   ""
   Stmt_Assign(LExpr_Var("SP_EL0"),Expr_TApply("add_bits.0",[64],[Expr_Var("SP_EL0");'1111111111111111111111111111111111111111111111111111111111100000']))
   "
   0xa8c80861
   "
-  Decoding instruction A64 a8c80861
+  Decoding instruction A64 0xa8c80861
   constant bits ( 64 ) Exp16__5 = Mem.read.0 {{ 8 }} ( __array _R [ 3 ],8,0 ) ;
   constant bits ( 64 ) Exp18__5 = Mem.read.0 {{ 8 }} ( add_bits.0 {{ 64 }} ( __array _R [ 3 ],'0000000000000000000000000000000000000000000000000000000000001000' ),8,0 ) ;
   __array _R [ 1 ] = Exp16__5 ;
@@ -46,7 +46,7 @@ run asli with these commands
   "
   0xa8880861
   "
-  Decoding instruction A64 a8880861
+  Decoding instruction A64 0xa8880861
   Mem.set.0 {{ 8 }} ( __array _R [ 3 ],8,0,__array _R [ 1 ] ) ;
   Mem.set.0 {{ 8 }} ( add_bits.0 {{ 64 }} ( __array _R [ 3 ],'0000000000000000000000000000000000000000000000000000000000001000' ),8,0,__array _R [ 2 ] ) ;
   __array _R [ 3 ] = add_bits.0 {{ 64 }} ( __array _R [ 3 ],'0000000000000000000000000000000000000000000000000000000010000000' ) ;
@@ -57,7 +57,7 @@ run asli with these commands
   "
   0x1e630040
   "
-  Decoding instruction A64 1e630040
+  Decoding instruction A64 0x1e630040
   bits ( 4 ) FPDecodeRounding5__6 ;
   FPDecodeRounding5__6 = ZeroExtend.0 {{ 2,4 }} ( FPCR [ 22 +: 2 ],4 ) ;
   constant bits ( 64 ) Exp9__5 = FixedToFP.0 {{ 32,64 }} ( __array _R [ 2 ] [ 0 +: 32 ],0,TRUE,FPCR,cvt_bits_uint.0 {{ 4 }} ( FPDecodeRounding5__6 ) ) ;
@@ -70,14 +70,14 @@ run asli with these commands
   "
   0xd53b4200
   "
-  Decoding instruction A64 d53b4200
+  Decoding instruction A64 0xd53b4200
   __array _R [ 0 ] = append_bits.0 {{ 36,28 }} ( ZeroExtend.0 {{ 4,36 }} ( append_bits.0 {{ 3,1 }} ( append_bits.0 {{ 2,1 }} ( append_bits.0 {{ 1,1 }} ( PSTATE . N,PSTATE . Z ),PSTATE . C ),PSTATE . V ),36 ),'0000000000000000000000000000' ) ;
   ""
   Stmt_Assign(LExpr_Array(LExpr_Var("_R"),0),Expr_TApply("append_bits.0",[36;28],[Expr_TApply("ZeroExtend.0",[4;36],[Expr_TApply("append_bits.0",[3;1],[Expr_TApply("append_bits.0",[2;1],[Expr_TApply("append_bits.0",[1;1],[Expr_Field(Expr_Var("PSTATE"),"N");Expr_Field(Expr_Var("PSTATE"),"Z")]);Expr_Field(Expr_Var("PSTATE"),"C")]);Expr_Field(Expr_Var("PSTATE"),"V")]);36]);'0000000000000000000000000000']))
   "
   0x0e000000
   "
-  Decoding instruction A64 e000000
+  Decoding instruction A64 0x0e000000
   constant bits ( 16 ) Cse15__5 = ZeroExtend.0 {{ 8,16 }} ( __array _Z [ 0 ] [ 0 +: 8 ],16 ) ;
   constant bits ( 16 ) Cse14__5 = mul_bits.0 {{ 16 }} ( ZeroExtend.0 {{ 8,16 }} ( __array _Z [ 0 ] [ 0 +: 8 ],16 ),'0000000000001000' ) ;
   constant bits ( 16 ) Cse13__5 = ZeroExtend.0 {{ 8,16 }} ( __array _Z [ 0 ] [ 8 +: 8 ],16 ) ;
@@ -184,7 +184,7 @@ run asli with these commands
   "
   0x0e205800
   "
-  Decoding instruction A64 e205800
+  Decoding instruction A64 0x0e205800
   bits ( 4 ) result__5 = '0000' ;
   if eq_bits.0 {{ 1 }} ( __array _Z [ 0 ] [ 0 +: 1 ],'1' ) then {
   result__5 = '0001' ;
@@ -591,7 +591,7 @@ run asli with these commands
   "
   0x4f71d000
   "
-  Decoding instruction A64 4f71d000
+  Decoding instruction A64 0x4f71d000
   constant bits ( 32 ) Cse43__5 = SignExtend.0 {{ 16,32 }} ( __array _Z [ 0 ] [ 0 +: 16 ],32 ) ;
   constant bits ( 32 ) Cse36__5 = SignExtend.0 {{ 16,32 }} ( __array _Z [ 0 ] [ 16 +: 16 ],32 ) ;
   constant bits ( 32 ) Cse30__5 = SignExtend.0 {{ 16,32 }} ( __array _Z [ 0 ] [ 32 +: 16 ],32 ) ;
@@ -885,4 +885,3 @@ run asli with these commands
   Stmt_Assign(LExpr_Var("FPSR"),Expr_TApply("append_bits.0",[4;28],[Expr_Slices(Expr_Var("FPSR"),[Slice_LoWd(28,4)]);Expr_TApply("append_bits.0",[1;27],['1';Expr_Slices(Expr_Var("FPSR"),[Slice_LoWd(0,27)])])]))
   ],[],[])
   Stmt_Assign(LExpr_Array(LExpr_Var("_Z"),0),Expr_TApply("append_bits.0",[16;112],[Expr_Var("SignedSatQ109__5");Expr_TApply("append_bits.0",[16;96],[Expr_Var("SignedSatQ96__5");Expr_TApply("append_bits.0",[16;80],[Expr_Var("SignedSatQ83__5");Expr_TApply("append_bits.0",[16;64],[Expr_Var("SignedSatQ70__5");Expr_TApply("append_bits.0",[16;48],[Expr_Var("SignedSatQ57__5");Expr_TApply("append_bits.0",[16;32],[Expr_Var("SignedSatQ44__5");Expr_TApply("append_bits.0",[16;16],[Expr_Var("SignedSatQ31__5");Expr_Var("SignedSatQ17__5")])])])])])])]))
-