diff --git a/examples/one_function_multi_call/one_function_multi_call.c b/examples/one_function_multi_call/one_function_multi_call.c
new file mode 100644
index 000000000..4aab3dd14
--- /dev/null
+++ b/examples/one_function_multi_call/one_function_multi_call.c
@@ -0,0 +1,23 @@
+#include <stdio.h>
+
+// Function declarations
+int addNumbers(int a, int b);
+
+int callAddFromAnotherFunction(int x, int y) {
+    return addNumbers(x, y);
+}
+
+int callFromFun2(int x, int y) {
+    return addNumbers(x, y);
+}
+
+int addNumbers(int a, int b) {
+    return a + b;
+}
+
+int main() {
+    int resultFromMain = addNumbers(10, 5);
+    int resultFromOtherFunc = callAddFromAnotherFunction(20, 15);
+    int resultFromFun2 = callFromFun2(30, 25);
+    return 0;
+}
diff --git a/examples/stackambiguity/stackambiguity.adt b/examples/stackambiguity/stackambiguity.adt
new file mode 100644
index 000000000..c06f24fdd
--- /dev/null
+++ b/examples/stackambiguity/stackambiguity.adt
@@ -0,0 +1,673 @@
+Project(Attrs([Attr("filename","\"a.out\""),
+Attr("image-specification","(declare abi (name str))\n(declare arch (name str))\n(declare base-address (addr int))\n(declare bias (off int))\n(declare bits (size int))\n(declare code-region (addr int) (size int) (off int))\n(declare code-start (addr int))\n(declare entry-point (addr int))\n(declare external-reference (addr int) (name str))\n(declare format (name str))\n(declare is-executable (flag bool))\n(declare is-little-endian (flag bool))\n(declare llvm:base-address (addr int))\n(declare llvm:code-entry (name str) (off int) (size int))\n(declare llvm:coff-import-library (name str))\n(declare llvm:coff-virtual-section-header (name str) (addr int) (size int))\n(declare llvm:elf-program-header (name str) (off int) (size int))\n(declare llvm:elf-program-header-flags (name str) (ld bool) (r bool) \n (w bool) (x bool))\n(declare llvm:elf-virtual-program-header (name str) (addr int) (size int))\n(declare llvm:entry-point (addr int))\n(declare llvm:macho-symbol (name str) (value int))\n(declare llvm:name-reference (at int) (name str))\n(declare llvm:relocation (at int) (addr int))\n(declare llvm:section-entry (name str) (addr int) (size int) (off int))\n(declare llvm:section-flags (name str) (r bool) (w bool) (x bool))\n(declare llvm:segment-command (name str) (off int) (size int))\n(declare llvm:segment-command-flags (name str) (r bool) (w bool) (x bool))\n(declare llvm:symbol-entry (name str) (addr int) (size int) (off int)\n (value int))\n(declare llvm:virtual-segment-command (name str) (addr int) (size int))\n(declare mapped (addr int) (size int) (off int))\n(declare named-region (addr int) (size int) (name str))\n(declare named-symbol (addr int) (name str))\n(declare require (name str))\n(declare section (addr int) (size int))\n(declare segment (addr int) (size int) (r bool) (w bool) (x bool))\n(declare subarch (name str))\n(declare symbol-chunk (addr int) (size int) (root int))\n(declare symbol-value (addr int) (value int))\n(declare system (name str))\n(declare vendor (name str))\n\n(abi unknown)\n(arch aarch64)\n(base-address 0)\n(bias 0)\n(bits 64)\n(code-region 1952 20 1952)\n(code-region 1536 416 1536)\n(code-region 1440 96 1440)\n(code-region 1408 24 1408)\n(code-start 1588)\n(code-start 1536)\n(code-start 1860)\n(code-start 1812)\n(entry-point 1536)\n(external-reference 69568 _ITM_deregisterTMCloneTable)\n(external-reference 69576 __cxa_finalize)\n(external-reference 69584 __gmon_start__)\n(external-reference 69600 _ITM_registerTMCloneTable)\n(external-reference 69632 __libc_start_main)\n(external-reference 69640 __cxa_finalize)\n(external-reference 69648 __gmon_start__)\n(external-reference 69656 abort)\n(format elf)\n(is-executable true)\n(is-little-endian true)\n(llvm:base-address 0)\n(llvm:code-entry abort 0 0)\n(llvm:code-entry __cxa_finalize 0 0)\n(llvm:code-entry __libc_start_main 0 0)\n(llvm:code-entry test 1812 48)\n(llvm:code-entry _init 1408 0)\n(llvm:code-entry main 1860 92)\n(llvm:code-entry _start 1536 52)\n(llvm:code-entry abort@GLIBC_2.17 0 0)\n(llvm:code-entry _fini 1952 0)\n(llvm:code-entry __cxa_finalize@GLIBC_2.17 0 0)\n(llvm:code-entry __libc_start_main@GLIBC_2.34 0 0)\n(llvm:code-entry frame_dummy 1808 0)\n(llvm:code-entry __do_global_dtors_aux 1728 0)\n(llvm:code-entry register_tm_clones 1664 0)\n(llvm:code-entry deregister_tm_clones 1616 0)\n(llvm:code-entry call_weak_fn 1588 20)\n(llvm:code-entry .fini 1952 20)\n(llvm:code-entry .text 1536 416)\n(llvm:code-entry .plt 1440 96)\n(llvm:code-entry .init 1408 24)\n(llvm:elf-program-header 08 3528 568)\n(llvm:elf-program-header 07 0 0)\n(llvm:elf-program-header 06 1976 68)\n(llvm:elf-program-header 05 596 68)\n(llvm:elf-program-header 04 3544 480)\n(llvm:elf-program-header 03 3528 616)\n(llvm:elf-program-header 02 0 2256)\n(llvm:elf-program-header 01 568 27)\n(llvm:elf-program-header 00 64 504)\n(llvm:elf-program-header-flags 08 false true false false)\n(llvm:elf-program-header-flags 07 false true true false)\n(llvm:elf-program-header-flags 06 false true false false)\n(llvm:elf-program-header-flags 05 false true false false)\n(llvm:elf-program-header-flags 04 false true true false)\n(llvm:elf-program-header-flags 03 true true true false)\n(llvm:elf-program-header-flags 02 true true false true)\n(llvm:elf-program-header-flags 01 false true false false)\n(llvm:elf-program-header-flags 00 false true false false)\n(llvm:elf-virtual-program-header 08 69064 568)\n(llvm:elf-virtual-program-header 07 0 0)\n(llvm:elf-virtual-program-header 06 1976 68)\n(llvm:elf-virtual-program-header 05 596 68)\n(llvm:elf-virtual-program-header 04 69080 480)\n(llvm:elf-virtual-program-header 03 69064 624)\n(llvm:elf-virtual-program-header 02 0 2256)\n(llvm:elf-virtual-program-header 01 568 27)\n(llvm:elf-virtual-program-header 00 64 504)\n(llvm:entry-point 1536)\n(llvm:name-reference 69656 abort)\n(llvm:name-reference 69648 __gmon_start__)\n(llvm:name-reference 69640 __cxa_finalize)\n(llvm:name-reference 69632 __libc_start_main)\n(llvm:name-reference 69600 _ITM_registerTMCloneTable)\n(llvm:name-reference 69584 __gmon_start__)\n(llvm:name-reference 69576 __cxa_finalize)\n(llvm:name-reference 69568 _ITM_deregisterTMCloneTable)\n(llvm:section-entry .shstrtab 0 259 6922)\n(llvm:section-entry .strtab 0 570 6352)\n(llvm:section-entry .symtab 0 2136 4216)\n(llvm:section-entry .comment 0 71 4144)\n(llvm:section-entry .bss 69680 8 4144)\n(llvm:section-entry .data 69664 16 4128)\n(llvm:section-entry .got.plt 69608 56 4072)\n(llvm:section-entry .got 69560 48 4024)\n(llvm:section-entry .dynamic 69080 480 3544)\n(llvm:section-entry .fini_array 69072 8 3536)\n(llvm:section-entry .init_array 69064 8 3528)\n(llvm:section-entry .eh_frame 2048 208 2048)\n(llvm:section-entry .eh_frame_hdr 1976 68 1976)\n(llvm:section-entry .rodata 1972 4 1972)\n(llvm:section-entry .fini 1952 20 1952)\n(llvm:section-entry .text 1536 416 1536)\n(llvm:section-entry .plt 1440 96 1440)\n(llvm:section-entry .init 1408 24 1408)\n(llvm:section-entry .rela.plt 1312 96 1312)\n(llvm:section-entry .rela.dyn 1120 192 1120)\n(llvm:section-entry .gnu.version_r 1072 48 1072)\n(llvm:section-entry .gnu.version 1054 18 1054)\n(llvm:section-entry .dynstr 912 141 912)\n(llvm:section-entry .dynsym 696 216 696)\n(llvm:section-entry .gnu.hash 664 28 664)\n(llvm:section-entry .note.ABI-tag 632 32 632)\n(llvm:section-entry .note.gnu.build-id 596 36 596)\n(llvm:section-entry .interp 568 27 568)\n(llvm:section-flags .shstrtab true false false)\n(llvm:section-flags .strtab true false false)\n(llvm:section-flags .symtab true false false)\n(llvm:section-flags .comment true false false)\n(llvm:section-flags .bss true true false)\n(llvm:section-flags .data true true false)\n(llvm:section-flags .got.plt true true false)\n(llvm:section-flags .got true true false)\n(llvm:section-flags .dynamic true true false)\n(llvm:section-flags .fini_array true true false)\n(llvm:section-flags .init_array true true false)\n(llvm:section-flags .eh_frame true false false)\n(llvm:section-flags .eh_frame_hdr true false false)\n(llvm:section-flags .rodata true false false)\n(llvm:section-flags .fini true false true)\n(llvm:section-flags .text true false true)\n(llvm:section-flags .plt true false true)\n(llvm:section-flags .init true false true)\n(llvm:section-flags .rela.plt true false false)\n(llvm:section-flags .rela.dyn true false false)\n(llvm:section-flags .gnu.version_r true false false)\n(llvm:section-flags .gnu.version true false false)\n(llvm:section-flags .dynstr true false false)\n(llvm:section-flags .dynsym true false false)\n(llvm:section-flags .gnu.hash true false false)\n(llvm:section-flags .note.ABI-tag true false false)\n(llvm:section-flags .note.gnu.build-id true false false)\n(llvm:section-flags .interp true false false)\n(llvm:symbol-entry abort 0 0 0 0)\n(llvm:symbol-entry __cxa_finalize 0 0 0 0)\n(llvm:symbol-entry __libc_start_main 0 0 0 0)\n(llvm:symbol-entry test 1812 48 1812 1812)\n(llvm:symbol-entry _init 1408 0 1408 1408)\n(llvm:symbol-entry main 1860 92 1860 1860)\n(llvm:symbol-entry _start 1536 52 1536 1536)\n(llvm:symbol-entry abort@GLIBC_2.17 0 0 0 0)\n(llvm:symbol-entry _fini 1952 0 1952 1952)\n(llvm:symbol-entry __cxa_finalize@GLIBC_2.17 0 0 0 0)\n(llvm:symbol-entry __libc_start_main@GLIBC_2.34 0 0 0 0)\n(llvm:symbol-entry frame_dummy 1808 0 1808 1808)\n(llvm:symbol-entry __do_global_dtors_aux 1728 0 1728 1728)\n(llvm:symbol-entry register_tm_clones 1664 0 1664 1664)\n(llvm:symbol-entry deregister_tm_clones 1616 0 1616 1616)\n(llvm:symbol-entry call_weak_fn 1588 20 1588 1588)\n(mapped 0 2256 0)\n(mapped 69064 616 3528)\n(named-region 0 2256 02)\n(named-region 69064 624 03)\n(named-region 568 27 .interp)\n(named-region 596 36 .note.gnu.build-id)\n(named-region 632 32 .note.ABI-tag)\n(named-region 664 28 .gnu.hash)\n(named-region 696 216 .dynsym)\n(named-region 912 141 .dynstr)\n(named-region 1054 18 .gnu.version)\n(named-region 1072 48 .gnu.version_r)\n(named-region 1120 192 .rela.dyn)\n(named-region 1312 96 .rela.plt)\n(named-region 1408 24 .init)\n(named-region 1440 96 .plt)\n(named-region 1536 416 .text)\n(named-region 1952 20 .fini)\n(named-region 1972 4 .rodata)\n(named-region 1976 68 .eh_frame_hdr)\n(named-region 2048 208 .eh_frame)\n(named-region 69064 8 .init_array)\n(named-region 69072 8 .fini_array)\n(named-region 69080 480 .dynamic)\n(named-region 69560 48 .got)\n(named-region 69608 56 .got.plt)\n(named-region 69664 16 .data)\n(named-region 69680 8 .bss)\n(named-region 0 71 .comment)\n(named-region 0 2136 .symtab)\n(named-region 0 570 .strtab)\n(named-region 0 259 .shstrtab)\n(named-symbol 1588 call_weak_fn)\n(named-symbol 1616 deregister_tm_clones)\n(named-symbol 1664 register_tm_clones)\n(named-symbol 1728 __do_global_dtors_aux)\n(named-symbol 1808 frame_dummy)\n(named-symbol 0 __libc_start_main@GLIBC_2.34)\n(named-symbol 0 __cxa_finalize@GLIBC_2.17)\n(named-symbol 1952 _fini)\n(named-symbol 0 abort@GLIBC_2.17)\n(named-symbol 1536 _start)\n(named-symbol 1860 main)\n(named-symbol 1408 _init)\n(named-symbol 1812 test)\n(named-symbol 0 __libc_start_main)\n(named-symbol 0 __cxa_finalize)\n(named-symbol 0 abort)\n(require libc.so.6)\n(section 568 27)\n(section 596 36)\n(section 632 32)\n(section 664 28)\n(section 696 216)\n(section 912 141)\n(section 1054 18)\n(section 1072 48)\n(section 1120 192)\n(section 1312 96)\n(section 1408 24)\n(section 1440 96)\n(section 1536 416)\n(section 1952 20)\n(section 1972 4)\n(section 1976 68)\n(section 2048 208)\n(section 69064 8)\n(section 69072 8)\n(section 69080 480)\n(section 69560 48)\n(section 69608 56)\n(section 69664 16)\n(section 69680 8)\n(section 0 71)\n(section 0 2136)\n(section 0 570)\n(section 0 259)\n(segment 0 2256 true false true)\n(segment 69064 624 true true false)\n(subarch v8)\n(symbol-chunk 1588 20 1588)\n(symbol-chunk 1536 52 1536)\n(symbol-chunk 1860 92 1860)\n(symbol-chunk 1812 48 1812)\n(symbol-value 1588 1588)\n(symbol-value 1616 1616)\n(symbol-value 1664 1664)\n(symbol-value 1728 1728)\n(symbol-value 1808 1808)\n(symbol-value 1952 1952)\n(symbol-value 1536 1536)\n(symbol-value 1860 1860)\n(symbol-value 1408 1408)\n(symbol-value 1812 1812)\n(symbol-value 0 0)\n(system \"\")\n(vendor \"\")\n"),
+Attr("abi-name","\"aarch64-linux-gnu-elf\"")]),
+Sections([Section(".shstrtab", 0x0, "\x7f\x45\x4c\x46\x02\x01\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x03\x00\xb7\x00\x01\x00\x00\x00\x00\x06\x00\x00\x00\x00\x00\x00\x40\x00\x00\x00\x00\x00\x00\x00\x10\x1c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x40\x00\x38\x00\x09\x00\x40\x00\x1d\x00\x1c\x00\x06\x00\x00\x00\x04\x00\x00\x00\x40\x00\x00\x00\x00\x00\x00\x00\x40\x00\x00\x00\x00\x00\x00\x00\x40\x00\x00\x00\x00\x00\x00\x00\xf8\x01\x00\x00\x00\x00\x00\x00\xf8\x01\x00\x00\x00\x00\x00\x00\x08\x00\x00\x00\x00\x00\x00\x00\x03\x00\x00\x00\x04\x00\x00\x00\x38\x02\x00\x00\x00\x00\x00\x00\x38\x02\x00\x00\x00\x00\x00\x00\x38\x02\x00\x00\x00\x00\x00\x00\x1b\x00\x00\x00\x00\x00\x00\x00\x1b\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x05\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd0\x08\x00\x00\x00\x00\x00\x00\xd0\x08\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x00\x00\x01\x00\x00\x00\x06\x00\x00\x00\xc8\x0d\x00\x00\x00\x00\x00\x00\xc8\x0d\x01\x00\x00\x00\x00\x00\xc8\x0d\x01"),
+Section(".strtab", 0x0, "\x7f\x45\x4c\x46\x02\x01\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x03\x00\xb7\x00\x01\x00\x00\x00\x00\x06\x00\x00\x00\x00\x00\x00\x40\x00\x00\x00\x00\x00\x00\x00\x10\x1c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x40\x00\x38\x00\x09\x00\x40\x00\x1d\x00\x1c\x00\x06\x00\x00\x00\x04\x00\x00\x00\x40\x00\x00\x00\x00\x00\x00\x00\x40\x00\x00\x00\x00\x00\x00\x00\x40\x00\x00\x00\x00\x00\x00\x00\xf8\x01\x00\x00\x00\x00\x00\x00\xf8\x01\x00\x00\x00\x00\x00\x00\x08\x00\x00\x00\x00\x00\x00\x00\x03\x00\x00\x00\x04\x00\x00\x00\x38\x02\x00\x00\x00\x00\x00\x00\x38\x02\x00\x00\x00\x00\x00\x00\x38\x02\x00\x00\x00\x00\x00\x00\x1b\x00\x00\x00\x00\x00\x00\x00\x1b\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x05\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd0\x08\x00\x00\x00\x00\x00\x00\xd0\x08\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x00\x00\x01\x00\x00\x00\x06\x00\x00\x00\xc8\x0d\x00\x00\x00\x00\x00\x00\xc8\x0d\x01\x00\x00\x00\x00\x00\xc8\x0d\x01\x00\x00\x00\x00\x00\x68\x02\x00\x00\x00\x00\x00\x00\x70\x02\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x00\x00\x02\x00\x00\x00\x06\x00\x00\x00\xd8\x0d\x00\x00\x00\x00\x00\x00\xd8\x0d\x01\x00\x00\x00\x00\x00\xd8\x0d\x01\x00\x00\x00\x00\x00\xe0\x01\x00\x00\x00\x00\x00\x00\xe0\x01\x00\x00\x00\x00\x00\x00\x08\x00\x00\x00\x00\x00\x00\x00\x04\x00\x00\x00\x04\x00\x00\x00\x54\x02\x00\x00\x00\x00\x00\x00\x54\x02\x00\x00\x00\x00\x00\x00\x54\x02\x00\x00\x00\x00\x00\x00\x44\x00\x00\x00\x00\x00\x00\x00\x44\x00\x00\x00\x00\x00\x00\x00\x04\x00\x00\x00\x00\x00\x00\x00\x50\xe5\x74\x64\x04\x00\x00\x00\xb8\x07\x00\x00\x00\x00\x00\x00\xb8\x07\x00\x00\x00\x00\x00\x00\xb8\x07\x00\x00\x00\x00\x00\x00\x44\x00\x00\x00\x00\x00\x00\x00\x44\x00\x00\x00\x00\x00\x00\x00\x04\x00\x00\x00\x00\x00\x00\x00\x51\xe5\x74\x64\x06\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x10\x00\x00\x00\x00\x00\x00\x00\x52\xe5\x74\x64\x04\x00\x00\x00\xc8\x0d\x00\x00\x00\x00\x00\x00\xc8\x0d\x01\x00\x00\x00\x00\x00\xc8\x0d\x01\x00\x00\x00\x00\x00\x38\x02\x00\x00\x00\x00\x00\x00\x38\x02\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00\x2f\x6c"),
+Section(".symtab", 0x0, "\x7f\x45\x4c\x46\x02\x01\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x03\x00\xb7\x00\x01\x00\x00\x00\x00\x06\x00\x00\x00\x00\x00\x00\x40\x00\x00\x00\x00\x00\x00\x00\x10\x1c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x40\x00\x38\x00\x09\x00\x40\x00\x1d\x00\x1c\x00\x06\x00\x00\x00\x04\x00\x00\x00\x40\x00\x00\x00\x00\x00\x00\x00\x40\x00\x00\x00\x00\x00\x00\x00\x40\x00\x00\x00\x00\x00\x00\x00\xf8\x01\x00\x00\x00\x00\x00\x00\xf8\x01\x00\x00\x00\x00\x00\x00\x08\x00\x00\x00\x00\x00\x00\x00\x03\x00\x00\x00\x04\x00\x00\x00\x38\x02\x00\x00\x00\x00\x00\x00\x38\x02\x00\x00\x00\x00\x00\x00\x38\x02\x00\x00\x00\x00\x00\x00\x1b\x00\x00\x00\x00\x00\x00\x00\x1b\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x05\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd0\x08\x00\x00\x00\x00\x00\x00\xd0\x08\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x00\x00\x01\x00\x00\x00\x06\x00\x00\x00\xc8\x0d\x00\x00\x00\x00\x00\x00\xc8\x0d\x01\x00\x00\x00\x00\x00\xc8\x0d\x01\x00\x00\x00\x00\x00\x68\x02\x00\x00\x00\x00\x00\x00\x70\x02\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x00\x00\x02\x00\x00\x00\x06\x00\x00\x00\xd8\x0d\x00\x00\x00\x00\x00\x00\xd8\x0d\x01\x00\x00\x00\x00\x00\xd8\x0d\x01\x00\x00\x00\x00\x00\xe0\x01\x00\x00\x00\x00\x00\x00\xe0\x01\x00\x00\x00\x00\x00\x00\x08\x00\x00\x00\x00\x00\x00\x00\x04\x00\x00\x00\x04\x00\x00\x00\x54\x02\x00\x00\x00\x00\x00\x00\x54\x02\x00\x00\x00\x00\x00\x00\x54\x02\x00\x00\x00\x00\x00\x00\x44\x00\x00\x00\x00\x00\x00\x00\x44\x00\x00\x00\x00\x00\x00\x00\x04\x00\x00\x00\x00\x00\x00\x00\x50\xe5\x74\x64\x04\x00\x00\x00\xb8\x07\x00\x00\x00\x00\x00\x00\xb8\x07\x00\x00\x00\x00\x00\x00\xb8\x07\x00\x00\x00\x00\x00\x00\x44\x00\x00\x00\x00\x00\x00\x00\x44\x00\x00\x00\x00\x00\x00\x00\x04\x00\x00\x00\x00\x00\x00\x00\x51\xe5\x74\x64\x06\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x10\x00\x00\x00\x00\x00\x00\x00\x52\xe5\x74\x64\x04\x00\x00\x00\xc8\x0d\x00\x00\x00\x00\x00\x00\xc8\x0d\x01\x00\x00\x00\x00\x00\xc8\x0d\x01\x00\x00\x00\x00\x00\x38\x02\x00\x00\x00\x00\x00\x00\x38\x02\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00\x2f\x6c\x69\x62\x2f\x6c\x64\x2d\x6c\x69\x6e\x75\x78\x2d\x61\x61\x72\x63\x68\x36\x34\x2e\x73\x6f\x2e\x31\x00\x00\x04\x00\x00\x00\x14\x00\x00\x00\x03\x00\x00\x00\x47\x4e\x55\x00\x75\xee\xa3\x81\x5a\xcb\x3c\xbb\xd6\xda\x03\x86\xf7\x5e\x45\x89\x13\xf4\x8c\xfe\x04\x00\x00\x00\x10\x00\x00\x00\x01\x00\x00\x00\x47\x4e\x55\x00\x00\x00\x00\x00\x03\x00\x00\x00\x07\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x03\x00\x0b\x00\x80\x05\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x03\x00\x17\x00\x20\x10\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x10\x00\x00\x00\x12\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x48\x00\x00\x00\x20\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x22\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x64\x00\x00\x00\x20\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x22\x00\x00\x00\x12\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x73\x00\x00\x00\x20\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5f\x5f\x63\x78\x61\x5f\x66\x69\x6e\x61\x6c\x69\x7a\x65\x00\x5f\x5f\x6c\x69\x62\x63\x5f\x73\x74\x61\x72\x74\x5f\x6d\x61\x69\x6e\x00\x61\x62\x6f\x72\x74\x00\x6c\x69\x62\x63\x2e\x73\x6f\x2e\x36\x00\x47\x4c\x49\x42\x43\x5f\x32\x2e\x31\x37\x00\x47\x4c\x49\x42\x43\x5f\x32\x2e\x33\x34\x00\x5f\x49\x54\x4d\x5f\x64\x65\x72\x65\x67\x69\x73\x74\x65\x72\x54\x4d\x43\x6c\x6f\x6e\x65\x54\x61\x62\x6c\x65\x00\x5f\x5f\x67\x6d\x6f\x6e\x5f\x73\x74\x61\x72\x74\x5f\x5f\x00\x5f\x49\x54\x4d\x5f\x72\x65\x67\x69\x73\x74\x65\x72\x54\x4d\x43\x6c\x6f\x6e\x65\x54\x61\x62\x6c\x65\x00\x00\x00\x00\x00\x00\x00\x00\x02\x00\x01\x00\x03\x00\x01\x00\x03\x00\x01\x00\x01\x00\x02\x00\x28\x00\x00\x00\x10\x00\x00\x00\x00\x00\x00\x00\x97\x91\x96\x06\x00\x00\x03\x00\x32\x00\x00\x00\x10\x00\x00\x00\xb4\x91\x96\x06\x00\x00\x02\x00\x3d\x00\x00\x00\x00\x00\x00\x00\xc8\x0d\x01\x00\x00\x00\x00\x00\x03\x04\x00\x00\x00\x00\x00\x00\x10\x07\x00\x00\x00\x00\x00\x00\xd0\x0d\x01\x00\x00\x00\x00\x00\x03\x04\x00\x00\x00\x00\x00\x00\xc0\x06\x00\x00\x00\x00\x00\x00\xd8\x0f\x01\x00\x00\x00\x00\x00\x03\x04\x00\x00\x00\x00\x00\x00\x44\x07\x00\x00\x00\x00\x00\x00\x28\x10\x01\x00\x00\x00\x00\x00\x03\x04\x00\x00\x00\x00\x00\x00\x28\x10\x01\x00\x00\x00\x00\x00\xc0\x0f\x01\x00\x00\x00\x00\x00\x01\x04\x00\x00\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc8\x0f\x01\x00\x00\x00\x00\x00\x01\x04\x00\x00\x05\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd0\x0f\x01\x00\x00\x00\x00\x00\x01\x04\x00\x00\x06\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe0\x0f\x01\x00\x00\x00\x00\x00\x01\x04\x00\x00\x08\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x10\x01\x00\x00\x00\x00\x00\x02\x04\x00\x00\x03\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x08\x10\x01\x00\x00\x00\x00\x00\x02\x04\x00\x00\x05\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x10\x10\x01\x00\x00\x00\x00\x00\x02\x04\x00\x00\x06\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x18\x10\x01\x00\x00\x00\x00\x00\x02\x04\x00\x00\x07\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1f\x20\x03\xd5\xfd\x7b\xbf\xa9\xfd\x03\x00\x91\x2a\x00\x00\x94\xfd\x7b\xc1\xa8\xc0\x03\x5f\xd6\x00\x00\x00\x00\x00\x00\x00\x00\xf0\x7b\xbf\xa9\x90\x00\x00\x90\x11\xfe\x47\xf9\x10\xe2\x3f\x91\x20\x02\x1f\xd6\x1f\x20\x03\xd5\x1f\x20\x03\xd5\x1f\x20\x03\xd5\x90\x00\x00\xb0\x11\x02\x40\xf9\x10\x02\x00\x91\x20\x02\x1f\xd6\x90\x00\x00\xb0\x11\x06\x40\xf9\x10\x22\x00\x91\x20\x02\x1f\xd6\x90\x00\x00\xb0\x11\x0a\x40\xf9\x10\x42\x00\x91\x20\x02\x1f\xd6\x90\x00\x00\xb0\x11\x0e\x40\xf9\x10\x62\x00\x91\x20\x02\x1f\xd6\x1f\x20\x03\xd5\x1d\x00\x80\xd2\x1e\x00\x80\xd2\xe5\x03\x00\xaa\xe1\x03\x40\xf9\xe2\x23\x00\x91\xe6\x03\x00\x91\x80\x00\x00\x90\x00\xec\x47\xf9\x03\x00\x80\xd2\x04\x00\x80\xd2\xe5\xff\xff\x97\xf0\xff\xff\x97\x80\x00\x00\x90\x00\xe8\x47\xf9\x40\x00\x00\xb4\xe8\xff\xff\x17\xc0\x03\x5f\xd6\x1f\x20\x03\xd5\x1f\x20\x03\xd5\x80\x00\x00\xb0\x00\xc0\x00\x91\x81\x00\x00\xb0\x21\xc0\x00\x91\x3f\x00\x00\xeb\xc0\x00\x00\x54\x81\x00\x00\x90\x21\xe0\x47\xf9\x61\x00\x00\xb4\xf0\x03\x01\xaa\x00\x02\x1f\xd6\xc0\x03\x5f\xd6\x80\x00\x00\xb0\x00\xc0\x00\x91\x81\x00\x00\xb0\x21\xc0\x00\x91\x21\x00\x00\xcb\x22\xfc\x7f\xd3\x41\x0c\x81\x8b\x21\xfc\x41\x93\xc1\x00\x00\xb4\x82\x00\x00\x90\x42\xf0\x47\xf9\x62\x00\x00\xb4\xf0\x03\x02\xaa\x00\x02\x1f\xd6\xc0\x03\x5f\xd6\x1f\x20\x03\xd5\xfd\x7b\xbe\xa9\xfd\x03\x00\x91\xf3\x0b\x00\xf9\x93\x00\x00\xb0\x60\xc2\x40\x39\x40\x01\x00\x35\x80\x00\x00\x90\x00\xe4\x47\xf9\x80\x00\x00\xb4\x80\x00\x00\xb0\x00\x14\x40\xf9\xb9\xff\xff\x97\xd8\xff\xff\x97\x20\x00\x80\x52\x60\xc2\x00\x39\xf3\x0b\x40\xf9\xfd\x7b\xc2\xa8\xc0\x03\x5f\xd6\x1f\x20\x03\xd5\x1f\x20\x03\xd5\xdc\xff\xff\x17\xff\x43\x00\xd1\xe8\x03\x00\x91\x7f\x0c\x00\x71\x09\xc9\x23\x8b\x08\x21\x00\x91\x28\xb1\x88\x9a\xe0\x07\x00\x29\xe2\x7f\x01\x29\x08\x01\x40\xb9\x00\x05\x00\x11\xff\x43\x00\x91\xc0\x03\x5f\xd6\xff\x43\x00\xd1\x09\x10\x00\x11\x0b\x08\x00\x0b\xc8\x00\x80\x52\xea\x03\x00\x91\x0d\x7c\x7e\x93\x08\x01\x00\x4b\x4c\x21\x00\x91\x1f\x0c\x00\x71\x4a\x01\x0d\x8b\xe9\x2f\x00\x29\x49\xb1\x8c\x9a\x4d\x0b\x80\x52\x4a\xb1\x8c\x9a\xe8\x7f\x01\x29\x29\x01\x40\xb9\xeb\x23\x00\x29\xed\x07\x00\xf9\x48\x01\x40\xb9\x28\x01\x08\x0b\x00\x09\x00\x11\xff\x43\x00\x91\xc0\x03\x5f\xd6\x1f\x20\x03\xd5\xfd\x7b\xbf\xa9\xfd\x03\x00\x91\xfd\x7b\xc1\xa8\xc0\x03\x5f\xd6\x01\x00\x02\x00\x01\x1b\x03\x3b\x44\x00\x00\x00\x07\x00\x00\x00\x48\xfe\xff\xff\x5c\x00\x00\x00\x98\xfe\xff\xff\x70\x00\x00\x00\xc8\xfe\xff\xff\x84\x00\x00\x00\x08\xff\xff\xff\x98\x00\x00\x00\x58\xff\xff\xff\xbc\x00\x00\x00\x5c\xff\xff\xff\xe4\x00\x00\x00\x8c\xff\xff\xff\xfc\x00\x00\x00\x00\x00\x00\x00\x10\x00\x00\x00\x00\x00\x00\x00\x01\x7a\x52\x00\x04\x78\x1e\x01\x1b\x0c\x1f\x00\x10\x00\x00\x00\x18\x00\x00\x00\xe4\xfd\xff\xff\x34\x00\x00\x00\x00\x41\x07\x1e\x10\x00\x00\x00\x2c\x00\x00\x00\x20\xfe\xff\xff\x30\x00\x00\x00\x00\x00\x00\x00\x10\x00\x00\x00\x40\x00\x00\x00\x3c\xfe\xff\xff\x3c\x00\x00\x00\x00\x00\x00\x00\x20\x00\x00\x00\x54\x00\x00\x00"),
+Section(".comment", 0x0, "\x7f\x45\x4c\x46\x02\x01\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x03\x00\xb7\x00\x01\x00\x00\x00\x00\x06\x00\x00\x00\x00\x00\x00\x40\x00\x00\x00\x00\x00\x00\x00\x10\x1c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x40\x00\x38\x00\x09\x00\x40\x00\x1d\x00\x1c\x00\x06\x00\x00\x00\x04\x00\x00"),
+Section(".interp", 0x238, "\x2f\x6c\x69\x62\x2f\x6c\x64\x2d\x6c\x69\x6e\x75\x78\x2d\x61\x61\x72\x63\x68\x36\x34\x2e\x73\x6f\x2e\x31\x00"),
+Section(".note.gnu.build-id", 0x254, "\x04\x00\x00\x00\x14\x00\x00\x00\x03\x00\x00\x00\x47\x4e\x55\x00\x75\xee\xa3\x81\x5a\xcb\x3c\xbb\xd6\xda\x03\x86\xf7\x5e\x45\x89\x13\xf4\x8c\xfe"),
+Section(".note.ABI-tag", 0x278, "\x04\x00\x00\x00\x10\x00\x00\x00\x01\x00\x00\x00\x47\x4e\x55\x00\x00\x00\x00\x00\x03\x00\x00\x00\x07\x00\x00\x00\x00\x00\x00\x00"),
+Section(".gnu.hash", 0x298, "\x01\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"),
+Section(".dynsym", 0x2B8, "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x03\x00\x0b\x00\x80\x05\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x03\x00\x17\x00\x20\x10\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x10\x00\x00\x00\x12\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x48\x00\x00\x00\x20\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x22\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x64\x00\x00\x00\x20\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x22\x00\x00\x00\x12\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x73\x00\x00\x00\x20\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"),
+Section(".dynstr", 0x390, "\x00\x5f\x5f\x63\x78\x61\x5f\x66\x69\x6e\x61\x6c\x69\x7a\x65\x00\x5f\x5f\x6c\x69\x62\x63\x5f\x73\x74\x61\x72\x74\x5f\x6d\x61\x69\x6e\x00\x61\x62\x6f\x72\x74\x00\x6c\x69\x62\x63\x2e\x73\x6f\x2e\x36\x00\x47\x4c\x49\x42\x43\x5f\x32\x2e\x31\x37\x00\x47\x4c\x49\x42\x43\x5f\x32\x2e\x33\x34\x00\x5f\x49\x54\x4d\x5f\x64\x65\x72\x65\x67\x69\x73\x74\x65\x72\x54\x4d\x43\x6c\x6f\x6e\x65\x54\x61\x62\x6c\x65\x00\x5f\x5f\x67\x6d\x6f\x6e\x5f\x73\x74\x61\x72\x74\x5f\x5f\x00\x5f\x49\x54\x4d\x5f\x72\x65\x67\x69\x73\x74\x65\x72\x54\x4d\x43\x6c\x6f\x6e\x65\x54\x61\x62\x6c\x65\x00"),
+Section(".gnu.version", 0x41E, "\x00\x00\x00\x00\x00\x00\x02\x00\x01\x00\x03\x00\x01\x00\x03\x00\x01\x00"),
+Section(".gnu.version_r", 0x430, "\x01\x00\x02\x00\x28\x00\x00\x00\x10\x00\x00\x00\x00\x00\x00\x00\x97\x91\x96\x06\x00\x00\x03\x00\x32\x00\x00\x00\x10\x00\x00\x00\xb4\x91\x96\x06\x00\x00\x02\x00\x3d\x00\x00\x00\x00\x00\x00\x00"),
+Section(".rela.dyn", 0x460, "\xc8\x0d\x01\x00\x00\x00\x00\x00\x03\x04\x00\x00\x00\x00\x00\x00\x10\x07\x00\x00\x00\x00\x00\x00\xd0\x0d\x01\x00\x00\x00\x00\x00\x03\x04\x00\x00\x00\x00\x00\x00\xc0\x06\x00\x00\x00\x00\x00\x00\xd8\x0f\x01\x00\x00\x00\x00\x00\x03\x04\x00\x00\x00\x00\x00\x00\x44\x07\x00\x00\x00\x00\x00\x00\x28\x10\x01\x00\x00\x00\x00\x00\x03\x04\x00\x00\x00\x00\x00\x00\x28\x10\x01\x00\x00\x00\x00\x00\xc0\x0f\x01\x00\x00\x00\x00\x00\x01\x04\x00\x00\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc8\x0f\x01\x00\x00\x00\x00\x00\x01\x04\x00\x00\x05\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd0\x0f\x01\x00\x00\x00\x00\x00\x01\x04\x00\x00\x06\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe0\x0f\x01\x00\x00\x00\x00\x00\x01\x04\x00\x00\x08\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"),
+Section(".rela.plt", 0x520, "\x00\x10\x01\x00\x00\x00\x00\x00\x02\x04\x00\x00\x03\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x08\x10\x01\x00\x00\x00\x00\x00\x02\x04\x00\x00\x05\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x10\x10\x01\x00\x00\x00\x00\x00\x02\x04\x00\x00\x06\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x18\x10\x01\x00\x00\x00\x00\x00\x02\x04\x00\x00\x07\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"),
+Section(".init", 0x580, "\x1f\x20\x03\xd5\xfd\x7b\xbf\xa9\xfd\x03\x00\x91\x2a\x00\x00\x94\xfd\x7b\xc1\xa8\xc0\x03\x5f\xd6"),
+Section(".plt", 0x5A0, "\xf0\x7b\xbf\xa9\x90\x00\x00\x90\x11\xfe\x47\xf9\x10\xe2\x3f\x91\x20\x02\x1f\xd6\x1f\x20\x03\xd5\x1f\x20\x03\xd5\x1f\x20\x03\xd5\x90\x00\x00\xb0\x11\x02\x40\xf9\x10\x02\x00\x91\x20\x02\x1f\xd6\x90\x00\x00\xb0\x11\x06\x40\xf9\x10\x22\x00\x91\x20\x02\x1f\xd6\x90\x00\x00\xb0\x11\x0a\x40\xf9\x10\x42\x00\x91\x20\x02\x1f\xd6\x90\x00\x00\xb0\x11\x0e\x40\xf9\x10\x62\x00\x91\x20\x02\x1f\xd6"),
+Section(".text", 0x600, "\x1f\x20\x03\xd5\x1d\x00\x80\xd2\x1e\x00\x80\xd2\xe5\x03\x00\xaa\xe1\x03\x40\xf9\xe2\x23\x00\x91\xe6\x03\x00\x91\x80\x00\x00\x90\x00\xec\x47\xf9\x03\x00\x80\xd2\x04\x00\x80\xd2\xe5\xff\xff\x97\xf0\xff\xff\x97\x80\x00\x00\x90\x00\xe8\x47\xf9\x40\x00\x00\xb4\xe8\xff\xff\x17\xc0\x03\x5f\xd6\x1f\x20\x03\xd5\x1f\x20\x03\xd5\x80\x00\x00\xb0\x00\xc0\x00\x91\x81\x00\x00\xb0\x21\xc0\x00\x91\x3f\x00\x00\xeb\xc0\x00\x00\x54\x81\x00\x00\x90\x21\xe0\x47\xf9\x61\x00\x00\xb4\xf0\x03\x01\xaa\x00\x02\x1f\xd6\xc0\x03\x5f\xd6\x80\x00\x00\xb0\x00\xc0\x00\x91\x81\x00\x00\xb0\x21\xc0\x00\x91\x21\x00\x00\xcb\x22\xfc\x7f\xd3\x41\x0c\x81\x8b\x21\xfc\x41\x93\xc1\x00\x00\xb4\x82\x00\x00\x90\x42\xf0\x47\xf9\x62\x00\x00\xb4\xf0\x03\x02\xaa\x00\x02\x1f\xd6\xc0\x03\x5f\xd6\x1f\x20\x03\xd5\xfd\x7b\xbe\xa9\xfd\x03\x00\x91\xf3\x0b\x00\xf9\x93\x00\x00\xb0\x60\xc2\x40\x39\x40\x01\x00\x35\x80\x00\x00\x90\x00\xe4\x47\xf9\x80\x00\x00\xb4\x80\x00\x00\xb0\x00\x14\x40\xf9\xb9\xff\xff\x97\xd8\xff\xff\x97\x20\x00\x80\x52\x60\xc2\x00\x39\xf3\x0b\x40\xf9\xfd\x7b\xc2\xa8\xc0\x03\x5f\xd6\x1f\x20\x03\xd5\x1f\x20\x03\xd5\xdc\xff\xff\x17\xff\x43\x00\xd1\xe8\x03\x00\x91\x7f\x0c\x00\x71\x09\xc9\x23\x8b\x08\x21\x00\x91\x28\xb1\x88\x9a\xe0\x07\x00\x29\xe2\x7f\x01\x29\x08\x01\x40\xb9\x00\x05\x00\x11\xff\x43\x00\x91\xc0\x03\x5f\xd6\xff\x43\x00\xd1\x09\x10\x00\x11\x0b\x08\x00\x0b\xc8\x00\x80\x52\xea\x03\x00\x91\x0d\x7c\x7e\x93\x08\x01\x00\x4b\x4c\x21\x00\x91\x1f\x0c\x00\x71\x4a\x01\x0d\x8b\xe9\x2f\x00\x29\x49\xb1\x8c\x9a\x4d\x0b\x80\x52\x4a\xb1\x8c\x9a\xe8\x7f\x01\x29\x29\x01\x40\xb9\xeb\x23\x00\x29\xed\x07\x00\xf9\x48\x01\x40\xb9\x28\x01\x08\x0b\x00\x09\x00\x11\xff\x43\x00\x91\xc0\x03\x5f\xd6"),
+Section(".fini", 0x7A0, "\x1f\x20\x03\xd5\xfd\x7b\xbf\xa9\xfd\x03\x00\x91\xfd\x7b\xc1\xa8\xc0\x03\x5f\xd6"),
+Section(".rodata", 0x7B4, "\x01\x00\x02\x00"),
+Section(".eh_frame_hdr", 0x7B8, "\x01\x1b\x03\x3b\x44\x00\x00\x00\x07\x00\x00\x00\x48\xfe\xff\xff\x5c\x00\x00\x00\x98\xfe\xff\xff\x70\x00\x00\x00\xc8\xfe\xff\xff\x84\x00\x00\x00\x08\xff\xff\xff\x98\x00\x00\x00\x58\xff\xff\xff\xbc\x00\x00\x00\x5c\xff\xff\xff\xe4\x00\x00\x00\x8c\xff\xff\xff\xfc\x00\x00\x00"),
+Section(".eh_frame", 0x800, "\x10\x00\x00\x00\x00\x00\x00\x00\x01\x7a\x52\x00\x04\x78\x1e\x01\x1b\x0c\x1f\x00\x10\x00\x00\x00\x18\x00\x00\x00\xe4\xfd\xff\xff\x34\x00\x00\x00\x00\x41\x07\x1e\x10\x00\x00\x00\x2c\x00\x00\x00\x20\xfe\xff\xff\x30\x00\x00\x00\x00\x00\x00\x00\x10\x00\x00\x00\x40\x00\x00\x00\x3c\xfe\xff\xff\x3c\x00\x00\x00\x00\x00\x00\x00\x20\x00\x00\x00\x54\x00\x00\x00\x68\xfe\xff\xff\x48\x00\x00\x00\x00\x41\x0e\x20\x9d\x04\x9e\x03\x42\x93\x02\x4e\xde\xdd\xd3\x0e\x00\x00\x00\x00\x10\x00\x00\x00\x78\x00\x00\x00\x94\xfe\xff\xff\x04\x00\x00\x00\x00\x00\x00\x00\x10\x00\x00\x00\x00\x00\x00\x00\x01\x7a\x52\x00\x01\x7c\x1e\x01\x1b\x0c\x1f\x00\x14\x00\x00\x00\x18\x00\x00\x00\x70\xfe\xff\xff\x30\x00\x00\x00\x00\x44\x0e\x10\x68\x0e\x00\x00\x14\x00\x00\x00\x30\x00\x00\x00\x88\xfe\xff\xff\x5c\x00\x00\x00\x00\x44\x0e\x10\x02\x54\x0e\x00\x00\x00\x00\x00"),
+Section(".fini_array", 0x10DD0, "\xc0\x06\x00\x00\x00\x00\x00\x00"),
+Section(".dynamic", 0x10DD8, "\x01\x00\x00\x00\x00\x00\x00\x00\x28\x00\x00\x00\x00\x00\x00\x00\x0c\x00\x00\x00\x00\x00\x00\x00\x80\x05\x00\x00\x00\x00\x00\x00\x0d\x00\x00\x00\x00\x00\x00\x00\xa0\x07\x00\x00\x00\x00\x00\x00\x19\x00\x00\x00\x00\x00\x00\x00\xc8\x0d\x01\x00\x00\x00\x00\x00\x1b\x00\x00\x00\x00\x00\x00\x00\x08\x00\x00\x00\x00\x00\x00\x00\x1a\x00\x00\x00\x00\x00\x00\x00\xd0\x0d\x01\x00\x00\x00\x00\x00\x1c\x00\x00\x00\x00\x00\x00\x00\x08\x00\x00\x00\x00\x00\x00\x00\xf5\xfe\xff\x6f\x00\x00\x00\x00\x98\x02\x00\x00\x00\x00\x00\x00\x05\x00\x00\x00\x00\x00\x00\x00\x90\x03\x00\x00\x00\x00\x00\x00\x06\x00\x00\x00\x00\x00\x00\x00\xb8\x02\x00\x00\x00\x00\x00\x00\x0a\x00\x00\x00\x00\x00\x00\x00\x8d\x00\x00\x00\x00\x00\x00\x00\x0b\x00\x00\x00\x00\x00\x00\x00\x18\x00\x00\x00\x00\x00\x00\x00\x15\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x03\x00\x00\x00\x00\x00\x00\x00\xe8\x0f\x01\x00\x00\x00\x00\x00\x02\x00\x00\x00\x00\x00\x00\x00\x60\x00\x00\x00\x00\x00\x00\x00\x14\x00\x00\x00\x00\x00\x00\x00\x07\x00\x00\x00\x00\x00\x00\x00\x17\x00\x00\x00\x00\x00\x00\x00\x20\x05\x00\x00\x00\x00\x00\x00\x07\x00\x00\x00\x00\x00\x00\x00\x60\x04\x00\x00\x00\x00\x00\x00\x08\x00\x00\x00\x00\x00\x00\x00\xc0\x00\x00\x00\x00\x00\x00\x00\x09\x00\x00\x00\x00\x00\x00\x00\x18\x00\x00\x00\x00\x00\x00\x00\xfb\xff\xff\x6f\x00\x00\x00\x00\x00\x00\x00\x08\x00\x00\x00\x00\xfe\xff\xff\x6f\x00\x00\x00\x00\x30\x04\x00\x00\x00\x00\x00\x00\xff\xff\xff\x6f\x00\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00\xf0\xff\xff\x6f\x00\x00\x00\x00\x1e\x04\x00\x00\x00\x00\x00\x00\xf9\xff\xff\x6f\x00\x00\x00\x00\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"),
+Section(".got", 0x10FB8, "\xd8\x0d\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x44\x07\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"),
+Section(".got.plt", 0x10FE8, "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x05\x00\x00\x00\x00\x00\x00\xa0\x05\x00\x00\x00\x00\x00\x00\xa0\x05\x00\x00\x00\x00\x00\x00\xa0\x05\x00\x00\x00\x00\x00\x00"),
+Section(".data", 0x11020, "\x00\x00\x00\x00\x00\x00\x00\x00\x28\x10\x01\x00\x00\x00\x00\x00"),
+Section(".init_array", 0x10DC8, "\x10\x07\x00\x00\x00\x00\x00\x00")]),
+Memmap([Annotation(Region(0x0,0x8CF), Attr("segment","02 0 2256")),
+Annotation(Region(0x600,0x633), Attr("symbol","\"_start\"")),
+Annotation(Region(0x0,0x102), Attr("section","\".shstrtab\"")),
+Annotation(Region(0x0,0x239), Attr("section","\".strtab\"")),
+Annotation(Region(0x0,0x857), Attr("section","\".symtab\"")),
+Annotation(Region(0x0,0x46), Attr("section","\".comment\"")),
+Annotation(Region(0x238,0x252), Attr("section","\".interp\"")),
+Annotation(Region(0x254,0x277), Attr("section","\".note.gnu.build-id\"")),
+Annotation(Region(0x278,0x297), Attr("section","\".note.ABI-tag\"")),
+Annotation(Region(0x298,0x2B3), Attr("section","\".gnu.hash\"")),
+Annotation(Region(0x2B8,0x38F), Attr("section","\".dynsym\"")),
+Annotation(Region(0x390,0x41C), Attr("section","\".dynstr\"")),
+Annotation(Region(0x41E,0x42F), Attr("section","\".gnu.version\"")),
+Annotation(Region(0x430,0x45F), Attr("section","\".gnu.version_r\"")),
+Annotation(Region(0x460,0x51F), Attr("section","\".rela.dyn\"")),
+Annotation(Region(0x520,0x57F), Attr("section","\".rela.plt\"")),
+Annotation(Region(0x580,0x597), Attr("section","\".init\"")),
+Annotation(Region(0x5A0,0x5FF), Attr("section","\".plt\"")),
+Annotation(Region(0x580,0x597), Attr("code-region","()")),
+Annotation(Region(0x5A0,0x5FF), Attr("code-region","()")),
+Annotation(Region(0x600,0x633), Attr("symbol-info","_start 0x600 52")),
+Annotation(Region(0x634,0x647), Attr("symbol","\"call_weak_fn\"")),
+Annotation(Region(0x634,0x647), Attr("symbol-info","call_weak_fn 0x634 20")),
+Annotation(Region(0x714,0x743), Attr("symbol","\"test\"")),
+Annotation(Region(0x600,0x79F), Attr("section","\".text\"")),
+Annotation(Region(0x600,0x79F), Attr("code-region","()")),
+Annotation(Region(0x714,0x743), Attr("symbol-info","test 0x714 48")),
+Annotation(Region(0x744,0x79F), Attr("symbol","\"main\"")),
+Annotation(Region(0x744,0x79F), Attr("symbol-info","main 0x744 92")),
+Annotation(Region(0x7A0,0x7B3), Attr("section","\".fini\"")),
+Annotation(Region(0x7A0,0x7B3), Attr("code-region","()")),
+Annotation(Region(0x7B4,0x7B7), Attr("section","\".rodata\"")),
+Annotation(Region(0x7B8,0x7FB), Attr("section","\".eh_frame_hdr\"")),
+Annotation(Region(0x800,0x8CF), Attr("section","\".eh_frame\"")),
+Annotation(Region(0x10DC8,0x1102F), Attr("segment","03 0x10DC8 624")),
+Annotation(Region(0x10DD0,0x10DD7), Attr("section","\".fini_array\"")),
+Annotation(Region(0x10DD8,0x10FB7), Attr("section","\".dynamic\"")),
+Annotation(Region(0x10FB8,0x10FE7), Attr("section","\".got\"")),
+Annotation(Region(0x10FE8,0x1101F), Attr("section","\".got.plt\"")),
+Annotation(Region(0x11020,0x1102F), Attr("section","\".data\"")),
+Annotation(Region(0x10DC8,0x10DCF), Attr("section","\".init_array\""))]),
+Program(Tid(1_876, "%00000754"), Attrs([]),
+ Subs([Sub(Tid(1_853, "@__cxa_finalize"),
+ Attrs([Attr("c.proto","signed (*)(void)"), Attr("address","0x5D0"),
+Attr("stub","()")]), "__cxa_finalize", Args([Arg(Tid(1_877, "%00000755"),
+ Attrs([Attr("c.layout","[signed : 32]"), Attr("c.data","Top:u32"),
+Attr("c.type","signed")]), Var("__cxa_finalize_result",Imm(32)),
+LOW(32,Var("R0",Imm(64))), Out())]), Blks([Blk(Tid(1_211, "@__cxa_finalize"),
+ Attrs([Attr("address","0x5D0")]), Phis([]),
+Defs([Def(Tid(1_459, "%000005b3"), Attrs([Attr("address","0x5D0"),
+Attr("insn","adrp x16, #69632")]), Var("R16",Imm(64)), Int(69632,64)),
+Def(Tid(1_466, "%000005ba"), Attrs([Attr("address","0x5D4"),
+Attr("insn","ldr x17, [x16, #0x8]")]), Var("R17",Imm(64)),
+Load(Var("mem",Mem(64,8)),PLUS(Var("R16",Imm(64)),Int(8,64)),LittleEndian(),64)),
+Def(Tid(1_472, "%000005c0"), Attrs([Attr("address","0x5D8"),
+Attr("insn","add x16, x16, #0x8")]), Var("R16",Imm(64)),
+PLUS(Var("R16",Imm(64)),Int(8,64)))]), Jmps([Call(Tid(1_477, "%000005c5"),
+ Attrs([Attr("address","0x5DC"), Attr("insn","br x17")]), Int(1,1),
+(Indirect(Var("R17",Imm(64))),))]))])),
+Sub(Tid(1_854, "@__do_global_dtors_aux"),
+ Attrs([Attr("c.proto","signed (*)(void)"), Attr("address","0x6C0")]),
+ "__do_global_dtors_aux", Args([Arg(Tid(1_878, "%00000756"),
+ Attrs([Attr("c.layout","[signed : 32]"), Attr("c.data","Top:u32"),
+Attr("c.type","signed")]), Var("__do_global_dtors_aux_result",Imm(32)),
+LOW(32,Var("R0",Imm(64))), Out())]),
+Blks([Blk(Tid(730, "@__do_global_dtors_aux"),
+ Attrs([Attr("address","0x6C0")]), Phis([]), Defs([Def(Tid(734, "%000002de"),
+ Attrs([Attr("address","0x6C0"),
+Attr("insn","stp x29, x30, [sp, #-0x20]!")]), Var("#3",Imm(64)),
+PLUS(Var("R31",Imm(64)),Int(18446744073709551584,64))),
+Def(Tid(740, "%000002e4"), Attrs([Attr("address","0x6C0"),
+Attr("insn","stp x29, x30, [sp, #-0x20]!")]), Var("mem",Mem(64,8)),
+Store(Var("mem",Mem(64,8)),Var("#3",Imm(64)),Var("R29",Imm(64)),LittleEndian(),64)),
+Def(Tid(746, "%000002ea"), Attrs([Attr("address","0x6C0"),
+Attr("insn","stp x29, x30, [sp, #-0x20]!")]), Var("mem",Mem(64,8)),
+Store(Var("mem",Mem(64,8)),PLUS(Var("#3",Imm(64)),Int(8,64)),Var("R30",Imm(64)),LittleEndian(),64)),
+Def(Tid(750, "%000002ee"), Attrs([Attr("address","0x6C0"),
+Attr("insn","stp x29, x30, [sp, #-0x20]!")]), Var("R31",Imm(64)),
+Var("#3",Imm(64))), Def(Tid(756, "%000002f4"),
+ Attrs([Attr("address","0x6C4"), Attr("insn","mov x29, sp")]),
+ Var("R29",Imm(64)), Var("R31",Imm(64))), Def(Tid(764, "%000002fc"),
+ Attrs([Attr("address","0x6C8"), Attr("insn","str x19, [sp, #0x10]")]),
+ Var("mem",Mem(64,8)),
+Store(Var("mem",Mem(64,8)),PLUS(Var("R31",Imm(64)),Int(16,64)),Var("R19",Imm(64)),LittleEndian(),64)),
+Def(Tid(769, "%00000301"), Attrs([Attr("address","0x6CC"),
+Attr("insn","adrp x19, #69632")]), Var("R19",Imm(64)), Int(69632,64)),
+Def(Tid(776, "%00000308"), Attrs([Attr("address","0x6D0"),
+Attr("insn","ldrb w0, [x19, #0x30]")]), Var("R0",Imm(64)),
+UNSIGNED(64,Load(Var("mem",Mem(64,8)),PLUS(Var("R19",Imm(64)),Int(48,64)),LittleEndian(),8)))]),
+Jmps([Goto(Tid(783, "%0000030f"), Attrs([Attr("address","0x6D4"),
+Attr("insn","cbnz w0, #0x28")]),
+ NEQ(Extract(31,0,Var("R0",Imm(64))),Int(0,32)),
+Direct(Tid(781, "%0000030d"))), Goto(Tid(1_855, "%0000073f"), Attrs([]),
+ Int(1,1), Direct(Tid(1_156, "%00000484")))])), Blk(Tid(1_156, "%00000484"),
+ Attrs([Attr("address","0x6D8")]), Phis([]),
+Defs([Def(Tid(1_159, "%00000487"), Attrs([Attr("address","0x6D8"),
+Attr("insn","adrp x0, #65536")]), Var("R0",Imm(64)), Int(65536,64)),
+Def(Tid(1_166, "%0000048e"), Attrs([Attr("address","0x6DC"),
+Attr("insn","ldr x0, [x0, #0xfc8]")]), Var("R0",Imm(64)),
+Load(Var("mem",Mem(64,8)),PLUS(Var("R0",Imm(64)),Int(4040,64)),LittleEndian(),64))]),
+Jmps([Goto(Tid(1_172, "%00000494"), Attrs([Attr("address","0x6E0"),
+Attr("insn","cbz x0, #0x10")]), EQ(Var("R0",Imm(64)),Int(0,64)),
+Direct(Tid(1_170, "%00000492"))), Goto(Tid(1_856, "%00000740"), Attrs([]),
+ Int(1,1), Direct(Tid(1_195, "%000004ab")))])), Blk(Tid(1_195, "%000004ab"),
+ Attrs([Attr("address","0x6E4")]), Phis([]),
+Defs([Def(Tid(1_198, "%000004ae"), Attrs([Attr("address","0x6E4"),
+Attr("insn","adrp x0, #69632")]), Var("R0",Imm(64)), Int(69632,64)),
+Def(Tid(1_205, "%000004b5"), Attrs([Attr("address","0x6E8"),
+Attr("insn","ldr x0, [x0, #0x28]")]), Var("R0",Imm(64)),
+Load(Var("mem",Mem(64,8)),PLUS(Var("R0",Imm(64)),Int(40,64)),LittleEndian(),64)),
+Def(Tid(1_210, "%000004ba"), Attrs([Attr("address","0x6EC"),
+Attr("insn","bl #-0x11c")]), Var("R30",Imm(64)), Int(1776,64))]),
+Jmps([Call(Tid(1_213, "%000004bd"), Attrs([Attr("address","0x6EC"),
+Attr("insn","bl #-0x11c")]), Int(1,1),
+(Direct(Tid(1_853, "@__cxa_finalize")),Direct(Tid(1_170, "%00000492"))))])),
+Blk(Tid(1_170, "%00000492"), Attrs([Attr("address","0x6F0")]), Phis([]),
+Defs([Def(Tid(1_178, "%0000049a"), Attrs([Attr("address","0x6F0"),
+Attr("insn","bl #-0xa0")]), Var("R30",Imm(64)), Int(1780,64))]),
+Jmps([Call(Tid(1_180, "%0000049c"), Attrs([Attr("address","0x6F0"),
+Attr("insn","bl #-0xa0")]), Int(1,1),
+(Direct(Tid(1_867, "@deregister_tm_clones")),Direct(Tid(1_182, "%0000049e"))))])),
+Blk(Tid(1_182, "%0000049e"), Attrs([Attr("address","0x6F4")]), Phis([]),
+Defs([Def(Tid(1_185, "%000004a1"), Attrs([Attr("address","0x6F4"),
+Attr("insn","mov w0, #0x1")]), Var("R0",Imm(64)), Int(1,64)),
+Def(Tid(1_193, "%000004a9"), Attrs([Attr("address","0x6F8"),
+Attr("insn","strb w0, [x19, #0x30]")]), Var("mem",Mem(64,8)),
+Store(Var("mem",Mem(64,8)),PLUS(Var("R19",Imm(64)),Int(48,64)),Extract(7,0,Var("R0",Imm(64))),LittleEndian(),8))]),
+Jmps([Goto(Tid(1_857, "%00000741"), Attrs([]), Int(1,1),
+Direct(Tid(781, "%0000030d")))])), Blk(Tid(781, "%0000030d"),
+ Attrs([Attr("address","0x6FC")]), Phis([]), Defs([Def(Tid(791, "%00000317"),
+ Attrs([Attr("address","0x6FC"), Attr("insn","ldr x19, [sp, #0x10]")]),
+ Var("R19",Imm(64)),
+Load(Var("mem",Mem(64,8)),PLUS(Var("R31",Imm(64)),Int(16,64)),LittleEndian(),64)),
+Def(Tid(798, "%0000031e"), Attrs([Attr("address","0x700"),
+Attr("insn","ldp x29, x30, [sp], #0x20")]), Var("R29",Imm(64)),
+Load(Var("mem",Mem(64,8)),Var("R31",Imm(64)),LittleEndian(),64)),
+Def(Tid(803, "%00000323"), Attrs([Attr("address","0x700"),
+Attr("insn","ldp x29, x30, [sp], #0x20")]), Var("R30",Imm(64)),
+Load(Var("mem",Mem(64,8)),PLUS(Var("R31",Imm(64)),Int(8,64)),LittleEndian(),64)),
+Def(Tid(807, "%00000327"), Attrs([Attr("address","0x700"),
+Attr("insn","ldp x29, x30, [sp], #0x20")]), Var("R31",Imm(64)),
+PLUS(Var("R31",Imm(64)),Int(32,64)))]), Jmps([Call(Tid(812, "%0000032c"),
+ Attrs([Attr("address","0x704"), Attr("insn","ret")]), Int(1,1),
+(Indirect(Var("R30",Imm(64))),))]))])), Sub(Tid(1_858, "@__libc_start_main"),
+ Attrs([Attr("c.proto","signed (*)(signed (*)(signed , char** , char** );* main, signed , char** , \nvoid* auxv)"),
+Attr("address","0x5C0"), Attr("stub","()")]), "__libc_start_main",
+ Args([Arg(Tid(1_879, "%00000757"),
+ Attrs([Attr("c.layout","**[<undef> : 64]"),
+Attr("c.data","Top:u64 ptr ptr"),
+Attr("c.type","signed (*)(signed , char** , char** );*")]),
+ Var("__libc_start_main_main",Imm(64)), Var("R0",Imm(64)), In()),
+Arg(Tid(1_880, "%00000758"), Attrs([Attr("c.layout","[signed : 32]"),
+Attr("c.data","Top:u32"), Attr("c.type","signed")]),
+ Var("__libc_start_main_arg2",Imm(32)), LOW(32,Var("R1",Imm(64))), In()),
+Arg(Tid(1_881, "%00000759"), Attrs([Attr("c.layout","**[char : 8]"),
+Attr("c.data","Top:u8 ptr ptr"), Attr("c.type","char**")]),
+ Var("__libc_start_main_arg3",Imm(64)), Var("R2",Imm(64)), Both()),
+Arg(Tid(1_882, "%0000075a"), Attrs([Attr("c.layout","*[<undef> : 8]"),
+Attr("c.data","{} ptr"), Attr("c.type","void*")]),
+ Var("__libc_start_main_auxv",Imm(64)), Var("R3",Imm(64)), Both()),
+Arg(Tid(1_883, "%0000075b"), Attrs([Attr("c.layout","[signed : 32]"),
+Attr("c.data","Top:u32"), Attr("c.type","signed")]),
+ Var("__libc_start_main_result",Imm(32)), LOW(32,Var("R0",Imm(64))),
+Out())]), Blks([Blk(Tid(563, "@__libc_start_main"),
+ Attrs([Attr("address","0x5C0")]), Phis([]),
+Defs([Def(Tid(1_437, "%0000059d"), Attrs([Attr("address","0x5C0"),
+Attr("insn","adrp x16, #69632")]), Var("R16",Imm(64)), Int(69632,64)),
+Def(Tid(1_444, "%000005a4"), Attrs([Attr("address","0x5C4"),
+Attr("insn","ldr x17, [x16]")]), Var("R17",Imm(64)),
+Load(Var("mem",Mem(64,8)),Var("R16",Imm(64)),LittleEndian(),64)),
+Def(Tid(1_450, "%000005aa"), Attrs([Attr("address","0x5C8"),
+Attr("insn","add x16, x16, #0x0")]), Var("R16",Imm(64)),
+Var("R16",Imm(64)))]), Jmps([Call(Tid(1_455, "%000005af"),
+ Attrs([Attr("address","0x5CC"), Attr("insn","br x17")]), Int(1,1),
+(Indirect(Var("R17",Imm(64))),))]))])), Sub(Tid(1_859, "@_fini"),
+ Attrs([Attr("c.proto","signed (*)(void)"), Attr("address","0x7A0")]),
+ "_fini", Args([Arg(Tid(1_884, "%0000075c"),
+ Attrs([Attr("c.layout","[signed : 32]"), Attr("c.data","Top:u32"),
+Attr("c.type","signed")]), Var("_fini_result",Imm(32)),
+LOW(32,Var("R0",Imm(64))), Out())]), Blks([Blk(Tid(31, "@_fini"),
+ Attrs([Attr("address","0x7A0")]), Phis([]), Defs([Def(Tid(37, "%00000025"),
+ Attrs([Attr("address","0x7A4"),
+Attr("insn","stp x29, x30, [sp, #-0x10]!")]), Var("#0",Imm(64)),
+PLUS(Var("R31",Imm(64)),Int(18446744073709551600,64))),
+Def(Tid(43, "%0000002b"), Attrs([Attr("address","0x7A4"),
+Attr("insn","stp x29, x30, [sp, #-0x10]!")]), Var("mem",Mem(64,8)),
+Store(Var("mem",Mem(64,8)),Var("#0",Imm(64)),Var("R29",Imm(64)),LittleEndian(),64)),
+Def(Tid(49, "%00000031"), Attrs([Attr("address","0x7A4"),
+Attr("insn","stp x29, x30, [sp, #-0x10]!")]), Var("mem",Mem(64,8)),
+Store(Var("mem",Mem(64,8)),PLUS(Var("#0",Imm(64)),Int(8,64)),Var("R30",Imm(64)),LittleEndian(),64)),
+Def(Tid(53, "%00000035"), Attrs([Attr("address","0x7A4"),
+Attr("insn","stp x29, x30, [sp, #-0x10]!")]), Var("R31",Imm(64)),
+Var("#0",Imm(64))), Def(Tid(59, "%0000003b"), Attrs([Attr("address","0x7A8"),
+Attr("insn","mov x29, sp")]), Var("R29",Imm(64)), Var("R31",Imm(64))),
+Def(Tid(66, "%00000042"), Attrs([Attr("address","0x7AC"),
+Attr("insn","ldp x29, x30, [sp], #0x10")]), Var("R29",Imm(64)),
+Load(Var("mem",Mem(64,8)),Var("R31",Imm(64)),LittleEndian(),64)),
+Def(Tid(71, "%00000047"), Attrs([Attr("address","0x7AC"),
+Attr("insn","ldp x29, x30, [sp], #0x10")]), Var("R30",Imm(64)),
+Load(Var("mem",Mem(64,8)),PLUS(Var("R31",Imm(64)),Int(8,64)),LittleEndian(),64)),
+Def(Tid(75, "%0000004b"), Attrs([Attr("address","0x7AC"),
+Attr("insn","ldp x29, x30, [sp], #0x10")]), Var("R31",Imm(64)),
+PLUS(Var("R31",Imm(64)),Int(16,64)))]), Jmps([Call(Tid(80, "%00000050"),
+ Attrs([Attr("address","0x7B0"), Attr("insn","ret")]), Int(1,1),
+(Indirect(Var("R30",Imm(64))),))]))])), Sub(Tid(1_860, "@_init"),
+ Attrs([Attr("c.proto","signed (*)(void)"), Attr("address","0x580")]),
+ "_init", Args([Arg(Tid(1_885, "%0000075d"),
+ Attrs([Attr("c.layout","[signed : 32]"), Attr("c.data","Top:u32"),
+Attr("c.type","signed")]), Var("_init_result",Imm(32)),
+LOW(32,Var("R0",Imm(64))), Out())]), Blks([Blk(Tid(1_660, "@_init"),
+ Attrs([Attr("address","0x580")]), Phis([]),
+Defs([Def(Tid(1_666, "%00000682"), Attrs([Attr("address","0x584"),
+Attr("insn","stp x29, x30, [sp, #-0x10]!")]), Var("#9",Imm(64)),
+PLUS(Var("R31",Imm(64)),Int(18446744073709551600,64))),
+Def(Tid(1_672, "%00000688"), Attrs([Attr("address","0x584"),
+Attr("insn","stp x29, x30, [sp, #-0x10]!")]), Var("mem",Mem(64,8)),
+Store(Var("mem",Mem(64,8)),Var("#9",Imm(64)),Var("R29",Imm(64)),LittleEndian(),64)),
+Def(Tid(1_678, "%0000068e"), Attrs([Attr("address","0x584"),
+Attr("insn","stp x29, x30, [sp, #-0x10]!")]), Var("mem",Mem(64,8)),
+Store(Var("mem",Mem(64,8)),PLUS(Var("#9",Imm(64)),Int(8,64)),Var("R30",Imm(64)),LittleEndian(),64)),
+Def(Tid(1_682, "%00000692"), Attrs([Attr("address","0x584"),
+Attr("insn","stp x29, x30, [sp, #-0x10]!")]), Var("R31",Imm(64)),
+Var("#9",Imm(64))), Def(Tid(1_688, "%00000698"),
+ Attrs([Attr("address","0x588"), Attr("insn","mov x29, sp")]),
+ Var("R29",Imm(64)), Var("R31",Imm(64))), Def(Tid(1_693, "%0000069d"),
+ Attrs([Attr("address","0x58C"), Attr("insn","bl #0xa8")]),
+ Var("R30",Imm(64)), Int(1424,64))]), Jmps([Call(Tid(1_695, "%0000069f"),
+ Attrs([Attr("address","0x58C"), Attr("insn","bl #0xa8")]), Int(1,1),
+(Direct(Tid(1_865, "@call_weak_fn")),Direct(Tid(1_697, "%000006a1"))))])),
+Blk(Tid(1_697, "%000006a1"), Attrs([Attr("address","0x590")]), Phis([]),
+Defs([Def(Tid(1_702, "%000006a6"), Attrs([Attr("address","0x590"),
+Attr("insn","ldp x29, x30, [sp], #0x10")]), Var("R29",Imm(64)),
+Load(Var("mem",Mem(64,8)),Var("R31",Imm(64)),LittleEndian(),64)),
+Def(Tid(1_707, "%000006ab"), Attrs([Attr("address","0x590"),
+Attr("insn","ldp x29, x30, [sp], #0x10")]), Var("R30",Imm(64)),
+Load(Var("mem",Mem(64,8)),PLUS(Var("R31",Imm(64)),Int(8,64)),LittleEndian(),64)),
+Def(Tid(1_711, "%000006af"), Attrs([Attr("address","0x590"),
+Attr("insn","ldp x29, x30, [sp], #0x10")]), Var("R31",Imm(64)),
+PLUS(Var("R31",Imm(64)),Int(16,64)))]), Jmps([Call(Tid(1_716, "%000006b4"),
+ Attrs([Attr("address","0x594"), Attr("insn","ret")]), Int(1,1),
+(Indirect(Var("R30",Imm(64))),))]))])), Sub(Tid(1_861, "@_start"),
+ Attrs([Attr("c.proto","signed (*)(void)"), Attr("address","0x600"),
+Attr("stub","()"), Attr("entry-point","()")]), "_start",
+ Args([Arg(Tid(1_886, "%0000075e"), Attrs([Attr("c.layout","[signed : 32]"),
+Attr("c.data","Top:u32"), Attr("c.type","signed")]),
+ Var("_start_result",Imm(32)), LOW(32,Var("R0",Imm(64))), Out())]),
+Blks([Blk(Tid(500, "@_start"), Attrs([Attr("address","0x600")]), Phis([]),
+Defs([Def(Tid(505, "%000001f9"), Attrs([Attr("address","0x604"),
+Attr("insn","mov x29, #0x0")]), Var("R29",Imm(64)), Int(0,64)),
+Def(Tid(510, "%000001fe"), Attrs([Attr("address","0x608"),
+Attr("insn","mov x30, #0x0")]), Var("R30",Imm(64)), Int(0,64)),
+Def(Tid(516, "%00000204"), Attrs([Attr("address","0x60C"),
+Attr("insn","mov x5, x0")]), Var("R5",Imm(64)), Var("R0",Imm(64))),
+Def(Tid(523, "%0000020b"), Attrs([Attr("address","0x610"),
+Attr("insn","ldr x1, [sp]")]), Var("R1",Imm(64)),
+Load(Var("mem",Mem(64,8)),Var("R31",Imm(64)),LittleEndian(),64)),
+Def(Tid(529, "%00000211"), Attrs([Attr("address","0x614"),
+Attr("insn","add x2, sp, #0x8")]), Var("R2",Imm(64)),
+PLUS(Var("R31",Imm(64)),Int(8,64))), Def(Tid(535, "%00000217"),
+ Attrs([Attr("address","0x618"), Attr("insn","mov x6, sp")]),
+ Var("R6",Imm(64)), Var("R31",Imm(64))), Def(Tid(540, "%0000021c"),
+ Attrs([Attr("address","0x61C"), Attr("insn","adrp x0, #65536")]),
+ Var("R0",Imm(64)), Int(65536,64)), Def(Tid(547, "%00000223"),
+ Attrs([Attr("address","0x620"), Attr("insn","ldr x0, [x0, #0xfd8]")]),
+ Var("R0",Imm(64)),
+Load(Var("mem",Mem(64,8)),PLUS(Var("R0",Imm(64)),Int(4056,64)),LittleEndian(),64)),
+Def(Tid(552, "%00000228"), Attrs([Attr("address","0x624"),
+Attr("insn","mov x3, #0x0")]), Var("R3",Imm(64)), Int(0,64)),
+Def(Tid(557, "%0000022d"), Attrs([Attr("address","0x628"),
+Attr("insn","mov x4, #0x0")]), Var("R4",Imm(64)), Int(0,64)),
+Def(Tid(562, "%00000232"), Attrs([Attr("address","0x62C"),
+Attr("insn","bl #-0x6c")]), Var("R30",Imm(64)), Int(1584,64))]),
+Jmps([Call(Tid(565, "%00000235"), Attrs([Attr("address","0x62C"),
+Attr("insn","bl #-0x6c")]), Int(1,1),
+(Direct(Tid(1_858, "@__libc_start_main")),Direct(Tid(567, "%00000237"))))])),
+Blk(Tid(567, "%00000237"), Attrs([Attr("address","0x630")]), Phis([]),
+Defs([Def(Tid(570, "%0000023a"), Attrs([Attr("address","0x630"),
+Attr("insn","bl #-0x40")]), Var("R30",Imm(64)), Int(1588,64))]),
+Jmps([Call(Tid(573, "%0000023d"), Attrs([Attr("address","0x630"),
+Attr("insn","bl #-0x40")]), Int(1,1),
+(Direct(Tid(1_864, "@abort")),Direct(Tid(1_862, "%00000746"))))])),
+Blk(Tid(1_862, "%00000746"), Attrs([]), Phis([]), Defs([]),
+Jmps([Call(Tid(1_863, "%00000747"), Attrs([]), Int(1,1),
+(Direct(Tid(1_865, "@call_weak_fn")),))]))])), Sub(Tid(1_864, "@abort"),
+ Attrs([Attr("noreturn","()"), Attr("c.proto","void (*)(void)"),
+Attr("address","0x5F0"), Attr("stub","()")]), "abort", Args([]),
+Blks([Blk(Tid(571, "@abort"), Attrs([Attr("address","0x5F0")]), Phis([]),
+Defs([Def(Tid(1_503, "%000005df"), Attrs([Attr("address","0x5F0"),
+Attr("insn","adrp x16, #69632")]), Var("R16",Imm(64)), Int(69632,64)),
+Def(Tid(1_510, "%000005e6"), Attrs([Attr("address","0x5F4"),
+Attr("insn","ldr x17, [x16, #0x18]")]), Var("R17",Imm(64)),
+Load(Var("mem",Mem(64,8)),PLUS(Var("R16",Imm(64)),Int(24,64)),LittleEndian(),64)),
+Def(Tid(1_516, "%000005ec"), Attrs([Attr("address","0x5F8"),
+Attr("insn","add x16, x16, #0x18")]), Var("R16",Imm(64)),
+PLUS(Var("R16",Imm(64)),Int(24,64)))]), Jmps([Call(Tid(1_521, "%000005f1"),
+ Attrs([Attr("address","0x5FC"), Attr("insn","br x17")]), Int(1,1),
+(Indirect(Var("R17",Imm(64))),))]))])), Sub(Tid(1_865, "@call_weak_fn"),
+ Attrs([Attr("c.proto","signed (*)(void)"), Attr("address","0x634")]),
+ "call_weak_fn", Args([Arg(Tid(1_887, "%0000075f"),
+ Attrs([Attr("c.layout","[signed : 32]"), Attr("c.data","Top:u32"),
+Attr("c.type","signed")]), Var("call_weak_fn_result",Imm(32)),
+LOW(32,Var("R0",Imm(64))), Out())]), Blks([Blk(Tid(575, "@call_weak_fn"),
+ Attrs([Attr("address","0x634")]), Phis([]), Defs([Def(Tid(578, "%00000242"),
+ Attrs([Attr("address","0x634"), Attr("insn","adrp x0, #65536")]),
+ Var("R0",Imm(64)), Int(65536,64)), Def(Tid(585, "%00000249"),
+ Attrs([Attr("address","0x638"), Attr("insn","ldr x0, [x0, #0xfd0]")]),
+ Var("R0",Imm(64)),
+Load(Var("mem",Mem(64,8)),PLUS(Var("R0",Imm(64)),Int(4048,64)),LittleEndian(),64))]),
+Jmps([Goto(Tid(591, "%0000024f"), Attrs([Attr("address","0x63C"),
+Attr("insn","cbz x0, #0x8")]), EQ(Var("R0",Imm(64)),Int(0,64)),
+Direct(Tid(589, "%0000024d"))), Goto(Tid(1_866, "%0000074a"), Attrs([]),
+ Int(1,1), Direct(Tid(1_275, "%000004fb")))])), Blk(Tid(589, "%0000024d"),
+ Attrs([Attr("address","0x644")]), Phis([]), Defs([]),
+Jmps([Call(Tid(597, "%00000255"), Attrs([Attr("address","0x644"),
+Attr("insn","ret")]), Int(1,1), (Indirect(Var("R30",Imm(64))),))])),
+Blk(Tid(1_275, "%000004fb"), Attrs([Attr("address","0x640")]), Phis([]),
+Defs([]), Jmps([Goto(Tid(1_278, "%000004fe"), Attrs([Attr("address","0x640"),
+Attr("insn","b #-0x60")]), Int(1,1),
+Direct(Tid(1_276, "@__gmon_start__")))])), Blk(Tid(1_276, "@__gmon_start__"),
+ Attrs([Attr("address","0x5E0")]), Phis([]),
+Defs([Def(Tid(1_481, "%000005c9"), Attrs([Attr("address","0x5E0"),
+Attr("insn","adrp x16, #69632")]), Var("R16",Imm(64)), Int(69632,64)),
+Def(Tid(1_488, "%000005d0"), Attrs([Attr("address","0x5E4"),
+Attr("insn","ldr x17, [x16, #0x10]")]), Var("R17",Imm(64)),
+Load(Var("mem",Mem(64,8)),PLUS(Var("R16",Imm(64)),Int(16,64)),LittleEndian(),64)),
+Def(Tid(1_494, "%000005d6"), Attrs([Attr("address","0x5E8"),
+Attr("insn","add x16, x16, #0x10")]), Var("R16",Imm(64)),
+PLUS(Var("R16",Imm(64)),Int(16,64)))]), Jmps([Call(Tid(1_499, "%000005db"),
+ Attrs([Attr("address","0x5EC"), Attr("insn","br x17")]), Int(1,1),
+(Indirect(Var("R17",Imm(64))),))]))])),
+Sub(Tid(1_867, "@deregister_tm_clones"),
+ Attrs([Attr("c.proto","signed (*)(void)"), Attr("address","0x650")]),
+ "deregister_tm_clones", Args([Arg(Tid(1_888, "%00000760"),
+ Attrs([Attr("c.layout","[signed : 32]"), Attr("c.data","Top:u32"),
+Attr("c.type","signed")]), Var("deregister_tm_clones_result",Imm(32)),
+LOW(32,Var("R0",Imm(64))), Out())]),
+Blks([Blk(Tid(603, "@deregister_tm_clones"),
+ Attrs([Attr("address","0x650")]), Phis([]), Defs([Def(Tid(606, "%0000025e"),
+ Attrs([Attr("address","0x650"), Attr("insn","adrp x0, #69632")]),
+ Var("R0",Imm(64)), Int(69632,64)), Def(Tid(612, "%00000264"),
+ Attrs([Attr("address","0x654"), Attr("insn","add x0, x0, #0x30")]),
+ Var("R0",Imm(64)), PLUS(Var("R0",Imm(64)),Int(48,64))),
+Def(Tid(617, "%00000269"), Attrs([Attr("address","0x658"),
+Attr("insn","adrp x1, #69632")]), Var("R1",Imm(64)), Int(69632,64)),
+Def(Tid(623, "%0000026f"), Attrs([Attr("address","0x65C"),
+Attr("insn","add x1, x1, #0x30")]), Var("R1",Imm(64)),
+PLUS(Var("R1",Imm(64)),Int(48,64))), Def(Tid(629, "%00000275"),
+ Attrs([Attr("address","0x660"), Attr("insn","cmp x1, x0")]),
+ Var("#1",Imm(64)), NOT(Var("R0",Imm(64)))), Def(Tid(634, "%0000027a"),
+ Attrs([Attr("address","0x660"), Attr("insn","cmp x1, x0")]),
+ Var("#2",Imm(64)), PLUS(Var("R1",Imm(64)),NOT(Var("R0",Imm(64))))),
+Def(Tid(640, "%00000280"), Attrs([Attr("address","0x660"),
+Attr("insn","cmp x1, x0")]), Var("VF",Imm(1)),
+NEQ(SIGNED(65,PLUS(Var("#2",Imm(64)),Int(1,64))),PLUS(PLUS(SIGNED(65,Var("R1",Imm(64))),SIGNED(65,Var("#1",Imm(64)))),Int(1,65)))),
+Def(Tid(646, "%00000286"), Attrs([Attr("address","0x660"),
+Attr("insn","cmp x1, x0")]), Var("CF",Imm(1)),
+NEQ(UNSIGNED(65,PLUS(Var("#2",Imm(64)),Int(1,64))),PLUS(PLUS(UNSIGNED(65,Var("R1",Imm(64))),UNSIGNED(65,Var("#1",Imm(64)))),Int(1,65)))),
+Def(Tid(650, "%0000028a"), Attrs([Attr("address","0x660"),
+Attr("insn","cmp x1, x0")]), Var("ZF",Imm(1)),
+EQ(PLUS(Var("#2",Imm(64)),Int(1,64)),Int(0,64))), Def(Tid(654, "%0000028e"),
+ Attrs([Attr("address","0x660"), Attr("insn","cmp x1, x0")]),
+ Var("NF",Imm(1)), Extract(63,63,PLUS(Var("#2",Imm(64)),Int(1,64))))]),
+Jmps([Goto(Tid(660, "%00000294"), Attrs([Attr("address","0x664"),
+Attr("insn","b.eq #0x18")]), EQ(Var("ZF",Imm(1)),Int(1,1)),
+Direct(Tid(658, "%00000292"))), Goto(Tid(1_868, "%0000074c"), Attrs([]),
+ Int(1,1), Direct(Tid(1_245, "%000004dd")))])), Blk(Tid(1_245, "%000004dd"),
+ Attrs([Attr("address","0x668")]), Phis([]),
+Defs([Def(Tid(1_248, "%000004e0"), Attrs([Attr("address","0x668"),
+Attr("insn","adrp x1, #65536")]), Var("R1",Imm(64)), Int(65536,64)),
+Def(Tid(1_255, "%000004e7"), Attrs([Attr("address","0x66C"),
+Attr("insn","ldr x1, [x1, #0xfc0]")]), Var("R1",Imm(64)),
+Load(Var("mem",Mem(64,8)),PLUS(Var("R1",Imm(64)),Int(4032,64)),LittleEndian(),64))]),
+Jmps([Goto(Tid(1_260, "%000004ec"), Attrs([Attr("address","0x670"),
+Attr("insn","cbz x1, #0xc")]), EQ(Var("R1",Imm(64)),Int(0,64)),
+Direct(Tid(658, "%00000292"))), Goto(Tid(1_869, "%0000074d"), Attrs([]),
+ Int(1,1), Direct(Tid(1_264, "%000004f0")))])), Blk(Tid(658, "%00000292"),
+ Attrs([Attr("address","0x67C")]), Phis([]), Defs([]),
+Jmps([Call(Tid(666, "%0000029a"), Attrs([Attr("address","0x67C"),
+Attr("insn","ret")]), Int(1,1), (Indirect(Var("R30",Imm(64))),))])),
+Blk(Tid(1_264, "%000004f0"), Attrs([Attr("address","0x674")]), Phis([]),
+Defs([Def(Tid(1_268, "%000004f4"), Attrs([Attr("address","0x674"),
+Attr("insn","mov x16, x1")]), Var("R16",Imm(64)), Var("R1",Imm(64)))]),
+Jmps([Call(Tid(1_273, "%000004f9"), Attrs([Attr("address","0x678"),
+Attr("insn","br x16")]), Int(1,1), (Indirect(Var("R16",Imm(64))),))]))])),
+Sub(Tid(1_870, "@frame_dummy"), Attrs([Attr("c.proto","signed (*)(void)"),
+Attr("address","0x710")]), "frame_dummy", Args([Arg(Tid(1_889, "%00000761"),
+ Attrs([Attr("c.layout","[signed : 32]"), Attr("c.data","Top:u32"),
+Attr("c.type","signed")]), Var("frame_dummy_result",Imm(32)),
+LOW(32,Var("R0",Imm(64))), Out())]), Blks([Blk(Tid(818, "@frame_dummy"),
+ Attrs([Attr("address","0x710")]), Phis([]), Defs([]),
+Jmps([Call(Tid(820, "%00000334"), Attrs([Attr("address","0x710"),
+Attr("insn","b #-0x90")]), Int(1,1),
+(Direct(Tid(1_872, "@register_tm_clones")),))]))])), Sub(Tid(1_871, "@main"),
+ Attrs([Attr("c.proto","signed (*)(signed argc,  const char** argv)"),
+Attr("address","0x744")]), "main", Args([Arg(Tid(1_890, "%00000762"),
+ Attrs([Attr("c.layout","[signed : 32]"), Attr("c.data","Top:u32"),
+Attr("c.type","signed")]), Var("main_argc",Imm(32)),
+LOW(32,Var("R0",Imm(64))), In()), Arg(Tid(1_891, "%00000763"),
+ Attrs([Attr("c.layout","**[char : 8]"), Attr("c.data","Top:u8 ptr ptr"),
+Attr("c.type"," const char**")]), Var("main_argv",Imm(64)),
+Var("R1",Imm(64)), Both()), Arg(Tid(1_892, "%00000764"),
+ Attrs([Attr("c.layout","[signed : 32]"), Attr("c.data","Top:u32"),
+Attr("c.type","signed")]), Var("main_result",Imm(32)),
+LOW(32,Var("R0",Imm(64))), Out())]), Blks([Blk(Tid(944, "@main"),
+ Attrs([Attr("address","0x744")]), Phis([]), Defs([Def(Tid(948, "%000003b4"),
+ Attrs([Attr("address","0x744"), Attr("insn","sub sp, sp, #0x10")]),
+ Var("R31",Imm(64)), PLUS(Var("R31",Imm(64)),Int(18446744073709551600,64))),
+Def(Tid(954, "%000003ba"), Attrs([Attr("address","0x748"),
+Attr("insn","add w9, w0, #0x4")]), Var("R9",Imm(64)),
+UNSIGNED(64,PLUS(Extract(31,0,Var("R0",Imm(64))),Int(4,32)))),
+Def(Tid(961, "%000003c1"), Attrs([Attr("address","0x74C"),
+Attr("insn","add w11, w0, w0, lsl #2")]), Var("R11",Imm(64)),
+UNSIGNED(64,PLUS(Extract(31,0,Var("R0",Imm(64))),Concat(Extract(29,0,Var("R0",Imm(64))),Int(0,2))))),
+Def(Tid(966, "%000003c6"), Attrs([Attr("address","0x750"),
+Attr("insn","mov w8, #0x6")]), Var("R8",Imm(64)), Int(6,64)),
+Def(Tid(972, "%000003cc"), Attrs([Attr("address","0x754"),
+Attr("insn","mov x10, sp")]), Var("R10",Imm(64)), Var("R31",Imm(64))),
+Def(Tid(978, "%000003d2"), Attrs([Attr("address","0x758"),
+Attr("insn","sbfiz x13, x0, #2, #32")]), Var("R13",Imm(64)),
+SIGNED(64,Concat(Extract(31,0,Var("R0",Imm(64))),Int(0,2)))),
+Def(Tid(985, "%000003d9"), Attrs([Attr("address","0x75C"),
+Attr("insn","sub w8, w8, w0")]), Var("R8",Imm(64)),
+UNSIGNED(64,PLUS(PLUS(Extract(31,0,Var("R8",Imm(64))),NOT(Extract(31,0,Var("R0",Imm(64))))),Int(1,32)))),
+Def(Tid(991, "%000003df"), Attrs([Attr("address","0x760"),
+Attr("insn","add x12, x10, #0x8")]), Var("R12",Imm(64)),
+PLUS(Var("R10",Imm(64)),Int(8,64))), Def(Tid(997, "%000003e5"),
+ Attrs([Attr("address","0x764"), Attr("insn","cmp w0, #0x3")]),
+ Var("#6",Imm(32)),
+PLUS(Extract(31,0,Var("R0",Imm(64))),Int(4294967292,32))),
+Def(Tid(1_002, "%000003ea"), Attrs([Attr("address","0x764"),
+Attr("insn","cmp w0, #0x3")]), Var("VF",Imm(1)),
+NEQ(SIGNED(33,PLUS(Var("#6",Imm(32)),Int(1,32))),PLUS(SIGNED(33,Extract(31,0,Var("R0",Imm(64)))),Int(8589934589,33)))),
+Def(Tid(1_007, "%000003ef"), Attrs([Attr("address","0x764"),
+Attr("insn","cmp w0, #0x3")]), Var("CF",Imm(1)),
+NEQ(UNSIGNED(33,PLUS(Var("#6",Imm(32)),Int(1,32))),PLUS(UNSIGNED(33,Extract(31,0,Var("R0",Imm(64)))),Int(4294967293,33)))),
+Def(Tid(1_011, "%000003f3"), Attrs([Attr("address","0x764"),
+Attr("insn","cmp w0, #0x3")]), Var("ZF",Imm(1)),
+EQ(PLUS(Var("#6",Imm(32)),Int(1,32)),Int(0,32))),
+Def(Tid(1_015, "%000003f7"), Attrs([Attr("address","0x764"),
+Attr("insn","cmp w0, #0x3")]), Var("NF",Imm(1)),
+Extract(31,31,PLUS(Var("#6",Imm(32)),Int(1,32)))),
+Def(Tid(1_022, "%000003fe"), Attrs([Attr("address","0x768"),
+Attr("insn","add x10, x10, x13")]), Var("R10",Imm(64)),
+PLUS(Var("R10",Imm(64)),Var("R13",Imm(64)))), Def(Tid(1_030, "%00000406"),
+ Attrs([Attr("address","0x76C"), Attr("insn","stp w9, w11, [sp]")]),
+ Var("mem",Mem(64,8)),
+Store(Var("mem",Mem(64,8)),Var("R31",Imm(64)),Extract(31,0,Var("R9",Imm(64))),LittleEndian(),32)),
+Def(Tid(1_036, "%0000040c"), Attrs([Attr("address","0x76C"),
+Attr("insn","stp w9, w11, [sp]")]), Var("mem",Mem(64,8)),
+Store(Var("mem",Mem(64,8)),PLUS(Var("R31",Imm(64)),Int(4,64)),Extract(31,0,Var("R11",Imm(64))),LittleEndian(),32))]),
+Jmps([Goto(Tid(1_051, "%0000041b"), Attrs([Attr("address","0x770"),
+Attr("insn","csel x9, x10, x12, lt")]),
+ NEQ(Var("NF",Imm(1)),Var("VF",Imm(1))), Direct(Tid(1_043, "%00000413"))),
+Goto(Tid(1_052, "%0000041c"), Attrs([Attr("address","0x770"),
+Attr("insn","csel x9, x10, x12, lt")]), Int(1,1),
+Direct(Tid(1_047, "%00000417")))])), Blk(Tid(1_047, "%00000417"), Attrs([]),
+ Phis([]), Defs([Def(Tid(1_048, "%00000418"), Attrs([Attr("address","0x770"),
+Attr("insn","csel x9, x10, x12, lt")]), Var("R9",Imm(64)),
+Var("R12",Imm(64)))]), Jmps([Goto(Tid(1_054, "%0000041e"),
+ Attrs([Attr("address","0x770"), Attr("insn","csel x9, x10, x12, lt")]),
+ Int(1,1), Direct(Tid(1_050, "%0000041a")))])), Blk(Tid(1_043, "%00000413"),
+ Attrs([]), Phis([]), Defs([Def(Tid(1_044, "%00000414"),
+ Attrs([Attr("address","0x770"), Attr("insn","csel x9, x10, x12, lt")]),
+ Var("R9",Imm(64)), Var("R10",Imm(64)))]),
+Jmps([Goto(Tid(1_053, "%0000041d"), Attrs([Attr("address","0x770"),
+Attr("insn","csel x9, x10, x12, lt")]), Int(1,1),
+Direct(Tid(1_050, "%0000041a")))])), Blk(Tid(1_050, "%0000041a"), Attrs([]),
+ Phis([]), Defs([Def(Tid(1_059, "%00000423"), Attrs([Attr("address","0x774"),
+Attr("insn","mov w13, #0x5a")]), Var("R13",Imm(64)), Int(90,64))]),
+Jmps([Goto(Tid(1_074, "%00000432"), Attrs([Attr("address","0x778"),
+Attr("insn","csel x10, x10, x12, lt")]),
+ NEQ(Var("NF",Imm(1)),Var("VF",Imm(1))), Direct(Tid(1_066, "%0000042a"))),
+Goto(Tid(1_075, "%00000433"), Attrs([Attr("address","0x778"),
+Attr("insn","csel x10, x10, x12, lt")]), Int(1,1),
+Direct(Tid(1_070, "%0000042e")))])), Blk(Tid(1_070, "%0000042e"), Attrs([]),
+ Phis([]), Defs([Def(Tid(1_071, "%0000042f"), Attrs([Attr("address","0x778"),
+Attr("insn","csel x10, x10, x12, lt")]), Var("R10",Imm(64)),
+Var("R12",Imm(64)))]), Jmps([Goto(Tid(1_077, "%00000435"),
+ Attrs([Attr("address","0x778"), Attr("insn","csel x10, x10, x12, lt")]),
+ Int(1,1), Direct(Tid(1_073, "%00000431")))])), Blk(Tid(1_066, "%0000042a"),
+ Attrs([]), Phis([]), Defs([Def(Tid(1_067, "%0000042b"),
+ Attrs([Attr("address","0x778"), Attr("insn","csel x10, x10, x12, lt")]),
+ Var("R10",Imm(64)), Var("R10",Imm(64)))]),
+Jmps([Goto(Tid(1_076, "%00000434"), Attrs([Attr("address","0x778"),
+Attr("insn","csel x10, x10, x12, lt")]), Int(1,1),
+Direct(Tid(1_073, "%00000431")))])), Blk(Tid(1_073, "%00000431"), Attrs([]),
+ Phis([]), Defs([Def(Tid(1_083, "%0000043b"), Attrs([Attr("address","0x77C"),
+Attr("insn","stp w8, wzr, [sp, #0x8]")]), Var("#7",Imm(64)),
+PLUS(Var("R31",Imm(64)),Int(8,64))), Def(Tid(1_089, "%00000441"),
+ Attrs([Attr("address","0x77C"), Attr("insn","stp w8, wzr, [sp, #0x8]")]),
+ Var("mem",Mem(64,8)),
+Store(Var("mem",Mem(64,8)),Var("#7",Imm(64)),Extract(31,0,Var("R8",Imm(64))),LittleEndian(),32)),
+Def(Tid(1_094, "%00000446"), Attrs([Attr("address","0x77C"),
+Attr("insn","stp w8, wzr, [sp, #0x8]")]), Var("mem",Mem(64,8)),
+Store(Var("mem",Mem(64,8)),PLUS(Var("#7",Imm(64)),Int(4,64)),Int(0,32),LittleEndian(),32)),
+Def(Tid(1_101, "%0000044d"), Attrs([Attr("address","0x780"),
+Attr("insn","ldr w9, [x9]")]), Var("R9",Imm(64)),
+UNSIGNED(64,Load(Var("mem",Mem(64,8)),Var("R9",Imm(64)),LittleEndian(),32))),
+Def(Tid(1_109, "%00000455"), Attrs([Attr("address","0x784"),
+Attr("insn","stp w11, w8, [sp]")]), Var("mem",Mem(64,8)),
+Store(Var("mem",Mem(64,8)),Var("R31",Imm(64)),Extract(31,0,Var("R11",Imm(64))),LittleEndian(),32)),
+Def(Tid(1_115, "%0000045b"), Attrs([Attr("address","0x784"),
+Attr("insn","stp w11, w8, [sp]")]), Var("mem",Mem(64,8)),
+Store(Var("mem",Mem(64,8)),PLUS(Var("R31",Imm(64)),Int(4,64)),Extract(31,0,Var("R8",Imm(64))),LittleEndian(),32)),
+Def(Tid(1_123, "%00000463"), Attrs([Attr("address","0x788"),
+Attr("insn","str x13, [sp, #0x8]")]), Var("mem",Mem(64,8)),
+Store(Var("mem",Mem(64,8)),PLUS(Var("R31",Imm(64)),Int(8,64)),Var("R13",Imm(64)),LittleEndian(),64)),
+Def(Tid(1_130, "%0000046a"), Attrs([Attr("address","0x78C"),
+Attr("insn","ldr w8, [x10]")]), Var("R8",Imm(64)),
+UNSIGNED(64,Load(Var("mem",Mem(64,8)),Var("R10",Imm(64)),LittleEndian(),32))),
+Def(Tid(1_137, "%00000471"), Attrs([Attr("address","0x790"),
+Attr("insn","add w8, w9, w8")]), Var("R8",Imm(64)),
+UNSIGNED(64,PLUS(Extract(31,0,Var("R9",Imm(64))),Extract(31,0,Var("R8",Imm(64)))))),
+Def(Tid(1_143, "%00000477"), Attrs([Attr("address","0x794"),
+Attr("insn","add w0, w8, #0x2")]), Var("R0",Imm(64)),
+UNSIGNED(64,PLUS(Extract(31,0,Var("R8",Imm(64))),Int(2,32)))),
+Def(Tid(1_149, "%0000047d"), Attrs([Attr("address","0x798"),
+Attr("insn","add sp, sp, #0x10")]), Var("R31",Imm(64)),
+PLUS(Var("R31",Imm(64)),Int(16,64)))]), Jmps([Call(Tid(1_154, "%00000482"),
+ Attrs([Attr("address","0x79C"), Attr("insn","ret")]), Int(1,1),
+(Indirect(Var("R30",Imm(64))),))]))])),
+Sub(Tid(1_872, "@register_tm_clones"),
+ Attrs([Attr("c.proto","signed (*)(void)"), Attr("address","0x680")]),
+ "register_tm_clones", Args([Arg(Tid(1_893, "%00000765"),
+ Attrs([Attr("c.layout","[signed : 32]"), Attr("c.data","Top:u32"),
+Attr("c.type","signed")]), Var("register_tm_clones_result",Imm(32)),
+LOW(32,Var("R0",Imm(64))), Out())]),
+Blks([Blk(Tid(668, "@register_tm_clones"), Attrs([Attr("address","0x680")]),
+ Phis([]), Defs([Def(Tid(671, "%0000029f"), Attrs([Attr("address","0x680"),
+Attr("insn","adrp x0, #69632")]), Var("R0",Imm(64)), Int(69632,64)),
+Def(Tid(677, "%000002a5"), Attrs([Attr("address","0x684"),
+Attr("insn","add x0, x0, #0x30")]), Var("R0",Imm(64)),
+PLUS(Var("R0",Imm(64)),Int(48,64))), Def(Tid(682, "%000002aa"),
+ Attrs([Attr("address","0x688"), Attr("insn","adrp x1, #69632")]),
+ Var("R1",Imm(64)), Int(69632,64)), Def(Tid(688, "%000002b0"),
+ Attrs([Attr("address","0x68C"), Attr("insn","add x1, x1, #0x30")]),
+ Var("R1",Imm(64)), PLUS(Var("R1",Imm(64)),Int(48,64))),
+Def(Tid(695, "%000002b7"), Attrs([Attr("address","0x690"),
+Attr("insn","sub x1, x1, x0")]), Var("R1",Imm(64)),
+PLUS(PLUS(Var("R1",Imm(64)),NOT(Var("R0",Imm(64)))),Int(1,64))),
+Def(Tid(701, "%000002bd"), Attrs([Attr("address","0x694"),
+Attr("insn","lsr x2, x1, #63")]), Var("R2",Imm(64)),
+Concat(Int(0,63),Extract(63,63,Var("R1",Imm(64))))),
+Def(Tid(708, "%000002c4"), Attrs([Attr("address","0x698"),
+Attr("insn","add x1, x2, x1, asr #3")]), Var("R1",Imm(64)),
+PLUS(Var("R2",Imm(64)),ARSHIFT(Var("R1",Imm(64)),Int(3,3)))),
+Def(Tid(714, "%000002ca"), Attrs([Attr("address","0x69C"),
+Attr("insn","asr x1, x1, #1")]), Var("R1",Imm(64)),
+SIGNED(64,Extract(63,1,Var("R1",Imm(64)))))]),
+Jmps([Goto(Tid(720, "%000002d0"), Attrs([Attr("address","0x6A0"),
+Attr("insn","cbz x1, #0x18")]), EQ(Var("R1",Imm(64)),Int(0,64)),
+Direct(Tid(718, "%000002ce"))), Goto(Tid(1_873, "%00000751"), Attrs([]),
+ Int(1,1), Direct(Tid(1_215, "%000004bf")))])), Blk(Tid(1_215, "%000004bf"),
+ Attrs([Attr("address","0x6A4")]), Phis([]),
+Defs([Def(Tid(1_218, "%000004c2"), Attrs([Attr("address","0x6A4"),
+Attr("insn","adrp x2, #65536")]), Var("R2",Imm(64)), Int(65536,64)),
+Def(Tid(1_225, "%000004c9"), Attrs([Attr("address","0x6A8"),
+Attr("insn","ldr x2, [x2, #0xfe0]")]), Var("R2",Imm(64)),
+Load(Var("mem",Mem(64,8)),PLUS(Var("R2",Imm(64)),Int(4064,64)),LittleEndian(),64))]),
+Jmps([Goto(Tid(1_230, "%000004ce"), Attrs([Attr("address","0x6AC"),
+Attr("insn","cbz x2, #0xc")]), EQ(Var("R2",Imm(64)),Int(0,64)),
+Direct(Tid(718, "%000002ce"))), Goto(Tid(1_874, "%00000752"), Attrs([]),
+ Int(1,1), Direct(Tid(1_234, "%000004d2")))])), Blk(Tid(718, "%000002ce"),
+ Attrs([Attr("address","0x6B8")]), Phis([]), Defs([]),
+Jmps([Call(Tid(726, "%000002d6"), Attrs([Attr("address","0x6B8"),
+Attr("insn","ret")]), Int(1,1), (Indirect(Var("R30",Imm(64))),))])),
+Blk(Tid(1_234, "%000004d2"), Attrs([Attr("address","0x6B0")]), Phis([]),
+Defs([Def(Tid(1_238, "%000004d6"), Attrs([Attr("address","0x6B0"),
+Attr("insn","mov x16, x2")]), Var("R16",Imm(64)), Var("R2",Imm(64)))]),
+Jmps([Call(Tid(1_243, "%000004db"), Attrs([Attr("address","0x6B4"),
+Attr("insn","br x16")]), Int(1,1), (Indirect(Var("R16",Imm(64))),))]))])),
+Sub(Tid(1_875, "@test"), Attrs([Attr("c.proto","signed (*)(void)"),
+Attr("address","0x714")]), "test", Args([Arg(Tid(1_894, "%00000766"),
+ Attrs([Attr("c.layout","[signed : 32]"), Attr("c.data","Top:u32"),
+Attr("c.type","signed")]), Var("test_result",Imm(32)),
+LOW(32,Var("R0",Imm(64))), Out())]), Blks([Blk(Tid(822, "@test"),
+ Attrs([Attr("address","0x714")]), Phis([]), Defs([Def(Tid(826, "%0000033a"),
+ Attrs([Attr("address","0x714"), Attr("insn","sub sp, sp, #0x10")]),
+ Var("R31",Imm(64)), PLUS(Var("R31",Imm(64)),Int(18446744073709551600,64))),
+Def(Tid(832, "%00000340"), Attrs([Attr("address","0x718"),
+Attr("insn","mov x8, sp")]), Var("R8",Imm(64)), Var("R31",Imm(64))),
+Def(Tid(838, "%00000346"), Attrs([Attr("address","0x71C"),
+Attr("insn","cmp w3, #0x3")]), Var("#4",Imm(32)),
+PLUS(Extract(31,0,Var("R3",Imm(64))),Int(4294967292,32))),
+Def(Tid(843, "%0000034b"), Attrs([Attr("address","0x71C"),
+Attr("insn","cmp w3, #0x3")]), Var("VF",Imm(1)),
+NEQ(SIGNED(33,PLUS(Var("#4",Imm(32)),Int(1,32))),PLUS(SIGNED(33,Extract(31,0,Var("R3",Imm(64)))),Int(8589934589,33)))),
+Def(Tid(848, "%00000350"), Attrs([Attr("address","0x71C"),
+Attr("insn","cmp w3, #0x3")]), Var("CF",Imm(1)),
+NEQ(UNSIGNED(33,PLUS(Var("#4",Imm(32)),Int(1,32))),PLUS(UNSIGNED(33,Extract(31,0,Var("R3",Imm(64)))),Int(4294967293,33)))),
+Def(Tid(852, "%00000354"), Attrs([Attr("address","0x71C"),
+Attr("insn","cmp w3, #0x3")]), Var("ZF",Imm(1)),
+EQ(PLUS(Var("#4",Imm(32)),Int(1,32)),Int(0,32))), Def(Tid(856, "%00000358"),
+ Attrs([Attr("address","0x71C"), Attr("insn","cmp w3, #0x3")]),
+ Var("NF",Imm(1)), Extract(31,31,PLUS(Var("#4",Imm(32)),Int(1,32)))),
+Def(Tid(863, "%0000035f"), Attrs([Attr("address","0x720"),
+Attr("insn","add x9, x8, w3, sxtw #2")]), Var("R9",Imm(64)),
+PLUS(Var("R8",Imm(64)),SIGNED(64,Concat(Extract(31,0,Var("R3",Imm(64))),Int(0,2))))),
+Def(Tid(869, "%00000365"), Attrs([Attr("address","0x724"),
+Attr("insn","add x8, x8, #0x8")]), Var("R8",Imm(64)),
+PLUS(Var("R8",Imm(64)),Int(8,64)))]), Jmps([Goto(Tid(884, "%00000374"),
+ Attrs([Attr("address","0x728"), Attr("insn","csel x8, x9, x8, lt")]),
+ NEQ(Var("NF",Imm(1)),Var("VF",Imm(1))), Direct(Tid(876, "%0000036c"))),
+Goto(Tid(885, "%00000375"), Attrs([Attr("address","0x728"),
+Attr("insn","csel x8, x9, x8, lt")]), Int(1,1),
+Direct(Tid(880, "%00000370")))])), Blk(Tid(880, "%00000370"), Attrs([]),
+ Phis([]), Defs([Def(Tid(881, "%00000371"), Attrs([Attr("address","0x728"),
+Attr("insn","csel x8, x9, x8, lt")]), Var("R8",Imm(64)),
+Var("R8",Imm(64)))]), Jmps([Goto(Tid(887, "%00000377"),
+ Attrs([Attr("address","0x728"), Attr("insn","csel x8, x9, x8, lt")]),
+ Int(1,1), Direct(Tid(883, "%00000373")))])), Blk(Tid(876, "%0000036c"),
+ Attrs([]), Phis([]), Defs([Def(Tid(877, "%0000036d"),
+ Attrs([Attr("address","0x728"), Attr("insn","csel x8, x9, x8, lt")]),
+ Var("R8",Imm(64)), Var("R9",Imm(64)))]), Jmps([Goto(Tid(886, "%00000376"),
+ Attrs([Attr("address","0x728"), Attr("insn","csel x8, x9, x8, lt")]),
+ Int(1,1), Direct(Tid(883, "%00000373")))])), Blk(Tid(883, "%00000373"),
+ Attrs([]), Phis([]), Defs([Def(Tid(895, "%0000037f"),
+ Attrs([Attr("address","0x72C"), Attr("insn","stp w0, w1, [sp]")]),
+ Var("mem",Mem(64,8)),
+Store(Var("mem",Mem(64,8)),Var("R31",Imm(64)),Extract(31,0,Var("R0",Imm(64))),LittleEndian(),32)),
+Def(Tid(901, "%00000385"), Attrs([Attr("address","0x72C"),
+Attr("insn","stp w0, w1, [sp]")]), Var("mem",Mem(64,8)),
+Store(Var("mem",Mem(64,8)),PLUS(Var("R31",Imm(64)),Int(4,64)),Extract(31,0,Var("R1",Imm(64))),LittleEndian(),32)),
+Def(Tid(907, "%0000038b"), Attrs([Attr("address","0x730"),
+Attr("insn","stp w2, wzr, [sp, #0x8]")]), Var("#5",Imm(64)),
+PLUS(Var("R31",Imm(64)),Int(8,64))), Def(Tid(913, "%00000391"),
+ Attrs([Attr("address","0x730"), Attr("insn","stp w2, wzr, [sp, #0x8]")]),
+ Var("mem",Mem(64,8)),
+Store(Var("mem",Mem(64,8)),Var("#5",Imm(64)),Extract(31,0,Var("R2",Imm(64))),LittleEndian(),32)),
+Def(Tid(918, "%00000396"), Attrs([Attr("address","0x730"),
+Attr("insn","stp w2, wzr, [sp, #0x8]")]), Var("mem",Mem(64,8)),
+Store(Var("mem",Mem(64,8)),PLUS(Var("#5",Imm(64)),Int(4,64)),Int(0,32),LittleEndian(),32)),
+Def(Tid(925, "%0000039d"), Attrs([Attr("address","0x734"),
+Attr("insn","ldr w8, [x8]")]), Var("R8",Imm(64)),
+UNSIGNED(64,Load(Var("mem",Mem(64,8)),Var("R8",Imm(64)),LittleEndian(),32))),
+Def(Tid(931, "%000003a3"), Attrs([Attr("address","0x738"),
+Attr("insn","add w0, w8, #0x1")]), Var("R0",Imm(64)),
+UNSIGNED(64,PLUS(Extract(31,0,Var("R8",Imm(64))),Int(1,32)))),
+Def(Tid(937, "%000003a9"), Attrs([Attr("address","0x73C"),
+Attr("insn","add sp, sp, #0x10")]), Var("R31",Imm(64)),
+PLUS(Var("R31",Imm(64)),Int(16,64)))]), Jmps([Call(Tid(942, "%000003ae"),
+ Attrs([Attr("address","0x740"), Attr("insn","ret")]), Int(1,1),
+(Indirect(Var("R30",Imm(64))),))]))]))])))
\ No newline at end of file
diff --git a/examples/stackambiguity/stackambiguity.bir b/examples/stackambiguity/stackambiguity.bir
new file mode 100644
index 000000000..98ceb4590
--- /dev/null
+++ b/examples/stackambiguity/stackambiguity.bir
@@ -0,0 +1,310 @@
+00000754: program
+0000073d: sub __cxa_finalize(__cxa_finalize_result)
+00000755: __cxa_finalize_result :: out u32 = low:32[R0]
+
+000004bb:
+000005b3: R16 := 0x11000
+000005ba: R17 := mem[R16 + 8, el]:u64
+000005c0: R16 := R16 + 8
+000005c5: call R17 with noreturn
+
+0000073e: sub __do_global_dtors_aux(__do_global_dtors_aux_result)
+00000756: __do_global_dtors_aux_result :: out u32 = low:32[R0]
+
+000002da:
+000002de: #3 := R31 - 0x20
+000002e4: mem := mem with [#3, el]:u64 <- R29
+000002ea: mem := mem with [#3 + 8, el]:u64 <- R30
+000002ee: R31 := #3
+000002f4: R29 := R31
+000002fc: mem := mem with [R31 + 0x10, el]:u64 <- R19
+00000301: R19 := 0x11000
+00000308: R0 := pad:64[mem[R19 + 0x30]]
+0000030f: when 31:0[R0] <> 0 goto %0000030d
+0000073f: goto %00000484
+
+00000484:
+00000487: R0 := 0x10000
+0000048e: R0 := mem[R0 + 0xFC8, el]:u64
+00000494: when R0 = 0 goto %00000492
+00000740: goto %000004ab
+
+000004ab:
+000004ae: R0 := 0x11000
+000004b5: R0 := mem[R0 + 0x28, el]:u64
+000004ba: R30 := 0x6F0
+000004bd: call @__cxa_finalize with return %00000492
+
+00000492:
+0000049a: R30 := 0x6F4
+0000049c: call @deregister_tm_clones with return %0000049e
+
+0000049e:
+000004a1: R0 := 1
+000004a9: mem := mem with [R19 + 0x30] <- 7:0[R0]
+00000741: goto %0000030d
+
+0000030d:
+00000317: R19 := mem[R31 + 0x10, el]:u64
+0000031e: R29 := mem[R31, el]:u64
+00000323: R30 := mem[R31 + 8, el]:u64
+00000327: R31 := R31 + 0x20
+0000032c: call R30 with noreturn
+
+00000742: sub __libc_start_main(__libc_start_main_main, __libc_start_main_arg2, __libc_start_main_arg3, __libc_start_main_auxv, __libc_start_main_result)
+00000757: __libc_start_main_main :: in u64 = R0
+00000758: __libc_start_main_arg2 :: in u32 = low:32[R1]
+00000759: __libc_start_main_arg3 :: in out u64 = R2
+0000075a: __libc_start_main_auxv :: in out u64 = R3
+0000075b: __libc_start_main_result :: out u32 = low:32[R0]
+
+00000233:
+0000059d: R16 := 0x11000
+000005a4: R17 := mem[R16, el]:u64
+000005aa: R16 := R16
+000005af: call R17 with noreturn
+
+00000743: sub _fini(_fini_result)
+0000075c: _fini_result :: out u32 = low:32[R0]
+
+0000001f:
+00000025: #0 := R31 - 0x10
+0000002b: mem := mem with [#0, el]:u64 <- R29
+00000031: mem := mem with [#0 + 8, el]:u64 <- R30
+00000035: R31 := #0
+0000003b: R29 := R31
+00000042: R29 := mem[R31, el]:u64
+00000047: R30 := mem[R31 + 8, el]:u64
+0000004b: R31 := R31 + 0x10
+00000050: call R30 with noreturn
+
+00000744: sub _init(_init_result)
+0000075d: _init_result :: out u32 = low:32[R0]
+
+0000067c:
+00000682: #9 := R31 - 0x10
+00000688: mem := mem with [#9, el]:u64 <- R29
+0000068e: mem := mem with [#9 + 8, el]:u64 <- R30
+00000692: R31 := #9
+00000698: R29 := R31
+0000069d: R30 := 0x590
+0000069f: call @call_weak_fn with return %000006a1
+
+000006a1:
+000006a6: R29 := mem[R31, el]:u64
+000006ab: R30 := mem[R31 + 8, el]:u64
+000006af: R31 := R31 + 0x10
+000006b4: call R30 with noreturn
+
+00000745: sub _start(_start_result)
+0000075e: _start_result :: out u32 = low:32[R0]
+
+000001f4:
+000001f9: R29 := 0
+000001fe: R30 := 0
+00000204: R5 := R0
+0000020b: R1 := mem[R31, el]:u64
+00000211: R2 := R31 + 8
+00000217: R6 := R31
+0000021c: R0 := 0x10000
+00000223: R0 := mem[R0 + 0xFD8, el]:u64
+00000228: R3 := 0
+0000022d: R4 := 0
+00000232: R30 := 0x630
+00000235: call @__libc_start_main with return %00000237
+
+00000237:
+0000023a: R30 := 0x634
+0000023d: call @abort with return %00000746
+
+00000746:
+00000747: call @call_weak_fn with noreturn
+
+00000748: sub abort()
+
+
+0000023b:
+000005df: R16 := 0x11000
+000005e6: R17 := mem[R16 + 0x18, el]:u64
+000005ec: R16 := R16 + 0x18
+000005f1: call R17 with noreturn
+
+00000749: sub call_weak_fn(call_weak_fn_result)
+0000075f: call_weak_fn_result :: out u32 = low:32[R0]
+
+0000023f:
+00000242: R0 := 0x10000
+00000249: R0 := mem[R0 + 0xFD0, el]:u64
+0000024f: when R0 = 0 goto %0000024d
+0000074a: goto %000004fb
+
+0000024d:
+00000255: call R30 with noreturn
+
+000004fb:
+000004fe: goto @__gmon_start__
+
+000004fc:
+000005c9: R16 := 0x11000
+000005d0: R17 := mem[R16 + 0x10, el]:u64
+000005d6: R16 := R16 + 0x10
+000005db: call R17 with noreturn
+
+0000074b: sub deregister_tm_clones(deregister_tm_clones_result)
+00000760: deregister_tm_clones_result :: out u32 = low:32[R0]
+
+0000025b:
+0000025e: R0 := 0x11000
+00000264: R0 := R0 + 0x30
+00000269: R1 := 0x11000
+0000026f: R1 := R1 + 0x30
+00000275: #1 := ~R0
+0000027a: #2 := R1 + ~R0
+00000280: VF := extend:65[#2 + 1] <> extend:65[R1] + extend:65[#1] + 1
+00000286: CF := pad:65[#2 + 1] <> pad:65[R1] + pad:65[#1] + 1
+0000028a: ZF := #2 + 1 = 0
+0000028e: NF := 63:63[#2 + 1]
+00000294: when ZF goto %00000292
+0000074c: goto %000004dd
+
+000004dd:
+000004e0: R1 := 0x10000
+000004e7: R1 := mem[R1 + 0xFC0, el]:u64
+000004ec: when R1 = 0 goto %00000292
+0000074d: goto %000004f0
+
+00000292:
+0000029a: call R30 with noreturn
+
+000004f0:
+000004f4: R16 := R1
+000004f9: call R16 with noreturn
+
+0000074e: sub frame_dummy(frame_dummy_result)
+00000761: frame_dummy_result :: out u32 = low:32[R0]
+
+00000332:
+00000334: call @register_tm_clones with noreturn
+
+0000074f: sub main(main_argc, main_argv, main_result)
+00000762: main_argc :: in u32 = low:32[R0]
+00000763: main_argv :: in out u64 = R1
+00000764: main_result :: out u32 = low:32[R0]
+
+000003b0:
+000003b4: R31 := R31 - 0x10
+000003ba: R9 := pad:64[31:0[R0] + 4]
+000003c1: R11 := pad:64[31:0[R0] + (29:0[R0].0)]
+000003c6: R8 := 6
+000003cc: R10 := R31
+000003d2: R13 := extend:64[31:0[R0].0]
+000003d9: R8 := pad:64[31:0[R8] + ~31:0[R0] + 1]
+000003df: R12 := R10 + 8
+000003e5: #6 := 31:0[R0] - 4
+000003ea: VF := extend:33[#6 + 1] <> extend:33[31:0[R0]] - 3
+000003ef: CF := pad:33[#6 + 1] <> pad:33[31:0[R0]] + 0xFFFFFFFD
+000003f3: ZF := #6 + 1 = 0
+000003f7: NF := 31:31[#6 + 1]
+000003fe: R10 := R10 + R13
+00000406: mem := mem with [R31, el]:u32 <- 31:0[R9]
+0000040c: mem := mem with [R31 + 4, el]:u32 <- 31:0[R11]
+0000041b: when NF <> VF goto %00000413
+0000041c: goto %00000417
+
+00000417:
+00000418: R9 := R12
+0000041e: goto %0000041a
+
+00000413:
+00000414: R9 := R10
+0000041d: goto %0000041a
+
+0000041a:
+00000423: R13 := 0x5A
+00000432: when NF <> VF goto %0000042a
+00000433: goto %0000042e
+
+0000042e:
+0000042f: R10 := R12
+00000435: goto %00000431
+
+0000042a:
+0000042b: R10 := R10
+00000434: goto %00000431
+
+00000431:
+0000043b: #7 := R31 + 8
+00000441: mem := mem with [#7, el]:u32 <- 31:0[R8]
+00000446: mem := mem with [#7 + 4, el]:u32 <- 0
+0000044d: R9 := pad:64[mem[R9, el]:u32]
+00000455: mem := mem with [R31, el]:u32 <- 31:0[R11]
+0000045b: mem := mem with [R31 + 4, el]:u32 <- 31:0[R8]
+00000463: mem := mem with [R31 + 8, el]:u64 <- R13
+0000046a: R8 := pad:64[mem[R10, el]:u32]
+00000471: R8 := pad:64[31:0[R9] + 31:0[R8]]
+00000477: R0 := pad:64[31:0[R8] + 2]
+0000047d: R31 := R31 + 0x10
+00000482: call R30 with noreturn
+
+00000750: sub register_tm_clones(register_tm_clones_result)
+00000765: register_tm_clones_result :: out u32 = low:32[R0]
+
+0000029c:
+0000029f: R0 := 0x11000
+000002a5: R0 := R0 + 0x30
+000002aa: R1 := 0x11000
+000002b0: R1 := R1 + 0x30
+000002b7: R1 := R1 + ~R0 + 1
+000002bd: R2 := 0.63:63[R1]
+000002c4: R1 := R2 + (R1 ~>> 3)
+000002ca: R1 := extend:64[63:1[R1]]
+000002d0: when R1 = 0 goto %000002ce
+00000751: goto %000004bf
+
+000004bf:
+000004c2: R2 := 0x10000
+000004c9: R2 := mem[R2 + 0xFE0, el]:u64
+000004ce: when R2 = 0 goto %000002ce
+00000752: goto %000004d2
+
+000002ce:
+000002d6: call R30 with noreturn
+
+000004d2:
+000004d6: R16 := R2
+000004db: call R16 with noreturn
+
+00000753: sub test(test_result)
+00000766: test_result :: out u32 = low:32[R0]
+
+00000336:
+0000033a: R31 := R31 - 0x10
+00000340: R8 := R31
+00000346: #4 := 31:0[R3] - 4
+0000034b: VF := extend:33[#4 + 1] <> extend:33[31:0[R3]] - 3
+00000350: CF := pad:33[#4 + 1] <> pad:33[31:0[R3]] + 0xFFFFFFFD
+00000354: ZF := #4 + 1 = 0
+00000358: NF := 31:31[#4 + 1]
+0000035f: R9 := R8 + extend:64[31:0[R3].0]
+00000365: R8 := R8 + 8
+00000374: when NF <> VF goto %0000036c
+00000375: goto %00000370
+
+00000370:
+00000371: R8 := R8
+00000377: goto %00000373
+
+0000036c:
+0000036d: R8 := R9
+00000376: goto %00000373
+
+00000373:
+0000037f: mem := mem with [R31, el]:u32 <- 31:0[R0]
+00000385: mem := mem with [R31 + 4, el]:u32 <- 31:0[R1]
+0000038b: #5 := R31 + 8
+00000391: mem := mem with [#5, el]:u32 <- 31:0[R2]
+00000396: mem := mem with [#5 + 4, el]:u32 <- 0
+0000039d: R8 := pad:64[mem[R8, el]:u32]
+000003a3: R0 := pad:64[31:0[R8] + 1]
+000003a9: R31 := R31 + 0x10
+000003ae: call R30 with noreturn
diff --git a/examples/stackambiguity/stackambiguity.c b/examples/stackambiguity/stackambiguity.c
new file mode 100644
index 000000000..ed765bc30
--- /dev/null
+++ b/examples/stackambiguity/stackambiguity.c
@@ -0,0 +1,19 @@
+int test(int a, int b, int c, int d) {
+  int q = 0;
+  int x[4] = {a, b, c};
+  int* y = &x[2]; 
+  if (d < 3) {
+    y = &x[d];
+  }
+  q = *y + 1;
+  return q;
+}
+
+int main(int argc, char** argv) {
+  int a = 4 + argc;
+  int b = 5 * argc;
+  int c = 6 - argc;
+  int d = test(a, b, c, argc);
+  int e = test(b, c, 90, argc);
+  return d + e;
+}
\ No newline at end of file
diff --git a/examples/stackambiguity/stackambiguity.relf b/examples/stackambiguity/stackambiguity.relf
new file mode 100644
index 000000000..db606f74a
--- /dev/null
+++ b/examples/stackambiguity/stackambiguity.relf
@@ -0,0 +1,122 @@
+
+Relocation section '.rela.dyn' at offset 0x460 contains 8 entries:
+    Offset             Info             Type               Symbol's Value  Symbol's Name + Addend
+0000000000010dc8  0000000000000403 R_AARCH64_RELATIVE                        710
+0000000000010dd0  0000000000000403 R_AARCH64_RELATIVE                        6c0
+0000000000010fd8  0000000000000403 R_AARCH64_RELATIVE                        744
+0000000000011028  0000000000000403 R_AARCH64_RELATIVE                        11028
+0000000000010fc0  0000000400000401 R_AARCH64_GLOB_DAT     0000000000000000 _ITM_deregisterTMCloneTable + 0
+0000000000010fc8  0000000500000401 R_AARCH64_GLOB_DAT     0000000000000000 __cxa_finalize@GLIBC_2.17 + 0
+0000000000010fd0  0000000600000401 R_AARCH64_GLOB_DAT     0000000000000000 __gmon_start__ + 0
+0000000000010fe0  0000000800000401 R_AARCH64_GLOB_DAT     0000000000000000 _ITM_registerTMCloneTable + 0
+
+Relocation section '.rela.plt' at offset 0x520 contains 4 entries:
+    Offset             Info             Type               Symbol's Value  Symbol's Name + Addend
+0000000000011000  0000000300000402 R_AARCH64_JUMP_SLOT    0000000000000000 __libc_start_main@GLIBC_2.34 + 0
+0000000000011008  0000000500000402 R_AARCH64_JUMP_SLOT    0000000000000000 __cxa_finalize@GLIBC_2.17 + 0
+0000000000011010  0000000600000402 R_AARCH64_JUMP_SLOT    0000000000000000 __gmon_start__ + 0
+0000000000011018  0000000700000402 R_AARCH64_JUMP_SLOT    0000000000000000 abort@GLIBC_2.17 + 0
+
+Symbol table '.dynsym' contains 9 entries:
+   Num:    Value          Size Type    Bind   Vis      Ndx Name
+     0: 0000000000000000     0 NOTYPE  LOCAL  DEFAULT  UND 
+     1: 0000000000000580     0 SECTION LOCAL  DEFAULT   11 .init
+     2: 0000000000011020     0 SECTION LOCAL  DEFAULT   23 .data
+     3: 0000000000000000     0 FUNC    GLOBAL DEFAULT  UND __libc_start_main@GLIBC_2.34 (2)
+     4: 0000000000000000     0 NOTYPE  WEAK   DEFAULT  UND _ITM_deregisterTMCloneTable
+     5: 0000000000000000     0 FUNC    WEAK   DEFAULT  UND __cxa_finalize@GLIBC_2.17 (3)
+     6: 0000000000000000     0 NOTYPE  WEAK   DEFAULT  UND __gmon_start__
+     7: 0000000000000000     0 FUNC    GLOBAL DEFAULT  UND abort@GLIBC_2.17 (3)
+     8: 0000000000000000     0 NOTYPE  WEAK   DEFAULT  UND _ITM_registerTMCloneTable
+
+Symbol table '.symtab' contains 89 entries:
+   Num:    Value          Size Type    Bind   Vis      Ndx Name
+     0: 0000000000000000     0 NOTYPE  LOCAL  DEFAULT  UND 
+     1: 0000000000000238     0 SECTION LOCAL  DEFAULT    1 .interp
+     2: 0000000000000254     0 SECTION LOCAL  DEFAULT    2 .note.gnu.build-id
+     3: 0000000000000278     0 SECTION LOCAL  DEFAULT    3 .note.ABI-tag
+     4: 0000000000000298     0 SECTION LOCAL  DEFAULT    4 .gnu.hash
+     5: 00000000000002b8     0 SECTION LOCAL  DEFAULT    5 .dynsym
+     6: 0000000000000390     0 SECTION LOCAL  DEFAULT    6 .dynstr
+     7: 000000000000041e     0 SECTION LOCAL  DEFAULT    7 .gnu.version
+     8: 0000000000000430     0 SECTION LOCAL  DEFAULT    8 .gnu.version_r
+     9: 0000000000000460     0 SECTION LOCAL  DEFAULT    9 .rela.dyn
+    10: 0000000000000520     0 SECTION LOCAL  DEFAULT   10 .rela.plt
+    11: 0000000000000580     0 SECTION LOCAL  DEFAULT   11 .init
+    12: 00000000000005a0     0 SECTION LOCAL  DEFAULT   12 .plt
+    13: 0000000000000600     0 SECTION LOCAL  DEFAULT   13 .text
+    14: 00000000000007a0     0 SECTION LOCAL  DEFAULT   14 .fini
+    15: 00000000000007b4     0 SECTION LOCAL  DEFAULT   15 .rodata
+    16: 00000000000007b8     0 SECTION LOCAL  DEFAULT   16 .eh_frame_hdr
+    17: 0000000000000800     0 SECTION LOCAL  DEFAULT   17 .eh_frame
+    18: 0000000000010dc8     0 SECTION LOCAL  DEFAULT   18 .init_array
+    19: 0000000000010dd0     0 SECTION LOCAL  DEFAULT   19 .fini_array
+    20: 0000000000010dd8     0 SECTION LOCAL  DEFAULT   20 .dynamic
+    21: 0000000000010fb8     0 SECTION LOCAL  DEFAULT   21 .got
+    22: 0000000000010fe8     0 SECTION LOCAL  DEFAULT   22 .got.plt
+    23: 0000000000011020     0 SECTION LOCAL  DEFAULT   23 .data
+    24: 0000000000011030     0 SECTION LOCAL  DEFAULT   24 .bss
+    25: 0000000000000000     0 SECTION LOCAL  DEFAULT   25 .comment
+    26: 0000000000000000     0 FILE    LOCAL  DEFAULT  ABS Scrt1.o
+    27: 0000000000000278     0 NOTYPE  LOCAL  DEFAULT    3 $d
+    28: 0000000000000278    32 OBJECT  LOCAL  DEFAULT    3 __abi_tag
+    29: 0000000000000600     0 NOTYPE  LOCAL  DEFAULT   13 $x
+    30: 0000000000000814     0 NOTYPE  LOCAL  DEFAULT   17 $d
+    31: 00000000000007b4     0 NOTYPE  LOCAL  DEFAULT   15 $d
+    32: 0000000000000000     0 FILE    LOCAL  DEFAULT  ABS crti.o
+    33: 0000000000000634     0 NOTYPE  LOCAL  DEFAULT   13 $x
+    34: 0000000000000634    20 FUNC    LOCAL  DEFAULT   13 call_weak_fn
+    35: 0000000000000580     0 NOTYPE  LOCAL  DEFAULT   11 $x
+    36: 00000000000007a0     0 NOTYPE  LOCAL  DEFAULT   14 $x
+    37: 0000000000000000     0 FILE    LOCAL  DEFAULT  ABS crtn.o
+    38: 0000000000000590     0 NOTYPE  LOCAL  DEFAULT   11 $x
+    39: 00000000000007ac     0 NOTYPE  LOCAL  DEFAULT   14 $x
+    40: 0000000000000000     0 FILE    LOCAL  DEFAULT  ABS crtstuff.c
+    41: 0000000000000650     0 NOTYPE  LOCAL  DEFAULT   13 $x
+    42: 0000000000000650     0 FUNC    LOCAL  DEFAULT   13 deregister_tm_clones
+    43: 0000000000000680     0 FUNC    LOCAL  DEFAULT   13 register_tm_clones
+    44: 0000000000011028     0 NOTYPE  LOCAL  DEFAULT   23 $d
+    45: 00000000000006c0     0 FUNC    LOCAL  DEFAULT   13 __do_global_dtors_aux
+    46: 0000000000011030     1 OBJECT  LOCAL  DEFAULT   24 completed.0
+    47: 0000000000010dd0     0 NOTYPE  LOCAL  DEFAULT   19 $d
+    48: 0000000000010dd0     0 OBJECT  LOCAL  DEFAULT   19 __do_global_dtors_aux_fini_array_entry
+    49: 0000000000000710     0 FUNC    LOCAL  DEFAULT   13 frame_dummy
+    50: 0000000000010dc8     0 NOTYPE  LOCAL  DEFAULT   18 $d
+    51: 0000000000010dc8     0 OBJECT  LOCAL  DEFAULT   18 __frame_dummy_init_array_entry
+    52: 0000000000000828     0 NOTYPE  LOCAL  DEFAULT   17 $d
+    53: 0000000000011030     0 NOTYPE  LOCAL  DEFAULT   24 $d
+    54: 0000000000000000     0 FILE    LOCAL  DEFAULT  ABS stackambiguity.c
+    55: 0000000000000714     0 NOTYPE  LOCAL  DEFAULT   13 $x.0
+    56: 000000000000002a     0 NOTYPE  LOCAL  DEFAULT   25 $d.1
+    57: 0000000000000888     0 NOTYPE  LOCAL  DEFAULT   17 $d.2
+    58: 0000000000000000     0 FILE    LOCAL  DEFAULT  ABS crtstuff.c
+    59: 00000000000008cc     0 NOTYPE  LOCAL  DEFAULT   17 $d
+    60: 00000000000008cc     0 OBJECT  LOCAL  DEFAULT   17 __FRAME_END__
+    61: 0000000000000000     0 FILE    LOCAL  DEFAULT  ABS 
+    62: 0000000000010dd8     0 OBJECT  LOCAL  DEFAULT  ABS _DYNAMIC
+    63: 00000000000007b8     0 NOTYPE  LOCAL  DEFAULT   16 __GNU_EH_FRAME_HDR
+    64: 0000000000010fb8     0 OBJECT  LOCAL  DEFAULT  ABS _GLOBAL_OFFSET_TABLE_
+    65: 00000000000005a0     0 NOTYPE  LOCAL  DEFAULT   12 $x
+    66: 0000000000000000     0 FUNC    GLOBAL DEFAULT  UND __libc_start_main@GLIBC_2.34
+    67: 0000000000000000     0 NOTYPE  WEAK   DEFAULT  UND _ITM_deregisterTMCloneTable
+    68: 0000000000011020     0 NOTYPE  WEAK   DEFAULT   23 data_start
+    69: 0000000000011030     0 NOTYPE  GLOBAL DEFAULT   24 __bss_start__
+    70: 0000000000000000     0 FUNC    WEAK   DEFAULT  UND __cxa_finalize@GLIBC_2.17
+    71: 0000000000011038     0 NOTYPE  GLOBAL DEFAULT   24 _bss_end__
+    72: 0000000000011030     0 NOTYPE  GLOBAL DEFAULT   23 _edata
+    73: 00000000000007a0     0 FUNC    GLOBAL HIDDEN    14 _fini
+    74: 0000000000011038     0 NOTYPE  GLOBAL DEFAULT   24 __bss_end__
+    75: 0000000000011020     0 NOTYPE  GLOBAL DEFAULT   23 __data_start
+    76: 0000000000000000     0 NOTYPE  WEAK   DEFAULT  UND __gmon_start__
+    77: 0000000000011028     0 OBJECT  GLOBAL HIDDEN    23 __dso_handle
+    78: 0000000000000000     0 FUNC    GLOBAL DEFAULT  UND abort@GLIBC_2.17
+    79: 00000000000007b4     4 OBJECT  GLOBAL DEFAULT   15 _IO_stdin_used
+    80: 0000000000011038     0 NOTYPE  GLOBAL DEFAULT   24 _end
+    81: 0000000000000600    52 FUNC    GLOBAL DEFAULT   13 _start
+    82: 0000000000011038     0 NOTYPE  GLOBAL DEFAULT   24 __end__
+    83: 0000000000011030     0 NOTYPE  GLOBAL DEFAULT   24 __bss_start
+    84: 0000000000000744    92 FUNC    GLOBAL DEFAULT   13 main
+    85: 0000000000011030     0 OBJECT  GLOBAL HIDDEN    23 __TMC_END__
+    86: 0000000000000000     0 NOTYPE  WEAK   DEFAULT  UND _ITM_registerTMCloneTable
+    87: 0000000000000580     0 FUNC    GLOBAL HIDDEN    11 _init
+    88: 0000000000000714    48 FUNC    GLOBAL DEFAULT   13 test
diff --git a/src/main/antlr4/Semantics.g4 b/src/main/antlr4/ASLp.g4
similarity index 99%
rename from src/main/antlr4/Semantics.g4
rename to src/main/antlr4/ASLp.g4
index 821111783..372f4ced5 100644
--- a/src/main/antlr4/Semantics.g4
+++ b/src/main/antlr4/ASLp.g4
@@ -1,4 +1,4 @@
-grammar Semantics;
+grammar ASLp;
 
 // See aslp/libASL/asl.ott for reference grammar Bap-ali-plugin/asli_lifer.ml may also be useful for
 // visitors
diff --git a/src/main/scala/Main.scala b/src/main/scala/Main.scala
index 2703b42e6..814b4c25b 100644
--- a/src/main/scala/Main.scala
+++ b/src/main/scala/Main.scala
@@ -50,6 +50,8 @@ object Main {
       threadSplit: Flag,
       @arg(name = "summarise-procedures", doc = "Generates summaries of procedures which are used in pre/post-conditions (requires --analyse flag)")
       summariseProcedures: Flag,
+      @arg(name = "memory-regions", doc = "Performs static analysis to separate memory into discrete regions in Boogie output (requires --analyse flag)")
+      memoryRegions: Flag,
       @arg(name = "no-irreducible-loops", doc = "Disable producing irreducible loops when --analyse is passed (does nothing without --analyse)")
       noIrreducibleLoops: Flag
   )
@@ -84,8 +86,7 @@ object Main {
     val q = BASILConfig(
       loading = ILLoadingConfig(conf.inputFileName, conf.relfFileName, conf.specFileName, conf.dumpIL, conf.mainProcedureName, conf.procedureDepth),
       runInterpret = conf.interpret.value,
-      staticAnalysis = if conf.analyse.value then Some(StaticAnalysisConfig(conf.dumpIL, conf.analysisResults, conf.analysisResultsDot, 
-        conf.threadSplit.value, conf.summariseProcedures.value, !conf.noIrreducibleLoops.value)) else None,
+      staticAnalysis = if conf.analyse.value then Some(StaticAnalysisConfig(conf.dumpIL, conf.analysisResults, conf.analysisResultsDot, conf.threadSplit.value, conf.summariseProcedures.value, conf.memoryRegions.value, !conf.noIrreducibleLoops.value)) else None,
       boogieTranslation = BoogieGeneratorConfig(if conf.lambdaStores.value then BoogieMemoryAccessMode.LambdaStoreSelect else BoogieMemoryAccessMode.SuccessiveStoreSelect,
         true, rely, conf.threadSplit.value),
       outputPrefix = conf.outFileName,
diff --git a/src/main/scala/analysis/ANR.scala b/src/main/scala/analysis/ANR.scala
index 196ef8634..c318bbaee 100644
--- a/src/main/scala/analysis/ANR.scala
+++ b/src/main/scala/analysis/ANR.scala
@@ -7,7 +7,7 @@ import scala.collection.immutable
 
 /**
  * Calculates the set of variables that are not read after being written up to that point in the program.
- * Useful for detecting dead stores, constants and if what variables are passed as parameters in a function call.
+ * Useful for detecting dead stores, constants and which variables are passed as parameters in a function call.
  */
 trait ANRAnalysis(program: Program) {
 
@@ -26,35 +26,41 @@ trait ANRAnalysis(program: Program) {
   /** Default implementation of eval.
     */
   def eval(cmd: Command, s: Set[Variable]): Set[Variable] = {
-    var m = s
     cmd match {
       case assume: Assume =>
-        m.diff(assume.body.variables)
+        s.diff(assume.body.variables)
       case assert: Assert =>
-        m.diff(assert.body.variables)
-      case memoryAssign: MemoryAssign =>
-        m.diff(memoryAssign.index.variables)
+        s.diff(assert.body.variables)
+      case memoryStore: MemoryStore =>
+        s.diff(memoryStore.index.variables)
       case indirectCall: IndirectCall =>
-        m - indirectCall.target
-      case assign: Assign =>
-        m = m.diff(assign.rhs.variables)
-        if ignoreRegions.contains(assign.lhs) then m else m + assign.lhs
+        s - indirectCall.target
+      case assign: LocalAssign =>
+        val m = s.diff(assign.rhs.variables)
+        if (ignoreRegions.contains(assign.lhs)) {
+          m
+        } else {
+          m + assign.lhs
+        }
+      case memoryLoad: MemoryLoad =>
+        val m = s.diff(memoryLoad.index.variables)
+        if (ignoreRegions.contains(memoryLoad.lhs)) {
+          m
+        } else {
+          m + memoryLoad.lhs
+        }
       case _ =>
-        m
+        s
     }
   }
 
   /** Transfer function for state lattice elements.
     */
-  def localTransfer(n: CFGPosition, s: Set[Variable]): Set[Variable] = n match {
+  def transfer(n: CFGPosition, s: Set[Variable]): Set[Variable] = n match {
     case cmd: Command =>
       eval(cmd, s)
     case _ => s // ignore other kinds of nodes
   }
-
-  /** Transfer function for state lattice elements.
-      */
-  def transfer(n: CFGPosition, s: Set[Variable]): Set[Variable] = localTransfer(n, s)
 }
 
 class ANRAnalysisSolver(program: Program) extends ANRAnalysis(program)
diff --git a/src/main/scala/analysis/Analysis.scala b/src/main/scala/analysis/Analysis.scala
index 9ab736160..9a77d4032 100644
--- a/src/main/scala/analysis/Analysis.scala
+++ b/src/main/scala/analysis/Analysis.scala
@@ -1,14 +1,5 @@
 package analysis
 
-import ir.*
-import analysis.solvers.*
-
-import scala.collection.mutable.{ArrayBuffer, HashMap, ListBuffer}
-import java.io.{File, PrintWriter}
-import scala.collection.mutable
-import scala.collection.immutable
-import util.Logger
-
 /** Trait for program analyses.
   *
   * @tparam R
@@ -18,177 +9,4 @@ trait Analysis[+R]:
 
   /** Performs the analysis and returns the result.
     */
-  def analyze(): R
-
-/** Base class for value analysis with simple (non-lifted) lattice.
-  */
-trait ConstantPropagation(val program: Program) {
-  /** The lattice of abstract states.
-    */
-
-  val valuelattice: ConstantPropagationLattice = ConstantPropagationLattice()
-
-  val statelattice: MapLattice[Variable, FlatElement[BitVecLiteral], ConstantPropagationLattice] = MapLattice(valuelattice)
-
-  /** Default implementation of eval.
-    */
-  def eval(exp: Expr, env: Map[Variable, FlatElement[BitVecLiteral]]): FlatElement[BitVecLiteral] =
-    import valuelattice._
-    exp match
-      case id: Variable => env(id)
-      case n: BitVecLiteral => bv(n)
-      case ze: ZeroExtend => zero_extend(ze.extension, eval(ze.body, env))
-      case se: SignExtend => sign_extend(se.extension, eval(se.body, env))
-      case e: Extract => extract(e.end, e.start, eval(e.body, env))
-      case bin: BinaryExpr =>
-        val left = eval(bin.arg1, env)
-        val right = eval(bin.arg2, env)
-        bin.op match
-          case BVADD => bvadd(left, right)
-          case BVSUB => bvsub(left, right)
-          case BVMUL => bvmul(left, right)
-          case BVUDIV => bvudiv(left, right)
-          case BVSDIV => bvsdiv(left, right)
-          case BVSREM => bvsrem(left, right)
-          case BVUREM => bvurem(left, right)
-          case BVSMOD => bvsmod(left, right)
-          case BVAND => bvand(left, right)
-          case BVOR => bvor(left, right)
-          case BVXOR => bvxor(left, right)
-          case BVNAND => bvnand(left, right)
-          case BVNOR => bvnor(left, right)
-          case BVXNOR => bvxnor(left, right)
-          case BVSHL => bvshl(left, right)
-          case BVLSHR => bvlshr(left, right)
-          case BVASHR => bvashr(left, right)
-          case BVCOMP => bvcomp(left, right)
-          case BVCONCAT => concat(left, right)
-
-      case un: UnaryExpr =>
-        val arg = eval(un.arg, env)
-
-        un.op match
-          case BVNOT => bvnot(arg)
-          case BVNEG => bvneg(arg)
-
-      case _ => valuelattice.top
-
-  /** Transfer function for state lattice elements.
-    */
-  def localTransfer(n: CFGPosition, s: Map[Variable, FlatElement[BitVecLiteral]]): Map[Variable, FlatElement[BitVecLiteral]] =
-    n match
-      case r: Command =>
-        r match
-          // assignments
-          case la: Assign =>
-            s + (la.lhs -> eval(la.rhs, s))
-          // all others: like no-ops
-          case _ => s
-      case _ => s
-
-  /** The analysis lattice.
-    */
-  val lattice: MapLattice[CFGPosition, Map[Variable, FlatElement[BitVecLiteral]], MapLattice[Variable, FlatElement[BitVecLiteral], ConstantPropagationLattice]] = MapLattice(statelattice)
-
-  val domain: Set[CFGPosition] = Set.empty ++ program
-
-  /** Transfer function for state lattice elements. (Same as `localTransfer` for simple value analysis.)
-    */
-  def transfer(n: CFGPosition, s: Map[Variable, FlatElement[BitVecLiteral]]): Map[Variable, FlatElement[BitVecLiteral]] = localTransfer(n, s)
-}
-
-class ConstantPropagationSolver(program: Program) extends ConstantPropagation(program)
-    with SimplePushDownWorklistFixpointSolver[CFGPosition, Map[Variable, FlatElement[BitVecLiteral]], MapLattice[Variable, FlatElement[BitVecLiteral], ConstantPropagationLattice]]
-    with IRIntraproceduralForwardDependencies
-    with Analysis[Map[CFGPosition, Map[Variable, FlatElement[BitVecLiteral]]]]
-
-/** Base class for value analysis with simple (non-lifted) lattice.
- */
-trait ConstantPropagationWithSSA(val program: Program, val reachingDefs: Map[CFGPosition, (Map[Variable, Set[Assign]], Map[Variable, Set[Assign]])]) {
-  /** The lattice of abstract states.
-   */
-
-  val valuelattice: ConstantPropagationLatticeWithSSA = ConstantPropagationLatticeWithSSA()
-
-  val statelattice: MapLattice[RegisterWrapperEqualSets, Set[BitVecLiteral], ConstantPropagationLatticeWithSSA] = MapLattice(valuelattice)
-
-  /** Default implementation of eval.
-   */
-  def eval(exp: Expr, env: Map[RegisterWrapperEqualSets, Set[BitVecLiteral]], n: CFGPosition): Set[BitVecLiteral] =
-    import valuelattice._
-    exp match
-      case id: Variable => env(RegisterWrapperEqualSets(id, getUse(id, n, reachingDefs)))
-      case n: BitVecLiteral => bv(n)
-      case ze: ZeroExtend => zero_extend(ze.extension, eval(ze.body, env, n))
-      case se: SignExtend => sign_extend(se.extension, eval(se.body, env, n))
-      case e: Extract => extract(e.end, e.start, eval(e.body, env, n))
-      case bin: BinaryExpr =>
-        val left = eval(bin.arg1, env, n)
-        val right = eval(bin.arg2, env, n)
-        bin.op match
-          case BVADD => bvadd(left, right)
-          case BVSUB => bvsub(left, right)
-          case BVMUL => bvmul(left, right)
-          case BVUDIV => bvudiv(left, right)
-          case BVSDIV => bvsdiv(left, right)
-          case BVSREM => bvsrem(left, right)
-          case BVUREM => bvurem(left, right)
-          case BVSMOD => bvsmod(left, right)
-          case BVAND => bvand(left, right)
-          case BVOR => bvor(left, right)
-          case BVXOR => bvxor(left, right)
-          case BVNAND => bvnand(left, right)
-          case BVNOR => bvnor(left, right)
-          case BVXNOR => bvxnor(left, right)
-          case BVSHL => bvshl(left, right)
-          case BVLSHR => bvlshr(left, right)
-          case BVASHR => bvashr(left, right)
-          case BVCOMP => bvcomp(left, right)
-          case BVCONCAT => concat(left, right)
-
-      case un: UnaryExpr =>
-        val arg = eval(un.arg, env, n)
-
-        un.op match
-          case BVNOT => bvnot(arg)
-          case BVNEG => bvneg(arg)
-
-      case _ => Set.empty
-
-  /** Transfer function for state lattice elements.
-   */
-  def localTransfer(n: CFGPosition, s: Map[RegisterWrapperEqualSets, Set[BitVecLiteral]]): Map[RegisterWrapperEqualSets, Set[BitVecLiteral]] =
-    n match {
-      case r: Command =>
-        r match {
-          // assignments
-          case a: Assign =>
-            val lhsWrappers = s.collect {
-              case (k, v) if RegisterVariableWrapper(k.variable, k.assigns) == RegisterVariableWrapper(a.lhs, getDefinition(a.lhs, r, reachingDefs)) => (k, v)
-            }
-            if (lhsWrappers.nonEmpty) {
-              s ++ lhsWrappers.map((k, v) => (k, v.union(eval(a.rhs, s, r))))
-            } else {
-              s + (RegisterWrapperEqualSets(a.lhs, getDefinition(a.lhs, r, reachingDefs)) -> eval(a.rhs, s, n))
-            }
-          // all others: like no-ops
-          case _ => s
-        }
-      case _ => s
-    }
-
-  /** The analysis lattice.
-   */
-  val lattice: MapLattice[CFGPosition, Map[RegisterWrapperEqualSets, Set[BitVecLiteral]], MapLattice[RegisterWrapperEqualSets, Set[BitVecLiteral], ConstantPropagationLatticeWithSSA]] = MapLattice(statelattice)
-
-  val domain: Set[CFGPosition] = Set.empty ++ program
-
-  /** Transfer function for state lattice elements. (Same as `localTransfer` for simple value analysis.)
-   */
-  def transfer(n: CFGPosition, s: Map[RegisterWrapperEqualSets, Set[BitVecLiteral]]): Map[RegisterWrapperEqualSets, Set[BitVecLiteral]] = localTransfer(n, s)
-}
-
-class ConstantPropagationSolverWithSSA(program: Program, reachingDefs: Map[CFGPosition, (Map[Variable, Set[Assign]], Map[Variable, Set[Assign]])]) extends ConstantPropagationWithSSA(program, reachingDefs)
-  with SimplePushDownWorklistFixpointSolver[CFGPosition, Map[RegisterWrapperEqualSets, Set[BitVecLiteral]], MapLattice[RegisterWrapperEqualSets, Set[BitVecLiteral], ConstantPropagationLatticeWithSSA]]
-  with IRIntraproceduralForwardDependencies
-  with Analysis[Map[CFGPosition, Map[RegisterWrapperEqualSets, Set[BitVecLiteral]]]]
+  def analyze(): R
\ No newline at end of file
diff --git a/src/main/scala/analysis/BasicIRConstProp.scala b/src/main/scala/analysis/BasicIRConstProp.scala
deleted file mode 100644
index 36a6d72d8..000000000
--- a/src/main/scala/analysis/BasicIRConstProp.scala
+++ /dev/null
@@ -1,75 +0,0 @@
-package analysis
-import ir.*
-import analysis.solvers.*
-
-trait ILValueAnalysisMisc:
-  val valuelattice: ConstantPropagationLattice = ConstantPropagationLattice()
-  val statelattice: MapLattice[Variable, FlatElement[BitVecLiteral], ConstantPropagationLattice] = MapLattice(valuelattice)
-
-  def eval(exp: Expr, env: Map[Variable, FlatElement[BitVecLiteral]]): FlatElement[BitVecLiteral] =
-    import valuelattice._
-    exp match
-      case id: Variable => env(id)
-      case n: BitVecLiteral => bv(n)
-      case ze: ZeroExtend => zero_extend(ze.extension, eval(ze.body, env))
-      case se: SignExtend => sign_extend(se.extension, eval(se.body, env))
-      case e: Extract => extract(e.end, e.start, eval(e.body, env))
-      case bin: BinaryExpr =>
-        val left = eval(bin.arg1, env)
-        val right = eval(bin.arg2, env)
-        bin.op match
-          case BVADD => bvadd(left, right)
-          case BVSUB => bvsub(left, right)
-          case BVMUL => bvmul(left, right)
-          case BVUDIV => bvudiv(left, right)
-          case BVSDIV => bvsdiv(left, right)
-          case BVSREM => bvsrem(left, right)
-          case BVUREM => bvurem(left, right)
-          case BVSMOD => bvsmod(left, right)
-          case BVAND => bvand(left, right)
-          case BVOR => bvor(left, right)
-          case BVXOR => bvxor(left, right)
-          case BVNAND => bvnand(left, right)
-          case BVNOR => bvnor(left, right)
-          case BVXNOR => bvxnor(left, right)
-          case BVSHL => bvshl(left, right)
-          case BVLSHR => bvlshr(left, right)
-          case BVASHR => bvashr(left, right)
-          case BVCOMP => bvcomp(left, right)
-          case BVCONCAT => concat(left, right)
-
-      case un: UnaryExpr =>
-        val arg = eval(un.arg, env)
-
-        un.op match
-          case BVNOT => bvnot(arg)
-          case BVNEG => bvneg(arg)
-
-      case _ => valuelattice.top
-
-  private final val callerPreservedRegisters = Set("R0", "R1", "R2", "R3", "R4", "R5", "R6", "R7", "R8", "R9", "R10",
-    "R11", "R12", "R13", "R14", "R15", "R16", "R17", "R18", "R30")
-
-  /** Transfer function for state lattice elements.
-    */
-  def localTransfer(n: CFGPosition, s: Map[Variable, FlatElement[BitVecLiteral]]): Map[Variable, FlatElement[BitVecLiteral]] =
-    n match
-      case la: Assign =>
-        s + (la.lhs -> eval(la.rhs, s))
-      case c: Call => s ++ callerPreservedRegisters.filter(reg => s.keys.exists(_.name == reg)).map(n => Register(n, 64) -> statelattice.sublattice.top).toMap
-      case _ => s
-
-
-
-object IRSimpleValueAnalysis:
-
-  class Solver(prog: Program) extends ILValueAnalysisMisc
-    with IRIntraproceduralForwardDependencies 
-    with Analysis[Map[CFGPosition, Map[Variable, FlatElement[BitVecLiteral]]]]
-    with SimplePushDownWorklistFixpointSolver[CFGPosition, Map[Variable, FlatElement[BitVecLiteral]], MapLattice[Variable, FlatElement[BitVecLiteral], ConstantPropagationLattice]]:
-      /* Worklist initial set */
-      //override val lattice: MapLattice[CFGPosition, statelattice.type] = MapLattice(statelattice)
-      override val lattice: MapLattice[CFGPosition, Map[Variable, FlatElement[BitVecLiteral]], MapLattice[Variable, FlatElement[BitVecLiteral], ConstantPropagationLattice]] = MapLattice(statelattice)
-
-      override val domain: Set[CFGPosition] = computeDomain(IntraProcIRCursor, prog.procedures).toSet
-      def transfer(n: CFGPosition, s: Map[Variable, FlatElement[BitVecLiteral]]): Map[Variable, FlatElement[BitVecLiteral]] = localTransfer(n, s)
diff --git a/src/main/scala/analysis/BitVectorEval.scala b/src/main/scala/analysis/BitVectorEval.scala
index 0b5847506..ee2d09512 100644
--- a/src/main/scala/analysis/BitVectorEval.scala
+++ b/src/main/scala/analysis/BitVectorEval.scala
@@ -1,7 +1,8 @@
 package analysis
-import ir._
+import ir.*
 import analysis.BitVectorEval.*
 
+import scala.annotation.tailrec
 import scala.math.pow
 
 object BitVectorEval {
@@ -24,6 +25,16 @@ object BitVectorEval {
     */
   def bv2nat(b: BitVecLiteral): BigInt = b.value
 
+  /**
+   * Converts a bitvector value to its corresponding signed integer
+   */
+  def bv2SignedInt(b: BitVecLiteral): BigInt =
+    if isNegative(b) then
+      b.value - BigInt(2).pow(b.size)
+    else
+      b.value
+
+
   /** (bvadd (_ BitVec m) (_ BitVec m) (_ BitVec m))
     *   - addition modulo 2^m
     *
@@ -327,5 +338,4 @@ object BitVectorEval {
       smt_zero_extend(i, s)
     }
   }
-
 }
diff --git a/src/main/scala/analysis/ConstantPropagation.scala b/src/main/scala/analysis/ConstantPropagation.scala
new file mode 100644
index 000000000..a5f6d2d00
--- /dev/null
+++ b/src/main/scala/analysis/ConstantPropagation.scala
@@ -0,0 +1,192 @@
+package analysis
+import ir.*
+import analysis.solvers.*
+
+trait ConstantPropagation {
+  val valuelattice: ConstantPropagationLattice = ConstantPropagationLattice()
+  val statelattice: MapLattice[Variable, FlatElement[BitVecLiteral], ConstantPropagationLattice] = MapLattice(valuelattice)
+  val lattice: MapLattice[CFGPosition, Map[Variable, FlatElement[BitVecLiteral]], MapLattice[Variable, FlatElement[BitVecLiteral], ConstantPropagationLattice]] = MapLattice(statelattice)
+
+  def eval(exp: Expr, env: Map[Variable, FlatElement[BitVecLiteral]]): FlatElement[BitVecLiteral] = {
+    import valuelattice.*
+    exp match {
+      case id: Variable => env(id)
+      case n: BitVecLiteral => bv(n)
+      case ze: ZeroExtend => zero_extend(ze.extension, eval(ze.body, env))
+      case se: SignExtend => sign_extend(se.extension, eval(se.body, env))
+      case e: Extract => extract(e.end, e.start, eval(e.body, env))
+      case bin: BinaryExpr =>
+        val left = eval(bin.arg1, env)
+        val right = eval(bin.arg2, env)
+        bin.op match {
+          case BVADD => bvadd(left, right)
+          case BVSUB => bvsub(left, right)
+          case BVMUL => bvmul(left, right)
+          case BVUDIV => bvudiv(left, right)
+          case BVSDIV => bvsdiv(left, right)
+          case BVSREM => bvsrem(left, right)
+          case BVUREM => bvurem(left, right)
+          case BVSMOD => bvsmod(left, right)
+          case BVAND => bvand(left, right)
+          case BVOR => bvor(left, right)
+          case BVXOR => bvxor(left, right)
+          case BVNAND => bvnand(left, right)
+          case BVNOR => bvnor(left, right)
+          case BVXNOR => bvxnor(left, right)
+          case BVSHL => bvshl(left, right)
+          case BVLSHR => bvlshr(left, right)
+          case BVASHR => bvashr(left, right)
+          case BVCOMP => bvcomp(left, right)
+          case BVCONCAT => concat(left, right)
+        }
+      case un: UnaryExpr =>
+        val arg = eval(un.arg, env)
+        un.op match {
+          case BVNOT => bvnot(arg)
+          case BVNEG => bvneg(arg)
+        }
+      case _ => valuelattice.top
+    }
+  }
+}
+
+class IntraProcConstantPropagation(prog: Program) extends ConstantPropagation
+with IRIntraproceduralForwardDependencies
+with Analysis[Map[CFGPosition, Map[Variable, FlatElement[BitVecLiteral]]]]
+with SimplePushDownWorklistFixpointSolver[CFGPosition, Map[Variable, FlatElement[BitVecLiteral]], MapLattice[Variable, FlatElement[BitVecLiteral], ConstantPropagationLattice]] {
+  override val domain: Set[CFGPosition] = computeDomain(IntraProcIRCursor, prog.procedures).toSet
+
+  private final val callerPreservedRegisters: Set[Variable] = Set("R0", "R1", "R2", "R3", "R4", "R5", "R6", "R7", "R8", "R9", "R10",
+    "R11", "R12", "R13", "R14", "R15", "R16", "R17", "R18", "R30").map(n => Register(n, 64))
+
+  def transfer(n: CFGPosition, s: Map[Variable, FlatElement[BitVecLiteral]]): Map[Variable, FlatElement[BitVecLiteral]] = {
+    n match {
+      case la: LocalAssign =>
+        s + (la.lhs -> eval(la.rhs, s))
+      case l: MemoryLoad =>
+        s + (l.lhs -> valuelattice.top)
+      case _: Call => s.map { (k, v) =>
+        if (callerPreservedRegisters.contains(k)) {
+          (k, valuelattice.top)
+        } else {
+          (k, v)
+        }
+      }
+      case _ => s
+    }
+  }
+}
+
+class InterProcConstantPropagation(val program: Program) extends ConstantPropagation
+with SimplePushDownWorklistFixpointSolver[CFGPosition, Map[Variable, FlatElement[BitVecLiteral]], MapLattice[Variable, FlatElement[BitVecLiteral], ConstantPropagationLattice]]
+with IRInterproceduralForwardDependencies
+with Analysis[Map[CFGPosition, Map[Variable, FlatElement[BitVecLiteral]]]] {
+
+  def transfer(n: CFGPosition, s: Map[Variable, FlatElement[BitVecLiteral]]): Map[Variable, FlatElement[BitVecLiteral]] = {
+    n match {
+      // assignments
+      case la: LocalAssign =>
+        s + (la.lhs -> eval(la.rhs, s))
+      case load: MemoryLoad =>
+        s + (load.lhs -> valuelattice.top)
+      // all others: like no-ops
+      case _ => s
+    }
+  }
+
+  override val domain: Set[CFGPosition] = Set.empty ++ program
+}
+
+/** Base class for value analysis with simple (non-lifted) lattice.
+  */
+trait ConstantPropagationWithSSA(val program: Program, val reachingDefs: Map[CFGPosition, (Map[Variable, Set[Assign]], Map[Variable, Set[Assign]])]) {
+  /** The lattice of abstract states.
+    */
+
+  val valuelattice: ConstantPropagationLatticeWithSSA = ConstantPropagationLatticeWithSSA()
+
+  val statelattice: MapLattice[RegisterWrapperEqualSets, Set[BitVecLiteral], ConstantPropagationLatticeWithSSA] = MapLattice(valuelattice)
+
+  /** Default implementation of eval.
+    */
+  def eval(exp: Expr, env: Map[RegisterWrapperEqualSets, Set[BitVecLiteral]], n: CFGPosition): Set[BitVecLiteral] = {
+    import valuelattice.*
+    exp match {
+      case id: Variable => env(RegisterWrapperEqualSets(id, getUse(id, n, reachingDefs)))
+      case n: BitVecLiteral => bv(n)
+      case ze: ZeroExtend => zero_extend(ze.extension, eval(ze.body, env, n))
+      case se: SignExtend => sign_extend(se.extension, eval(se.body, env, n))
+      case e: Extract => extract(e.end, e.start, eval(e.body, env, n))
+      case bin: BinaryExpr =>
+        val left = eval(bin.arg1, env, n)
+        val right = eval(bin.arg2, env, n)
+        bin.op match {
+          case BVADD => bvadd(left, right)
+          case BVSUB => bvsub(left, right)
+          case BVMUL => bvmul(left, right)
+          case BVUDIV => bvudiv(left, right)
+          case BVSDIV => bvsdiv(left, right)
+          case BVSREM => bvsrem(left, right)
+          case BVUREM => bvurem(left, right)
+          case BVSMOD => bvsmod(left, right)
+          case BVAND => bvand(left, right)
+          case BVOR => bvor(left, right)
+          case BVXOR => bvxor(left, right)
+          case BVNAND => bvnand(left, right)
+          case BVNOR => bvnor(left, right)
+          case BVXNOR => bvxnor(left, right)
+          case BVSHL => bvshl(left, right)
+          case BVLSHR => bvlshr(left, right)
+          case BVASHR => bvashr(left, right)
+          case BVCOMP => bvcomp(left, right)
+          case BVCONCAT => concat(left, right)
+        }
+
+      case un: UnaryExpr =>
+        val arg = eval(un.arg, env, n)
+        un.op match {
+          case BVNOT => bvnot(arg)
+          case BVNEG => bvneg(arg)
+        }
+
+      case _ => Set.empty
+    }
+  }
+
+  /** Transfer function for state lattice elements.
+    */
+  def transfer(n: CFGPosition, s: Map[RegisterWrapperEqualSets, Set[BitVecLiteral]]): Map[RegisterWrapperEqualSets, Set[BitVecLiteral]] =
+    n match {
+      case a: LocalAssign =>
+        val lhsWrappers = s.collect {
+          case (k, v) if RegisterVariableWrapper(k.variable, k.assigns) == RegisterVariableWrapper(a.lhs, getDefinition(a.lhs, a, reachingDefs)) => (k, v)
+        }
+        if (lhsWrappers.nonEmpty) {
+          s ++ lhsWrappers.map((k, v) => (k, v.union(eval(a.rhs, s, a))))
+        } else {
+          s + (RegisterWrapperEqualSets(a.lhs, getDefinition(a.lhs, a, reachingDefs)) -> eval(a.rhs, s, n))
+        }
+      case l: MemoryLoad =>
+        val lhsWrappers = s.collect {
+          case (k, v) if RegisterVariableWrapper(k.variable, k.assigns) == RegisterVariableWrapper(l.lhs, getDefinition(l.lhs, l, reachingDefs)) => (k, v)
+        }
+        if (lhsWrappers.nonEmpty) {
+          s ++ lhsWrappers
+        } else {
+          s + (RegisterWrapperEqualSets(l.lhs, getDefinition(l.lhs, l, reachingDefs)) -> Set())
+        }
+
+      case _ => s
+    }
+
+  /** The analysis lattice.
+    */
+  val lattice: MapLattice[CFGPosition, Map[RegisterWrapperEqualSets, Set[BitVecLiteral]], MapLattice[RegisterWrapperEqualSets, Set[BitVecLiteral], ConstantPropagationLatticeWithSSA]] = MapLattice(statelattice)
+
+  val domain: Set[CFGPosition] = Set.empty ++ program
+}
+
+class ConstantPropagationSolverWithSSA(program: Program, reachingDefs: Map[CFGPosition, (Map[Variable, Set[Assign]], Map[Variable, Set[Assign]])]) extends ConstantPropagationWithSSA(program, reachingDefs)
+  with SimplePushDownWorklistFixpointSolver[CFGPosition, Map[RegisterWrapperEqualSets, Set[BitVecLiteral]], MapLattice[RegisterWrapperEqualSets, Set[BitVecLiteral], ConstantPropagationLatticeWithSSA]]
+  with IRInterproceduralForwardDependencies
+  with Analysis[Map[CFGPosition, Map[RegisterWrapperEqualSets, Set[BitVecLiteral]]]]
diff --git a/src/main/scala/analysis/GlobalRegionAnalysis.scala b/src/main/scala/analysis/GlobalRegionAnalysis.scala
new file mode 100644
index 000000000..2157b4d80
--- /dev/null
+++ b/src/main/scala/analysis/GlobalRegionAnalysis.scala
@@ -0,0 +1,196 @@
+package analysis
+
+import analysis.solvers.SimpleWorklistFixpointSolver
+import ir.*
+
+import scala.collection.mutable
+
+trait GlobalRegionAnalysis(val program: Program,
+                           val domain: Set[CFGPosition],
+                           val constantProp: Map[CFGPosition, Map[Variable, FlatElement[BitVecLiteral]]],
+                           val reachingDefs: Map[CFGPosition, (Map[Variable, Set[Assign]], Map[Variable, Set[Assign]])],
+                           val mmm: MemoryModelMap,
+                           val vsaResult: Map[CFGPosition, LiftedElement[Map[Variable | MemoryRegion, Set[Value]]]]) {
+
+  private var dataCount: Int = 0
+  private def nextDataCount() = {
+    dataCount += 1
+    s"data_$dataCount"
+  }
+
+  val regionLattice: PowersetLattice[DataRegion] = PowersetLattice()
+
+  val lattice: MapLattice[CFGPosition, Set[DataRegion], PowersetLattice[DataRegion]] = MapLattice(regionLattice)
+
+  val first: Set[CFGPosition] = Set(program.mainProcedure)
+
+  private val dataMap: mutable.HashMap[BigInt, DataRegion] = mutable.HashMap()
+
+  private def dataPoolMaster(offset: BigInt, size: BigInt): DataRegion = {
+    assert(size >= 0)
+    if (dataMap.contains(offset)) {
+      if (dataMap(offset).size < (size.toDouble / 8).ceil.toInt) {
+        dataMap(offset) = DataRegion(dataMap(offset).regionIdentifier, offset, (size.toDouble / 8).ceil.toInt)
+        dataMap(offset)
+      } else {
+        dataMap(offset)
+      }
+    } else {
+      dataMap(offset) = DataRegion(nextDataCount(), offset, (size.toDouble / 8).ceil.toInt)
+      dataMap(offset)
+    }
+  }
+
+  def getDataMap: mutable.HashMap[BigInt, DataRegion] = dataMap
+
+  /**
+   * For DataRegions, the actual address used needs to be converted to the relocated address.
+   * This is because when regions are found, the relocated address is used and as such match
+   * the correct range.
+   *
+   * @param address: The starting DataRegion
+   * @return DataRegion: The relocated data region if any
+   */
+  def resolveGlobalOffsetSecondLast(address: DataRegion): DataRegion = {
+    var tableAddress = address
+    // addresses may be layered as in jumptable2 example for which recursive search is required
+    var exitLoop = false
+    while (mmm.relocatedDataRegion(tableAddress.start).isDefined && mmm.relocatedDataRegion(mmm.relocatedDataRegion(tableAddress.start).get.start).isDefined && !exitLoop) {
+      val newAddress = mmm.relocatedDataRegion(tableAddress.start).getOrElse(tableAddress)
+      if (newAddress == tableAddress) {
+        exitLoop = true
+      } else {
+        tableAddress = newAddress
+      }
+    }
+    tableAddress
+  }
+
+  def tryCoerceIntoData(exp: Expr, n: Command, subAccess: BigInt, loadOp: Boolean = false): Set[DataRegion] = {
+    val eval = evaluateExpression(exp, constantProp(n))
+    if (eval.isDefined) {
+      Set(dataPoolMaster(eval.get.value, subAccess))
+    } else {
+      exp match {
+        case literal: BitVecLiteral => tryCoerceIntoData(literal, n, subAccess)
+        case Extract(_, _, body) => tryCoerceIntoData(body, n, subAccess)
+        case Repeat(_, body) => tryCoerceIntoData(body, n, subAccess)
+        case ZeroExtend(_, body) => tryCoerceIntoData(body, n, subAccess)
+        case SignExtend(_, body) => tryCoerceIntoData(body, n, subAccess)
+        case UnaryExpr(_, arg) => tryCoerceIntoData(arg, n, subAccess)
+        case BinaryExpr(op, arg1, arg2) =>
+          val evalArg2 = evaluateExpression(arg2, constantProp(n))
+          if (evalArg2.isDefined) {
+            tryCoerceIntoData(arg1, n, subAccess, true) flatMap { i =>
+              val newExpr = BinaryExpr(op, BitVecLiteral(i.start, evalArg2.get.size), evalArg2.get)
+              tryCoerceIntoData(newExpr, n, subAccess)
+            }
+          } else {
+            Set()
+          }
+        case _: UninterpretedFunction => Set.empty
+        case variable: Variable =>
+          val ctx = getUse(variable, n, reachingDefs)
+          val collage = ctx.flatMap { i =>
+            if (i != n) {
+              val regions: Set[DataRegion] = vsaResult.get(i) match {
+                case Some(Lift(el)) =>
+                  el.getOrElse(i.lhs, Set()).flatMap {
+                    case AddressValue(region) =>
+                      el.getOrElse(region, Set()).flatMap {
+                        case AddressValue(dataRegion: DataRegion) => Some(dataRegion)
+                        case _ => None
+                      }
+                    case _ => Set()
+                  }
+                case _ => Set()
+              }
+              if (regions.isEmpty) {
+                localTransfer(i, Set())
+              } else {
+                regions
+              }
+            } else {
+              Set()
+            }
+          }
+          collage.map { i =>
+            if (!loadOp) {
+              mmm.relocatedDataRegion(i.start).getOrElse(i)
+            } else {
+              resolveGlobalOffsetSecondLast(i)
+            }
+          }
+        case _ => Set()
+      }
+    }
+  }
+
+  def evalMemLoadToGlobal(index: Expr, size: BigInt, n: Command, loadOp: Boolean = false): Set[DataRegion] = {
+    val indexValue = evaluateExpression(index, constantProp(n))
+    if (indexValue.isDefined) {
+      val indexValueBigInt = indexValue.get.value
+      Set(dataPoolMaster(indexValueBigInt, size))
+    } else {
+      tryCoerceIntoData(index, n, size)
+    }
+  }
+
+  /**
+   * Check if the data region is defined.
+   * Finds full and partial matches
+   * Full matches sizes are altered to match the size of the data region
+   * Partial matches are not altered
+   * Otherwise the data region is returned
+   *
+   * @param dataRegions Set[DataRegion]
+   * @param n CFGPosition
+   * @return Set[DataRegion]
+   */
+  def checkIfDefined(dataRegions: Set[DataRegion], n: CFGPosition): Set[DataRegion] = {
+    dataRegions.map { i =>
+      val (f, p) = mmm.findDataObjectWithSize(i.start, i.size)
+      val accesses = f.union(p)
+      if (accesses.isEmpty) {
+        i
+      } else if (accesses.size == 1) {
+        dataMap(i.start) = DataRegion(i.regionIdentifier, i.start, i.size.max(accesses.head.size))
+        dataMap(i.start)
+      } else {
+        val highestRegion = accesses.maxBy(_.start)
+        dataMap(i.start) = DataRegion(i.regionIdentifier, i.start, i.size.max(highestRegion.end - i.start))
+        dataMap(i.start)
+      }
+    }
+  }
+
+  /** Transfer function for state lattice elements.
+   */
+  def localTransfer(n: CFGPosition, s: Set[DataRegion]): Set[DataRegion] = {
+    n match {
+      case store: MemoryStore =>
+        checkIfDefined(evalMemLoadToGlobal(store.index, store.size, store), n)
+      case load: MemoryLoad =>
+        checkIfDefined(evalMemLoadToGlobal(load.index, load.size, load, loadOp = true), n)
+      case assign: LocalAssign =>
+        // this is a constant but we need to check if it is a data region
+        checkIfDefined(evalMemLoadToGlobal(assign.rhs, 1, assign), n)
+      case _ =>
+        Set()
+    }
+ }
+
+  def transfer(n: CFGPosition, s: Set[DataRegion]): Set[DataRegion] = localTransfer(n, s)
+}
+
+class GlobalRegionAnalysisSolver(
+                                  program: Program,
+                                  domain: Set[CFGPosition],
+                                  constantProp: Map[CFGPosition, Map[Variable, FlatElement[BitVecLiteral]]],
+                                  reachingDefs: Map[CFGPosition, (Map[Variable, Set[Assign]], Map[Variable, Set[Assign]])],
+                                  mmm: MemoryModelMap,
+                                  vsaResult: Map[CFGPosition, LiftedElement[Map[Variable | MemoryRegion, Set[Value]]]]
+  ) extends GlobalRegionAnalysis(program, domain, constantProp, reachingDefs, mmm, vsaResult)
+  with IRIntraproceduralForwardDependencies
+  with Analysis[Map[CFGPosition, Set[DataRegion]]]
+  with SimpleWorklistFixpointSolver[CFGPosition, Set[DataRegion], PowersetLattice[DataRegion]]
\ No newline at end of file
diff --git a/src/main/scala/analysis/InterLiveVarsAnalysis.scala b/src/main/scala/analysis/InterLiveVarsAnalysis.scala
index cbe3076c6..ef9173a65 100644
--- a/src/main/scala/analysis/InterLiveVarsAnalysis.scala
+++ b/src/main/scala/analysis/InterLiveVarsAnalysis.scala
@@ -1,7 +1,7 @@
 package analysis
 
 import analysis.solvers.BackwardIDESolver
-import ir.{Assert, Assume, Block, GoTo, CFGPosition, Command, DirectCall, IndirectCall, Assign, MemoryAssign, Unreachable, Return, Procedure, Program, Variable, toShortString}
+import ir.{Assert, LocalAssign, Assume, CFGPosition, Command, DirectCall, IndirectCall, MemoryLoad, MemoryStore, Procedure, Program, Return, Variable}
 
 /**
  * Micro-transfer-functions for LiveVar analysis
@@ -28,54 +28,68 @@ trait LiveVarsAnalysisFunctions extends BackwardIDEAnalysis[Variable, TwoElement
   }
 
   def edgesCallToAfterCall(call: Command, aftercall: DirectCall)(d: DL): Map[DL, EdgeFunction[TwoElement]] = {
-    d match
-      case Left(value) => Map() // maps all variables before the call to bottom
+    d match {
+      case Left(_) => Map() // maps all variables before the call to bottom
       case Right(_) => Map(d -> IdEdge())
+    }
   }
 
   def edgesOther(n: CFGPosition)(d: DL): Map[DL, EdgeFunction[TwoElement]] = {
-    n match
-      case Assign(variable, expr, _) => // (s - variable) ++ expr.variables
-        d match
+    n match {
+      case LocalAssign(variable, expr, _) => // (s - variable) ++ expr.variables
+        d match {
           case Left(value) =>
             if value == variable then
               Map()
             else
               Map(d -> IdEdge())
-
-          case Right(_) => expr.variables.foldLeft(Map[DL, EdgeFunction[TwoElement]](d -> IdEdge())) {
+          case Right(_) =>
+            expr.variables.foldLeft(Map[DL, EdgeFunction[TwoElement]](d -> IdEdge())) {
+              (mp, expVar) => mp + (Left(expVar) -> ConstEdge(TwoElementTop))
+            }
+        }
+      case MemoryLoad(lhs, _, index, _, _, _) =>
+        d match {
+          case Left(value) =>
+            if value == lhs then
+              Map()
+            else
+              Map(d -> IdEdge())
+          case Right(_) => index.variables.foldLeft(Map[DL, EdgeFunction[TwoElement]](d -> IdEdge())) {
             (mp, expVar) => mp + (Left(expVar) -> ConstEdge(TwoElementTop))
           }
-
-      case MemoryAssign(_, index, value, _, _, _) => // s ++ store.index.variables ++ store.value.variables
-        d match
-          case Left(value) => Map(d -> IdEdge())
+        }
+      case MemoryStore(_, index, value, _, _, _) => // s ++ store.index.variables ++ store.value.variables
+        d match {
+          case Left(_) => Map(d -> IdEdge())
           case Right(_) =>
             (index.variables ++ value.variables).foldLeft(Map[DL, EdgeFunction[TwoElement]](d -> IdEdge())) {
               (mp, storVar) => mp + (Left(storVar) -> ConstEdge(TwoElementTop))
             }
-
+        }
       case Assume(expr, _, _, _) => // s ++ expr.variables
-        d match
-          case Left(value) => Map(d -> IdEdge())
+        d match {
+          case Left(_) => Map(d -> IdEdge())
           case Right(_) =>
             expr.variables.foldLeft(Map(d -> IdEdge()): Map[DL, EdgeFunction[TwoElement]]) {
               (mp, expVar) => mp + (Left(expVar) -> ConstEdge(TwoElementTop))
             }
-
+        }
       case Assert(expr, _, _) => // s ++ expr.variables
-        d match
-          case Left(value) => Map(d -> IdEdge())
+        d match {
+          case Left(_) => Map(d -> IdEdge())
           case Right(_) =>
             expr.variables.foldLeft(Map[DL, EdgeFunction[TwoElement]](d -> IdEdge())) {
               (mp, expVar) => mp + (Left(expVar) -> ConstEdge(TwoElementTop))
             }
+        }
       case IndirectCall(variable, _) =>
-        d match
+        d match {
           case Left(value) => if value != variable then Map(d -> IdEdge()) else Map()
           case Right(_) => Map(d -> IdEdge(), Left(variable) -> ConstEdge(TwoElementTop))
+        }
       case _ => Map(d -> IdEdge())
-
+    }
   }
 }
 
diff --git a/src/main/scala/analysis/InterprocSteensgaardAnalysis.scala b/src/main/scala/analysis/InterprocSteensgaardAnalysis.scala
index 4e7ba81f1..ea34505f1 100644
--- a/src/main/scala/analysis/InterprocSteensgaardAnalysis.scala
+++ b/src/main/scala/analysis/InterprocSteensgaardAnalysis.scala
@@ -22,321 +22,122 @@ case class RegisterVariableWrapper(variable: Variable, assigns: Set[Assign]) {
 /** Wrapper for variables so we can have ConstantPropegation-specific equals method indirectly
  * Relies on SSA sets being exactly the same
  * */
-case class RegisterWrapperEqualSets(variable: Variable, assigns: Set[Assign]) {
-  override def equals(obj: Any): Boolean = {
-    obj match {
-      case RegisterWrapperEqualSets(other, otherAssigns) =>
-        variable == other && assigns == otherAssigns
-      case _ =>
-        false
-    }
-  }
-}
+case class RegisterWrapperEqualSets(variable: Variable, assigns: Set[Assign])
 
 /** Steensgaard-style pointer analysis. The analysis associates an [[StTerm]] with each variable declaration and
-  * expression node in the AST. It is implemented using [[analysis.solvers.UnionFindSolver]].
-  */
+ * expression node in the AST. It is implemented using [[analysis.solvers.UnionFindSolver]].
+ */
 class InterprocSteensgaardAnalysis(
-      program: Program,
-      constantProp: Map[CFGPosition, Map[RegisterWrapperEqualSets, Set[BitVecLiteral]]],
-      regionAccesses: Map[CFGPosition, Map[RegisterVariableWrapper, FlatElement[Expr]]],
-      mmm: MemoryModelMap,
-      reachingDefs: Map[CFGPosition, (Map[Variable, Set[Assign]], Map[Variable, Set[Assign]])],
-      globalOffsets: Map[BigInt, BigInt]) extends Analysis[Any] {
+                                    domain: Set[CFGPosition],
+                                    mmm: MemoryModelMap,
+                                    reachingDefs: Map[CFGPosition, (Map[Variable, Set[Assign]], Map[Variable, Set[Assign]])],
+                                    vsaResult: Map[CFGPosition, LiftedElement[Map[Variable | MemoryRegion, Set[Value]]]]) extends Analysis[Any] {
 
   val solver: UnionFindSolver[StTerm] = UnionFindSolver()
 
-  private val stackPointer = Register("R31", 64)
-  private val linkRegister = Register("R30", 64)
-  private val framePointer = Register("R29", 64)
-  private val ignoreRegions: Set[Expr] = Set(linkRegister, framePointer)
   private val mallocVariable = Register("R0", 64)
 
-  var mallocCount: Int = 0
-  var stackCount: Int = 0
-  val stackMap: mutable.Map[Expr, StackRegion] = mutable.Map()
-
-  private val memoryRegionContents: mutable.Map[MemoryRegion, mutable.Set[BitVecLiteral | MemoryRegion]] = mutable.Map()
-
-  def getMemoryRegionContents: Map[MemoryRegion, Set[BitVecLiteral | MemoryRegion]] = memoryRegionContents.map((k, v) => k -> v.toSet).toMap
-
-  private def nextMallocCount() = {
-    mallocCount += 1
-    s"malloc_$mallocCount"
-  }
-
-  /**
-   * In expressions that have accesses within a region, we need to relocate
-   * the base address to the actual address using the relocation table.
-   * MUST RELOCATE because MMM iterate to find the lowest address
-   * TODO: May need to iterate over the relocation table to find the actual address
-   *
-   * @param address
-   * @return BitVecLiteral: the relocated address
-   */
-  def relocatedBase(address: BitVecLiteral): BitVecLiteral = {
-    val tableAddress = globalOffsets.getOrElse(address.value, address.value)
-    // this condition checks if the address is not layered and returns if it is not
-    if (tableAddress != address.value && !globalOffsets.contains(tableAddress)) {
-      return address
-    }
-    BitVecLiteral(tableAddress, address.size)
-  }
-
-  /**
-   * Used to reduce an expression that may be a sub-region of a memory region.
-   * Pointer reduction example:
-   * R2 = R31 + 20
-   * Mem[R2 + 8] <- R1
-   *
-   * Steps:
-   * 1) R2 = R31 + 20         <- ie. stack access (assume R31 = stackPointer)
-   *         ↓
-   *    R2 = StackRegion("stack_1", 20)
-   *
-   * 2) Mem[R2 + 8] <- R1     <- ie. memStore
-   *         ↓
-   *    (StackRegion("stack_1", 20) + 8) <- R1
-   *         ↓
-   *    MMM.get(20 + 8) <- R1
-   *
-   * @param binExpr
-   * @param n
-   * @return Set[MemoryRegion]: a set of regions that the expression may be pointing to
-   */
-  def reducibleToRegion(binExpr: BinaryExpr, n: Command): Set[MemoryRegion] = {
-    var reducedRegions = Set.empty[MemoryRegion]
-    binExpr.arg1 match {
-      case variable: Variable =>
-        evaluateExpressionWithSSA(binExpr, constantProp(n), n, reachingDefs).foreach { b =>
-          val region = mmm.findDataObject(b.value)
-          reducedRegions = reducedRegions ++ region
-        }
-        if (reducedRegions.nonEmpty) {
-          return reducedRegions
-        }
-        val ctx = getUse(variable, n, reachingDefs)
-        for (i <- ctx) {
-          if (i != n) { // handles loops (ie. R19 = R19 + 1) %00000662 in jumptable2
-            val regions = i.rhs match {
-              case loadL: MemoryLoad =>
-                val foundRegions = exprToRegion(loadL.index, i)
-                val toReturn = mutable.Set[MemoryRegion]().addAll(foundRegions)
-                for {
-                  f <- foundRegions
-                } {
-                  if (memoryRegionContents.contains(f)) {
-                    memoryRegionContents(f).foreach {
-                      case b: BitVecLiteral =>
-//                        val region = mmm.findDataObject(b.value)
-//                        if (region.isDefined) {
-//                          toReturn.addOne(region.get)
-//                        }
-                      case r: MemoryRegion =>
-                        toReturn.addOne(r)
-                        toReturn.remove(f)
-                    }
-                  }
-                }
-                toReturn.toSet
-              case _: BitVecLiteral =>
-                Set.empty[MemoryRegion]
-              case _ =>
-                Logger.debug(s"Unknown expression: $i")
-                Logger.debug(ctx)
-                exprToRegion(i.rhs, i)
-            }
-            val results = evaluateExpressionWithSSA(binExpr.arg2, constantProp(n), n, reachingDefs)
-            for {
-              b <- results
-              r <- regions
-            } {
-              r match {
-                case stackRegion: StackRegion =>
-                  val nextOffset = BinaryExpr(binExpr.op, stackRegion.start, b)
-                  evaluateExpressionWithSSA(nextOffset, constantProp(n), n, reachingDefs).foreach { b2 =>
-                    reducedRegions ++= exprToRegion(BinaryExpr(binExpr.op, stackPointer, b2), n)
-                  }
-                case dataRegion: DataRegion =>
-                  Logger.debug(s"Hey, I'm a data region: $dataRegion")
-                  Logger.debug(s"Hey, I'm a offset: $b")
-                  val nextOffset = BinaryExpr(binExpr.op, relocatedBase(dataRegion.start), b)
-                  evaluateExpressionWithSSA(nextOffset, constantProp(n), n, reachingDefs).foreach { b2 =>
-                    reducedRegions ++= exprToRegion(b2, n)
-                  }
-                case _ =>
-              }
+  def vsaApproximation(variable: Variable, n: CFGPosition): Set[MemoryRegion] = {
+    val ctx = getUse(variable, n, reachingDefs)
+    ctx.flatMap { i =>
+      if (i != n) {
+        vsaResult.get(i) match {
+          case Some(Lift(el)) => el.get(i.lhs) match {
+            case Some(values) => values.flatMap {
+              case addressValue: AddressValue =>
+                Some(addressValue.region)
+              case _: LiteralValue => None
             }
+            case None => Set()
           }
+          case _ => Set()
         }
-      case _ =>
+      } else {
+        Set()
+      }
     }
-    reducedRegions
   }
 
-  // TODO: You must redefine how shared regions are accessed by finding if the register we are evaluating is shared
+  /** @inheritdoc
+   */
+  def analyze(): Unit = {
+    // generate the constraints by traversing the AST and solve them on-the-fly
+    domain.foreach { p =>
+      visit(p, ())
+    }
+  }
 
-  /**
-   * Finds a region for a given expression using MMM results
-   *
-   * @param expr
-   * @param n
-   * @return Set[MemoryRegion]: a set of regions that the expression may be pointing to
+  /** Generates the constraints for the given sub-AST.
+   * @param node
+   *   the node for which it generates the constraints
+   * @param arg
+   *   unused for this visitor
    */
-  def exprToRegion(expr: Expr, n: Command): Set[MemoryRegion] = {
-    var res = Set[MemoryRegion]()
-    mmm.popContext()
-    mmm.pushContext(IRWalk.procedure(n).name)
-    expr match { // TODO: Stack detection here should be done in a better way or just merged with data
-      case binOp: BinaryExpr if binOp.arg1 == stackPointer =>
-        evaluateExpressionWithSSA(binOp.arg2, constantProp(n), n, reachingDefs).foreach { b =>
-          if binOp.arg2.variables.exists { v => v.sharedVariable } then {
-            Logger.debug("Shared stack object: " + b)
-            Logger.debug("Shared in: " + expr)
-            val regions = mmm.findSharedStackObject(b.value)
-            Logger.debug("found: " + regions)
-            res ++= regions
-          } else {
-            val region = mmm.findStackObject(b.value)
-            if (region.isDefined) {
-              res = res + region.get
-            }
+  def visit(node: CFGPosition, arg: Unit): Unit = {
+    node match {
+      case directCall: DirectCall if directCall.target.name == "malloc" =>
+        // X = alloc P:  [[X]] = ↑[[alloc-i]]
+        val alloc = mmm.nodeToRegion(directCall).head
+        val defs = getDefinition(mallocVariable, directCall, reachingDefs)
+        unify(IdentifierVariable(RegisterWrapperEqualSets(mallocVariable, defs)), PointerRef(AllocVariable(alloc)))
+      case assign: LocalAssign =>
+        // TODO: unsound
+        val unwrapped = unwrapExprToVar(assign.rhs)
+        if (unwrapped.isDefined) {
+          // X1 = X2: [[X1]] = [[X2]]
+          val X1 = assign.lhs
+          val X2 = unwrapped.get
+          unify(IdentifierVariable(RegisterWrapperEqualSets(X1, getDefinition(X1, assign, reachingDefs))), IdentifierVariable(RegisterWrapperEqualSets(X2, getUse(X2, assign, reachingDefs))))
+        } else {
+          // X1 = *X2: [[X2]] = ↑a ^ [[X1]] = a where a is a fresh term variable
+          val X1 = assign.lhs
+          val X2_star = mmm.nodeToRegion(node)
+          val alpha = FreshVariable()
+          X2_star.foreach { x =>
+            unify(PointerRef(alpha), ExpressionVariable(x))
           }
+          unify(IdentifierVariable(RegisterWrapperEqualSets(X1, getDefinition(X1, assign, reachingDefs))), alpha)
         }
-        res
-      case binaryExpr: BinaryExpr =>
-        res ++= reducibleToRegion(binaryExpr, n)
-        res
-      case v: Variable if v == stackPointer =>
-        res ++= mmm.findStackObject(0)
-        res
-      case v: Variable =>
-        evaluateExpressionWithSSA(expr, constantProp(n), n, reachingDefs).foreach { b =>
-          Logger.debug("BitVecLiteral: " + b)
-          val region = mmm.findDataObject(b.value)
-          if (region.isDefined) {
-            res += region.get
+      case memoryStore: MemoryStore =>
+        // *X1 = X2: [[X1]] = ↑a ^ [[X2]] = a where a is a fresh term variable
+        val X1_star = mmm.nodeToRegion(node)
+        // TODO: This is not sound
+        val unwrapped = unwrapExprToVar(memoryStore.value)
+        if (unwrapped.isDefined) {
+          val X2 = unwrapped.get
+          val X2_regions: Set[MemoryRegion] = vsaApproximation(X2, node)
+
+          val alpha = FreshVariable()
+          val pointerRef = PointerRef(alpha)
+          X1_star.foreach { x =>
+            unify(ExpressionVariable(x), pointerRef)
           }
-        }
-        if (res.isEmpty) { // may be passed as param
-          val ctx = getUse(v, n, reachingDefs)
-          for (i <- ctx) {
-            i.rhs match {
-              case load: MemoryLoad => // treat as a region
-                res ++= exprToRegion(load.index, i)
-              case binaryExpr: BinaryExpr =>
-                res ++= reducibleToRegion(binaryExpr, i)
-                res ++= exprToRegion(i.rhs, i)
-              case _ => // also treat as a region (for now) even if just Base + Offset without memLoad
-                res ++= exprToRegion(i.rhs, i)
-            }
+          X2_regions.foreach { x =>
+            unify(ExpressionVariable(x), alpha)
           }
         }
-        res
-      case _ =>
-        evaluateExpressionWithSSA(expr, constantProp(n), n, reachingDefs).foreach { b =>
-          Logger.debug("BitVecLiteral: " + b)
-          val region = mmm.findDataObject(b.value)
-          if (region.isDefined) {
-            res += region.get
+      case memoryLoad: MemoryLoad =>
+        // TODO: unsound
+        val unwrapped = unwrapExprToVar(memoryLoad.index)
+        if (unwrapped.isDefined) {
+          // X1 = X2: [[X1]] = [[X2]]
+          val X1 = memoryLoad.lhs
+          val X2 = unwrapped.get
+          unify(IdentifierVariable(RegisterWrapperEqualSets(X1, getDefinition(X1, memoryLoad, reachingDefs))), IdentifierVariable(RegisterWrapperEqualSets(X2, getUse(X2, memoryLoad, reachingDefs))))
+        } else {
+          // X1 = *X2: [[X2]] = ↑a ^ [[X1]] = a where a is a fresh term variable
+          val X1 = memoryLoad.lhs
+          val X2_star = mmm.nodeToRegion(node)
+          val alpha = FreshVariable()
+          X2_star.foreach { x =>
+            unify(PointerRef(alpha), ExpressionVariable(x))
           }
+          unify(IdentifierVariable(RegisterWrapperEqualSets(X1, getDefinition(X1, memoryLoad, reachingDefs))), alpha)
         }
-        res
-    }
-  }
-
-  /** @inheritdoc
-    */
-  def analyze(): Unit =
-    // generate the constraints by traversing the AST and solve them on-the-fly
-    program.procedures.foreach(p => {
-      p.blocks.foreach(b => b.statements.foreach(visit(_, ())))
-    })
-
-  /** Generates the constraints for the given sub-AST.
-    * @param node
-    *   the node for which it generates the constraints
-    * @param arg
-    *   unused for this visitor
-    */
-  def visit(cmd: Command, arg: Unit): Unit = {
-
-    cmd match {
-        case directCall: DirectCall =>
-          // X = alloc P:  [[X]] = ↑[[alloc-i]]
-          if (directCall.target.name == "malloc") {
-            val alloc = HeapRegion(nextMallocCount(), BitVecLiteral(BigInt(0), 0), IRWalk.procedure(cmd))
-            unify(IdentifierVariable(RegisterVariableWrapper(mallocVariable, getUse(mallocVariable, cmd, reachingDefs))), PointerRef(AllocVariable(alloc)))
-          }
-
-        case assign: Assign =>
-          assign.rhs match {
-            case binOp: BinaryExpr =>
-              // X1 = &X2: [[X1]] = ↑[[X2]]
-              exprToRegion(binOp, cmd).foreach(
-                x => unify(IdentifierVariable(RegisterVariableWrapper(assign.lhs, getDefinition(assign.lhs, cmd, reachingDefs))), PointerRef(AllocVariable(x)))
-              )
-            // TODO: should lookout for global base + offset case as well
-            case _ =>
-              unwrapExpr(assign.rhs).foreach {
-                case memoryLoad: MemoryLoad =>
-                  // X1 = *X2: [[X2]] = ↑a ^ [[X1]] = a where a is a fresh term variable
-                  val X1 = assign.lhs
-                  val X2_star = exprToRegion(memoryLoad.index, cmd)
-                  val alpha = FreshVariable()
-                  X2_star.foreach(
-                    x => unify(ExpressionVariable(x), PointerRef(alpha))
-                  )
-                  unify(alpha, IdentifierVariable(RegisterVariableWrapper(X1, getDefinition(X1, cmd, reachingDefs))))
-
-                  Logger.debug("Memory load: " + memoryLoad)
-                  Logger.debug("Index: " + memoryLoad.index)
-                  Logger.debug("X2_star: " + X2_star)
-                  Logger.debug("X1: " + X1)
-                  Logger.debug("Assign: " + assign)
-
-                  // TODO: This might not be correct for globals
-                  // X1 = &X: [[X1]] = ↑[[X2]] (but for globals)
-                  val $X2 = exprToRegion(memoryLoad.index, cmd)
-                  $X2.foreach(
-                    x => unify(IdentifierVariable(RegisterVariableWrapper(assign.lhs, getDefinition(assign.lhs, cmd, reachingDefs))), PointerRef(AllocVariable(x)))
-                  )
-                case variable: Variable =>
-                  // X1 = X2: [[X1]] = [[X2]]
-                  val X1 = assign.lhs
-                  val X2 = variable
-                  unify(IdentifierVariable(RegisterVariableWrapper(X1, getDefinition(X1, cmd, reachingDefs))), IdentifierVariable(RegisterVariableWrapper(X2, getUse(X2, cmd, reachingDefs))))
-                case _ => // do nothing
-              }
-          }
-        case memoryAssign: MemoryAssign =>
-          // *X1 = X2: [[X1]] = ↑a ^ [[X2]] = a where a is a fresh term variable
-          val X1_star = exprToRegion(memoryAssign.index, cmd)
-          val X2 = evaluateExpressionWithSSA(memoryAssign.value, constantProp(cmd), cmd, reachingDefs)
-          // TODO: This is risky as it tries to coerce every value to a region (needed for functionpointer example)
-          val possibleRegions = exprToRegion(memoryAssign.value, cmd)
 
-          Logger.debug("I am at stmt: " + cmd.label)
-          Logger.debug("Memory assign: " + memoryAssign)
-          Logger.debug("X2 is: " + X2)
-          Logger.debug("PossibleRegions instead of X2 " + possibleRegions)
-          Logger.debug("Evaluated: " + memoryAssign.value)
-          Logger.debug("Region " + X1_star)
-          Logger.debug("Index " + memoryAssign.index)
-          val alpha = FreshVariable()
-          X1_star.foreach(x =>
-            unify(ExpressionVariable(x), PointerRef(alpha))
-            if (!memoryRegionContents.contains(x)) {
-              memoryRegionContents.addOne(x -> mutable.Set())
-            }
-            memoryRegionContents(x).addAll(X2)
-            memoryRegionContents(x).addAll(possibleRegions.filter(r => r != x))
-          )
-          X2.foreach(x => unify(alpha, ExpressionVariable(x)))
-          possibleRegions.foreach(x => unify(alpha, ExpressionVariable(x)))
-        case _ => // do nothing TODO: Maybe LocalVar too?
-      }
+      case _ => // do nothing TODO: Maybe LocalVar too?
     }
+  }
 
   private def unify(t1: Term[StTerm], t2: Term[StTerm]): Unit = {
     //Logger.info(s"univfying constraint $t1 = $t2\n")
@@ -345,35 +146,25 @@ class InterprocSteensgaardAnalysis(
   }
 
   /** @inheritdoc
-    */
-  def pointsTo(): Map[RegisterVariableWrapper, Set[RegisterVariableWrapper | MemoryRegion]] = {
+   */
+  def pointsTo(): Map[RegisterWrapperEqualSets, Set[RegisterWrapperEqualSets | MemoryRegion]] = {
     val solution = solver.solution()
     val unifications = solver.unifications()
     Logger.debug(s"Solution: \n${solution.mkString(",\n")}\n")
     Logger.debug(s"Sets: \n${unifications.values.map { s => s"{ ${s.mkString(",")} }"}.mkString(", ")}")
 
     val vars = solution.keys.collect { case id: IdentifierVariable => id }
-    val emptyMap = Map[RegisterVariableWrapper, Set[RegisterVariableWrapper | MemoryRegion]]()
+    val emptyMap = Map[RegisterWrapperEqualSets, Set[RegisterWrapperEqualSets | MemoryRegion]]()
     val pointsto = vars.foldLeft(emptyMap) { (a, v: IdentifierVariable) =>
-      val pt: Set[RegisterVariableWrapper | MemoryRegion] = unifications(solution(v)).collect {
+      val pt: Set[RegisterWrapperEqualSets | MemoryRegion] = unifications(solution(v)).collect {
         case PointerRef(IdentifierVariable(id)) => id
         case PointerRef(AllocVariable(alloc))   => alloc
       }.toSet
       a + (v.id -> pt)
     }
-    Logger.debug(s"\nPoints-to:\n${pointsto.map(p => s"${p._1} -> { ${p._2.mkString(",")} }").mkString("\n")}\n")
+    Logger.debug(s"\nPoints-to:\n${pointsto.map((k, v) => s"$k -> { ${v.mkString(",")} }").mkString("\n")}\n")
     pointsto
   }
-
-  /** @inheritdoc
-    */
-  def mayAlias(): (RegisterVariableWrapper, RegisterVariableWrapper) => Boolean = {
-    val solution = solver.solution()
-    (id1: RegisterVariableWrapper, id2: RegisterVariableWrapper) =>
-      val sol1 = solution(IdentifierVariable(id1))
-      val sol2 = solution(IdentifierVariable(id2))
-      sol1 == sol2 && sol1.isInstanceOf[PointerRef] // same equivalence class, and it contains a reference
-  }
 }
 
 /** Terms used in unification.
@@ -388,14 +179,14 @@ case class AllocVariable(alloc: MemoryRegion) extends StTerm with Var[StTerm] {
 }
 
 /** A term variable that represents an identifier in the program.
-  */
-case class IdentifierVariable(id: RegisterVariableWrapper) extends StTerm with Var[StTerm] {
+ */
+case class IdentifierVariable(id: RegisterWrapperEqualSets) extends StTerm with Var[StTerm] {
 
   override def toString: String = s"$id"
 }
 
 /** A term variable that represents an expression in the program.
-  */
+ */
 case class ExpressionVariable(expr: MemoryRegion | Expr) extends StTerm with Var[StTerm] {
 
   override def toString: String = s"$expr"
@@ -403,13 +194,22 @@ case class ExpressionVariable(expr: MemoryRegion | Expr) extends StTerm with Var
 
 /** A fresh term variable.
   */
-case class FreshVariable(var id: Int = 0) extends StTerm with Var[StTerm] {
+case class FreshVariable(id: Int) extends StTerm with Var[StTerm] {
+  override def toString: String = s"x$id"
+}
 
-  id = Fresh.next()
+object FreshVariable {
+  private var n = 0
 
-  override def toString: String = s"x$id"
+  def next(): Int = {
+    n += 1
+    n
+  }
+
+  def apply(): FreshVariable = FreshVariable(next())
 }
 
+
 /** A constructor term that represents a pointer to another term.
   */
 case class PointerRef(of: Term[StTerm]) extends StTerm with Cons[StTerm] {
@@ -419,16 +219,4 @@ case class PointerRef(of: Term[StTerm]) extends StTerm with Cons[StTerm] {
   def subst(v: Var[StTerm], t: Term[StTerm]): Term[StTerm] = PointerRef(of.subst(v, t))
 
   override def toString: String = s"$of"
-}
-
-/** Counter for producing fresh IDs.
-  */
-object Fresh {
-
-  var n = 0
-
-  def next(): Int = {
-    n += 1
-    n
-  }
-}
+}
\ No newline at end of file
diff --git a/src/main/scala/analysis/IntraLiveVarsAnalysis.scala b/src/main/scala/analysis/IntraLiveVarsAnalysis.scala
index a576b27fb..1271aa720 100644
--- a/src/main/scala/analysis/IntraLiveVarsAnalysis.scala
+++ b/src/main/scala/analysis/IntraLiveVarsAnalysis.scala
@@ -1,28 +1,31 @@
 package analysis
 
 import analysis.solvers.SimpleWorklistFixpointSolver
-import ir.{Assert, Assume, Block, CFGPosition, Call, DirectCall, GoTo, IndirectCall, Jump, Assign, MemoryAssign, NOP, Procedure, Program, Statement, Variable, Return, Unreachable}
+import ir.{Assert, Assume, Block, CFGPosition, Call, DirectCall, GoTo, IndirectCall, Jump, LocalAssign, MemoryLoad, MemoryStore, Procedure, Program, Statement, Variable, Return, Unreachable}
 
-abstract class LivenessAnalysis(program: Program) extends Analysis[Any]:
+abstract class LivenessAnalysis(program: Program) extends Analysis[Any] {
   val lattice: MapLattice[CFGPosition, Set[Variable], PowersetLattice[Variable]] = MapLattice(PowersetLattice())
   val domain: Set[CFGPosition] = Set.empty ++ program
 
   def transfer(n: CFGPosition, s: Set[Variable]): Set[Variable] = {
     n match {
-      case p: Procedure => s
-      case b: Block => s
-      case Assign(variable, expr, _) => (s - variable) ++ expr.variables
-      case MemoryAssign(_, index, value, _, _, _) => s ++ index.variables ++ value.variables
+      case _: Procedure => s
+      case _: Block => s
+      case LocalAssign(variable, expr, _) => (s - variable) ++ expr.variables
+      case MemoryStore(_, index, value, _, _, _) => s ++ index.variables ++ value.variables
+      case MemoryLoad(lhs, _, index, _, _, _) => (s - lhs) ++ index.variables
       case Assume(expr, _, _, _) => s ++ expr.variables
       case Assert(expr, _, _) => s ++ expr.variables
       case IndirectCall(variable, _) => s + variable
-      case c: DirectCall => s
-      case g: GoTo => s
-      case r: Return => s
-      case r: Unreachable => s
+      case _: DirectCall => s
+      case _: GoTo => s
+      case _: Return => s
+      case _: Unreachable => s
       case _ => ???
     }
   }
+}
+
 
 class IntraLiveVarsAnalysis(program: Program)
   extends LivenessAnalysis(program)
diff --git a/src/main/scala/analysis/IrreducibleLoops.scala b/src/main/scala/analysis/IrreducibleLoops.scala
index 2d32cf28c..84011c0af 100644
--- a/src/main/scala/analysis/IrreducibleLoops.scala
+++ b/src/main/scala/analysis/IrreducibleLoops.scala
@@ -65,9 +65,9 @@ object LoopDetector {
     edgeStack: List[LoopEdge] = List(),
 
   ) {
-    def irreducibleLoops = loops.values.filter(l => !l.reducible).toSet
+    def irreducibleLoops: Set[Loop] = loops.values.filter(l => !l.reducible).toSet
 
-    def identifiedLoops = loops.values
+    def identifiedLoops: Iterable[Loop] = loops.values
 
     def reducibleTransformIR() : State = {
       this.copy(loops = LoopTransform.llvm_transform(loops.values).map(l => l.header -> l).toMap)
@@ -75,15 +75,15 @@ object LoopDetector {
   }
 
   def identify_loops(entryBlock: Block): State = {
-    traverse_loops_dfs(State(), entryBlock, 1)._1
+    traverse_loops_dfs(State(), entryBlock, 1)(0)
   }
 
   /*
    * Returns the set of loops for each procedure in the program.
    */
   def identify_loops(cfg: Program): State = {
-    cfg.procedures.toSet.map(_.entryBlock).flatten
-      .foldLeft(State())((st, eb) => (traverse_loops_dfs(st, eb, 1)._1))
+    cfg.procedures.toSet.flatMap(_.entryBlock)
+      .foldLeft(State())((st, eb) => traverse_loops_dfs(st, eb, 1)(0))
   }
 
 
@@ -95,7 +95,7 @@ object LoopDetector {
       // b is in DFSP(edge.from)
       st = st.copy(headers = st.headers + edge.to)
 
-      val newLoop = st.loops.get(edge.to).getOrElse(Loop(edge.to))
+      val newLoop = st.loops.getOrElse(edge.to, Loop(edge.to))
       st.edgeStack.reverse.slice(st.nodeDFSPpos(edge.to) - 1, st.nodeDFSPpos(edge.from)).foreach { pEdge => newLoop.addEdge(pEdge) }
       newLoop.backEdges += edge
 
@@ -222,33 +222,33 @@ object LoopDetector {
      *
      *
      */
-    enum Action:
-      case BeginProcessNode 
+    enum Action {
+      case BeginProcessNode
       case ContinueDFS
       case ProcessVisitedNode
-      case FinishProcessNode 
+      case FinishProcessNode
+    }
 
     case class LocalState(istate: State, b0: Block, pos: Int, action: Action, processingEdges: List[LoopEdge])
     val stack = mutable.Stack[LocalState]()
     stack.push(LocalState(_istate, _b0, _DFSPpos, Action.BeginProcessNode, List()))
 
-    var retval : (State, Option[Block]) = (_istate, None)
+    var retval: (State, Option[Block]) = (_istate, None)
 
-    while (!stack.isEmpty) {
+    while (stack.nonEmpty) {
       var sf = stack.pop()
       var st = sf.istate
 
       sf.action match {
-        case Action.BeginProcessNode => {
+        case Action.BeginProcessNode =>
           st = st.copy(visitedNodes = st.visitedNodes + sf.b0)
           st = st.copy(nodeDFSPpos = st.nodeDFSPpos.updated(sf.b0, sf.pos))
           val edgesToProcess = sf.b0.nextBlocks.map(toNode => LoopEdge(sf.b0, toNode)).toList
           sf = sf.copy(istate = st, processingEdges = edgesToProcess, action = Action.ContinueDFS)
           stack.push(sf)
-        }
-        case Action.ContinueDFS => {
+        case Action.ContinueDFS =>
           sf.processingEdges match {
-            case edge::tl => {
+            case edge::tl =>
               sf = sf.copy(processingEdges = tl)
 
               if (!st.visitedNodes.contains(edge.to)) {
@@ -262,25 +262,20 @@ object LoopDetector {
                 // continue iterating `processingEdges`
                 stack.push(sf.copy(istate = st, action = Action.ContinueDFS))
               }
-            }
-            case Nil => {
+            case Nil =>
               // loop over
               sf = sf.copy(action = Action.FinishProcessNode)
               stack.push(sf)
-            }
           }
-        }
-        case Action.ProcessVisitedNode => {
+        case Action.ProcessVisitedNode =>
           val (nst, newhead) = retval
           st = nst
           st = newhead.foldLeft(st)((st, b) => tag_lhead(st, sf.b0, b))
           sf = sf.copy(action=Action.ContinueDFS, istate = st) // continue iteration
           stack.push(sf)
-        }
-        case Action.FinishProcessNode => {
+        case Action.FinishProcessNode =>
           st = st.copy(nodeDFSPpos = st.nodeDFSPpos.updated(sf.b0, 0))
           retval = (st, st.iloopHeaders.get(sf.b0))
-        }
       }
     }
 
@@ -329,13 +324,13 @@ object LoopTransform {
    * Returns: Set of loops which were previously irreducible, but are no longer
    */
   def llvm_transform(loops: Iterable[Loop]): Iterable[Loop] = {
-    loops.map(l => {
+    loops.map { l => {
       if (!l.reducible) {
         llvm_transform_loop(l)
       } else {
         l
       }
-    }) 
+    }
   }
 
   /* Performs the LLVM transform for an individual loop. The algorithm is as follows:
@@ -362,23 +357,22 @@ object LoopTransform {
     // WARNING: We are not careful to avoid repeatedly adding these statements to the IR, so
     // re-running this transform following a transform producing irreducible control flow over the
     // same entry blocks will produce invalid/unreachable code
-    val entrys = P_e.map(_.from).toSet
+    val entrys = P_e.map(_.from)
     val entryids = entrys.zip(0 until entrys.size).toMap
 
     for ((block, id) <- entryids) {
-      block.statements.prepend(Assign(LocalVar("FromEntryIdx", IntType), IntLiteral(BigInt(id))))
+      block.statements.prepend(LocalAssign(LocalVar("FromEntryIdx", IntType), IntLiteral(BigInt(id))))
     }
 
-    P_e.groupBy(_.to).map((destBlock,origins) => {
+    P_e.groupBy(_.to).map { (destBlock,origins) =>
       val idexs = origins.map(b => BinaryExpr(IntEQ,LocalVar("FromEntryIdx", IntType), IntLiteral(BigInt(entryids(b.from)))))
       idexs.toList match {
         case Nil => ()
-        case h::tl => {
+        case h::tl =>
           val cond = tl.foldLeft(h)((l, r) => BinaryExpr(BoolOR, l, r))
           destBlock.statements.prepend(Assume(cond))
-        }
       }
-    })
+    }
 
     // 3. Create block `N` and redirect every edge from set `P` to `H` via `N`
     val conns = P_e.map(e => e.to).union(P_b.map(e => e.to)).collect { case blk: Block => blk }
@@ -390,21 +384,19 @@ object LoopTransform {
     val newLoop = Loop(N)
     newLoop.edges ++= body
 
-    P_e.foreach { originalEdge => {
-        originalEdge.from.replaceJump(GoTo(List(N)))
-        newLoop.addEdge(LoopEdge(originalEdge.from, N))
-        newLoop.addEdge(LoopEdge(N, originalEdge.to))
-      }
+    P_e.foreach { originalEdge =>
+      originalEdge.from.replaceJump(GoTo(List(N)))
+      newLoop.addEdge(LoopEdge(originalEdge.from, N))
+      newLoop.addEdge(LoopEdge(N, originalEdge.to))
     }
 
-    P_b.foreach { originalEdge => {
-        originalEdge.from.replaceJump(GoTo(List(N)))
-        val toEdge = LoopEdge(originalEdge.from, N)
+    P_b.foreach { originalEdge =>
+      originalEdge.from.replaceJump(GoTo(List(N)))
+      val toEdge = LoopEdge(originalEdge.from, N)
 
-        newLoop.addEdge(toEdge)
-        newLoop.addEdge(LoopEdge(N, originalEdge.to))
-        newLoop.backEdges += toEdge
-      }
+      newLoop.addEdge(toEdge)
+      newLoop.addEdge(LoopEdge(N, originalEdge.to))
+      newLoop.backEdges += toEdge
     }
 
     newLoop
diff --git a/src/main/scala/analysis/MemoryModelMap.scala b/src/main/scala/analysis/MemoryModelMap.scala
index d91340d5b..0df82014c 100644
--- a/src/main/scala/analysis/MemoryModelMap.scala
+++ b/src/main/scala/analysis/MemoryModelMap.scala
@@ -4,40 +4,68 @@ import analysis.*
 import ir.*
 import util.Logger
 
+import scala.collection.immutable.TreeMap
 import scala.collection.mutable
 
 // Define a case class to represent a range
 case class RangeKey(start: BigInt, end: BigInt) extends Ordered[RangeKey]:
-  val size: BigInt = end - start
+  val size: BigInt = end - start + 1
   override def compare(that: RangeKey): Int = {
     if (start < that.start) -1
     else if (start > that.start) 1
     else 0
   }
-  override def toString: String = s"Range[$start, $end]"
-
+  override def toString: String = s"Range[$start, $end] (size: $size)"
 
 // Custom data structure for storing range-to-object mappings
-class MemoryModelMap {
-  private val MAX_BIGINT: BigInt = BigInt(Long.MaxValue)
-  private val contextStack = mutable.Stack.empty[List[StackRegion]]
+class MemoryModelMap(val globalOffsets: Map[BigInt, BigInt]) {
+  private val contextStack = mutable.Stack.empty[String]
   private val sharedContextStack = mutable.Stack.empty[List[StackRegion]]
-  private val localStacks = mutable.Map[String, List[StackRegion]]()
+  private val localStacks = mutable.Map[String, List[StackRegion]]().withDefaultValue(List.empty)
   private val sharedStacks = mutable.Map[String, List[StackRegion]]()
 
   private val stackMap: mutable.Map[RangeKey, StackRegion] = mutable.TreeMap()
+  private val bufferedStackMap: mutable.Map[String, mutable.Map[RangeKey, StackRegion]] = mutable.Map()
   private val sharedStackMap: mutable.Map[Procedure, mutable.TreeMap[RangeKey, StackRegion]] = mutable.Map[Procedure, mutable.TreeMap[RangeKey, StackRegion]]()
+  private val bufferedSharedStackMap: mutable.Map[String, mutable.Map[Procedure, mutable.TreeMap[RangeKey, StackRegion]]] = mutable.Map()
   private val heapMap: mutable.Map[RangeKey, HeapRegion] = mutable.TreeMap()
   private val dataMap: mutable.Map[RangeKey, DataRegion] = mutable.TreeMap()
+  private val cfgPositionToDataRegion: mutable.Map[CFGPosition, Set[DataRegion]] = mutable.Map()
+  private val heapCalls: mutable.Map[DirectCall, HeapRegion] = mutable.Map()
+  private var relocatedAddressesMap: Map[BigInt, DataRegion] = Map()
+
+  private val stackAllocationSites: mutable.Map[CFGPosition, Set[StackRegion]] = mutable.Map()
+
+  private val uf = UnionFind()
+  val relfContent: mutable.Map[DataRegion, mutable.Set[String]] = mutable.Map()
+  val stackSubAccesses: mutable.Map[StackRegion, mutable.Set[BigInt]] = mutable.Map()
 
   /** Add a range and object to the mapping
    *
-   * @param offset the offset of the range
+   * @param offset the offset of the range, if a heap region is given, the offsets controls the shift of regions from the start
    * @param region the region to add
    * @param shared if the region is shared. When true, the region is added to the sharedStackMap
    *                otherwise to the stackMap
    */
   def add(offset: BigInt, region: MemoryRegion, shared: Boolean = false): Unit = {
+    def maxSize(r: MemoryRegion): BigInt = {
+      r match {
+        case DataRegion(_, start, size) => start + size
+        case _: HeapRegion => ???
+        case s: StackRegion =>
+          if (stackSubAccesses.contains(s) && stackSubAccesses(s).nonEmpty) {
+            s.start + stackSubAccesses(s).max
+          } else {
+            ???
+          }
+        case _ => ???
+      }
+    }
+
+    def regionsOverlap(r1: RangeKey, r2: RangeKey): Boolean = {
+      r1.start <= r2.end && r2.start <= r1.end
+    }
+
     region match {
       case s: StackRegion =>
         var currentStackMap = stackMap
@@ -45,132 +73,142 @@ class MemoryModelMap {
           currentStackMap = sharedStackMap.getOrElseUpdate(s.parent, mutable.TreeMap())
         }
         if (currentStackMap.isEmpty) {
-          currentStackMap(RangeKey(offset, MAX_BIGINT)) = s
+          currentStackMap(RangeKey(offset, maxSize(region) - 1)) = s
         } else {
           val currentMaxRange = currentStackMap.keys.maxBy(_.end)
           val currentMaxRegion = currentStackMap(currentMaxRange)
-          currentStackMap.remove(currentMaxRange)
-          val updatedRange = RangeKey(currentMaxRange.start, offset - 1)
-          currentStackMap.addOne(updatedRange -> currentMaxRegion)
-          currentStackMap(RangeKey(offset, MAX_BIGINT)) = s
+          if (offset <= currentMaxRange.end) {
+            currentStackMap.remove(currentMaxRange)
+            val updatedRange = RangeKey(currentMaxRange.start, (maxSize(region) - 1).max(currentMaxRange.end))
+            currentStackMap.addOne(updatedRange -> currentMaxRegion)
+          } else {
+            currentStackMap(RangeKey(offset, maxSize(region) - 1)) = s
+          }
         }
       case d: DataRegion =>
         val currentDataMap = dataMap
         if (currentDataMap.isEmpty) {
-          currentDataMap(RangeKey(offset, MAX_BIGINT)) = d
+          currentDataMap(RangeKey(offset, maxSize(d) - 1)) = d
         } else {
           val currentMaxRange = currentDataMap.keys.maxBy(_.end)
-          val currentMaxRegion = currentDataMap(currentMaxRange)
-          currentDataMap.remove(currentMaxRange)
-          val updatedRange = RangeKey(currentMaxRange.start, offset - 1)
-          currentDataMap.addOne(updatedRange -> currentMaxRegion)
-          currentDataMap(RangeKey(offset, MAX_BIGINT)) = d
+          if (regionsOverlap(currentMaxRange, RangeKey(offset, maxSize(d) - 1))) {
+            currentDataMap.remove(currentMaxRange) // TODO: this removes previously overlapping parent region (jumptable2 example) which favours more fine grained regions
+            currentDataMap(RangeKey(offset, maxSize(d) - 1)) = d
+          } else {
+            currentDataMap(RangeKey(offset, maxSize(d) - 1)) = d
+          }
+        }
+      case h: HeapRegion =>
+        val currentHeapMap = heapMap
+        if (currentHeapMap.isEmpty) {
+          currentHeapMap(RangeKey(offset, offset + h.size - 1)) = h
+        } else {
+          val currentMaxRange = currentHeapMap.keys.maxBy(_.end)
+          currentHeapMap(RangeKey(currentMaxRange.start + 1, h.size - 1)) = h
         }
     }
   }
 
-  /**
-   * For DataRegions, the actual address used needs to be converted to the relocated address.
-   * This is because when regions are found, the relocated address is used and as such match
-   * the correct range.
-   *
-   * @param name
-   * @param address
-   * @param globalOffsets
-   * @return DataRegion: a DataRegion representing the actual address
-   */
-  private def resolveInverseGlobalOffset(name: String, address: BitVecLiteral, globalOffsets: Map[BigInt, BigInt]): DataRegion = {
-    val inverseGlobalOffsets = globalOffsets.map(_.swap)
-    var tableAddress = inverseGlobalOffsets.getOrElse(address.value, address.value)
-    // addresses may be layered as in jumptable2 example for which recursive search is required
-    var exitLoop = false
-    while (inverseGlobalOffsets.contains(tableAddress) && !exitLoop) {
-      val newAddress = inverseGlobalOffsets.getOrElse(tableAddress, tableAddress)
-      if (newAddress == tableAddress) {
-        exitLoop = true
-      } else {
-        tableAddress = newAddress
-      }
+  private var relocCount: Int = 0
+  private def nextRelocCount() = {
+    relocCount += 1
+    s"reloc_$relocCount"
+  }
+
+  // size of pointer is 8 bytes
+  private val SIZE_OF_POINTER = 8
+
+  def preLoadGlobals(externalFunctions: Map[BigInt, String], globalAddresses: Map[BigInt, String], globalSizes: Map[String, Int]): Unit = {
+    val relocRegions = globalOffsets.keys.map(offset => DataRegion(nextRelocCount(), offset, SIZE_OF_POINTER))
+
+    // map externalFunctions name, value to DataRegion(name, value) and then sort by value
+    val filteredGlobalOffsets = globalAddresses.filterNot((offset, _) => externalFunctions.contains(offset))
+
+    val externalFunctionRgns = (externalFunctions ++ filteredGlobalOffsets).map((offset, name) => DataRegion(name, offset, (globalSizes.getOrElse(name, 1).toDouble / 8).ceil.toInt))
+
+    // add externalFunctionRgn to dataRgns and sort by value
+    val allDataRgns = (externalFunctionRgns ++ relocRegions).toList.sortBy(_.start)
+    for (dataRgn <- allDataRgns) {
+      add(dataRgn.start, dataRgn)
     }
 
-    DataRegion(name, BitVecLiteral(tableAddress, 64))
+    // cannot fail to find any regions here
+    relocatedAddressesMap = globalOffsets.map { (offset, offset2) =>
+      (offset, findDataObject(offset2).get)
+    }
   }
 
-  /**
-   * Get the mapping of procedures to memory regions
-   * Gets the regions from each CFGPosition and maps them to the corresponding procedure based on the
-   * parent field of the StackRegion
-   * No shared regions here
-   * @param memoryRegions
-   * @return
-   */
-  def getProceduresToRegionsMapping(memoryRegions: Map[CFGPosition, LiftedElement[Set[MemoryRegion]]]): mutable.Map[Procedure, mutable.Set[MemoryRegion]] = {
-    val procedureToRegions = mutable.Map[Procedure, mutable.Set[MemoryRegion]]()
-    for ((position, regions) <- memoryRegions) {
-      regions match {
-        case Lift(node) =>
-          for (region <- node) {
-            region match {
-              case stackRegion: StackRegion =>
-                val procedure = stackRegion.parent
-                if (!procedureToRegions.contains(procedure)) {
-                  procedureToRegions(procedure) = mutable.Set()
-                }
-                procedureToRegions(procedure) += stackRegion
-              case heapRegion: HeapRegion =>
-                val procedure = heapRegion.parent
-                if (!procedureToRegions.contains(procedure)) {
-                  procedureToRegions(procedure) = mutable.Set()
-                }
-                procedureToRegions(procedure) += heapRegion
-              case _ =>
-            }
-          }
-        case LiftedBottom =>
-      }
+  def relocatedDataRegion(value: BigInt): Option[DataRegion] = {
+    relocatedAddressesMap.get(value)
+  }
+
+  def convertMemoryRegions(stackRegionsPerProcedure: mutable.Map[Procedure, mutable.Set[StackRegion]],
+                           heapRegions: mutable.Map[DirectCall, HeapRegion],
+                           allocationSites: Map[CFGPosition, Set[StackRegion]],
+                           procedureToSharedRegions: mutable.Map[Procedure, mutable.Set[MemoryRegion]],
+                           graRegions: mutable.HashMap[BigInt, DataRegion],
+                           graResults: Map[CFGPosition, Set[DataRegion]]): Unit = {
+    //val keepData = dataMap.filterNot((range, region) => graRegions.contains(region.start)).map((range, region) => region)
+    val oldRegions = dataMap.values.toSet
+    dataMap.clear()
+    for (dr <- graRegions.values) {
+      add(dr.start, dr)
     }
-    // make sure all procedures have results otherwise make them empty
-    memoryRegions.keys.collect {case procedure: Procedure => procedure}.foreach(procedure => {
-      if (!procedureToRegions.contains(procedure)) {
-        procedureToRegions(procedure) = mutable.Set()
+    for (dr <- oldRegions) {
+      val obj = findDataObject(dr.start)
+      if (obj.isEmpty) {
+        Logger.debug(s"Data region $dr not found in the new data map")
+      } else {
+        val isRelocated = relocatedDataRegion(dr.start)
+        if (isRelocated.isDefined) {
+          relfContent(obj.get) = relfContent.getOrElse(obj.get, mutable.Set()) += isRelocated.get.regionIdentifier
+        } else {
+          relfContent(obj.get) = relfContent.getOrElse(obj.get, mutable.Set()) += dr.regionIdentifier
+        }
       }
-    })
-    procedureToRegions
-  }
+    }
 
-  def convertMemoryRegions(memoryRegions: Map[CFGPosition, LiftedElement[Set[MemoryRegion]]], externalFunctions: Map[BigInt, String], globalOffsets: Map[BigInt, BigInt], procedureToSharedRegions: mutable.Map[Procedure, mutable.Set[MemoryRegion]]): Unit = {
-    // map externalFunctions name, value to DataRegion(name, value) and then sort by value
-    val externalFunctionRgns = externalFunctions.map((offset, name) => resolveInverseGlobalOffset(name, BitVecLiteral(offset, 64), globalOffsets))
-
-    // we should collect all data regions otherwise the ordering might be wrong
-    var dataRgns: Set[DataRegion] = Set.empty
-    // get all function exit node
-    val regionsPerProcedure = getProceduresToRegionsMapping(memoryRegions)
-    val exitNodes = regionsPerProcedure.keys.collect { case procedure: Procedure => procedure }
-
-    exitNodes.foreach(exitNode =>
-      if (procedureToSharedRegions.contains(exitNode)) {
-        val sharedRegions = procedureToSharedRegions(exitNode)
-        sharedStacks(exitNode.name) = sharedRegions.collect { case r: StackRegion => r }.toList.sortBy(_.start.value)
+    cfgPositionToDataRegion ++= graResults
+    stackAllocationSites ++= allocationSites
+    stackRegionsPerProcedure.keys.foreach { proc =>
+      if (procedureToSharedRegions.contains(proc)) {
+        val sharedRegions = procedureToSharedRegions(proc)
+        sharedStacks(proc.name) = sharedRegions.collect { case r: StackRegion => r }.toList.sortBy(_.start)
       }
       // for each function exit node we get the memory region and add it to the mapping
-      val stackRgns = regionsPerProcedure(exitNode).collect { case r: StackRegion => r }.toList.sortBy(_.start.value)
-      dataRgns = dataRgns ++ regionsPerProcedure(exitNode).collect { case r: DataRegion => r }
+      val stackRgns = stackRegionsPerProcedure(proc).toList.sortBy(_.start)
+      localStacks(proc.name) = stackRgns
+    }
 
-      localStacks(exitNode.name) = stackRgns
-    )
-    // add externalFunctionRgn to dataRgns and sort by value
-    val allDataRgns = (dataRgns ++ externalFunctionRgns).toList.sortBy(_.start.value)
-    for (dataRgn <- allDataRgns) {
-      add(dataRgn.start.value, dataRgn)
+    heapCalls ++= heapRegions
+    // add heap regions
+    val rangeStart = 0
+    for (heapRegion <- heapRegions.values) {
+      add(rangeStart, heapRegion)
+    }
+
+    /* this is done because the stack regions will change after MMM transforms them
+    and merges some of them based on size, thus we need to alter the results of
+    the analysis to match MMM transformations
+    TODO: Can this be done directly in MRA?
+     */
+    for ((n, stacks) <- stackAllocationSites) {
+      pushContext(IRWalk.procedure(n).name)
+      stackAllocationSites(n) = stacks.map(r => findStackObject(r.start).getOrElse(r))
+      pushContext(IRWalk.procedure(n).name)
     }
   }
-  // TODO: push and pop could be optimised by caching the results
+
   def pushContext(funName: String): Unit = {
-    contextStack.push(localStacks(funName))
+    contextStack.push(funName)
     stackMap.clear()
-    for (stackRgn <- contextStack.top) {
-      add(stackRgn.start.value, stackRgn)
+    if (bufferedStackMap.contains(funName)) {
+      stackMap ++= bufferedStackMap(funName)
+    } else {
+      for (stackRgn <- localStacks(contextStack.top).sortBy(_.start)) {
+        add(stackRgn.start, stackRgn)
+      }
+      bufferedStackMap(funName) = stackMap.clone()
     }
 
     if (!sharedStacks.contains(funName)) {
@@ -178,8 +216,13 @@ class MemoryModelMap {
     }
     sharedContextStack.push(sharedStacks(funName))
     sharedStackMap.clear()
-    for (stackRgn <- sharedContextStack.top) {
-      add(stackRgn.start.value, stackRgn, true)
+    if (bufferedSharedStackMap.contains(funName)) {
+      sharedStackMap ++= bufferedSharedStackMap(funName)
+    } else {
+      for (stackRgn <- sharedContextStack.top.sortBy(_.start)) {
+        add(stackRgn.start, stackRgn, true)
+      }
+      bufferedSharedStackMap(funName) = sharedStackMap.clone()
     }
   }
 
@@ -187,29 +230,48 @@ class MemoryModelMap {
     if (contextStack.size > 1) {
       contextStack.pop()
       stackMap.clear()
-      for (stackRgn <- contextStack.top) {
-        add(stackRgn.start.value, stackRgn)
+      if (bufferedStackMap.contains(contextStack.top)) {
+        stackMap ++= bufferedStackMap(contextStack.top)
+      } else {
+        for (stackRgn <- localStacks(contextStack.top)) {
+          add(stackRgn.start, stackRgn)
+        }
       }
     }
 
     if (sharedContextStack.size > 1) {
       sharedContextStack.pop()
       sharedStackMap.clear()
-      for (stackRgn <- sharedContextStack.top) {
-        add(stackRgn.start.value, stackRgn, true)
+      if (bufferedSharedStackMap.contains(contextStack.top)) {
+        sharedStackMap ++= bufferedSharedStackMap(contextStack.top)
+      } else {
+        for (stackRgn <- sharedContextStack.top) {
+          add(stackRgn.start, stackRgn, true)
+        }
       }
     }
   }
 
-
   def findStackObject(value: BigInt): Option[StackRegion] = 
-    stackMap.find((range, _) => range.start <= value && value <= range.end).map((range, obj) => obj)
+    stackMap.find((range, _) => range.start <= value && value <= range.end).map((range, obj) => returnRegion(obj))
 
   def findSharedStackObject(value: BigInt): Set[StackRegion] =
-    sharedStackMap.values.flatMap(_.find((range, _) => range.start <= value && value <= range.end).map((range, obj) => obj)).toSet
+    sharedStackMap.values.flatMap(_.find((range, _) => range.start <= value && value <= range.end).map((range, obj) => returnRegion(obj))).toSet
+
+  def findDataObject(value: BigInt): Option[DataRegion] =
+    dataMap.find((range, _) => range.start <= value && value <= range.end).map((range, obj) => returnRegion(obj))
 
-  def findDataObject(value: BigInt): Option[DataRegion] = 
-    dataMap.find((range, _) => range.start <= value && value <= range.end).map((range, obj) => obj)
+  def findDataObjectWithSize(value: BigInt, size: BigInt): (Set[DataRegion], Set[DataRegion]) =
+    // get regions that are between value and value + size and put partial regions (if part of the regions is between value and value + size) in a separate set
+    dataMap.foldLeft((Set.empty[DataRegion], Set.empty[DataRegion])) { case ((fullRegions, partialRegions), (range, region)) =>
+      if (range.start >= value && range.end <= value + size - 1) {
+        (fullRegions + returnRegion(region), partialRegions)
+      } else if ((range.start < value && range.end >= value) || (range.start <= value + size - 1 && range.end > value + size - 1)) {
+        (fullRegions, partialRegions + returnRegion(region))
+      } else {
+        (fullRegions, partialRegions)
+      }
+    }
 
   override def toString: String =
     s"Stack: $stackMap\n Heap: $heapMap\n Data: $dataMap\n"
@@ -245,6 +307,25 @@ class MemoryModelMap {
           logRegion(range, region, true)
         }
       }
+    Logger.debug("Stack Union-Find Roots:")
+    for name <- localStacks.keys do
+      popContext()
+      pushContext(name)
+      Logger.debug(s"  Function: $name")
+      var parentCount = 0
+      // get root regions
+      for ((range, region) <- stackMap) {
+        val root = uf.find(region)
+        if root == region then
+          logRegion(range, root)
+          parentCount += 1
+      }
+      if parentCount == 0 then Logger.debug("    No root regions") else Logger.debug(s"    Parents: $parentCount/${stackMap.size}")
+    Logger.debug("Shared Stacks:")
+    for (name, sharedStacks) <- sharedStacks do
+      Logger.debug(s"  Function: $name")
+      for region <- sharedStacks do
+        Logger.debug(s"    $region")
     Logger.debug("Heap:")
     for ((range, region) <- heapMap) {
       logRegion(range, region)
@@ -254,20 +335,110 @@ class MemoryModelMap {
       logRegion(range, region)
     }
   }
+
+  def mergeRegions(regions: Set[MemoryRegion]): MemoryRegion = {
+    // assert regions are of the same type
+    regions.foreach(uf.makeSet)
+    regions.foreach(uf.union(regions.head, _))
+    uf.find(regions.head)
+  }
+
+  private def returnRegion(region: MemoryRegion): MemoryRegion = {
+    uf.find(region)
+  }
+
+  private def returnRegion(region: StackRegion): StackRegion = {
+    uf.find(region).asInstanceOf[StackRegion]
+  }
+
+  private def returnRegion(region: DataRegion): DataRegion = {
+    uf.find(region).asInstanceOf[DataRegion]
+  }
+
+  private def returnRegion(region: HeapRegion): HeapRegion = {
+    uf.find(region).asInstanceOf[HeapRegion]
+  }
+
+  def getHeap(directCall: DirectCall): HeapRegion = {
+    require(directCall.target.name == "malloc", "Should be a malloc call")
+    heapCalls(directCall)
+  }
+
+  def getStack(allocationSite: CFGPosition): Set[StackRegion] = {
+    stackAllocationSites.getOrElse(allocationSite, Set.empty).map(returnRegion)
+  }
+
+  def getData(cfgPosition: CFGPosition): Set[DataRegion] = {
+    cfgPositionToDataRegion.getOrElse(cfgPosition, Set.empty).map(returnRegion)
+  }
+
+  def nodeToRegion(n: CFGPosition): Set[MemoryRegion] = {
+    n match {
+      case directCall: DirectCall =>
+        Set(getHeap(directCall))
+      case _ =>
+        getStack(n) ++ getData(n)
+    }
+  }
 }
 
 trait MemoryRegion {
   val regionIdentifier: String
+  val start: BigInt
 }
 
-case class StackRegion(override val regionIdentifier: String, start: BitVecLiteral, parent: Procedure) extends MemoryRegion {
-  override def toString: String = s"Stack($regionIdentifier, $start, ${parent.name})"
+case class StackRegion(override val regionIdentifier: String, override val start: BigInt, parent: Procedure) extends MemoryRegion {
+  override def toString: String = s"Stack($regionIdentifier, $start, ${parent.name}"
 }
 
-case class HeapRegion(override val regionIdentifier: String, size: BitVecLiteral, parent: Procedure) extends MemoryRegion {
+case class HeapRegion(override val regionIdentifier: String, override val start: BigInt, size: BigInt, parent: Procedure) extends MemoryRegion {
   override def toString: String = s"Heap($regionIdentifier, $size)"
 }
 
-case class DataRegion(override val regionIdentifier: String, start: BitVecLiteral) extends MemoryRegion {
-  override def toString: String = s"Data($regionIdentifier, $start)"
+case class DataRegion(override val regionIdentifier: String, override val start: BigInt, size: BigInt) extends MemoryRegion {
+  override def toString: String = s"Data($regionIdentifier, $start, $size)"
+  val end: BigInt = start + size - 1
 }
+
+class UnionFind {
+  // Map to store the parent of each region
+  private val parent: mutable.Map[MemoryRegion, MemoryRegion] = mutable.Map()
+
+  // Map to store the size of each set, used for union by rank
+  private val size: mutable.Map[MemoryRegion, Int] = mutable.Map()
+
+  // Initialise each region to be its own parent and set size to 1
+  def makeSet(region: MemoryRegion): Unit = {
+    parent(region) = region
+    size(region) = 1
+  }
+
+  // Find operation with path compression
+  def find(region: MemoryRegion): MemoryRegion = {
+    if (!parent.contains(region)) {
+      makeSet(region)
+    }
+
+    if (parent(region) != region) {
+      parent(region) = find(parent(region)) // Path compression
+    }
+    parent(region)
+  }
+
+  // Union operation with union by rank
+  def union(region1: MemoryRegion, region2: MemoryRegion): Unit = {
+    val root1 = find(region1)
+    val root2 = find(region2)
+
+    if (root1 != root2) {
+      if (size(root1) < size(root2)) {
+        parent(root1) = root2
+        size(root2) += size(root1)
+      } else {
+        parent(root2) = root1
+        size(root1) += size(root2)
+      }
+    }
+  }
+
+}
\ No newline at end of file
diff --git a/src/main/scala/analysis/MemoryRegionAnalysis.scala b/src/main/scala/analysis/MemoryRegionAnalysis.scala
index c7d888a43..d40957842 100644
--- a/src/main/scala/analysis/MemoryRegionAnalysis.scala
+++ b/src/main/scala/analysis/MemoryRegionAnalysis.scala
@@ -1,6 +1,7 @@
 package analysis
 
-import analysis.solvers.WorklistFixpointSolverWithReachability
+import analysis.BitVectorEval.bv2SignedInt
+import analysis.solvers.SimpleWorklistFixpointSolver
 import ir.*
 import util.Logger
 
@@ -8,22 +9,25 @@ import scala.collection.mutable
 import scala.collection.mutable.ListBuffer
 
 trait MemoryRegionAnalysis(val program: Program,
+                           val domain: Set[CFGPosition],
                            val globals: Map[BigInt, String],
                            val globalOffsets: Map[BigInt, BigInt],
                            val subroutines: Map[BigInt, String],
                            val constantProp: Map[CFGPosition, Map[Variable, FlatElement[BitVecLiteral]]],
                            val ANRResult: Map[CFGPosition, Set[Variable]],
                            val RNAResult: Map[CFGPosition, Set[Variable]],
-                           val regionAccesses: Map[CFGPosition, Map[RegisterVariableWrapper, FlatElement[Expr]]],
-                           reachingDefs: Map[CFGPosition, (Map[Variable, Set[Assign]], Map[Variable, Set[Assign]])]) {
+                           val reachingDefs: Map[CFGPosition, (Map[Variable, Set[Assign]], Map[Variable, Set[Assign]])],
+                           val graResult: Map[CFGPosition, Set[DataRegion]],
+                           val mmm: MemoryModelMap) {
 
-  var mallocCount: Int = 0
+  private var mallocCount: BigInt = 0
   private var stackCount: Int = 0
-  val stackMap: mutable.Map[Procedure, mutable.Map[Expr, StackRegion]] = mutable.Map()
+  val stackMap: mutable.Map[Procedure, mutable.Map[BigInt, StackRegion]] = mutable.Map()
 
-  private def nextMallocCount() = {
-    mallocCount += 1
-    s"malloc_$mallocCount"
+  private def nextMallocCount(size: BigInt) = {
+    val start = mallocCount
+    mallocCount += (size.toDouble/8).ceil.toInt + 1
+    (s"malloc_$mallocCount", start)
   }
 
   private def nextStackCount() = {
@@ -35,151 +39,155 @@ trait MemoryRegionAnalysis(val program: Program,
    * Controls the pool of stack regions. Each pool is unique to a function.
    * If the offset has already been defined in the context of the function, then the same region is returned.
    *
-   * @param expr   : the offset
+   * @param base   : the offset
    * @param parent : the function entry node
    * @return the stack region corresponding to the offset
    */
-  private def poolMaster(expr: BitVecLiteral, stackBase: Procedure): StackRegion = {
+  private def poolMaster(base: BigInt, stackBase: Procedure, subAccess: BigInt): StackRegion = {
+    assert(subAccess >= 0)
     val stackPool = stackMap.getOrElseUpdate(stackBase, mutable.HashMap())
-    if (stackPool.contains(expr)) {
-      stackPool(expr)
+    val region = if (stackPool.contains(base)) {
+      stackPool(base)
     } else {
-      val newRegion = StackRegion(nextStackCount(), expr, stackBase)
-      stackPool += (expr -> newRegion)
+      val newRegion = StackRegion(nextStackCount(), base, stackBase)
+      addReturnStack(stackBase, newRegion)
+      stackPool += (base -> newRegion)
       newRegion
     }
+    mmm.stackSubAccesses(region) = mmm.stackSubAccesses.getOrElse(region, mutable.Set()) += (subAccess.toDouble/8).ceil.toInt
+    region
   }
 
   private def stackDetection(stmt: Statement): Unit = {
     Logger.debug("Stack detection")
     Logger.debug(spList)
     stmt match {
-      case assign: Assign =>
+      case assign: LocalAssign =>
         if (spList.contains(assign.rhs)) {
           // add lhs to spList
           spList.addOne(assign.lhs)
-        } else {
+        // TODO: This is a hack: it should check for stack ptr using the wrapper
+        } else if (spList.contains(assign.lhs) && assign.lhs != stackPointer) {
           // remove lhs from spList
-          if spList.contains(assign.lhs) && assign.lhs != stackPointer then // TODO: This is a hack: it should check for stack ptr using the wrapper
-            spList.remove(spList.indexOf(assign.lhs))
+          spList.remove(spList.indexOf(assign.lhs))
         }
       // TODO: should handle the store case (last case)
       case _ =>
     }
   }
 
-  val regionLattice: PowersetLattice[MemoryRegion] = PowersetLattice()
+  val regionLattice: PowersetLattice[StackRegion] = PowersetLattice()
 
-  /**
-   * Lifted memory region lattice, with new bottom element representing "unreachable".
-   */
-  val liftedLattice: LiftLattice[Set[MemoryRegion], PowersetLattice[MemoryRegion]] = LiftLattice(regionLattice)
-
-  val lattice: MapLattice[CFGPosition, LiftedElement[Set[MemoryRegion]], LiftLattice[Set[MemoryRegion], PowersetLattice[MemoryRegion]]] = MapLattice(liftedLattice)
+  val lattice: MapLattice[CFGPosition, Set[StackRegion], PowersetLattice[StackRegion]] = MapLattice(regionLattice)
 
-  val domain: Set[CFGPosition] = Set.empty ++ program
-
-  val first: Set[CFGPosition] = Set.empty ++ program.procedures
+  val first: Set[CFGPosition] = Set.empty + program.mainProcedure
 
   private val stackPointer = Register("R31", 64)
-  private val linkRegister = Register("R30", 64)
-  private val framePointer = Register("R29", 64)
   private val mallocVariable = Register("R0", 64)
   private val spList = ListBuffer[Expr](stackPointer)
-  private val ignoreRegions: Set[Expr] = Set(linkRegister, framePointer)
-  // TODO: this could be used instead of regionAccesses in other analyses to reduce the Expr to region conversion
-  private val registerToRegions: mutable.Map[RegisterVariableWrapper, mutable.Set[MemoryRegion]] = mutable.Map()
   val procedureToSharedRegions: mutable.Map[Procedure, mutable.Set[MemoryRegion]] = mutable.Map()
+  var procedureToStackRegions: mutable.Map[Procedure, mutable.Set[StackRegion]] = mutable.Map()
+  var procedureToHeapRegions: mutable.Map[DirectCall, HeapRegion] = mutable.Map()
+  var mergeRegions: mutable.Set[Set[MemoryRegion]] = mutable.Set()
 
-  def reducibleToRegion(binExpr: BinaryExpr, n: Command): Set[MemoryRegion] = {
-    var reducedRegions = Set.empty[MemoryRegion]
-    binExpr.arg1 match {
-      case variable: Variable =>
-        val ctx = getUse(variable, n, reachingDefs)
-        for (i <- ctx) {
-          val regions = i.rhs match {
-            case memoryLoad: MemoryLoad =>
-              eval(memoryLoad.index, Set.empty, i)
-            case _: BitVecLiteral =>
-              Set.empty
-            case _ =>
-              eval(i.rhs, Set.empty, i)
-          }
-          evaluateExpression(binExpr.arg2, constantProp(n)) match {
-            case Some(b: BitVecLiteral) =>
-              regions.foreach {
-                case stackRegion: StackRegion =>
-                  val nextOffset = BinaryExpr(binExpr.op, stackRegion.start, b)
-                  evaluateExpression(nextOffset, constantProp(n)) match {
-                    case Some(b2: BitVecLiteral) =>
-                      reducedRegions = reducedRegions + poolMaster(b2, IRWalk.procedure(n))
-                    case None =>
-                  }
-                case _ =>
-              }
-            case None =>
-          }
+  def addReturnStack(procedure: Procedure, returnRegion: StackRegion): Unit = {
+    procedureToStackRegions.getOrElseUpdate(procedure, mutable.Set.empty).add(returnRegion)
+  }
+
+  def addReturnHeap(directCall: DirectCall, returnRegion: HeapRegion): Unit = {
+    procedureToHeapRegions.put(directCall, returnRegion)
+  }
+
+  def reducibleToRegion(binExpr: BinaryExpr, n: Command, subAccess: BigInt): Set[StackRegion] = {
+    val reducedRegions = binExpr.arg1 match {
+      case variable: Variable if !spList.contains(variable) =>
+        evaluateExpression(binExpr.arg2, constantProp(n)) match {
+          case Some(b: BitVecLiteral) =>
+            val ctx = getUse(variable, n, reachingDefs)
+            val stackRegions = ctx.flatMap {
+              case l: LocalAssign => eval(l.rhs, l, subAccess)
+              case m: MemoryLoad => eval(m.index, m, m.size)
+            }
+            for (stackRegion <- stackRegions) yield {
+              val nextOffset = bitVectorOpToBigIntOp(binExpr.op, stackRegion.start, b.value)
+              poolMaster(nextOffset, IRWalk.procedure(n), subAccess)
+            }
+          case None =>
+            Set()
         }
       case _ =>
+        eval(binExpr, n, subAccess)
     }
     reducedRegions
   }
 
-  def eval(exp: Expr, env: Set[MemoryRegion], n: Command): Set[MemoryRegion] = {
-    Logger.debug(s"evaluating $exp")
-    Logger.debug(s"env: $env")
-    Logger.debug(s"n: $n")
-    exp match {
-      case binOp: BinaryExpr =>
-        if (spList.contains(binOp.arg1)) {
-          evaluateExpression(binOp.arg2, constantProp(n)) match {
-            case Some(b: BitVecLiteral) => Set(poolMaster(b, IRWalk.procedure(n)))
-            case None => env
-          }
-        } else if (reducibleToRegion(binOp, n).nonEmpty) {
-          reducibleToRegion(binOp, n)
-        } else {
-          evaluateExpression(binOp, constantProp(n)) match {
-            case Some(b: BitVecLiteral) => eval(b, env, n)
-            case None => env
-          }
+  def reducibleVariable(variable: Variable, n: Command, subAccess: BigInt): Set[StackRegion] = {
+    val ctx = getDefinition(variable, n, reachingDefs)
+
+    // TODO: nicer way to deal with loops (a variable is being incremented in a loop)
+    val regions = ctx.flatMap { i =>
+      if (i != n) {
+        i match {
+          case l: LocalAssign => eval(l.rhs, l, subAccess)
+          case m: MemoryLoad => eval(m.index, m, m.size)
         }
-      case variable: Variable =>
-        variable match {
-          case _: LocalVar =>
-            env
-          case reg: Register if spList.contains(reg) =>
-            eval(BitVecLiteral(0, 64), env, n)
-          case _ =>
-            evaluateExpression(variable, constantProp(n)) match {
+      } else {
+        Set()
+      }
+    }
+    regions
+  }
+
+  def eval(exp: Expr, n: Command, subAccess: BigInt): Set[StackRegion] = {
+    if (graResult(n).nonEmpty) {
+      Set.empty // skip global memory regions
+    } else {
+      exp match {
+        case binOp: BinaryExpr =>
+          if (spList.contains(binOp.arg1)) {
+            evaluateExpression(binOp.arg2, constantProp(n)) match {
               case Some(b: BitVecLiteral) =>
-                eval(b, env, n)
-              case _ =>
-                env // we cannot evaluate this to a concrete value, we need VSA for this
+                val negB = bv2SignedInt(b)
+                Set(poolMaster(negB, IRWalk.procedure(n), subAccess))
+              case None => Set.empty
             }
-        }
-      case memoryLoad: MemoryLoad =>
-        eval(memoryLoad.index, env, n)
-      // ignore case where it could be a global region (loaded later in MMM from relf)
-      case b: BitVecLiteral =>
-        Set(poolMaster(b, IRWalk.procedure(n)))
-      // we cannot evaluate this to a concrete value, we need VSA for this
-      case _ =>
-        Logger.debug(s"type: ${exp.getClass} $exp\n")
-        throw new Exception("Unknown type")
+          } else if (reducibleToRegion(binOp, n, subAccess).nonEmpty) {
+            reducibleToRegion(binOp, n, subAccess)
+          } else {
+            Set.empty
+          }
+        case reg: Register if spList.contains(reg) => // TODO: this is a hack because spList is not comprehensive it needs to be a standalone analysis
+          if (getDefinition(reg, n, reachingDefs).isEmpty) {
+            Set(poolMaster(Long.MaxValue, IRWalk.procedure(n), subAccess))
+          } else {
+            reducibleVariable(reg, n, subAccess)
+          }
+        case variable: Variable =>
+          evaluateExpression(variable, constantProp(n)) match {
+            case Some(b: BitVecLiteral) =>
+              eval(b, n, subAccess)
+            case _ =>
+              reducibleVariable(variable, n, subAccess)
+          }
+        // ignore case where it could be a global region (loaded later in MMM from relf)
+        case _: BitVecLiteral =>
+          Set.empty
+        // we cannot evaluate this to a concrete value, we need VSA for this
+        case _ =>
+          Logger.debug(s"type: ${exp.getClass} $exp\n")
+          throw new Exception("Unknown type")
+      }
     }
   }
 
   /** Transfer function for state lattice elements.
    */
-  def localTransfer(n: CFGPosition, s: Set[MemoryRegion]): Set[MemoryRegion] = n match {
-    case cmd: Command =>
-      cmd match {
-        case directCall: DirectCall =>
-          val ANR = ANRResult(cmd)
-          val RNA = RNAResult(program.procedures.filter(fn => fn == directCall.target).head)
-          val parameters = RNA.intersect(ANR)
-          // TODO: Re-enable when ReachingDef has interprocedural option
+  def localTransfer(n: CFGPosition, s: Set[StackRegion]): Set[StackRegion] = n match {
+    case directCall: DirectCall =>
+      // TODO: Re-enable when ReachingDef has interprocedural option
+      // val ANR = ANRResult(directCall)
+      // val RNA = RNAResult(program.procedures.filter(fn => fn == directCall.target).head)
+      //      val parameters = RNA.intersect(ANR)
 //          val ctx = regionAccesses(cmd)
 //          for (elem <- parameters) {
 //            if (ctx.contains(RegisterVariableWrapper(elem, getUse(elem, cmd.data, reachingDefs)))) {
@@ -193,60 +201,56 @@ trait MemoryRegionAnalysis(val program: Program,
 //              }
 //            }
 //          }
-          if (directCall.target.name == "malloc") {
-            evaluateExpression(mallocVariable, constantProp(n)) match {
-              case Some(b: BitVecLiteral) => regionLattice.lub(s, Set(HeapRegion(nextMallocCount(), b, IRWalk.procedure(n))))
-              case None => s
-            }
-          } else {
+      if (directCall.target.name == "malloc") {
+        evaluateExpression(mallocVariable, constantProp(n)) match {
+          case Some(b: BitVecLiteral) =>
+            val negB = bv2SignedInt(b)
+            val (name, start) = nextMallocCount(negB)
+            val newHeapRegion = HeapRegion(name, start, negB, IRWalk.procedure(n))
+            addReturnHeap(directCall, newHeapRegion)
             s
-          }
-        case memAssign: MemoryAssign =>
-          if (ignoreRegions.contains(memAssign.value)) {
+          case None =>
+            // Assume heap region size is at least 1 TODO: must approximate size of heap
+            val negB = 1
+            val (name, start) = nextMallocCount(negB)
+            val newHeapRegion = HeapRegion(name, start, negB, IRWalk.procedure(n))
+            addReturnHeap(directCall, newHeapRegion)
             s
-          } else {
-            val result = eval(memAssign.index, s, cmd)
-            regionLattice.lub(s, result)
-          }
-        case assign: Assign =>
-          stackDetection(assign)
-          var m = s
-          unwrapExpr(assign.rhs).foreach {
-            case memoryLoad: MemoryLoad =>
-              val result = eval(memoryLoad.index, s, cmd)
-              m = regionLattice.lub(m, result)
-            case _ => m
-          }
-          m
-        case _ => s
+        }
+      } else {
+        s
       }
-    case _ => s // ignore other kinds of nodes
+    case memAssign: MemoryStore =>
+      val result = eval(memAssign.index, memAssign, memAssign.size)
+//          if (result.size > 1) {
+//            //throw new Exception(s"Memory load resulted in multiple regions ${result} for mem load $memoryLoad")
+//            addMergableRegions(result)
+//          }
+      result
+    case assign: LocalAssign =>
+      stackDetection(assign)
+      Set()
+    case load: MemoryLoad =>
+      eval(load.index, load, load.size)
+    case _ => s
   }
 
-  def transferUnlifted(n: CFGPosition, s: Set[MemoryRegion]): Set[MemoryRegion] = localTransfer(n, s)
+  def transfer(n: CFGPosition, s: Set[StackRegion]): Set[StackRegion] = localTransfer(n, s)
 }
 
 class MemoryRegionAnalysisSolver(
-    program: Program,
-    globals: Map[BigInt, String],
-    globalOffsets: Map[BigInt, BigInt],
-    subroutines: Map[BigInt, String],
-    constantProp: Map[CFGPosition, Map[Variable, FlatElement[BitVecLiteral]]],
-    ANRResult: Map[CFGPosition, Set[Variable]],
-    RNAResult: Map[CFGPosition, Set[Variable]],
-    regionAccesses: Map[CFGPosition, Map[RegisterVariableWrapper, FlatElement[Expr]]],
-    reachingDefs: Map[CFGPosition, (Map[Variable, Set[Assign]], Map[Variable, Set[Assign]])]
-  ) extends MemoryRegionAnalysis(program, globals, globalOffsets, subroutines, constantProp, ANRResult, RNAResult, regionAccesses, reachingDefs)
+                                  program: Program,
+                                  domain: Set[CFGPosition],
+                                  globals: Map[BigInt, String],
+                                  globalOffsets: Map[BigInt, BigInt],
+                                  subroutines: Map[BigInt, String],
+                                  constantProp: Map[CFGPosition, Map[Variable, FlatElement[BitVecLiteral]]],
+                                  ANRResult: Map[CFGPosition, Set[Variable]],
+                                  RNAResult: Map[CFGPosition, Set[Variable]],
+                                  reachingDefs: Map[CFGPosition, (Map[Variable, Set[Assign]], Map[Variable, Set[Assign]])],
+                                  graResult: Map[CFGPosition, Set[DataRegion]],
+                                  mmm: MemoryModelMap
+  ) extends MemoryRegionAnalysis(program, domain, globals, globalOffsets, subroutines, constantProp, ANRResult, RNAResult, reachingDefs, graResult, mmm)
   with IRIntraproceduralForwardDependencies
-  with Analysis[Map[CFGPosition, LiftedElement[Set[MemoryRegion]]]]
-  with WorklistFixpointSolverWithReachability[CFGPosition, Set[MemoryRegion], PowersetLattice[MemoryRegion]] {
-
-  override def funsub(n: CFGPosition, x: Map[CFGPosition, LiftedElement[Set[MemoryRegion]]]): LiftedElement[Set[MemoryRegion]] = {
-    n match {
-      // function entry nodes are always reachable as this is intraprocedural
-      case _: Procedure => liftedLattice.lift(regionLattice.bottom)
-      // all other nodes are processed with join+transfer
-      case _ => super.funsub(n, x)
-    }
-  }
-}
+  with Analysis[Map[CFGPosition, Set[StackRegion]]]
+  with SimpleWorklistFixpointSolver[CFGPosition, Set[StackRegion], PowersetLattice[StackRegion]]
\ No newline at end of file
diff --git a/src/main/scala/analysis/RNA.scala b/src/main/scala/analysis/RNA.scala
index b58e74dd9..e15dbe914 100644
--- a/src/main/scala/analysis/RNA.scala
+++ b/src/main/scala/analysis/RNA.scala
@@ -22,47 +22,44 @@ trait RNAAnalysis(program: Program) {
   private val linkRegister = Register("R30", 64)
   private val framePointer = Register("R29", 64)
 
-  private val ignoreRegions: Set[Expr] = Set(linkRegister, framePointer, stackPointer)
+  private val ignoreRegions: Set[Variable] = Set(linkRegister, framePointer, stackPointer)
 
-  /** Default implementation of eval.
-    */
   def eval(cmd: Command, s: Set[Variable]): Set[Variable] = {
-    var m = s
     cmd match {
       case assume: Assume =>
-        m.union(assume.body.variables.filter(!ignoreRegions.contains(_)))
+        s ++ (assume.body.variables -- ignoreRegions)
       case assert: Assert =>
-        m.union(assert.body.variables.filter(!ignoreRegions.contains(_)))
-      case memoryAssign: MemoryAssign =>
-        m.union(memoryAssign.index.variables.filter(!ignoreRegions.contains(_)))
+        s ++ (assert.body.variables -- ignoreRegions)
+      case memoryStore: MemoryStore =>
+        s ++ (memoryStore.index.variables -- ignoreRegions)
       case indirectCall: IndirectCall =>
-        if (ignoreRegions.contains(indirectCall.target)) return m
-        m + indirectCall.target
-      case assign: Assign =>
-        m = m - assign.lhs
-        m.union(assign.rhs.variables.filter(!ignoreRegions.contains(_)))
+        if (ignoreRegions.contains(indirectCall.target)) {
+          s
+        } else {
+          s + indirectCall.target
+        }
+      case assign: LocalAssign =>
+        val m = s - assign.lhs
+        m ++ (assign.rhs.variables -- ignoreRegions)
+      case memoryLoad: MemoryLoad =>
+        val m = s - memoryLoad.lhs
+        m ++ (memoryLoad.index.variables -- ignoreRegions)
       case _ =>
-        m
+        s
     }
   }
 
   /** Transfer function for state lattice elements.
     */
-  def localTransfer(n: CFGPosition, s: Set[Variable]): Set[Variable] = n match {
+  def transfer(n: CFGPosition, s: Set[Variable]): Set[Variable] = n match {
     case cmd: Command =>
       eval(cmd, s)
     case _ => s // ignore other kinds of nodes
   }
 
-  /** Transfer function for state lattice elements.
-      */
-  def transfer(n: CFGPosition, s: Set[Variable]): Set[Variable] = localTransfer(n, s)
 }
 
-class RNAAnalysisSolver(
-    program: Program,
-) extends RNAAnalysis(program)
+class RNAAnalysisSolver(program: Program) extends RNAAnalysis(program)
     with IRIntraproceduralBackwardDependencies
     with Analysis[Map[CFGPosition, Set[Variable]]]
-    with SimpleWorklistFixpointSolver[CFGPosition, Set[Variable], PowersetLattice[Variable]] {
-}
\ No newline at end of file
+    with SimpleWorklistFixpointSolver[CFGPosition, Set[Variable], PowersetLattice[Variable]]
\ No newline at end of file
diff --git a/src/main/scala/analysis/ReachingDefinitionsAnalysis.scala b/src/main/scala/analysis/ReachingDefinitionsAnalysis.scala
index 47592f082..07fe443d2 100644
--- a/src/main/scala/analysis/ReachingDefinitionsAnalysis.scala
+++ b/src/main/scala/analysis/ReachingDefinitionsAnalysis.scala
@@ -3,70 +3,64 @@ package analysis
 import ir.*
 import analysis.solvers.SimpleWorklistFixpointSolver
 
-case class ReachingDefinitionsAnalysis(program: Program) {
+type TupleElement =
+  TupleLattice[MapLattice[Variable, Set[Assign], PowersetLattice[Assign]], MapLattice[Variable, Set[Assign], PowersetLattice[Assign]], Map[Variable, Set[Assign]], Map[Variable, Set[Assign]]]
 
-  type Definition = Assign // local assign is a definition because it is a statement and statements are assumed to be unique
-  type TupleElement =
-    TupleLattice[MapLattice[Variable, Set[Definition], PowersetLattice[Definition]], MapLattice[Variable, Set[Definition], PowersetLattice[Definition]], Map[Variable, Set[Definition]], Map[Variable, Set[Definition]]]
+trait ReachingDefinitionsAnalysis(program: Program) {
 
-  val tupleLattice: TupleLattice[MapLattice[Variable, Set[Definition], PowersetLattice[Definition]], MapLattice[Variable, Set[Assign], PowersetLattice[
-    Assign]], Map[Variable, Set[Definition]], Map[Variable, Set[Definition]]] =
-    new TupleLattice(
-      new MapLattice[Variable, Set[Definition], PowersetLattice[Definition]](new PowersetLattice[Definition]()),
-      new MapLattice[Variable, Set[Definition], PowersetLattice[Definition]](new PowersetLattice[Definition]())
+  private val tupleLattice: TupleLattice[MapLattice[Variable, Set[Assign], PowersetLattice[Assign]], MapLattice[Variable, Set[Assign], PowersetLattice[
+    Assign]], Map[Variable, Set[Assign]], Map[Variable, Set[Assign]]] =
+    TupleLattice(
+      MapLattice[Variable, Set[Assign], PowersetLattice[Assign]](PowersetLattice[Assign]()),
+      MapLattice[Variable, Set[Assign], PowersetLattice[Assign]](PowersetLattice[Assign]())
     )
 
-  val lattice: MapLattice[CFGPosition, (Map[Variable, Set[Definition]], Map[Variable, Set[Definition]]), TupleElement] = MapLattice(
+  val lattice: MapLattice[CFGPosition, (Map[Variable, Set[Assign]], Map[Variable, Set[Assign]]), TupleElement] = MapLattice(
     tupleLattice
   )
 
   val domain: Set[CFGPosition] = Set.empty ++ program
 
-  /*
-   * Good enough as stmts are unique
-   */
-  private def generateUniqueDefinition(
-      variable: Variable
-  ): Assign = {
-    Assign(variable, BitVecLiteral(0, 0))
-  }
-
-  def transfer(n: CFGPosition, s: (Map[Variable, Set[Definition]], Map[Variable, Set[Definition]])): (Map[Variable, Set[Definition]], Map[Variable, Set[Definition]]) =
-    localTransfer(n, s)
-
-  def localTransfer(
-      n: CFGPosition,
-      s: (Map[Variable, Set[Definition]], Map[Variable, Set[Definition]])
-  ): (Map[Variable, Set[Definition]], Map[Variable, Set[Definition]]) = n match {
-    case cmd: Command =>
-      eval(cmd, s)
-    case _ => s
+  def transfer(n: CFGPosition, s: (Map[Variable, Set[Assign]], Map[Variable, Set[Assign]])): (Map[Variable, Set[Assign]], Map[Variable, Set[Assign]]) = {
+    n match {
+      case cmd: Command =>
+        eval(cmd, s)
+      case _ => s
+    }
   }
 
-  def transformUses(vars: Set[Variable], s: (Map[Variable, Set[Definition]], Map[Variable, Set[Definition]])): (Map[Variable, Set[Definition]], Map[Variable, Set[Definition]]) = {
-    vars.foldLeft((s._1, Map.empty[Variable, Set[Definition]])) {
+  private def transformUses(vars: Set[Variable], s: (Map[Variable, Set[Assign]], Map[Variable, Set[Assign]])): (Map[Variable, Set[Assign]], Map[Variable, Set[Assign]]) = {
+    vars.foldLeft((s(0), Map.empty[Variable, Set[Assign]])) {
       case ((state, acc), v) =>
         (state, acc + (v -> state(v)))
     }
   }
 
-  def eval(cmd: Command, s: (Map[Variable, Set[Definition]], Map[Variable, Set[Definition]])
-  ): (Map[Variable, Set[Definition]], Map[Variable, Set[Definition]]) = cmd match {
-    case assign: Assign =>
+  def eval(cmd: Command, s: (Map[Variable, Set[Assign]], Map[Variable, Set[Assign]])):
+    (Map[Variable, Set[Assign]], Map[Variable, Set[Assign]]) = cmd match {
+    case assign: LocalAssign =>
       // do the rhs first (should reset the values for this node to the empty set)
       // for each variable in the rhs, find the definitions from the lattice lhs and add them to the lattice rhs
       // for lhs, addOrReplace the definition
       val rhs = assign.rhs.variables
       val lhs = assign.lhs
-      val rhsUseDefs: Map[Variable, Set[Definition]] = rhs.foldLeft(Map.empty[Variable, Set[Definition]]) {
+      val rhsUseDefs: Map[Variable, Set[Assign]] = rhs.foldLeft(Map.empty[Variable, Set[Assign]]) {
         case (acc, v) =>
-          acc + (v -> s._1(v))
+          acc + (v -> s(0)(v))
       }
-      (s._1 + (lhs -> Set(assign)), rhsUseDefs)
+      (s(0) + (lhs -> Set(assign)), rhsUseDefs)
     case assert: Assert =>
       transformUses(assert.body.variables, s)
-    case memoryAssign: MemoryAssign =>
-      transformUses(memoryAssign.index.variables ++ memoryAssign.value.variables, s)
+    case memoryStore: MemoryStore =>
+      transformUses(memoryStore.index.variables ++ memoryStore.value.variables, s)
+    case memoryLoad: MemoryLoad =>
+      val lhs = memoryLoad.lhs
+      val rhs = memoryLoad.index.variables
+      val rhsUseDefs: Map[Variable, Set[Assign]] = rhs.foldLeft(Map.empty[Variable, Set[Assign]]) {
+        case (acc, v) =>
+          acc + (v -> s(0)(v))
+      }
+      (s(0) + (lhs -> Set(memoryLoad)), rhsUseDefs)
     case assume: Assume =>
       transformUses(assume.body.variables, s)
     case indirectCall: IndirectCall =>
@@ -75,7 +69,7 @@ case class ReachingDefinitionsAnalysis(program: Program) {
   }
 }
 
-class ReachingDefinitionsAnalysisSolver(program: Program)
+class InterprocReachingDefinitionsAnalysisSolver(program: Program)
   extends ReachingDefinitionsAnalysis(program)
-    with SimpleWorklistFixpointSolver[CFGPosition, (Map[Variable, Set[ReachingDefinitionsAnalysis#Definition]], Map[Variable, Set[ReachingDefinitionsAnalysis#Definition]]), ReachingDefinitionsAnalysis#TupleElement]
-    with IRIntraproceduralForwardDependencies
+    with SimpleWorklistFixpointSolver[CFGPosition, (Map[Variable, Set[Assign]], Map[Variable, Set[Assign]]), TupleElement]
+    with IRInterproceduralForwardDependencies
\ No newline at end of file
diff --git a/src/main/scala/analysis/ReachingDefs.scala b/src/main/scala/analysis/ReachingDefs.scala
new file mode 100644
index 000000000..f60e9ffc6
--- /dev/null
+++ b/src/main/scala/analysis/ReachingDefs.scala
@@ -0,0 +1,34 @@
+package analysis
+
+import analysis.solvers.SimplePushDownWorklistFixpointSolver
+import ir.{LocalAssign, CFGPosition, DirectCall, IntraProcIRCursor, MemoryLoad, Procedure, Program, Register, Variable, computeDomain}
+
+abstract class ReachingDefs(program: Program, writesTo: Map[Procedure, Set[Register]]) extends Analysis[Map[CFGPosition, Map[Variable, Set[CFGPosition]]]] {
+
+  val mallocRegister = Register("R0", 64)
+  val domain: Set[CFGPosition] = computeDomain(IntraProcIRCursor, program.procedures).toSet
+  val lattice: MapLattice[CFGPosition, Map[Variable, Set[CFGPosition]], MapLattice[Variable, Set[CFGPosition], PowersetLattice[CFGPosition]]] = MapLattice(MapLattice(PowersetLattice[CFGPosition]()))
+
+  def transfer(n: CFGPosition, s: Map[Variable, Set[CFGPosition]]): Map[Variable, Set[CFGPosition]] = {
+    n match {
+      case loc: LocalAssign =>
+        s + (loc.lhs -> Set(n))
+      case load: MemoryLoad =>
+        s + (load.lhs -> Set(n))
+      case DirectCall(target, _) if target.name == "malloc" =>
+        s + (mallocRegister -> Set(n))
+      case DirectCall(target, _) if writesTo.contains(target) =>
+        val result: Map[Variable, Set[CFGPosition]] = writesTo(target).foldLeft(Map[Variable, Set[CFGPosition]]()) {
+          (m, register) =>
+            m + (register -> Set(n))
+        }
+        s ++ result
+      case _ => s
+    }
+  }
+
+}
+
+class ReachingDefsAnalysis(program: Program, writesTo: Map[Procedure, Set[Register]]) extends ReachingDefs(program, writesTo), IRIntraproceduralForwardDependencies,
+  SimplePushDownWorklistFixpointSolver[CFGPosition, Map[Variable, Set[CFGPosition]], MapLattice[Variable, Set[CFGPosition], PowersetLattice[CFGPosition]]]
+
diff --git a/src/main/scala/analysis/RegToMemAnalysis.scala b/src/main/scala/analysis/RegToMemAnalysis.scala
deleted file mode 100644
index 1afde6f4d..000000000
--- a/src/main/scala/analysis/RegToMemAnalysis.scala
+++ /dev/null
@@ -1,72 +0,0 @@
-package analysis
-
-import ir.{MemoryLoad, *}
-import analysis.solvers.*
-import util.Logger
-
-import scala.collection.immutable
-
-/**
- * Collects all the memory loads and the expressions that are assigned to a register but cannot be evaluated.
- *
- * Tracks:
- * R_x = MemoryLoad[Base + Offset]
- * R_x = Base + Offset
- *
- * Both in which constant propagation mark as TOP which is not useful.
- */
-trait RegionAccessesAnalysis(program: Program, constantProp: Map[CFGPosition, Map[Variable, FlatElement[BitVecLiteral]]], reachingDefs: Map[CFGPosition, (Map[Variable, Set[Assign]], Map[Variable, Set[Assign]])]) {
-
-  val mapLattice: MapLattice[RegisterVariableWrapper, FlatElement[Expr], FlatLattice[Expr]] = MapLattice(FlatLattice[_root_.ir.Expr]())
-
-  val lattice: MapLattice[CFGPosition, Map[RegisterVariableWrapper, FlatElement[Expr]], MapLattice[RegisterVariableWrapper, FlatElement[Expr], FlatLattice[Expr]]] = MapLattice(mapLattice)
-
-  val domain: Set[CFGPosition] = program.toSet 
-
-  val first: Set[CFGPosition] = program.procedures.toSet
-
-  /** Default implementation of eval.
-   */
-  def eval(cmd: Statement, constants: Map[Variable, FlatElement[BitVecLiteral]], s: Map[RegisterVariableWrapper, FlatElement[Expr]]): Map[RegisterVariableWrapper, FlatElement[Expr]] = {
-    cmd match {
-      case assign: Assign =>
-        assign.rhs match {
-          case memoryLoad: MemoryLoad =>
-            s + (RegisterVariableWrapper(assign.lhs, getDefinition(assign.lhs, cmd, reachingDefs)) -> FlatEl(memoryLoad))
-          case binaryExpr: BinaryExpr =>
-            if (evaluateExpression(binaryExpr.arg1, constants).isEmpty) { // approximates Base + Offset
-              Logger.debug(s"Approximating $assign in $binaryExpr")
-              Logger.debug(s"Reaching defs: ${reachingDefs(cmd)}")
-              s + (RegisterVariableWrapper(assign.lhs, getDefinition(assign.lhs, cmd, reachingDefs)) -> FlatEl(binaryExpr))
-            } else {
-              s
-            }
-          case _ => s
-        }
-      case _ =>
-        s
-    }
-  }
-
-  /** Transfer function for state lattice elements.
-   */
-  def localTransfer(n: CFGPosition, s: Map[RegisterVariableWrapper, FlatElement[Expr]]): Map[RegisterVariableWrapper, FlatElement[Expr]] = n match {
-    case cmd: Statement =>
-      eval(cmd, constantProp(cmd), s)
-    case _ => s // ignore other kinds of nodes
-  }
-
-  /** Transfer function for state lattice elements.
-   */
-  def transfer(n: CFGPosition, s: Map[RegisterVariableWrapper, FlatElement[Expr]]): Map[RegisterVariableWrapper, FlatElement[Expr]] = localTransfer(n, s)
-}
-
-class RegionAccessesAnalysisSolver(
-                         program: Program,
-                         constantProp: Map[CFGPosition, Map[Variable, FlatElement[BitVecLiteral]]],
-                         reachingDefs: Map[CFGPosition, (Map[Variable, Set[Assign]], Map[Variable, Set[Assign]])],
-                       ) extends RegionAccessesAnalysis(program, constantProp, reachingDefs)
-  with IRInterproceduralForwardDependencies
-  with Analysis[Map[CFGPosition, Map[RegisterVariableWrapper, FlatElement[Expr]]]]
-  with SimpleWorklistFixpointSolver[CFGPosition, Map[RegisterVariableWrapper, FlatElement[Expr]], MapLattice[RegisterVariableWrapper, FlatElement[Expr], FlatLattice[Expr]]] {
-}
diff --git a/src/main/scala/analysis/RegionInjector.scala b/src/main/scala/analysis/RegionInjector.scala
new file mode 100644
index 000000000..77f1bd89c
--- /dev/null
+++ b/src/main/scala/analysis/RegionInjector.scala
@@ -0,0 +1,160 @@
+package analysis
+
+import analysis.BitVectorEval.isNegative
+import ir.*
+import util.Logger
+
+import scala.collection.mutable
+import scala.collection.mutable.ArrayBuffer
+
+/**
+ * Replaces the region access with the calculated memory region.
+ */
+
+class MergedRegion(var name: String, val subregions: mutable.Set[MemoryRegion])
+
+class RegionInjector(program: Program, mmm: MemoryModelMap) {
+  private val accessToRegion = mutable.Map[Statement, Set[MemoryRegion]]()
+  val mergedRegions: mutable.Map[MemoryRegion, MergedRegion] = mutable.Map()
+
+  def nodeVisitor(): Unit = {
+    // visit reachable procedures
+    val queue = mutable.Queue[Procedure]()
+    val visited = mutable.Set[Procedure]()
+    queue.enqueue(program.mainProcedure)
+
+    while (queue.nonEmpty) {
+      val procedure = queue.dequeue()
+      for {
+        b <- procedure.blocks
+        s <- b.statements
+      } {
+        visitStatement(s)
+      }
+      visited.add(procedure)
+      for (call <- procedure.calls) {
+        if (!queue.contains(call) && !visited.contains(call)) {
+          queue.enqueue(call)
+        }
+      }
+    }
+
+    for (access <- accessToRegion.keys) {
+      val regions = accessToRegion(access)
+      if (regions.isEmpty) {
+        //throw Exception("no regions found for " + access)
+      } else {
+        mergeRegions(regions)
+      }
+    }
+
+    // rename all regions
+    renameMemory()
+
+    transformMemorySections(program)
+  }
+
+  def mergeRegions(regions: Set[MemoryRegion]): Unit = {
+    // TODO need to check that all regions are the same type
+    val oldMergedRegions = regions.flatMap(r => mergedRegions.get(r))
+    if (oldMergedRegions.nonEmpty) {
+      // TODO rename in sensible deterministic way
+      val oldRegion = oldMergedRegions.head
+      for (o <- oldMergedRegions.tail) {
+        oldRegion.subregions.addAll(o.subregions)
+      }
+      oldRegion.subregions.addAll(regions)
+      for (o <- oldRegion.subregions) {
+        mergedRegions(o) = oldRegion
+      }
+    } else {
+      // TODO give sensible deterministic name
+      val mergedRegion = MergedRegion(regions.head.regionIdentifier, mutable.Set())
+      mergedRegion.subregions.addAll(regions)
+      for (m <- mergedRegion.subregions) {
+        mergedRegions(m) = mergedRegion
+      }
+    }
+  }
+
+  def renameMemory(): Unit = {
+    for (access <- accessToRegion.keys) {
+      // all regions associated with an access should have same merged region so no need to check others
+      val regions = accessToRegion(access)
+      if (regions.nonEmpty) {
+        val regionsHead = regions.head
+        val mergedRegion = mergedRegions(regionsHead)
+
+        access match {
+          case store: MemoryStore =>
+            val newMemory = replaceMemory(store.mem, regionsHead, mergedRegion)
+            store.mem = newMemory
+          case load: MemoryLoad =>
+            val newMemory = replaceMemory(load.mem, regionsHead, mergedRegion)
+            load.mem = newMemory
+          case _ =>
+        }
+      }
+
+    }
+  }
+
+  def replaceMemory(memory: Memory, region: MemoryRegion, mergedRegion: MergedRegion): Memory = {
+    region match {
+      case _: StackRegion =>
+        StackMemory(mergedRegion.name, memory.addressSize, memory.valueSize)
+      case _: DataRegion =>
+        SharedMemory(mergedRegion.name, memory.addressSize, memory.valueSize)
+      case _: HeapRegion =>
+        SharedMemory(mergedRegion.name, memory.addressSize, memory.valueSize)
+    }
+  }
+
+  private def statementToRegions(n: Statement): Set[MemoryRegion] = {
+    mmm.getStack(n) ++ mmm.getData(n)
+  }
+
+  def visitStatement(n: Statement): Unit = n match {
+    case m: MemoryStore =>
+      val regions = statementToRegions(m)
+      accessToRegion(m) = regions
+    case m: MemoryLoad =>
+      val regions = statementToRegions(n)
+      accessToRegion(n) = regions
+    case _ => // ignore other kinds of nodes
+  }
+
+  // replace memory renamer with something that creates map from access to region
+  // then handle all the merging required
+  // then do the renaming
+  // then get regions per procedure, handle initial memory with those
+
+  def transformMemorySections(program: Program): Unit = {
+    val dataRegions = mergedRegions.keys.collect { case d: DataRegion => d }
+
+    for (region <- dataRegions) {
+      program.initialMemoryLookup(region.start) match {
+        case Some(section) =>
+          val size = region.size.toInt
+          val bytes = section.getBytes(region.start, size)
+          // should probably check that region is entirely contained within section but shouldn't happen in practice?
+          val newSection = MemorySection(region.regionIdentifier, region.start, size, bytes, section.readOnly, Some(mergedRegions(region)))
+          program.usedMemory(region.start) = newSection
+        case None =>
+      }
+    }
+  }
+
+  def getMergedRegion(address: BigInt): Option[MergedRegion] = {
+    val region = mmm.findDataObject(address)
+    if (region.isDefined && mergedRegions.contains(region.get)) {
+      Some(mergedRegions(region.get))
+    } else {
+      None
+    }
+  }
+}
+
+class RegionRenamer(memory: Memory) extends Visitor {
+  override def visitMemory(node: Memory): Memory = memory
+}
\ No newline at end of file
diff --git a/src/main/scala/analysis/SSAForm.scala b/src/main/scala/analysis/SSAForm.scala
deleted file mode 100644
index 044780a6b..000000000
--- a/src/main/scala/analysis/SSAForm.scala
+++ /dev/null
@@ -1,100 +0,0 @@
-//package analysis
-//
-//import analysis.*
-//import ir.{SignExtend, *}
-//import util.Logger
-//
-//import scala.collection.mutable
-//
-///** Set-Based SSA
-// * - Each variable has a set of versions
-// * - New assignments create new versions and replaces any new versions
-// *
-// * NOTE: This approach does not make an attempt to handle loops
-// */
-//class SSAForm(program: Program) {
-//
-//  private val varMaxTracker = mutable.HashMap[String, Int]()
-//  private val blockBasedMappings = mutable.HashMap[(Block, String), mutable.Set[Int]]().withDefault(_ => mutable.Set())
-//  private val context = mutable.HashMap[(Procedure, String), mutable.Set[Int]]().withDefault(_ => mutable.Set())
-//  private def getMax(varName: String): Int =
-//    val ret = varMaxTracker.getOrElse(varName, 0)
-//    varMaxTracker(varName) = ret + 1
-//    ret
-//
-//  private def transformVariables(vars: Set[Variable], block: Block, proc: Procedure): Unit = {
-//    vars.foreach { v =>
-//      if (context.contains((proc, v.name))) {
-//        v.sharedVariable = true
-//      }
-//      v.ssa_id.clear()
-//      val contextResult = context.getOrElseUpdate((proc, v.name), mutable.Set(getMax(v.name)))
-//      v.ssa_id.addAll(blockBasedMappings.getOrElseUpdate((block, v.name), contextResult))
-//    }
-//  }
-//
-//  def applySSA(): Unit = {
-//    for (proc <- program.procedures) {
-//      val visitedBlocks = mutable.Set[Block]()
-//      val stack = mutable.Stack[Block]()
-//
-//      // Start with the entry block
-//      if (proc.entryBlock.isDefined) {
-//        stack.push(proc.entryBlock.get)
-//      }
-//
-//      while (stack.nonEmpty) {
-//        val currentBlock = stack.pop()
-//
-//        if (!visitedBlocks.contains(currentBlock)) {
-//          visitedBlocks.add(currentBlock)
-//
-//          for (stmt <- currentBlock.statements) {
-//            Logger.debug(stmt)
-//            stmt match {
-//              case localAssign: LocalAssign =>
-//                transformVariables(localAssign.rhs.variables, currentBlock, proc)
-//                val maxVal = varMaxTracker.getOrElseUpdate(localAssign.lhs.name, 0)
-//                blockBasedMappings((currentBlock, localAssign.lhs.name)) = mutable.Set(maxVal)
-//
-//                localAssign.lhs.ssa_id.clear()
-//                localAssign.lhs.ssa_id.addAll(blockBasedMappings((currentBlock, localAssign.lhs.name)))
-//
-//                varMaxTracker(localAssign.lhs.name) = blockBasedMappings((currentBlock, localAssign.lhs.name)).max + 1
-//
-//              case memoryAssign: MemoryAssign =>
-//                transformVariables(memoryAssign.rhs.variables, currentBlock, proc)
-//
-//              case assume: Assume =>
-//                transformVariables(assume.body.variables, currentBlock, proc)
-//              // no required for analyses
-//              case assert: Assert =>
-//                transformVariables(assert.body.variables, currentBlock, proc)
-//              // no required for analyses
-//              case _ => throw new RuntimeException("No SSA form for " + stmt.getClass + " yet")
-//            }
-//          }
-//          currentBlock.jump match {
-//            case directCall: DirectCall =>
-//              // TODO: transfers the whole context but it could be using ANR and RNA to transfer only the relevant context
-//              varMaxTracker.keys.foreach { varr =>
-//                //context((directCall.target, varr)) = context((directCall.target, varr)) ++ blockBasedMappings(block, varr)
-//                context.getOrElseUpdate((directCall.target, varr), mutable.Set()) ++= blockBasedMappings((currentBlock, varr))
-//              }
-//            case indirectCall: IndirectCall =>
-//              transformVariables(indirectCall.target.variables, currentBlock, proc)
-//            case goTo: GoTo =>
-//              for {
-//                b <- goTo.targets
-//                varr <- varMaxTracker.keys
-//              } {
-//                blockBasedMappings((b, varr)) ++= blockBasedMappings(currentBlock, varr)
-//              }
-//          }
-//          // Push unvisited successors onto the stack
-//          stack.pushAll(currentBlock.nextBlocks)
-//        }
-//      }
-//    }
-//  }
-//}
diff --git a/src/main/scala/analysis/SteensgaardAnalysis.scala b/src/main/scala/analysis/SteensgaardAnalysis.scala
deleted file mode 100644
index e69de29bb..000000000
diff --git a/src/main/scala/analysis/SummaryGenerator.scala b/src/main/scala/analysis/SummaryGenerator.scala
index 552295f23..1a878e21d 100644
--- a/src/main/scala/analysis/SummaryGenerator.scala
+++ b/src/main/scala/analysis/SummaryGenerator.scala
@@ -24,35 +24,31 @@ private trait RNATaintableAnalysis(
   private val linkRegister = Register("R30", 64)
   private val framePointer = Register("R29", 64)
 
-  private val ignoreRegions: Set[Expr] = Set(linkRegister, framePointer, stackPointer)
+  private val ignoreRegions: Set[Variable] = Set(linkRegister, framePointer, stackPointer)
 
   def eval(cmd: Command, s: Set[Taintable]): Set[Taintable] = {
-    var m = s
-    val exprs = cmd match {
+    cmd match {
       case assume: Assume =>
-        Set(assume.body)
+        s ++ assume.body.variables -- ignoreRegions
       case assert: Assert =>
-        Set(assert.body)
-      case memoryAssign: MemoryAssign =>
-        m = m -- getMemoryVariable(cmd, memoryAssign.mem, memoryAssign.index, memoryAssign.size, constProp, globals)
-        Set(memoryAssign.index, memoryAssign.value)
+        s ++ assert.body.variables -- ignoreRegions
+      case memoryStore: MemoryStore =>
+        val m = s -- getMemoryVariable(cmd, memoryStore.mem, memoryStore.index, memoryStore.size, constProp, globals)
+        m ++ memoryStore.index.variables ++ memoryStore.value.variables -- ignoreRegions
       case indirectCall: IndirectCall =>
-        if (ignoreRegions.contains(indirectCall.target)) return m
-        Set(indirectCall.target)
-      case assign: Assign =>
-        m = m - assign.lhs
-        Set(assign.rhs)
-      case _ => return m
-    }
-
-    exprs.foldLeft(m) {
-      (m, expr) => {
-        val vars = expr.variables.filter(!ignoreRegions.contains(_)).map { v => v: Taintable }
-        val memvars: Set[Taintable] = expr.loads.flatMap {
-          l => getMemoryVariable(cmd, l.mem, l.index, l.size, constProp, globals)
+        if (ignoreRegions.contains(indirectCall.target)) {
+          s
+        } else {
+          s + indirectCall.target -- ignoreRegions
         }
-        m.union(vars).union(memvars)
-      }
+      case assign: LocalAssign =>
+        val m = s - assign.lhs
+        m ++ assign.rhs.variables -- ignoreRegions
+      case memoryLoad: MemoryLoad =>
+        val m = s - memoryLoad.lhs
+        val memvar = getMemoryVariable(cmd, memoryLoad.mem, memoryLoad.index, memoryLoad.size, constProp, globals)
+        m ++ memvar ++ memoryLoad.index.variables -- ignoreRegions
+      case _ => s
     }
   }
 
@@ -96,10 +92,10 @@ class SummaryGenerator(
   private def toGamma(variable: Taintable): Option[BExpr] = {
     variable match {
       case variable: Register => Some(variable.toGamma)
-      case variable: LocalVar => None
+      case _: LocalVar => None
       case variable: GlobalVariable => Some(variable.toGamma)
       //case variable: LocalStackVariable => None
-      case variable: UnknownMemory => Some(FalseBLiteral)
+      case _: UnknownMemory => Some(FalseBLiteral)
     }
   }
 
@@ -184,4 +180,4 @@ class SummaryGenerator(
       }
     }
   }
-}
+}
\ No newline at end of file
diff --git a/src/main/scala/analysis/TaintAnalysis.scala b/src/main/scala/analysis/TaintAnalysis.scala
index d51eda374..d18e27d48 100644
--- a/src/main/scala/analysis/TaintAnalysis.scala
+++ b/src/main/scala/analysis/TaintAnalysis.scala
@@ -15,7 +15,7 @@ type Taintable = Variable | GlobalVariable /*| LocalStackVariable*/ | UnknownMem
 /**
  * A global variable in memory.
  */
-case class GlobalVariable(val mem: Memory, val address: BitVecLiteral, val size: Int, val identifier: String) {
+case class GlobalVariable(mem: Memory, address: BitVecLiteral, size: Int, identifier: String) {
   override def toString(): String = {
     s"GlobalVariable($mem, $identifier, $size, $address)"
   }
@@ -59,7 +59,10 @@ case class UnknownMemory() {
 }
 
 def getMemoryVariable(
-  n: CFGPosition, mem: Memory, expression: Expr, size: Int,
+  n: CFGPosition,
+  mem: Memory,
+  expression: Expr,
+  size: Int,
   constProp: Map[CFGPosition, Map[Variable, FlatElement[BitVecLiteral]]],
   globals: Map[BigInt, String],
 ): Option[GlobalVariable/*| LocalStackVariable*/] = {
@@ -69,25 +72,23 @@ def getMemoryVariable(
 
   expression match {
     // TODO assumes stack var accesses are all of the form R31 + n, or just R31, when in reality they could be more complex.
-    case BinaryExpr(BVADD, arg1, arg2) if arg1 == stackPointer => {
+    case BinaryExpr(BVADD, arg1, arg2) if arg1 == stackPointer =>
       evaluateExpression(arg2, constProp(n)) match
         // TODO This assumes that all stack variables are initialized local variables, which is not necessarily the case.
         //      If a stack address is read, without being assigned a value in this procedure, it will be
         //      assumed untainted, when in reality it may be UnknownMemory.
         //case Some(addr) => Some(LocalStackVariable(addr, size))
-        case Some(addr) => None
+        case Some(_) => None
         case None => None
-    }
     //case v: Variable if v == stackPointer => Some(LocalStackVariable(BitVecLiteral(0, 64), size))
     case v: Variable if v == stackPointer => None
-    case _ => {
+    case _ =>
       // TOOD check that the global access has the right size
       evaluateExpression(expression, constProp(n)) match
         case Some(addr) => globals.get(addr.value) match
           case Some(global) => Some(GlobalVariable(mem, addr, size, global))
           case None => None
         case None => None
-    }
   }
 }
 
@@ -100,8 +101,6 @@ trait TaintAnalysisFunctions(
   val edgelattice = EdgeFunctionLattice(valuelattice)
   import edgelattice.{IdEdge, ConstEdge}
 
-  private val stackPointer = Register("R31", 64)
-
   def edgesCallToEntry(call: DirectCall, entry: Procedure)(d: DL): Map[DL, EdgeFunction[TwoElement]] = {
     Map(d -> IdEdge())
   }
@@ -115,39 +114,34 @@ trait TaintAnalysisFunctions(
   }
 
   def edgesOther(n: CFGPosition)(d: DL): Map[DL, EdgeFunction[TwoElement]] = {
-    def containsValue(expression: Expr, value: Taintable): Boolean = {
-      value match {
-        case (v: Variable) => expression.variables.contains(v)
-        case v => {
-          expression.loads.map {
-            load => getMemoryVariable(n, load.mem, load.index, load.size, constProp, globals).getOrElse(UnknownMemory())
-          }.contains(v)
-        }
-      }
-    }
-
     (n match {
-      case Assign(variable, expression, _) => {
+      case LocalAssign(variable, expression, _) =>
         d match {
-          case Left(v) => {
-            if containsValue(expression, v) then Map(d -> IdEdge(), Left(variable) -> IdEdge())
-            else if v == variable then Map()
-            else Map(d -> IdEdge())
-          }
+          case Left(v: Variable) =>
+            if (expression.variables.contains(v)) {
+              Map(d -> IdEdge(), Left(variable) -> IdEdge())
+            } else if (v == variable) {
+              Map()
+            } else {
+              Map(d -> IdEdge())
+            }
           case _ => Map(d -> IdEdge())
         }
-      }
-      case MemoryAssign(mem, index, expression, _, size, _) => {
-        val variable = getMemoryVariable(n, mem, index, size, constProp, globals).getOrElse(UnknownMemory())
+      case MemoryStore(mem, index, expression, _, size, _) =>
+        val variable: Taintable = getMemoryVariable(n, mem, index, size, constProp, globals).getOrElse(UnknownMemory())
         d match {
-          case Left(v) => {
-            if containsValue(expression, v) then Map(d -> IdEdge(), Left(variable) -> IdEdge())
-            else if variable == v && v != UnknownMemory() then Map()
-            else Map(d -> IdEdge())
-          }
-          case Right(_) => Map(d -> IdEdge())
+          case Left(v: Variable) if expression.variables.contains(v) => Map(d -> IdEdge(), Left(variable) -> IdEdge())
+          case Left(v: GlobalVariable) if variable == v => Map()
+          case _ => Map(d -> IdEdge())
+        }
+      case MemoryLoad(lhs, mem, index, _, size, _) =>
+        val memoryVariable: Taintable = getMemoryVariable(n, mem, index, size, constProp, globals).getOrElse(UnknownMemory())
+        d match {
+          case Left(v: Variable) if index.variables.contains(v) => Map(d -> IdEdge(), Left(lhs) -> IdEdge())
+          case Left(v: Variable) if v == lhs => Map()
+          case Left(v: Taintable) if memoryVariable == v => Map(d -> IdEdge(), Left(lhs) -> IdEdge())
+          case _ => Map(d -> IdEdge())
         }
-      }
       case _ => Map(d -> IdEdge())
     }) ++ (
       d match
diff --git a/src/main/scala/analysis/UtilMethods.scala b/src/main/scala/analysis/UtilMethods.scala
index 2d6c54090..be32662f8 100644
--- a/src/main/scala/analysis/UtilMethods.scala
+++ b/src/main/scala/analysis/UtilMethods.scala
@@ -12,7 +12,6 @@ import util.Logger
   *   The evaluated expression (e.g. 0x69632)
   */
 def evaluateExpression(exp: Expr, constantPropResult: Map[Variable, FlatElement[BitVecLiteral]]): Option[BitVecLiteral] = {
-  Logger.debug(s"evaluateExpression: $exp")
   exp match {
     case binOp: BinaryExpr =>
       val lhs = evaluateExpression(binOp.arg1, constantPropResult)
@@ -73,8 +72,6 @@ def evaluateExpression(exp: Expr, constantPropResult: Map[Variable, FlatElement[
 }
 
 def evaluateExpressionWithSSA(exp: Expr, constantPropResult: Map[RegisterWrapperEqualSets, Set[BitVecLiteral]], n: CFGPosition, reachingDefs: Map[CFGPosition, (Map[Variable, Set[Assign]], Map[Variable, Set[Assign]])]): Set[BitVecLiteral] = {
-  Logger.debug(s"evaluateExpression: $exp")
-
   def apply(op: (BitVecLiteral, BitVecLiteral) => BitVecLiteral, a: Set[BitVecLiteral], b: Set[BitVecLiteral]): Set[BitVecLiteral] = {
     val res = for {
       x <- a
@@ -84,9 +81,7 @@ def evaluateExpressionWithSSA(exp: Expr, constantPropResult: Map[RegisterWrapper
   }
 
   def applySingle(op: BitVecLiteral => BitVecLiteral, a: Set[BitVecLiteral]): Set[BitVecLiteral] = {
-    val res = for {
-      x <- a
-    } yield op(x)
+    val res = for (x <- a) yield op(x)
     res
   }
 
@@ -139,6 +134,8 @@ def evaluateExpressionWithSSA(exp: Expr, constantPropResult: Map[RegisterWrapper
       Logger.debug("getUse: " + getUse(variable, n, reachingDefs))
       constantPropResult(RegisterWrapperEqualSets(variable, getUse(variable, n, reachingDefs)))
     case b: BitVecLiteral => Set(b)
+    case Repeat(_, body) => evaluateExpressionWithSSA(body, constantPropResult, n, reachingDefs)
+    case _: UninterpretedFunction => Set.empty
     case _ => throw RuntimeException("ERROR: CASE NOT HANDLED: " + exp + "\n")
   }
 }
@@ -153,21 +150,27 @@ def getUse(variable: Variable, node: CFGPosition, reachingDefs: Map[CFGPosition,
   out.getOrElse(variable, Set())
 }
 
-def unwrapExpr(expr: Expr): Set[Expr] = {
-  var buffers: Set[Expr] = Set()
+def unwrapExprToVar(expr: Expr): Option[Variable] = {
   expr match {
-    case e: Extract => buffers ++= unwrapExpr(e.body)
-    case e: SignExtend => buffers ++= unwrapExpr(e.body)
-    case e: ZeroExtend => buffers ++= unwrapExpr(e.body)
-    case repeat: Repeat => buffers ++= unwrapExpr(repeat.body)
-    case unaryExpr: UnaryExpr => buffers ++= unwrapExpr(unaryExpr.arg)
-    case binaryExpr: BinaryExpr =>
-      buffers ++= unwrapExpr(binaryExpr.arg1)
-      buffers ++= unwrapExpr(binaryExpr.arg2)
-    case memoryLoad: MemoryLoad =>
-      buffers += memoryLoad
-      buffers ++= unwrapExpr(memoryLoad.index)
+    case variable: Variable =>
+      Some(variable)
+    case e: Extract => unwrapExprToVar(e.body)
+    case e: SignExtend => unwrapExprToVar(e.body)
+    case e: ZeroExtend => unwrapExprToVar(e.body)
+    case repeat: Repeat => unwrapExprToVar(repeat.body)
+    case unaryExpr: UnaryExpr => unwrapExprToVar(unaryExpr.arg)
+    case binaryExpr: BinaryExpr => // TODO: incorrect
+      unwrapExprToVar(binaryExpr.arg1)
+      unwrapExprToVar(binaryExpr.arg2)
     case _ =>
+      None
+  }
+}
+
+def bitVectorOpToBigIntOp(op: BinOp, lhs: BigInt, rhs: BigInt): BigInt = {
+  op match {
+    case BVADD => lhs + rhs
+    case BVSUB => lhs - rhs
+    case _ => throw RuntimeException("Binary operation support not implemented: " + op)
   }
-  buffers
 }
\ No newline at end of file
diff --git a/src/main/scala/analysis/VSA.scala b/src/main/scala/analysis/VSA.scala
index 734f9bf11..4a9f11a14 100644
--- a/src/main/scala/analysis/VSA.scala
+++ b/src/main/scala/analysis/VSA.scala
@@ -10,19 +10,10 @@ import scala.collection.immutable
 import util.Logger
 
 /** ValueSets are PowerSet of possible values */
-trait Value {
-  val expr: BitVecLiteral
-}
-trait AddressValue extends Value {
-  val name: String
-}
+trait Value
 
-case class GlobalAddress(override val expr: BitVecLiteral, override val name: String) extends AddressValue {
-  override def toString: String = "GlobalAddress(" + expr + ", " + name + ")"
-}
-
-case class LocalAddress(override val expr: BitVecLiteral, override val name: String) extends AddressValue {
-  override def toString: String = "LocalAddress(" + expr + ", " + name + ")"
+case class AddressValue(region: MemoryRegion) extends Value {
+  override def toString: String = "Address(" + region + ")"
 }
 
 case class LiteralValue(expr: BitVecLiteral) extends Value {
@@ -30,12 +21,8 @@ case class LiteralValue(expr: BitVecLiteral) extends Value {
 }
 
 trait ValueSetAnalysis(program: Program,
-                        globals: Map[BigInt, String],
-                        externalFunctions: Map[BigInt, String],
-                        globalOffsets: Map[BigInt, BigInt],
-                        subroutines: Map[BigInt, String],
-                        mmm: MemoryModelMap,
-                        constantProp: Map[CFGPosition, Map[Variable, FlatElement[BitVecLiteral]]]) {
+                       mmm: MemoryModelMap,
+                       constantProp: Map[CFGPosition, Map[Variable, FlatElement[BitVecLiteral]]]) {
 
   val powersetLattice: PowersetLattice[Value] = PowersetLattice()
 
@@ -45,157 +32,112 @@ trait ValueSetAnalysis(program: Program,
 
   val lattice: MapLattice[CFGPosition, LiftedElement[Map[Variable | MemoryRegion, Set[Value]]], LiftLattice[Map[Variable | MemoryRegion, Set[Value]], mapLattice.type]] = MapLattice(liftedLattice)
 
-  val domain: Set[CFGPosition] = Set.empty ++ program
-
-  val first: Set[CFGPosition] = Set.empty ++ program
-
-  private val stackPointer = Register("R31", 64)
-  private val linkRegister = Register("R30", 64)
-  private val framePointer = Register("R29", 64)
-
-  private val ignoreRegions: Set[Expr] = Set(linkRegister, framePointer)
+  val first: Set[CFGPosition] = Set(program.mainProcedure)
 
   private val mallocVariable = Register("R0", 64)
 
-  private def resolveGlobalOffset(address: BigInt): String = {
-    val tableAddress = globalOffsets(address)
-    if (globals.contains(tableAddress)) {
-      globals(tableAddress)
-    } else if (subroutines.contains(tableAddress)) {
-      subroutines(tableAddress)
-    } else {
-      //throw Exception("Error: cannot resolve global offset " + address + " -> " + tableAddress)
-      "@ERROR"
-    }
-  }
-
-  def exprToRegion(expr: Expr, n: CFGPosition): Option[MemoryRegion] = {
-    expr match {
-      case binOp: BinaryExpr if binOp.arg1 == stackPointer =>
-        evaluateExpression(binOp.arg2, constantProp(n)) match {
-          case Some(b: BitVecLiteral) => mmm.findStackObject(b.value)
-          case None => None
-        }
-      case _ =>
-        evaluateExpression(expr, constantProp(n)) match {
-          case Some(b: BitVecLiteral) => mmm.findDataObject(b.value)
-          case None => None
-        }
-    }
-  }
-
-  private def getValueType(bitVecLiteral: BitVecLiteral): Value = {
-    if (externalFunctions.contains(bitVecLiteral.value)) {
-      LocalAddress(bitVecLiteral, externalFunctions(bitVecLiteral.value))
-    } else if (globals.contains(bitVecLiteral.value)) {
-      GlobalAddress(bitVecLiteral, globals(bitVecLiteral.value))
-    } else if (globalOffsets.contains(bitVecLiteral.value)) {
-      GlobalAddress(bitVecLiteral, resolveGlobalOffset(bitVecLiteral.value))
-    } else if (subroutines.contains(bitVecLiteral.value)) {
-      GlobalAddress(bitVecLiteral, subroutines(bitVecLiteral.value))
-    } else {
-      LiteralValue(bitVecLiteral)
-    }
+  def canCoerceIntoDataRegion(bitVecLiteral: BitVecLiteral, size: Int): Option[DataRegion] = {
+    mmm.findDataObject(bitVecLiteral.value)
   }
 
   /** Default implementation of eval.
     */
-  def eval(cmd: Command, s: Map[Variable | MemoryRegion, Set[Value]], n: CFGPosition): Map[Variable | MemoryRegion, Set[Value]] = {
-    Logger.debug(s"eval: $cmd")
-    Logger.debug(s"state: $s")
-    Logger.debug(s"node: $n")
-    var m = s
-    cmd match
-      case localAssign: Assign =>
-        localAssign.rhs match
-          case memoryLoad: MemoryLoad =>
-            exprToRegion(memoryLoad.index, n) match
-              case Some(r: MemoryRegion) =>
-                // this is an exception to the rule and only applies to data regions
-                evaluateExpression(memoryLoad.index, constantProp(n)) match
-                  case Some(bitVecLiteral: BitVecLiteral) =>
-                    m = m + (r -> Set(getValueType(bitVecLiteral)))
-                    m = m + (localAssign.lhs -> m(r))
-                    m
-                  case None =>
-                    m = m + (localAssign.lhs -> m(r))
-                    m
-              case None =>
-                Logger.debug("could not find region for " + localAssign)
-                m
-          case e: Expr =>
-            evaluateExpression(e, constantProp(n)) match {
-              case Some(bv: BitVecLiteral) =>
-                m = m + (localAssign.lhs -> Set(getValueType(bv)))
-                m
-              case None =>
-                Logger.debug("could not evaluate expression" + e)
-                m
+  def eval(cmd: Command, s: Map[Variable | MemoryRegion, Set[Value]]): Map[Variable | MemoryRegion, Set[Value]] = {
+    cmd match {
+      case directCall: DirectCall if directCall.target.name == "malloc" =>
+        val regions = mmm.nodeToRegion(cmd)
+        // malloc variable
+        s + (mallocVariable -> regions.map(r => AddressValue(r)))
+      case localAssign: LocalAssign =>
+        val regions = mmm.nodeToRegion(cmd)
+        if (regions.nonEmpty) {
+          s + (localAssign.lhs -> regions.map(r => AddressValue(r)))
+        } else {
+          evaluateExpression(localAssign.rhs, constantProp(cmd)) match {
+            case Some(bitVecLiteral: BitVecLiteral) =>
+              val possibleData = canCoerceIntoDataRegion(bitVecLiteral, 1)
+              if (possibleData.isDefined) {
+                s + (localAssign.lhs -> Set(AddressValue(possibleData.get)))
+              } else {
+                s + (localAssign.lhs -> Set(LiteralValue(bitVecLiteral)))
+              }
+            case None =>
+              // TODO this is not at all sound
+              val unwrapValue = unwrapExprToVar(localAssign.rhs)
+              unwrapValue match {
+                case Some(v: Variable) =>
+                  s + (localAssign.lhs -> s(v))
+                case None =>
+                  Logger.debug(s"Too Complex: ${localAssign.rhs}") // do nothing
+                  s
+              }
+          }
+        }
+      case load: MemoryLoad =>
+        val regions = mmm.nodeToRegion(cmd)
+        if (regions.nonEmpty) {
+          s + (load.lhs -> regions.map(r => AddressValue(r)))
+        } else {
+          // TODO this is blatantly incorrect but maintaining current functionality to start
+          val unwrapValue = unwrapExprToVar(load.index)
+          unwrapValue match {
+            case Some(v: Variable) =>
+              s + (load.lhs -> s(v))
+            case None =>
+              Logger.debug(s"Too Complex: ${load.index}") // do nothing
+              s
+          }
+        }
+      case store: MemoryStore =>
+        val regions = mmm.nodeToRegion(cmd)
+        evaluateExpression(store.value, constantProp(cmd)) match {
+          case Some(bitVecLiteral: BitVecLiteral) =>
+            val possibleData = canCoerceIntoDataRegion(bitVecLiteral, store.size)
+            if (possibleData.isDefined) {
+              s ++ regions.map(r => r -> Set(AddressValue(possibleData.get)))
+            } else {
+              s ++ regions.map(r => r -> Set(LiteralValue(bitVecLiteral)))
             }
-      case memAssign: MemoryAssign =>
-        memAssign.index match
-          case binOp: BinaryExpr =>
-            val region: Option[MemoryRegion] = exprToRegion(binOp, n)
-            region match
-              case Some(r: MemoryRegion) =>
-                val storeValue = memAssign.value
-                evaluateExpression(storeValue, constantProp(n)) match
-                  case Some(bitVecLiteral: BitVecLiteral) =>
-                    m = m + (r -> Set(getValueType(bitVecLiteral)))
-                    m
-                    /*
-                  // TODO constant prop returned BOT OR TOP. Merge regions because RHS could be a memory loaded address
-                  case variable: Variable =>
-                    s + (r -> s(variable))
-                    */
-                  case None =>
-                    storeValue.match {
-                      case v: Variable =>
-                        m = m + (r -> m(v))
-                        m
-                      case _ =>
-                        Logger.debug(s"Too Complex: $storeValue") // do nothing
-                        m
-                    }
+          case None =>
+            // TODO: unsound
+            val unwrapValue = unwrapExprToVar(store.value)
+            unwrapValue match {
+              case Some(v: Variable) =>
+                s ++ regions.map(r => r -> s(v))
               case None =>
-                Logger.debug("could not find region for " + memAssign)
-                m
-          case _ =>
-            m
+                Logger.debug(s"Too Complex: $store.value") // do nothing
+                s
+            }
+        }
       case _ =>
-        m
+        s
+    }
   }
 
-  /** Transfer function for state lattice elements.
+  /** Transfer function for state lattice elements. (Same as `localTransfer` for simple value analysis.)
     */
-  def localTransfer(n: CFGPosition, s: Map[Variable | MemoryRegion, Set[Value]]): Map[Variable | MemoryRegion, Set[Value]] =
-    if (IRWalk.procedure(n) == n) {
-      mmm.pushContext(n.asInstanceOf[Procedure].name)
-      s
-    } else if (IRWalk.lastInProc(IRWalk.procedure(n)) == n) {
-      mmm.popContext()
-      s
-    } else n match
+  def transferUnlifted(n: CFGPosition, s: Map[Variable | MemoryRegion, Set[Value]]): Map[Variable | MemoryRegion, Set[Value]] = {
+    n match {
+      case p: Procedure =>
+        mmm.pushContext(p.name)
+        s
+      case _: Return =>
+        mmm.popContext()
+        s
       case command: Command =>
-        eval(command, s, n)
+        eval(command, s)
       case _ =>
         s
-
-  /** Transfer function for state lattice elements. (Same as `localTransfer` for simple value analysis.)
-    */
-  def transferUnlifted(n: CFGPosition, s: Map[Variable | MemoryRegion, Set[Value]]): Map[Variable | MemoryRegion, Set[Value]] = localTransfer(n, s)
+    }
+  }
 }
 
 class ValueSetAnalysisSolver(
     program: Program,
-    globals: Map[BigInt, String],
-    externalFunctions: Map[BigInt, String],
-    globalOffsets: Map[BigInt, BigInt],
-    subroutines: Map[BigInt, String],
     mmm: MemoryModelMap,
     constantProp: Map[CFGPosition, Map[Variable, FlatElement[BitVecLiteral]]],
-) extends ValueSetAnalysis(program, globals, externalFunctions, globalOffsets, subroutines, mmm, constantProp)
-    with IRInterproceduralForwardDependencies
+) extends ValueSetAnalysis(program, mmm, constantProp)
+    with IRIntraproceduralForwardDependencies
     with Analysis[Map[CFGPosition, LiftedElement[Map[Variable | MemoryRegion, Set[Value]]]]]
     with WorklistFixpointSolverWithReachability[CFGPosition, Map[Variable | MemoryRegion, Set[Value]], MapLattice[Variable | MemoryRegion, Set[Value], PowersetLattice[Value]]] {
 
diff --git a/src/main/scala/analysis/VariableDependencyAnalysis.scala b/src/main/scala/analysis/VariableDependencyAnalysis.scala
index ed1ed1eaf..643bf5b6f 100644
--- a/src/main/scala/analysis/VariableDependencyAnalysis.scala
+++ b/src/main/scala/analysis/VariableDependencyAnalysis.scala
@@ -37,46 +37,50 @@ trait ProcVariableDependencyAnalysisFunctions(
 
   def edgesCallToAfterCall(call: DirectCall, aftercall: Command)(d: DL): Map[DL, EdgeFunction[Set[Taintable]]] = {
     d match {
-      case Left(v) => varDepsSummaries.get(call.target).flatMap(_.get(v).map( _.foldLeft(Map[DL, EdgeFunction[Set[Taintable]]]()) {
-        (m, d) => m + (Left(d) -> IdEdge())
-      })).getOrElse(Map())
+      case Left(v) =>
+        varDepsSummaries.get(call.target).flatMap {
+          _.get(v).map {
+            _.foldLeft(Map[DL, EdgeFunction[Set[Taintable]]]()) {
+              (m, d) => m + (Left(d) -> IdEdge())
+            }
+          }
+        }.getOrElse(Map())
       case Right(_) => Map(d -> IdEdge())
     }
   }
 
   def edgesOther(n: CFGPosition)(d: DL): Map[DL, EdgeFunction[Set[Taintable]]] = {
-    def getVars(expression: Expr): Set[Taintable] = {
-      expression.variables.map { v => v: Taintable } ++
-      expression.loads.map { l => getMemoryVariable(n, l.mem, l.index, l.size, constProp, globals).getOrElse(UnknownMemory()) }
-    }
-
     if n == procedure then d match {
       // At the start of the procedure, no variables should depend on anything but themselves.
       case Left(_) => Map()
-      case Right(_) => {
+      case Right(_) =>
         variables.foldLeft(Map(d -> IdEdge())) {
           (m: Map[DL, EdgeFunction[Set[Taintable]]], v) => m + (Left(v) -> ConstEdge(Set(v)))
         }
-      }
     } else n match {
-      case Assign(assigned, expression, _) => {
-        val vars = getVars(expression) -- ignoredRegisters
+      case LocalAssign(assigned, expression, _) =>
+        val vars = expression.variables -- ignoredRegisters
         d match {
-          case Left(v) if vars.contains(v) => Map(d -> IdEdge(), Left(assigned) -> IdEdge())
-          case Left(v) if v == assigned => Map()
+          case Left(v: Variable) if vars.contains(v) => Map(d -> IdEdge(), Left(assigned) -> IdEdge())
+          case Left(v: Variable) if v == assigned => Map()
           case _ => Map(d -> IdEdge())
         }
-      }
-      case MemoryAssign(mem, index, expression, _, size, _) => {
-        val assigned = getMemoryVariable(n, mem, index, size, constProp, globals).getOrElse(UnknownMemory())
-
-        val vars = getVars(expression) -- ignoredRegisters
+      case MemoryStore(mem, index, expression, _, size, _) =>
+        val assigned: Taintable = getMemoryVariable(n, mem, index, size, constProp, globals).getOrElse(UnknownMemory())
+        val vars = expression.variables -- ignoredRegisters
         d match {
-          case Left(v) if vars.contains(v) => Map(d -> IdEdge(), Left(assigned) -> IdEdge())
-          case Left(v) if v == assigned && v != UnknownMemory() => Map()
+          case Left(v: Variable) if vars.contains(v) => Map(d -> IdEdge(), Left(assigned) -> IdEdge())
+          case Left(v: GlobalVariable) if v == assigned => Map()
+          case _ => Map(d -> IdEdge())
+        }
+      case MemoryLoad(lhs, mem, index, _, size, _) =>
+        val memoryVariable: Taintable = getMemoryVariable(n, mem, index, size, constProp, globals).getOrElse(UnknownMemory())
+        val vars: Set[Taintable] = Set(memoryVariable) ++ index.variables -- ignoredRegisters
+        d match {
+          case Left(v) if vars.contains(v) => Map(d -> IdEdge(), Left(lhs) -> IdEdge())
+          case Left(v) if v == lhs => Map()
           case _ => Map(d -> IdEdge())
         }
-      }
       case _ => Map(d -> IdEdge())
     }
   }
@@ -97,7 +101,7 @@ class ProcVariableDependencyAnalysis(
 {
   override def phase2Init: Set[Taintable] = Set(Register("R0", 64))
 
-  override val startNode: CFGPosition = procedure
+  override def start: CFGPosition = procedure
 }
 
 class VariableDependencyAnalysis(
@@ -107,7 +111,7 @@ class VariableDependencyAnalysis(
   constProp: Map[CFGPosition, Map[Variable, FlatElement[BitVecLiteral]]],
   scc: mutable.ListBuffer[mutable.Set[Procedure]],
 ) {
-  val varDepVariables: Set[analysis.Taintable] = 0.to(28).map { n =>
+  val varDepVariables: Set[Taintable] = 0.to(28).map { n =>
     Register(s"R$n", 64)
   }.toSet ++ specGlobals.map { g =>
     analysis.GlobalVariable(dsl.mem, BitVecLiteral(g.address, 64), g.size, g.name)
diff --git a/src/main/scala/analysis/WriteToAnalysis.scala b/src/main/scala/analysis/WriteToAnalysis.scala
new file mode 100644
index 000000000..cc4e3eba2
--- /dev/null
+++ b/src/main/scala/analysis/WriteToAnalysis.scala
@@ -0,0 +1,48 @@
+package analysis
+
+import ir.{DirectCall, LocalAssign, MemoryLoad, MemoryStore, Procedure, Program, Register}
+
+import scala.collection.mutable
+
+class WriteToAnalysis(program: Program) extends Analysis[Map[Procedure, Set[Register]]] {
+
+  val writesTo: mutable.Map[Procedure, Set[Register]] = mutable.Map()
+  val mallocRegister = Register("R0", 64)
+  val paramRegisters: Set[Register] = Set(
+    mallocRegister,
+    Register("R1", 64),
+    Register("R2", 64),
+    Register("R3", 64),
+    Register("R4", 64),
+    Register("R5", 64),
+    Register("R6", 64),
+    Register("R7", 64),
+  )
+
+  def getWritesTos(proc: Procedure): Set[Register] = {
+    if writesTo.contains(proc) then
+      writesTo(proc)
+    else
+      val writtenTo: mutable.Set[Register] = mutable.Set()
+      proc.blocks.foreach { block =>
+        block.statements.foreach {
+          case LocalAssign(variable: Register, _, _) if paramRegisters.contains(variable) =>
+            writtenTo.add(variable)
+          case MemoryLoad(lhs: Register, _, _, _, _, _) if paramRegisters.contains(lhs) =>
+            writtenTo.add(lhs)
+          case DirectCall(target, _) if target.name == "malloc" =>
+            writtenTo.add(mallocRegister)
+          case DirectCall(target, _) if program.procedures.contains(target) =>
+            writtenTo.addAll(getWritesTos(target))
+          case _ =>
+        }
+    }
+
+      writesTo.update(proc, writtenTo.toSet)
+      writesTo(proc)
+  }
+
+  def analyze(): Map[Procedure, Set[Register]] =
+    program.procedures.foreach(getWritesTos)
+    writesTo.toMap
+}
diff --git a/src/main/scala/analysis/data_structure_analysis/DataStructureAnalysis.scala b/src/main/scala/analysis/data_structure_analysis/DataStructureAnalysis.scala
new file mode 100644
index 000000000..8f46c4173
--- /dev/null
+++ b/src/main/scala/analysis/data_structure_analysis/DataStructureAnalysis.scala
@@ -0,0 +1,218 @@
+package analysis.data_structure_analysis
+
+import analysis.*
+import ir.*
+import specification.{ExternalFunction, SpecGlobal, SymbolTableEntry}
+
+import scala.collection.mutable
+
+/**
+ * Data Structure Analysis
+ * Performs all phases of DSA and stores the results in member variables
+ * local, bottom-up, top-down results in member variables locals, bu and td respectively.
+ * @param program program to be analysed
+ * @param symResults result of symbolic access analysis
+ * @param constProp
+ * @param globals
+ * @param globalOffsets
+ * @param externalFunctions
+ * @param reachingDefs
+ * @param writesTo mapping from procedures to registers they change
+ * @param params mapping from procedures to their parameters
+ */
+class DataStructureAnalysis(program: Program,
+                            symResults: Map[CFGPosition, Map[SymbolicAddress, TwoElement]],
+                            constProp: Map[CFGPosition, Map[Variable, FlatElement[BitVecLiteral]]],
+                            globals: Set[SymbolTableEntry],
+                            globalOffsets: Map[BigInt, BigInt],
+                            externalFunctions: Set[ExternalFunction],
+                            reachingDefs: Map[CFGPosition, Map[Variable, Set[CFGPosition]]],
+                            writesTo: Map[Procedure, Set[Register]],
+                            params: Map[Procedure, Set[Variable]]
+         ) extends Analysis[Map[Procedure, Graph]] {
+
+  val local: mutable.Map[Procedure, Graph] = mutable.Map()
+  val bottomUp: mutable.Map[Procedure, Graph] = mutable.Map()
+  val topDown: mutable.Map[Procedure, Graph] = mutable.Map()
+
+  private val stackPointer = Register("R31", 64)
+  private val returnPointer = Register("R30", 64)
+  private val framePointer = Register("R29", 64)
+
+  private val ignoreRegisters: Set[Variable] = Set(stackPointer, returnPointer, framePointer)
+
+  private def findLeaf(procedure: Procedure): Set[Procedure] = {
+    val succ = CallGraph.succ(procedure)
+    if (succ.isEmpty) {
+      Set(procedure)
+    } else {
+      succ.flatMap(findLeaf)
+    }
+  }
+
+  private var visited = Set[Procedure]()
+  private val queue = mutable.Queue[Procedure]()
+
+  override def analyze(): Map[Procedure, Graph] = {
+    var domain: Set[Procedure] = Set(program.mainProcedure)
+    val stack: mutable.Stack[Procedure] = mutable.Stack()
+    stack.pushAll(program.mainProcedure.calls)
+
+    // calculate the procedures used in the program
+    while (stack.nonEmpty) {
+      val current = stack.pop()
+      domain += current
+      stack.pushAll(current.calls.diff(domain))
+    }
+
+    // perform local analysis on all procs
+    domain.foreach { proc =>
+      val dsg = LocalPhase(proc, symResults, constProp, globals, globalOffsets, externalFunctions, reachingDefs, writesTo, params).analyze()
+
+      local.update(proc, dsg)
+      bottomUp.update(proc, dsg.cloneSelf())
+    }
+
+    val leafNodes = findLeaf(program.mainProcedure)
+
+    leafNodes.foreach { proc =>
+      assert(local(proc).callsites.isEmpty)
+      visited += proc
+      //val preds: Set[Procedure] = CallGraph.pred(proc)
+      queue.enqueueAll(CallGraph.pred(proc).diff(visited).intersect(domain))
+    }
+
+    // bottom up phase
+    while queue.nonEmpty do
+      var proc = queue.dequeue()
+      while !local.contains(proc) && queue.nonEmpty do proc = queue.dequeue()
+      visited += proc
+      if local.contains(proc) then
+        queue.enqueueAll(CallGraph.pred(proc).diff(visited))
+        val buGraph = bottomUp(proc)
+
+        buGraph.callsites.foreach { callSite =>
+          val callee = callSite.proc
+          val calleeGraph = local(callee) //.cloneSelf()
+          assert(buGraph.globalMapping.keySet.equals(calleeGraph.globalMapping.keySet))
+          assert(calleeGraph.formals.keySet.diff(ignoreRegisters).equals(callSite.paramCells.keySet))
+          calleeGraph.globalMapping.values.foreach { field =>
+            val newNode = calleeGraph.find(field.node).node
+            newNode.cloneNode(calleeGraph, buGraph)
+          }
+
+          calleeGraph.formals.foreach { (variable, slice) =>
+            if (!ignoreRegisters.contains(variable)) {
+              assert(callSite.paramCells.contains(variable))
+              val node = calleeGraph.find(slice).node
+              node.cloneNode(calleeGraph, buGraph)
+            }
+          }
+
+          assert(writesTo(callee).equals(callSite.returnCells.keySet))
+          writesTo(callee).foreach { reg =>
+            assert(callSite.returnCells.contains(reg))
+            val returnCells = calleeGraph.getCells(IRWalk.lastInProc(callee).get, reg).map(calleeGraph.find)
+            assert(returnCells.nonEmpty)
+            returnCells.foreach { slice =>
+              val node = calleeGraph.find(slice).node
+              node.cloneNode(calleeGraph, buGraph)
+            }
+          }
+
+          //          assert(calleeGraph.formals.isEmpty || buGraph.varToCell(begin(callee)).equals(calleeGraph.formals))
+          calleeGraph.globalMapping.foreach {
+            case (range: AddressRange, Field(node: Node, offset: BigInt)) =>
+              val field = calleeGraph.find(node)
+              buGraph.mergeCells(
+                buGraph.globalMapping(range).node.getCell(buGraph.globalMapping(range).offset),
+                field.node.getCell(field.offset + offset)
+              )
+          }
+
+          if (buGraph.varToCell.contains(callee)) {
+            buGraph.varToCell(callee).keys.foreach { variable =>
+              if (!ignoreRegisters.contains(variable)) {
+                val formal = buGraph.varToCell(callee)(variable)
+                buGraph.mergeCells(buGraph.adjust(formal), buGraph.adjust(callSite.paramCells(variable)))
+              }
+            }
+          }
+
+          writesTo(callee).foreach { reg =>
+            val returnCells = buGraph.getCells(IRWalk.lastInProc(callee).get, reg)
+            //              assert(returnCells.nonEmpty)
+            returnCells.foldLeft(buGraph.adjust(callSite.returnCells(reg))) { (c, ret) =>
+              buGraph.mergeCells(c, buGraph.adjust(ret))
+            }
+          }
+        }
+        buGraph.collectNodes()
+    // bottom up phase finished
+    // clone bu graphs to top-down graphs
+    domain.foreach { proc =>
+      topDown.update(proc, bottomUp(proc).cloneSelf())
+    }
+
+    queue.enqueue(program.mainProcedure)
+    visited = Set()
+
+    // top-down phase
+    while (queue.nonEmpty) {
+      val proc = queue.dequeue()
+      visited += proc
+      queue.enqueueAll(CallGraph.succ(proc).diff(visited))
+      val callersGraph = topDown(proc)
+      callersGraph.callsites.foreach { callSite =>
+        val callee = callSite.proc
+        val calleesGraph = topDown(callee)
+        assert(callersGraph.globalMapping.keySet.equals(calleesGraph.globalMapping.keySet))
+
+        callersGraph.globalMapping.values.foreach { field =>
+          val oldNode = field.node
+          val node = callersGraph.find(oldNode).node
+          node.cloneNode(callersGraph, calleesGraph)
+        }
+
+        callSite.paramCells.values.foreach { slice =>
+          val node = callersGraph.find(slice).node
+          node.cloneNode(callersGraph, calleesGraph)
+        }
+
+        callSite.returnCells.values.foreach { slice =>
+          val node = callersGraph.find(slice).node
+          node.cloneNode(callersGraph, callersGraph)
+        }
+
+        callersGraph.globalMapping.foreach { case (range: AddressRange, Field(oldNode, internal)) =>
+          //              val node = callersGraph
+          val field = callersGraph.find(oldNode)
+          calleesGraph.mergeCells(
+            calleesGraph.globalMapping(range).node.getCell(calleesGraph.globalMapping(range).offset),
+            field.node.getCell(field.offset + internal)
+          )
+        }
+
+        callSite.paramCells.keySet.foreach { variable =>
+          val paramCells = calleesGraph.getCells(callSite.call, variable) // wrong param offset
+          paramCells.foldLeft(calleesGraph.adjust(calleesGraph.formals(variable))) {
+            (cell, slice) => calleesGraph.mergeCells(calleesGraph.adjust(slice), cell)
+          }
+        }
+
+        if (calleesGraph.varToCell.contains(callSite.call)) {
+          calleesGraph.varToCell(callSite.call).foreach { (variable, oldSlice) =>
+            val slice = callersGraph.find(oldSlice)
+            val returnCells = calleesGraph.getCells(IRWalk.lastInProc(callee).get, variable)
+            returnCells.foldLeft(calleesGraph.adjust(slice)) {
+              (c, retCell) => calleesGraph.mergeCells(c, calleesGraph.adjust(retCell))
+            }
+          }
+        }
+      }
+      callersGraph.collectNodes()
+    }
+    topDown.toMap
+
+  }
+}
diff --git a/src/main/scala/analysis/data_structure_analysis/Graph.scala b/src/main/scala/analysis/data_structure_analysis/Graph.scala
new file mode 100644
index 000000000..a7cae0af4
--- /dev/null
+++ b/src/main/scala/analysis/data_structure_analysis/Graph.scala
@@ -0,0 +1,747 @@
+package analysis.data_structure_analysis
+
+import analysis.FlatElement
+import analysis.solvers.DSAUnionFindSolver
+import analysis.evaluateExpression
+import cfg_visualiser.*
+import ir.*
+import specification.{ExternalFunction, SymbolTableEntry}
+
+import scala.collection.mutable
+import scala.collection.mutable.ArrayBuffer
+import scala.util.control.Breaks.{break, breakable}
+
+/**
+  * Data Structure Graph for DSA
+  *
+  * @param proc procedure of DSG
+  * @param constProp
+  * @param varToSym mapping flow-sensitive (position sensitive) mapping from registers to their set of symbolic accesses
+  * @param globals
+  * @param globalOffsets
+  * @param externalFunctions
+  * @param reachingDefs
+  * @param writesTo
+  * @param params
+  */
+class Graph(val proc: Procedure,
+            constProp: Map[CFGPosition, Map[Variable, FlatElement[BitVecLiteral]]],
+            varToSym: Map[CFGPosition, Map[Variable, Set[SymbolicAddress]]],
+            globals: Set[SymbolTableEntry],
+            globalOffsets: Map[BigInt, BigInt],
+            externalFunctions: Set[ExternalFunction],
+            val reachingDefs: Map[CFGPosition, Map[Variable, Set[CFGPosition]]],
+            val writesTo: Map[Procedure, Set[Register]],
+            val params: Map[Procedure, Set[Variable]]
+           ) {
+
+  // DSNodes owned by this graph, only updated once analysis is done,
+  val nodes: mutable.Set[Node] = mutable.Set()
+
+  // Points-to relations in this graph, only updated once the analysis is done,
+  val pointsto: mutable.Map[Cell, Slice] = mutable.Map()
+
+  // represent callees in proc
+  val callsites: mutable.Set[CallSite] = mutable.Set()
+
+  private val mallocRegister = Register("R0", 64)
+
+  // collect all stack access and their maximum accessed size
+  // BigInt is the offset of the stack position and Int is it's size
+  private val stackAccesses: Map[BigInt, Int] = {
+    computeDomain(IntraProcIRCursor, Set(proc)).toSeq.sortBy(_.toShortString).foldLeft(Map[BigInt, Int]()) {
+      (results, pos) =>
+        pos match {
+          case LocalAssign(_, expr, _) =>
+            visitStackAccess(pos, expr, 0).foldLeft(results) {
+              (res, access) =>
+                if !res.contains(access.offset) || (res.getOrElse(access.offset, -1) < access.size) then
+                  res + (access.offset -> access.size)
+                else
+                  res
+            }
+          case MemoryStore(_, index, _, _, size, _) =>
+            visitStackAccess(pos, index, size).foldLeft(results) {
+              (res, access) =>
+                if !res.contains(access.offset) || (res.getOrElse(access.offset, -1) < access.size) then
+                  res + (access.offset -> access.size)
+                else
+                  res
+            }
+          case MemoryLoad(_, _, index, _, size, _) =>
+            visitStackAccess(pos, index, size).foldLeft(results) {
+              (res, access) =>
+                if !res.contains(access.offset) || (res.getOrElse(access.offset, -1) < access.size) then
+                  res + (access.offset -> access.size)
+                else
+                  res
+            }
+          case _ => results
+        }
+    }
+  }
+
+  private case class StackAccess(offset: BigInt, size: Int)
+
+  private def visitStackAccess(pos: CFGPosition, index: Expr, size: Int): Set[StackAccess] = {
+    assert(size % 8 == 0)
+    val byteSize = size / 8
+    index match
+      case BinaryExpr(_, arg1: Variable, arg2) if varToSym.contains(pos) && varToSym(pos).contains(arg1) &&
+        evaluateExpression(arg2, constProp(pos)).isDefined =>
+        val offset = evaluateExpression(arg2, constProp(pos)).get.value
+        varToSym(pos)(arg1).flatMap {
+          case SymbolicAddress(_, _: StackLocation, symOffset) => // only consider stack accesses
+            Some(StackAccess(offset + symOffset, byteSize))
+          case _ => None
+        }
+      case arg: Variable if varToSym.contains(pos) && varToSym(pos).contains(arg) =>
+        varToSym(pos)(arg).flatMap {
+          case SymbolicAddress(_, _: StackLocation, offset) =>
+            //                 createStackMapping(pos.toShortString, offset, m, byteSize)
+            Some(StackAccess(offset, byteSize))
+          case _ =>
+            None
+        }
+      case _ => Set.empty
+  }
+
+  // this is the mapping from offsets/positions on the stack to their representative DS nodes
+  val stackMapping: mutable.Map[BigInt, Node] = mutable.Map()
+  private var lastOffset: BigInt = -1
+  private var nextValidOffset: BigInt = 0
+  stackAccesses.keys.toSeq.sorted.foreach { offset =>
+    val byteSize = stackAccesses(offset)
+    if offset >= nextValidOffset then
+      val node = Node(Some(this), byteSize)
+      node.allocationRegions.add(StackLocation(s"Stack_${proc}_$offset", proc, byteSize))
+      node.flags.stack = true
+      node.addCell(0, byteSize)
+      stackMapping.update(offset, node)
+      lastOffset = offset
+    else
+      val diff = nextValidOffset - offset
+      stackMapping(lastOffset).addCell(diff, byteSize)
+    nextValidOffset = offset + byteSize
+  }
+
+  private val swappedOffsets = globalOffsets.map(_.swap)
+
+  // creates the globals from the symbol tables
+  val globalMapping = mutable.Map[AddressRange, Field]()
+  globals.foreach { global =>
+    val node = Node(Some(this), global.size)
+    node.allocationRegions.add(DataLocation(global.name, global.address, global.size / 8))
+    node.flags.global = true
+    node.flags.incomplete = true
+    globalMapping.update(AddressRange(global.address, global.address + global.size / 8), Field(node, 0))
+  }
+
+  // creates a global for each relocation entry in the symbol table
+  // the global corresponding to the relocated address points to the global corresponding to the original address
+  globals.foreach { global =>
+    var address = global.address
+    breakable {
+      while (swappedOffsets.contains(address)) {
+        val relocatedAddress = swappedOffsets(address)
+        if relocatedAddress == address then
+          break
+
+        var field: BigInt = 0
+        val node: Node = isGlobal(relocatedAddress) match
+          case Some(value) =>
+            field = relocatedAddress - value.addressRange.start
+            val node = value.field.node
+            node.addCell(field, 8)
+            node
+
+          case None =>
+            val node = Node(Some(this))
+            node.allocationRegions.add(DataLocation(s"Relocated_$relocatedAddress", relocatedAddress, 8))
+            node.flags.global = true
+            node.flags.incomplete = true
+            globalMapping.update(AddressRange(relocatedAddress, relocatedAddress + 8), Field(node, 0))
+            node
+
+        node.cells(field).pointee = Some(Slice(isGlobal(address).get.field.node.cells(0), 0))
+        address = relocatedAddress
+      }
+    }
+  }
+
+  externalFunctions.foreach { external =>
+    val node = Node(Some(this))
+    node.allocationRegions.add(DataLocation(external.name, external.offset, 0))
+    node.flags.global = true
+    node.flags.incomplete = true
+    globalMapping.update(AddressRange(external.offset, external.offset), Field(node, 0))
+  }
+
+  // determine if an address is a global and return the corresponding global if it is.
+  def isGlobal(address: BigInt): Option[DSAGlobal] = {
+    var global: Option[DSAGlobal] = None
+    breakable {
+      for ((range, field) <- globalMapping) {
+        if address >= range.start && (address < range.end || (range.start == range.end && range.end == address)) then
+          global = Some(DSAGlobal(range, field))
+          break
+      }
+    }
+    global
+  }
+
+  def getCells(pos: CFGPosition, arg: Variable): Set[Slice] = {
+    if (reachingDefs(pos).contains(arg)) {
+      reachingDefs(pos)(arg).map(definition => varToCell(definition)(arg))
+    } else {
+      Set(formals(arg))
+    }
+  }
+
+
+  /**
+    * collects all the nodes that are currently in the DSG and updates nodes member variable
+    */
+  def collectNodes(): Unit = {
+    nodes.clear()
+    pointsto.clear()
+    nodes.addAll(formals.values.map(n => find(n.cell.node.get).node))
+    varToCell.values.foreach {
+      value => nodes.addAll(value.values.map(n => find(n.cell.node.get).node))
+    }
+    nodes.addAll(stackMapping.values.map(n => find(n).node))
+    nodes.addAll(globalMapping.values.map(n => find(n.node).node))
+
+    val queue: mutable.Queue[Node] = mutable.Queue()
+    queue.enqueueAll(nodes)
+    while (queue.nonEmpty) {
+      val cur = queue.dequeue()
+      cur.cells.values.foreach { cell =>
+        if (cell.pointee.isDefined) {
+          val node = find(cell.getPointee.node).node
+          if !nodes.contains(node) then
+            nodes.add(node)
+            queue.enqueue(node)
+          assert(!pointsto.contains(cell))
+          pointsto.update(cell, find(cell.getPointee))
+        }
+      }
+    }
+  }
+
+  def toDot: String = {
+    collectNodes()
+
+    val structs = ArrayBuffer[DotStruct]()
+    val arrows = ArrayBuffer[StructArrow]()
+
+    nodes.foreach { n =>
+      structs.append(DotStruct(n.id.toString, n.toString, Some(n.cells.keys.map(o => o.toString))))
+    }
+
+    formals.keys.foreach { variable =>
+      var varName = variable.name
+      if (varName.startsWith("#")) {
+        varName = s"LocalVar_${varName.drop(1)}"
+      }
+      structs.append(DotStruct(s"Formal_${varName}", s"Formal_${varName}", None))
+    }
+
+    pointsto.foreach { (cell, pointee) =>
+      val pointerID = cell.node.get.id.toString
+      val pointerOffset = cell.offset.toString
+      arrows.append(StructArrow(DotStructElement(pointerID, Some(pointerOffset)), DotStructElement(pointee.node.id.toString, Some(pointee.cell.offset.toString)), pointee.internalOffset.toString))
+    }
+
+    formals.foreach { (variable, slice) =>
+      val value = find(slice)
+      arrows.append(StructArrow(DotStructElement(s"Formal_${variable.name}", None), DotStructElement(value.node.id.toString, Some(value.cell.offset.toString)), value.internalOffset.toString))
+    }
+
+    varToCell.foreach { (pos, mapping) =>
+      var id = pos match {
+        case p: Procedure => p.name
+        case b: Block => b.label
+        case c: Command => c.label.getOrElse("")
+      }
+      if (id.startsWith("%")) {
+        id = id.drop(1)
+      }
+      mapping.foreach { (variable, slice) =>
+        var varName = variable.name
+        if (varName.startsWith("#")) {
+          varName = s"LocalVar_${varName.drop(1)}"
+        }
+        structs.append(DotStruct(s"SSA_${id}_$varName", s"SSA_${pos}_$varName", None, false))
+        val value = find(slice)
+        arrows.append(StructArrow(DotStructElement(s"SSA_${id}_$varName", None), DotStructElement(value.node.id.toString, Some(value.cell.offset.toString)), value.internalOffset.toString))
+      }
+    }
+
+    globalMapping.foreach { (range, field) =>
+      structs.append(DotStruct(s"Global_${range.start}_${range.end}", s"Global_$range", None))
+      val node = find(field.node).node
+      val offset = field.offset + find(field.node).offset
+      val cellOffset = node.getCell(offset).offset
+      val internalOffset = offset - cellOffset
+      arrows.append(StructArrow(DotStructElement(s"Global_${range.start}_${range.end}", None), DotStructElement(node.id.toString, Some(cellOffset.toString)), internalOffset.toString))
+    }
+
+    stackMapping.foreach { (offset, dsn) =>
+      structs.append(DotStruct(s"Stack_$offset", s"Stack_$offset", None))
+      val node = find(dsn).node
+      val nodeOffset = find(dsn).offset
+      val cellOffset = node.getCell(nodeOffset).offset
+      val internalOffset = nodeOffset - cellOffset
+      arrows.append(StructArrow(DotStructElement(s"Stack_$offset", None), DotStructElement(node.id.toString, Some(cellOffset.toString)), internalOffset.toString))
+    }
+
+    StructDotGraph(proc.name, structs, arrows).toDotString
+  }
+
+
+  /**
+    * Collapses the node causing it to lose field sensitivity
+    */
+  def collapseNode(n: Node): Node = {
+    val (term, _) = solver.findWithOffset(n.term)
+    val node: Node = term.node
+
+    if (!(n.collapsed || find(n).node.collapsed)) {
+      val collapsedNode: Node = Node(n.graph)
+      val collapsedCell = Cell(Some(collapsedNode), 0)
+
+      n.flags.collapsed = true
+      collapsedNode.flags.collapsed = true
+
+      var pointeeInternalOffset: BigInt = 0
+      var pointToItself = false
+      val cells = node.cells.values
+      var cell = cells.tail.foldLeft(adjust(cells.head.getPointee)) { (c, cell) =>
+        val pointee = cell.pointee
+        if (pointee.isDefined && adjust(cell.getPointee) == cell) {
+          pointToItself = true
+          c
+        } else if (pointee.isDefined) {
+          val slice = cell.getPointee
+          if (slice.internalOffset > pointeeInternalOffset) {
+            pointeeInternalOffset = slice.internalOffset
+          }
+          mergeCells(c, adjust(slice))
+        } else {
+          c
+        }
+      }
+
+      if (pointToItself) {
+        cell = mergeCells(cell, collapsedCell)
+      }
+
+      collapsedCell.pointee = Some(Slice(collapsedCell, 0))
+
+      assert(collapsedNode.cells.size == 1)
+
+      collapsedNode.children.addAll(node.children)
+      collapsedNode.children += (node -> 0)
+      collapsedNode.allocationRegions.addAll(node.allocationRegions) // add regions and flags of node 1 to node 2
+      collapsedNode.flags.join(node.flags)
+
+      solver.unify(n.term, collapsedNode.term, 0)
+
+      collapsedNode
+    } else {
+      assert(find(n).node.collapsed)
+      find(n).node
+    }
+  }
+
+
+  /**
+    * this function merges all the overlapping cells in the given node
+    * The node DOESN'T lose field sensitivity after this
+    */
+  def selfCollapse(node: Node): Unit = {
+    var lastOffset: BigInt = -1
+    var lastAccess: BigInt = -1
+    val removed = mutable.Set[BigInt]()
+    val sortedOffsets = node.cells.keys.toSeq.sorted
+    sortedOffsets.foreach { offset =>
+      val cell = node.cells(offset)
+      if (lastOffset + lastAccess > offset) {
+        val result = mergeNeighbours(node.cells(lastOffset), cell)
+        removed.add(offset)
+        lastAccess = result.largestAccessedSize
+      } else {
+        lastOffset = offset
+        lastAccess = cell.largestAccessedSize
+      }
+    }
+    removed.foreach(node.cells.remove)
+  }
+
+  /**
+    * merges two neighbouring cells into one
+    */
+  private def mergeNeighbours(cell1: Cell, cell2: Cell): Cell = {
+    require(cell1.node.equals(cell2.node) && cell1.offset < cell2.offset)
+    if (cell2.pointee.isDefined) {
+      if (cell1.pointee.isDefined) {
+        val slice1 = cell1.getPointee
+        val slice2 = cell2.getPointee
+        val result = mergeCells(adjust(slice1), adjust(slice2))
+        cell1.pointee = Some(Slice(result, slice2.internalOffset.max(slice1.internalOffset)))
+      } else {
+        cell1.pointee = cell2.pointee
+      }
+    }
+    val internalOffsetChange = cell2.offset - cell1.offset
+    cell2.node.get.cells.remove(cell2.offset)
+    cell1.growSize((cell2.offset - cell1.offset).toInt + cell2.largestAccessedSize) // might cause another collapse
+    cell1
+  }
+
+  //  private val parent = mutable.Map[DSC, DSC]()
+  val solver: DSAUnionFindSolver = DSAUnionFindSolver()
+
+  /**
+    * wrapper for find functionality of the union-find
+    * @param node the node to perform find on
+    * @return a field which is the tuple (parent node of the input node, starting offset of the input node in its parent)
+    */
+  def find(node: Node): Field = {
+    val (n, offset) = solver.findWithOffset(node.term)
+    val resultNode = n.node
+    Field(resultNode, offset)
+  }
+
+  /**
+    * wrapper for find functionality of the union-find
+    *
+    * @param cell the cell to perform find on
+    * @return the input cell's equivalent cell in the parent
+    */
+  def find(cell: Cell): Cell = {
+    val node = cell.node.get
+    val parent: Field = find(node)
+    parent.node.addCell(cell.offset + parent.offset, cell.largestAccessedSize)
+  }
+
+  def find(slice: Slice): Slice = deadjust(adjust(slice))
+
+  /**
+    * merges two cells and unifies their nodes
+    * @param cell1
+    * @param cell2
+    * @return the resulting cell in the unified node
+    */
+  def mergeCells(c1: Cell, c2: Cell): Cell = {
+    var cell1 = c1
+    var cell2 = c2
+    if c1.node.isDefined then
+      cell1 = find(c1)
+
+    if c2.node.isDefined then
+      cell2 = find(c2)
+
+    if cell1.equals(cell2) then // same cell no action required
+      cell1
+    else if cell1.node.isDefined && cell1.node.equals(cell2.node) then // same node different cells causes collapse
+      val ne = collapseNode(cell1.node.get)
+      ne.cells(0)
+    else if cell1.node.isEmpty then
+      ??? // not sure how to handle this yet TODO possibly take it out of the merge?
+      cell2
+    else if cell1.node.get.collapsed || cell2.node.get.collapsed then // a collapsed node
+
+      var node1 = cell1.node.get
+      var node2 = cell2.node.get
+
+      assert(node1.collapsed || node2.collapsed)
+
+      node1 = collapseNode(node1) // collapse the other node
+      node2 = collapseNode(node2)
+      node2.children.addAll(node1.children)
+      node2.children += (node1 -> 0)
+      node2.allocationRegions.addAll(node1.allocationRegions) // add regions and flags of node 1 to node 2
+      node2.flags.join(node1.flags)
+      if node1.cells(0).pointee.isDefined then // merge the pointees of the two collapsed (single cell) nodes
+        if node2.cells(0).pointee.isDefined then
+          val slice1 = node1.cells(0).getPointee
+          val slice2 = node2.cells(0).getPointee
+          val result = mergeCells(adjust(slice1), adjust(slice2))
+          node2.cells(0).pointee = Some(Slice(result, slice1.internalOffset.max(slice2.internalOffset)))
+        else
+          node2.cells(0).pointee = node1.cells(0).pointee
+      //      node1.cells(0).pointee = None
+      //      replace(node1.cells(0), node2.cells(0), 0)
+      solver.unify(node1.term, node2.term, 0)
+      node2.cells(0)
+    else // standard merge
+
+      // node 1 is the cell with the higher offset
+
+      var delta = cell1.offset - cell2.offset
+      var node1 = cell1.node.get
+      var node2 = cell2.node.get
+      if cell1.offset < cell2.offset then
+        delta = cell2.offset - cell1.offset
+        node1 = cell2.node.get
+        node2 = cell1.node.get
+
+
+      // create a seq of all cells from both nodes in order of their offsets in the resulting unified node
+
+      val node2CellsOffset = node2.cells.toSeq.map((offset, cell) => (offset + delta, cell))
+
+      val cells: Seq[(BigInt, Cell)] = (node1.cells.toSeq ++ node2CellsOffset).sortBy(_(0))
+
+      var lastOffset: BigInt = -1
+      var lastAccess: Int = -1
+      // create a new node to represent the unified node
+      val resultNode = Node(Some(this))
+      // add nodes flags and regions to the resulting node
+      resultNode.allocationRegions.addAll(node1.allocationRegions ++ node2.allocationRegions)
+      resultNode.flags.join(node1.flags)
+      resultNode.flags.join(node2.flags)
+      resultNode.children.addAll(node1.children)
+      resultNode.children += (node1 -> 0)
+      node2.children.keys.foreach { k =>
+        resultNode.children(k) = node2.children(k) + delta
+      }
+      resultNode.children += (node2 -> delta)
+      if node2.flags.global then // node 2 may have been adjusted depending on cell1 and cell2 offsets
+        globalMapping.foreach { // update global mapping if node 2 was global
+          case (range: AddressRange, Field(node, offset)) =>
+            if node.equals(node2) then
+              globalMapping.update(range, Field(node, offset + delta))
+        }
+
+      // compute the cells present in the resulting unified node
+      // a mapping from offsets to the set of old cells which are merged to form a cell in the new unified node
+      // values in the mapping also include the largest access size so far computed for each resulting cell
+      val resultCells = mutable.Map[BigInt, mutable.Set[Cell]]()
+      val resultLargestAccesses = mutable.Map[BigInt, Int]()
+      cells.foreach { (offset, cell) =>
+        if ((lastOffset + lastAccess > offset) || lastOffset == offset) { // includes this cell
+          if ((offset - lastOffset) + cell.largestAccessedSize > lastAccess) {
+            lastAccess = (offset - lastOffset).toInt + cell.largestAccessedSize
+          }
+          if (resultCells.contains(lastOffset)) {
+            resultCells(lastOffset).addOne(cell)
+          } else {
+            resultCells(lastOffset) = mutable.Set(cell)
+          }
+          resultLargestAccesses(lastOffset) = lastAccess
+        } else {
+          lastOffset = offset
+          lastAccess = cell.largestAccessedSize
+          resultCells(lastOffset) = mutable.Set(cell)
+          resultLargestAccesses(lastOffset) = lastAccess
+        }
+      }
+
+      resultCells.keys.foreach { offset =>
+        val collapsedCell = resultNode.addCell(offset, resultLargestAccesses(offset))
+        val outgoing: Set[Slice] = cells.flatMap { (_, cell) =>
+          if (cell.pointee.isDefined) {
+            Some(cell.getPointee)
+          } else {
+            None
+          }
+        }.toSet
+        // replace outgoing edges
+        if (outgoing.size == 1) {
+          collapsedCell.pointee = Some(outgoing.head)
+        } else if (outgoing.size > 1) {
+          val result = outgoing.tail.foldLeft(adjust(outgoing.head)) {
+            (result, pointee) =>
+              mergeCells(result, adjust(pointee))
+          }
+          collapsedCell.pointee = Some(deadjust(result))
+        }
+      }
+
+      solver.unify(node1.term, resultNode.term, 0)
+      solver.unify(node2.term, resultNode.term, delta)
+      if cell1.offset >= cell2.offset then
+        resultNode.getCell(cell1.offset)
+      else
+        resultNode.getCell(cell2.offset)
+  }
+
+  def adjust(cell: Cell, internalOffset: BigInt): Cell = {
+    val (term, linkOffset) = solver.findWithOffset(cell.node.get.term)
+    val node = term.node
+    node.addCell(cell.offset + internalOffset + linkOffset, 0)
+  }
+
+  def adjust(slice: Slice, offset: BigInt = 0): Cell = {
+    val cell = slice.cell
+    val internal = slice.internalOffset
+    adjust(cell, internal + offset)
+  }
+
+  def deadjust(cell: Cell): Slice = {
+    val node = cell.node.get
+    val offset = cell.offset
+    selfCollapse(node)
+    val newCell = node.getCell(offset)
+    assert(offset >= newCell.offset)
+    Slice(newCell, offset - newCell.offset)
+  }
+
+  private def isFormal(pos: CFGPosition, variable: Variable): Boolean = !reachingDefs(pos).contains(variable)
+
+  // formal arguments to this function
+  val formals: mutable.Map[Variable, Slice] = mutable.Map()
+
+  // mapping from each SSA variable (position, variable) to a slice
+  val varToCell: mutable.Map[CFGPosition, mutable.Map[Variable, Slice]] = varToCellInit(proc)
+
+  private def varToCellInit(proc: Procedure): mutable.Map[CFGPosition, mutable.Map[Variable, Slice]] = {
+    val varToCell = mutable.Map[CFGPosition, mutable.Map[Variable, Slice]]()
+    val domain = computeDomain(IntraProcIRCursor, Set(proc))
+    domain.foreach {
+      case pos @ LocalAssign(variable, value, _) =>
+        value.variables.foreach { v =>
+          if (isFormal(pos, v)) {
+            val node = Node(Some(this))
+            node.flags.incomplete = true
+            nodes.add(node)
+            formals.update(v, Slice(node.cells(0), 0))
+          }
+        }
+        val node = Node(Some(this))
+        varToCell(pos) = mutable.Map(variable -> Slice(node.cells(0), 0))
+      case pos @ MemoryLoad(lhs, _, index, _, _, _) =>
+        index.variables.foreach { v =>
+          if (isFormal(pos, v)) {
+            val node = Node(Some(this))
+            node.flags.incomplete = true
+            nodes.add(node)
+            formals.update(v, Slice(node.cells(0), 0))
+          }
+        }
+        val node = Node(Some(this))
+        varToCell(pos) = mutable.Map(lhs -> Slice(node.cells(0), 0))
+      case pos @ DirectCall(target, _) if target.name == "malloc" =>
+        val node = Node(Some(this))
+        varToCell(pos) = mutable.Map(mallocRegister -> Slice(node.cells(0), 0))
+      case pos @ DirectCall(target, _) if writesTo.contains(target) =>
+        val result = mutable.Map[Variable, Slice]()
+        writesTo(target).foreach { variable =>
+          val node = Node(Some(this))
+          result(variable) = Slice(node.cells(0), 0)
+        }
+        varToCell(pos) = result
+      case pos @ MemoryStore(_, _, expr, _, _, _) =>
+        unwrapPaddingAndSlicing(expr) match {
+          case value: Variable =>
+            if (isFormal(pos, value)) {
+              val node = Node(Some(this))
+              node.flags.incomplete = true
+              nodes.add(node)
+              formals.update(value, Slice(node.cells(0), 0))
+            }
+          case _ =>
+        }
+      case _ =>
+    }
+    varToCell
+  }
+
+  def cloneSelf(): Graph = {
+    val newGraph = Graph(proc, constProp, varToSym, globals, globalOffsets, externalFunctions, reachingDefs, writesTo, params)
+    assert(formals.size == newGraph.formals.size)
+    val nodes = mutable.Set[Node]()
+    val idToNode: mutable.Map[Int, Node] = mutable.Map()
+    formals.foreach { (variable, slice) =>
+      //        assert(newGraph.formals.contains(variable))
+      val node = find(slice).node
+      nodes.add(node)
+      if !idToNode.contains(node.id) then
+        val newNode = node.cloneSelf(newGraph)
+        idToNode.update(node.id, newNode)
+      newGraph.formals.update(variable, Slice(idToNode(node.id).cells(slice.offset), slice.internalOffset))
+    }
+
+    varToCell.foreach { (position, values) =>
+      //        assert(newGraph.varToCell.contains(position))
+      if (!newGraph.varToCell.contains(position)) {
+        newGraph.varToCell.update(position, mutable.Map[Variable, Slice]())
+      }
+      values.foreach { (variable, s) =>
+        //            assert(newGraph.varToCell(position).contains(variable))
+        val slice = find(s)
+        val node = slice.node
+        nodes.add(node)
+        if (!idToNode.contains(node.id)) {
+          val newNode = node.cloneSelf(newGraph)
+          idToNode.update(node.id, newNode)
+        }
+        newGraph.varToCell(position).update(variable, Slice(idToNode(node.id).cells(slice.offset), slice.internalOffset))
+      }
+    }
+
+    stackMapping.foreach { (offset, oldNode) =>
+      val node = find(oldNode).node
+      nodes.add(node)
+      assert(newGraph.stackMapping.contains(offset))
+      if !idToNode.contains(node.id) then
+        val newNode = node.cloneSelf(newGraph)
+        idToNode.update(node.id, newNode)
+      newGraph.stackMapping.update(offset, idToNode(node.id))
+    }
+
+    globalMapping.foreach { case (range: AddressRange, Field(node, offset)) =>
+      assert(newGraph.globalMapping.contains(range))
+      val field = find(node)
+      nodes.add(field.node)
+      if !idToNode.contains(field.node.id) then
+        val newNode = node.cloneSelf(newGraph)
+        idToNode.update(field.node.id, newNode)
+      newGraph.globalMapping.update(range, Field(idToNode(field.node.id), field.offset + offset))
+    }
+
+    val queue = mutable.Queue[Node]()
+    queue.addAll(nodes)
+    while (queue.nonEmpty) {
+      val node = queue.dequeue()
+      node.cells.values.foreach { cell =>
+        if (cell.pointee.isDefined) {
+          val id = cell.node.get.id
+          val pointee = find(cell.getPointee)
+          val pointeeId = pointee.node.id
+          if (!idToNode.contains(pointeeId)) {
+            queue.enqueue(pointee.node)
+            val newNode = pointee.node.cloneSelf(newGraph)
+            idToNode.update(pointeeId, newNode)
+          }
+          idToNode(id).cells(cell.offset).pointee = Some(Slice(idToNode(pointeeId).cells(pointee.offset), pointee.internalOffset))
+        }
+      }
+    }
+
+    callsites.foreach { callSite =>
+      val cs = CallSite(callSite.call, newGraph)
+      newGraph.callsites.add(cs)
+      assert(cs.paramCells.keySet.equals(callSite.paramCells.keySet))
+      callSite.paramCells.foreach { (variable, oldSlice) =>
+        val slice = find(oldSlice)
+        assert(cs.paramCells.contains(variable))
+        val id = slice.node.id
+        cs.paramCells.update(variable, Slice(idToNode(id).cells(slice.offset), slice.internalOffset))
+      }
+
+      callSite.returnCells.foreach { (variable, oldSlice) =>
+        val slice = find(oldSlice)
+        assert(cs.returnCells.contains(variable))
+        val id = slice.node.id
+        cs.returnCells.update(variable, Slice(idToNode(id).cells(slice.offset), slice.internalOffset))
+      }
+    }
+
+    newGraph.nodes.addAll(idToNode.values)
+    newGraph
+  }
+}
diff --git a/src/main/scala/analysis/data_structure_analysis/LocalPhase.scala b/src/main/scala/analysis/data_structure_analysis/LocalPhase.scala
new file mode 100644
index 000000000..cd975bbb4
--- /dev/null
+++ b/src/main/scala/analysis/data_structure_analysis/LocalPhase.scala
@@ -0,0 +1,368 @@
+package analysis.data_structure_analysis
+
+import analysis.BitVectorEval.{bv2SignedInt, isNegative}
+import analysis.*
+import ir.*
+import specification.{ExternalFunction, SpecGlobal, SymbolTableEntry}
+import util.writeToFile
+
+import java.math.BigInteger
+import scala.collection.mutable
+import scala.util.control.Breaks.{break, breakable}
+
+/**
+ * The local phase of Data Structure Analysis
+ * @param proc procedure to be analysed
+ * @param symResults result of symbolic access analysis
+ * @param constProp
+ * @param globals
+ * @param globalOffsets
+ * @param externalFunctions
+ * @param reachingDefs
+ * @param writesTo mapping from procedures to registers they change
+ * @param params mapping from procedures to their parameters
+ */
+class LocalPhase(proc: Procedure,
+                 symResults: Map[CFGPosition, Map[SymbolicAddress, TwoElement]],
+                 constProp: Map[CFGPosition, Map[Variable, FlatElement[BitVecLiteral]]],
+                 globals: Set[SymbolTableEntry], globalOffsets: Map[BigInt, BigInt],
+                 externalFunctions: Set[ExternalFunction],
+                 reachingDefs: Map[CFGPosition, Map[Variable, Set[CFGPosition]]],
+                 writesTo: Map[Procedure, Set[Register]],
+                 params: Map[Procedure, Set[Variable]]
+                ) extends Analysis[Any] {
+
+  private val mallocRegister = Register("R0", 64)
+  private val stackPointer = Register("R31", 64)
+
+  // set of cfg positions already processed by the analysis local phase
+  private val visited: mutable.Set[CFGPosition] = mutable.Set()
+
+  val varToSym: Map[CFGPosition, Map[Variable, Set[SymbolicAddress]]] = symResults.map { (position, innerMap) =>
+    val newMap = innerMap.keys.foldLeft(Map[Variable, Set[SymbolicAddress]]()) { (m, access) =>
+      if (m.contains(access.accessor)) {
+        // every variable pointing to a stack region ONLY has one symbolic access associated with it.
+        //            m(access.accessor).foreach(
+        //              sym =>
+        //                if (sym.symbolicBase.isInstanceOf[StackLocation]) then
+        //                  println(m)
+        //                  println(access.accessor)
+        //                  println(access)
+        //                  print("")
+        //                //assert(!sym.symbolicBase.isInstanceOf[StackLocation])
+        //            )
+        //            assert(!access.symbolicBase.isInstanceOf[StackLocation])
+        m + (access.accessor -> (m(access.accessor) + access))
+      } else {
+        m + (access.accessor -> Set(access))
+      }
+    }
+    position -> newMap
+  }
+
+  private def getStack(offset: BigInt): Cell = {
+    var last: BigInt = 0
+    if graph.stackMapping.contains(offset) then
+      graph.stackMapping(offset).cells(0)
+    else
+      breakable {
+        graph.stackMapping.keys.foreach {
+          elementOffset =>
+            if offset < elementOffset then
+              break
+            else
+              last = elementOffset
+        }
+      }
+      val diff = offset - last
+      assert(graph.stackMapping.contains(last))
+      graph.stackMapping(last).getCell(diff)
+  }
+
+  /**
+   * if an expr is the address of a stack location return its corresponding cell
+   * @param pos IL position where the expression is used
+   */
+  private def isStack(expr: Expr, pos: CFGPosition): Option[Cell] = {
+    expr match
+      case BinaryExpr(_, arg1: Variable, arg2) if varToSym.contains(pos) && varToSym(pos).contains(arg1) &&
+        varToSym(pos)(arg1).exists(s => s.symbolicBase.isInstanceOf[StackLocation]) =>
+        evaluateExpression(arg2, constProp(pos)) match
+          case Some(v) =>
+            val stackRegions = varToSym(pos)(arg1).filter(s => s.symbolicBase.isInstanceOf[StackLocation])
+            val res = stackRegions.tail.foldLeft(getStack(v.value + stackRegions.head.offset)) {
+              (res, sym) =>
+                graph.mergeCells(res, getStack(v.value + sym.offset))
+            }
+            Some(res)
+          case None => None
+      case arg: Variable if varToSym.contains(pos) && varToSym(pos).contains(arg) &&
+        varToSym(pos)(arg).exists(s => s.symbolicBase.isInstanceOf[StackLocation]) =>
+        val stackRegions = varToSym(pos)(arg).filter(s => s.symbolicBase.isInstanceOf[StackLocation])
+        val res = stackRegions.tail.foldLeft(getStack(stackRegions.head.offset)) {
+          (res, sym) =>
+            graph.mergeCells(res, getStack(sym.offset))
+        }
+        Some(res)
+      case _ => None
+  }
+
+  var mallocCount: Int = 0
+
+  private def nextMallocCount = {
+    mallocCount += 1
+    s"malloc_$mallocCount"
+  }
+
+  val graph: Graph = Graph(proc, constProp, varToSym, globals, globalOffsets, externalFunctions, reachingDefs, writesTo, params)
+
+  /**
+   * if an expr is the address of a global location return its corresponding cell
+   * @param pos IL position where the expression is used
+   */
+  def isGlobal(expr: Expr, pos: CFGPosition, size: Int = 0): Option[Cell] = {
+    val value = evaluateExpression(expr, constProp(pos))
+    if value.isDefined  then
+      val global = graph.isGlobal(value.get.value)
+      if global.isDefined then
+        val address = value.get.value
+        val DSAGlobal(range: AddressRange, Field(node, internal)) = global.get
+        val offset = address - range.start
+        node.addCell(internal + offset, size)
+        graph.selfCollapse(node)
+        if node.collapsed then
+          Some(node.cells(0))
+        else
+          Some(node.getCell(internal + offset))
+      else
+        None
+    else
+      None
+  }
+
+  /**
+   * Handles unification for instructions of the form R_x = R_y [+ offset] where R_y is a pointer and [+ offset] is optional
+   * @param position the cfg position being visited (note this might be a local assign of the form R_x = R_y [+ offset]
+   *                 or it might be memory load/store where the index is of the form R_y [+ offset]
+   * @param lhs Ev(R_x) if position is local assign or a cell from an empty node if R_y [+ offset] is the index of a memoryStore
+   * @param rhs R_y, reachingDefs(position)(R_y) can be used to find the set of SSA variables that may define R_x
+   * @param pointee if false, the position is local pointer arithmetic therefore Ev(R_y [+ offset]) is merged with lhs
+   *                else, the position is a memory read/write therefore E(Ev(R_y [+ offset])) is merged with lhs
+   * @param offset offset if [+ offset] is present
+   * @return the cell resulting from the unification
+   */
+  private def visitPointerArithmeticOperation(position: CFGPosition, lhs: Cell, rhs: Variable, size: Int, pointee: Boolean = false, offset: BigInt = 0, collapse: Boolean = false): Cell =
+    // visit all the defining pointer operation on rhs variable first
+    reachingDefs(position)(rhs).foreach(visit)
+    // get the cells of all the SSA variables in the set
+    val cells: Set[Slice] = graph.getCells(position, rhs).foldLeft(Set[Slice]()) {
+      (col, slice) =>
+        col + Slice(graph.find(slice.cell), slice.internalOffset)
+    }
+    // merge the cells or their pointees with lhs
+    var result = cells.foldLeft(lhs) {
+      (c, t) =>
+        val cell = t.cell
+        val internalOffset = t.internalOffset
+        if !collapse then  // offset != 0 then // it's R_x = R_y + offset
+          val node = cell.node.get // get the node of R_y
+          var field = offset + cell.offset + internalOffset // calculate the total offset
+          node.addCell(field, size) // add cell there if doesn't already exists
+          if node.collapsed then
+            field = 0
+          graph.mergeCells(c,
+            if pointee then
+              graph.adjust(node.getCell(field).getPointee)
+            else
+              node.getCell(field)
+          )
+        else
+          var node = cell.node.get
+          node = graph.collapseNode(node)
+          graph.mergeCells(c, if pointee then graph.adjust(node.cells(0).getPointee) else node.cells(0))
+
+    }
+    if pointee then
+      cells.foreach { t =>
+        val offset = t.cell.offset
+        val internalOffset = t.internalOffset
+        val node = t.cell.node.get
+        val cell = graph.find(node.getCell(offset + internalOffset))
+        if cell.pointee.isDefined && graph.find(cell.getPointee.cell).equals(result) then
+          graph.selfCollapse(node)
+          //            assert(graph.pointTo.contains(node.getCell(offset))) TODO
+          result = graph.find(graph.find(node.getCell(offset)).getPointee.cell)
+        else
+          graph.selfCollapse(node)
+      }
+    val resultOffset = result.offset
+    graph.selfCollapse(result.node.get)
+    result.node.get.getCell(result.offset)
+
+  /**
+   * handles unsupported pointer arithmetic by collapsing all the nodes invloved
+   */
+  private def unsupportedPointerArithmeticOperation(n: CFGPosition, expr: Expr, lhsCell: Cell): Cell = {
+    val cell = expr.variables.foldLeft(lhsCell) {
+      (c, v) =>
+        val cells: Set[Slice] = graph.getCells(n, v)
+
+        cells.foldLeft(c) {
+          (c, p) =>
+            graph.mergeCells(c, p.cell)
+        }
+    }
+
+    val node = cell.node.get
+    node.flags.unknown = true
+    graph.collapseNode(node)
+
+    node.cells(0)
+  }
+
+  def visit(n: CFGPosition): Unit = {
+    if visited.contains(n) then
+      return
+    else
+      visited.add(n)
+    n match
+      case DirectCall(target, _) if target.name == "malloc" => // R0 = Malloc()
+        val size: BigInt = evaluateExpression(mallocRegister, constProp(n)) match
+          case Some(value) => value.value
+          case None => 0
+        val node = Node(Some(graph), size)
+        node.allocationRegions.add(HeapLocation(nextMallocCount, target, size))
+        node.flags.heap = true
+        graph.mergeCells(graph.varToCell(n)(mallocRegister).cell, node.cells(0))
+      case call: DirectCall if params.contains(call.target) => // Rx, Ry, ... Rn = FunctionCall()
+        // create call sites for the callees
+        val cs = CallSite(call, graph)
+        graph.callsites.add(cs)
+        cs.paramCells.foreach { (variable, slice) =>
+          visitPointerArithmeticOperation(call, graph.adjust(slice), variable, 0)
+        }
+        cs.returnCells.foreach { (variable, slice) =>
+          val returnArgument = graph.varToCell(n)(variable)
+          graph.mergeCells(graph.adjust(returnArgument), graph.adjust(slice))
+        }
+      case LocalAssign(variable, rhs, _) =>
+        val expr: Expr = unwrapPaddingAndSlicing(rhs)
+        val lhsCell = graph.adjust(graph.varToCell(n)(variable))
+        val global = isGlobal(rhs, n)
+        val stack = isStack(rhs, n)
+        if global.isDefined then // Rx = global address
+          graph.mergeCells(lhsCell, global.get)
+        else if stack.isDefined then // Rx = stack address
+          graph.mergeCells(lhsCell, stack.get)
+        else
+          expr match
+            case BinaryExpr(op, arg1: Variable, arg2) if op.equals(BVADD) => // Rx = Rx + c
+              val arg2Offset = evaluateExpression(arg2, constProp(n))
+              if op.equals(BVADD) && arg1.equals(stackPointer)
+              && arg2Offset.isDefined && isNegative(arg2Offset.get) then
+                () // the stack is handled prior to this
+              else if /*varToSym.contains(n) &&  varToSym(n).contains(arg1) && */  arg2Offset.isDefined then
+                // merge lhs with cell(s) corresponding to (arg1 + arg2) where arg1 is cell and arg2 is an offset
+                val offset = evaluateExpression(arg2, constProp(n)).get.value
+                visitPointerArithmeticOperation(n, lhsCell, arg1, 0, false, offset)
+              else // c can't be statically evaluated
+                unsupportedPointerArithmeticOperation(n, expr, lhsCell)
+
+            // Rx = Ry merge corresponding cells to Rx and Ry
+            case arg: Variable /*if varToSym.contains(n) && varToSym(n).contains(arg)*/ =>
+             visitPointerArithmeticOperation(n, lhsCell, arg, 0)
+            case _ =>
+              unsupportedPointerArithmeticOperation(n, expr, lhsCell)
+        
+      case MemoryLoad(lhs, _, index, _, size, _) => // Rx = Mem[Ry], merge Rx and pointee of Ry (E(Ry))
+        val indexUnwrapped = unwrapPaddingAndSlicing(index)
+        val lhsCell = graph.adjust(graph.varToCell(n)(lhs))
+        assert(size % 8 == 0)
+        val byteSize = size / 8
+        lhsCell.node.get.flags.read = true
+        val global = isGlobal(indexUnwrapped, n, byteSize)
+        val stack = isStack(indexUnwrapped, n)
+        if global.isDefined then
+          graph.mergeCells(lhsCell, graph.adjust(graph.find(global.get).getPointee))
+        else if stack.isDefined then
+          graph.mergeCells(lhsCell, graph.adjust(graph.find(stack.get).getPointee))
+        else
+          indexUnwrapped match
+            case BinaryExpr(op, arg1: Variable, arg2) if op.equals(BVADD) =>
+              evaluateExpression(arg2, constProp(n)) match
+                case Some(v) =>
+                  //                        assert(varToSym(n).contains(arg1))
+                  val offset = v.value
+                  visitPointerArithmeticOperation(n, lhsCell, arg1, byteSize, true, offset)
+                case None =>
+                  //                        assert(varToSym(n).contains(arg1))
+                  // collapse the result
+                  //                        visitPointerArithmeticOperation(n, lhsCell, arg1, byteSize, true, 0, true)
+                  unsupportedPointerArithmeticOperation(n, indexUnwrapped, Node(Some(graph)).cells(0))
+            case arg: Variable =>
+              //                    assert(varToSym(n).contains(arg))
+              visitPointerArithmeticOperation(n, lhsCell, arg, byteSize, true)
+            case _ => ???
+      case MemoryStore(_, ind, expr, _, size, _) =>
+        val unwrapped = unwrapPaddingAndSlicing(expr)
+        unwrapped match {
+          // Mem[Ry] = Rx
+          case value: Variable =>
+            val index: Expr = unwrapPaddingAndSlicing(ind)
+            reachingDefs(n)(value).foreach(visit)
+            assert(size % 8 == 0)
+            val byteSize = size / 8
+            val global = isGlobal(index, n, byteSize)
+            val stack = isStack(index, n)
+            val addressPointee: Cell =
+              if global.isDefined then
+                graph.adjust(graph.find(global.get).getPointee)
+              else if stack.isDefined then
+                graph.adjust(graph.find(stack.get).getPointee)
+              else
+                index match
+                  case BinaryExpr(op, arg1: Variable, arg2) if op.equals(BVADD) =>
+                    evaluateExpression(arg2, constProp(n)) match
+                      case Some(v) =>
+                        //                    assert(varToSym(n).contains(arg1))
+                        val offset = v.value
+                        visitPointerArithmeticOperation(n, Node(Some(graph)).cells(0), arg1, byteSize, true, offset)
+                      case None =>
+                        //                    assert(varToSym(n).contains(arg1))
+                        // collapse the results
+                        // visitPointerArithmeticOperation(n, DSN(Some(graph)).cells(0), arg1, byteSize, true, 0, true)
+                        unsupportedPointerArithmeticOperation(n, index, Node(Some(graph)).cells(0))
+                  case arg: Variable =>
+                    //                assert(varToSym(n).contains(arg))
+                    visitPointerArithmeticOperation(n, Node(Some(graph)).cells(0), arg, byteSize, true)
+                  case _ =>
+                    ???
+
+            addressPointee.node.get.flags.modified = true
+            val valueCells = graph.getCells(n, value)
+            val result = valueCells.foldLeft(addressPointee) { (c, slice) =>
+              graph.mergeCells(graph.adjust(slice), c)
+            }
+          case _ => // if value is a literal ignore it
+        }
+      case _ =>
+
+  }
+  def analyze(): Graph = {
+    val domain = computeDomain(IntraProcIRCursor, Set(proc)).toSeq.sortBy(_.toShortString)
+
+    domain.foreach(visit)
+
+    val b = graph.solver.solution()
+    graph.collectNodes()
+    //    graph.nodes.foreach(node =>
+    //      node.children.foreach(
+    //        child =>
+    //          assert(graph.solver.find(child._1.term).equals(graph.solver.find(node.term)))
+    //          assert(graph.solver.find(child._1.term)._2.equals(child._2))
+    //
+    //      )
+    //    )
+    graph
+  }
+}
diff --git a/src/main/scala/analysis/data_structure_analysis/SymbolicAddressAnalysis.scala b/src/main/scala/analysis/data_structure_analysis/SymbolicAddressAnalysis.scala
new file mode 100644
index 000000000..a66b7f616
--- /dev/null
+++ b/src/main/scala/analysis/data_structure_analysis/SymbolicAddressAnalysis.scala
@@ -0,0 +1,157 @@
+package analysis.data_structure_analysis
+
+import analysis.BitVectorEval.{bv2SignedInt, isNegative}
+import analysis.solvers.ForwardIDESolver
+import analysis.*
+import ir.*
+
+import java.math.BigInteger
+
+case class SymbolicAddress(accessor: Variable, symbolicBase: MemoryLocation, offset: BigInt) {
+  override def toString: String = s"SymbolicAddress($accessor, $symbolicBase, $offset)"
+}
+
+trait MemoryLocation {
+  val regionIdentifier: String
+
+  override def toString: String = s"MemoryRegion($regionIdentifier)"
+}
+
+case class StackLocation(override val regionIdentifier: String, proc: Procedure, size: BigInt) extends MemoryLocation {
+  override def toString: String = s"Stack($regionIdentifier,  $size)"
+}
+
+case class HeapLocation(override val regionIdentifier: String, proc: Procedure, size: BigInt) extends MemoryLocation {
+  override def toString: String = s"Heap($regionIdentifier, $size)"
+}
+
+case class DataLocation(override val regionIdentifier: String, start: BigInt, size: BigInt) extends MemoryLocation {
+  override def toString: String = s"Data($regionIdentifier, $start, $size)"
+}
+
+case class UnknownLocation(override val regionIdentifier: String, proc: Procedure) extends MemoryLocation {
+  override def toString: String = s"Unknown($regionIdentifier)"
+}
+
+/**
+ * environment transformers for SAA or symbolic access analysis
+ * Combination of reaching definitions and constant propagation
+ * elements in D are symbolic accesses of the form (variable, symbolic base, concrete offset)
+ * lattice L is a binary lattice with top being the definition is valid (alive) and bottom being
+ * the definition is dead or no longer affects the environment
+ */
+trait SymbolicAddressFunctions(constProp: Map[CFGPosition, Map[Variable, FlatElement[BitVecLiteral]]]) extends ForwardIDEAnalysis[SymbolicAddress, TwoElement, TwoElementLattice] {
+
+  private val stackPointer = Register("R31", 64)
+  private val mallocVariable = Register("R0", 64)
+
+  var mallocCount: Int = 0
+  private def nextMallocCount = {
+    mallocCount += 1
+    s"malloc_$mallocCount"
+  }
+
+  var unknownCount: Int = 0
+  private def nextunknownCount = {
+    unknownCount += 1
+    s"unknown_$unknownCount"
+  }
+
+  val valuelattice: TwoElementLattice = TwoElementLattice()
+  val edgelattice: EdgeFunctionLattice[TwoElement, TwoElementLattice] = EdgeFunctionLattice(valuelattice)
+  import edgelattice.{ConstEdge, IdEdge}
+
+  def edgesCallToEntry(call: DirectCall, entry: Procedure)(d: DL): Map[DL, EdgeFunction[TwoElement]] =
+    d match
+      case Left(value) =>
+        value.symbolicBase match
+          case _: StackLocation => Map()
+          case _ => Map(d -> IdEdge())
+      case Right(_) => Map(d -> IdEdge())
+
+  def edgesExitToAfterCall(exit: Return, aftercall: Command)(d: DL): Map[DL, EdgeFunction[TwoElement]] =
+    d match
+      case Left(value) =>
+        value.symbolicBase match
+          case _: StackLocation => Map()
+          case _ =>
+            if value.accessor.name == "R29" then Map()
+            else Map(d -> IdEdge())
+      case Right(_) => Map(d -> IdEdge())
+
+  def edgesCallToAfterCall(call: DirectCall, aftercall: Command)(d: DL): Map[DL, EdgeFunction[TwoElement]] =
+    d match
+      case Left(value) =>
+        value.symbolicBase match
+          case _: StackLocation => Map(d -> IdEdge())
+          case _ => Map() // maps all variables before the call to bottom
+      case Right(_) => Map(d -> IdEdge())
+
+  def edgesOther(n: CFGPosition)(d: DL): Map[DL, EdgeFunction[TwoElement]] =
+    n match
+      case LocalAssign(variable, rhs, _) =>
+        val expr = unwrapPaddingAndSlicing(rhs)
+        expr match
+          case BinaryExpr(op, arg1: Variable, arg2) if op.equals(BVADD) =>
+            evaluateExpression(arg2, constProp(n)) match
+              case Some(v) =>
+                if op.equals(BVADD) && arg1.equals(stackPointer) && isNegative(v) then
+                  d match
+                    case Left(value) if value.accessor == variable => Map()
+                    case Left(_) => Map(d -> IdEdge())
+                    case Right(_) =>
+                      val size = bv2SignedInt(v)
+                      val procedure = IRWalk.procedure(n)
+                      Map(d -> IdEdge(), Left(SymbolicAddress(variable, StackLocation(s"Stack_${procedure.name}", procedure, -size), 0)) -> ConstEdge(TwoElementTop))
+                else
+                  d match
+                    case Left(value) if value.accessor == arg1 =>
+                      val offsetUpdate = evaluateExpression(arg2, constProp(n)).get.value
+                      val result: Map[DL, EdgeFunction[TwoElement]] = Map(Left(SymbolicAddress(variable, value.symbolicBase, value.offset + offsetUpdate)) -> ConstEdge(TwoElementTop))
+                      if value.accessor != variable then
+                        result + (d -> IdEdge())
+                      else
+                        result
+                    case Left(value) if value.accessor == variable => Map()
+                    case _ => Map(d -> IdEdge())
+              case None => Map(d -> IdEdge())
+          case arg: Variable =>
+            d match
+              case Left(value) if value.accessor == arg =>
+                val result: Map[DL, EdgeFunction[TwoElement]] = Map(Left(SymbolicAddress(variable, value.symbolicBase, value.offset)) -> ConstEdge(TwoElementTop))
+                if value.accessor != variable then
+                  result + (d -> IdEdge())
+                else
+                  result
+              case Left(value) if value.accessor == variable => Map()
+              case _ => Map(d -> IdEdge())
+          case _ =>
+            d match
+              case Left(value) if value.accessor == variable => Map()
+              case _ => Map(d -> IdEdge())
+      case MemoryLoad(lhs, _, _, _, _, _) =>
+        d match
+          case Left(value) if value.accessor == lhs => Map()
+          case Left(_) => Map(d -> IdEdge())
+          case Right(_) => Map(d -> IdEdge(), Left(SymbolicAddress(lhs, UnknownLocation(nextunknownCount, IRWalk.procedure(n)), 0)) -> ConstEdge(TwoElementTop))
+      case DirectCall(target, _) if target.name == "malloc" =>
+        d match
+          case Left(value) if value.accessor == mallocVariable => Map()
+          case Left(_) => Map(d -> IdEdge())
+          case Right(_) =>
+            val size: BigInt = evaluateExpression(mallocVariable, constProp(n)) match
+              case Some(value) => value.value
+              case None => -1
+            Map(d -> IdEdge(), Left(SymbolicAddress(mallocVariable, HeapLocation(nextMallocCount, IRWalk.procedure(n), size), 0)) -> ConstEdge(TwoElementTop))
+      case DirectCall(target, _) if target.returnBlock.isEmpty => // for when calls are non returning, kills the stack dataflow facts
+        d match
+          case Left(value) =>
+            value.symbolicBase match
+              case _: StackLocation => Map()
+              case _ => Map(d -> IdEdge())
+          case Right(_) => Map(d -> IdEdge())
+      case _ => Map(d -> IdEdge())
+}
+
+class SymbolicAddressAnalysis(program: Program, constProp: Map[CFGPosition, Map[Variable, FlatElement[BitVecLiteral]]])
+  extends ForwardIDESolver[SymbolicAddress, TwoElement, TwoElementLattice](program), SymbolicAddressFunctions(constProp)
\ No newline at end of file
diff --git a/src/main/scala/analysis/data_structure_analysis/Utility.scala b/src/main/scala/analysis/data_structure_analysis/Utility.scala
new file mode 100644
index 000000000..6d89db0d7
--- /dev/null
+++ b/src/main/scala/analysis/data_structure_analysis/Utility.scala
@@ -0,0 +1,252 @@
+package analysis.data_structure_analysis
+
+import analysis.solvers.{DSAUniTerm, DSAUnionFindSolver, UnionFindSolver, Var}
+import analysis.*
+import cfg_visualiser.{DotStruct, DotStructElement, StructArrow, StructDotGraph}
+import ir.*
+import specification.{ExternalFunction, SpecGlobal, SymbolTableEntry}
+import util.Logger
+
+import scala.collection.mutable
+import scala.collection.mutable.ArrayBuffer
+import scala.util.control.Breaks.{break, breakable}
+
+object NodeCounter {
+  private var counter: Int = 0
+
+  def getCounter: Int =
+    counter = counter + 1
+    counter
+}
+
+class Flags() {
+  var collapsed = false
+  var stack = false
+  var heap = false
+  var global = false
+  var unknown = false
+  var read = false
+  var modified = false
+  var incomplete = false
+  var foreign = false
+
+  def join(other: Flags): Unit =
+    collapsed = collapsed || other.collapsed
+    stack = other.stack || stack
+    heap = other.heap || heap
+    global = other.global || global
+    unknown = other.unknown || unknown
+    read = other.read || read
+    modified = other.modified || modified
+    incomplete = other.incomplete || incomplete
+    foreign = other.foreign && foreign
+}
+
+/**
+ * a Data structure Node
+ */
+class Node(val graph: Option[Graph], var size: BigInt = 0, val id: Int = NodeCounter.getCounter) {
+
+  val term: DSAUniTerm = DSAUniTerm(this)
+  val children: mutable.Map[Node, BigInt] = mutable.Map()
+//  var collapsed = false
+  var flags: Flags = Flags()
+  def collapsed: Boolean = flags.collapsed
+
+  val allocationRegions: mutable.Set[MemoryLocation] = mutable.Set()
+
+  val cells: mutable.Map[BigInt, Cell] = mutable.Map()
+  this.addCell(0, 0)
+
+  private def updateSize(newSize: BigInt): Unit = {
+    if newSize > size then
+      size = newSize
+  }
+
+  def getCell(offset: BigInt): Cell = {
+    if (collapsed) {
+      cells(0)
+    } else if (!cells.contains(offset)) {
+      var result: Option[Cell] = None
+      cells.foreach { (start, cell) =>
+        if (start <= offset && offset < (start + cell.largestAccessedSize)) {
+          result = Some(cell)
+        }
+      }
+      result match {
+        case Some(value) => value
+        case None => ???
+        //          Logger.warn(s"$this didn't have a cell at offset: $offset. An empty cell was added in")
+        //          addCell(offset, 0)
+      }
+    } else {
+      cells(offset)
+    }
+  }
+
+
+  def addCell(offset: BigInt, size: Int): Cell = {
+    this.updateSize(offset + size)
+    if collapsed then
+      cells(0)
+    else if !cells.contains(offset) then
+      val cell = Cell(Some(this), offset)
+      cells.update(offset, cell)
+      cell.growSize(size)
+      cell
+    else
+      cells(offset).growSize(size)
+      cells(offset)
+  }
+
+  def cloneSelf(graph: Graph): Node = {
+    val node = Node(Some(graph), this.size)
+    node.allocationRegions.addAll(this.allocationRegions)
+    node.flags.join(this.flags)
+    cells.foreach { (offset, cell) =>
+      node.addCell(offset, cell.largestAccessedSize)
+    }
+    node
+  }
+
+  def cloneNode(from: Graph, to: Graph): Unit = {
+//    assert(from.nodes.contains(this)) TODO update nodes after each phase for to check this assertion
+    if (!to.nodes.contains(this)) {
+      to.nodes.add(this)
+
+      from.varToCell.foreach { (pos, varMap) =>
+        varMap.foreach { (variable, slice) =>
+          if (from.find(slice).node.equals(this)) {
+            if (to.varToCell.contains(pos)) {
+              to.varToCell(pos)(variable) = from.find(slice)
+            } else {
+              to.varToCell(pos) = mutable.Map(variable -> from.find(slice))
+            }
+          }
+        }
+      }
+      from.formals.foreach { (variable, slice) =>
+        if (from.find(slice).node.equals(this)) {
+          if (to.varToCell.contains(from.proc)) {
+            to.varToCell(from.proc)(variable) = from.find(slice)
+          } else {
+            to.varToCell(from.proc) = mutable.Map(variable -> from.find(slice))
+          }
+        }
+      }
+      cells.values.foreach { cell =>
+        if (cell.pointee.isDefined) {
+          val pointee = cell.getPointee
+          pointee.node.cloneNode(from, to)
+          //          to.pointTo.update(cell, pointee) TODO check this is not necessary
+        }
+      }
+    }
+  }
+
+  override def equals(obj: Any): Boolean = {
+    obj match
+      case node: Node =>
+        this.id == node.id
+      case _ => false
+  }
+
+  override def hashCode(): Int = id
+
+  override def toString: String = s"Node($id, $allocationRegions ${if collapsed then ", collapsed" else ""})"
+
+}
+
+/**
+ * a cell in DSA
+ * @param node the node this cell belongs to
+ * @param offset the offset of the cell
+ */
+class Cell(val node: Option[Node], val offset: BigInt) {
+  var largestAccessedSize: Int = 0
+
+  // the cell's pointee
+  var pointee: Option[Slice] = None
+
+  // returns the cell's pointee if it has one.
+  // if not it will create a placeholder, set it as the pointee of this cell and return it
+  def getPointee: Slice =
+    if pointee.isEmpty then
+      val node = Node(Some(this.node.get.graph.get))
+      pointee = Some(Slice(node.cells(0), 0))
+    else
+      val graph = pointee.get.node.graph.get
+      val resolvedPointee = graph.find(graph.adjust(pointee.get))
+
+      pointee = Some(graph.deadjust(resolvedPointee))
+    pointee.get
+
+  def growSize(size: Int): Boolean =
+    if size > largestAccessedSize then
+      largestAccessedSize = size
+      true
+    else false
+
+  override def equals(obj: Any): Boolean =
+    obj match
+      case cell: Cell => this.node.equals(cell.node) && this.offset.equals(cell.offset)
+      case _ => false
+
+  override def toString: String = s"Cell(${if node.isDefined then node.get.toString else "NONE"}, $offset)"
+}
+
+
+/**
+ * a slice made from a cell and an internal offset
+ */
+case class Slice(cell: Cell, internalOffset: BigInt) {
+  def node: Node = cell.node.get
+  def offset: BigInt = cell.offset
+}
+
+/**
+ * represents a direct call in DSA
+ * @param call instance of the call
+ * @param graph caller's DSG
+ */
+class CallSite(val call: DirectCall, val graph: Graph) {
+  val proc: Procedure = call.target
+  val paramCells: mutable.Map[Variable, Slice] = graph.params(proc).foldLeft(mutable.Map[Variable, Slice]()) {
+    (m, reg) =>
+      val node = Node(Some(graph))
+      node.flags.incomplete = true
+      m += (reg -> Slice(node.cells(0), 0))
+  }
+  val returnCells: mutable.Map[Variable, Slice] = graph.writesTo(proc).foldLeft(mutable.Map[Variable, Slice]()) {
+    (m, reg) =>
+      val node = Node(Some(graph))
+      node.flags.incomplete = true
+      m += (reg -> Slice(node.cells(0), 0))
+  }
+}
+
+case class DSAGlobal(addressRange: AddressRange, field: Field) {
+  lazy val start: BigInt = addressRange.start
+  lazy val end: BigInt = addressRange.end
+  lazy val node: Node = field.node
+  lazy val offset: BigInt = field.offset
+}
+
+// global address range
+case class AddressRange(start: BigInt, end: BigInt)
+
+// a node, offset pair, difference to a cell is that it doesn't represent a DSG construct,
+case class Field(node: Node, offset: BigInt)
+
+// unwraps internal padding and slicing and returns the expression
+def unwrapPaddingAndSlicing(expr: Expr): Expr =
+  expr match
+    case literal: Literal => literal
+    case Repeat(repeats, body) => Repeat(repeats, unwrapPaddingAndSlicing(body))
+    case SignExtend(extension, body) => SignExtend(extension, unwrapPaddingAndSlicing(body))
+    case UnaryExpr(op, arg) => UnaryExpr(op, arg)
+    case BinaryExpr(op, arg1, arg2) => BinaryExpr(op, unwrapPaddingAndSlicing(arg1), unwrapPaddingAndSlicing(arg2))
+    case variable: Variable => variable
+    case Extract(_, _, body) /*if start == 0 && end == 32*/ => unwrapPaddingAndSlicing(body) // this may make it unsound
+    case ZeroExtend(_, body) => unwrapPaddingAndSlicing(body)
+    case _ => expr
\ No newline at end of file
diff --git a/src/main/scala/analysis/solvers/DSAUnionFindSolver.scala b/src/main/scala/analysis/solvers/DSAUnionFindSolver.scala
new file mode 100644
index 000000000..2a52591c9
--- /dev/null
+++ b/src/main/scala/analysis/solvers/DSAUnionFindSolver.scala
@@ -0,0 +1,61 @@
+package analysis.solvers
+
+import analysis.data_structure_analysis.Node
+import scala.collection.mutable
+
+class DSAUnionFindSolver extends UnionFindSolver[UniTerm] {
+  private val parent = mutable.Map[DSAUniTerm, DSAUniTerm]()
+  private val offsets = mutable.Map[DSAUniTerm, BigInt]()
+
+  override def unify(t1: Term[UniTerm], t2: Term[UniTerm]): Unit =
+    unify(t1.asInstanceOf[DSAUniTerm], t2.asInstanceOf[DSAUniTerm], 0)
+
+  // offset is the offset at which
+  def unify(t1: DSAUniTerm, t2: DSAUniTerm, offset: BigInt): Unit = {
+    mkSet(t1)
+    mkSet(t2)
+    val (rep1, _) = findWithOffset(t1)
+    val (rep2, _) = findWithOffset(t2)
+
+    if (rep1 != rep2) {
+      /** Perform the union of the equivalence classes of `t1` and `t2`, such that `t2` becomes the new canonical element.
+        * We assume `t1` and `t2` to be distinct canonical elements. This implementation does not use
+        * [[https://en.wikipedia.org/wiki/Disjoint-set_data_structure union-by-rank]].
+        */
+      parent += t1 -> t2
+      offsets += t1 -> offset
+    }
+  }
+  
+  def findWithOffset(t: DSAUniTerm): (DSAUniTerm, BigInt) = {
+    mkSet(t)
+    if (parent(t) != t)
+      val (par, offset) = findWithOffset(parent(t))
+      parent += t -> par
+      offsets += t -> (offsets(t) + offset)
+
+    (parent(t), offsets(t))
+  }
+
+
+  /** Creates an equivalence class for the term `t`, if it does not exists already.
+   */
+  private def mkSet(t: DSAUniTerm): Unit = {
+    if (!parent.contains(t))
+      parent += (t -> t)
+      offsets += (t -> 0)
+  }
+
+}
+
+/** Terms used in unification.
+ */
+sealed trait UniTerm
+
+/** A term variable in the solver
+ */
+case class DSAUniTerm(node: Node) extends Var[UniTerm] {
+
+  override def toString: String = s"Term{$node}"
+}
+
diff --git a/src/main/scala/analysis/solvers/FixPointSolver.scala b/src/main/scala/analysis/solvers/FixPointSolver.scala
index bae5f8b9d..29186a9eb 100644
--- a/src/main/scala/analysis/solvers/FixPointSolver.scala
+++ b/src/main/scala/analysis/solvers/FixPointSolver.scala
@@ -249,9 +249,8 @@ trait PushDownWorklistFixpointSolver[N, T, L <: Lattice[T]] extends MapLatticeSo
   def process(n: N): Unit =
     val xn = x(n)
     val y = transfer(n, xn)
+    // TODO: Only propagate if there's a change
     for succ <- outdep(n) do propagate(y, succ)
-
-
 /** Worklist-based fixpoint solver.
   *
   * @tparam N
diff --git a/src/main/scala/analysis/solvers/IDESolver.scala b/src/main/scala/analysis/solvers/IDESolver.scala
index 5e94726d9..4b60e2e16 100644
--- a/src/main/scala/analysis/solvers/IDESolver.scala
+++ b/src/main/scala/analysis/solvers/IDESolver.scala
@@ -24,7 +24,8 @@ abstract class IDESolver[E <: Procedure | Command, EE <: Procedure | Command, C
   protected def isExit(exit: CFGPosition): Boolean
   protected def getAfterCalls(exit: EE): Set[R]
 
-  def phase2Init = valuelattice.top
+  def phase2Init: T = valuelattice.top
+  def start: CFGPosition = startNode
 
   /**
    * Phase 1 of the IDE algorithm.
@@ -32,10 +33,10 @@ abstract class IDESolver[E <: Procedure | Command, EE <: Procedure | Command, C
    * The original version of the algorithm uses summary edges from call nodes to after-call nodes
    * instead of `callJumpCache` and `exitJumpCache`.
    */
-  private class Phase1(val program: Program) extends InitializingPushDownWorklistFixpointSolver[(CFGPosition, DL, DL), EdgeFunction[T], EdgeFunctionLattice[T, L]] {
+  private class Phase1 extends InitializingPushDownWorklistFixpointSolver[(CFGPosition, DL, DL), EdgeFunction[T], EdgeFunctionLattice[T, L]] {
 
     val lattice: MapLattice[(CFGPosition, DL, DL), EdgeFunction[T], EdgeFunctionLattice[T, L]] = MapLattice(edgelattice)
-    val first: Set[(CFGPosition, DL, DL)] = Set((startNode, Right(Lambda()), Right(Lambda())))
+    val first: Set[(CFGPosition, DL, DL)] = Set((start, Right(Lambda()), Right(Lambda())))
 
     /**
      * callJumpCache(funentry, d1, call)(d3) returns the composition of the edges (call.funentry, d3) -> (call, *) -> (funentry, d1).
@@ -77,7 +78,6 @@ abstract class IDESolver[E <: Procedure | Command, EE <: Procedure | Command, C
       }
     }
 
-
     def process(n: (CFGPosition, DL, DL)): Unit = {
       val (position, d1, d2) = n
       val e1 = x(n)
@@ -142,14 +142,14 @@ abstract class IDESolver[E <: Procedure | Command, EE <: Procedure | Command, C
    * Performs a forward dataflow analysis using the decomposed lattice and the micro-transformers.
    * The original RHS version of IDE uses jump functions for all nodes, not only at exits, but the analysis result and complexity is the same.
    */
-  private class Phase2(val program: Program, val phase1: Phase1) extends InitializingPushDownWorklistFixpointSolver[(CFGPosition, DL), T, L]:
+  private class Phase2(val phase1: Phase1) extends InitializingPushDownWorklistFixpointSolver[(CFGPosition, DL), T, L] {
     val lattice: MapLattice[(CFGPosition, DL), T, L] = MapLattice(valuelattice)
-    val first: Set[(CFGPosition, DL)] = Set((startNode, Right(Lambda())))
+    val first: Set[(CFGPosition, DL)] = Set((start, Right(Lambda())))
 
     /**
-     * Function summaries from phase 1.
-     * Built when first invoked.
-     */
+      * Function summaries from phase 1.
+      * Built when first invoked.
+      */
     lazy val summaries: mutable.Map[Procedure, mutable.Map[DL, mutable.Map[DL, EdgeFunction[T]]]] = phase1.summaries()
 
     def init: T = phase2Init
@@ -188,21 +188,28 @@ abstract class IDESolver[E <: Procedure | Command, EE <: Procedure | Command, C
     val restructuredlattice: MapLattice[CFGPosition, Map[D, T], MapLattice[D, T, L]] = MapLattice(MapLattice(valuelattice))
 
     /**
-     * Restructures the analysis output to match `restructuredlattice`.
-     */
-    def restructure(y: lattice.Element): restructuredlattice.Element =
+      * Restructures the analysis output to match `restructuredlattice`.
+      */
+    def restructure(y: lattice.Element): restructuredlattice.Element = {
       y.foldLeft(Map[CFGPosition, Map[D, valuelattice.Element]]()) { case (acc, ((n, dl), e)) =>
         dl match {
           case Left(d) => acc + (n -> (acc.getOrElse(n, Map[D, valuelattice.Element]()) + (d -> e)))
           case _ => acc
         }
       }
+    }
+  }
 
   def analyze(): Map[CFGPosition, Map[D, T]] = {
-    val phase1 = Phase1(program)
-    phase1.analyze()
-    val phase2 = Phase2(program, phase1)
-    phase2.restructure(phase2.analyze())
+    if (program.mainProcedure.blocks.nonEmpty && program.mainProcedure.returnBlock.isDefined && program.mainProcedure.entryBlock.isDefined) {
+      val phase1 = Phase1()
+      phase1.analyze()
+      val phase2 = Phase2(phase1)
+      phase2.restructure(phase2.analyze())
+    } else {
+      Logger.warn(s"Disabling IDE solver tests due to external main procedure: ${program.mainProcedure.name}")
+      Map()
+    }
   }
 }
 
@@ -219,7 +226,7 @@ abstract class ForwardIDESolver[D, T, L <: Lattice[T]](program: Program)
 
   protected def returnToCall(ret: Command): DirectCall = ret match {
     case ret: Statement => ret.parent.statements.getPrev(ret).asInstanceOf[DirectCall]
-    case r: Jump => ret.parent.statements.last.asInstanceOf[DirectCall]
+    case _: Jump => ret.parent.statements.last.asInstanceOf[DirectCall]
   }
 
   protected def getCallee(call: DirectCall): Procedure = {
@@ -227,16 +234,20 @@ abstract class ForwardIDESolver[D, T, L <: Lattice[T]](program: Program)
     call.target
   }
 
-  protected def isCall(call: CFGPosition): Boolean =
-    call match
-      case directCall: DirectCall if (!directCall.successor.isInstanceOf[Unreachable] && directCall.target.returnBlock.isDefined && directCall.target.entryBlock.isDefined) => true
+  protected def isCall(call: CFGPosition): Boolean = {
+    call match {
+      case directCall: DirectCall if !directCall.successor.isInstanceOf[Unreachable] && directCall.target.returnBlock.isDefined && directCall.target.entryBlock.isDefined => true
       case _ => false
+    }
+  }
 
-  protected def isExit(exit: CFGPosition): Boolean =
-    exit match
+  protected def isExit(exit: CFGPosition): Boolean = {
+    exit match {
       // only looking at functions with statements
-      case command: Return => true
+      case _: Return => true
       case _ => false
+    }
+  }
 
   protected def getAfterCalls(exit: Return): Set[Command] =
     InterProcIRCursor.succ(exit).filter(_.isInstanceOf[Command]).map(_.asInstanceOf[Command])
@@ -244,7 +255,7 @@ abstract class ForwardIDESolver[D, T, L <: Lattice[T]](program: Program)
 
 
 abstract class BackwardIDESolver[D, T, L <: Lattice[T]](program: Program)
-  extends IDESolver[Return, Procedure, Command, DirectCall, D, T, L](program, IRWalk.lastInProc(program.mainProcedure).get),
+  extends IDESolver[Return, Procedure, Command, DirectCall, D, T, L](program, IRWalk.lastInProc(program.mainProcedure).getOrElse(program.mainProcedure)),
     BackwardIDEAnalysis[D, T, L], IRInterproceduralBackwardDependencies {
 
   protected def entryToExit(entry: Return): Procedure = IRWalk.procedure(entry)
@@ -253,7 +264,7 @@ abstract class BackwardIDESolver[D, T, L <: Lattice[T]](program: Program)
 
   protected def callToReturn(call: Command): DirectCall =  {
     IRWalk.prevCommandInBlock(call) match {
-      case Some(x : DirectCall) => x
+      case Some(x: DirectCall) => x
       case p => throw Exception(s"Not a return/aftercall node $call  .... prev = $p")
     }
   }
@@ -266,22 +277,25 @@ abstract class BackwardIDESolver[D, T, L <: Lattice[T]](program: Program)
     procCalled.returnBlock.getOrElse(throw Exception(s"No return node for procedure ${procCalled}")).jump.asInstanceOf[Return]
   }
 
-  protected def isCall(call: CFGPosition): Boolean =
-    call match
-      case c: Unreachable => false /* don't process non-returning calls */
-      case c : Command => {
+  protected def isCall(call: CFGPosition): Boolean = {
+    call match {
+      case _: Unreachable => false /* don't process non-returning calls */
+      case c: Command =>
         val call = IRWalk.prevCommandInBlock(c)
         call match {
           case Some(d: DirectCall) if d.target.returnBlock.isDefined => true
           case _ => false
         }
-      }
       case _ => false
+    }
+  }
 
-  protected def isExit(exit: CFGPosition): Boolean =
-    exit match
+  protected def isExit(exit: CFGPosition): Boolean = {
+    exit match {
       case procedure: Procedure => procedure.blocks.nonEmpty
       case _ => false
+    }
+  }
 
   protected def getAfterCalls(exit: Procedure): Set[DirectCall] = exit.incomingCalls().toSet
 }
diff --git a/src/main/scala/analysis/solvers/UnionFindSolver.scala b/src/main/scala/analysis/solvers/UnionFindSolver.scala
index bde8ef4e7..efc09b2a2 100644
--- a/src/main/scala/analysis/solvers/UnionFindSolver.scala
+++ b/src/main/scala/analysis/solvers/UnionFindSolver.scala
@@ -88,7 +88,7 @@ class UnionFindSolver[A] {
   /** Produces a string representation of the solution.
     */
   override def toString: String =
-    solution().map(p => s"${p._1} = ${p._2}").mkString("\n")
+    solution().map((k, v) => s"$k = $v").mkString("\n")
 }
 
 /** Exception thrown in case of unification failure.
diff --git a/src/main/scala/bap/BAPExpr.scala b/src/main/scala/bap/BAPExpr.scala
index 7408328dd..0f2591e3d 100644
--- a/src/main/scala/bap/BAPExpr.scala
+++ b/src/main/scala/bap/BAPExpr.scala
@@ -5,8 +5,6 @@ import ir._
 /** Expression
   */
 trait BAPExpr {
-  def toIR: Expr
-
   /*
    * The size of output of the given expression.
    *
@@ -18,8 +16,6 @@ trait BAPExpr {
 /** Concatenation of two bitvectors
   */
 case class BAPConcat(left: BAPExpr, right: BAPExpr) extends BAPExpr {
-  def toIR: BinaryExpr = BinaryExpr(BVCONCAT, left.toIR, right.toIR)
-
   override val size: Int = left.size + right.size
 }
 
@@ -28,14 +24,6 @@ case class BAPConcat(left: BAPExpr, right: BAPExpr) extends BAPExpr {
 
 case class BAPSignedExtend(width: Int, body: BAPExpr) extends BAPExpr {
   override val size: Int = width
-
-  override def toIR: Expr = {
-    if (width > body.size) {
-      SignExtend(width - body.size, body.toIR)
-    } else {
-      BAPExtract(width - 1, 0, body).toIR
-    }
-  }
 }
 
 /** Unsigned extend - pad in BIL
@@ -43,15 +31,6 @@ case class BAPSignedExtend(width: Int, body: BAPExpr) extends BAPExpr {
 
 case class BAPUnsignedExtend(width: Int, body: BAPExpr) extends BAPExpr {
   override val size: Int = width
-
-  override def toIR: Expr = {
-    if (width > body.size) {
-      ZeroExtend(width - body.size, body.toIR)
-    } else {
-      BAPExtract(width - 1, 0, body).toIR
-    }
-
-  }
 }
 
 /** Extracts the bits from firstInt to secondInt (inclusive) from variable.
@@ -61,19 +40,6 @@ case class BAPExtract(high: Int, low: Int, body: BAPExpr) extends BAPExpr {
 
   // + 1 as extracts are inclusive (e.g. [31:0] has 32 bits)
   override val size: Int = high - low + 1
-
-  override def toIR: Expr = {
-    val bodySize = body.size
-    if (size > bodySize) {
-      if (low == 0) {
-        ZeroExtend(size - bodySize, body.toIR)
-      } else {
-        Extract(high + 1, low, ZeroExtend(size - bodySize, body.toIR))
-      }
-    } else {
-      Extract(high + 1, low, body.toIR)
-    }
-  }
 }
 
 case object BAPHighCast {
@@ -90,19 +56,12 @@ case class BAPLiteral(value: BigInt, size: Int) extends BAPExpr {
 
   /** Value of literal */
   override def toString: String = s"${value}bv$size"
-
-  override def toIR: BitVecLiteral = BitVecLiteral(value, size)
 }
 
 /** Unary operator
   */
 case class BAPUnOp(operator: BAPUnOperator, exp: BAPExpr) extends BAPExpr {
   override val size: Int = exp.size
-
-  override def toIR: UnaryExpr = operator match {
-    case NOT => UnaryExpr(BVNOT, exp.toIR)
-    case NEG => UnaryExpr(BVNEG, exp.toIR)
-  }
 }
 
 sealed trait BAPUnOperator(op: String) {
@@ -126,46 +85,6 @@ case class BAPBinOp(operator: BAPBinOperator, lhs: BAPExpr, rhs: BAPExpr) extend
     case EQ | NEQ | LT | LE | SLT | SLE => 1
     case _                              => lhs.size
   }
-
-  override def toIR: Expr = operator match {
-    case PLUS    => BinaryExpr(BVADD, lhs.toIR, rhs.toIR)
-    case MINUS   => BinaryExpr(BVSUB, lhs.toIR, rhs.toIR)
-    case TIMES   => BinaryExpr(BVMUL, lhs.toIR, rhs.toIR)
-    case DIVIDE  => BinaryExpr(BVUDIV, lhs.toIR, rhs.toIR)
-    case SDIVIDE => BinaryExpr(BVSDIV, lhs.toIR, rhs.toIR)
-    // counterintuitive but correct according to BAP source
-    case MOD => BinaryExpr(BVSREM, lhs.toIR, rhs.toIR)
-    // counterintuitive but correct according to BAP source
-    case SMOD => BinaryExpr(BVUREM, lhs.toIR, rhs.toIR)
-    case LSHIFT => // BAP says caring about this case is necessary?
-      if (lhs.size == rhs.size) {
-        BinaryExpr(BVSHL, lhs.toIR, rhs.toIR)
-      } else {
-        BinaryExpr(BVSHL, lhs.toIR, ZeroExtend(lhs.size - rhs.size, rhs.toIR))
-      }
-    case RSHIFT =>
-      if (lhs.size == rhs.size) {
-        BinaryExpr(BVLSHR, lhs.toIR, rhs.toIR)
-      } else {
-        BinaryExpr(BVLSHR, lhs.toIR, ZeroExtend(lhs.size - rhs.size, rhs.toIR))
-      }
-    case ARSHIFT =>
-      if (lhs.size == rhs.size) {
-        BinaryExpr(BVASHR, lhs.toIR, rhs.toIR)
-      } else {
-        BinaryExpr(BVASHR, lhs.toIR, ZeroExtend(lhs.size - rhs.size, rhs.toIR))
-      }
-    case AND => BinaryExpr(BVAND, lhs.toIR, rhs.toIR)
-    case OR  => BinaryExpr(BVOR, lhs.toIR, rhs.toIR)
-    case XOR => BinaryExpr(BVXOR, lhs.toIR, rhs.toIR)
-    case EQ  => BinaryExpr(BVCOMP, lhs.toIR, rhs.toIR)
-    case NEQ => UnaryExpr(BVNOT, BinaryExpr(BVCOMP, lhs.toIR, rhs.toIR))
-    case LT  => BinaryExpr(BVULT, lhs.toIR, rhs.toIR)
-    case LE  => BinaryExpr(BVULE, lhs.toIR, rhs.toIR)
-    case SLT => BinaryExpr(BVSLT, lhs.toIR, rhs.toIR)
-    case SLE => BinaryExpr(BVSLE, lhs.toIR, rhs.toIR)
-  }
-
 }
 
 sealed trait BAPBinOperator(op: String) {
@@ -216,39 +135,23 @@ case object LE extends BAPBinOperator("LE")
 case object SLT extends BAPBinOperator("SLT")
 case object SLE extends BAPBinOperator("SLE")
 
-trait BAPVariable extends BAPExpr
-
-trait BAPVar extends BAPVariable {
+trait BAPVar extends BAPExpr {
   val name: String
   override val size: Int
   override def toString: String = name
-  override def toIR: Variable
 }
+case class BAPRegister(override val name: String, override val size: Int) extends BAPVar
 
-case class BAPRegister(override val name: String, override val size: Int) extends BAPVar {
-  override def toIR: Register = Register(s"$name", size)
-}
-
-case class BAPLocalVar(override val name: String, override val size: Int) extends BAPVar {
-  override def toIR: LocalVar = LocalVar(s"$name", BitVecType(size))
-}
+case class BAPLocalVar(override val name: String, override val size: Int) extends BAPVar
 
 /** A load from memory at location exp
   */
-case class BAPMemAccess(memory: BAPMemory, index: BAPExpr, endian: Endian, override val size: Int) extends BAPVariable {
+case class BAPMemAccess(memory: BAPMemory, index: BAPExpr, endian: Endian, override val size: Int) extends BAPExpr {
   override def toString: String = s"${memory.name}[$index]"
-  override def toIR: MemoryLoad = {
-    MemoryLoad(memory.toIRMemory, index.toIR, endian, size)
-  }
 }
 
-case class BAPMemory(name: String, addressSize: Int, valueSize: Int) extends BAPVariable {
-  override val size: Int = valueSize // should reconsider
-  override def toIR: Expr = ??? // should not encounter
-  def toIRMemory: Memory = SharedMemory(name, addressSize, valueSize)
-}
+case class BAPMemory(name: String, addressSize: Int, valueSize: Int)
 
 case class BAPStore(memory: BAPMemory, index: BAPExpr, value: BAPExpr, endian: Endian, size: Int) extends BAPExpr {
-  override def toIR: Expr = ??? // should not encounter
   override def toString: String = s"${memory.name}[$index] := $value"
 }
diff --git a/src/main/scala/bap/BAPProgram.scala b/src/main/scala/bap/BAPProgram.scala
index c586f5980..ed1f65400 100644
--- a/src/main/scala/bap/BAPProgram.scala
+++ b/src/main/scala/bap/BAPProgram.scala
@@ -45,15 +45,6 @@ case class BAPBlock(label: String, address: Option[BigInt], statements: List[BAP
 
 }
 
-case class BAPParameter(name: String, size: Int, value: BAPVar) {
-  def toIR: Parameter = {
-    val register = value.toIR
-    register match {
-      case r: Register => Parameter(name, size, r)
-      case _           => throw Exception(s"subroutine parameter $this refers to non-register variable $value")
-    }
-
-  }
-}
+case class BAPParameter(name: String, size: Int, value: BAPVar)
 
 case class BAPMemorySection(name: String, address: BigInt, size: Int, bytes: Seq[BAPLiteral])
diff --git a/src/main/scala/bap/BAPStatement.scala b/src/main/scala/bap/BAPStatement.scala
index 09b77f60d..2f9afe34d 100644
--- a/src/main/scala/bap/BAPStatement.scala
+++ b/src/main/scala/bap/BAPStatement.scala
@@ -23,14 +23,12 @@ case class BAPGoTo(target: String, condition: BAPExpr, override val line: String
 
 sealed trait BAPStatement
 
-sealed trait BAPAssign(lhs: BAPVariable, rhs: BAPExpr, line: String, instruction: String) extends BAPStatement {
-  override def toString: String = String.format("%s := %s;", lhs, rhs)
-}
-
 /** Memory store
   */
-case class BAPMemAssign(lhs: BAPMemory, rhs: BAPStore, line: String, instruction: String, address: Option[BigInt] = None)
-    extends BAPAssign(lhs, rhs, line, instruction)
+case class BAPMemAssign(lhs: BAPMemory, rhs: BAPStore, line: String, instruction: String, address: Option[BigInt] = None) extends BAPStatement {
+  override def toString: String = String.format("%s := %s;", lhs, rhs)
+}
 
-case class BAPLocalAssign(lhs: BAPVar, rhs: BAPExpr, line: String, instruction: String, address: Option[BigInt] = None)
-    extends BAPAssign(lhs, rhs, line, instruction)
+case class BAPLocalAssign(lhs: BAPVar, rhs: BAPExpr, line: String, instruction: String, address: Option[BigInt] = None) extends BAPStatement {
+  override def toString: String = String.format("%s := %s;", lhs, rhs)
+}
diff --git a/src/main/scala/boogie/BExpr.scala b/src/main/scala/boogie/BExpr.scala
index 2c5b5c1d8..d334d6800 100644
--- a/src/main/scala/boogie/BExpr.scala
+++ b/src/main/scala/boogie/BExpr.scala
@@ -10,22 +10,15 @@ trait BExpr {
   def functionOps: Set[FunctionOp] = Set()
   def locals: Set[BVar] = Set()
   def globals: Set[BVar] = Set()
+  def params: Set[BVar] = Set()
   def specGlobals: Set[SpecGlobalOrAccess] = Set()
   def oldSpecGlobals: Set[SpecGlobalOrAccess] = Set()
-  def resolveSpec: BExpr = this
-  def resolveOld: BExpr = this
-  def removeOld: BExpr = this
-  def resolveSpecL: BExpr = this
-  def resolveInsideOld: BExpr = this
-  def resolveSpecParam: BExpr = this
-  def resolveSpecParamOld: BExpr = this
-  def resolveSpecInv: BExpr = this
-  def resolveSpecInvOld: BExpr = this
   def loads: Set[BExpr] = Set()
   def serialiseBoogie(w: Writer): Unit = w.append(toString)
+  def acceptVisit(visitor: BVisitor): BExpr = this
 }
 
-trait BLiteral extends BExpr {}
+trait BLiteral extends BExpr
 
 sealed trait BoolBLiteral extends BLiteral
 
@@ -39,7 +32,6 @@ case object StarBLiteral extends BoolBLiteral {
   override def toString: String = "*"
 }
 
-
 case object FalseBLiteral extends BoolBLiteral {
   override val getType: BType = BoolBType
   override def toString: String = "false"
@@ -53,10 +45,6 @@ case class BitVecBLiteral(value: BigInt, size: Int) extends BLiteral {
 case class IntBLiteral(value: BigInt) extends BLiteral {
   override val getType: BType = IntBType
   override def toString: String = value.toString
-  override def resolveSpecL: BitVecBLiteral = BitVecBLiteral(value, 32) // TODO
-  override def resolveSpec: BitVecBLiteral = BitVecBLiteral(value, 32) // TODO
-  override def resolveOld: BitVecBLiteral = BitVecBLiteral(value, 32) // TODO
-  override def removeOld: BitVecBLiteral = BitVecBLiteral(value, 32) // TODO
 }
 
 case class BVExtract(end: Int, start: Int, body: BExpr) extends BExpr {
@@ -65,17 +53,9 @@ case class BVExtract(end: Int, start: Int, body: BExpr) extends BExpr {
   override def functionOps: Set[FunctionOp] = body.functionOps
   override def locals: Set[BVar] = body.locals
   override def globals: Set[BVar] = body.globals
+  override def params: Set[BVar] = body.params
   override def specGlobals: Set[SpecGlobalOrAccess] = body.specGlobals
   override def oldSpecGlobals: Set[SpecGlobalOrAccess] = body.oldSpecGlobals
-  override def resolveSpec: BVExtract = copy(body = body.resolveSpec)
-  override def resolveSpecInv: BVExtract = copy(body = body.resolveSpecInv)
-  override def resolveSpecInvOld: BVExtract = copy(body = body.resolveSpecInvOld)
-  override def resolveSpecParam: BVExtract = copy(body = body.resolveSpecParam)
-  override def resolveSpecParamOld: BVExtract = copy(body = body.resolveSpecParamOld)
-  override def resolveSpecL: BVExtract = copy(body = body.resolveSpecL)
-  override def resolveOld: BVExtract = copy(body = body.resolveOld)
-  override def resolveInsideOld: BVExtract = copy(body = body.resolveInsideOld)
-  override def removeOld: BVExtract = copy(body = body.removeOld)
   override def loads: Set[BExpr] = body.loads
 
   override def serialiseBoogie(w: Writer): Unit = {
@@ -83,6 +63,8 @@ case class BVExtract(end: Int, start: Int, body: BExpr) extends BExpr {
     w.append(s"[$end:$start]")
   }
 
+  override def acceptVisit(visitor: BVisitor): BExpr = visitor.visitBVExtract(this)
+
 }
 
 case class BVRepeat(repeats: Int, body: BExpr) extends BExpr {
@@ -109,18 +91,11 @@ case class BVRepeat(repeats: Int, body: BExpr) extends BExpr {
   }
   override def locals: Set[BVar] = body.locals
   override def globals: Set[BVar] = body.globals
+  override def params: Set[BVar] = body.params
   override def specGlobals: Set[SpecGlobalOrAccess] = body.specGlobals
   override def oldSpecGlobals: Set[SpecGlobalOrAccess] = body.oldSpecGlobals
-  override def resolveSpec: BVRepeat = copy(body = body.resolveSpec)
-  override def resolveSpecInv: BVRepeat = copy(body = body.resolveSpecInv)
-  override def resolveSpecInvOld: BVRepeat = copy(body = body.resolveSpecInvOld)
-  override def resolveSpecParam: BVRepeat = copy(body = body.resolveSpecParam)
-  override def resolveSpecParamOld: BVRepeat = copy(body = body.resolveSpecParamOld)
-  override def resolveSpecL: BVRepeat = copy(body = body.resolveSpecL)
-  override def resolveOld: BVRepeat = copy(body = body.resolveOld)
-  override def resolveInsideOld: BVRepeat = copy(body = body.resolveInsideOld)
-  override def removeOld: BVRepeat = copy(body = body.removeOld)
   override def loads: Set[BExpr] = body.loads
+  override def acceptVisit(visitor: BVisitor): BExpr = visitor.visitBVRepeat(this)
 }
 
 case class BVZeroExtend(extension: Int, body: BExpr) extends BExpr {
@@ -148,18 +123,12 @@ case class BVZeroExtend(extension: Int, body: BExpr) extends BExpr {
   }
   override def locals: Set[BVar] = body.locals
   override def globals: Set[BVar] = body.globals
+  override def params: Set[BVar] = body.params
   override def specGlobals: Set[SpecGlobalOrAccess] = body.specGlobals
   override def oldSpecGlobals: Set[SpecGlobalOrAccess] = body.oldSpecGlobals
-  override def resolveSpec: BVZeroExtend = copy(body = body.resolveSpec)
-  override def resolveSpecInv: BVZeroExtend = copy(body = body.resolveSpecInv)
-  override def resolveSpecInvOld: BVZeroExtend = copy(body = body.resolveSpecInvOld)
-  override def resolveSpecParam: BVZeroExtend = copy(body = body.resolveSpecParam)
-  override def resolveSpecParamOld: BVZeroExtend = copy(body = body.resolveSpecParamOld)
-  override def resolveSpecL: BVZeroExtend = copy(body = body.resolveSpecL)
-  override def resolveOld: BExpr = copy(body = body.resolveOld)
-  override def resolveInsideOld: BExpr = copy(body = body.resolveInsideOld)
-  override def removeOld: BExpr = copy(body = body.removeOld)
   override def loads: Set[BExpr] = body.loads
+
+  override def acceptVisit(visitor: BVisitor): BExpr = visitor.visitBVZeroExtend(this)
 }
 
 case class BVSignExtend(extension: Int, body: BExpr) extends BExpr {
@@ -181,25 +150,17 @@ case class BVSignExtend(extension: Int, body: BExpr) extends BExpr {
     w.append(")")
   }
 
-
   override def functionOps: Set[FunctionOp] = {
     val thisFn = BVFunctionOp(fnName, s"sign_extend $extension", List(BParam(BitVecBType(bodySize))), BParam(getType))
     body.functionOps + thisFn
   }
   override def locals: Set[BVar] = body.locals
   override def globals: Set[BVar] = body.globals
+  override def params: Set[BVar] = body.params
   override def specGlobals: Set[SpecGlobalOrAccess] = body.specGlobals
   override def oldSpecGlobals: Set[SpecGlobalOrAccess] = body.oldSpecGlobals
-  override def resolveSpecL: BVSignExtend = copy(body = body.resolveSpecL)
-  override def resolveSpec: BVSignExtend = copy(body = body.resolveSpec)
-  override def resolveSpecInv: BVSignExtend = copy(body = body.resolveSpecInv)
-  override def resolveSpecInvOld: BVSignExtend = copy(body = body.resolveSpecInvOld)
-  override def resolveSpecParam: BVSignExtend = copy(body = body.resolveSpecParam)
-  override def resolveSpecParamOld: BVSignExtend = copy(body = body.resolveSpecParamOld)
-  override def resolveOld: BExpr = copy(body = body.resolveOld)
-  override def resolveInsideOld: BExpr = copy(body = body.resolveInsideOld)
-  override def removeOld: BExpr = copy(body = body.removeOld)
   override def loads: Set[BExpr] = body.loads
+  override def acceptVisit(visitor: BVisitor): BExpr = visitor.visitBVSignExtend(this)
 }
 
 abstract class BVar(val name: String, val bType: BType, val scope: Scope) extends BExpr with Ordered[BVar] {
@@ -220,6 +181,10 @@ abstract class BVar(val name: String, val bType: BType, val scope: Scope) extend
     case Scope.Global => Set(this)
     case _            => Set()
   }
+  override def params: Set[BVar] = scope match {
+    case Scope.Parameter => Set(this)
+    case _ => Set()
+  }
 }
 
 case class BVariable(override val name: String, override val bType: BType, override val scope: Scope)
@@ -255,17 +220,11 @@ case class BFunctionCall(name: String, args: List[BExpr], outType: BType, uninte
   }
   override def locals: Set[BVar] = args.flatMap(a => a.locals).toSet
   override def globals: Set[BVar] = args.flatMap(a => a.globals).toSet
+  override def params: Set[BVar] = args.flatMap(a => a.params).toSet
   override def specGlobals: Set[SpecGlobalOrAccess] = args.flatMap(a => a.specGlobals).toSet
   override def oldSpecGlobals: Set[SpecGlobalOrAccess] = args.flatMap(a => a.oldSpecGlobals).toSet
-  override def resolveSpec: BFunctionCall = copy(args = args.map(a => a.resolveSpec))
-  override def resolveSpecInv: BFunctionCall = copy(args = args.map(a => a.resolveSpecInv))
-  override def resolveSpecInvOld: BFunctionCall = copy(args = args.map(a => a.resolveSpecInvOld))
-  override def resolveSpecParam: BFunctionCall = copy(args = args.map(a => a.resolveSpecParam))
-  override def resolveSpecParamOld: BFunctionCall = copy(args = args.map(a => a.resolveSpecParamOld))
-  override def resolveSpecL: BFunctionCall = copy(args = args.map(a => a.resolveSpecL))
-  override def resolveOld: BExpr = copy(args = args.map(a => a.resolveOld))
-  override def removeOld: BExpr = copy(args = args.map(a => a.removeOld))
   override def loads: Set[BExpr] = args.flatMap(a => a.loads).toSet
+  override def acceptVisit(visitor: BVisitor): BExpr = visitor.visitBFunctionCall(this)
 }
 
 case class UnaryBExpr(op: UnOp, arg: BExpr) extends BExpr {
@@ -298,45 +257,12 @@ case class UnaryBExpr(op: UnOp, arg: BExpr) extends BExpr {
 
   override def locals: Set[BVar] = arg.locals
   override def globals: Set[BVar] = arg.globals
+  override def params: Set[BVar] = arg.params
   override def specGlobals: Set[SpecGlobalOrAccess] = arg.specGlobals
   override def oldSpecGlobals: Set[SpecGlobalOrAccess] = arg.oldSpecGlobals
-  override def resolveSpec: UnaryBExpr = op match {
-    case i: IntUnOp => copy(op = i.toBV, arg = arg.resolveSpec)
-    case _          => copy(arg = arg.resolveSpec)
-  }
-  override def resolveSpecInv: UnaryBExpr = op match {
-    case i: IntUnOp => copy(op = i.toBV, arg = arg.resolveSpecInv)
-    case _ => copy(arg = arg.resolveSpecInv)
-  }
-  override def resolveSpecInvOld: UnaryBExpr = op match {
-    case i: IntUnOp => copy(op = i.toBV, arg = arg.resolveSpecInvOld)
-    case _ => copy(arg = arg.resolveSpecInvOld)
-  }
-  override def resolveSpecParam: UnaryBExpr = op match {
-    case i: IntUnOp => copy(op = i.toBV, arg = arg.resolveSpecParam)
-    case _ => copy(arg = arg.resolveSpecParam)
-  }
-  override def resolveSpecParamOld: UnaryBExpr = op match {
-    case i: IntUnOp => copy(op = i.toBV, arg = arg.resolveSpecParamOld)
-    case _ => copy(arg = arg.resolveSpecParamOld)
-  }
-  override def resolveSpecL: UnaryBExpr = op match {
-    case i: IntUnOp => copy(op = i.toBV, arg = arg.resolveSpecL)
-    case _          => copy(arg = arg.resolveSpecL)
-  }
-  override def resolveOld: BExpr = op match {
-    case i: IntUnOp => copy(op = i.toBV, arg = arg.resolveOld)
-    case _          => copy(arg = arg.resolveOld)
-  }
-  override def resolveInsideOld: BExpr = op match {
-    case i: IntUnOp => copy(op = i.toBV, arg = arg.resolveInsideOld)
-    case _          => copy(arg = arg.resolveInsideOld)
-  }
-  override def removeOld: BExpr = op match {
-    case i: IntUnOp => copy(op = i.toBV, arg = arg.removeOld)
-    case _          => copy(arg = arg.removeOld)
-  }
   override def loads: Set[BExpr] = arg.loads
+
+  override def acceptVisit(visitor: BVisitor): BExpr = visitor.visitUnaryBExpr(this)
 }
 
 case class BinaryBExpr(op: BinOp, arg1: BExpr, arg2: BExpr) extends BExpr {
@@ -420,8 +346,6 @@ case class BinaryBExpr(op: BinOp, arg1: BExpr, arg2: BExpr) extends BExpr {
     case bOp: IntBinOp => s"($arg1 $bOp $arg2)"
   }
 
-
-
   override def functionOps: Set[FunctionOp] = {
     val thisFn = op match {
       case b: BVBinOp =>
@@ -439,54 +363,12 @@ case class BinaryBExpr(op: BinOp, arg1: BExpr, arg2: BExpr) extends BExpr {
 
   override def locals: Set[BVar] = arg1.locals ++ arg2.locals
   override def globals: Set[BVar] = arg1.globals ++ arg2.globals
+  override def params: Set[BVar] = arg1.params ++ arg2.params
   override def specGlobals: Set[SpecGlobalOrAccess] = arg1.specGlobals ++ arg2.specGlobals
   override def oldSpecGlobals: Set[SpecGlobalOrAccess] = arg1.oldSpecGlobals ++ arg2.oldSpecGlobals
-
-  override def resolveSpec: BinaryBExpr = op match {
-    case i: IntBinOp => copy(op = i.toBV, arg1 = arg1.resolveSpec, arg2 = arg2.resolveSpec)
-    case _           => copy(arg1 = arg1.resolveSpec, arg2 = arg2.resolveSpec)
-  }
-
-  override def resolveSpecInv: BinaryBExpr = op match {
-    case i: IntBinOp => copy(op = i.toBV, arg1 = arg1.resolveSpecInv, arg2 = arg2.resolveSpecInv)
-    case _ => copy(arg1 = arg1.resolveSpecInv, arg2 = arg2.resolveSpecInv)
-  }
-
-  override def resolveSpecInvOld: BinaryBExpr = op match {
-    case i: IntBinOp => copy(op = i.toBV, arg1 = arg1.resolveSpecInvOld, arg2 = arg2.resolveSpecInvOld)
-    case _ => copy(arg1 = arg1.resolveSpecInvOld, arg2 = arg2.resolveSpecInvOld)
-  }
-
-  override def resolveSpecParamOld: BinaryBExpr = op match {
-    case i: IntBinOp => copy(op = i.toBV, arg1 = arg1.resolveSpec, arg2 = arg2.resolveSpecParamOld)
-    case _ => copy(arg1 = arg1.resolveSpecParamOld, arg2 = arg2.resolveSpecParamOld)
-  }
-
-  override def resolveSpecParam: BinaryBExpr = op match {
-    case i: IntBinOp => copy(op = i.toBV, arg1 = arg1.resolveSpecParam, arg2 = arg2.resolveSpecParam)
-    case _ => copy(arg1 = arg1.resolveSpecParam, arg2 = arg2.resolveSpecParam)
-  }
-
-  override def resolveSpecL: BinaryBExpr = op match {
-    case i: IntBinOp => copy(op = i.toBV, arg1 = arg1.resolveSpecL, arg2 = arg2.resolveSpecL)
-    case _           => copy(arg1 = arg1.resolveSpecL, arg2 = arg2.resolveSpecL)
-  }
-
-  override def resolveOld: BinaryBExpr = op match {
-    case i: IntBinOp => copy(op = i.toBV, arg1 = arg1.resolveOld, arg2 = arg2.resolveOld)
-    case _           => copy(arg1 = arg1.resolveOld, arg2 = arg2.resolveOld)
-  }
-
-  override def resolveInsideOld: BinaryBExpr = op match {
-    case i: IntBinOp => copy(op = i.toBV, arg1 = arg1.resolveInsideOld, arg2 = arg2.resolveInsideOld)
-    case _           => copy(arg1 = arg1.resolveInsideOld, arg2 = arg2.resolveInsideOld)
-  }
-
-  override def removeOld: BinaryBExpr = op match {
-    case i: IntBinOp => copy(op = i.toBV, arg1 = arg1.removeOld, arg2 = arg2.removeOld)
-    case _           => copy(arg1 = arg1.removeOld, arg2 = arg2.removeOld)
-  }
   override def loads: Set[BExpr] = arg1.loads ++ arg2.loads
+
+  override def acceptVisit(visitor: BVisitor): BExpr = visitor.visitBinaryBExpr(this)
 }
 
 case class IfThenElse(guard: BExpr, thenExpr: BExpr, elseExpr: BExpr) extends BExpr {
@@ -502,28 +384,13 @@ case class IfThenElse(guard: BExpr, thenExpr: BExpr, elseExpr: BExpr) extends BE
   override def functionOps: Set[FunctionOp] = guard.functionOps ++ thenExpr.functionOps ++ elseExpr.functionOps
   override def locals: Set[BVar] = guard.locals ++ thenExpr.locals ++ elseExpr.locals
   override def globals: Set[BVar] = guard.globals ++ thenExpr.globals ++ elseExpr.globals
+  override def params: Set[BVar] = guard.params ++ thenExpr.params ++ elseExpr.params
   override def specGlobals: Set[SpecGlobalOrAccess] = guard.specGlobals ++ thenExpr.specGlobals ++ elseExpr.specGlobals
   override def oldSpecGlobals: Set[SpecGlobalOrAccess] =
     guard.oldSpecGlobals ++ thenExpr.oldSpecGlobals ++ elseExpr.oldSpecGlobals
-  override def resolveSpec: IfThenElse =
-    copy(guard = guard.resolveSpec, thenExpr = thenExpr.resolveSpec, elseExpr = elseExpr.resolveSpec)
-  override def resolveSpecInv: IfThenElse =
-    copy(guard = guard.resolveSpecInv, thenExpr = thenExpr.resolveSpecInv, elseExpr = elseExpr.resolveSpecInv)
-  override def resolveSpecInvOld: IfThenElse =
-    copy(guard = guard.resolveSpecInvOld, thenExpr = thenExpr.resolveSpecInvOld, elseExpr = elseExpr.resolveSpecInvOld)
-  override def resolveSpecParam: IfThenElse =
-    copy(guard = guard.resolveSpecParam, thenExpr = thenExpr.resolveSpecParam, elseExpr = elseExpr.resolveSpecParam)
-  override def resolveSpecParamOld: IfThenElse =
-    copy(guard = guard.resolveSpecParamOld, thenExpr = thenExpr.resolveSpecParamOld, elseExpr = elseExpr.resolveSpecParamOld)
-  override def resolveSpecL: IfThenElse =
-    copy(guard = guard.resolveSpecL, thenExpr = thenExpr.resolveSpecL, elseExpr = elseExpr.resolveSpecL)
-  override def resolveOld: IfThenElse =
-    copy(guard = guard.resolveOld, thenExpr = thenExpr.resolveOld, elseExpr = elseExpr.resolveOld)
-  override def resolveInsideOld: IfThenElse =
-    copy(guard = guard.resolveInsideOld, thenExpr = thenExpr.resolveInsideOld, elseExpr = elseExpr.resolveInsideOld)
-  override def removeOld: IfThenElse =
-    copy(guard = guard.removeOld, thenExpr = thenExpr.removeOld, elseExpr = elseExpr.removeOld)
   override def loads: Set[BExpr] = guard.loads ++ thenExpr.loads ++ elseExpr.loads
+
+  override def acceptVisit(visitor: BVisitor): BExpr = visitor.visitIfThenElse(this)
 }
 
 trait QuantifierExpr(sort: Quantifier, bound: List[BVar], body: BExpr) extends BExpr {
@@ -535,6 +402,7 @@ trait QuantifierExpr(sort: Quantifier, bound: List[BVar], body: BExpr) extends B
   override def functionOps: Set[FunctionOp] = body.functionOps
   override def locals: Set[BVar] = body.locals -- bound.toSet
   override def globals: Set[BVar] = body.globals -- bound.toSet
+  override def params: Set[BVar] = body.params -- bound.toSet
   override def specGlobals: Set[SpecGlobalOrAccess] = body.specGlobals
   override def oldSpecGlobals: Set[SpecGlobalOrAccess] = body.oldSpecGlobals
   override def loads: Set[BExpr] = body.loads
@@ -558,14 +426,10 @@ case class Old(body: BExpr) extends BExpr {
   override def functionOps: Set[FunctionOp] = body.functionOps
   override def locals: Set[BVar] = body.locals
   override def globals: Set[BVar] = body.globals
+  override def params: Set[BVar] = body.params
   override def oldSpecGlobals: Set[SpecGlobalOrAccess] = body.specGlobals
-  override def resolveSpecParam: BExpr = body.resolveSpecParamOld
-  override def resolveSpecInv: BExpr = body.resolveSpecInvOld
-  override def resolveSpec: BExpr = copy(body = body.resolveSpec)
-  override def resolveSpecL: BExpr = copy(body = body.resolveSpecL)
-  override def resolveOld: BExpr = body.resolveInsideOld
-  override def removeOld: BExpr = body.resolveSpec
   override def loads: Set[BExpr] = body.loads
+  override def acceptVisit(visitor: BVisitor): BExpr = visitor.visitOld(this)
 }
 
 case class MapAccess(mapVar: BMapVar, index: BExpr) extends BExpr {
@@ -574,6 +438,7 @@ case class MapAccess(mapVar: BMapVar, index: BExpr) extends BExpr {
   override def functionOps: Set[FunctionOp] = index.functionOps
   override def locals: Set[BVar] = index.locals
   override def globals: Set[BVar] = index.globals ++ mapVar.globals
+  override def params: Set[BVar] = index.params ++ mapVar.params
   override def loads: Set[BExpr] = index.loads
 }
 
@@ -583,6 +448,7 @@ case class MapUpdate(map: BExpr, index: BExpr, value: BExpr) extends BExpr {
   override def functionOps: Set[FunctionOp] = map.functionOps ++ index.functionOps ++ value.functionOps
   override def locals: Set[BVar] = map.locals ++ index.locals ++ value.locals
   override def globals: Set[BVar] = index.globals ++ map.globals ++ value.globals
+  override def params: Set[BVar] = index.params ++ map.params ++ value.params
   override def loads: Set[BExpr] = index.loads ++ value.loads ++ map.loads
 }
 
@@ -614,7 +480,7 @@ case class GammaLoadOp(addressSize: Int, bits: Int, accesses: Int) extends Funct
 case class GammaStoreOp(addressSize: Int, bits: Int, accesses: Int) extends FunctionOp {
   val fnName: String = s"gamma_store$bits"
 }
-case class LOp(memoryType: BType, indexType: BType) extends FunctionOp
+case class LOp(indexType: BType) extends FunctionOp
 
 /**
  * Utility to extract a particular byte from a bitvector.
@@ -643,6 +509,7 @@ case class BByteExtract(value: BExpr, offset: BExpr) extends BExpr {
     value.functionOps ++ offset.functionOps + ByteExtract(valueSize, offsetSize)
   override def locals: Set[BVar] = value.locals ++ offset.locals
   override def globals: Set[BVar] = value.globals ++ offset.globals
+  override def params: Set[BVar] = value.params ++ offset.params
   override def loads: Set[BExpr] = value.loads ++ offset.loads
 }
 
@@ -676,7 +543,8 @@ case class BInBounds(base: BExpr, len: BExpr, endian: Endian, i: BExpr) extends
   override def functionOps: Set[FunctionOp] =
     base.functionOps ++ len.functionOps ++ i.functionOps + InBounds(baseSize, endian)
   override def locals: Set[BVar]  = base.locals ++ len.locals ++ i.locals
-  override def globals: Set[BVar] = base.globals ++ len.globals ++ i.globals 
+  override def globals: Set[BVar] = base.globals ++ len.globals ++ i.globals
+  override def params: Set[BVar] = base.params ++ len.params ++ i.params
   override def loads: Set[BExpr]  = base.loads ++ len.loads ++ i.loads 
 }
 
@@ -703,6 +571,7 @@ case class BMemoryLoad(memory: BMapVar, index: BExpr, endian: Endian, bits: Int)
     memory.functionOps ++ index.functionOps + MemoryLoadOp(addressSize, valueSize, endian, bits)
   override def locals: Set[BVar] = memory.locals ++ index.locals
   override def globals: Set[BVar] = index.globals ++ memory.globals
+  override def params: Set[BVar] = index.params ++ memory.params
   override def loads: Set[BExpr] = Set(this) ++ index.loads
 }
 
@@ -729,6 +598,7 @@ case class BMemoryStore(memory: BMapVar, index: BExpr, value: BExpr, endian: End
     memory.functionOps ++ index.functionOps ++ value.functionOps + MemoryStoreOp(addressSize, valueSize, endian, bits)
   override def locals: Set[BVar] = memory.locals ++ index.locals ++ value.locals
   override def globals: Set[BVar] = index.globals ++ memory.globals ++ value.globals
+  override def params: Set[BVar] = index.params ++ memory.params ++ value.params
   override def loads: Set[BExpr] = index.loads ++ value.loads
 }
 
@@ -753,6 +623,7 @@ case class GammaLoad(gammaMap: BMapVar, index: BExpr, bits: Int, accesses: Int)
     gammaMap.functionOps ++ index.functionOps + GammaLoadOp(addressSize, bits, accesses)
   override def locals: Set[BVar] = gammaMap.locals ++ index.locals
   override def globals: Set[BVar] = index.globals ++ gammaMap.globals
+  override def params: Set[BVar] = index.params ++ gammaMap.params
   override def loads: Set[BExpr] = Set(this) ++ index.loads
 }
 
@@ -772,14 +643,20 @@ case class GammaStore(gammaMap: BMapVar, index: BExpr, value: BExpr, bits: Int,
     gammaMap.functionOps ++ index.functionOps ++ value.functionOps + GammaStoreOp(addressSize, bits, accesses)
   override def locals: Set[BVar] = gammaMap.locals ++ index.locals ++ value.locals
   override def globals: Set[BVar] = index.globals ++ gammaMap.globals ++ value.globals
+  override def params: Set[BVar] = index.params ++ gammaMap.params ++ value.params
   override def loads: Set[BExpr] = index.loads ++ value.loads
 }
 
-case class L(memory: BMapVar, index: BExpr) extends BExpr {
-  override def toString: String = s"L($memory, $index)"
+case class L(memories: List[BMapVar], index: BExpr) extends BExpr {
+  override def toString: String = if (memories.isEmpty) {
+    s"L($index)"
+  } else {
+    s"L(${memories.mkString(", ")}, $index)"
+  }
   override val getType: BType = BoolBType
-  override def functionOps: Set[FunctionOp] = index.functionOps + LOp(memory.getType, index.getType)
-  override def locals: Set[BVar] = index.locals
-  override def globals: Set[BVar] = index.globals
+  override def functionOps: Set[FunctionOp] = index.functionOps + LOp(index.getType)
+  override def locals: Set[BVar] = index.locals ++ memories.flatMap(_.locals)
+  override def globals: Set[BVar] = index.globals ++ memories.flatMap(_.globals)
+  override def params: Set[BVar] = index.params ++ memories.flatMap(_.params)
   override def loads: Set[BExpr] = index.loads
 }
diff --git a/src/main/scala/boogie/BProgram.scala b/src/main/scala/boogie/BProgram.scala
index fe6d19e0b..b8e276bf6 100644
--- a/src/main/scala/boogie/BProgram.scala
+++ b/src/main/scala/boogie/BProgram.scala
@@ -75,12 +75,19 @@ case class BProcedure(
     procList ++ implList ++ List("")
   }
   override def toString: String = toBoogie.mkString("\n")
-  def functionOps: Set[FunctionOp] =
-    body.flatMap(c => c.functionOps).toSet ++ ensures.flatMap(c => c.functionOps).toSet ++ requires
-      .flatMap(c => c.functionOps)
-      .toSet ++ freeEnsures.flatMap(c => c.functionOps).toSet ++ freeRequires.flatMap(c => c.functionOps).toSet
+  def functionOps: Set[FunctionOp] = {
+    val bodyOps = body.flatMap(_.functionOps)
+    val ensuresOps = ensures.flatMap(_.functionOps) ++ freeEnsures.flatMap(_.functionOps)
+    val requiresOps = requires.flatMap(_.functionOps) ++ freeRequires.flatMap(_.functionOps)
+    (bodyOps ++ ensuresOps ++ requiresOps).toSet
+  }
 
-  def globals: Set[BVar] = body.flatMap(c => c.globals).toSet ++ modifies
+  def globals: Set[BVar] = {
+    val bodyGlobals = body.flatMap(_.globals)
+    val ensuresGlobals = ensures.flatMap(_.globals) ++ freeEnsures.flatMap(_.globals)
+    val requiresGlobals = requires.flatMap(_.globals) ++ freeRequires.flatMap(_.globals)
+    (bodyGlobals ++ ensuresGlobals ++ requiresGlobals).toSet ++ modifies
+  }
 }
 
 case class BAxiom(body: BExpr, override val attributes: List[BAttribute] = List()) extends BDeclaration {
diff --git a/src/main/scala/boogie/BVisitor.scala b/src/main/scala/boogie/BVisitor.scala
new file mode 100644
index 000000000..cc8dad009
--- /dev/null
+++ b/src/main/scala/boogie/BVisitor.scala
@@ -0,0 +1,263 @@
+package boogie
+
+import analysis.RegionInjector
+import ir.{Endian, IntBinOp, IntUnOp}
+import specification.{ArrayAccess, SpecGamma, SpecGlobal}
+
+trait BVisitor {
+  def visitBExpr(node: BExpr): BExpr = node.acceptVisit(this)
+
+  def visitBVExtract(node: BVExtract): BExpr = node.copy(body = visitBExpr(node.body))
+
+  def visitBVRepeat(node: BVRepeat): BExpr = node.copy(body = visitBExpr(node.body))
+
+  def visitBVZeroExtend(node: BVZeroExtend): BExpr = node.copy(body = visitBExpr(node.body))
+
+  def visitBVSignExtend(node: BVSignExtend): BExpr = node.copy(body = visitBExpr(node.body))
+
+  def visitBFunctionCall(node: BFunctionCall): BExpr = node.copy(args = node.args.map(visitBExpr))
+
+  def visitUnaryBExpr(node: UnaryBExpr): BExpr = node.copy(arg = visitBExpr(node.arg))
+
+  def visitBinaryBExpr(node: BinaryBExpr): BExpr = {
+    node.copy(arg1 = visitBExpr(node.arg1), arg2 = visitBExpr(node.arg2))
+  }
+
+  def visitIfThenElse(node: IfThenElse): BExpr = {
+    node.copy(guard = visitBExpr(node.guard), thenExpr = visitBExpr(node.thenExpr), elseExpr = visitBExpr(node.elseExpr))
+  }
+
+  def visitOld(node: Old): BExpr = node.copy(body = visitBExpr(node.body))
+
+  def visitSpecGlobal(node: SpecGlobal): BExpr = node
+
+  def visitSpecGamma(node: SpecGamma): BExpr = node
+
+  def visitArrayAccess(node: ArrayAccess): BExpr = node
+}
+
+trait SpecResolutionVisitor extends BVisitor {
+  override def visitUnaryBExpr(node: UnaryBExpr): BExpr = {
+    node.op match {
+      case i: IntUnOp => node.copy(op = i.toBV, arg = visitBExpr(node.arg))
+      case _ => node.copy(arg = visitBExpr(node.arg))
+    }
+  }
+
+  override def visitBinaryBExpr(node: BinaryBExpr): BExpr = {
+    node.op match {
+      case i: IntBinOp => node.copy(op = i.toBV, arg1 = visitBExpr(node.arg1), arg2 = visitBExpr(node.arg2))
+      case _ => node.copy(arg1 = visitBExpr(node.arg1), arg2 = visitBExpr(node.arg2))
+    }
+  }
+}
+
+class ResolveSpec(regionInjector: Option[RegionInjector]) extends SpecResolutionVisitor {
+  private val mem = BMapVar("mem", MapBType(BitVecBType(64), BitVecBType(8)), Scope.Global)
+  private val gammaMem = BMapVar("Gamma_mem", MapBType(BitVecBType(64), BoolBType), Scope.Global)
+
+  override def visitSpecGlobal(node: SpecGlobal): BMemoryLoad = {
+    val memory = if (regionInjector.isDefined) {
+      regionInjector.get.getMergedRegion(node.address) match {
+        case Some(region) => BMapVar(region.name, MapBType(BitVecBType(64), BitVecBType(8)), Scope.Global)
+        case None => mem
+      }
+    } else {
+      mem
+    }
+    BMemoryLoad(memory, node.toAddrVar, Endian.LittleEndian, node.size)
+  }
+
+  override def visitSpecGamma(node: SpecGamma): GammaLoad = {
+    val gammaMemory = if (regionInjector.isDefined) {
+      regionInjector.get.getMergedRegion(node.address) match {
+        case Some(region) => BMapVar(s"Gamma_${region.name}", MapBType(BitVecBType(64), BoolBType), Scope.Global)
+        case None => gammaMem
+      }
+    } else {
+      gammaMem
+    }
+    GammaLoad(gammaMemory, node.global.toAddrVar, node.global.size, node.global.size / 8)
+  }
+
+  override def visitArrayAccess(node: ArrayAccess): BMemoryLoad = {
+    val memory = if (regionInjector.isDefined) {
+      regionInjector.get.getMergedRegion(node.address) match {
+        case Some(region) => BMapVar(region.name, MapBType(BitVecBType(64), BitVecBType(8)), Scope.Global)
+        case None => mem
+      }
+    } else {
+      mem
+    }
+    BMemoryLoad(memory, node.toAddrVar, Endian.LittleEndian, node.size)
+  }
+
+}
+
+class ResolveOld(resolveSpec: ResolveSpec) extends SpecResolutionVisitor {
+  override def visitOld(node: Old): BExpr = ResolveInsideOld.visitBExpr(node.body)
+  override def visitSpecGlobal(node: SpecGlobal): BMemoryLoad = resolveSpec.visitSpecGlobal(node)
+  override def visitSpecGamma(node: SpecGamma): GammaLoad = resolveSpec.visitSpecGamma(node)
+  override def visitArrayAccess(node: ArrayAccess): BMemoryLoad = resolveSpec.visitArrayAccess(node)
+}
+
+class RemoveOld(resolveSpec: ResolveSpec) extends SpecResolutionVisitor {
+  override def visitOld(node: Old): BExpr = resolveSpec.visitBExpr(node.body)
+  override def visitSpecGlobal(node: SpecGlobal): BMemoryLoad = resolveSpec.visitSpecGlobal(node)
+  override def visitSpecGamma(node: SpecGamma): GammaLoad = resolveSpec.visitSpecGamma(node)
+  override def visitArrayAccess(node: ArrayAccess): BMemoryLoad = resolveSpec.visitArrayAccess(node)
+}
+
+class ResolveSpecL(regionInjector: Option[RegionInjector]) extends SpecResolutionVisitor {
+  private val mem_in = BMapVar("mem$in", MapBType(BitVecBType(64), BitVecBType(8)), Scope.Parameter)
+  override def visitSpecGlobal(node: SpecGlobal): BMemoryLoad = {
+    val memory = if (regionInjector.isDefined) {
+      regionInjector.get.getMergedRegion(node.address) match {
+        case Some(region) => BMapVar(s"${region.name}$$in", MapBType(BitVecBType(64), BitVecBType(8)), Scope.Parameter)
+        case None => mem_in
+      }
+    } else {
+      mem_in
+    }
+    BMemoryLoad(memory, node.toAddrVar, Endian.LittleEndian, node.size)
+  }
+
+  override def visitArrayAccess(node: ArrayAccess): BMemoryLoad = {
+    val memory = if (regionInjector.isDefined) {
+      regionInjector.get.getMergedRegion(node.address) match {
+        case Some(region) => BMapVar(s"${region.name}$$in", MapBType(BitVecBType(64), BitVecBType(8)), Scope.Parameter)
+        case None => mem_in
+      }
+    } else {
+      mem_in
+    }
+    BMemoryLoad(memory, node.toAddrVar, Endian.LittleEndian, node.size)
+  }
+}
+
+object ResolveInsideOld extends SpecResolutionVisitor {
+  override def visitSpecGlobal(node: SpecGlobal): BExpr = node.toOldVar
+  override def visitSpecGamma(node: SpecGamma): BExpr = node.global.toOldGamma
+  override def visitArrayAccess(node: ArrayAccess): BExpr = node.toOldVar
+}
+
+object ResolveSpecParam extends SpecResolutionVisitor {
+  override def visitOld(node: Old): BExpr = ResolveSpecParamOld.visitBExpr(node.body)
+
+  override def visitSpecGlobal(node: SpecGlobal): BMemoryLoad = {
+    BMemoryLoad(
+      BMapVar("mem$out", MapBType(BitVecBType(64), BitVecBType(8)), Scope.Parameter),
+      node.toAddrVar,
+      Endian.LittleEndian,
+      node.size
+    )
+  }
+
+  override def visitSpecGamma(node: SpecGamma): GammaLoad = {
+    GammaLoad(
+      BMapVar("Gamma_mem$out", MapBType(BitVecBType(64), BoolBType), Scope.Parameter),
+      node.global.toAddrVar,
+      node.global.size,
+      node.global.size / 8
+    )
+  }
+
+  override def visitArrayAccess(node: ArrayAccess): BMemoryLoad = {
+    BMemoryLoad(
+      BMapVar("mem$out", MapBType(BitVecBType(64), BitVecBType(8)), Scope.Parameter),
+      node.toAddrVar,
+      Endian.LittleEndian,
+      node.global.size
+    )
+  }
+}
+
+object ResolveSpecParamOld extends SpecResolutionVisitor {
+  override def visitSpecGlobal(node: SpecGlobal): BMemoryLoad = {
+    BMemoryLoad(
+      BMapVar("mem$in", MapBType(BitVecBType(64), BitVecBType(8)), Scope.Parameter),
+      node.toAddrVar,
+      Endian.LittleEndian,
+      node.size
+    )
+  }
+
+  override def visitSpecGamma(node: SpecGamma): GammaLoad = {
+    GammaLoad(
+      BMapVar("Gamma_mem$in", MapBType(BitVecBType(64), BoolBType), Scope.Parameter),
+      node.global.toAddrVar,
+      node.global.size,
+      node.global.size / 8
+    )
+  }
+
+  override def visitArrayAccess(node: ArrayAccess): BMemoryLoad = {
+    BMemoryLoad(
+      BMapVar("mem$in", MapBType(BitVecBType(64), BitVecBType(8)), Scope.Parameter),
+      node.toAddrVar,
+      Endian.LittleEndian,
+      node.global.size
+    )
+  }
+}
+
+object ResolveSpecInv extends SpecResolutionVisitor {
+  override def visitOld(node: Old): BExpr = ResolveSpecInvOld.visitBExpr(node.body)
+
+  override def visitSpecGlobal(node: SpecGlobal): BMemoryLoad = {
+    BMemoryLoad(
+      BMapVar("mem$inv2", MapBType(BitVecBType(64), BitVecBType(8)), Scope.Local),
+      node.toAddrVar,
+      Endian.LittleEndian,
+      node.size
+    )
+  }
+
+  override def visitSpecGamma(node: SpecGamma): GammaLoad = {
+    GammaLoad(
+      BMapVar("Gamma_mem$inv2", MapBType(BitVecBType(64), BoolBType), Scope.Local),
+      node.global.toAddrVar,
+      node.global.size,
+      node.global.size / 8
+    )
+  }
+
+  override def visitArrayAccess(node: ArrayAccess): BMemoryLoad = {
+    BMemoryLoad(
+      BMapVar("mem$inv2", MapBType(BitVecBType(64), BitVecBType(8)), Scope.Local),
+      node.toAddrVar,
+      Endian.LittleEndian,
+      node.global.size
+    )
+  }
+}
+
+object ResolveSpecInvOld extends SpecResolutionVisitor {
+  override def visitSpecGlobal(node: SpecGlobal): BMemoryLoad = {
+    BMemoryLoad(
+      BMapVar("mem$inv1", MapBType(BitVecBType(64), BitVecBType(8)), Scope.Local),
+      node.toAddrVar,
+      Endian.LittleEndian,
+      node.size
+    )
+  }
+
+  override def visitSpecGamma(node: SpecGamma): GammaLoad = {
+    GammaLoad(
+      BMapVar("Gamma_mem$inv1", MapBType(BitVecBType(64), BoolBType), Scope.Local),
+      node.global.toAddrVar,
+      node.global.size,
+      node.global.size / 8
+    )
+  }
+
+  override def visitArrayAccess(node: ArrayAccess): BMemoryLoad = {
+    BMemoryLoad(
+      BMapVar("mem$inv1", MapBType(BitVecBType(64), BitVecBType(8)), Scope.Local),
+      node.toAddrVar,
+      Endian.LittleEndian,
+      node.global.size
+    )
+  }
+
+}
\ No newline at end of file
diff --git a/src/main/scala/cfg_visualiser/DotTools.scala b/src/main/scala/cfg_visualiser/DotTools.scala
index 937bd8293..d89cf8333 100644
--- a/src/main/scala/cfg_visualiser/DotTools.scala
+++ b/src/main/scala/cfg_visualiser/DotTools.scala
@@ -136,3 +136,68 @@ class DotGraph(val title: String, val nodes: Iterable[DotNode], val edges: Itera
 
   def toDotString: String = "digraph " + title + " {\n" + (nodes ++ edges).foldLeft("")((str, elm) => str + elm.toDotString + "\n") + "}"
 }
+
+
+
+class DotStruct(val id: String, val details: String, val fields: Option[Iterable[String]], val verbose: Boolean = true) extends DotElement {
+  def equals(other: DotStruct): Boolean = toDotString.equals(other.toDotString)
+
+
+  val label = s"\"{<$id> ${if verbose then wrap(details, 80) else id} ${if fields.isDefined then  s" | {${fields.get.map(f => s"<$f> $f").mkString("|")}}" else "" }}\""
+  override def toString: String = toDotString
+
+  override def toDotString: String =
+    s"$id " + "[label=" + label + "]"
+}
+
+class DotStructElement(val id: String, val field: Option[String]) extends DotElement {
+  def equals(other: DotStruct): Boolean = toDotString.equals(other.toDotString)
+  override def toString: String = toDotString
+
+  override def toDotString: String =
+    s"$id${if field.isDefined then ":" + field.get else ""}"
+}
+
+case class StructArrow(
+                        from: DotStructElement,
+                        to: DotStructElement,
+                        label: String = "",
+                        arrow: String = "->",
+                        style: String = "solid",
+                        colour: String = "black") extends DotElement {
+
+  def equals(other: DotArrow): Boolean = toDotString.equals(other.toDotString)
+
+  def toDotString: String =
+    s"${from.toString} $arrow ${to.toString} [label=\"$label\", style=\"$style\", color=\"$colour\"]"
+}
+
+
+/** Represents a Graphviz dot graph.
+ */
+class StructDotGraph(val title: String, val nodes: Iterable[DotStruct], val edges: Iterable[StructArrow]) extends DotElement {
+
+  def this(nodes: List[DotStruct], edges: List[StructArrow]) = this("", nodes, edges)
+
+  def this(title: String) = this(title, List(), List())
+
+  def this() = this(List(), List())
+
+  def addGraph(g: StructDotGraph): StructDotGraph = {
+    val ng = g.nodes.foldLeft(this)((g, n) => g.addNode(n))
+    g.edges.foldLeft(ng)((g, e) => g.addEdge(e))
+  }
+
+  def addNode(n: DotStruct): StructDotGraph =
+    if (nodes.exists(a => n.equals(a))) this
+    else new StructDotGraph(title, nodes ++ List(n), edges)
+
+  def addEdge(e: StructArrow): StructDotGraph =
+    if (edges.exists(a => e.equals(a))) this
+    else new StructDotGraph(title, nodes, edges ++ List(e))
+
+  override def toString: String = toDotString
+
+  def toDotString: String = "digraph " + title + " {\nrankdir=\"LR\"\nnode [shape=record];\n" + (nodes ++ edges).foldLeft("")((str, elm) => str + elm.toDotString + "\n") + "}"
+}
+
diff --git a/src/main/scala/ir/Expr.scala b/src/main/scala/ir/Expr.scala
index 6a7c862cd..d250ca9fc 100644
--- a/src/main/scala/ir/Expr.scala
+++ b/src/main/scala/ir/Expr.scala
@@ -5,21 +5,8 @@ import scala.collection.mutable
 
 sealed trait Expr {
   def toBoogie: BExpr
-  def toGamma: BExpr = {
-    val gammaVars: Set[BExpr] = gammas.map(_.toGamma)
-    if (gammaVars.isEmpty) {
-      TrueBLiteral
-    } else if (gammaVars.size == 1) {
-      gammaVars.head
-    } else {
-      gammaVars.tail.foldLeft(gammaVars.head) { (join: BExpr, next: BExpr) =>
-        BinaryBExpr(BoolAND, next, join)
-      }
-    }
-  }
-  def loads: Set[MemoryLoad] = Set()
   def getType: IRType
-  def gammas: Set[Expr] = Set()
+  def gammas: Set[Variable] = Set() // variables not including those inside a load's index
   def variables: Set[Variable] = Set()
   def acceptVisit(visitor: Visitor): Expr = throw new Exception("visitor " + visitor + " unimplemented for: " + this)
 }
@@ -61,17 +48,16 @@ case class IntLiteral(value: BigInt) extends Literal {
   */
 case class Extract(end: Int, start: Int, body: Expr) extends Expr {
   override def toBoogie: BExpr = BVExtract(end, start, body.toBoogie)
-  override def gammas: Set[Expr] = body.gammas
+  override def gammas: Set[Variable] = body.gammas
   override def variables: Set[Variable] = body.variables
   override def getType: BitVecType = BitVecType(end - start)
   override def toString: String = s"$body[$end:$start]"
   override def acceptVisit(visitor: Visitor): Expr = visitor.visitExtract(this)
-  override def loads: Set[MemoryLoad] = body.loads
 }
 
 case class Repeat(repeats: Int, body: Expr) extends Expr {
   override def toBoogie: BExpr = BVRepeat(repeats, body.toBoogie)
-  override def gammas: Set[Expr] = body.gammas
+  override def gammas: Set[Variable] = body.gammas
   override def variables: Set[Variable] = body.variables
   override def getType: BitVecType = BitVecType(bodySize * repeats)
   private def bodySize: Int = body.getType match {
@@ -80,12 +66,11 @@ case class Repeat(repeats: Int, body: Expr) extends Expr {
   }
   override def toString: String = s"Repeat($repeats, $body)"
   override def acceptVisit(visitor: Visitor): Expr = visitor.visitRepeat(this)
-  override def loads: Set[MemoryLoad] = body.loads
 }
 
 case class ZeroExtend(extension: Int, body: Expr) extends Expr {
   override def toBoogie: BExpr = BVZeroExtend(extension, body.toBoogie)
-  override def gammas: Set[Expr] = body.gammas
+  override def gammas: Set[Variable] = body.gammas
   override def variables: Set[Variable] = body.variables
   override def getType: BitVecType = BitVecType(bodySize + extension)
   private def bodySize: Int = body.getType match {
@@ -94,12 +79,11 @@ case class ZeroExtend(extension: Int, body: Expr) extends Expr {
   }
   override def toString: String = s"ZeroExtend($extension, $body)"
   override def acceptVisit(visitor: Visitor): Expr = visitor.visitZeroExtend(this)
-  override def loads: Set[MemoryLoad] = body.loads
 }
 
 case class SignExtend(extension: Int, body: Expr) extends Expr {
   override def toBoogie: BExpr = BVSignExtend(extension, body.toBoogie)
-  override def gammas: Set[Expr] = body.gammas
+  override def gammas: Set[Variable] = body.gammas
   override def variables: Set[Variable] = body.variables
   override def getType: BitVecType = BitVecType(bodySize + extension)
   private def bodySize: Int = body.getType match {
@@ -108,14 +92,12 @@ case class SignExtend(extension: Int, body: Expr) extends Expr {
   }
   override def toString: String = s"SignExtend($extension, $body)"
   override def acceptVisit(visitor: Visitor): Expr = visitor.visitSignExtend(this)
-  override def loads: Set[MemoryLoad] = body.loads
 }
 
 case class UnaryExpr(op: UnOp, arg: Expr) extends Expr {
   override def toBoogie: BExpr = UnaryBExpr(op, arg.toBoogie)
-  override def gammas: Set[Expr] = arg.gammas
+  override def gammas: Set[Variable] = arg.gammas
   override def variables: Set[Variable] = arg.variables
-  override def loads: Set[MemoryLoad] = arg.loads
   override def getType: IRType = (op, arg.getType) match {
     case (_: BoolUnOp, BoolType)     => BoolType
     case (_: BVUnOp, bv: BitVecType) => bv
@@ -162,9 +144,8 @@ case object BVNEG extends BVUnOp("neg")
 
 case class BinaryExpr(op: BinOp, arg1: Expr, arg2: Expr) extends Expr {
   override def toBoogie: BExpr = BinaryBExpr(op, arg1.toBoogie, arg2.toBoogie)
-  override def gammas: Set[Expr] = arg1.gammas ++ arg2.gammas
+  override def gammas: Set[Variable] = arg1.gammas ++ arg2.gammas
   override def variables: Set[Variable] = arg1.variables ++ arg2.variables
-  override def loads: Set[MemoryLoad] = arg1.loads ++ arg2.loads
   override def getType: IRType = (op, arg1.getType, arg2.getType) match {
     case (_: BoolBinOp, BoolType, BoolType) => BoolType
     case (binOp: BVBinOp, bv1: BitVecType, bv2: BitVecType) =>
@@ -304,27 +285,10 @@ enum Endian {
   case BigEndian
 }
 
-case class MemoryLoad(mem: Memory, index: Expr, endian: Endian, size: Int) extends Expr {
-  override def toBoogie: BMemoryLoad = BMemoryLoad(mem.toBoogie, index.toBoogie, endian, size)
-  override def toGamma: BExpr = mem match {
-    case m: StackMemory =>
-      GammaLoad(m.toGamma, index.toBoogie, size, size / m.valueSize)
-    case m: SharedMemory =>
-      BinaryBExpr(BoolOR, GammaLoad(m.toGamma, index.toBoogie, size, size / m.valueSize), L(m.toBoogie, index.toBoogie))
-  }
-  override def variables: Set[Variable] = index.variables
-  override def gammas: Set[Expr] = Set(this)
-  override def loads: Set[MemoryLoad] = Set(this)
-  override def getType: IRType = BitVecType(size)
-  override def toString: String = s"MemoryLoad($mem, $index, $endian, $size)"
-  override def acceptVisit(visitor: Visitor): Expr = visitor.visitMemoryLoad(this)
-}
-
 case class UninterpretedFunction(name: String, params: Seq[Expr], returnType: IRType) extends Expr {
   override def getType: IRType = returnType
   override def toBoogie: BFunctionCall = BFunctionCall(name, params.map(_.toBoogie).toList, returnType.toBoogie, true)
   override def acceptVisit(visitor: Visitor): Expr = visitor.visitUninterpretedFunction(this)
-  override def gammas: Set[Expr] = params.flatMap(_.gammas).toSet
   override def variables: Set[Variable] = params.flatMap(_.variables).toSet
 }
 
@@ -336,14 +300,12 @@ sealed trait Global
 sealed trait Variable extends Expr {
   val name: String
   val irType: IRType
-  var sharedVariable: Boolean = false
 
   override def getType: IRType = irType
   override def variables: Set[Variable] = Set(this)
-  override def gammas: Set[Expr] = Set(this)
+  override def gammas: Set[Variable] = Set(this)
   override def toBoogie: BVar
-  // placeholder definition not actually used
-  override def toGamma: BVar = BVariable(s"$name", irType.toBoogie, Scope.Global)
+  def toGamma: BVar
 
   override def toString: String = s"Variable($name, $irType)"
 
@@ -365,7 +327,7 @@ case class Register(override val name: String, size: Int) extends Variable with
 case class LocalVar(override val name: String, override val irType: IRType) extends Variable {
   override def toGamma: BVar = BVariable(s"Gamma_$name", BoolBType, Scope.Local)
   override def toBoogie: BVar = BVariable(s"$name", irType.toBoogie, Scope.Local)
-  override def toString: String = s"LocalVar(${name}_$sharedVariable, $irType)"
+  override def toString: String = s"LocalVar($name, $irType)"
   override def acceptVisit(visitor: Visitor): Variable = visitor.visitLocalVar(this)
 }
 
diff --git a/src/main/scala/ir/IRCursor.scala b/src/main/scala/ir/IRCursor.scala
index 21944d4f1..3d0fc902e 100644
--- a/src/main/scala/ir/IRCursor.scala
+++ b/src/main/scala/ir/IRCursor.scala
@@ -148,27 +148,21 @@ object IntraProcBlockIRCursor extends IntraProcBlockIRCursor
 trait InterProcIRCursor extends IRWalk[CFGPosition, CFGPosition] {
 
   final def succ(pos: CFGPosition): Set[CFGPosition] = {
-    IntraProcIRCursor.succ(pos) ++
-      (pos match
+      pos match
         case c: DirectCall if c.target.blocks.nonEmpty => Set(c.target)
         case c: Return => c.parent.parent.incomingCalls().map(_.successor).toSet
-        case _         => Set.empty
-      )
+        case _         => IntraProcIRCursor.succ(pos)
   }
 
   final def pred(pos: CFGPosition): Set[CFGPosition] = {
-    IntraProcIRCursor.pred(pos) ++
-      (pos match
-        case c: Command => {
+      pos match
+        case c: Command =>
           IRWalk.prevCommandInBlock(c) match {
             case Some(d: DirectCall) if d.target.blocks.nonEmpty => d.target.returnBlock.toSet
-            case o            => o.toSet
+            case o            => o.toSet ++ IntraProcIRCursor.pred(pos)
           }
-
-        }
-        case c: Procedure                              => c.incomingCalls().toSet.asInstanceOf[Set[CFGPosition]]
-        case _                                         => Set.empty
-      )
+        case c: Procedure => c.incomingCalls().toSet.asInstanceOf[Set[CFGPosition]]
+        case _            => IntraProcIRCursor.pred(pos)
   }
 }
 
@@ -177,7 +171,7 @@ object InterProcIRCursor extends InterProcIRCursor
 trait CallGraph extends IRWalk[Procedure, Procedure] {
   final def succ(b: Procedure): Set[Procedure] = b.calls
 
-  final def pred(b: Procedure): Set[Procedure] = b.incomingCalls().map(_.target).toSet
+  final def pred(b: Procedure): Set[Procedure] = b.incomingCalls().map(_.parent.parent).toSet
 }
 
 object CallGraph extends CallGraph
@@ -251,9 +245,14 @@ def stronglyConnectedComponents[T <: CFGPosition, O <: T](walker: IRWalk[T, O],
   out
 }
 
-def toDot(program: Program, labels: Map[CFGPosition, String] = Map.empty): String = {
-  val domain = computeDomain[CFGPosition, CFGPosition](IntraProcIRCursor, program.procedures)
-  toDot[CFGPosition](domain, IntraProcIRCursor, labels)
+def toDot(program: Program, labels: Map[CFGPosition, String] = Map.empty, inter: Boolean = false): String = {
+  if (inter) {
+    val domain = computeDomain[CFGPosition, CFGPosition](InterProcIRCursor, program.procedures)
+    toDot[CFGPosition](domain, InterProcIRCursor, labels)
+  } else {
+    val domain = computeDomain[CFGPosition, CFGPosition](IntraProcIRCursor, program.procedures)
+    toDot[CFGPosition](domain, IntraProcIRCursor, labels)
+  }
 }
 
 def dotCallGraph(program: Program, labels: Map[CFGPosition, String] = Map.empty): String = {
@@ -293,7 +292,7 @@ def toDot[T <: CFGPosition](
       case s        => s.toString
     }
     if (labels.contains(node)) {
-      text += "\n" ++ labels(node)
+      text = labels(node) ++ "\n" ++ text
     }
     text
   }
diff --git a/src/main/scala/ir/Interpreter.scala b/src/main/scala/ir/Interpreter.scala
index d3b48a549..204a3fda7 100644
--- a/src/main/scala/ir/Interpreter.scala
+++ b/src/main/scala/ir/Interpreter.scala
@@ -85,11 +85,6 @@ class Interpreter() {
           case BVNOT   => smt_bvnot(arg)
         }
 
-      case ml: MemoryLoad =>
-        Logger.debug(s"\t$ml")
-        val index: Int = eval(ml.index, env).value.toInt
-        getMemory(index, ml.size, ml.endian, mems)
-
       case u: UninterpretedFunction =>
         Logger.debug(s"\t$u")
         ???
@@ -259,26 +254,35 @@ class Interpreter() {
   private def interpretStatement(s: Statement): Unit = {
     Logger.debug(s"statement[$s]:")
     s match {
-      case assign: Assign =>
+      case assign: LocalAssign =>
         Logger.debug(s"LocalAssign ${assign.lhs} = ${assign.rhs}")
         val evalRight = eval(assign.rhs, regs)
         Logger.debug(s"LocalAssign ${assign.lhs} := 0x${evalRight.value.toString(16)}[u${evalRight.size}]\n")
         regs += (assign.lhs -> evalRight)
 
-      case assign: MemoryAssign =>
-        Logger.debug(s"MemoryAssign ${assign.mem}[${assign.index}] = ${assign.value}")
+      case store: MemoryStore =>
+        Logger.debug(s"MemoryStore ${store.mem}[${store.index}] = ${store.value}")
 
-        val index: Int = eval(assign.index, regs).value.toInt
-        val value: BitVecLiteral = eval(assign.value, regs)
-        Logger.debug(s"\tMemoryStore(mem:${assign.mem}, index:0x${index.toHexString}, value:0x${
-          value.value
-            .toString(16)
-        }[u${value.size}], size:${assign.size})")
+        val index: Int = eval(store.index, regs).value.toInt
+        val value: BitVecLiteral = eval(store.value, regs)
+        Logger.debug(s"\tMemoryStore(mem:${store.mem}, index:0x${index.toHexString}, value:0x${
+          value.value.toString(16)
+        }[u${value.size}], size:${store.size})")
 
-        val evalStore = setMemory(index, assign.size, assign.endian, value, mems)
+        val evalStore = setMemory(index, store.size, store.endian, value, mems)
         evalStore match {
           case BitVecLiteral(value, size) =>
-            Logger.debug(s"MemoryAssign ${assign.mem} := 0x${value.toString(16)}[u$size]\n")
+            Logger.debug(s"MemoryStore ${store.mem} := 0x${value.toString(16)}[u$size]\n")
+        }
+      case load: MemoryLoad =>
+        Logger.debug(s"MemoryLoad ${load.lhs} = ${load.mem}[${load.index}]")
+        val index: Int = eval(load.index, regs).value.toInt
+        Logger.debug(s"MemoryLoad ${load.lhs} := ${load.mem}[0x${index.toHexString}[u${load.size}]\n")
+        val evalLoad = getMemory(index, load.size, load.endian, mems)
+        regs += (load.lhs -> evalLoad)
+        evalLoad match {
+          case BitVecLiteral(value, size) =>
+            Logger.debug(s"MemoryStore ${load.lhs} := 0x${value.toString(16)}[u$size]\n")
         }
       case _ : NOP => ()
       case assert: Assert =>
@@ -322,9 +326,7 @@ class Interpreter() {
   def interpret(IRProgram: Program): mutable.Map[Variable, BitVecLiteral] = {
     // initialize memory array from IRProgram
     var currentAddress = BigInt(0)
-    IRProgram.initialMemory
-      .sortBy(_.address)
-      .foreach { im =>
+    IRProgram.initialMemory.values.foreach { im =>
         if (im.address + im.size > currentAddress) {
           val start = im.address.max(currentAddress)
           val data = if (im.address < currentAddress) im.bytes.slice((currentAddress - im.address).toInt, im.size) else im.bytes
diff --git a/src/main/scala/ir/Program.scala b/src/main/scala/ir/Program.scala
index d06e4b59c..5ff441799 100644
--- a/src/main/scala/ir/Program.scala
+++ b/src/main/scala/ir/Program.scala
@@ -3,17 +3,18 @@ package ir
 import scala.collection.mutable.ArrayBuffer
 import scala.collection.{IterableOnceExtensionMethods, View, immutable, mutable}
 import boogie.*
-import analysis.BitVectorEval
+import analysis.{BitVectorEval, MergedRegion}
 import util.intrusive_list.*
 import translating.serialiseIL
 
 class Program(var procedures: ArrayBuffer[Procedure],
               var mainProcedure: Procedure,
-              var initialMemory: ArrayBuffer[MemorySection],
-              var readOnlyMemory: ArrayBuffer[MemorySection]) extends Iterable[CFGPosition] {
+              val initialMemory: mutable.TreeMap[BigInt, MemorySection]) extends Iterable[CFGPosition] {
 
   val threads: ArrayBuffer[ProgramThread] = ArrayBuffer()
 
+  val usedMemory: mutable.Map[BigInt, MemorySection] = mutable.TreeMap()
+
   override def toString(): String = {
     serialiseIL(this)
   }
@@ -71,14 +72,12 @@ class Program(var procedures: ArrayBuffer[Procedure],
     * section in readOnlyMemory. It also takes the .rela.dyn entries taken from the readelf output and adds them to the
     * .rodata section, as they are the global offset table entries that we can assume are constant.
     */
-  def determineRelevantMemory(rela_dyn: Map[BigInt, BigInt]): Unit = {
-    val initialMemoryNew = ArrayBuffer[MemorySection]()
 
-    val rodata = initialMemory.collect { case s if s.name == ".rodata" => s }
-    readOnlyMemory.addAll(rodata)
-
-    val data = initialMemory.collect { case s if s.name == ".data" => s }
-    initialMemoryNew.addAll(data)
+  def determineRelevantMemory(rela_dyn: Map[BigInt, BigInt]): Unit = {
+    val rodata = initialMemory.values.collect { case s if s.name == ".rodata" => s }
+    rodata.foreach { r => usedMemory.addOne(r.address, r) }
+    val data = initialMemory.values.collect { case s if s.name == ".data" => s }
+    data.foreach { d => usedMemory.addOne(d.address, d) }
 
     // assuming little endian, adding the rela_dyn offset/address pairs like this is crude but is simplest for now
     for ((offset, address) <- rela_dyn) {
@@ -88,10 +87,9 @@ class Program(var procedures: ArrayBuffer[Procedure],
         val high = low + 8
         BitVectorEval.boogie_extract(high, low, addressBV)
       }
-      readOnlyMemory.append(MemorySection(s".got_$offset", offset.intValue, 8, bytes))
+      usedMemory.addOne(offset, MemorySection(s".got_$offset", offset, 8, bytes, true, None))
     }
 
-    initialMemory = initialMemoryNew
   }
 
   /**
@@ -127,6 +125,20 @@ class Program(var procedures: ArrayBuffer[Procedure],
     ILUnorderedIterator(this)
   }
 
+  private def memoryLookup(memory: mutable.TreeMap[BigInt, MemorySection], address: BigInt) = {
+    memory.maxBefore(address + 1) match {
+      case Some(_, section) =>
+        if (section.address + section.size > address) {
+          Some(section)
+        } else {
+          None
+        }
+      case _ => None
+    }
+  }
+
+  def initialMemoryLookup(address: BigInt): Option[MemorySection] = memoryLookup(initialMemory, address)
+
   def nameToProcedure: Map[String, Procedure] = {
     procedures.view.map(p => p.name -> p).toMap
   }
@@ -189,7 +201,7 @@ class Procedure private (
 
   def returnBlock_=(value: Block): Unit = {
     if (!returnBlock.contains(value)) {
-      _returnBlock.foreach(removeBlocks(_))
+      _returnBlock.foreach(removeBlocks)
       _returnBlock = Some(addBlocks(value))
     }
   }
@@ -198,7 +210,7 @@ class Procedure private (
 
   def entryBlock_=(value: Block): Unit = {
     if (!entryBlock.contains(value)) {
-      _entryBlock.foreach(removeBlocks(_))
+      _entryBlock.foreach(removeBlocks)
       _entryBlock = Some(addBlocks(value))
     }
   }
@@ -325,8 +337,6 @@ class Parameter(var name: String, var size: Int, var value: Register) {
   def toGamma: BVariable = BParam(s"Gamma_$name", BoolBType)
 }
 
-
-
 class Block private (
  val label: String,
  val address: Option[BigInt],
@@ -456,4 +466,17 @@ object Block {
   * @param size number of bytes
   * @param bytes sequence of bytes represented by BitVecLiterals of size 8
   */
-case class MemorySection(name: String, address: BigInt, size: Int, bytes: Seq[BitVecLiteral])
+case class MemorySection(name: String, address: BigInt, size: Int, bytes: Seq[BitVecLiteral], readOnly: Boolean, region: Option[MergedRegion] = None) {
+
+  def getBytes(addr: BigInt, num: Int): Seq[BitVecLiteral] = {
+    val startIndex = (addr - address).toInt
+    for (i <- 0 until num) yield {
+      val index = startIndex + i
+      if (index >= bytes.size || index < 0) {
+        throw Exception(s"can't get $num bytes from section $name with size $size starting at index $startIndex (access address $addr)")
+      }
+      bytes(index)
+    }
+  }
+
+}
\ No newline at end of file
diff --git a/src/main/scala/ir/Statement.scala b/src/main/scala/ir/Statement.scala
index ce49bc82e..c1862a9ff 100644
--- a/src/main/scala/ir/Statement.scala
+++ b/src/main/scala/ir/Statement.scala
@@ -23,33 +23,47 @@ sealed trait Statement extends Command, IntrusiveListElement[Statement] {
   def acceptVisit(visitor: Visitor): Statement = throw new Exception(
     "visitor " + visitor + " unimplemented for: " + this
   )
-
   def successor: Command = parent.statements.nextOption(this).getOrElse(parent.jump)
+}
 
+sealed trait Assign extends Statement {
+  var lhs: Variable
 }
 
-// invariant: rhs contains at most one MemoryLoad
-class Assign(var lhs: Variable, var rhs: Expr, override val label: Option[String] = None) extends Statement {
+class LocalAssign(var lhs: Variable, var rhs: Expr, override val label: Option[String] = None) extends Assign {
   override def modifies: Set[Global] = lhs match {
     case r: Register => Set(r)
     case _           => Set()
   }
   override def toString: String = s"$labelStr$lhs := $rhs"
-  override def acceptVisit(visitor: Visitor): Statement = visitor.visitAssign(this)
+  override def acceptVisit(visitor: Visitor): Statement = visitor.visitLocalAssign(this)
 }
 
-object Assign:
-  def unapply(l: Assign): Option[(Variable, Expr, Option[String])] = Some(l.lhs, l.rhs, l.label)
+object LocalAssign:
+  def unapply(l: LocalAssign): Option[(Variable, Expr, Option[String])] = Some(l.lhs, l.rhs, l.label)
 
-// invariant: index and value do not contain MemoryLoads
-class MemoryAssign(var mem: Memory, var index: Expr, var value: Expr, var endian: Endian, var size: Int, override val label: Option[String] = None) extends Statement {
+class MemoryStore(var mem: Memory, var index: Expr, var value: Expr, var endian: Endian, var size: Int, override val label: Option[String] = None) extends Statement {
   override def modifies: Set[Global] = Set(mem)
   override def toString: String = s"$labelStr$mem[$index] := MemoryStore($value, $endian, $size)"
-  override def acceptVisit(visitor: Visitor): Statement = visitor.visitMemoryAssign(this)
+  override def acceptVisit(visitor: Visitor): Statement = visitor.visitMemoryStore(this)
 }
 
-object MemoryAssign:
-  def unapply(m: MemoryAssign): Option[(Memory, Expr, Expr, Endian, Int, Option[String])] = Some(m.mem, m.index, m.value, m.endian, m.size, m.label)
+object MemoryStore {
+  def unapply(m: MemoryStore): Option[(Memory, Expr, Expr, Endian, Int, Option[String])] = Some(m.mem, m.index, m.value, m.endian, m.size, m.label)
+}
+
+class MemoryLoad(var lhs: Variable, var mem: Memory, var index: Expr, var endian: Endian, var size: Int, override val label: Option[String] = None) extends Assign {
+  override def modifies: Set[Global] = lhs match {
+    case r: Register => Set(r)
+    case _ => Set()
+  }
+  override def toString: String = s"$labelStr$lhs := MemoryLoad($mem, $index, $endian, $size)"
+  override def acceptVisit(visitor: Visitor): Statement = visitor.visitMemoryLoad(this)
+}
+
+object MemoryLoad {
+  def unapply(m: MemoryLoad): Option[(Variable, Memory, Expr, Endian, Int, Option[String])] = Some(m.lhs, m.mem, m.index, m.endian, m.size, m.label)
+}
 
 class NOP(override val label: Option[String] = None) extends Statement {
   override def toString: String = s"NOP $labelStr"
@@ -87,10 +101,17 @@ class Unreachable(override val label: Option[String] = None) extends Jump {
   override def acceptVisit(visitor: Visitor): Jump = this
 }
 
+object Unreachable {
+  def unapply(u: Unreachable): Option[Option[String]] = Some(u.label)
+}
+
 class Return(override val label: Option[String] = None) extends Jump {
   override def acceptVisit(visitor: Visitor): Jump = this
 }
 
+object Return {
+  def unapply(r: Return): Option[Option[String]] = Some(r.label)
+}
 
 class GoTo private (private val _targets: mutable.LinkedHashSet[Block], override val label: Option[String]) extends Jump {
 
diff --git a/src/main/scala/ir/Visitor.scala b/src/main/scala/ir/Visitor.scala
index 1cc9c1b40..c649dc4f3 100644
--- a/src/main/scala/ir/Visitor.scala
+++ b/src/main/scala/ir/Visitor.scala
@@ -10,19 +10,27 @@ abstract class Visitor {
 
   def visitStatement(node: Statement): Statement = node.acceptVisit(this)
 
-  def visitAssign(node: Assign): Statement = {
+  def visitLocalAssign(node: LocalAssign): Statement = {
     node.lhs = visitVariable(node.lhs)
     node.rhs = visitExpr(node.rhs)
     node
   }
 
-  def visitMemoryAssign(node: MemoryAssign): Statement = {
+  def visitMemoryStore(node: MemoryStore): Statement = {
     node.mem = visitMemory(node.mem)
     node.index = visitExpr(node.index)
     node.value = visitExpr(node.value)
     node
   }
 
+  def visitMemoryLoad(node: MemoryLoad): Statement = {
+    node.lhs = visitVariable(node.lhs)
+    node.mem = visitMemory(node.mem)
+    node.index = visitExpr(node.index)
+    node
+  }
+
+
   def visitAssume(node: Assume): Statement = {
     node.body = visitExpr(node.body)
     node
@@ -110,10 +118,6 @@ abstract class Visitor {
     node.copy(arg1 = visitExpr(node.arg1), arg2 = visitExpr(node.arg2))
   }
 
-  def visitMemoryLoad(node: MemoryLoad): Expr = {
-    node.copy(mem = visitMemory(node.mem), index = visitExpr(node.index))
-  }
-
   def visitMemory(node: Memory): Memory = node.acceptVisit(this)
 
   def visitStackMemory(node: StackMemory): Memory = node
@@ -166,25 +170,26 @@ abstract class ReadOnlyVisitor extends Visitor {
     node
   }
 
-  override def visitMemoryLoad(node: MemoryLoad): Expr = {
-    visitMemory(node.mem)
-    visitExpr(node.index)
-    node
-  }
-
-  override def visitAssign(node: Assign): Statement = {
+  override def visitLocalAssign(node: LocalAssign): Statement = {
     visitVariable(node.lhs)
     visitExpr(node.rhs)
     node
   }
 
-  override def visitMemoryAssign(node: MemoryAssign): Statement = {
+  override def visitMemoryStore(node: MemoryStore): Statement = {
     visitMemory(node.mem)
     visitExpr(node.index)
     visitExpr(node.value)
     node
   }
 
+  override def visitMemoryLoad(node: MemoryLoad): Statement = {
+    visitVariable(node.lhs)
+    visitMemory(node.mem)
+    visitExpr(node.index)
+    node
+  }
+
   override def visitAssume(node: Assume): Statement = {
     visitExpr(node.body)
     node
@@ -307,17 +312,18 @@ class StackSubstituter extends IntraproceduralControlFlowVisitor {
   override def visitMemoryLoad(node: MemoryLoad): MemoryLoad = {
     // replace mem with stack in load if index contains stack references
     val loadStackRefs = node.index.variables.intersect(stackRefs)
+
     if (loadStackRefs.nonEmpty) {
-      node.copy(mem = stackMemory)
-    } else {
-      node
+      node.mem = stackMemory
+    }
+    if (stackRefs.contains(node.lhs) && node.lhs != stackPointer) {
+      stackRefs.remove(node.lhs)
     }
-  }
 
-  override def visitAssign(node: Assign): Statement = {
-    node.lhs = visitVariable(node.lhs)
-    node.rhs = visitExpr(node.rhs)
+    node
+  }
 
+  override def visitLocalAssign(node: LocalAssign): Statement = {
     // update stack references
     val variableVisitor = VariablesWithoutStoresLoads()
     variableVisitor.visitExpr(node.rhs)
@@ -331,7 +337,7 @@ class StackSubstituter extends IntraproceduralControlFlowVisitor {
     node
   }
 
-  override def visitMemoryAssign(node: MemoryAssign): Statement = {
+  override def visitMemoryStore(node: MemoryStore): Statement = {
     val indexStackRefs = node.index.variables.intersect(stackRefs)
     if (indexStackRefs.nonEmpty) {
       node.mem = stackMemory
@@ -358,6 +364,18 @@ class Substituter(variables: Map[Variable, Variable] = Map(), memories: Map[Memo
   * Useful for avoiding Boogie's reserved keywords.
   */
 class Renamer(reserved: Set[String]) extends Visitor {
+  override def visitProgram(node: Program): Program = {
+    for (section <- node.usedMemory.values) {
+      section.region match {
+        case Some(region) if reserved.contains(region.name) =>
+          region.name = s"#${region.name}"
+        case _ =>
+      }
+    }
+
+    super.visitProgram(node)
+  }
+
   override def visitLocalVar(node: LocalVar): LocalVar = {
     if (reserved.contains(node.name)) {
       node.copy(name = s"#${node.name}")
@@ -409,7 +427,7 @@ class ExternalRemover(external: Set[String]) extends Visitor {
   }
 }
 
-/** Gives variables that are not contained within a MemoryStore or MemoryLoad
+/** Gives variables that are not contained within a MemoryStore or the rhs of a MemoryLoad
   * */
 class VariablesWithoutStoresLoads extends ReadOnlyVisitor {
   val variables: mutable.Set[Variable] = mutable.Set()
@@ -425,6 +443,7 @@ class VariablesWithoutStoresLoads extends ReadOnlyVisitor {
   }
 
   override def visitMemoryLoad(node: MemoryLoad): MemoryLoad = {
+    visitVariable(node.lhs)
     node
   }
 
diff --git a/src/main/scala/ir/cilvisitor/CILVisitor.scala b/src/main/scala/ir/cilvisitor/CILVisitor.scala
index 5583b12da..372b500de 100644
--- a/src/main/scala/ir/cilvisitor/CILVisitor.scala
+++ b/src/main/scala/ir/cilvisitor/CILVisitor.scala
@@ -35,7 +35,7 @@ trait CILVisitor:
   def leave_scope(outparam: ArrayBuffer[Parameter]): Unit = ()
 
 
-def doVisitList[T](v: CILVisitor, a: VisitAction[List[T]], n: T, continue: (T) => T): List[T] = {
+def doVisitList[T](v: CILVisitor, a: VisitAction[List[T]], n: T, continue: T => T): List[T] = {
   a match {
     case SkipChildren()             => List(n)
     case ChangeTo(z)                => z
@@ -44,7 +44,7 @@ def doVisitList[T](v: CILVisitor, a: VisitAction[List[T]], n: T, continue: (T) =
   }
 }
 
-def doVisit[T](v: CILVisitor, a: VisitAction[T], n: T, continue: (T) => T): T = {
+def doVisit[T](v: CILVisitor, a: VisitAction[T], n: T, continue: T => T): T = {
   a match {
     case SkipChildren()             => n
     case DoChildren()               => continue(n)
@@ -56,31 +56,30 @@ def doVisit[T](v: CILVisitor, a: VisitAction[T], n: T, continue: (T) => T): T =
 class CILVisitorImpl(val v: CILVisitor) {
 
   def visit_parameters(p: ArrayBuffer[Parameter]): ArrayBuffer[Parameter] = {
-    doVisit(v, v.vparams(p), p, (n) => n)
+    doVisit(v, v.vparams(p), p, n => n)
   }
 
   def visit_var(n: Variable): Variable = {
-    doVisit(v, v.vvar(n), n, (n) => n)
+    doVisit(v, v.vvar(n), n, n => n)
   }
 
 
   def visit_mem(n: Memory): Memory = {
-    doVisit(v, v.vmem(n), n, (n) => n)
+    doVisit(v, v.vmem(n), n, n => n)
   }
 
 
   def visit_jump(j: Jump): Jump = {
-    doVisit(v, v.vjump(j), j, (j) => j)
+    doVisit(v, v.vjump(j), j, j => j)
   }
 
   def visit_fallthrough(j: Option[GoTo]): Option[GoTo] = {
-    doVisit(v, v.vfallthrough(j), j, (j) => j)
+    doVisit(v, v.vfallthrough(j), j, j => j)
   }
 
   def visit_expr(n: Expr): Expr = {
     def continue(n: Expr): Expr = n match {
       case n: Literal                           => n
-      case MemoryLoad(mem, index, endian, size) => MemoryLoad(visit_mem(mem), visit_expr(index), endian, size)
       case Extract(end, start, arg)             => Extract(end, start, visit_expr(arg))
       case Repeat(repeats, arg)                 => Repeat(repeats, visit_expr(arg))
       case ZeroExtend(bits, arg)                => ZeroExtend(bits, visit_expr(arg))
@@ -96,29 +95,29 @@ class CILVisitorImpl(val v: CILVisitor) {
   def visit_stmt(s: Statement): List[Statement] = {
     def continue(n: Statement) = n match {
       case d: DirectCall => d
-      case i: IndirectCall => {
+      case i: IndirectCall =>
         i.target = visit_var(i.target)
         i
-      }
-      case m: MemoryAssign => {
+      case m: MemoryStore =>
         m.mem = visit_mem(m.mem)
         m.index = visit_expr(m.index)
         m.value = visit_expr(m.value)
         m
-      }
-      case m: Assign => {
+      case m: MemoryLoad =>
+        m.mem = visit_mem(m.mem)
+        m.index = visit_expr(m.index)
+        m.lhs = visit_var(m.lhs)
+        m
+      case m: LocalAssign =>
         m.rhs = visit_expr(m.rhs)
         m.lhs = visit_var(m.lhs)
         m
-      }
-      case s: Assert => {
+      case s: Assert =>
         s.body = visit_expr(s.body)
         s
-      }
-      case s: Assume => {
+      case s: Assume =>
         s.body = visit_expr(s.body)
         s
-      }
       case n: NOP => n
     }
     doVisitList(v, v.vstmt(s), s, continue)
@@ -126,7 +125,7 @@ class CILVisitorImpl(val v: CILVisitor) {
 
   def visit_block(b: Block): Block = {
     def continue(b: Block) = {
-      b.statements.foreach(s => {
+      b.statements.foreach { s =>
         val r = visit_stmt(s)
         r match {
           case Nil => b.statements.remove(s)
@@ -134,7 +133,7 @@ class CILVisitorImpl(val v: CILVisitor) {
             b.statements.replace(s, n)
             b.statements.insertAllAfter(Some(n), tl)
         }
-      })
+      }
       b.replaceJump(visit_jump(b.jump))
       b
     }
diff --git a/src/main/scala/ir/dsl/DSL.scala b/src/main/scala/ir/dsl/DSL.scala
index 3ebeefbc4..a0d87f5f9 100644
--- a/src/main/scala/ir/dsl/DSL.scala
+++ b/src/main/scala/ir/dsl/DSL.scala
@@ -1,6 +1,7 @@
 package ir.dsl
 import ir.*
 import scala.collection.mutable
+import scala.collection.mutable.ArrayBuffer
 import scala.collection.immutable.*
 
 val R0: Register = Register("R0", 64)
@@ -146,9 +147,8 @@ def stack: SharedMemory = SharedMemory("stack", 64, 8)
 def prog(procedures: EventuallyProcedure*): Program = {
   require(procedures.nonEmpty)
 
-  val initialMemory = mutable.ArrayBuffer.empty[MemorySection]
-  val readOnlyMemory = mutable.ArrayBuffer.empty[MemorySection]
-  val p = Program(mutable.ArrayBuffer.from(procedures.map(_.tempProc)), procedures.map(_.tempProc).head, initialMemory, readOnlyMemory)
+  val initialMemory = mutable.TreeMap[BigInt, MemorySection]()
+  val p = Program(ArrayBuffer.from(procedures.map(_.tempProc)), procedures.map(_.tempProc).head, initialMemory)
 
   procedures.foreach(_.resolve(p))
   p
diff --git a/src/main/scala/ir/transforms/IndirectCallResolution.scala b/src/main/scala/ir/transforms/IndirectCallResolution.scala
index 8f1ae8e3b..a643062cb 100644
--- a/src/main/scala/ir/transforms/IndirectCallResolution.scala
+++ b/src/main/scala/ir/transforms/IndirectCallResolution.scala
@@ -1,96 +1,140 @@
 package ir.transforms
 
-import scala.collection.mutable.ListBuffer
-import scala.collection.mutable.ArrayBuffer
-import analysis.solvers.*
-import analysis.*
-import bap.*
+import analysis.{AddressValue, DataRegion, Lift, LiftedElement, LiteralValue, MemoryModelMap, MemoryRegion, RegisterWrapperEqualSets, StackRegion, Value, getUse}
 import ir.*
-import translating.*
 import util.Logger
-import util.intrusive_list.IntrusiveList
+
 import scala.collection.mutable
-import cilvisitor._
-
-def resolveIndirectCallsUsingPointsTo(
-    pointsTos: Map[RegisterVariableWrapper, Set[RegisterVariableWrapper | MemoryRegion]],
-    regionContents: Map[MemoryRegion, Set[BitVecLiteral | MemoryRegion]],
-    reachingDefs: Map[CFGPosition, (Map[Variable, Set[Assign]], Map[Variable, Set[Assign]])],
-    IRProgram: Program
-): Boolean = {
-  var modified: Boolean = false
-  val worklist = ListBuffer[CFGPosition]()
-
-  worklist.addAll(IRProgram)
-
-  val visited = mutable.Set[CFGPosition]()
-  while (worklist.nonEmpty) {
-    val node = worklist.remove(0)
-    if (!visited.contains(node)) {
-      // add to worklist before we delete the node and can no longer find its successors
-      InterProcIRCursor.succ(node).foreach(node => worklist.addOne(node))
-      process(node)
-      visited.add(node)
-    }
-  }
+import scala.collection.mutable.{ArrayBuffer, ListBuffer}
+
+
+class SteensgaardIndirectCallResolution(
+  override val program: Program,
+  val pointsTos: Map[RegisterWrapperEqualSets | MemoryRegion, Set[RegisterWrapperEqualSets | MemoryRegion]],
+  val reachingDefs: Map[CFGPosition, (Map[Variable, Set[Assign]], Map[Variable, Set[Assign]])]
+) extends IndirectCallResolution {
 
-  def searchRegion(region: MemoryRegion): mutable.Set[String] = {
-    val result = mutable.Set[String]()
+  private def searchRegion(region: MemoryRegion): Set[String] = {
     region match {
       case stackRegion: StackRegion =>
-        if (regionContents.contains(stackRegion)) {
-          for (c <- regionContents(stackRegion)) {
-            c match {
-              case bitVecLiteral: BitVecLiteral => Logger.debug("hi: " + bitVecLiteral) //???
-              case memoryRegion: MemoryRegion =>
-                result.addAll(searchRegion(memoryRegion))
-            }
+        if (pointsTos.contains(stackRegion)) {
+          pointsTos(stackRegion).flatMap {
+            case registerWrapperEqualSets: RegisterWrapperEqualSets =>
+              pointsTos(registerWrapperEqualSets).flatMap {
+                case memoryRegion: MemoryRegion =>
+                  searchRegion(memoryRegion)
+                case registerWrapperEqualSets: RegisterWrapperEqualSets =>
+                  throw Exception(s"possibly recursive points-to relation? should I handle this? $registerWrapperEqualSets")
+              }
+            case memoryRegion: MemoryRegion =>
+              //searchRegion(memoryRegion)
+              Set(memoryRegion.regionIdentifier) // TODO: fix me
           }
+        } else {
+          Set()
         }
-        result
       case dataRegion: DataRegion =>
-        if (!regionContents.contains(dataRegion) || regionContents(dataRegion).isEmpty) {
-          result.add(dataRegion.regionIdentifier)
+        if (!pointsTos.contains(dataRegion) || pointsTos(dataRegion).isEmpty) {
+          Set(dataRegion.regionIdentifier)
         } else {
-          result.add(dataRegion.regionIdentifier) // TODO: may need to investigate if we should add the parent region
-          for (c <- regionContents(dataRegion)) {
-            c match {
-              case bitVecLiteral: BitVecLiteral => Logger.debug("hi: " + bitVecLiteral) //???
-              case memoryRegion: MemoryRegion =>
-                result.addAll(searchRegion(memoryRegion))
-            }
+          val names: Set[String] = pointsTos(dataRegion).flatMap {
+            case registerWrapperEqualSets: RegisterWrapperEqualSets =>
+              pointsTos(registerWrapperEqualSets).flatMap {
+                case memoryRegion: MemoryRegion =>
+                  searchRegion(memoryRegion)
+                case registerWrapperEqualSets: RegisterWrapperEqualSets =>
+                  throw Exception(s"possibly recursive points-to relation? should I handle this? $registerWrapperEqualSets")
+              }
+            case memoryRegion: MemoryRegion =>
+              //searchRegion(memoryRegion))
+              Set(memoryRegion.regionIdentifier) // TODO: fix me
           }
+          names + dataRegion.regionIdentifier // TODO: may need to investigate if we should add the parent region
         }
-        result
     }
   }
 
-  def addFakeProcedure(name: String): Procedure = {
-    val newProcedure = Procedure(name)
-    IRProgram.procedures += newProcedure
-    newProcedure
-  }
-
-  def resolveAddresses(variable: Variable, i: IndirectCall): mutable.Set[String] = {
-    val names = mutable.Set[String]()
-    val variableWrapper = RegisterVariableWrapper(variable, getUse(variable, i, reachingDefs))
+  override def resolveAddresses(variable: Variable, i: IndirectCall): Set[String] = {
+    val variableWrapper = RegisterWrapperEqualSets(variable, getUse(variable, i, reachingDefs))
     pointsTos.get(variableWrapper) match {
-      case Some(value) =>
-        value.map {
-          case v: RegisterVariableWrapper => names.addAll(resolveAddresses(v.variable, i))
-          case m: MemoryRegion            => names.addAll(searchRegion(m))
+      case Some(values) =>
+        values.flatMap {
+          case v: RegisterWrapperEqualSets => resolveAddresses(v.variable, i)
+          case m: MemoryRegion            => searchRegion(m)
         }
+      case None => Set()
+    }
+  }
+
+}
+
+class VSAIndirectCallResolution(
+  override val program: Program,
+  val vsaResult: Map[CFGPosition, LiftedElement[Map[Variable | MemoryRegion, Set[Value]]]],
+  val mmm: MemoryModelMap
+) extends IndirectCallResolution {
+
+  private def searchRegion(memoryRegion: MemoryRegion, n: CFGPosition): Set[String] = {
+    val names = vsaResult.get(n) match {
+      case Some(Lift(el)) => el.get(memoryRegion) match {
+        case Some(values) =>
+          values.flatMap {
+            case addressValue: AddressValue => searchRegion(addressValue.region, n)
+            case _ => Set()
+          }
+        case _ => Set()
+      }
+      case _ => Set()
+    }
+    memoryRegion match {
+      case _: StackRegion =>
         names
-      case None => names
+      case dataRegion: DataRegion =>
+        names ++ mmm.relfContent.getOrElse(dataRegion, Set())
+      case _ =>
+        Set()
+    }
+  }
+
+  override def resolveAddresses(variable: Variable, i: IndirectCall): Set[String] = {
+    vsaResult.get(i) match {
+      case Some(Lift(el)) => el.get(variable) match {
+        case Some(values) =>
+          values.flatMap {
+            case addressValue: AddressValue => searchRegion(addressValue.region, i)
+            case _: LiteralValue => Set()
+          }
+        case _ => Set()
+      }
+      case _ => Set()
     }
   }
+}
 
-  def process(n: CFGPosition): Unit = n match {
-    case indirectCall: IndirectCall if indirectCall.target != Register("R30", 64) =>
-      if (!indirectCall.hasParent) {
-        // skip if we have already processesd this call
-        return
+trait IndirectCallResolution {
+  val program: Program
+
+  def resolveIndirectCalls(): Boolean = {
+    var modified = false
+    val worklist = ListBuffer[CFGPosition]()
+    worklist.addAll(program)
+
+    val visited = mutable.Set[CFGPosition]()
+    while (worklist.nonEmpty) {
+      val node = worklist.remove(0)
+      if (!visited.contains(node)) {
+        // add to worklist before we delete the node and can no longer find its successors
+        InterProcIRCursor.succ(node).foreach(node => worklist.addOne(node))
+        modified = process(node) || modified
+        visited.add(node)
       }
+    }
+    modified
+  }
+
+  // returns whether or not the program was modified
+  def process(n: CFGPosition): Boolean = n match {
+    case indirectCall: IndirectCall if indirectCall.target != Register("R30", 64) && indirectCall.hasParent =>
       // we need the single-call-at-end-of-block invariant
       assert(indirectCall.parent.statements.lastOption.contains(indirectCall))
 
@@ -98,25 +142,22 @@ def resolveIndirectCallsUsingPointsTo(
       val procedure = block.parent
 
       val targetNames = resolveAddresses(indirectCall.target, indirectCall)
-      Logger.debug(s"Points-To approximated call ${indirectCall.target} with $targetNames")
-      Logger.debug(IRProgram.procedures)
-      val targets: mutable.Set[Procedure] =
-        targetNames.map(name => IRProgram.procedures.find(_.name == name).getOrElse(addFakeProcedure(name)))
+      Logger.debug(s"approximated call ${indirectCall.target} with $targetNames")
+      Logger.debug(program.procedures)
+      val targets: Set[Procedure] =
+        targetNames.map(name => program.procedures.find(_.name == name).getOrElse(addFakeProcedure(name)))
 
-      if (targets.size > 1) {
+      if (targets.nonEmpty) {
         Logger.debug(s"Resolved indirect call $indirectCall")
       }
 
       if (targets.size == 1) {
-        modified = true
-
         val newCall = DirectCall(targets.head, indirectCall.label)
         block.statements.replace(indirectCall, newCall)
+        true
       } else if (targets.size > 1) {
 
         val oft = indirectCall.parent.jump
-
-        modified = true
         val newBlocks = ArrayBuffer[Block]()
         for (t <- targets) {
           Logger.debug(targets)
@@ -131,9 +172,9 @@ def resolveIndirectCallsUsingPointsTo(
 
           /* copy the goto node resulting */
           val fallthrough = oft match {
-            case g: GoTo        => GoTo(g.targets, g.label)
-            case h: Unreachable => Unreachable()
-            case r: Return      => Return()
+            case g: GoTo => GoTo(g.targets, g.label)
+            case _: Unreachable => Unreachable()
+            case _: Return => Return()
           }
           newBlocks.append(Block(newLabel, None, ArrayBuffer(assume, directCall), fallthrough))
         }
@@ -141,9 +182,20 @@ def resolveIndirectCallsUsingPointsTo(
         procedure.addBlocks(newBlocks)
         val newCall = GoTo(newBlocks, indirectCall.label)
         block.replaceJump(newCall)
+        true
+      } else {
+        false
       }
     case _ =>
+      false
   }
 
-  modified
-}
+  def addFakeProcedure(name: String): Procedure = {
+    val newProcedure = Procedure(name)
+    program.procedures += newProcedure
+    newProcedure
+  }
+
+  def resolveAddresses(variable: Variable, i: IndirectCall): Set[String]
+
+}
\ No newline at end of file
diff --git a/src/main/scala/ir/transforms/SplitThreads.scala b/src/main/scala/ir/transforms/SplitThreads.scala
index 8678720e7..8123c0ae1 100644
--- a/src/main/scala/ir/transforms/SplitThreads.scala
+++ b/src/main/scala/ir/transforms/SplitThreads.scala
@@ -1,65 +1,46 @@
 package ir.transforms
 
-import scala.collection.mutable.ListBuffer
-import scala.collection.mutable.ArrayBuffer
-import analysis.solvers.*
-import analysis.*
-import bap.*
+import analysis.{DataRegion, MemoryRegion, RegisterWrapperEqualSets, getDefinition}
 import ir.*
-import translating.*
-import util.Logger
-import java.util.Base64
-import spray.json.DefaultJsonProtocol.*
-import util.intrusive_list.IntrusiveList
+
 import scala.collection.mutable
-import cilvisitor._
 
-// identify calls to pthread_create
-// use analysis result to determine the third parameter's value (the function pointer)
-// split off that procedure into new thread
-// do reachability analysis
-// also need a bit in the IR where it creates separate files
+
 def splitThreads(program: Program,
-                 pointsTo: Map[RegisterVariableWrapper, Set[RegisterVariableWrapper | MemoryRegion]],
-                 regionContents: Map[MemoryRegion, Set[BitVecLiteral | MemoryRegion]],
+                 pointsTo: Map[RegisterWrapperEqualSets, Set[RegisterWrapperEqualSets | MemoryRegion]],
                  reachingDefs: Map[CFGPosition, (Map[Variable, Set[Assign]], Map[Variable, Set[Assign]])]
                 ): Unit = {
   
-  // iterate over all commands - if call is to pthread_create, look up?
-  program.foreach(c =>
-    c match {
-      case d: DirectCall if d.target.name == "pthread_create" =>
-
-        // R2 should hold the function pointer of the function that begins the thread
-        // look up R2 value using points to results
-        val R2 = Register("R2", 64)
-        val b = reachingDefs(d)
-        val R2Wrapper = RegisterVariableWrapper(R2, getDefinition(R2, d, reachingDefs))
-        val threadTargets = pointsTo(R2Wrapper)
-
-        if (threadTargets.size > 1) {
-          // currently can't handle case where the thread created is ambiguous
-          throw Exception("can't handle thread creation with more than one possible target")
-        }
+  // iterate over all commands - if call is to pthread_create, look up
+  program.foreach {
+    case d: DirectCall if d.target.name == "pthread_create" =>
+      // R2 should hold the function pointer of the function that begins the thread
+      // look up R2 value using points to results
+      val R2 = Register("R2", 64)
+      val R2Wrapper = RegisterWrapperEqualSets(R2, getDefinition(R2, d, reachingDefs))
+      val threadTargets = pointsTo(R2Wrapper)
 
-        if (threadTargets.size == 1) {
+      if (threadTargets.size > 1) {
+        // currently can't handle case where the thread created is ambiguous
+        throw Exception("can't handle thread creation with more than one possible target")
+      }
 
-          // not trying to untangle the very messy region resolution at present, just dealing with simplest case
-          threadTargets.head match {
-            case data: DataRegion =>
-              val threadEntrance = program.procedures.find(_.name == data.regionIdentifier) match {
-                case Some(proc) => proc
-                case None => throw Exception("could not find procedure with name " + data.regionIdentifier)
-              }
-              val thread = ProgramThread(threadEntrance, mutable.LinkedHashSet(threadEntrance), Some(d))
-              program.threads.addOne(thread)
-            case _ =>
-              throw Exception("unexpected non-data region " + threadTargets.head + " as PointsTo result for R2 at " + d)
-          }
+      if (threadTargets.size == 1) {
+        // not trying to untangle the very messy region resolution at present, just dealing with simplest case
+        threadTargets.head match {
+          case data: DataRegion =>
+            val threadEntrance = program.procedures.find(_.name == data.regionIdentifier) match {
+              case Some(proc) => proc
+              case None => throw Exception("could not find procedure with name " + data.regionIdentifier)
+            }
+            val thread = ProgramThread(threadEntrance, mutable.LinkedHashSet(threadEntrance), Some(d))
+            program.threads.addOne(thread)
+          case _ =>
+            throw Exception("unexpected non-data region " + threadTargets.head + " as PointsTo result for R2 at " + d)
         }
-      case _ =>
-    })
-
+      }
+    case _ =>
+  }
 
   if (program.threads.nonEmpty) {
     val mainThread = ProgramThread(program.mainProcedure, mutable.LinkedHashSet(program.mainProcedure), None)
diff --git a/src/main/scala/specification/Specification.scala b/src/main/scala/specification/Specification.scala
index 6ae8d8cfe..1439e6b06 100644
--- a/src/main/scala/specification/Specification.scala
+++ b/src/main/scala/specification/Specification.scala
@@ -1,158 +1,61 @@
 package specification
 
-import boogie._
-import ir._
+import boogie.*
+import ir.*
 import util.Logger
 
 trait SpecVar extends BExpr {
+  val address: BigInt
   override def getType: BType = {
     throw new Exception("getType called on SpecVar")
   }
 }
 
-trait SpecGlobalOrAccess extends SpecVar {
+trait SpecGlobalOrAccess extends SpecVar with Ordered[SpecGlobalOrAccess] {
   val toAddrVar: BExpr
   val toOldVar: BVar
   val toOldGamma: BVar
   val size: Int
+
+  def compare(that: SpecGlobalOrAccess): Int = address.compare(that.address)
+}
+
+trait SymbolTableEntry{
+  val name: String
+  val size: Int
+  val address: BigInt
 }
 
-case class SpecGlobal(name: String, override val size: Int, arraySize: Option[Int], address: BigInt)
-    extends SpecGlobalOrAccess {
+case class FuncEntry(override val name: String, override val size: Int, override val address: BigInt) extends SymbolTableEntry
+
+case class SpecGlobal(override val name: String, override val size: Int, arraySize: Option[Int], override val address: BigInt)
+    extends SymbolTableEntry, SpecGlobalOrAccess {
   override def specGlobals: Set[SpecGlobalOrAccess] = Set(this)
   override val toAddrVar: BVar = BVariable("$" + s"${name}_addr", BitVecBType(64), Scope.Const)
   override val toOldVar: BVar = BVariable(s"${name}_old", BitVecBType(size), Scope.Local)
   override val toOldGamma: BVar = BVariable(s"Gamma_${name}_old", BoolBType, Scope.Local)
   val toAxiom: BAxiom = BAxiom(BinaryBExpr(BoolEQ, toAddrVar, BitVecBLiteral(address, 64)), List.empty)
-  override def resolveSpec: BMemoryLoad = BMemoryLoad(
-    BMapVar("mem", MapBType(BitVecBType(64), BitVecBType(8)), Scope.Global),
-    toAddrVar,
-    Endian.LittleEndian,
-    size
-  )
-  override def resolveSpecParam: BMemoryLoad = BMemoryLoad(
-    BMapVar("mem$out", MapBType(BitVecBType(64), BitVecBType(8)), Scope.Parameter),
-    toAddrVar,
-    Endian.LittleEndian,
-    size
-  )
-  override def resolveSpecParamOld: BMemoryLoad = BMemoryLoad(
-    BMapVar("mem$in", MapBType(BitVecBType(64), BitVecBType(8)), Scope.Parameter),
-    toAddrVar,
-    Endian.LittleEndian,
-    size
-  )
-  override def resolveSpecInv: BMemoryLoad = BMemoryLoad(
-    BMapVar("mem$inv2", MapBType(BitVecBType(64), BitVecBType(8)), Scope.Local),
-    toAddrVar,
-    Endian.LittleEndian,
-    size
-  )
-  override def resolveSpecInvOld: BMemoryLoad = BMemoryLoad(
-    BMapVar("mem$inv1", MapBType(BitVecBType(64), BitVecBType(8)), Scope.Local),
-    toAddrVar,
-    Endian.LittleEndian,
-    size
-  )
-  override def resolveOld: BMemoryLoad = resolveSpec
-  override def resolveInsideOld: BExpr = toOldVar
-  override def removeOld: BMemoryLoad = resolveSpec
-  override def resolveSpecL: BMemoryLoad = BMemoryLoad(
-    BMapVar("memory", MapBType(BitVecBType(64), BitVecBType(8)), Scope.Parameter),
-    toAddrVar,
-    Endian.LittleEndian,
-    size
-  )
+  override def acceptVisit(visitor: BVisitor): BExpr = visitor.visitSpecGlobal(this)
 }
 
 case class SpecGamma(global: SpecGlobal) extends SpecVar {
-  // TODO don't hardcode this
-  override def resolveSpec: GammaLoad = GammaLoad(
-    BMapVar("Gamma_mem", MapBType(BitVecBType(64), BoolBType), Scope.Global),
-    global.toAddrVar,
-    global.size,
-    global.size / 8
-  )
-  override def resolveSpecParam: GammaLoad = GammaLoad(
-    BMapVar("Gamma_mem$out", MapBType(BitVecBType(64), BoolBType), Scope.Parameter),
-    global.toAddrVar,
-    global.size,
-    global.size / 8
-  )
-  override def resolveSpecParamOld: GammaLoad = GammaLoad(
-    BMapVar("Gamma_mem$in", MapBType(BitVecBType(64), BoolBType), Scope.Parameter),
-    global.toAddrVar,
-    global.size,
-    global.size / 8
-  )
-  override def resolveSpecInv: GammaLoad = GammaLoad(
-    BMapVar("Gamma_mem$inv2", MapBType(BitVecBType(64), BoolBType), Scope.Local),
-    global.toAddrVar,
-    global.size,
-    global.size / 8
-  )
-  override def resolveSpecInvOld: GammaLoad = GammaLoad(
-    BMapVar("Gamma_mem$inv1", MapBType(BitVecBType(64), BoolBType), Scope.Local),
-    global.toAddrVar,
-    global.size,
-    global.size / 8
-  )
-  override def resolveOld: GammaLoad = resolveSpec
-  override def resolveInsideOld: BExpr = global.toOldGamma
-  override def removeOld: GammaLoad = resolveSpec
-  override def resolveSpecL: GammaLoad = resolveSpec
+  override val address = global.address
+  override def acceptVisit(visitor: BVisitor): BExpr = visitor.visitSpecGamma(this)
 }
 
 case class ArrayAccess(global: SpecGlobal, index: Int) extends SpecGlobalOrAccess {
+  val offset = index * (global.size / 8)
+  override val address = global.address + offset
   override val size: Int = global.size
-  private val accessIndex = BitVecBLiteral(index * (global.size / 8), 64)
   override val toOldVar: BVar = BVariable(s"${global.name}$$${index}_old", BitVecBType(global.size), Scope.Local)
-  override val toAddrVar: BExpr = BinaryBExpr(BVADD, global.toAddrVar, accessIndex)
+  override val toAddrVar: BExpr = BinaryBExpr(BVADD, global.toAddrVar, BitVecBLiteral(offset, 64))
   override val toOldGamma: BVar = BVariable(s"Gamma_${global.name}$$${index}_old", BoolBType, Scope.Local)
   override def specGlobals: Set[SpecGlobalOrAccess] = Set(this)
-  override def resolveSpec: BMemoryLoad = BMemoryLoad(
-    BMapVar("mem", MapBType(BitVecBType(64), BitVecBType(8)), Scope.Global),
-    toAddrVar,
-    Endian.LittleEndian,
-    global.size
-  )
-  override def resolveSpecParam: BMemoryLoad = BMemoryLoad(
-    BMapVar("mem$out", MapBType(BitVecBType(64), BitVecBType(8)), Scope.Parameter),
-    toAddrVar,
-    Endian.LittleEndian,
-    global.size
-  )
-  override def resolveSpecParamOld: BMemoryLoad = BMemoryLoad(
-    BMapVar("mem$in", MapBType(BitVecBType(64), BitVecBType(8)), Scope.Parameter),
-    toAddrVar,
-    Endian.LittleEndian,
-    global.size
-  )
-
-  override def resolveSpecInv: BMemoryLoad = BMemoryLoad(
-    BMapVar("mem$inv2", MapBType(BitVecBType(64), BitVecBType(8)), Scope.Local),
-    toAddrVar,
-    Endian.LittleEndian,
-    global.size
-  )
-  override def resolveSpecInvOld: BMemoryLoad = BMemoryLoad(
-    BMapVar("mem$inv1", MapBType(BitVecBType(64), BitVecBType(8)), Scope.Local),
-    toAddrVar,
-    Endian.LittleEndian,
-    global.size
-  )
-  override def resolveOld: BMemoryLoad = resolveSpec
-  override def resolveInsideOld: BExpr = toOldVar
-  override def removeOld: BMemoryLoad = resolveSpec
-  override def resolveSpecL: BMemoryLoad = BMemoryLoad(
-    BMapVar("memory", MapBType(BitVecBType(64), BitVecBType(8)), Scope.Parameter),
-    toAddrVar,
-    Endian.LittleEndian,
-    global.size
-  )
+  override def acceptVisit(visitor: BVisitor): BExpr = visitor.visitArrayAccess(this)
 }
 
 case class Specification(
+    funcs: Set[FuncEntry],
     globals: Set[SpecGlobal],
     LPreds: Map[SpecGlobal, BExpr],
     relies: List[BExpr],
@@ -160,11 +63,9 @@ case class Specification(
     subroutines: List[SubroutineSpec],
     directFunctions: Set[FunctionOp]
 ) {
-  val guaranteeOldVars: List[SpecGlobalOrAccess] = guarantees.flatMap(g => g.oldSpecGlobals)
-
   val controls: Map[SpecGlobalOrAccess, Set[SpecGlobal]] = {
     val controlledBy = LPreds.map((k, v) => k -> v.specGlobals).collect { case (k, v) if v.nonEmpty => (k, v) }
-    controlledBy.toSet.flatMap((k, v) => v.map(_ -> k)).groupMap(_._1)(_._2)
+    controlledBy.toSet.flatMap((k, v) => v.map(_ -> k)).groupMap(_(0))(_(1))
   }
   val controlled: Set[SpecGlobal] = controls.values.flatten.toSet
 }
diff --git a/src/main/scala/translating/BAPToIR.scala b/src/main/scala/translating/BAPToIR.scala
index ae501c277..9793022cb 100644
--- a/src/main/scala/translating/BAPToIR.scala
+++ b/src/main/scala/translating/BAPToIR.scala
@@ -8,6 +8,7 @@ import specification.*
 import scala.collection.mutable
 import scala.collection.mutable.Map
 import scala.collection.mutable.ArrayBuffer
+import scala.collection.mutable.TreeMap
 import util.intrusive_list.*
 
 class BAPToIR(var program: BAPProgram, mainAddress: BigInt) {
@@ -15,6 +16,8 @@ class BAPToIR(var program: BAPProgram, mainAddress: BigInt) {
   private val nameToProcedure: mutable.Map[String, Procedure] = mutable.Map()
   private val labelToBlock: mutable.Map[String, Block] = mutable.Map()
 
+  private var loadCounter: Int = 0
+
   def translate: Program = {
     var mainProcedure: Option[Procedure] = None
     val procedures: ArrayBuffer[Procedure] = ArrayBuffer()
@@ -29,10 +32,10 @@ class BAPToIR(var program: BAPProgram, mainAddress: BigInt) {
         labelToBlock.addOne(b.label, block)
       }
       for (p <- s.in) {
-        procedure.in.append(p.toIR)
+        procedure.in.append(translateParameter(p))
       }
       for (p <- s.out) {
-        procedure.out.append(p.toIR)
+        procedure.out.append(translateParameter(p))
       }
       if (s.address.get == mainAddress) {
         mainProcedure = Some(procedure)
@@ -46,7 +49,10 @@ class BAPToIR(var program: BAPProgram, mainAddress: BigInt) {
       for (b <- s.blocks) {
         val block = labelToBlock(b.label)
         for (st <- b.statements) {
-          block.statements.append(translate(st))
+          val statements = translateStatement(st)
+          for (s <- statements) {
+            block.statements.append(s)
+          }
         }
         val (call, jump, newBlocks) = translate(b.jumps, block)
         procedure.addBlocks(newBlocks)
@@ -62,26 +68,160 @@ class BAPToIR(var program: BAPProgram, mainAddress: BigInt) {
 
     }
 
-    val memorySections: ArrayBuffer[MemorySection] = ArrayBuffer()
+    val memorySections: mutable.TreeMap[BigInt, MemorySection] = mutable.TreeMap()
     for (m <- program.memorySections) {
-      val bytes = m.bytes.map(_.toIR)
-      memorySections.append(MemorySection(m.name, m.address, m.size, bytes))
+      val bytes = if (m.name == ".bss" && m.bytes.isEmpty) {
+        for (_ <- 0 until m.size) yield BitVecLiteral(0, 8)
+      } else {
+        m.bytes.map(translateLiteral)
+      }
+      val readOnly = m.name == ".rodata" || m.name == ".got" // crude heuristic
+      memorySections.addOne(m.address, MemorySection(m.name, m.address, m.size, bytes, readOnly, None))
     }
 
-    Program(procedures, mainProcedure.get, memorySections, ArrayBuffer())
+    Program(procedures, mainProcedure.get, memorySections)
   }
 
-  private def translate(s: BAPStatement) = s match {
+  private def translateStatement(s: BAPStatement): Seq[Statement] = s match {
     case b: BAPMemAssign =>
-      val mem = b.lhs.toIRMemory
-      if (mem != b.rhs.memory.toIRMemory) {
+      val mem = translateMemory(b.lhs)
+      if (mem != translateMemory(b.rhs.memory)) {
         throw Exception(s"$b has conflicting lhs ${b.lhs} and rhs ${b.rhs.memory}")
       }
-      MemoryAssign(mem, b.rhs.index.toIR, b.rhs.value.toIR, b.rhs.endian, b.rhs.size, Some(b.line))
+      Seq(MemoryStore(mem, translateExprOnly(b.rhs.index), translateExprOnly(b.rhs.value), b.rhs.endian, b.rhs.size, Some(b.line)))
     case b: BAPLocalAssign =>
-      Assign(b.lhs.toIR, b.rhs.toIR, Some(b.line))
+      val lhs = translateVar(b.lhs)
+      val (rhs, load) = translateExpr(b.rhs)
+      if (load.isDefined) {
+        val loadWithLabel = MemoryLoad(load.get.lhs, load.get.mem, load.get.index, load.get.endian, load.get.size, Some(b.line + "$0"))
+        val assign = LocalAssign(lhs, rhs, Some(b.line + "$1"))
+        Seq(loadWithLabel, assign)
+      } else {
+        val assign = LocalAssign(lhs, rhs, Some(b.line))
+        Seq(assign)
+      }
   }
 
+  private def translateExpr(e: BAPExpr): (Expr, Option[MemoryLoad]) = e match {
+    case b @ BAPConcat(left, right) =>
+      val (arg0, load0) = translateExpr(left)
+      val (arg1, load1) = translateExpr(right)
+      (load0, load1) match {
+        case (Some(load), None) => (BinaryExpr(BVCONCAT, arg0, arg1), Some(load))
+        case (None, Some(load)) => (BinaryExpr(BVCONCAT, arg0, arg1), Some(load))
+        case (None, None) => (BinaryExpr(BVCONCAT, arg0, arg1), None)
+        case (Some(_), Some(_)) => throw Exception(s"$b contains multiple loads")
+      }
+    case BAPSignedExtend(width, body) =>
+      if (width > body.size) {
+        val (irBody, load) = translateExpr(body)
+        val se = SignExtend(width - body.size, irBody)
+        (se, load)
+      } else {
+        translateExpr(BAPExtract(width - 1, 0, body))
+      }
+    case BAPUnsignedExtend(width, body) =>
+      if (width > body.size) {
+        val (irBody, load) = translateExpr(body)
+        val ze = ZeroExtend(width - body.size, irBody)
+        (ze, load)
+      } else {
+        translateExpr(BAPExtract(width - 1, 0, body))
+      }
+    case b @ BAPExtract(high, low, body) =>
+      val bodySize = body.size
+      val (irBody, load) = translateExpr(body)
+      val extract = if (b.size > bodySize) {
+        if (low == 0) {
+          ZeroExtend(b.size - bodySize, irBody)
+        } else {
+          Extract(high + 1, low, ZeroExtend(b.size - bodySize, irBody))
+        }
+      } else {
+        Extract(high + 1, low, irBody)
+      }
+      (extract, load)
+    case literal: BAPLiteral => (translateLiteral(literal), None)
+    case BAPUnOp(operator, exp) => operator match {
+      case NOT => (UnaryExpr(BVNOT, translateExprOnly(exp)), None)
+      case NEG => (UnaryExpr(BVNEG, translateExprOnly(exp)), None)
+    }
+    case BAPBinOp(operator, lhs, rhs) => operator match {
+      case PLUS => (BinaryExpr(BVADD, translateExprOnly(lhs), translateExprOnly(rhs)), None)
+      case MINUS => (BinaryExpr(BVSUB, translateExprOnly(lhs), translateExprOnly(rhs)), None)
+      case TIMES => (BinaryExpr(BVMUL, translateExprOnly(lhs), translateExprOnly(rhs)), None)
+      case DIVIDE => (BinaryExpr(BVUDIV, translateExprOnly(lhs), translateExprOnly(rhs)), None)
+      case SDIVIDE => (BinaryExpr(BVSDIV, translateExprOnly(lhs), translateExprOnly(rhs)), None)
+      // counterintuitive but correct according to BAP source
+      case MOD => (BinaryExpr(BVSREM, translateExprOnly(lhs), translateExprOnly(rhs)), None)
+      // counterintuitive but correct according to BAP source
+      case SMOD => (BinaryExpr(BVUREM, translateExprOnly(lhs), translateExprOnly(rhs)), None)
+      case LSHIFT => // BAP says caring about this case is necessary?
+        if (lhs.size == rhs.size) {
+          (BinaryExpr(BVSHL, translateExprOnly(lhs), translateExprOnly(rhs)), None)
+        } else {
+          (BinaryExpr(BVSHL, translateExprOnly(lhs), ZeroExtend(lhs.size - rhs.size, translateExprOnly(rhs))), None)
+        }
+      case RSHIFT =>
+        if (lhs.size == rhs.size) {
+          (BinaryExpr(BVLSHR, translateExprOnly(lhs), translateExprOnly(rhs)), None)
+        } else {
+          (BinaryExpr(BVLSHR, translateExprOnly(lhs), ZeroExtend(lhs.size - rhs.size, translateExprOnly(rhs))), None)
+        }
+      case ARSHIFT =>
+        if (lhs.size == rhs.size) {
+          (BinaryExpr(BVASHR, translateExprOnly(lhs), translateExprOnly(rhs)), None)
+        } else {
+          (BinaryExpr(BVASHR, translateExprOnly(lhs), ZeroExtend(lhs.size - rhs.size, translateExprOnly(rhs))), None)
+        }
+      case AND => (BinaryExpr(BVAND, translateExprOnly(lhs), translateExprOnly(rhs)), None)
+      case OR => (BinaryExpr(BVOR, translateExprOnly(lhs), translateExprOnly(rhs)), None)
+      case XOR => (BinaryExpr(BVXOR, translateExprOnly(lhs), translateExprOnly(rhs)), None)
+      case EQ => (BinaryExpr(BVCOMP, translateExprOnly(lhs), translateExprOnly(rhs)), None)
+      case NEQ => (UnaryExpr(BVNOT, BinaryExpr(BVCOMP, translateExprOnly(lhs), translateExprOnly(rhs))), None)
+      case LT => (BinaryExpr(BVULT, translateExprOnly(lhs), translateExprOnly(rhs)), None)
+      case LE => (BinaryExpr(BVULE, translateExprOnly(lhs), translateExprOnly(rhs)), None)
+      case SLT => (BinaryExpr(BVSLT, translateExprOnly(lhs), translateExprOnly(rhs)), None)
+      case SLE => (BinaryExpr(BVSLE, translateExprOnly(lhs), translateExprOnly(rhs)), None)
+    }
+    case b: BAPVar => (translateVar(b), None)
+    case BAPMemAccess(memory, index, endian, size) =>
+      val temp = LocalVar("$load$" + loadCounter, BitVecType(size))
+      loadCounter += 1
+      val load = MemoryLoad(temp, translateMemory(memory), translateExprOnly(index), endian, size, None)
+      (temp, Some(load))
+  }
+
+  private def translateExprOnly(e: BAPExpr) = {
+    val (expr, load) = translateExpr(e)
+    if (load.isDefined) {
+      throw Exception(s"unexpected load in $e")
+    }
+    expr
+  }
+
+  private def translateVar(variable: BAPVar): Variable = variable match {
+    case BAPRegister(name, size) => Register(name, size)
+    case BAPLocalVar(name, size) => LocalVar(name, BitVecType(size))
+  }
+
+  private def translateMemory(memory: BAPMemory): Memory = {
+    SharedMemory(memory.name, memory.addressSize, memory.valueSize)
+  }
+
+  private def translateParameter(parameter: BAPParameter): Parameter = {
+    val register = translateExprOnly(parameter.value)
+    register match {
+      case r: Register => Parameter(parameter.name, parameter.size, r)
+      case _ => throw Exception(s"subroutine parameter $this refers to non-register variable ${parameter.value}")
+    }
+  }
+
+  private def translateLiteral(literal: BAPLiteral) = {
+    BitVecLiteral(literal.value, literal.size)
+  }
+
+
   /**
     * Translates a list of jumps from BAP into a single Jump at the IR level by moving any conditions on jumps to
     * Assume statements in new blocks
@@ -106,7 +246,9 @@ class BAPToIR(var program: BAPProgram, mainAddress: BigInt) {
                   // condition is true and previous conditions existing means this condition
                   // is actually that all previous conditions are false
                   val conditionsIR = conditions.map(c => convertConditionBool(c, true))
-                  val condition = conditionsIR.tail.foldLeft(conditionsIR.head)((ands: Expr, next: Expr) => BinaryExpr(BoolAND, next, ands))
+                  val condition = conditionsIR.tail.foldLeft(conditionsIR.head) {
+                    (ands: Expr, next: Expr) => BinaryExpr(BoolAND, next, ands)
+                  }
                   val newBlock = newBlockCondition(block, target, condition)
                   newBlocks.append(newBlock)
                   targets.append(newBlock)
@@ -121,7 +263,9 @@ class BAPToIR(var program: BAPProgram, mainAddress: BigInt) {
                   // if this is not the first condition, then we need to need to add
                   // that all previous conditions are false
                   val conditionsIR = conditions.map(c => convertConditionBool(c, true))
-                  conditionsIR.tail.foldLeft(currentCondition)((ands: Expr, next: Expr) => BinaryExpr(BoolAND, next, ands))
+                  conditionsIR.tail.foldLeft(currentCondition) {
+                    (ands: Expr, next: Expr) => BinaryExpr(BoolAND, next, ands)
+                  }
                 }
                 val newBlock = newBlockCondition(block, target, condition)
                 newBlocks.append(newBlock)
@@ -136,11 +280,11 @@ class BAPToIR(var program: BAPProgram, mainAddress: BigInt) {
       jumps.head match {
         case b: BAPDirectCall =>
           val call = Some(DirectCall(nameToProcedure(b.target),Some(b.line)))
-          val ft = (b.returnTarget.map(t => labelToBlock(t))).map(x => GoTo(Set(x))).getOrElse(Unreachable())
+          val ft = b.returnTarget.map(t => labelToBlock(t)).map(x => GoTo(Set(x))).getOrElse(Unreachable())
           (call, ft, ArrayBuffer())
         case b: BAPIndirectCall =>
-          val call = IndirectCall(b.target.toIR, Some(b.line))
-          val ft = (b.returnTarget.map(t => labelToBlock(t))).map(x => GoTo(Set(x))).getOrElse(Unreachable())
+          val call = IndirectCall(translateVar(b.target), Some(b.line))
+          val ft = b.returnTarget.map(t => labelToBlock(t)).map(x => GoTo(Set(x))).getOrElse(Unreachable())
           (Some(call), ft, ArrayBuffer())
         case b: BAPGoTo =>
           val target = labelToBlock(b.target)
@@ -167,7 +311,7 @@ class BAPToIR(var program: BAPProgram, mainAddress: BigInt) {
     * if necessary.
     * */
   private def convertConditionBool(expr: BAPExpr, negative: Boolean): Expr = {
-    val e = expr.toIR
+    val e = translateExprOnly(expr)
     e.getType match {
       case BitVecType(s) =>
         if (negative) {
diff --git a/src/main/scala/translating/SemanticsLoader.scala b/src/main/scala/translating/GTIRBLoader.scala
similarity index 68%
rename from src/main/scala/translating/SemanticsLoader.scala
rename to src/main/scala/translating/GTIRBLoader.scala
index e858a9e85..836ed5de0 100644
--- a/src/main/scala/translating/SemanticsLoader.scala
+++ b/src/main/scala/translating/GTIRBLoader.scala
@@ -1,5 +1,5 @@
 package translating
-import Parsers.SemanticsParser.*
+import Parsers.ASLpParser.*
 import com.google.protobuf.ByteString
 import Parsers.*
 
@@ -13,14 +13,15 @@ import scala.collection.mutable.ArrayBuffer
 import com.grammatech.gtirb.proto.Module.ByteOrder.LittleEndian
 import util.Logger
 
-class SemanticsLoader(parserMap: immutable.Map[String, Array[Array[StmtContext]]]) {
+class GTIRBLoader(parserMap: immutable.Map[String, Array[Array[StmtContext]]]) {
 
   private val constMap = mutable.Map[String, IRType]()
   private val varMap = mutable.Map[String, IRType]()
   private var instructionCount = 0
   private var blockCount = 0
+  private var loadCounter = 0
 
-  val opcodeSize = 4
+  private val opcodeSize = 4
 
   def visitBlock(blockUUID: ByteString, blockCountIn: Int, blockAddress: Option[BigInt]): ArrayBuffer[Statement] = {
     blockCount = blockCountIn
@@ -39,34 +40,31 @@ class SemanticsLoader(parserMap: immutable.Map[String, Array[Array[StmtContext]]
           val instructionAddress = a + (opcodeSize * instructionCount)
           instructionAddress.toString + "$" + i
         }
-        
-        val statement = visitStmt(s, label)
-        if (statement.isDefined) {
-          statements.append(statement.get)
-        }
+
+        statements.appendAll(visitStmt(s, label))
       }
       instructionCount += 1
     }
     statements
   }
 
-  private def visitStmt(ctx: StmtContext, label: Option[String] = None): Option[Statement] = {
+  private def visitStmt(ctx: StmtContext, label: Option[String] = None): Seq[Statement] = {
     ctx match {
       case a: AssignContext => visitAssign(a, label)
       case c: ConstDeclContext => visitConstDecl(c, label)
       case v: VarDeclContext => visitVarDecl(v, label)
       case v: VarDeclsNoInitContext =>
         visitVarDeclsNoInit(v)
-        None
-      case a: AssertContext => visitAssert(a, label)
-      case t: TCallContext => visitTCall(t, label)
-      case i: IfContext => visitIf(i, label)
-      case t: ThrowContext => Some(visitThrow(t, label))
+        Seq()
+      case a: AssertContext => visitAssert(a, label).toSeq
+      case t: TCallContext => visitTCall(t, label).toSeq
+      case i: IfContext => visitIf(i, label).toSeq
+      case t: ThrowContext => Seq(visitThrow(t, label))
     }
   }
 
-  private def visitAssert(ctx: AssertContext, label: Option[String] = None): Option[Assert] = {
-    val expr = visitExpr(ctx.expr)
+  private def visitAssert(ctx: AssertContext, label: Option[String] = None): Option[Statement] = {
+    val expr = visitExprOnly(ctx.expr)
     if (expr.isDefined) {
       Some(Assert(expr.get, None, label))
     } else {
@@ -90,8 +88,8 @@ class SemanticsLoader(parserMap: immutable.Map[String, Array[Array[StmtContext]]
         checkArgs(function, 1, 4, typeArgs.size, args.size, ctx.getText)
         val mem = SharedMemory("mem", 64, 8) // yanked from BAP
         val size = parseInt(typeArgs.head) * 8
-        val index = visitExpr(args.head)
-        val value = visitExpr(args(3))
+        val index = visitExprOnly(args.head)
+        val value = visitExprOnly(args(3))
         val otherSize = parseInt(args(1)) * 8
         val accessType = parseInt(args(2)) // AccType enum in ASLi, not very relevant to us
         if (size != otherSize) {
@@ -100,12 +98,12 @@ class SemanticsLoader(parserMap: immutable.Map[String, Array[Array[StmtContext]]
 
         // LittleEndian is an assumption
         if (index.isDefined && value.isDefined) {
-          Some(MemoryAssign(mem, index.get, value.get, Endian.LittleEndian, size.toInt, label))
+          Some(MemoryStore(mem, index.get, value.get, Endian.LittleEndian, size.toInt, label))
         } else {
           None
         }
       case "unsupported_opcode.0" => {
-        val op = args.headOption.flatMap(visitExpr) match {
+        val op = args.headOption.flatMap(visitExprOnly) match {
           case Some(IntLiteral(s)) => Some("%08x".format(s))
           case c => c.map(_.toString)
         }
@@ -130,7 +128,7 @@ class SemanticsLoader(parserMap: immutable.Map[String, Array[Array[StmtContext]]
   }
 
   private def visitIf(ctx: IfContext, label: Option[String] = None): Option[TempIf] = {
-    val condition = visitExpr(ctx.cond)
+    val condition = visitExprOnly(ctx.cond)
     val thenStmts = ctx.thenStmts.stmt.asScala.flatMap(visitStmt(_, label))
 
     val elseStmts = Option(ctx.elseStmts) match {
@@ -151,35 +149,64 @@ class SemanticsLoader(parserMap: immutable.Map[String, Array[Array[StmtContext]]
     varMap ++= newVars
   }
 
-  private def visitVarDecl(ctx: VarDeclContext, label: Option[String] = None): Option[Assign] = {
+  private def visitVarDecl(ctx: VarDeclContext, label: Option[String] = None): Seq[Statement] = {
     val ty = visitType(ctx.`type`())
     val name = visitIdent(ctx.lvar)
     varMap += (name -> ty)
 
-    val expr = visitExpr(ctx.expr())
-    expr.map(Assign(LocalVar(name, ty), _, label))
+    val (expr, load) = visitExpr(ctx.expr)
+    if (expr.isDefined) {
+      if (load.isDefined) {
+        val loadWithLabel = MemoryLoad(load.get.lhs, load.get.mem, load.get.index, load.get.endian, load.get.size, label.map(_ + "$0"))
+        val assign = LocalAssign(LocalVar(name, ty), expr.get, label.map(_ + "$1"))
+        Seq(loadWithLabel, assign)
+      } else {
+        val assign = LocalAssign(LocalVar(name, ty), expr.get, label)
+        Seq(assign)
+      }
+    } else {
+      Seq()
+    }
   }
 
-  private def visitAssign(ctx: AssignContext, label: Option[String] = None): Option[Assign] = {
+  private def visitAssign(ctx: AssignContext, label: Option[String] = None): Seq[Statement] = {
     val lhs = visitLexpr(ctx.lexpr)
-    val rhs = visitExpr(ctx.expr)
-    lhs.zip(rhs).map((lhs, rhs) => Assign(lhs, rhs, label))
+    val (rhs, load) = visitExpr(ctx.expr)
+    if (lhs.isDefined && rhs.isDefined) {
+      if (load.isDefined) {
+        val loadWithLabel = MemoryLoad(load.get.lhs, load.get.mem, load.get.index, load.get.endian, load.get.size, label.map(_ + "$0"))
+        val assign = LocalAssign(lhs.get, rhs.get, label.map(_ + "$1"))
+        Seq(loadWithLabel, assign)
+      } else {
+        val assign = LocalAssign(lhs.get, rhs.get, label)
+        Seq(assign)
+      }
+    } else {
+      Seq()
+    }
   }
 
-  private def visitConstDecl(ctx: ConstDeclContext, label: Option[String] = None): Option[Assign] = {
+  private def visitConstDecl(ctx: ConstDeclContext, label: Option[String] = None): Seq[Statement] = {
     val ty = visitType(ctx.`type`())
     val name = visitIdent(ctx.lvar)
     constMap += (name -> ty)
-    val expr = visitExpr(ctx.expr)
+    val (expr, load) = visitExpr(ctx.expr)
     if (expr.isDefined) {
-      Some(Assign(LocalVar(name + "$" + blockCount + "$" + instructionCount, ty), expr.get, label))
+      if (load.isDefined) {
+        val loadWithLabel = MemoryLoad(load.get.lhs, load.get.mem, load.get.index, load.get.endian, load.get.size, label.map(_ + "$0"))
+        val assign = LocalAssign(LocalVar(name + "$" + blockCount + "$" + instructionCount, ty), expr.get, label.map(_ + "$1"))
+        Seq(loadWithLabel, assign)
+      } else {
+        val assign = LocalAssign(LocalVar(name + "$" + blockCount + "$" + instructionCount, ty), expr.get, label)
+        Seq(assign)
+      }
     } else {
-      None
+      Seq()
     }
   }
 
   private def visitType(ctx: TypeContext): IRType = {
-    ctx match
+    ctx match {
       case e: TypeBitsContext => BitVecType(parseInt(e.size).toInt)
       case r: TypeRegisterContext =>
         // this is a special register - not the same as a register in the IR
@@ -191,21 +218,31 @@ class SemanticsLoader(parserMap: immutable.Map[String, Array[Array[StmtContext]]
         case _ => throw Exception(s"unknown type ${ctx.getText}")
       }
       case _ => throw Exception(s"unknown type ${ctx.getText}")
+    }
   }
 
-  private def visitExpr(ctx: ExprContext): Option[Expr] = {
+  private def visitExpr(ctx: ExprContext): (Option[Expr], Option[MemoryLoad]) = {
     ctx match {
-      case e: ExprVarContext => visitExprVar(e)
+      case e: ExprVarContext => (visitExprVar(e), None)
       case e: ExprTApplyContext => visitExprTApply(e)
       case e: ExprSlicesContext => visitExprSlices(e)
-      case e: ExprFieldContext => Some(visitExprField(e))
-      case e: ExprArrayContext => Some(visitExprArray(e))
-      case e: ExprLitIntContext => Some(IntLiteral(parseInt(e)))
-      case e: ExprLitBitsContext => Some(visitExprLitBits(e))
+      case e: ExprFieldContext => (Some(visitExprField(e)), None)
+      case e: ExprArrayContext => (Some(visitExprArray(e)), None)
+      case e: ExprLitIntContext => (Some(IntLiteral(parseInt(e))), None)
+      case e: ExprLitBitsContext => (Some(visitExprLitBits(e)), None)
     }
   }
 
-  private  def visitExprVar(ctx: ExprVarContext): Option[Expr] = {
+  private def visitExprOnly(ctx: ExprContext): Option[Expr] = {
+    val (expr, load) = visitExpr(ctx)
+    if (load.isDefined) {
+      throw Exception("")
+    } else {
+      expr
+    }
+  }
+
+  private def visitExprVar(ctx: ExprVarContext): Option[Expr] = {
     val name = visitIdent(ctx.ident)
     name match {
       case n if constMap.contains(n) => Some(LocalVar(n + "$" + blockCount + "$" + instructionCount, constMap(n)))
@@ -225,7 +262,7 @@ class SemanticsLoader(parserMap: immutable.Map[String, Array[Array[StmtContext]]
     }
   }
 
-  private def visitExprTApply(ctx: ExprTApplyContext): Option[Expr] = {
+  private def visitExprTApply(ctx: ExprTApplyContext): (Option[Expr], Option[MemoryLoad]) = {
     val function = visitIdent(ctx.ident)
 
     val typeArgs: mutable.Buffer[ExprContext] = Option(ctx.tes) match {
@@ -241,7 +278,7 @@ class SemanticsLoader(parserMap: immutable.Map[String, Array[Array[StmtContext]]
       case "Mem.read.0" =>
         checkArgs(function, 1, 3, typeArgs.size, args.size, ctx.getText)
         val mem = SharedMemory("mem", 64, 8)
-        val index = visitExpr(args.head)
+        val index = visitExprOnly(args.head) // can't have load inside load
         val size = parseInt(typeArgs.head) * 8
 
         val otherSize = parseInt(args(1)) * 8
@@ -250,112 +287,112 @@ class SemanticsLoader(parserMap: immutable.Map[String, Array[Array[StmtContext]]
           throw Exception(s"inconsistent size parameters in Mem.read.0: ${ctx.getText}")
         }
 
+        val temp = LocalVar("$load" + loadCounter, BitVecType(size.toInt))
+        loadCounter += 1
+
         if (index.isDefined) {
           // LittleEndian is assumed
-          Some(MemoryLoad(mem, index.get, Endian.LittleEndian, size.toInt))
+          (Some(temp), Some(MemoryLoad(temp, mem, index.get, Endian.LittleEndian, size.toInt, None)))
         } else {
-          None
+          (None, None)
         }
 
       case "cvt_bool_bv.0" =>
         checkArgs(function, 0, 1, typeArgs.size, args.size, ctx.getText)
-        val expr = visitExpr(args.head)
-        if (expr.isDefined) {
-          val e = expr.get
-          e match {
-            case b: BinaryExpr if b.op == BVEQ => Some(BinaryExpr(BVCOMP, b.arg1, b.arg2))
-            case FalseLiteral   => Some(BitVecLiteral(0, 1))
-            case TrueLiteral => Some(BitVecLiteral(1, 1))
-            case _ => throw Exception(s"unhandled conversion from bool to bitvector: ${ctx.getText}")
-          }
-        } else {
-          None
+        val expr = visitExprOnly(args.head)
+        val result = expr.map {
+          case b: BinaryExpr if b.op == BVEQ => BinaryExpr(BVCOMP, b.arg1, b.arg2)
+          case FalseLiteral => BitVecLiteral(0, 1)
+          case TrueLiteral => BitVecLiteral(1, 1)
+          case _ => throw Exception(s"unhandled conversion from bool to bitvector: ${ctx.getText}")
         }
-
-      case "not_bool.0" => resolveUnaryOp(BoolNOT, function, 0, typeArgs, args, ctx.getText)
-      case "eq_enum.0" => resolveBinaryOp(BoolEQ, function, 0, typeArgs, args, ctx.getText)
-      case "or_bool.0" => resolveBinaryOp(BoolOR, function, 0, typeArgs, args, ctx.getText)
-      case "and_bool.0" => resolveBinaryOp(BoolAND, function, 0, typeArgs, args, ctx.getText)
-
-      case "not_bits.0" => resolveUnaryOp(BVNOT, function, 1, typeArgs, args, ctx.getText)
-      case "or_bits.0" => resolveBinaryOp(BVOR, function, 1, typeArgs, args, ctx.getText)
-      case "and_bits.0" => resolveBinaryOp(BVAND, function, 1, typeArgs, args, ctx.getText)
-      case "eor_bits.0" => resolveBinaryOp(BVXOR, function, 1, typeArgs, args, ctx.getText)
-      case "eq_bits.0" => resolveBinaryOp(BVEQ, function, 1, typeArgs, args, ctx.getText)
-      case "add_bits.0" => resolveBinaryOp(BVADD, function, 1, typeArgs, args, ctx.getText)
-      case "sub_bits.0" => resolveBinaryOp(BVSUB, function, 1, typeArgs, args, ctx.getText)
-      case "mul_bits.0" => resolveBinaryOp(BVMUL, function, 1, typeArgs, args, ctx.getText)
-      case "sdiv_bits.0" => resolveBinaryOp(BVSDIV, function, 1, typeArgs, args, ctx.getText)
-
-      case "slt_bits.0" => resolveBinaryOp(BVSLT, function, 1, typeArgs, args, ctx.getText)
-      case "sle_bits.0" => resolveBinaryOp(BVSLE, function, 1, typeArgs, args, ctx.getText)
-
-      case "lsl_bits.0" => resolveBitShiftOp(BVSHL, function, typeArgs, args, ctx.getText)
-      case "lsr_bits.0" => resolveBitShiftOp(BVLSHR, function, typeArgs, args, ctx.getText)
-      case "asr_bits.0" => resolveBitShiftOp(BVASHR, function, typeArgs, args, ctx.getText)
+        (result, None)
+
+      case "not_bool.0" => (resolveUnaryOp(BoolNOT, function, 0, typeArgs, args, ctx.getText), None)
+      case "eq_enum.0" => (resolveBinaryOp(BoolEQ, function, 0, typeArgs, args, ctx.getText), None)
+      case "or_bool.0" => (resolveBinaryOp(BoolOR, function, 0, typeArgs, args, ctx.getText), None)
+      case "and_bool.0" => (resolveBinaryOp(BoolAND, function, 0, typeArgs, args, ctx.getText), None)
+
+      case "not_bits.0" => (resolveUnaryOp(BVNOT, function, 1, typeArgs, args, ctx.getText), None)
+      case "or_bits.0" => (resolveBinaryOp(BVOR, function, 1, typeArgs, args, ctx.getText), None)
+      case "and_bits.0" => (resolveBinaryOp(BVAND, function, 1, typeArgs, args, ctx.getText), None)
+      case "eor_bits.0" => (resolveBinaryOp(BVXOR, function, 1, typeArgs, args, ctx.getText), None)
+      case "eq_bits.0" => (resolveBinaryOp(BVEQ, function, 1, typeArgs, args, ctx.getText), None)
+      case "add_bits.0" => (resolveBinaryOp(BVADD, function, 1, typeArgs, args, ctx.getText), None)
+      case "sub_bits.0" => (resolveBinaryOp(BVSUB, function, 1, typeArgs, args, ctx.getText), None)
+      case "mul_bits.0" => (resolveBinaryOp(BVMUL, function, 1, typeArgs, args, ctx.getText), None)
+      case "sdiv_bits.0" => (resolveBinaryOp(BVSDIV, function, 1, typeArgs, args, ctx.getText), None)
+
+      case "slt_bits.0" => (resolveBinaryOp(BVSLT, function, 1, typeArgs, args, ctx.getText), None)
+      case "sle_bits.0" => (resolveBinaryOp(BVSLE, function, 1, typeArgs, args, ctx.getText), None)
+
+      case "lsl_bits.0" => (resolveBitShiftOp(BVSHL, function, typeArgs, args, ctx.getText), None)
+      case "lsr_bits.0" => (resolveBitShiftOp(BVLSHR, function, typeArgs, args, ctx.getText), None)
+      case "asr_bits.0" => (resolveBitShiftOp(BVASHR, function, typeArgs, args, ctx.getText), None)
 
       case "append_bits.0" =>
-        resolveBinaryOp(BVCONCAT, function, 2, typeArgs, args, ctx.getText)
+        (resolveBinaryOp(BVCONCAT, function, 2, typeArgs, args, ctx.getText), None)
 
       case "replicate_bits.0" =>
         checkArgs(function, 2, 2, typeArgs.size, args.size, ctx.getText)
         val oldSize = parseInt(typeArgs(0))
         val replications = parseInt(typeArgs(1)).toInt
-        val arg0 = visitExpr(args(0))
+        // memory loads shouldn't appear here?
+        val arg0 = visitExprOnly(args(0))
         val arg1 = parseInt(args(1))
         val newSize = oldSize * replications
         if (arg1 != replications) {
           Exception(s"inconsistent size parameters in replicate_bits.0: ${ctx.getText}")
         }
         if (arg0.isDefined) {
-          Some(Repeat(replications, arg0.get))
+          (Some(Repeat(replications, arg0.get)), None)
         } else {
-          None
+          (None, None)
         }
 
       case "ZeroExtend.0" =>
         checkArgs(function, 2, 2, typeArgs.size, args.size, ctx.getText)
         val oldSize = parseInt(typeArgs(0))
         val newSize = parseInt(typeArgs(1))
-        val arg0 = visitExpr(args(0))
+        val (arg0, load) = visitExpr(args(0))
         val arg1 = parseInt(args(1))
         if (arg1 != newSize) {
           Exception(s"inconsistent size parameters in ZeroExtend.0: ${ctx.getText}")
         }
         if (arg0.isDefined) {
-          Some(ZeroExtend((newSize - oldSize).toInt, arg0.get))
+          (Some(ZeroExtend((newSize - oldSize).toInt, arg0.get)), load)
         } else {
-          None
+          (None, None)
         }
 
       case "SignExtend.0" =>
         checkArgs(function, 2, 2, typeArgs.size, args.size, ctx.getText)
         val oldSize = parseInt(typeArgs(0))
         val newSize = parseInt(typeArgs(1))
-        val arg0 = visitExpr(args(0))
+        val (arg0, load) = visitExpr(args(0))
         val arg1 = parseInt(args(1))
         if (arg1 != newSize) {
           Exception(s"inconsistent size parameters in SignExtend.0: ${ctx.getText}")
         }
         if (arg0.isDefined) {
-          Some(SignExtend((newSize - oldSize).toInt, arg0.get))
+          (Some(SignExtend((newSize - oldSize).toInt, arg0.get)), load)
         } else {
-          None
+          (None, None)
         }
 
       case "FPCompareGT.0" | "FPCompareGE.0" | "FPCompareEQ.0" =>
         checkArgs(function, 1, 3, typeArgs.size, args.size, ctx.getText)
         val name = function.stripSuffix(".0")
         val size = parseInt(typeArgs(0))
-        val argsIR = args.flatMap(visitExpr).toSeq
-        Some(UninterpretedFunction(name + "$" + size, argsIR, BoolType))
+        val argsIR = args.flatMap(visitExprOnly).toSeq
+        (Some(UninterpretedFunction(name + "$" + size, argsIR, BoolType)), None)
 
       case "FPAdd.0" | "FPMul.0" | "FPDiv.0" | "FPMulX.0" | "FPMax.0" | "FPMin.0" | "FPMaxNum.0" | "FPMinNum.0" | "FPSub.0" =>
         checkArgs(function, 1, 3, typeArgs.size, args.size, ctx.getText)
         val name = function.stripSuffix(".0")
         val size = parseInt(typeArgs(0)).toInt
-        val argsIR = args.flatMap(visitExpr).toSeq
-        Some(UninterpretedFunction(name + "$" + size, argsIR, BitVecType(size)))
+        val argsIR = args.flatMap(visitExprOnly).toSeq
+        (Some(UninterpretedFunction(name + "$" + size, argsIR, BitVecType(size))), None)
 
       case "FPMulAddH.0" | "FPMulAdd.0" |
            "FPRoundInt.0" |
@@ -363,31 +400,31 @@ class SemanticsLoader(parserMap: immutable.Map[String, Array[Array[StmtContext]]
         checkArgs(function, 1, 4, typeArgs.size, args.size, ctx.getText)
         val name = function.stripSuffix(".0")
         val size = parseInt(typeArgs(0)).toInt
-        val argsIR = args.flatMap(visitExpr).toSeq
-        Some(UninterpretedFunction(name + "$" + size, argsIR, BitVecType(size)))
+        val argsIR = args.flatMap(visitExprOnly).toSeq
+        (Some(UninterpretedFunction(name + "$" + size, argsIR, BitVecType(size))), None)
 
       case "FPRecpX.0" | "FPSqrt.0" | "FPRecipEstimate.0" |
            "FPRSqrtStepFused.0" | "FPRecipStepFused.0" =>
         checkArgs(function, 1, 2, typeArgs.size, args.size, ctx.getText)
         val name = function.stripSuffix(".0")
         val size = parseInt(typeArgs(0)).toInt
-        val argsIR = args.flatMap(visitExpr).toSeq
-        Some(UninterpretedFunction(name + "$" + size, argsIR, BitVecType(size)))
+        val argsIR = args.flatMap(visitExprOnly).toSeq
+        (Some(UninterpretedFunction(name + "$" + size, argsIR, BitVecType(size))), None)
 
       case "FPCompare.0" =>
         checkArgs(function, 1, 4, typeArgs.size, args.size, ctx.getText)
         val name = function.stripSuffix(".0")
         val size = parseInt(typeArgs(0))
-        val argsIR = args.flatMap(visitExpr).toSeq
-        Some(UninterpretedFunction(name + "$" + size, argsIR, BitVecType(4)))
+        val argsIR = args.flatMap(visitExprOnly).toSeq
+        (Some(UninterpretedFunction(name + "$" + size, argsIR, BitVecType(4))), None)
 
       case "FPConvert.0" =>
         checkArgs(function, 2, 3, typeArgs.size, args.size, ctx.getText)
         val name = function.stripSuffix(".0")
         val outSize = parseInt(typeArgs(0)).toInt
         val inSize = parseInt(typeArgs(1))
-        val argsIR = args.flatMap(visitExpr).toSeq
-        Some(UninterpretedFunction(name + "$" + outSize + "$" + inSize, argsIR, BitVecType(outSize)))
+        val argsIR = args.flatMap(visitExprOnly).toSeq
+        (Some(UninterpretedFunction(name + "$" + outSize + "$" + inSize, argsIR, BitVecType(outSize))), None)
 
       case "FPToFixed.0" =>
         checkArgs(function, 2, 5, typeArgs.size, args.size, ctx.getText)
@@ -395,8 +432,8 @@ class SemanticsLoader(parserMap: immutable.Map[String, Array[Array[StmtContext]]
         val outSize = parseInt(typeArgs(0)).toInt
         val inSize = parseInt(typeArgs(1))
         // need to specifically handle the integer parameter
-        val argsIR = args.flatMap(visitExpr).toSeq
-        Some(UninterpretedFunction(name + "$" + outSize + "$" + inSize, argsIR, BitVecType(outSize)))
+        val argsIR = args.flatMap(visitExprOnly).toSeq
+        (Some(UninterpretedFunction(name + "$" + outSize + "$" + inSize, argsIR, BitVecType(outSize))), None)
 
       case "FixedToFP.0" =>
         checkArgs(function, 2, 5, typeArgs.size, args.size, ctx.getText)
@@ -404,28 +441,28 @@ class SemanticsLoader(parserMap: immutable.Map[String, Array[Array[StmtContext]]
         val inSize = parseInt(typeArgs(0))
         val outSize = parseInt(typeArgs(1)).toInt
         // need to specifically handle the integer parameter
-        val argsIR = args.flatMap(visitExpr).toSeq
-        Some(UninterpretedFunction(name + "$" + outSize + "$" + inSize, argsIR, BitVecType(outSize)))
+        val argsIR = args.flatMap(visitExprOnly).toSeq
+        (Some(UninterpretedFunction(name + "$" + outSize + "$" + inSize, argsIR, BitVecType(outSize))), None)
 
       case "FPConvertBF.0" =>
         checkArgs(function, 0, 3, typeArgs.size, args.size, ctx.getText)
         val name = function.stripSuffix(".0")
-        val argsIR = args.flatMap(visitExpr).toSeq
-        Some(UninterpretedFunction(name, argsIR, BitVecType(32)))
+        val argsIR = args.flatMap(visitExprOnly).toSeq
+        (Some(UninterpretedFunction(name, argsIR, BitVecType(32))), None)
 
       case "FPToFixedJS_impl.0" =>
         checkArgs(function, 2, 3, typeArgs.size, args.size, ctx.getText)
         val name = function.stripSuffix(".0")
         val inSize = parseInt(typeArgs(0))
         val outSize = parseInt(typeArgs(1)).toInt
-        val argsIR = args.flatMap(visitExpr).toSeq
-        Some(UninterpretedFunction(name + "$" + outSize + "$" + inSize, argsIR, BitVecType(outSize)))
+        val argsIR = args.flatMap(visitExprOnly).toSeq
+        (Some(UninterpretedFunction(name + "$" + outSize + "$" + inSize, argsIR, BitVecType(outSize))), None)
 
       case "BFAdd.0" | "BFMul.0" =>
         checkArgs(function, 0, 2, typeArgs.size, args.size, ctx.getText)
         val name = function.stripSuffix(".0")
-        val argsIR = args.flatMap(visitExpr).toSeq
-        Some(UninterpretedFunction(name, argsIR, BitVecType(32)))
+        val argsIR = args.flatMap(visitExprOnly).toSeq
+        (Some(UninterpretedFunction(name, argsIR, BitVecType(32))), None)
 
       case _ =>
         // known ASLp methods not yet handled:
@@ -434,7 +471,7 @@ class SemanticsLoader(parserMap: immutable.Map[String, Array[Array[StmtContext]]
         // and will require some research into their semantics
         // AtomicStart, AtomicEnd - can't model as uninterpreted functions, requires modelling atomic section
         Logger.debug(s"unidentified call to $function: ${ctx.getText}")
-        None
+        (None, None)
     }
 
   }
@@ -448,8 +485,9 @@ class SemanticsLoader(parserMap: immutable.Map[String, Array[Array[StmtContext]]
                              ): Option[BinaryExpr] = {
     checkArgs(function, typeArgsExpected, 2, typeArgs.size, args.size, token)
     // we don't currently check the size for BV ops which is the type arg
-    val arg0 = visitExpr(args(0))
-    val arg1 = visitExpr(args(1))
+    // memory loads shouldn't appear inside binary operations?
+    val arg0 = visitExprOnly(args(0))
+    val arg1 = visitExprOnly(args(1))
     if (arg0.isDefined && arg1.isDefined) {
       Some(BinaryExpr(operator, arg0.get, arg1.get))
     } else {
@@ -466,7 +504,8 @@ class SemanticsLoader(parserMap: immutable.Map[String, Array[Array[StmtContext]]
                             ): Option[UnaryExpr] = {
     checkArgs(function, typeArgsExpected, 1, typeArgs.size, args.size, token)
     // we don't currently check the size for BV ops which is the type arg
-    val arg = visitExpr(args.head)
+    // memory loads shouldn't appear inside unary operations?
+    val arg = visitExprOnly(args.head)
     if (arg.isDefined) {
       Some(UnaryExpr(operator, arg.get))
     } else {
@@ -483,8 +522,9 @@ class SemanticsLoader(parserMap: immutable.Map[String, Array[Array[StmtContext]]
     checkArgs(function, 2, 2, typeArgs.size, args.size, token)
     val size0 = parseInt(typeArgs(0))
     val size1 = parseInt(typeArgs(1))
-    val arg0 = visitExpr(args(0))
-    val arg1 = visitExpr(args(1))
+    val arg0 = visitExprOnly(args(0))
+    val arg1 = visitExprOnly(args(1))
+    // memory loads shouldn't appear inside bitshifts?
     if (arg0.isDefined && arg1.isDefined) {
       if (size0 == size1) {
         Some(BinaryExpr(operator, arg0.get, arg1.get))
@@ -496,18 +536,18 @@ class SemanticsLoader(parserMap: immutable.Map[String, Array[Array[StmtContext]]
     }
   }
 
-  private def visitExprSlices(ctx: ExprSlicesContext): Option[Extract] = {
+  private def visitExprSlices(ctx: ExprSlicesContext): (Option[Extract], Option[MemoryLoad]) = {
     val slices = ctx.slices.slice().asScala
     if (slices.size != 1) {
       // need to determine the semantics for this case
       throw Exception(s"currently unable to handle Expr_Slices that contains more than one slice: ${ctx.getText}")
     }
     val (hi, lo) = visitSliceContext(slices.head)
-    val expr = visitExpr(ctx.expr)
+    val (expr, load) = visitExpr(ctx.expr)
     if (expr.isDefined) {
-      Some(Extract(hi, lo, expr.get))
+      (Some(Extract(hi, lo, expr.get)), load)
     } else {
-      None
+      (None, None)
     }
   }
 
@@ -524,7 +564,7 @@ class SemanticsLoader(parserMap: immutable.Map[String, Array[Array[StmtContext]]
     }
   }
 
-  private  def visitExprField(ctx: ExprFieldContext): Register = {
+  private def visitExprField(ctx: ExprFieldContext): Register = {
     val name = ctx.expr match {
       case e: ExprVarContext => visitIdent(e.ident)
       case _ => throw Exception(s"expected ${ctx.getText} to have an Expr_Var as first parameter")
@@ -534,7 +574,7 @@ class SemanticsLoader(parserMap: immutable.Map[String, Array[Array[StmtContext]]
     resolveFieldExpr(name, field)
   }
 
-  private  def visitExprArray(ctx: ExprArrayContext): Register = {
+  private def visitExprArray(ctx: ExprArrayContext): Register = {
     val name = ctx.array match {
       case e: ExprVarContext => visitIdent(e.ident)
       case _ => throw Exception(s"expected ${ctx.getText} to have an Expr_Var as first parameter")
diff --git a/src/main/scala/translating/GTIRBToIR.scala b/src/main/scala/translating/GTIRBToIR.scala
index 7bbe493b4..31049706c 100644
--- a/src/main/scala/translating/GTIRBToIR.scala
+++ b/src/main/scala/translating/GTIRBToIR.scala
@@ -7,7 +7,7 @@ import com.grammatech.gtirb.proto.CFG.Edge
 import com.grammatech.gtirb.proto.CFG.EdgeLabel
 import com.grammatech.gtirb.proto.Module.Module
 import com.grammatech.gtirb.proto.Symbol.Symbol
-import Parsers.SemanticsParser.*
+import Parsers.ASLpParser.*
 import gtirb.*
 import ir.*
 
@@ -156,7 +156,7 @@ class GTIRBToIR(mods: Seq[Module], parserMap: immutable.Map[String, Array[Array[
 
     // maybe good to sort blocks by address around here?
 
-    val semanticsLoader = SemanticsLoader(parserMap)
+    val semanticsLoader = GTIRBLoader(parserMap)
 
     for ((functionUUID, blockUUIDs) <- functionBlocks) {
       val procedure = uuidToProcedure(functionUUID)
@@ -200,29 +200,35 @@ class GTIRBToIR(mods: Seq[Module], parserMap: immutable.Map[String, Array[Array[
 
     val sections = mods.flatMap(_.sections)
 
-    val initialMemory: ArrayBuffer[MemorySection] = ArrayBuffer()
-    sections.map {elem =>
-      val bytestoInt = elem.byteIntervals.head.contents.toByteArray.map(byte => BigInt(byte))
-      val bytes = bytestoInt.map {byte =>
-        if (byte < 0) {
-          BitVecLiteral(byte + (BigInt(1) << 8), 8)
-        } else {
-          BitVecLiteral(byte, 8)
-        }
+    val initialMemory: mutable.TreeMap[BigInt, MemorySection] = mutable.TreeMap()
+    sections.map { elem =>
+      val bytesToInt = elem.byteIntervals.head.contents.toByteArray.map(byte => BigInt(byte))
+      val size = elem.byteIntervals.head.size.toInt
+      val bytes = if (elem.name == ".bss" && bytesToInt.isEmpty) {
+        for (_ <- 0 until size) yield BitVecLiteral(0, 8)
+      } else {
+        bytesToInt.map { byte =>
+          if (byte < 0) {
+            BitVecLiteral(byte + (BigInt(1) << 8), 8)
+          } else {
+            BitVecLiteral(byte, 8)
+          }
+        }.toSeq
       }
-      val section = MemorySection(elem.name, elem.byteIntervals.head.address.toInt, elem.byteIntervals.head.size.toInt, bytes.toSeq)
-      initialMemory += section
+      val readOnly = elem.name == ".rodata" || elem.name == ".got" // crude heuristic for now
+      val address = BigInt(elem.byteIntervals.head.address)
+      val section = MemorySection(elem.name, address, size, bytes, readOnly, None)
+      initialMemory += (address -> section)
     }
 
-    val readOnlyMemory: ArrayBuffer[MemorySection] = ArrayBuffer()
     val intialProc: Procedure = procedures.find(_.address.get == mainAddress).get
 
-    Program(procedures, intialProc, initialMemory, readOnlyMemory)
+    Program(procedures, intialProc, initialMemory)
   }
 
   private def removePCAssign(block: Block): Option[String] = {
     block.statements.last match {
-      case last @ Assign(lhs: Register, _, _) if lhs.name == "_PC" =>
+      case last @ LocalAssign(lhs: Register, _, _) if lhs.name == "_PC" =>
         val label = last.label
         block.statements.remove(last)
         label
@@ -232,7 +238,7 @@ class GTIRBToIR(mods: Seq[Module], parserMap: immutable.Map[String, Array[Array[
 
   private def getPCTarget(block: Block): Register = {
     block.statements.last match {
-      case Assign(lhs: Register, rhs: Register, _) if lhs.name == "_PC" => rhs
+      case LocalAssign(lhs: Register, rhs: Register, _) if lhs.name == "_PC" => rhs
       case _ => throw Exception(s"expected block ${block.label} to have a program counter assignment at its end")
     }
   }
@@ -367,8 +373,8 @@ class GTIRBToIR(mods: Seq[Module], parserMap: immutable.Map[String, Array[Array[
       // need to copy jump as it can't have multiple parents
       val jumpCopy = currentBlock.jump match {
         case GoTo(targets, label) => GoTo(targets, label)
-        case h: Unreachable => Unreachable()
-        case r: Return => Return()
+        case Unreachable(label) => Unreachable(label)
+        case Return(label) => Return(label)
         case _ => throw Exception("this shouldn't be reachable")
       }
       trueBlock.replaceJump(currentBlock.jump)
@@ -391,7 +397,7 @@ class GTIRBToIR(mods: Seq[Module], parserMap: immutable.Map[String, Array[Array[
           if (proxySymbols.isEmpty) {
             // indirect call with no further information
             val target = block.statements.last match {
-              case Assign(lhs: Register, rhs: Register, _) if lhs.name == "_PC" => rhs
+              case LocalAssign(lhs: Register, rhs: Register, _) if lhs.name == "_PC" => rhs
               case _ => throw Exception(s"no assignment to program counter found before indirect call in block ${block.label}")
             }
             val label = block.statements.last.label
diff --git a/src/main/scala/translating/ILtoIL.scala b/src/main/scala/translating/ILtoIL.scala
index 856b18934..9e17aee9e 100644
--- a/src/main/scala/translating/ILtoIL.scala
+++ b/src/main/scala/translating/ILtoIL.scala
@@ -1,5 +1,5 @@
 package translating
-import ir._
+import ir.*
 
 private class ILSerialiser extends ReadOnlyVisitor {
   var program: StringBuilder = StringBuilder()
@@ -32,7 +32,7 @@ private class ILSerialiser extends ReadOnlyVisitor {
 
   override def visitStatement(node: Statement): Statement = node.acceptVisit(this)
 
-  override def visitAssign(node: Assign): Statement = {
+  override def visitLocalAssign(node: LocalAssign): Statement = {
     program ++= "LocalAssign("
     visitVariable(node.lhs)
     program ++= " := "
@@ -41,8 +41,8 @@ private class ILSerialiser extends ReadOnlyVisitor {
     node
   }
 
-  override def visitMemoryAssign(node: MemoryAssign): Statement = {
-    program ++= "MemoryAssign("
+  override def visitMemoryStore(node: MemoryStore): Statement = {
+    program ++= "MemoryStore("
     visitMemory(node.mem)
     program ++= "["
     visitExpr(node.index)
@@ -53,6 +53,17 @@ private class ILSerialiser extends ReadOnlyVisitor {
     node
   }
 
+  override def visitMemoryLoad(node: MemoryLoad): Statement = {
+    program ++= "MemoryLoad("
+    visitVariable(node.lhs)
+    program ++= " := "
+    visitMemory(node.mem)
+    program ++= ", ["
+    visitExpr(node.index)
+    program ++= "])"
+    node
+  }
+
   override def visitAssert(node: Assert): Statement = {
     program ++= "Assert("
     visitExpr(node.body)
@@ -63,14 +74,13 @@ private class ILSerialiser extends ReadOnlyVisitor {
   override def visitJump(node: Jump): Jump = {
     node match {
       case j: GoTo => program ++= s"goTo(${j.targets.map(_.label).mkString(", ")})" 
-      case h: Unreachable => program ++= "halt"
-      case h: Return => program ++= "return"
+      case _: Unreachable => program ++= "halt"
+      case _: Return => program ++= "return"
     }
 
     node
   }
 
-
   override def visitGoTo(node: GoTo): GoTo = {
     program ++= "GoTo("
     program ++= node.targets.map(blockIdentifier).mkString(", ")
@@ -78,7 +88,6 @@ private class ILSerialiser extends ReadOnlyVisitor {
     node
   }
 
-
   override def visitDirectCall(node: DirectCall): Statement = {
     program ++= "DirectCall("
     program ++= procedureIdentifier(node.target)
@@ -213,15 +222,6 @@ private class ILSerialiser extends ReadOnlyVisitor {
     node
   }
 
-  override def visitMemoryLoad(node: MemoryLoad): Expr = {
-    program ++= "MemoryLoad("
-    visitMemory(node.mem)
-    program ++= ", ["
-    visitExpr(node.index)
-    program ++= "])"
-    node
-  }
-
   override def visitMemory(node: Memory): Memory = {
     program ++= "Memory("
     program ++= s"\"${node.name}\", ${node.addressSize}, ${node.valueSize})"
diff --git a/src/main/scala/translating/IRToBoogie.scala b/src/main/scala/translating/IRToBoogie.scala
index 48c4eb9d2..ec9049334 100644
--- a/src/main/scala/translating/IRToBoogie.scala
+++ b/src/main/scala/translating/IRToBoogie.scala
@@ -1,28 +1,33 @@
 package translating
+import analysis.{RegionInjector, DataRegion, HeapRegion, MergedRegion}
 import ir.{BoolOR, *}
 import boogie.*
 import specification.*
 import util.{BoogieGeneratorConfig, BoogieMemoryAccessMode, ProcRelyVersion}
 
+import scala.collection.mutable
 import scala.collection.mutable.ArrayBuffer
 
-class IRToBoogie(var program: Program, var spec: Specification, var thread: Option[ProgramThread], val filename: String) {
+class IRToBoogie(var program: Program, var spec: Specification, var thread: Option[ProgramThread], val filename: String, val regionInjector: Option[RegionInjector], val config: BoogieGeneratorConfig) {
   private val externAttr = BAttribute("extern")
   private val inlineAttr = BAttribute("inline")
   private val globals = spec.globals
   private val controls = spec.controls
   private val controlled = spec.controlled
-  private val relies = spec.relies.map(r => r.resolveSpec)
-  private val reliesParam = spec.relies.map(r => r.resolveSpecParam)
-  private val reliesReflexive = spec.relies.map(r => r.removeOld)
-  private val guarantees = spec.guarantees.map(g => g.resolveOld)
-  private val guaranteesParam = spec.guarantees.map(g => g.resolveSpecParam)
-  private val guaranteesReflexive = spec.guarantees.map(g => g.removeOld)
-  private val guaranteeOldVars = spec.guaranteeOldVars
-  private val LPreds = spec.LPreds.map((k, v) => k -> v.resolveSpecL)
-  private val requires = spec.subroutines.map(s => s.name -> s.requires.map(e => e.resolveSpec)).toMap
+  private val resolveSpec = ResolveSpec(regionInjector)
+  private val resolveSpecL = ResolveSpecL(regionInjector)
+  private val resolveOld = ResolveOld(resolveSpec)
+  private val removeOld = RemoveOld(resolveSpec)
+  private val relies = spec.relies.map(resolveSpec.visitBExpr)
+  private val reliesParam = spec.relies.map(ResolveSpecParam.visitBExpr)
+  private val reliesReflexive = spec.relies.map(removeOld.visitBExpr)
+  private val guarantees = spec.guarantees.map(g => resolveOld.visitBExpr(g) -> g.oldSpecGlobals).toMap
+  private val guaranteeRegions = guarantees.keys.map(g => g -> g.globals).toMap
+  private val guaranteesParam = spec.guarantees.map(ResolveSpecParam.visitBExpr)
+  private val guaranteesReflexive = spec.guarantees.map(removeOld.visitBExpr)
+  private val requires = spec.subroutines.map(s => s.name -> s.requires.map(resolveSpec.visitBExpr)).toMap
   private val requiresDirect = spec.subroutines.map(s => s.name -> s.requiresDirect).toMap
-  private val ensures = spec.subroutines.map(s => s.name -> s.ensures.map(e => e.resolveSpec)).toMap
+  private val ensures = spec.subroutines.map(s => s.name -> s.ensures.map(resolveSpec.visitBExpr)).toMap
   private val ensuresDirect = spec.subroutines.map(s => s.name -> s.ensuresDirect).toMap
   private val libRelies = spec.subroutines.map(s => s.name -> s.rely).toMap
   private val libGuarantees = spec.subroutines.map(s => s.name -> s.guarantee).toMap
@@ -31,6 +36,22 @@ class IRToBoogie(var program: Program, var spec: Specification, var thread: Opti
   private val mem = BMapVar("mem", MapBType(BitVecBType(64), BitVecBType(8)), Scope.Global)
   private val Gamma_mem = BMapVar("Gamma_mem", MapBType(BitVecBType(64), BoolBType), Scope.Global)
 
+  private val LPreds = spec.LPreds.map((k, v) => k -> resolveSpecL.visitBExpr(v))
+  private val LArgs = lArgs
+
+  private val memoriesToGamma = if (regionInjector.isDefined) {
+    regionInjector.get.mergedRegions.collect {
+      case (_: DataRegion | _: HeapRegion, region: MergedRegion) =>
+        val memory = BMapVar(region.name, MapBType(BitVecBType(64), BitVecBType(8)), Scope.Global)
+        val gamma = BMapVar(s"Gamma_${region.name}", MapBType(BitVecBType(64), BoolBType), Scope.Global)
+        memory -> gamma
+    }.toMap
+  } else {
+    Map(mem -> Gamma_mem)
+  }
+
+  private val memoriesAndGammas: Set[BVar] = memoriesToGamma.flatMap((k, v) => Set(k, v)).toSet
+
   private val mem_in = BMapVar("mem$in", MapBType(BitVecBType(64), BitVecBType(8)), Scope.Parameter)
   private val Gamma_mem_in = BMapVar("Gamma_mem$in", MapBType(BitVecBType(64), BoolBType), Scope.Parameter)
   private val mem_out = BMapVar("mem$out", MapBType(BitVecBType(64), BitVecBType(8)), Scope.Parameter)
@@ -41,8 +62,6 @@ class IRToBoogie(var program: Program, var spec: Specification, var thread: Opti
   private val mem_inv2 = BMapVar("mem$inv2", MapBType(BitVecBType(64), BitVecBType(8)), Scope.Local)
   private val Gamma_mem_inv2 = BMapVar("Gamma_mem$inv2", MapBType(BitVecBType(64), BoolBType), Scope.Local)
 
-
-  private var config: BoogieGeneratorConfig = BoogieGeneratorConfig()
   private val modifiedCheck: Set[BVar] = (for (i <- 19 to 29) yield {
     Set(BVariable("R" + i, BitVecBType(64), Scope.Global), BVariable("Gamma_R" + i, BoolBType, Scope.Global))
   }).flatten.toSet ++ Set(
@@ -50,35 +69,43 @@ class IRToBoogie(var program: Program, var spec: Specification, var thread: Opti
     BVariable("Gamma_R31", BoolBType, Scope.Global)
   )
 
-  def translate(boogieGeneratorConfig: BoogieGeneratorConfig): BProgram = {
-    config = boogieGeneratorConfig
-    val readOnlyMemory = memoryToCondition(program.readOnlyMemory)
+  def lArgs: List[BMapVar] = {
+    if (regionInjector.isDefined) {
+      spec.LPreds.values.flatMap(_.specGlobals).toSet.map { g =>
+        regionInjector.get.getMergedRegion(g.address) match {
+          case Some(region) => BMapVar(s"${region.name}", MapBType(BitVecBType(64), BitVecBType(8)), Scope.Global)
+          case None => mem
+        }
+      }.toList.sorted
+    } else {
+      List(mem)
+    }
+  }
+
+  def translate: BProgram = {
+    val readOnlySections = program.usedMemory.values.filter(_.readOnly)
+    val readOnlyMemory = memoryToCondition(readOnlySections)
+    val initialSections = program.usedMemory.values.filter(!_.readOnly)
+    val initialMemory = memoryToCondition(initialSections)
 
-    val procedures = thread match {
+    val procedures: ArrayBuffer[BProcedure] = thread match {
       case None =>
-        program.procedures.map(f => translateProcedure(f, readOnlyMemory))
+        program.procedures.map(f => translateProcedure(f, readOnlyMemory, initialMemory))
       case Some(t) =>
-        val translatedProcedures = ArrayBuffer[BProcedure]()
-        t.procedures.foreach(p => translatedProcedures.addOne(translateProcedure(p, readOnlyMemory)))
+        val translatedProcedures: ArrayBuffer[BProcedure] = ArrayBuffer[BProcedure]()
+        t.procedures.foreach(p => translatedProcedures.addOne(translateProcedure(p, readOnlyMemory, initialMemory)))
         translatedProcedures
     }
-    val defaultGlobals = List(BVarDecl(mem, List(externAttr)), BVarDecl(Gamma_mem, List(externAttr)))
-    val globalVars = procedures.flatMap(p => p.globals ++ p.freeRequires.flatMap(_.globals) ++ p.freeEnsures.flatMap(_.globals) ++ p.ensures.flatMap(_.globals) ++ p.requires.flatMap(_.globals))
-    val globalDecls = (globalVars.map(b => BVarDecl(b, List(externAttr))) ++ defaultGlobals).distinct.sorted.toList
-
-    val globalConsts: List[BConstAxiomPair] =
-      globals.map(g => BConstAxiomPair(BVarDecl(g.toAddrVar, List(externAttr)), g.toAxiom)).toList.sorted
 
     val guaranteeReflexive = BProcedure(
       name = "guarantee_reflexive",
-      modifies = Set(mem, Gamma_mem),
+      modifies = memoriesAndGammas,
       body = guaranteesReflexive.map(g => BAssert(g)),
       attributes = List(externAttr)
     )
 
     val rgProcs = genRely(relies, readOnlyMemory) :+ guaranteeReflexive
 
-
     val rgLib = config.procedureRely match {
       case Some(ProcRelyVersion.Function) =>
         // if rely/guarantee lib exist, create genRelyInv, and genInv for every procedure where rely/guarantee lib exist
@@ -91,7 +118,6 @@ class IRToBoogie(var program: Program, var spec: Specification, var thread: Opti
       case None => Nil
     }
 
-
     val functionsUsed1 = procedures.flatMap(p => p.functionOps).toSet ++
       rgProcs.flatMap(p => p.functionOps).toSet ++
       rgLib.flatMap(p => p.functionOps).toSet ++
@@ -102,6 +128,12 @@ class IRToBoogie(var program: Program, var spec: Specification, var thread: Opti
     val functionsUsed4 = functionsUsed3.flatMap(p => p.functionOps).map(p => functionOpToDefinition(p))
     val functionsUsed = (functionsUsed2 ++ functionsUsed3 ++ functionsUsed4).toList.sorted
 
+    val globalVars = procedures.flatMap(_.globals) ++ rgProcs.flatMap(_.globals)
+    val globalDecls = globalVars.map(b => BVarDecl(b, List(externAttr))).distinct.sorted.toList
+
+    val globalConsts: List[BConstAxiomPair] = globals.map { g =>
+      BConstAxiomPair(BVarDecl(g.toAddrVar, List(externAttr)), g.toAxiom)
+    }.toList.sorted
 
     val declarations = globalDecls ++ globalConsts ++ functionsUsed ++ rgLib ++ pushUpModifiesFixedPoint(rgProcs ++ procedures)
     BProgram(declarations, filename)
@@ -112,23 +144,32 @@ class IRToBoogie(var program: Program, var spec: Specification, var thread: Opti
       relies
     } else {
       // default case where no rely is given - rely on no external changes
-      List(BinaryBExpr(BVEQ, mem, Old(mem)), BinaryBExpr(BVEQ, Gamma_mem, Old(Gamma_mem)))
+      memoriesAndGammas.toList.sorted.map(m => BinaryBExpr(BVEQ, m, Old(m)))
     }
     val relyEnsures = if (relies.nonEmpty) {
       val i = BVariable("i", BitVecBType(64), Scope.Local)
-      val rely2 = ForAll(List(i), BinaryBExpr(BoolIMPLIES, BinaryBExpr(BVEQ, MapAccess(mem, i), Old(MapAccess(mem, i))), BinaryBExpr(BVEQ, MapAccess(Gamma_mem, i), Old(MapAccess(Gamma_mem, i)))))
-      List(rely2) ++ reliesUsed
+
+      val memImpliesGamma = memoriesToGamma.keys.toList.sorted.map { memory =>
+        val gamma = memoriesToGamma(memory)
+        ForAll(
+          List(i),
+          BinaryBExpr(BoolIMPLIES,
+            BinaryBExpr(BVEQ, MapAccess(memory, i), Old(MapAccess(memory, i))),
+            BinaryBExpr(BVEQ, MapAccess(gamma, i), Old(MapAccess(gamma, i)))
+          )
+        )
+      }
+      memImpliesGamma ++ reliesUsed
     } else {
       reliesUsed
     }
-    val relyProc = BProcedure("rely", ensures = relyEnsures, freeEnsures = readOnlyMemory, modifies = Set(mem, Gamma_mem), attributes = List(externAttr))
-    val relyTransitive = BProcedure("rely_transitive", ensures = reliesUsed, modifies = Set(mem, Gamma_mem), body = List(BProcedureCall("rely"), BProcedureCall("rely")),
+    val relyProc = BProcedure("rely", ensures = relyEnsures, freeEnsures = readOnlyMemory, modifies = memoriesAndGammas, attributes = List(externAttr))
+    val relyTransitive = BProcedure("rely_transitive", ensures = reliesUsed, modifies = memoriesAndGammas, body = List(BProcedureCall("rely"), BProcedureCall("rely")),
       attributes = List(externAttr))
     val relyReflexive = BProcedure("rely_reflexive", body = reliesReflexive.map(r => BAssert(r)), attributes = List(externAttr))
     List(relyProc, relyTransitive, relyReflexive)
   }
 
-
   def genRelyInv: BProcedure = {
     val reliesUsed = if (reliesParam.nonEmpty) {
       reliesParam
@@ -168,7 +209,7 @@ class IRToBoogie(var program: Program, var spec: Specification, var thread: Opti
       relyEnsures.head
     }
 
-    val guaranteeEnsures = libGuarantees(name).map(g => g.resolveSpecParam)
+    val guaranteeEnsures = libGuarantees(name).map(ResolveSpecParam.visitBExpr)
     val guaranteeOneLine = if (guaranteeEnsures.size > 1) {
       guaranteeEnsures.tail.foldLeft(guaranteeEnsures.head)((ands: BExpr, next: BExpr) => BinaryBExpr(BoolAND, ands, next))
     } else {
@@ -190,7 +231,7 @@ class IRToBoogie(var program: Program, var spec: Specification, var thread: Opti
 
   def genLibGuarantee(name: String): BProcedure = {
     // G_f
-    val guaranteeLib = libGuarantees(name).map(g => g.resolveSpecParam)
+    val guaranteeLib = libGuarantees(name).map(ResolveSpecParam.visitBExpr)
     val guaranteeOneLine = if (guaranteeLib.size > 1) {
       guaranteeLib.tail.foldLeft(guaranteeLib.head)((ands: BExpr, next: BExpr) => BinaryBExpr(BoolAND, ands, next))
     } else {
@@ -266,7 +307,7 @@ class IRToBoogie(var program: Program, var spec: Specification, var thread: Opti
         val in = List(memVar, indexVar, valueVar)
         val out = BParam(memType)
         val body: BExpr = config.memoryFunctionType match {
-          case BoogieMemoryAccessMode.SuccessiveStoreSelect => {
+          case BoogieMemoryAccessMode.SuccessiveStoreSelect =>
             val indices: Seq[BExpr] = for (i <- 0 until m.accesses) yield {
               if (i == 0) {
                 indexVar
@@ -286,18 +327,19 @@ class IRToBoogie(var program: Program, var spec: Specification, var thread: Opti
             }
 
             indiceValues.tail.foldLeft(MapUpdate(memVar, indices.head, valuesEndian.head)) {
-              (update: MapUpdate, next: (BExpr, BExpr)) => MapUpdate(update, next._1, next._2)
+              (update: MapUpdate, next: (BExpr, BExpr)) => MapUpdate(update, next(0), next(1))
             }
-          }
+
           case BoogieMemoryAccessMode.LambdaStoreSelect =>
-            if m.accesses == 1 then
+            if (m.accesses == 1) {
               MapUpdate(memVar, indexVar, valueVar)
-            else {
+            } else {
               val i = BVariable("i", BitVecBType(m.addressSize), Scope.Local)
               Lambda(List(i), IfThenElse(
                 BInBounds(indexVar, BitVecBLiteral(m.accesses, m.addressSize), m.endian, i),
                 BByteExtract(valueVar, BinaryBExpr(BVSUB, i, indexVar)),
-                MapAccess(memVar, i)))
+                MapAccess(memVar, i))
+              )
             }
         }
 
@@ -319,7 +361,8 @@ class IRToBoogie(var program: Program, var spec: Specification, var thread: Opti
               Lambda(List(i), IfThenElse(
                 BInBounds(indexVar, BitVecBLiteral(g.accesses, g.addressSize), Endian.LittleEndian, i),
                 valueVar,
-                MapAccess(gammaMapVar, i)))
+                MapAccess(gammaMapVar, i))
+              )
             }
           case BoogieMemoryAccessMode.SuccessiveStoreSelect =>
             val indices: Seq[BExpr] = for (i <- 0 until g.accesses) yield {
@@ -336,47 +379,51 @@ class IRToBoogie(var program: Program, var spec: Specification, var thread: Opti
               (indices(i), values(i))
             }
             indiceValues.tail.foldLeft(MapUpdate(gammaMapVar, indices.head, values.head)) {
-              (update: MapUpdate, next: (BExpr, BExpr)) => MapUpdate(update, next._1, next._2)
+              (update: MapUpdate, next: (BExpr, BExpr)) => MapUpdate(update, next(0), next(1))
             }
         }
 
         BFunction(g.fnName, in, out, Some(body), List(externAttr))
       case l: LOp =>
-        val memoryVar = BParam("memory", l.memoryType)
-        val indexVar = BParam("index", l.indexType)
+        val indexVar: BVar = BParam("index", l.indexType)
         val body: BExpr = LPreds.keys.foldLeft(FalseBLiteral) { (ite: BExpr, next: SpecGlobal) =>
-          {
-            val guard = next.arraySize match {
-              case Some(size: Int) =>
-                val initial: BExpr = BinaryBExpr(BoolEQ, indexVar, ArrayAccess(next, 0).toAddrVar)
-                val indices = 1 until size
-                indices.foldLeft(initial) { (or: BExpr, i: Int) =>
-                  {
-                    BinaryBExpr(BoolOR, BinaryBExpr(BoolEQ, indexVar, ArrayAccess(next, i).toAddrVar), or)
-                  }
-                }
-              case None => BinaryBExpr(BoolEQ, indexVar, next.toAddrVar)
-            }
-            val LPred = LPreds(next)
-            /*if (controlled.contains(next)) {
-            FunctionCall(s"L_${next.name}", List(l.memory), BoolType)
-          } else {
-            LPreds(next)
-          } */
-            IfThenElse(guard, LPred, ite)
+          val guard = next.arraySize match {
+            case Some(size: Int) =>
+              val initial: BExpr = BinaryBExpr(BoolEQ, indexVar, ArrayAccess(next, 0).toAddrVar)
+              val indices = 1 until size
+              indices.foldLeft(initial) { (or: BExpr, i: Int) =>
+                BinaryBExpr(BoolOR, BinaryBExpr(BoolEQ, indexVar, ArrayAccess(next, i).toAddrVar), or)
+              }
+            case None =>
+              BinaryBExpr(BoolEQ, indexVar, next.toAddrVar)
           }
+          val LPred = LPreds(next)
+          /*if (controlled.contains(next)) {
+          FunctionCall(s"L_${next.name}", List(l.memory), BoolType)
+        } else {
+          LPreds(next)
+        } */
+          IfThenElse(guard, LPred, ite)
+        }
+        val params = if (regionInjector.isDefined) {
+          (body.params - indexVar).toList.sorted
+        } else {
+          List(BParam("mem$in", mem.bType))
         }
-        BFunction("L", List(memoryVar, indexVar), BParam(BoolBType), Some(body), List(externAttr))
+        BFunction("L", params :+ indexVar, BParam(BoolBType), Some(body), List(externAttr))
       case b: ByteExtract =>
         val valueVar = BParam("value", BitVecBType(b.valueSize))
         val offsetVar = BParam("offset", BitVecBType(b.offsetSize))
         val in = List(valueVar, offsetVar)
         val out = BParam(BitVecBType(8))
         val shift = BinaryBExpr(BVMUL, offsetVar, BitVecBLiteral(8, b.offsetSize))
-        val eshift =
-          if (b.valueSize < b.offsetSize) BVExtract(b.valueSize, 0, shift)
-          else if (b.valueSize == b.offsetSize) shift
-          else BVZeroExtend(b.valueSize - b.offsetSize, shift)
+        val eshift = if (b.valueSize < b.offsetSize) {
+          BVExtract(b.valueSize, 0, shift)
+        } else if (b.valueSize == b.offsetSize) {
+          shift
+        } else {
+          BVZeroExtend(b.valueSize - b.offsetSize, shift)
+        }
         val body = BVExtract(8, 0, BinaryBExpr(BVLSHR, valueVar, eshift))
         BFunction(b.fnName, in, out, Some(body), List(inlineAttr))
       case b: InBounds =>
@@ -406,41 +453,33 @@ class IRToBoogie(var program: Program, var spec: Specification, var thread: Opti
   }
 
   def pushUpModifiesFixedPoint(procedures: List[BProcedure]): List[BProcedure] = {
-
     var changed = true
     var proceduresUpdated = procedures
     while (changed) {
       changed = false
       val nameToProcedure = proceduresUpdated.map(p => p.name -> p).toMap
-      proceduresUpdated = proceduresUpdated.map(
-        procedure => {
-          val cmds: List[BCmd] = procedure.body.flatten {
-            case b: BBlock => b.body
-            case c: BCmd => Seq(c)
-          }
-          val callModifies = cmds.collect { case c: BProcedureCall => nameToProcedure(c.name) }.flatMap(_.modifies)
-          val modifiesUpdate = procedure.modifies ++ callModifies
-          if (modifiesUpdate != procedure.modifies) {
-            changed = true
-          }
-
-          procedure.copy(modifies = modifiesUpdate)
+      proceduresUpdated = proceduresUpdated.map { procedure =>
+        val cmds: List[BCmd] = procedure.body.flatten {
+          case b: BBlock => b.body
+          case c: BCmd => Seq(c)
         }
-      )
+        val callModifies = cmds.collect { case c: BProcedureCall => nameToProcedure(c.name) }.flatMap(_.modifies)
+        val modifiesUpdate = procedure.modifies ++ callModifies
+        if (modifiesUpdate != procedure.modifies) {
+          changed = true
+        }
+
+        procedure.copy(modifies = modifiesUpdate)
+      }
     }
     proceduresUpdated
   }
 
 
-  def translateProcedure(p: Procedure, readOnlyMemory: List[BExpr]): BProcedure = {
+  def translateProcedure(p: Procedure, readOnlyMemory: List[BExpr], initialMemory: List[BExpr]): BProcedure = {
     val body = (p.entryBlock.view ++ p.blocks.filterNot(x => p.entryBlock.contains(x))).map(translateBlock).toList
 
-    val callsRely: Boolean = body.flatMap(_.body).exists(_ match
-      case BProcedureCall("rely", lhs, params, comment) => true
-      case _ => false)
-
-    val modifies: Seq[BVar] = p.modifies.toSeq
-      .flatMap {
+    val modifies: Seq[BVar] = p.modifies.toSeq.flatMap {
         case m: Memory   => Seq(m.toBoogie, m.toGamma)
         case r: Register => Seq(r.toBoogie, r.toGamma)
       }.distinct.sorted
@@ -455,7 +494,7 @@ class IRToBoogie(var program: Program, var spec: Specification, var thread: Opti
     val procEnsuresDirect: List[String] = ensuresDirect.getOrElse(p.name, List())
 
     val freeRequires: List[BExpr] = if (p == program.mainProcedure) {
-      memoryToCondition(program.initialMemory) ++ readOnlyMemory
+      initialMemory ++ readOnlyMemory
     } else {
       readOnlyMemory
     }
@@ -477,10 +516,10 @@ class IRToBoogie(var program: Program, var spec: Specification, var thread: Opti
     )
   }
 
-  private def memoryToCondition(memory: ArrayBuffer[MemorySection]): List[BExpr] = {
+  private def memoryToCondition(memorySections: Iterable[MemorySection]): List[BExpr] = {
 
     def coalesced: List[BExpr] = {
-      val sections = memory.flatMap { s =>
+      val sections = memorySections.flatMap { s =>
         // Phrase the memory condition in terms of 64-bit operations, as long as the memory
         // section's size is a multiple of 64-bits and 64-bits (8 bytes) aligned
         // If the memory section is not aligned, the initial unaligned part of it will not be coalesced into a 64-bit
@@ -488,66 +527,86 @@ class IRToBoogie(var program: Program, var spec: Specification, var thread: Opti
         // If the memory section's size is not a multiple of 64-bits, the last part of it that cannot be coalesced into
         // a 64-bit representation will remain as an 8-bit representation
 
-        val aligned: Int = (s.address % 8).toInt
-
-        val alignedSizeMultiple = (s.bytes.size - aligned) % 8
-        // index of the byte that marks the end of the part that is a multiple of 64-bits
-        val alignedEnd = s.bytes.size - alignedSizeMultiple
-
-        // Aligned section that is safe to convert to 64-bit values
-        val alignedSection = for (b <- aligned until alignedEnd by 8) yield {
-          // Combine the byte constants into a 64-bit value
-          val combined: BigInt =
-            (0 until 8).foldLeft(BigInt(0))((x, y) => x + (s.bytes(b + y).value * BigInt(2).pow(y * 8)))
-          BinaryBExpr(
-            BVEQ,
-            BMemoryLoad(mem, BitVecBLiteral(s.address + b, 64), Endian.LittleEndian, 64),
-            BitVecBLiteral(combined, 64)
-          )
+        val memory = s.region match {
+          case Some(region) => BMapVar(region.name, MapBType(BitVecBType(64), BitVecBType(8)), Scope.Global)
+          case None => mem
         }
 
-        // If memory section is somehow not aligned (is this possible?) then don't convert the initial non-aligned
-        // section to 64-bit operations, just the rest
-        val unalignedStartSection = if (aligned == 0) {
-          Seq()
+        if (s.bytes.size <= 8) {
+          // if section is less than 8 bytes, just represent it with one access
+          val combined = s.bytes.indices.foldLeft(BigInt(0))((x, y) => x + (s.bytes(y).value * BigInt(2).pow(y * 8)))
+          val bits = s.bytes.size * 8
+          Seq(BinaryBExpr(
+            BVEQ,
+            BMemoryLoad(memory, BitVecBLiteral(s.address, 64), Endian.LittleEndian, bits),
+            BitVecBLiteral(combined, bits)
+          ))
         } else {
-          for (b <- 0 until aligned) yield {
+          val aligned: Int = (s.address % 8).toInt
+
+          val alignedSizeMultiple = (s.bytes.size - aligned) % 8
+          // index of the byte that marks the end of the part that is a multiple of 64-bits
+          val alignedEnd = s.bytes.size - alignedSizeMultiple
+
+          // Aligned section that is safe to convert to 64-bit values
+          val alignedSection = for (b <- aligned until alignedEnd by 8) yield {
+            // Combine the byte constants into a 64-bit value
+            val combined: BigInt =
+              (0 until 8).foldLeft(BigInt(0))((x, y) => x + (s.bytes(b + y).value * BigInt(2).pow(y * 8)))
             BinaryBExpr(
               BVEQ,
-              BMemoryLoad(mem, BitVecBLiteral(s.address + b, 64), Endian.LittleEndian, 8),
-              s.bytes(b).toBoogie
+              BMemoryLoad(memory, BitVecBLiteral(s.address + b, 64), Endian.LittleEndian, 64),
+              BitVecBLiteral(combined, 64)
             )
           }
-        }
 
-        // If the memory section is not a multiple of 64-bits then don't convert the last section to 64-bits
-        // This is not ideal but will do for now
-        // Ideal solution is to match the sizes based on the sizes listed in the symbol table, dividing further
-        // for values greater than 64-bit as much as possible
-        // But that requires more work
-        // Combine the byte constants into a 64-bit value
-        val unalignedEndSection = if (alignedSizeMultiple == 0) {
-          Seq()
-        } else {
-          for (b <- alignedEnd until s.bytes.size) yield {
-            BinaryBExpr(
-              BVEQ,
-              BMemoryLoad(mem, BitVecBLiteral(s.address + b, 64), Endian.LittleEndian, 8),
-              s.bytes(b).toBoogie
-            )
+          // If memory section is somehow not aligned (is this possible?) then don't convert the initial non-aligned
+          // section to 64-bit operations, just the rest
+          val unalignedStartSection = if (aligned == 0) {
+            Seq()
+          } else {
+            for (b <- 0 until aligned) yield {
+              BinaryBExpr(
+                BVEQ,
+                BMemoryLoad(memory, BitVecBLiteral(s.address + b, 64), Endian.LittleEndian, 8),
+                s.bytes(b).toBoogie
+              )
+            }
           }
+
+          // If the memory section is not a multiple of 64-bits then don't convert the last section to 64-bits
+          // This is not ideal but will do for now
+          // Ideal solution is to match the sizes based on the sizes listed in the symbol table, dividing further
+          // for values greater than 64-bit as much as possible
+          // But that requires more work
+          // Combine the byte constants into a 64-bit value
+          val unalignedEndSection = if (alignedSizeMultiple == 0) {
+            Seq()
+          } else {
+            for (b <- alignedEnd until s.bytes.size) yield {
+              BinaryBExpr(
+                BVEQ,
+                BMemoryLoad(memory, BitVecBLiteral(s.address + b, 64), Endian.LittleEndian, 8),
+                s.bytes(b).toBoogie
+              )
+            }
+          }
+          unalignedStartSection ++ alignedSection ++ unalignedEndSection
         }
-        unalignedStartSection ++ alignedSection ++ unalignedEndSection
       }
       sections.toList
     }
 
     def bytes: List[BExpr] = {
-      val sections = memory.flatMap { s =>
+      val sections = memorySections.flatMap { s =>
+        val memory = s.region match {
+          case Some(region) => BMapVar(region.name, MapBType(BitVecBType(64), BitVecBType(8)), Scope.Global)
+          case None => mem
+        }
         for (b <- s.bytes.indices) yield {
           BinaryBExpr(
             BVEQ,
-            BMemoryLoad(mem, BitVecBLiteral(s.address + b, 64), Endian.LittleEndian, 8),
+            BMemoryLoad(memory, BitVecBLiteral(s.address + b, 64), Endian.LittleEndian, 8),
             s.bytes(b).toBoogie
           )
         }
@@ -588,12 +647,12 @@ class IRToBoogie(var program: Program, var spec: Specification, var thread: Opti
      *   Procedures with no precond and the predicate as their postcond are generated to encode two-state assumptions.
      *
      */
-    (libRelies.keySet ++ libGuarantees.keySet).filter(x => libRelies(x).nonEmpty && libGuarantees(x).nonEmpty).map(targetName => {
-      val Rc: BExpr = spec.relies.reduce((a, b) => BinaryBExpr(BoolAND, a, b)).resolveSpec
-      val Gc: BExpr = spec.guarantees.reduce((a, b) => BinaryBExpr(BoolAND, a, b)).resolveSpec
+    (libRelies.keySet ++ libGuarantees.keySet).filter(x => libRelies(x).nonEmpty && libGuarantees(x).nonEmpty).map { targetName =>
+      val Rc: BExpr = resolveSpec.visitBExpr(spec.relies.reduce((a, b) => BinaryBExpr(BoolAND, a, b)))
+      val Gc: BExpr = resolveSpec.visitBExpr(spec.guarantees.reduce((a, b) => BinaryBExpr(BoolAND, a, b)))
 
-      val Rf: BExpr = libRelies(targetName).reduce((a, b) => BinaryBExpr(BoolAND, a, b)).resolveSpec
-      val Gf: BExpr = libGuarantees(targetName).reduce((a, b) => BinaryBExpr(BoolAND, a, b)).resolveSpec
+      val Rf: BExpr = resolveSpec.visitBExpr(libRelies(targetName).reduce((a, b) => BinaryBExpr(BoolAND, a, b)))
+      val Gf: BExpr = resolveSpec.visitBExpr(libGuarantees(targetName).reduce((a, b) => BinaryBExpr(BoolAND, a, b)))
 
       val inv = BinaryBExpr(BoolOR, Rc, Gf)
       val conseq = BinaryBExpr(BoolIMPLIES, Rc, Rf)
@@ -617,20 +676,19 @@ class IRToBoogie(var program: Program, var spec: Specification, var thread: Opti
         ))
 
       targetName -> Seq(procInv, proc2, procGf, proc4, proc5)
-    }).toMap
+    }.toMap
   }
 
-  def relyfun(targetName: String) : Option[IfCmd] = {
-    libRGFunsContradictionProof.get(targetName).map(proc =>
-      {
-        IfCmd(StarBLiteral, List(
-          BProcedureCall(proc(0).name, Seq(), Seq()),
-          BProcedureCall(proc(1).name, Seq(), Seq()),
-          BAssert(FalseBLiteral)
-        ))
-      }
-    )
+  def relyfun(targetName: String): Option[IfCmd] = {
+    libRGFunsContradictionProof.get(targetName).map { proc =>
+      IfCmd(StarBLiteral, List(
+        BProcedureCall(proc(0).name, Seq(), Seq()),
+        BProcedureCall(proc(1).name, Seq(), Seq()),
+        BAssert(FalseBLiteral)
+      ))
+    }
   }
+
   def translate(j: Jump): List[BCmd] = j match {
     case g: GoTo =>
       // collects all targets of the goto with a branch condition that we need to check the security level for
@@ -648,8 +706,8 @@ class IRToBoogie(var program: Program, var spec: Specification, var thread: Opti
       }
       val jump = GoToCmd(g.targets.map(_.label).toSeq)
       conditionAssert :+ jump
-    case r: Return => List(ReturnCmd)
-    case r: Unreachable => List(BAssume(FalseBLiteral))
+    case _: Return => List(ReturnCmd)
+    case _: Unreachable => List(BAssume(FalseBLiteral))
   }
 
   def translate(j: Call): List[BCmd] = j match {
@@ -661,7 +719,7 @@ class IRToBoogie(var program: Program, var spec: Specification, var thread: Opti
           if (libRelies.contains(d.target.name) && libGuarantees.contains(d.target.name) && libRelies(d.target.name).nonEmpty && libGuarantees(d.target.name).nonEmpty) {
             val invCall1 = BProcedureCall(d.target.name + "$inv", List(mem_inv1, Gamma_mem_inv1), List(mem, Gamma_mem))
             val invCall2 = BProcedureCall("rely$inv", List(mem_inv2, Gamma_mem_inv2), List(mem_inv1, Gamma_mem_inv1))
-            val libRGAssert = libRelies(d.target.name).map(r => BAssert(r.resolveSpecInv))
+            val libRGAssert = libRelies(d.target.name).map(r => BAssert(ResolveSpecInv.visitBExpr(r)))
             List(invCall1, invCall2) ++ libRGAssert
           } else {
             List()
@@ -674,35 +732,63 @@ class IRToBoogie(var program: Program, var spec: Specification, var thread: Opti
 
   def translate(s: Statement): List[BCmd] = s match {
     case d: Call => translate(d)
-    case m: NOP => List.empty
-    case m: MemoryAssign =>
+    case _: NOP => List.empty
+    case m: MemoryStore =>
       val lhs = m.mem.toBoogie
       val rhs = BMemoryStore(m.mem.toBoogie, m.index.toBoogie, m.value.toBoogie, m.endian, m.size)
       val lhsGamma = m.mem.toGamma
-      val rhsGamma = GammaStore(m.mem.toGamma, m.index.toBoogie, m.value.toGamma, m.size, m.size / m.mem.valueSize)
+      val rhsGamma = GammaStore(m.mem.toGamma, m.index.toBoogie, exprToGamma(m.value), m.size, m.size / m.mem.valueSize)
       val store = AssignCmd(List(lhs, lhsGamma), List(rhs, rhsGamma))
       val stateSplit = s match {
-        case MemoryAssign(_, _, _, _, _, Some(label)) => List(captureStateStatement(s"$label"))
-        case Assign(_, _, Some(label)) => List(captureStateStatement(s"$label"))
+        case MemoryStore(_, _, _, _, _, Some(label)) => List(captureStateStatement(s"$label"))
+        case LocalAssign(_, _, Some(label)) => List(captureStateStatement(s"$label"))
         case _ => List.empty
       }
       m.mem match {
-        case s: StackMemory =>
+        case _: StackMemory =>
           List(store) ++ stateSplit
-        case s: SharedMemory =>
+        case _: SharedMemory =>
           val rely = BProcedureCall("rely")
-          val gammaValueCheck = BAssert(BinaryBExpr(BoolIMPLIES, L(lhs, rhs.index), m.value.toGamma))
-          val oldAssigns =
-            guaranteeOldVars.map(g => AssignCmd(g.toOldVar, BMemoryLoad(lhs, g.toAddrVar, Endian.LittleEndian, g.size)))
-          val oldGammaAssigns = controlled.map(g =>
+          val gammaValueCheck = BAssert(BinaryBExpr(BoolIMPLIES, L(LArgs, rhs.index), exprToGamma(m.value)))
+          val oldVars = guarantees.keys.view.toSet.flatMap { g =>
+            if (guaranteeRegions(g).contains(lhs)) {
+              guarantees(g)
+            } else {
+              Set()
+            }
+          }
+          val oldAssigns = oldVars.toList.sorted.map { g =>
+            val memory = if (regionInjector.isDefined) {
+              regionInjector.get.getMergedRegion(g.address) match {
+                case Some(region) => BMapVar(region.name, MapBType(BitVecBType(64), BitVecBType(8)), Scope.Global)
+                case None => mem
+              }
+            } else {
+              mem
+            }
+            AssignCmd(g.toOldVar, BMemoryLoad(memory, g.toAddrVar, Endian.LittleEndian, g.size))
+          }
+          val oldGammaAssigns = controlled.map { g =>
+            val gamma = if (regionInjector.isDefined) {
+              regionInjector.get.getMergedRegion(g.address) match {
+                case Some(region) =>
+                  BMapVar(s"Gamma_${region.name}", MapBType(BitVecBType(64), BoolBType), Scope.Global)
+                case None =>
+                  Gamma_mem
+              }
+            } else {
+              Gamma_mem
+            }
             AssignCmd(
               g.toOldGamma,
-              BinaryBExpr(BoolOR, GammaLoad(lhsGamma, g.toAddrVar, g.size, g.size / m.mem.valueSize), L(lhs, g.toAddrVar))
+              BinaryBExpr(BoolOR, GammaLoad(gamma, g.toAddrVar, g.size, g.size / m.mem.valueSize), L(LArgs, g.toAddrVar))
             )
-          )
-          val secureUpdate = for (c <- controls.keys) yield {
+          }
+          val secureUpdate = for (c <- controls.keys.view.toSeq.sorted) yield {
             val addrCheck = BinaryBExpr(BVEQ, rhs.index, c.toAddrVar)
-            val checks = controls(c).map(v => BinaryBExpr(BoolIMPLIES, L(lhs, v.toAddrVar), v.toOldGamma)).toList
+            val checks = controls(c).toList.sorted.map { v =>
+              BinaryBExpr(BoolIMPLIES, L(LArgs, v.toAddrVar), v.toOldGamma)
+            }
             val checksAnd = if (checks.size > 1) {
               checks.tail.foldLeft(checks.head)((next: BExpr, ands: BExpr) => BinaryBExpr(BoolAND, next, ands))
             } else {
@@ -710,25 +796,34 @@ class IRToBoogie(var program: Program, var spec: Specification, var thread: Opti
             }
             BAssert(BinaryBExpr(BoolIMPLIES, addrCheck, checksAnd))
           }
-          val guaranteeChecks = guarantees.map(v => BAssert(v))
+          val guaranteeChecks = guarantees.keys.collect {
+            case g if guaranteeRegions(g).contains(lhs) => BAssert(g)
+          }
           (List(rely, gammaValueCheck) ++ oldAssigns ++ oldGammaAssigns :+ store) ++ secureUpdate ++ guaranteeChecks ++ stateSplit
       }
-    case l: Assign =>
+    case l: LocalAssign =>
       val lhs = l.lhs.toBoogie
       val rhs = l.rhs.toBoogie
       val lhsGamma = l.lhs.toGamma
-      val rhsGamma = l.rhs.toGamma
-      val assign = AssignCmd(List(lhs, lhsGamma), List(rhs, rhsGamma))
-      val loads = l.rhs.loads
-      if (loads.size > 1) {
-        throw Exception(s"$l contains multiple loads")
+      val rhsGamma = exprToGamma(l.rhs)
+      List(AssignCmd(List(lhs, lhsGamma), List(rhs, rhsGamma)))
+    case m: MemoryLoad =>
+      val lhs = m.lhs.toBoogie
+      val lhsGamma = m.lhs.toGamma
+      val rhs = BMemoryLoad(m.mem.toBoogie, m.index.toBoogie, m.endian, m.size)
+      val rhsGamma = m.mem match {
+        case s: StackMemory =>
+          GammaLoad(s.toGamma, m.index.toBoogie, m.size, m.size / s.valueSize)
+        case s: SharedMemory =>
+          val boogieIndex = m.index.toBoogie
+          BinaryBExpr(BoolOR, GammaLoad(s.toGamma, boogieIndex, m.size, m.size / s.valueSize), L(LArgs, boogieIndex))
       }
-      // add rely call if assignment contains a non-stack load
-      loads.headOption match {
-        case Some(MemoryLoad(SharedMemory(_, _, _), _, _, _)) =>
+      val assign = AssignCmd(List(lhs, lhsGamma), List(rhs, rhsGamma))
+      // add rely call if is a non-stack load
+      m.mem match {
+        case _: SharedMemory =>
           List(BProcedureCall("rely"), assign)
         case _ =>
-          // load is a stack load or doesn't exist
           List(assign)
       }
     case a: Assert =>
@@ -738,4 +833,17 @@ class IRToBoogie(var program: Program, var spec: Specification, var thread: Opti
       val body = a.body.toBoogie
       List(BAssume(body, a.comment))
   }
+
+  def exprToGamma(e: Expr): BExpr = {
+    val gammaVars: Set[BExpr] = e.gammas.map(_.toGamma)
+    if (gammaVars.isEmpty) {
+      TrueBLiteral
+    } else if (gammaVars.size == 1) {
+      gammaVars.head
+    } else {
+      gammaVars.tail.foldLeft(gammaVars.head) { (join: BExpr, next: BExpr) =>
+        BinaryBExpr(BoolAND, next, join)
+      }
+    }
+  }
 }
diff --git a/src/main/scala/translating/ReadELFLoader.scala b/src/main/scala/translating/ReadELFLoader.scala
index a57836bc8..5c958d8d1 100644
--- a/src/main/scala/translating/ReadELFLoader.scala
+++ b/src/main/scala/translating/ReadELFLoader.scala
@@ -44,20 +44,24 @@ case class ELFSymbol(num: Int,  /* symbol number */
   name: String)
 
 object ReadELFLoader {
-  def visitSyms(ctx: SymsContext, config: ILLoadingConfig): (List[ELFSymbol], Set[ExternalFunction], Set[SpecGlobal], Map[BigInt, BigInt], BigInt) = {
+  def visitSyms(ctx: SymsContext, config: ILLoadingConfig): (List[ELFSymbol], Set[ExternalFunction], Set[SpecGlobal], Set[FuncEntry], Map[BigInt, BigInt], BigInt) = {
     val externalFunctions = ctx.relocationTable.asScala.filter(_.relocationTableHeader != null).flatMap(r => visitRelocationTableExtFunc(r)).toSet
     val relocationOffsets = ctx.relocationTable.asScala.filter(_.relocationTableHeader != null).flatMap(r => visitRelocationTableOffsets(r)).toMap
     val mainAddress = ctx.symbolTable.asScala.flatMap(s => getFunctionAddress(s, config.mainProcedureName))
 
     val symbolTable = ctx.symbolTable.asScala.flatMap(s => visitSymbolTable(s)).toList
-    val globalVariables = (symbolTable.collect {
-      case ELFSymbol(num, value, size, ELFSymType.OBJECT, ELFBind.GLOBAL, ELFVis.DEFAULT, ndx, name) if ndx != ELFNDX.UND =>  SpecGlobal(name, size * 8, None, value)
-    }).toSet
+    val globalVariables = symbolTable.collect {
+      case ELFSymbol(_, value, size, ELFSymType.OBJECT, ELFBind.GLOBAL, ELFVis.DEFAULT, ndx, name) if ndx != ELFNDX.UND => SpecGlobal(name, size * 8, None, value)
+    }.toSet
+
+    val functionEntries = symbolTable.collect {
+      case ELFSymbol(_, value, size, ELFSymType.FUNC, ELFBind.GLOBAL, ELFVis.DEFAULT, ndx, name) if ndx != ELFNDX.UND => FuncEntry(name, size * 8, value)
+    }.toSet
 
     if (mainAddress.isEmpty) {
       throw Exception(s"no ${config.mainProcedureName} function in symbol table")
     }
-    (symbolTable, externalFunctions, globalVariables, relocationOffsets, mainAddress.head)
+    (symbolTable, externalFunctions, globalVariables, functionEntries, relocationOffsets, mainAddress.head)
   }
 
   def visitRelocationTableExtFunc(ctx: RelocationTableContext): Set[ExternalFunction] = {
diff --git a/src/main/scala/translating/SpecificationLoader.scala b/src/main/scala/translating/SpecificationLoader.scala
index 1d9b82336..eaca37ef6 100644
--- a/src/main/scala/translating/SpecificationLoader.scala
+++ b/src/main/scala/translating/SpecificationLoader.scala
@@ -43,7 +43,7 @@ case class SpecificationLoader(symbols: Set[SpecGlobal], program: Program) {
       case Some(_) => visitDirectFunctions(ctx.directFunctions)
       case None    => Set()
     }
-    Specification(globals, lPreds, relies, guarantees, subroutines, directFunctions)
+    Specification(Set(), globals, lPreds, relies, guarantees, subroutines, directFunctions)
   }
 
   def visitDirectFunctions(ctx: DirectFunctionsContext): Set[FunctionOp] = {
@@ -276,8 +276,8 @@ case class SpecificationLoader(symbols: Set[SpecGlobal], program: Program) {
   def visitBoogieTypeName(ctx: BoogieTypeNameContext): BType = {
     ctx match {
       case b: BvBTypeContext => BitVecBType(Integer.parseInt(b.BVSIZE.getText.stripPrefix("bv")))
-      case c: IntBTypeContext => IntBType
-      case c: BoolBTypeContext => BoolBType
+      case _: IntBTypeContext => IntBType
+      case _: BoolBTypeContext => BoolBType
       case m: MapBTypeContext => MapBType(visitBoogieTypeName(m.keyT), visitBoogieTypeName(m.valT))
     }
   }
@@ -317,26 +317,22 @@ case class SpecificationLoader(symbols: Set[SpecGlobal], program: Program) {
   }
 
   def visitId(ctx: IdContext, nameToGlobals: Map[String, SpecGlobal], params: Map[String, Parameter] = Map()): BExpr = {
-    val id = ctx.getText
-    id match {
-      case id if id.startsWith("Gamma_R") => {
+    ctx.getText match {
+      case id if id.startsWith("Gamma_R") =>
         BVariable(id, BoolBType, Scope.Global)
-      }
-      case id if (id.startsWith("Gamma_")) => {
-      val gamma_id = id.stripPrefix("Gamma_")
-      params.get(gamma_id) match {
-        case Some(p: Parameter) => p.value.toGamma
-        case None =>
-          nameToGlobals.get(gamma_id) match {
-            case Some(g: SpecGlobal) => SpecGamma(g)
-            case None                => throw new Exception(s"unresolvable reference to '$id' in specification")
+      case id if id.startsWith("Gamma_") =>
+        val gamma_id = id.stripPrefix("Gamma_")
+        params.get(gamma_id) match {
+          case Some(p: Parameter) => p.value.toGamma
+          case None =>
+            nameToGlobals.get(gamma_id) match {
+              case Some(g: SpecGlobal) => SpecGamma(g)
+              case None                => throw new Exception(s"unresolvable reference to '$id' in specification")
+            }
           }
-        }
-      }
-      case id if id.startsWith("R") => {
+      case id if id.startsWith("R") =>
         BVariable(id, BitVecBType(64), Scope.Global)
-      }
-      case id =>  {
+      case id =>
         params.get(id) match {
           case Some(p: Parameter) =>
             val registerSize = p.value.size
@@ -354,8 +350,7 @@ case class SpecificationLoader(symbols: Set[SpecGlobal], program: Program) {
               case None                => throw new Exception(s"unresolvable reference to '$id' in specification")
             }
         }
-      }
-      }
+    }
   }
 
   def visitMulDivModOp(ctx: MulDivModOpContext): BVBinOp = ctx.getText match {
diff --git a/src/main/scala/util/BASILConfig.scala b/src/main/scala/util/BASILConfig.scala
index 281a5b1ee..bcf93739b 100644
--- a/src/main/scala/util/BASILConfig.scala
+++ b/src/main/scala/util/BASILConfig.scala
@@ -20,6 +20,7 @@ case class StaticAnalysisConfig(dumpILToPath: Option[String] = None,
                                 analysisDotPath: Option[String] = None,
                                 threadSplit: Boolean = false,
                                 summariseProcedures: Boolean = false,
+                                memoryRegions: Boolean = false,
                                 irreducibleLoops: Boolean = true)
 enum BoogieMemoryAccessMode:
   case SuccessiveStoreSelect, LambdaStoreSelect
diff --git a/src/main/scala/util/RunUtils.scala b/src/main/scala/util/RunUtils.scala
index 121b7f430..1a0505178 100644
--- a/src/main/scala/util/RunUtils.scala
+++ b/src/main/scala/util/RunUtils.scala
@@ -1,15 +1,14 @@
 package util
 
-import java.io.{File, PrintWriter, FileInputStream, BufferedWriter, FileWriter, IOException}
+import java.io.{BufferedWriter, File, FileInputStream, FileWriter, IOException, PrintWriter}
 import com.grammatech.gtirb.proto.IR.IR
 import com.grammatech.gtirb.proto.Module.Module
 import com.grammatech.gtirb.proto.Section.Section
 import spray.json.*
 import gtirb.*
+
 import scala.collection.mutable.ListBuffer
 import scala.collection.mutable.ArrayBuffer
-import java.io.{File, PrintWriter}
-import java.io.{BufferedWriter, FileWriter, IOException}
 import scala.jdk.CollectionConverters.*
 import analysis.solvers.*
 import analysis.*
@@ -18,12 +17,14 @@ import ir.*
 import boogie.*
 import specification.*
 import Parsers.*
-import Parsers.SemanticsParser.*
+import Parsers.ASLpParser.*
+import analysis.data_structure_analysis.{DataStructureAnalysis, Graph, SymbolicAddress, SymbolicAddressAnalysis}
 import org.antlr.v4.runtime.tree.ParseTreeWalker
 import org.antlr.v4.runtime.BailErrorStrategy
 import org.antlr.v4.runtime.{CharStreams, CommonTokenStream, Token}
 import translating.*
 import util.Logger
+
 import java.util.Base64
 import spray.json.DefaultJsonProtocol.*
 import util.intrusive_list.IntrusiveList
@@ -42,6 +43,7 @@ case class IRContext(
     symbols: List[ELFSymbol],
     externalFunctions: Set[ExternalFunction],
     globals: Set[SpecGlobal],
+    funcEntries: Set[FuncEntry],
     globalOffsets: Map[BigInt, BigInt],
     specification: Specification,
     program: Program // internally mutable
@@ -50,17 +52,21 @@ case class IRContext(
 /** Stores the results of the static analyses.
   */
 case class StaticAnalysisContext(
-    constPropResult: Map[CFGPosition, Map[Variable, FlatElement[BitVecLiteral]]],
-    IRconstPropResult: Map[CFGPosition, Map[Variable, FlatElement[BitVecLiteral]]],
-    memoryRegionResult: Map[CFGPosition, LiftedElement[Set[MemoryRegion]]],
-    vsaResult: Map[CFGPosition, LiftedElement[Map[Variable | MemoryRegion, Set[Value]]]],
-    interLiveVarsResults: Map[CFGPosition, Map[Variable, TwoElement]],
-    paramResults: Map[Procedure, Set[Variable]],
-    steensgaardResults: Map[RegisterVariableWrapper, Set[RegisterVariableWrapper | MemoryRegion]],
-    mmmResults: MemoryModelMap,
-    memoryRegionContents: Map[MemoryRegion, Set[BitVecLiteral | MemoryRegion]],
-    reachingDefs: Map[CFGPosition, (Map[Variable, Set[Assign]], Map[Variable, Set[Assign]])],
-    varDepsSummaries: Map[Procedure, Map[Taintable, Set[Taintable]]],
+  intraProcConstProp: Map[CFGPosition, Map[Variable, FlatElement[BitVecLiteral]]],
+  interProcConstProp: Map[CFGPosition, Map[Variable, FlatElement[BitVecLiteral]]],
+  memoryRegionResult: Map[CFGPosition, Set[StackRegion]],
+  vsaResult: Map[CFGPosition, LiftedElement[Map[Variable | MemoryRegion, Set[Value]]]],
+  interLiveVarsResults: Map[CFGPosition, Map[Variable, TwoElement]],
+  paramResults: Map[Procedure, Set[Variable]],
+  steensgaardResults: Map[RegisterWrapperEqualSets, Set[RegisterWrapperEqualSets | MemoryRegion]],
+  mmmResults: MemoryModelMap,
+  reachingDefs: Map[CFGPosition, (Map[Variable, Set[Assign]], Map[Variable, Set[Assign]])],
+  varDepsSummaries: Map[Procedure, Map[Taintable, Set[Taintable]]],
+  regionInjector: Option[RegionInjector],
+  symbolicAddresses: Map[CFGPosition, Map[SymbolicAddress, TwoElement]],
+  localDSA: Map[Procedure, Graph],
+  bottomUpDSA: Map[Procedure, Graph],
+  topDownDSA: Map[Procedure, Graph]
 )
 
 /** Results of the main program execution.
@@ -74,14 +80,14 @@ object IRLoading {
   /** Create a context from just an IR program.
     */
   def load(p: Program): IRContext = {
-    IRContext(List.empty, Set.empty, Set.empty, Map.empty, IRLoading.loadSpecification(None, p, Set.empty), p)
+    IRContext(List.empty, Set.empty, Set.empty, Set.empty, Map.empty, IRLoading.loadSpecification(None, p, Set.empty), p)
   }
 
   /** Load a program from files using the provided configuration.
     */
   def load(q: ILLoadingConfig): IRContext = {
     // TODO: this tuple is large, should be a case class
-    val (symbols, externalFunctions, globals, globalOffsets, mainAddress) = IRLoading.loadReadELF(q.relfFile, q)
+    val (symbols, externalFunctions, globals, funcEntries, globalOffsets, mainAddress) = IRLoading.loadReadELF(q.relfFile, q)
 
     val program: Program = if (q.inputFile.endsWith(".adt")) {
       val bapProgram = loadBAP(q.inputFile)
@@ -95,7 +101,7 @@ object IRLoading {
 
     val specification = IRLoading.loadSpecification(q.specFile, program, globals)
 
-    IRContext(symbols, externalFunctions, globals, globalOffsets, specification, program)
+    IRContext(symbols, externalFunctions, globals, funcEntries, globalOffsets, specification, program)
   }
 
   def loadBAP(fileName: String): BAPProgram = {
@@ -117,9 +123,9 @@ object IRLoading {
     val semantics = mods.map(_.auxData("ast").data.toStringUtf8.parseJson.convertTo[Map[String, Array[Array[String]]]])
 
     def parse_insn(line: String): StmtContext = {
-      val semanticsLexer = SemanticsLexer(CharStreams.fromString(line))
-      val tokens = CommonTokenStream(semanticsLexer)
-      val parser = SemanticsParser(tokens)
+      val lexer = ASLpLexer(CharStreams.fromString(line))
+      val tokens = CommonTokenStream(lexer)
+      val parser = ASLpParser(tokens)
       parser.setErrorHandler(BailErrorStrategy())
       parser.setBuildParseTree(true)
 
@@ -153,7 +159,7 @@ object IRLoading {
   def loadReadELF(
       fileName: String,
       config: ILLoadingConfig
-  ): (List[ELFSymbol], Set[ExternalFunction], Set[SpecGlobal], Map[BigInt, BigInt], BigInt) = {
+  ): (List[ELFSymbol], Set[ExternalFunction], Set[SpecGlobal],  Set[FuncEntry], Map[BigInt, BigInt], BigInt) = {
     val lexer = ReadELFLexer(CharStreams.fromFileName(fileName))
     val tokens = CommonTokenStream(lexer)
     val parser = ReadELFParser(tokens)
@@ -170,7 +176,7 @@ object IRLoading {
         specParser.setBuildParseTree(true)
         val specLoader = SpecificationLoader(globals, program)
         specLoader.visitSpecification(specParser.specification())
-      case None => Specification(globals, Map(), List(), List(), List(), Set())
+      case None => Specification(Set(), globals, Map(), List(), List(), List(), Set())
     }
   }
 }
@@ -202,9 +208,7 @@ object IRTransform {
     cilvisitor.visit_prog(transforms.ConvertSingleReturn(), ctx.program)
 
     val externalRemover = ExternalRemover(externalNamesLibRemoved.toSet)
-    val renamer = Renamer(boogieReserved)
     externalRemover.visitProgram(ctx.program)
-    renamer.visitProgram(ctx.program)
 
     ctx
   }
@@ -212,28 +216,36 @@ object IRTransform {
   /** Cull unneccessary information that does not need to be included in the translation, and infer stack regions, and
     * add in modifies from the spec.
     */
-  def prepareForTranslation(config: ILLoadingConfig, ctx: IRContext): Unit = {
-    ctx.program.determineRelevantMemory(ctx.globalOffsets)
+  def prepareForTranslation(config: BASILConfig, ctx: IRContext): Unit = {
+    if (!config.staticAnalysis.isDefined || !config.staticAnalysis.get.memoryRegions) {
+      ctx.program.determineRelevantMemory(ctx.globalOffsets)
+    }
 
     Logger.debug("[!] Stripping unreachable")
     val before = ctx.program.procedures.size
-    transforms.stripUnreachableFunctions(ctx.program, config.procedureTrimDepth)
+    transforms.stripUnreachableFunctions(ctx.program, config.loading.procedureTrimDepth)
     Logger.debug(
       s"[!] Removed ${before - ctx.program.procedures.size} functions (${ctx.program.procedures.size} remaining)"
     )
-    val dupProcNames = (ctx.program.procedures.groupBy(_.name).filter((n,p) => p.size > 1)).toList.flatMap(_._2)
+    val dupProcNames = ctx.program.procedures.groupBy(_.name).filter((_, p) => p.size > 1).toList.flatMap(_(1))
 
-    var dupCounter = 0 
+    var dupCounter = 0
     for (p <- dupProcNames) {
       dupCounter += 1
       p.name = p.name + "$" + p.address.map(_.toString).getOrElse(dupCounter.toString)
     }
 
-    val stackIdentification = StackSubstituter()
-    stackIdentification.visitProgram(ctx.program)
+    if (!config.staticAnalysis.isDefined || !config.staticAnalysis.get.memoryRegions) {
+      val stackIdentification = StackSubstituter()
+      stackIdentification.visitProgram(ctx.program)
+    }
 
     val specModifies = ctx.specification.subroutines.map(s => s.name -> s.modifies).toMap
     ctx.program.setModifies(specModifies)
+
+    val renamer = Renamer(boogieReserved)
+    renamer.visitProgram(ctx.program)
+
     assert(invariant.singleCallBlockEnd(ctx.program))
   }
 
@@ -277,7 +289,8 @@ object StaticAnalysis {
   def analyse(
       ctx: IRContext,
       config: StaticAnalysisConfig,
-      iteration: Int
+      iteration: Int,
+      previousResults: Option[StaticAnalysisContext] = None
   ): StaticAnalysisContext = {
     val IRProgram: Program = ctx.program
     val externalFunctions: Set[ExternalFunction] = ctx.externalFunctions
@@ -289,17 +302,19 @@ object StaticAnalysis {
       .map(p => p.address.get -> p.name)
       .toMap
     val globalAddresses = globals.map(s => s.address -> s.name).toMap
+    val globalSizes = globals.map(s => s.name -> s.size).toMap
     val externalAddresses = externalFunctions.map(e => e.offset -> e.name).toMap
     Logger.debug("Globals:")
     Logger.debug(globalAddresses)
     Logger.debug("Global Offsets: ")
     Logger.debug(globalOffsets)
+    Logger.debug("Global Sizes: ")
+    Logger.debug(globalSizes)
     Logger.debug("External: ")
     Logger.debug(externalAddresses)
     Logger.debug("Subroutine Addresses:")
     Logger.debug(subroutines)
 
-
     // reducible loops
     if (config.irreducibleLoops) {
       Logger.debug("[!] Find loops")
@@ -318,6 +333,9 @@ object StaticAnalysis {
 
     val mergedSubroutines = subroutines ++ externalAddresses
 
+    val domain = computeDomain(IntraProcIRCursor, IRProgram.procedures)
+    val interDomain = computeDomain(InterProcIRCursor, IRProgram.procedures)
+
     Logger.debug("[!] Running ANR")
     val ANRSolver = ANRAnalysisSolver(IRProgram)
     val ANRResult = ANRSolver.analyze()
@@ -326,60 +344,59 @@ object StaticAnalysis {
     val RNASolver = RNAAnalysisSolver(IRProgram)
     val RNAResult = RNASolver.analyze()
 
-    Logger.debug("[!] Running Constant Propagation")
-    val constPropSolver = ConstantPropagationSolver(IRProgram)
-    val constPropResult: Map[CFGPosition, Map[Variable, FlatElement[BitVecLiteral]]] = constPropSolver.analyze()
+    Logger.debug("[!] Running Inter-procedural Constant Propagation")
+    val interProcConstProp = InterProcConstantPropagation(IRProgram)
+    val interProcConstPropResult: Map[CFGPosition, Map[Variable, FlatElement[BitVecLiteral]]] = interProcConstProp.analyze()
+
+    config.analysisResultsPath.foreach { s =>
+      writeToFile(printAnalysisResults(IRProgram, interProcConstPropResult), s"${s}OGconstprop$iteration.txt")
+    }
 
     Logger.debug("[!] Variable dependency summaries")
     val scc = stronglyConnectedComponents(CallGraph, List(IRProgram.mainProcedure))
     val specGlobalAddresses = ctx.specification.globals.map(s => s.address -> s.name).toMap
-    val varDepsSummaries = VariableDependencyAnalysis(IRProgram, ctx.specification.globals, specGlobalAddresses, constPropResult, scc).analyze()
+    val varDepsSummaries = VariableDependencyAnalysis(IRProgram, ctx.specification.globals, specGlobalAddresses, interProcConstPropResult, scc).analyze()
 
-    val ilcpsolver = IRSimpleValueAnalysis.Solver(IRProgram)
-    val newCPResult: Map[CFGPosition, Map[Variable, FlatElement[BitVecLiteral]]] = ilcpsolver.analyze()
+    val intraProcConstProp = IntraProcConstantPropagation(IRProgram)
+    val intraProcConstPropResult: Map[CFGPosition, Map[Variable, FlatElement[BitVecLiteral]]] = intraProcConstProp.analyze()
 
-    config.analysisResultsPath.foreach(s =>
-      writeToFile(printAnalysisResults(IRProgram, newCPResult), s"${s}_new_ir_constprop$iteration.txt")
-    )
+    config.analysisResultsPath.foreach { s =>
+      writeToFile(printAnalysisResults(IRProgram, intraProcConstPropResult), s"${s}_new_ir_constprop$iteration.txt")
+    }
 
-    config.analysisDotPath.foreach(f => {
+    config.analysisDotPath.foreach { f =>
       val dumpdomain = computeDomain[CFGPosition, CFGPosition](InterProcIRCursor, IRProgram.procedures)
       writeToFile(toDot(dumpdomain, InterProcIRCursor, Map.empty), s"${f}_new_ir_intercfg$iteration.dot")
-    })
+    }
 
-    val reachingDefinitionsAnalysisSolver = ReachingDefinitionsAnalysisSolver(IRProgram)
+    val reachingDefinitionsAnalysisSolver = InterprocReachingDefinitionsAnalysisSolver(IRProgram)
     val reachingDefinitionsAnalysisResults = reachingDefinitionsAnalysisSolver.analyze()
 
-    config.analysisDotPath.foreach(s => {
+    config.analysisDotPath.foreach { s =>
       writeToFile(
-        toDot(IRProgram, IRProgram.filter(_.isInstanceOf[Command]).map(b => b -> reachingDefinitionsAnalysisResults(b).toString).toMap),
+        toDot(IRProgram, IRProgram.filter(_.isInstanceOf[Command]).map(b => b -> reachingDefinitionsAnalysisResults(b).toString).toMap, true),
         s"${s}_reachingDefinitions$iteration.dot"
       )
-    })
-
+    }
 
-    Logger.debug("[!] Running RegToMemAnalysisSolver")
-    val regionAccessesAnalysisSolver = RegionAccessesAnalysisSolver(IRProgram, constPropResult, reachingDefinitionsAnalysisResults)
-    val regionAccessesAnalysisResults = regionAccessesAnalysisSolver.analyze()
+    val mmm = MemoryModelMap(globalOffsets)
+    mmm.preLoadGlobals(mergedSubroutines, globalAddresses, globalSizes)
 
-//     config.analysisDotPath.foreach(s => writeToFile(cfg.toDot(Output.labeler(regionAccessesAnalysisResults, true), Output.dotIder), s"${s}_RegTo$iteration.dot"))
-    config.analysisResultsPath.foreach(s => writeToFile(printAnalysisResults(IRProgram, regionAccessesAnalysisResults), s"${s}_RegTo$iteration.txt"))
-    config.analysisDotPath.foreach(s => {
-      writeToFile(
-        toDot(IRProgram, IRProgram.filter(_.isInstanceOf[Command]).map(b => b -> regionAccessesAnalysisResults(b).toString).toMap),
-        s"${s}_RegTo$iteration.dot"
-      )
-    })
+    val previousVSAResults = if (previousResults.isDefined) {
+      previousResults.get.vsaResult
+    } else {
+      Map[CFGPosition, LiftedElement[Map[Variable | MemoryRegion, Set[Value]]]]()
+    }
 
-    Logger.debug("[!] Running Constant Propagation with SSA")
-    val constPropSolverWithSSA = ConstantPropagationSolverWithSSA(IRProgram, reachingDefinitionsAnalysisResults)
-    val constPropResultWithSSA = constPropSolverWithSSA.analyze()
+    Logger.debug("[!] Running GRA")
+    val graSolver = GlobalRegionAnalysisSolver(IRProgram, domain.toSet, interProcConstPropResult, reachingDefinitionsAnalysisResults, mmm, previousVSAResults)
+    val graResult = graSolver.analyze()
 
     Logger.debug("[!] Running MRA")
-    val mraSolver = MemoryRegionAnalysisSolver(IRProgram, globalAddresses, globalOffsets, mergedSubroutines, constPropResult, ANRResult, RNAResult, regionAccessesAnalysisResults, reachingDefinitionsAnalysisResults)
+    val mraSolver = MemoryRegionAnalysisSolver(IRProgram, domain.toSet, globalAddresses, globalOffsets, mergedSubroutines, interProcConstPropResult, ANRResult, RNAResult, reachingDefinitionsAnalysisResults, graResult, mmm)
     val mraResult = mraSolver.analyze()
 
-    config.analysisDotPath.foreach(s => {
+    config.analysisDotPath.foreach { s =>
       writeToFile(dotCallGraph(IRProgram), s"${s}_callgraph$iteration.dot")
       writeToFile(
         dotBlockGraph(IRProgram, IRProgram.filter(_.isInstanceOf[Block]).map(b => b -> b.toString).toMap),
@@ -387,7 +404,7 @@ object StaticAnalysis {
       )
 
       writeToFile(
-        toDot(IRProgram, IRProgram.filter(_.isInstanceOf[Command]).map(b => b -> newCPResult(b).toString).toMap),
+        toDot(IRProgram, IRProgram.filter(_.isInstanceOf[Command]).map(b => b -> intraProcConstPropResult(b).toString).toMap),
         s"${s}_new_ir_constprop$iteration.dot"
       )
 
@@ -395,56 +412,64 @@ object StaticAnalysis {
         toDot(IRProgram, IRProgram.filter(_.isInstanceOf[Command]).map(b => b -> mraResult(b).toString).toMap),
         s"${s}_MRA$iteration.dot"
       )
-    })
+
+      writeToFile(
+        toDot(IRProgram, IRProgram.filter(_.isInstanceOf[Command]).map(b => b -> graResult(b).toString).toMap),
+        s"${s}_GRA$iteration.dot"
+      )
+    }
 
     Logger.debug("[!] Running MMM")
-    val mmm = MemoryModelMap()
-    mmm.convertMemoryRegions(mraResult, mergedSubroutines, globalOffsets, mraSolver.procedureToSharedRegions)
+    mmm.convertMemoryRegions(mraSolver.procedureToStackRegions, mraSolver.procedureToHeapRegions, mraResult, mraSolver.procedureToSharedRegions, graSolver.getDataMap, graResult)
     mmm.logRegions()
 
     Logger.debug("[!] Running Steensgaard")
-    val steensgaardSolver = InterprocSteensgaardAnalysis(IRProgram, constPropResultWithSSA, regionAccessesAnalysisResults, mmm, reachingDefinitionsAnalysisResults, globalOffsets)
+    val steensgaardSolver = InterprocSteensgaardAnalysis(interDomain.toSet, mmm, reachingDefinitionsAnalysisResults, previousVSAResults)
     steensgaardSolver.analyze()
     val steensgaardResults = steensgaardSolver.pointsTo()
-    val memoryRegionContents = steensgaardSolver.getMemoryRegionContents
-    mmm.logRegions(memoryRegionContents)
 
-    // turn fake procedures into diamonds
     Logger.debug("[!] Running VSA")
-    val vsaSolver = ValueSetAnalysisSolver(IRProgram, globalAddresses, externalAddresses, globalOffsets, subroutines, mmm, constPropResult)
+    val vsaSolver = ValueSetAnalysisSolver(IRProgram, mmm, interProcConstPropResult)
     val vsaResult: Map[CFGPosition, LiftedElement[Map[Variable | MemoryRegion, Set[Value]]]] = vsaSolver.analyze()
 
+    config.analysisDotPath.foreach { s =>
+      writeToFile(
+        toDot(IRProgram, IRProgram.filter(_.isInstanceOf[Command]).map(b => b -> vsaResult(b).toString).toMap),
+        s"${s}_VSA$iteration.dot"
+      )
+    }
 
-    var paramResults: Map[Procedure, Set[Variable]] = Map.empty
-    var interLiveVarsResults: Map[CFGPosition, Map[Variable, TwoElement]] = Map.empty
-
-    if (IRProgram.mainProcedure.blocks.nonEmpty && IRProgram.mainProcedure.returnBlock.isDefined && IRProgram.mainProcedure.entryBlock.isDefined) {
-      Logger.debug("[!] Running Interprocedural Live Variables Analysis")
-      interLiveVarsResults = InterLiveVarsAnalysis(IRProgram).analyze()
-
-      Logger.debug("[!] Running Parameter Analysis")
-      paramResults = ParamAnalysis(IRProgram).analyze()
-
+    Logger.debug("[!] Injecting regions")
+    val regionInjector = if (config.memoryRegions) {
+      val injector = RegionInjector(IRProgram, mmm)
+      injector.nodeVisitor()
+      Some(injector)
     } else {
-      Logger.warn(s"Disabling IDE solver tests due to external main procedure: ${IRProgram.mainProcedure.name}")
+      None
     }
 
+    val paramResults: Map[Procedure, Set[Variable]] = ParamAnalysis(IRProgram).analyze()
+    val interLiveVarsResults: Map[CFGPosition, Map[Variable, TwoElement]] = InterLiveVarsAnalysis(IRProgram).analyze()
+
     StaticAnalysisContext(
-      constPropResult = constPropResult,
-      IRconstPropResult = newCPResult,
+      intraProcConstProp = interProcConstPropResult,
+      interProcConstProp = intraProcConstPropResult,
       memoryRegionResult = mraResult,
       vsaResult = vsaResult,
       interLiveVarsResults = interLiveVarsResults,
       paramResults = paramResults,
       steensgaardResults = steensgaardResults,
       mmmResults = mmm,
-      memoryRegionContents = memoryRegionContents,
+      symbolicAddresses = Map.empty,
       reachingDefs = reachingDefinitionsAnalysisResults,
       varDepsSummaries = varDepsSummaries,
+      regionInjector = regionInjector,
+      localDSA = Map.empty,
+      bottomUpDSA = Map.empty,
+      topDownDSA = Map.empty,
     )
   }
 
-
   def printAnalysisResults(prog: Program, result: Map[CFGPosition, _]): String = {
     val results = mutable.ArrayBuffer[String]()
     val toVisit = mutable.Stack[CFGPosition]()
@@ -511,7 +536,9 @@ object RunUtils {
     IRTransform.doCleanup(ctx)
 
     q.loading.dumpIL.foreach(s => writeToFile(serialiseIL(ctx.program), s"$s-before-analysis.il"))
-    val analysis = q.staticAnalysis.map(conf => staticAnalysis(conf, ctx))
+    val analysis = q.staticAnalysis.map {
+      conf => staticAnalysis(conf, ctx)
+    }
     q.loading.dumpIL.foreach(s => writeToFile(serialiseIL(ctx.program), s"$s-after-analysis.il"))
 
     if (q.runInterpret) {
@@ -519,21 +546,23 @@ object RunUtils {
       interpreter.interpret(ctx.program)
     }
 
-    IRTransform.prepareForTranslation(q.loading, ctx)
+    IRTransform.prepareForTranslation(q, ctx)
 
     Logger.debug("[!] Translating to Boogie")
 
+    val regionInjector = analysis.flatMap(a => a.regionInjector)
+
     val boogiePrograms = if (q.boogieTranslation.threadSplit && ctx.program.threads.nonEmpty) {
       val outPrograms = ArrayBuffer[BProgram]()
       for (thread <- ctx.program.threads) {
         val fileName = q.outputPrefix.stripSuffix(".bpl") + "_" + thread.entry.name + ".bpl"
-        val boogieTranslator = IRToBoogie(ctx.program, ctx.specification, Some(thread), fileName)
-        outPrograms.addOne(boogieTranslator.translate(q.boogieTranslation))
+        val boogieTranslator = IRToBoogie(ctx.program, ctx.specification, Some(thread), fileName, regionInjector, q.boogieTranslation)
+        outPrograms.addOne(boogieTranslator.translate)
       }
       outPrograms
     } else {
-      val boogieTranslator = IRToBoogie(ctx.program, ctx.specification, None, q.outputPrefix)
-      ArrayBuffer(boogieTranslator.translate(q.boogieTranslation))
+      val boogieTranslator = IRToBoogie(ctx.program, ctx.specification, None, q.outputPrefix, regionInjector, q.boogieTranslation)
+      ArrayBuffer(boogieTranslator.translate)
     }
     assert(invariant.singleCallBlockEnd(ctx.program))
 
@@ -546,21 +575,31 @@ object RunUtils {
     var iteration = 1
     var modified: Boolean = true
     val analysisResult = mutable.ArrayBuffer[StaticAnalysisContext]()
-    while (modified) {
+    while (modified || (analysisResult.size < 2 && config.memoryRegions)) {
       Logger.debug("[!] Running Static Analysis")
-      val result = StaticAnalysis.analyse(ctx, config, iteration)
+      val result = StaticAnalysis.analyse(ctx, config, iteration, analysisResult.lastOption)
       analysisResult.append(result)
       Logger.debug("[!] Replacing Indirect Calls")
-      modified = transforms.resolveIndirectCallsUsingPointsTo(
+
+      /*
+      modified = transforms.SteensgaardIndirectCallResolution(
+        ctx.program,
         result.steensgaardResults,
-        result.memoryRegionContents,
-        result.reachingDefs,
-        ctx.program
-      )
+        result.reachingDefs
+      ).resolveIndirectCalls()
+      */
+
+      modified = transforms.VSAIndirectCallResolution(
+        ctx.program,
+        result.vsaResult,
+        result.mmmResults
+      ).resolveIndirectCalls()
+
       Logger.debug("[!] Generating Procedure Summaries")
       if (config.summariseProcedures) {
-        IRTransform.generateProcedureSummaries(ctx, ctx.program, result.constPropResult, result.varDepsSummaries)
+        IRTransform.generateProcedureSummaries(ctx, ctx.program, result.intraProcConstProp, result.varDepsSummaries)
       }
+
       if (modified) {
         iteration += 1
         Logger.debug(s"[!] Analysing again (iter $iteration)")
@@ -570,12 +609,42 @@ object RunUtils {
     // should later move this to be inside while (modified) loop and have splitting threads cause further iterations
 
     if (config.threadSplit) {
-      transforms.splitThreads(ctx.program, analysisResult.last.steensgaardResults, analysisResult.last.memoryRegionContents, analysisResult.last.reachingDefs)
+      transforms.splitThreads(ctx.program, analysisResult.last.steensgaardResults, analysisResult.last.reachingDefs)
+    }
+
+    Logger.debug("[!] Running Writes To")
+    val writesTo = WriteToAnalysis(ctx.program).analyze()
+    val reachingDefs = ReachingDefsAnalysis(ctx.program, writesTo).analyze()
+    config.analysisDotPath.foreach { s =>
+      writeToFile(toDot(ctx.program), s"${s}_ct.dot")
+    }
+
+    Logger.debug("[!] Running Symbolic Access Analysis")
+    val symResults: Map[CFGPosition, Map[SymbolicAddress, TwoElement]] =
+      SymbolicAddressAnalysis(ctx.program, analysisResult.last.interProcConstProp).analyze()
+    config.analysisDotPath.foreach { s =>
+      val labels = symResults.map { (k, v) => k -> v.toString }
+      writeToFile(toDot(ctx.program, labels), s"${s}_saa.dot")
+    }
+
+    Logger.debug("[!] Running DSA Analysis")
+    val symbolTableEntries: Set[SymbolTableEntry] = ctx.globals ++ ctx.funcEntries
+    val dsa = DataStructureAnalysis(ctx.program, symResults, analysisResult.last.interProcConstProp, symbolTableEntries, ctx.globalOffsets, ctx.externalFunctions, reachingDefs, writesTo, analysisResult.last.paramResults)
+    dsa.analyze()
+
+    config.analysisDotPath.foreach { s =>
+      dsa.topDown(ctx.program.mainProcedure).toDot
+      writeToFile(dsa.topDown(ctx.program.mainProcedure).toDot, s"${s}_main_dsg.dot")
     }
 
     assert(invariant.singleCallBlockEnd(ctx.program))
     Logger.debug(s"[!] Finished indirect call resolution after $iteration iterations")
-    analysisResult.last
+    analysisResult.last.copy(
+      symbolicAddresses = symResults,
+      localDSA = dsa.local.toMap,
+      bottomUpDSA = dsa.bottomUp.toMap,
+      topDownDSA = dsa.topDown.toMap
+    )
   }
 }
 
diff --git a/src/test/correct/arrays_simple/clang/arrays_simple.expected b/src/test/correct/arrays_simple/clang/arrays_simple.expected
index c24e7d31d..73aa783a4 100644
--- a/src/test/correct/arrays_simple/clang/arrays_simple.expected
+++ b/src/test/correct/arrays_simple/clang/arrays_simple.expected
@@ -27,10 +27,6 @@ function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv6
   (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
-}
-
 function {:extern} memory_store32_le(memory: [bv64]bv8, index: bv64, value: bv32) returns ([bv64]bv8) {
   memory[index := value[8:0]][bvadd64(index, 1bv64) := value[16:8]][bvadd64(index, 2bv64) := value[24:16]][bvadd64(index, 3bv64) := value[32:24]]
 }
@@ -38,12 +34,9 @@ function {:extern} memory_store32_le(memory: [bv64]bv8, index: bv64, value: bv32
 function {:extern} {:bvbuiltin "zero_extend 32"} zero_extend32_32(bv32) returns (bv64);
 procedure {:extern} rely();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
-  free ensures (memory_load8_le(mem, 1872bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1873bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1874bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1875bv64) == 0bv8);
+  ensures (mem == old(mem));
+  free ensures (memory_load32_le(mem, 1872bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1812bv64);
@@ -51,8 +44,8 @@ procedure {:extern} rely();
 
 procedure {:extern} rely_transitive();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
+  ensures (mem == old(mem));
 
 implementation {:extern} rely_transitive()
 {
@@ -69,20 +62,14 @@ procedure main();
   modifies Gamma_R0, Gamma_R31, Gamma_R8, Gamma_stack, R0, R31, R8, stack;
   free requires (memory_load64_le(mem, 69664bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
-  free requires (memory_load8_le(mem, 1872bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1873bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1874bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1875bv64) == 0bv8);
+  free requires (memory_load32_le(mem, 1872bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free requires (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free requires (memory_load64_le(mem, 69592bv64) == 1812bv64);
   free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
   free ensures (Gamma_R31 == old(Gamma_R31));
   free ensures (R31 == old(R31));
-  free ensures (memory_load8_le(mem, 1872bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1873bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1874bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1875bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1872bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1812bv64);
diff --git a/src/test/correct/arrays_simple/clang/arrays_simple_gtirb.expected b/src/test/correct/arrays_simple/clang/arrays_simple_gtirb.expected
index b58ac9c72..eda5cac95 100644
--- a/src/test/correct/arrays_simple/clang/arrays_simple_gtirb.expected
+++ b/src/test/correct/arrays_simple/clang/arrays_simple_gtirb.expected
@@ -27,10 +27,6 @@ function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv6
   (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
-}
-
 function {:extern} memory_store32_le(memory: [bv64]bv8, index: bv64, value: bv32) returns ([bv64]bv8) {
   memory[index := value[8:0]][bvadd64(index, 1bv64) := value[16:8]][bvadd64(index, 2bv64) := value[24:16]][bvadd64(index, 3bv64) := value[32:24]]
 }
@@ -38,12 +34,9 @@ function {:extern} memory_store32_le(memory: [bv64]bv8, index: bv64, value: bv32
 function {:extern} {:bvbuiltin "zero_extend 32"} zero_extend32_32(bv32) returns (bv64);
 procedure {:extern} rely();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
-  free ensures (memory_load8_le(mem, 1872bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1873bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1874bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1875bv64) == 0bv8);
+  ensures (mem == old(mem));
+  free ensures (memory_load32_le(mem, 1872bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1812bv64);
@@ -51,8 +44,8 @@ procedure {:extern} rely();
 
 procedure {:extern} rely_transitive();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
+  ensures (mem == old(mem));
 
 implementation {:extern} rely_transitive()
 {
@@ -69,20 +62,14 @@ procedure main();
   modifies Gamma_R0, Gamma_R31, Gamma_R8, Gamma_stack, R0, R31, R8, stack;
   free requires (memory_load64_le(mem, 69664bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
-  free requires (memory_load8_le(mem, 1872bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1873bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1874bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1875bv64) == 0bv8);
+  free requires (memory_load32_le(mem, 1872bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free requires (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free requires (memory_load64_le(mem, 69592bv64) == 1812bv64);
   free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
   free ensures (Gamma_R31 == old(Gamma_R31));
   free ensures (R31 == old(R31));
-  free ensures (memory_load8_le(mem, 1872bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1873bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1874bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1875bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1872bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1812bv64);
diff --git a/src/test/correct/basic_arrays_read/clang/basic_arrays_read.expected b/src/test/correct/basic_arrays_read/clang/basic_arrays_read.expected
index f4ac60347..1fcc04f91 100644
--- a/src/test/correct/basic_arrays_read/clang/basic_arrays_read.expected
+++ b/src/test/correct/basic_arrays_read/clang/basic_arrays_read.expected
@@ -10,7 +10,7 @@ var {:extern} mem: [bv64]bv8;
 var {:extern} stack: [bv64]bv8;
 const {:extern} $arr_addr: bv64;
 axiom ($arr_addr == 69684bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
   (if ((index == bvadd64($arr_addr, 4bv64)) || (index == bvadd64($arr_addr, 0bv64))) then false else false)
 }
 
@@ -31,10 +31,6 @@ function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv6
   (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
-}
-
 function {:extern} memory_store32_le(memory: [bv64]bv8, index: bv64, value: bv32) returns ([bv64]bv8) {
   memory[index := value[8:0]][bvadd64(index, 1bv64) := value[16:8]][bvadd64(index, 2bv64) := value[24:16]][bvadd64(index, 3bv64) := value[32:24]]
 }
@@ -44,10 +40,7 @@ procedure {:extern} rely();
   modifies Gamma_mem, mem;
   ensures (forall i: bv64 :: (((mem[i] == old(mem[i])) ==> (Gamma_mem[i] == old(Gamma_mem[i])))));
   ensures (old(memory_load32_le(mem, bvadd64($arr_addr, 0bv64))) == memory_load32_le(mem, bvadd64($arr_addr, 0bv64)));
-  free ensures (memory_load8_le(mem, 1860bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1861bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1862bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1863bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1860bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1812bv64);
@@ -82,20 +75,14 @@ procedure main();
   modifies Gamma_R0, Gamma_R31, Gamma_R8, Gamma_mem, Gamma_stack, R0, R31, R8, mem, stack;
   free requires (memory_load64_le(mem, 69664bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
-  free requires (memory_load8_le(mem, 1860bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1861bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1862bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1863bv64) == 0bv8);
+  free requires (memory_load32_le(mem, 1860bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free requires (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free requires (memory_load64_le(mem, 69592bv64) == 1812bv64);
   free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
   free ensures (Gamma_R31 == old(Gamma_R31));
   free ensures (R31 == old(R31));
-  free ensures (memory_load8_le(mem, 1860bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1861bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1862bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1863bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1860bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1812bv64);
@@ -112,7 +99,6 @@ implementation main()
     call rely();
     assert (L(mem, bvadd64(R8, 52bv64)) ==> true);
     mem, Gamma_mem := memory_store32_le(mem, bvadd64(R8, 52bv64), 0bv32), gamma_store32(Gamma_mem, bvadd64(R8, 52bv64), true);
-    assert true;
     assume {:captureState "%000002dd"} true;
     call rely();
     R0, Gamma_R0 := zero_extend32_32(memory_load32_le(mem, bvadd64(R8, 52bv64))), (gamma_load32(Gamma_mem, bvadd64(R8, 52bv64)) || L(mem, bvadd64(R8, 52bv64)));
diff --git a/src/test/correct/basic_arrays_read/clang/basic_arrays_read_gtirb.expected b/src/test/correct/basic_arrays_read/clang/basic_arrays_read_gtirb.expected
index 8e4bac79d..f4cde0c06 100644
--- a/src/test/correct/basic_arrays_read/clang/basic_arrays_read_gtirb.expected
+++ b/src/test/correct/basic_arrays_read/clang/basic_arrays_read_gtirb.expected
@@ -10,7 +10,7 @@ var {:extern} mem: [bv64]bv8;
 var {:extern} stack: [bv64]bv8;
 const {:extern} $arr_addr: bv64;
 axiom ($arr_addr == 69684bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
   (if ((index == bvadd64($arr_addr, 4bv64)) || (index == bvadd64($arr_addr, 0bv64))) then false else false)
 }
 
@@ -31,10 +31,6 @@ function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv6
   (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
-}
-
 function {:extern} memory_store32_le(memory: [bv64]bv8, index: bv64, value: bv32) returns ([bv64]bv8) {
   memory[index := value[8:0]][bvadd64(index, 1bv64) := value[16:8]][bvadd64(index, 2bv64) := value[24:16]][bvadd64(index, 3bv64) := value[32:24]]
 }
@@ -44,10 +40,7 @@ procedure {:extern} rely();
   modifies Gamma_mem, mem;
   ensures (forall i: bv64 :: (((mem[i] == old(mem[i])) ==> (Gamma_mem[i] == old(Gamma_mem[i])))));
   ensures (old(memory_load32_le(mem, bvadd64($arr_addr, 0bv64))) == memory_load32_le(mem, bvadd64($arr_addr, 0bv64)));
-  free ensures (memory_load8_le(mem, 1860bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1861bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1862bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1863bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1860bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1812bv64);
@@ -82,20 +75,14 @@ procedure main();
   modifies Gamma_R0, Gamma_R31, Gamma_R8, Gamma_mem, Gamma_stack, R0, R31, R8, mem, stack;
   free requires (memory_load64_le(mem, 69664bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
-  free requires (memory_load8_le(mem, 1860bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1861bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1862bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1863bv64) == 0bv8);
+  free requires (memory_load32_le(mem, 1860bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free requires (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free requires (memory_load64_le(mem, 69592bv64) == 1812bv64);
   free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
   free ensures (Gamma_R31 == old(Gamma_R31));
   free ensures (R31 == old(R31));
-  free ensures (memory_load8_le(mem, 1860bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1861bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1862bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1863bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1860bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1812bv64);
@@ -112,7 +99,6 @@ implementation main()
     call rely();
     assert (L(mem, bvadd64(R8, 52bv64)) ==> true);
     mem, Gamma_mem := memory_store32_le(mem, bvadd64(R8, 52bv64), 0bv32), gamma_store32(Gamma_mem, bvadd64(R8, 52bv64), true);
-    assert true;
     assume {:captureState "1824$0"} true;
     call rely();
     R0, Gamma_R0 := zero_extend32_32(memory_load32_le(mem, bvadd64(R8, 52bv64))), (gamma_load32(Gamma_mem, bvadd64(R8, 52bv64)) || L(mem, bvadd64(R8, 52bv64)));
diff --git a/src/test/correct/basic_arrays_read/clang_pic/basic_arrays_read.expected b/src/test/correct/basic_arrays_read/clang_pic/basic_arrays_read.expected
index 736e8907d..b97a02fe9 100644
--- a/src/test/correct/basic_arrays_read/clang_pic/basic_arrays_read.expected
+++ b/src/test/correct/basic_arrays_read/clang_pic/basic_arrays_read.expected
@@ -10,7 +10,7 @@ var {:extern} mem: [bv64]bv8;
 var {:extern} stack: [bv64]bv8;
 const {:extern} $arr_addr: bv64;
 axiom ($arr_addr == 69684bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
   (if ((index == bvadd64($arr_addr, 4bv64)) || (index == bvadd64($arr_addr, 0bv64))) then false else false)
 }
 
@@ -35,10 +35,6 @@ function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv6
   (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
-}
-
 function {:extern} memory_store32_le(memory: [bv64]bv8, index: bv64, value: bv32) returns ([bv64]bv8) {
   memory[index := value[8:0]][bvadd64(index, 1bv64) := value[16:8]][bvadd64(index, 2bv64) := value[24:16]][bvadd64(index, 3bv64) := value[32:24]]
 }
@@ -48,15 +44,12 @@ procedure {:extern} rely();
   modifies Gamma_mem, mem;
   ensures (forall i: bv64 :: (((mem[i] == old(mem[i])) ==> (Gamma_mem[i] == old(Gamma_mem[i])))));
   ensures (old(memory_load32_le(mem, bvadd64($arr_addr, 0bv64))) == memory_load32_le(mem, bvadd64($arr_addr, 0bv64)));
-  free ensures (memory_load8_le(mem, 1928bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1929bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1930bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1931bv64) == 0bv8);
-  free ensures (memory_load64_le(mem, 69672bv64) == 69672bv64);
-  free ensures (memory_load64_le(mem, 69584bv64) == 1876bv64);
+  free ensures (memory_load32_le(mem, 1928bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69056bv64) == 1872bv64);
   free ensures (memory_load64_le(mem, 69064bv64) == 1792bv64);
+  free ensures (memory_load64_le(mem, 69584bv64) == 1876bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 69684bv64);
+  free ensures (memory_load64_le(mem, 69672bv64) == 69672bv64);
 
 procedure {:extern} rely_transitive();
   modifies Gamma_mem, mem;
@@ -87,26 +80,20 @@ procedure main();
   modifies Gamma_R0, Gamma_R31, Gamma_R8, Gamma_mem, Gamma_stack, R0, R31, R8, mem, stack;
   free requires (memory_load64_le(mem, 69664bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
-  free requires (memory_load8_le(mem, 1928bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1929bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1930bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1931bv64) == 0bv8);
-  free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
-  free requires (memory_load64_le(mem, 69584bv64) == 1876bv64);
+  free requires (memory_load32_le(mem, 1928bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69056bv64) == 1872bv64);
   free requires (memory_load64_le(mem, 69064bv64) == 1792bv64);
+  free requires (memory_load64_le(mem, 69584bv64) == 1876bv64);
   free requires (memory_load64_le(mem, 69592bv64) == 69684bv64);
+  free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
   free ensures (Gamma_R31 == old(Gamma_R31));
   free ensures (R31 == old(R31));
-  free ensures (memory_load8_le(mem, 1928bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1929bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1930bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1931bv64) == 0bv8);
-  free ensures (memory_load64_le(mem, 69672bv64) == 69672bv64);
-  free ensures (memory_load64_le(mem, 69584bv64) == 1876bv64);
+  free ensures (memory_load32_le(mem, 1928bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69056bv64) == 1872bv64);
   free ensures (memory_load64_le(mem, 69064bv64) == 1792bv64);
+  free ensures (memory_load64_le(mem, 69584bv64) == 1876bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 69684bv64);
+  free ensures (memory_load64_le(mem, 69672bv64) == 69672bv64);
 
 implementation main()
 {
@@ -121,7 +108,6 @@ implementation main()
     call rely();
     assert (L(mem, R8) ==> true);
     mem, Gamma_mem := memory_store32_le(mem, R8, 0bv32), gamma_store32(Gamma_mem, R8, true);
-    assert true;
     assume {:captureState "%000002e8"} true;
     call rely();
     R0, Gamma_R0 := zero_extend32_32(memory_load32_le(mem, R8)), (gamma_load32(Gamma_mem, R8) || L(mem, R8));
diff --git a/src/test/correct/basic_arrays_read/clang_pic/basic_arrays_read_gtirb.expected b/src/test/correct/basic_arrays_read/clang_pic/basic_arrays_read_gtirb.expected
index e65df320f..36598de3f 100644
--- a/src/test/correct/basic_arrays_read/clang_pic/basic_arrays_read_gtirb.expected
+++ b/src/test/correct/basic_arrays_read/clang_pic/basic_arrays_read_gtirb.expected
@@ -10,7 +10,7 @@ var {:extern} mem: [bv64]bv8;
 var {:extern} stack: [bv64]bv8;
 const {:extern} $arr_addr: bv64;
 axiom ($arr_addr == 69684bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
   (if ((index == bvadd64($arr_addr, 4bv64)) || (index == bvadd64($arr_addr, 0bv64))) then false else false)
 }
 
@@ -35,10 +35,6 @@ function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv6
   (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
-}
-
 function {:extern} memory_store32_le(memory: [bv64]bv8, index: bv64, value: bv32) returns ([bv64]bv8) {
   memory[index := value[8:0]][bvadd64(index, 1bv64) := value[16:8]][bvadd64(index, 2bv64) := value[24:16]][bvadd64(index, 3bv64) := value[32:24]]
 }
@@ -48,15 +44,12 @@ procedure {:extern} rely();
   modifies Gamma_mem, mem;
   ensures (forall i: bv64 :: (((mem[i] == old(mem[i])) ==> (Gamma_mem[i] == old(Gamma_mem[i])))));
   ensures (old(memory_load32_le(mem, bvadd64($arr_addr, 0bv64))) == memory_load32_le(mem, bvadd64($arr_addr, 0bv64)));
-  free ensures (memory_load8_le(mem, 1928bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1929bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1930bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1931bv64) == 0bv8);
-  free ensures (memory_load64_le(mem, 69672bv64) == 69672bv64);
-  free ensures (memory_load64_le(mem, 69584bv64) == 1876bv64);
+  free ensures (memory_load32_le(mem, 1928bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69056bv64) == 1872bv64);
   free ensures (memory_load64_le(mem, 69064bv64) == 1792bv64);
+  free ensures (memory_load64_le(mem, 69584bv64) == 1876bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 69684bv64);
+  free ensures (memory_load64_le(mem, 69672bv64) == 69672bv64);
 
 procedure {:extern} rely_transitive();
   modifies Gamma_mem, mem;
@@ -87,26 +80,20 @@ procedure main();
   modifies Gamma_R0, Gamma_R31, Gamma_R8, Gamma_mem, Gamma_stack, R0, R31, R8, mem, stack;
   free requires (memory_load64_le(mem, 69664bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
-  free requires (memory_load8_le(mem, 1928bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1929bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1930bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1931bv64) == 0bv8);
-  free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
-  free requires (memory_load64_le(mem, 69584bv64) == 1876bv64);
+  free requires (memory_load32_le(mem, 1928bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69056bv64) == 1872bv64);
   free requires (memory_load64_le(mem, 69064bv64) == 1792bv64);
+  free requires (memory_load64_le(mem, 69584bv64) == 1876bv64);
   free requires (memory_load64_le(mem, 69592bv64) == 69684bv64);
+  free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
   free ensures (Gamma_R31 == old(Gamma_R31));
   free ensures (R31 == old(R31));
-  free ensures (memory_load8_le(mem, 1928bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1929bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1930bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1931bv64) == 0bv8);
-  free ensures (memory_load64_le(mem, 69672bv64) == 69672bv64);
-  free ensures (memory_load64_le(mem, 69584bv64) == 1876bv64);
+  free ensures (memory_load32_le(mem, 1928bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69056bv64) == 1872bv64);
   free ensures (memory_load64_le(mem, 69064bv64) == 1792bv64);
+  free ensures (memory_load64_le(mem, 69584bv64) == 1876bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 69684bv64);
+  free ensures (memory_load64_le(mem, 69672bv64) == 69672bv64);
 
 implementation main()
 {
@@ -121,7 +108,6 @@ implementation main()
     call rely();
     assert (L(mem, R8) ==> true);
     mem, Gamma_mem := memory_store32_le(mem, R8, 0bv32), gamma_store32(Gamma_mem, R8, true);
-    assert true;
     assume {:captureState "1892$0"} true;
     call rely();
     R0, Gamma_R0 := zero_extend32_32(memory_load32_le(mem, R8)), (gamma_load32(Gamma_mem, R8) || L(mem, R8));
diff --git a/src/test/correct/basic_arrays_read/gcc/basic_arrays_read.expected b/src/test/correct/basic_arrays_read/gcc/basic_arrays_read.expected
index cbb6c5f36..7c0e78f1a 100644
--- a/src/test/correct/basic_arrays_read/gcc/basic_arrays_read.expected
+++ b/src/test/correct/basic_arrays_read/gcc/basic_arrays_read.expected
@@ -4,7 +4,7 @@ var {:extern} R0: bv64;
 var {:extern} mem: [bv64]bv8;
 const {:extern} $arr_addr: bv64;
 axiom ($arr_addr == 69656bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
   (if ((index == bvadd64($arr_addr, 4bv64)) || (index == bvadd64($arr_addr, 0bv64))) then false else false)
 }
 
@@ -25,10 +25,6 @@ function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv6
   (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
-}
-
 function {:extern} memory_store32_le(memory: [bv64]bv8, index: bv64, value: bv32) returns ([bv64]bv8) {
   memory[index := value[8:0]][bvadd64(index, 1bv64) := value[16:8]][bvadd64(index, 2bv64) := value[24:16]][bvadd64(index, 3bv64) := value[32:24]]
 }
@@ -38,10 +34,7 @@ procedure {:extern} rely();
   modifies Gamma_mem, mem;
   ensures (forall i: bv64 :: (((mem[i] == old(mem[i])) ==> (Gamma_mem[i] == old(Gamma_mem[i])))));
   ensures (old(memory_load32_le(mem, bvadd64($arr_addr, 0bv64))) == memory_load32_le(mem, bvadd64($arr_addr, 0bv64)));
-  free ensures (memory_load8_le(mem, 1860bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1861bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1862bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1863bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1860bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69016bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69024bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69616bv64) == 1812bv64);
@@ -76,18 +69,12 @@ procedure main();
   modifies Gamma_R0, Gamma_mem, R0, mem;
   free requires (memory_load64_le(mem, 69632bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free requires (memory_load8_le(mem, 1860bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1861bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1862bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1863bv64) == 0bv8);
+  free requires (memory_load32_le(mem, 1860bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69016bv64) == 1808bv64);
   free requires (memory_load64_le(mem, 69024bv64) == 1728bv64);
   free requires (memory_load64_le(mem, 69616bv64) == 1812bv64);
   free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free ensures (memory_load8_le(mem, 1860bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1861bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1862bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1863bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1860bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69016bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69024bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69616bv64) == 1812bv64);
@@ -102,7 +89,6 @@ implementation main()
     call rely();
     assert (L(mem, R0) ==> true);
     mem, Gamma_mem := memory_store32_le(mem, R0, 0bv32), gamma_store32(Gamma_mem, R0, true);
-    assert true;
     assume {:captureState "%000002d6"} true;
     R0, Gamma_R0 := 69632bv64, true;
     R0, Gamma_R0 := bvadd64(R0, 24bv64), Gamma_R0;
diff --git a/src/test/correct/basic_arrays_read/gcc/basic_arrays_read_gtirb.expected b/src/test/correct/basic_arrays_read/gcc/basic_arrays_read_gtirb.expected
index 5a1213e87..c0bf7949f 100644
--- a/src/test/correct/basic_arrays_read/gcc/basic_arrays_read_gtirb.expected
+++ b/src/test/correct/basic_arrays_read/gcc/basic_arrays_read_gtirb.expected
@@ -4,7 +4,7 @@ var {:extern} R0: bv64;
 var {:extern} mem: [bv64]bv8;
 const {:extern} $arr_addr: bv64;
 axiom ($arr_addr == 69656bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
   (if ((index == bvadd64($arr_addr, 4bv64)) || (index == bvadd64($arr_addr, 0bv64))) then false else false)
 }
 
@@ -25,10 +25,6 @@ function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv6
   (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
-}
-
 function {:extern} memory_store32_le(memory: [bv64]bv8, index: bv64, value: bv32) returns ([bv64]bv8) {
   memory[index := value[8:0]][bvadd64(index, 1bv64) := value[16:8]][bvadd64(index, 2bv64) := value[24:16]][bvadd64(index, 3bv64) := value[32:24]]
 }
@@ -38,10 +34,7 @@ procedure {:extern} rely();
   modifies Gamma_mem, mem;
   ensures (forall i: bv64 :: (((mem[i] == old(mem[i])) ==> (Gamma_mem[i] == old(Gamma_mem[i])))));
   ensures (old(memory_load32_le(mem, bvadd64($arr_addr, 0bv64))) == memory_load32_le(mem, bvadd64($arr_addr, 0bv64)));
-  free ensures (memory_load8_le(mem, 1860bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1861bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1862bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1863bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1860bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69016bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69024bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69616bv64) == 1812bv64);
@@ -76,18 +69,12 @@ procedure main();
   modifies Gamma_R0, Gamma_mem, R0, mem;
   free requires (memory_load64_le(mem, 69632bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free requires (memory_load8_le(mem, 1860bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1861bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1862bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1863bv64) == 0bv8);
+  free requires (memory_load32_le(mem, 1860bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69016bv64) == 1808bv64);
   free requires (memory_load64_le(mem, 69024bv64) == 1728bv64);
   free requires (memory_load64_le(mem, 69616bv64) == 1812bv64);
   free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free ensures (memory_load8_le(mem, 1860bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1861bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1862bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1863bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1860bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69016bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69024bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69616bv64) == 1812bv64);
@@ -102,7 +89,6 @@ implementation main()
     call rely();
     assert (L(mem, R0) ==> true);
     mem, Gamma_mem := memory_store32_le(mem, R0, 0bv32), gamma_store32(Gamma_mem, R0, true);
-    assert true;
     assume {:captureState "1820$0"} true;
     R0, Gamma_R0 := 69632bv64, true;
     R0, Gamma_R0 := bvadd64(R0, 24bv64), Gamma_R0;
diff --git a/src/test/correct/basic_arrays_read/gcc_pic/basic_arrays_read.expected b/src/test/correct/basic_arrays_read/gcc_pic/basic_arrays_read.expected
index 67045570e..99eaf7326 100644
--- a/src/test/correct/basic_arrays_read/gcc_pic/basic_arrays_read.expected
+++ b/src/test/correct/basic_arrays_read/gcc_pic/basic_arrays_read.expected
@@ -4,7 +4,7 @@ var {:extern} R0: bv64;
 var {:extern} mem: [bv64]bv8;
 const {:extern} $arr_addr: bv64;
 axiom ($arr_addr == 69656bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
   (if ((index == bvadd64($arr_addr, 4bv64)) || (index == bvadd64($arr_addr, 0bv64))) then false else false)
 }
 
@@ -29,10 +29,6 @@ function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv6
   (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
-}
-
 function {:extern} memory_store32_le(memory: [bv64]bv8, index: bv64, value: bv32) returns ([bv64]bv8) {
   memory[index := value[8:0]][bvadd64(index, 1bv64) := value[16:8]][bvadd64(index, 2bv64) := value[24:16]][bvadd64(index, 3bv64) := value[32:24]]
 }
@@ -42,15 +38,12 @@ procedure {:extern} rely();
   modifies Gamma_mem, mem;
   ensures (forall i: bv64 :: (((mem[i] == old(mem[i])) ==> (Gamma_mem[i] == old(Gamma_mem[i])))));
   ensures (old(memory_load32_le(mem, bvadd64($arr_addr, 0bv64))) == memory_load32_le(mem, bvadd64($arr_addr, 0bv64)));
-  free ensures (memory_load8_le(mem, 1924bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1925bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1926bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1927bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1924bv64) == 131073bv32);
+  free ensures (memory_load64_le(mem, 69008bv64) == 1872bv64);
+  free ensures (memory_load64_le(mem, 69016bv64) == 1792bv64);
   free ensures (memory_load64_le(mem, 69608bv64) == 1876bv64);
-  free ensures (memory_load64_le(mem, 69640bv64) == 69640bv64);
   free ensures (memory_load64_le(mem, 69616bv64) == 69656bv64);
-  free ensures (memory_load64_le(mem, 69016bv64) == 1792bv64);
-  free ensures (memory_load64_le(mem, 69008bv64) == 1872bv64);
+  free ensures (memory_load64_le(mem, 69640bv64) == 69640bv64);
 
 procedure {:extern} rely_transitive();
   modifies Gamma_mem, mem;
@@ -81,24 +74,18 @@ procedure main();
   modifies Gamma_R0, Gamma_mem, R0, mem;
   free requires (memory_load64_le(mem, 69632bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free requires (memory_load8_le(mem, 1924bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1925bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1926bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1927bv64) == 0bv8);
+  free requires (memory_load32_le(mem, 1924bv64) == 131073bv32);
+  free requires (memory_load64_le(mem, 69008bv64) == 1872bv64);
+  free requires (memory_load64_le(mem, 69016bv64) == 1792bv64);
   free requires (memory_load64_le(mem, 69608bv64) == 1876bv64);
-  free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
   free requires (memory_load64_le(mem, 69616bv64) == 69656bv64);
-  free requires (memory_load64_le(mem, 69016bv64) == 1792bv64);
-  free requires (memory_load64_le(mem, 69008bv64) == 1872bv64);
-  free ensures (memory_load8_le(mem, 1924bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1925bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1926bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1927bv64) == 0bv8);
+  free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
+  free ensures (memory_load32_le(mem, 1924bv64) == 131073bv32);
+  free ensures (memory_load64_le(mem, 69008bv64) == 1872bv64);
+  free ensures (memory_load64_le(mem, 69016bv64) == 1792bv64);
   free ensures (memory_load64_le(mem, 69608bv64) == 1876bv64);
-  free ensures (memory_load64_le(mem, 69640bv64) == 69640bv64);
   free ensures (memory_load64_le(mem, 69616bv64) == 69656bv64);
-  free ensures (memory_load64_le(mem, 69016bv64) == 1792bv64);
-  free ensures (memory_load64_le(mem, 69008bv64) == 1872bv64);
+  free ensures (memory_load64_le(mem, 69640bv64) == 69640bv64);
 
 implementation main()
 {
@@ -110,7 +97,6 @@ implementation main()
     call rely();
     assert (L(mem, R0) ==> true);
     mem, Gamma_mem := memory_store32_le(mem, R0, 0bv32), gamma_store32(Gamma_mem, R0, true);
-    assert true;
     assume {:captureState "%000002d7"} true;
     R0, Gamma_R0 := 65536bv64, true;
     call rely();
diff --git a/src/test/correct/basic_arrays_read/gcc_pic/basic_arrays_read_gtirb.expected b/src/test/correct/basic_arrays_read/gcc_pic/basic_arrays_read_gtirb.expected
index 1cb1a7c77..9015de36a 100644
--- a/src/test/correct/basic_arrays_read/gcc_pic/basic_arrays_read_gtirb.expected
+++ b/src/test/correct/basic_arrays_read/gcc_pic/basic_arrays_read_gtirb.expected
@@ -4,7 +4,7 @@ var {:extern} R0: bv64;
 var {:extern} mem: [bv64]bv8;
 const {:extern} $arr_addr: bv64;
 axiom ($arr_addr == 69656bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
   (if ((index == bvadd64($arr_addr, 4bv64)) || (index == bvadd64($arr_addr, 0bv64))) then false else false)
 }
 
@@ -29,10 +29,6 @@ function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv6
   (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
-}
-
 function {:extern} memory_store32_le(memory: [bv64]bv8, index: bv64, value: bv32) returns ([bv64]bv8) {
   memory[index := value[8:0]][bvadd64(index, 1bv64) := value[16:8]][bvadd64(index, 2bv64) := value[24:16]][bvadd64(index, 3bv64) := value[32:24]]
 }
@@ -42,15 +38,12 @@ procedure {:extern} rely();
   modifies Gamma_mem, mem;
   ensures (forall i: bv64 :: (((mem[i] == old(mem[i])) ==> (Gamma_mem[i] == old(Gamma_mem[i])))));
   ensures (old(memory_load32_le(mem, bvadd64($arr_addr, 0bv64))) == memory_load32_le(mem, bvadd64($arr_addr, 0bv64)));
-  free ensures (memory_load8_le(mem, 1924bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1925bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1926bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1927bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1924bv64) == 131073bv32);
+  free ensures (memory_load64_le(mem, 69008bv64) == 1872bv64);
+  free ensures (memory_load64_le(mem, 69016bv64) == 1792bv64);
   free ensures (memory_load64_le(mem, 69608bv64) == 1876bv64);
-  free ensures (memory_load64_le(mem, 69640bv64) == 69640bv64);
   free ensures (memory_load64_le(mem, 69616bv64) == 69656bv64);
-  free ensures (memory_load64_le(mem, 69016bv64) == 1792bv64);
-  free ensures (memory_load64_le(mem, 69008bv64) == 1872bv64);
+  free ensures (memory_load64_le(mem, 69640bv64) == 69640bv64);
 
 procedure {:extern} rely_transitive();
   modifies Gamma_mem, mem;
@@ -81,24 +74,18 @@ procedure main();
   modifies Gamma_R0, Gamma_mem, R0, mem;
   free requires (memory_load64_le(mem, 69632bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free requires (memory_load8_le(mem, 1924bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1925bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1926bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1927bv64) == 0bv8);
+  free requires (memory_load32_le(mem, 1924bv64) == 131073bv32);
+  free requires (memory_load64_le(mem, 69008bv64) == 1872bv64);
+  free requires (memory_load64_le(mem, 69016bv64) == 1792bv64);
   free requires (memory_load64_le(mem, 69608bv64) == 1876bv64);
-  free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
   free requires (memory_load64_le(mem, 69616bv64) == 69656bv64);
-  free requires (memory_load64_le(mem, 69016bv64) == 1792bv64);
-  free requires (memory_load64_le(mem, 69008bv64) == 1872bv64);
-  free ensures (memory_load8_le(mem, 1924bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1925bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1926bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1927bv64) == 0bv8);
+  free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
+  free ensures (memory_load32_le(mem, 1924bv64) == 131073bv32);
+  free ensures (memory_load64_le(mem, 69008bv64) == 1872bv64);
+  free ensures (memory_load64_le(mem, 69016bv64) == 1792bv64);
   free ensures (memory_load64_le(mem, 69608bv64) == 1876bv64);
-  free ensures (memory_load64_le(mem, 69640bv64) == 69640bv64);
   free ensures (memory_load64_le(mem, 69616bv64) == 69656bv64);
-  free ensures (memory_load64_le(mem, 69016bv64) == 1792bv64);
-  free ensures (memory_load64_le(mem, 69008bv64) == 1872bv64);
+  free ensures (memory_load64_le(mem, 69640bv64) == 69640bv64);
 
 implementation main()
 {
@@ -110,7 +97,6 @@ implementation main()
     call rely();
     assert (L(mem, R0) ==> true);
     mem, Gamma_mem := memory_store32_le(mem, R0, 0bv32), gamma_store32(Gamma_mem, R0, true);
-    assert true;
     assume {:captureState "1884$0"} true;
     R0, Gamma_R0 := 65536bv64, true;
     call rely();
diff --git a/src/test/correct/basic_arrays_write/clang/basic_arrays_write.expected b/src/test/correct/basic_arrays_write/clang/basic_arrays_write.expected
index 61947ed82..02898a966 100644
--- a/src/test/correct/basic_arrays_write/clang/basic_arrays_write.expected
+++ b/src/test/correct/basic_arrays_write/clang/basic_arrays_write.expected
@@ -12,7 +12,7 @@ var {:extern} mem: [bv64]bv8;
 var {:extern} stack: [bv64]bv8;
 const {:extern} $arr_addr: bv64;
 axiom ($arr_addr == 69684bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
   (if ((index == bvadd64($arr_addr, 4bv64)) || (index == bvadd64($arr_addr, 0bv64))) then false else false)
 }
 
@@ -33,10 +33,6 @@ function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv6
   (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
-}
-
 function {:extern} memory_store32_le(memory: [bv64]bv8, index: bv64, value: bv32) returns ([bv64]bv8) {
   memory[index := value[8:0]][bvadd64(index, 1bv64) := value[16:8]][bvadd64(index, 2bv64) := value[24:16]][bvadd64(index, 3bv64) := value[32:24]]
 }
@@ -46,10 +42,7 @@ procedure {:extern} rely();
   modifies Gamma_mem, mem;
   ensures (forall i: bv64 :: (((mem[i] == old(mem[i])) ==> (Gamma_mem[i] == old(Gamma_mem[i])))));
   ensures true;
-  free ensures (memory_load8_le(mem, 1868bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1869bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1870bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1871bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1868bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1812bv64);
@@ -85,20 +78,14 @@ procedure main();
   requires (Gamma_R0 == false);
   free requires (memory_load64_le(mem, 69664bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
-  free requires (memory_load8_le(mem, 1868bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1869bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1870bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1871bv64) == 0bv8);
+  free requires (memory_load32_le(mem, 1868bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free requires (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free requires (memory_load64_le(mem, 69592bv64) == 1812bv64);
   free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
   free ensures (Gamma_R31 == old(Gamma_R31));
   free ensures (R31 == old(R31));
-  free ensures (memory_load8_le(mem, 1868bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1869bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1870bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1871bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1868bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1812bv64);
diff --git a/src/test/correct/basic_arrays_write/clang/basic_arrays_write_gtirb.expected b/src/test/correct/basic_arrays_write/clang/basic_arrays_write_gtirb.expected
index e8ee268ce..c0e68cb5f 100644
--- a/src/test/correct/basic_arrays_write/clang/basic_arrays_write_gtirb.expected
+++ b/src/test/correct/basic_arrays_write/clang/basic_arrays_write_gtirb.expected
@@ -12,7 +12,7 @@ var {:extern} mem: [bv64]bv8;
 var {:extern} stack: [bv64]bv8;
 const {:extern} $arr_addr: bv64;
 axiom ($arr_addr == 69684bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
   (if ((index == bvadd64($arr_addr, 4bv64)) || (index == bvadd64($arr_addr, 0bv64))) then false else false)
 }
 
@@ -33,10 +33,6 @@ function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv6
   (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
-}
-
 function {:extern} memory_store32_le(memory: [bv64]bv8, index: bv64, value: bv32) returns ([bv64]bv8) {
   memory[index := value[8:0]][bvadd64(index, 1bv64) := value[16:8]][bvadd64(index, 2bv64) := value[24:16]][bvadd64(index, 3bv64) := value[32:24]]
 }
@@ -46,10 +42,7 @@ procedure {:extern} rely();
   modifies Gamma_mem, mem;
   ensures (forall i: bv64 :: (((mem[i] == old(mem[i])) ==> (Gamma_mem[i] == old(Gamma_mem[i])))));
   ensures true;
-  free ensures (memory_load8_le(mem, 1868bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1869bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1870bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1871bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1868bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1812bv64);
@@ -85,20 +78,14 @@ procedure main();
   requires (Gamma_R0 == false);
   free requires (memory_load64_le(mem, 69664bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
-  free requires (memory_load8_le(mem, 1868bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1869bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1870bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1871bv64) == 0bv8);
+  free requires (memory_load32_le(mem, 1868bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free requires (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free requires (memory_load64_le(mem, 69592bv64) == 1812bv64);
   free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
   free ensures (Gamma_R31 == old(Gamma_R31));
   free ensures (R31 == old(R31));
-  free ensures (memory_load8_le(mem, 1868bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1869bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1870bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1871bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1868bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1812bv64);
diff --git a/src/test/correct/basic_arrays_write/clang_O2/basic_arrays_write.expected b/src/test/correct/basic_arrays_write/clang_O2/basic_arrays_write.expected
index a86300943..cd666691a 100644
--- a/src/test/correct/basic_arrays_write/clang_O2/basic_arrays_write.expected
+++ b/src/test/correct/basic_arrays_write/clang_O2/basic_arrays_write.expected
@@ -8,7 +8,7 @@ var {:extern} R9: bv64;
 var {:extern} mem: [bv64]bv8;
 const {:extern} $arr_addr: bv64;
 axiom ($arr_addr == 69684bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
   (if ((index == bvadd64($arr_addr, 4bv64)) || (index == bvadd64($arr_addr, 0bv64))) then false else false)
 }
 
@@ -25,10 +25,6 @@ function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv6
   (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
-}
-
 function {:extern} memory_store32_le(memory: [bv64]bv8, index: bv64, value: bv32) returns ([bv64]bv8) {
   memory[index := value[8:0]][bvadd64(index, 1bv64) := value[16:8]][bvadd64(index, 2bv64) := value[24:16]][bvadd64(index, 3bv64) := value[32:24]]
 }
@@ -38,10 +34,7 @@ procedure {:extern} rely();
   modifies Gamma_mem, mem;
   ensures (forall i: bv64 :: (((mem[i] == old(mem[i])) ==> (Gamma_mem[i] == old(Gamma_mem[i])))));
   ensures true;
-  free ensures (memory_load8_le(mem, 1852bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1853bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1854bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1855bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1852bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1812bv64);
@@ -77,18 +70,12 @@ procedure main();
   requires (Gamma_R0 == false);
   free requires (memory_load64_le(mem, 69664bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
-  free requires (memory_load8_le(mem, 1852bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1853bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1854bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1855bv64) == 0bv8);
+  free requires (memory_load32_le(mem, 1852bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free requires (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free requires (memory_load64_le(mem, 69592bv64) == 1812bv64);
   free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
-  free ensures (memory_load8_le(mem, 1852bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1853bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1854bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1855bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1852bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1812bv64);
diff --git a/src/test/correct/basic_arrays_write/clang_O2/basic_arrays_write_gtirb.expected b/src/test/correct/basic_arrays_write/clang_O2/basic_arrays_write_gtirb.expected
index 4e59a1e8e..7b61c3082 100644
--- a/src/test/correct/basic_arrays_write/clang_O2/basic_arrays_write_gtirb.expected
+++ b/src/test/correct/basic_arrays_write/clang_O2/basic_arrays_write_gtirb.expected
@@ -8,7 +8,7 @@ var {:extern} R9: bv64;
 var {:extern} mem: [bv64]bv8;
 const {:extern} $arr_addr: bv64;
 axiom ($arr_addr == 69684bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
   (if ((index == bvadd64($arr_addr, 4bv64)) || (index == bvadd64($arr_addr, 0bv64))) then false else false)
 }
 
@@ -25,10 +25,6 @@ function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv6
   (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
-}
-
 function {:extern} memory_store32_le(memory: [bv64]bv8, index: bv64, value: bv32) returns ([bv64]bv8) {
   memory[index := value[8:0]][bvadd64(index, 1bv64) := value[16:8]][bvadd64(index, 2bv64) := value[24:16]][bvadd64(index, 3bv64) := value[32:24]]
 }
@@ -38,10 +34,7 @@ procedure {:extern} rely();
   modifies Gamma_mem, mem;
   ensures (forall i: bv64 :: (((mem[i] == old(mem[i])) ==> (Gamma_mem[i] == old(Gamma_mem[i])))));
   ensures true;
-  free ensures (memory_load8_le(mem, 1852bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1853bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1854bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1855bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1852bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1812bv64);
@@ -77,18 +70,12 @@ procedure main();
   requires (Gamma_R0 == false);
   free requires (memory_load64_le(mem, 69664bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
-  free requires (memory_load8_le(mem, 1852bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1853bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1854bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1855bv64) == 0bv8);
+  free requires (memory_load32_le(mem, 1852bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free requires (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free requires (memory_load64_le(mem, 69592bv64) == 1812bv64);
   free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
-  free ensures (memory_load8_le(mem, 1852bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1853bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1854bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1855bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1852bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1812bv64);
diff --git a/src/test/correct/basic_arrays_write/clang_pic/basic_arrays_write.expected b/src/test/correct/basic_arrays_write/clang_pic/basic_arrays_write.expected
index 228ad3272..a9469c047 100644
--- a/src/test/correct/basic_arrays_write/clang_pic/basic_arrays_write.expected
+++ b/src/test/correct/basic_arrays_write/clang_pic/basic_arrays_write.expected
@@ -12,7 +12,7 @@ var {:extern} mem: [bv64]bv8;
 var {:extern} stack: [bv64]bv8;
 const {:extern} $arr_addr: bv64;
 axiom ($arr_addr == 69684bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
   (if ((index == bvadd64($arr_addr, 4bv64)) || (index == bvadd64($arr_addr, 0bv64))) then false else false)
 }
 
@@ -37,10 +37,6 @@ function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv6
   (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
-}
-
 function {:extern} memory_store32_le(memory: [bv64]bv8, index: bv64, value: bv32) returns ([bv64]bv8) {
   memory[index := value[8:0]][bvadd64(index, 1bv64) := value[16:8]][bvadd64(index, 2bv64) := value[24:16]][bvadd64(index, 3bv64) := value[32:24]]
 }
@@ -50,15 +46,12 @@ procedure {:extern} rely();
   modifies Gamma_mem, mem;
   ensures (forall i: bv64 :: (((mem[i] == old(mem[i])) ==> (Gamma_mem[i] == old(Gamma_mem[i])))));
   ensures true;
-  free ensures (memory_load8_le(mem, 1932bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1933bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1934bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1935bv64) == 0bv8);
-  free ensures (memory_load64_le(mem, 69672bv64) == 69672bv64);
-  free ensures (memory_load64_le(mem, 69584bv64) == 1876bv64);
+  free ensures (memory_load32_le(mem, 1932bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69056bv64) == 1872bv64);
   free ensures (memory_load64_le(mem, 69064bv64) == 1792bv64);
+  free ensures (memory_load64_le(mem, 69584bv64) == 1876bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 69684bv64);
+  free ensures (memory_load64_le(mem, 69672bv64) == 69672bv64);
 
 procedure {:extern} rely_transitive();
   modifies Gamma_mem, mem;
@@ -90,26 +83,20 @@ procedure main();
   requires (Gamma_R0 == false);
   free requires (memory_load64_le(mem, 69664bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
-  free requires (memory_load8_le(mem, 1932bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1933bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1934bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1935bv64) == 0bv8);
-  free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
-  free requires (memory_load64_le(mem, 69584bv64) == 1876bv64);
+  free requires (memory_load32_le(mem, 1932bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69056bv64) == 1872bv64);
   free requires (memory_load64_le(mem, 69064bv64) == 1792bv64);
+  free requires (memory_load64_le(mem, 69584bv64) == 1876bv64);
   free requires (memory_load64_le(mem, 69592bv64) == 69684bv64);
+  free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
   free ensures (Gamma_R31 == old(Gamma_R31));
   free ensures (R31 == old(R31));
-  free ensures (memory_load8_le(mem, 1932bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1933bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1934bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1935bv64) == 0bv8);
-  free ensures (memory_load64_le(mem, 69672bv64) == 69672bv64);
-  free ensures (memory_load64_le(mem, 69584bv64) == 1876bv64);
+  free ensures (memory_load32_le(mem, 1932bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69056bv64) == 1872bv64);
   free ensures (memory_load64_le(mem, 69064bv64) == 1792bv64);
+  free ensures (memory_load64_le(mem, 69584bv64) == 1876bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 69684bv64);
+  free ensures (memory_load64_le(mem, 69672bv64) == 69672bv64);
 
 implementation main()
 {
diff --git a/src/test/correct/basic_arrays_write/clang_pic/basic_arrays_write_gtirb.expected b/src/test/correct/basic_arrays_write/clang_pic/basic_arrays_write_gtirb.expected
index d89eb58c2..b6eec67eb 100644
--- a/src/test/correct/basic_arrays_write/clang_pic/basic_arrays_write_gtirb.expected
+++ b/src/test/correct/basic_arrays_write/clang_pic/basic_arrays_write_gtirb.expected
@@ -12,7 +12,7 @@ var {:extern} mem: [bv64]bv8;
 var {:extern} stack: [bv64]bv8;
 const {:extern} $arr_addr: bv64;
 axiom ($arr_addr == 69684bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
   (if ((index == bvadd64($arr_addr, 4bv64)) || (index == bvadd64($arr_addr, 0bv64))) then false else false)
 }
 
@@ -37,10 +37,6 @@ function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv6
   (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
-}
-
 function {:extern} memory_store32_le(memory: [bv64]bv8, index: bv64, value: bv32) returns ([bv64]bv8) {
   memory[index := value[8:0]][bvadd64(index, 1bv64) := value[16:8]][bvadd64(index, 2bv64) := value[24:16]][bvadd64(index, 3bv64) := value[32:24]]
 }
@@ -50,15 +46,12 @@ procedure {:extern} rely();
   modifies Gamma_mem, mem;
   ensures (forall i: bv64 :: (((mem[i] == old(mem[i])) ==> (Gamma_mem[i] == old(Gamma_mem[i])))));
   ensures true;
-  free ensures (memory_load8_le(mem, 1932bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1933bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1934bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1935bv64) == 0bv8);
-  free ensures (memory_load64_le(mem, 69672bv64) == 69672bv64);
-  free ensures (memory_load64_le(mem, 69584bv64) == 1876bv64);
+  free ensures (memory_load32_le(mem, 1932bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69056bv64) == 1872bv64);
   free ensures (memory_load64_le(mem, 69064bv64) == 1792bv64);
+  free ensures (memory_load64_le(mem, 69584bv64) == 1876bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 69684bv64);
+  free ensures (memory_load64_le(mem, 69672bv64) == 69672bv64);
 
 procedure {:extern} rely_transitive();
   modifies Gamma_mem, mem;
@@ -90,26 +83,20 @@ procedure main();
   requires (Gamma_R0 == false);
   free requires (memory_load64_le(mem, 69664bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
-  free requires (memory_load8_le(mem, 1932bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1933bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1934bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1935bv64) == 0bv8);
-  free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
-  free requires (memory_load64_le(mem, 69584bv64) == 1876bv64);
+  free requires (memory_load32_le(mem, 1932bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69056bv64) == 1872bv64);
   free requires (memory_load64_le(mem, 69064bv64) == 1792bv64);
+  free requires (memory_load64_le(mem, 69584bv64) == 1876bv64);
   free requires (memory_load64_le(mem, 69592bv64) == 69684bv64);
+  free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
   free ensures (Gamma_R31 == old(Gamma_R31));
   free ensures (R31 == old(R31));
-  free ensures (memory_load8_le(mem, 1932bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1933bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1934bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1935bv64) == 0bv8);
-  free ensures (memory_load64_le(mem, 69672bv64) == 69672bv64);
-  free ensures (memory_load64_le(mem, 69584bv64) == 1876bv64);
+  free ensures (memory_load32_le(mem, 1932bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69056bv64) == 1872bv64);
   free ensures (memory_load64_le(mem, 69064bv64) == 1792bv64);
+  free ensures (memory_load64_le(mem, 69584bv64) == 1876bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 69684bv64);
+  free ensures (memory_load64_le(mem, 69672bv64) == 69672bv64);
 
 implementation main()
 {
diff --git a/src/test/correct/basic_arrays_write/gcc/basic_arrays_write.expected b/src/test/correct/basic_arrays_write/gcc/basic_arrays_write.expected
index 0dcd266ac..10630740e 100644
--- a/src/test/correct/basic_arrays_write/gcc/basic_arrays_write.expected
+++ b/src/test/correct/basic_arrays_write/gcc/basic_arrays_write.expected
@@ -10,7 +10,7 @@ var {:extern} mem: [bv64]bv8;
 var {:extern} stack: [bv64]bv8;
 const {:extern} $arr_addr: bv64;
 axiom ($arr_addr == 69656bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
   (if ((index == bvadd64($arr_addr, 4bv64)) || (index == bvadd64($arr_addr, 0bv64))) then false else false)
 }
 
@@ -31,10 +31,6 @@ function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv6
   (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
-}
-
 function {:extern} memory_store32_le(memory: [bv64]bv8, index: bv64, value: bv32) returns ([bv64]bv8) {
   memory[index := value[8:0]][bvadd64(index, 1bv64) := value[16:8]][bvadd64(index, 2bv64) := value[24:16]][bvadd64(index, 3bv64) := value[32:24]]
 }
@@ -44,10 +40,7 @@ procedure {:extern} rely();
   modifies Gamma_mem, mem;
   ensures (forall i: bv64 :: (((mem[i] == old(mem[i])) ==> (Gamma_mem[i] == old(Gamma_mem[i])))));
   ensures true;
-  free ensures (memory_load8_le(mem, 1868bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1869bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1870bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1871bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1868bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69016bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69024bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69616bv64) == 1812bv64);
@@ -83,20 +76,14 @@ procedure main();
   requires (Gamma_R0 == false);
   free requires (memory_load64_le(mem, 69632bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free requires (memory_load8_le(mem, 1868bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1869bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1870bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1871bv64) == 0bv8);
+  free requires (memory_load32_le(mem, 1868bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69016bv64) == 1808bv64);
   free requires (memory_load64_le(mem, 69024bv64) == 1728bv64);
   free requires (memory_load64_le(mem, 69616bv64) == 1812bv64);
   free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
   free ensures (Gamma_R31 == old(Gamma_R31));
   free ensures (R31 == old(R31));
-  free ensures (memory_load8_le(mem, 1868bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1869bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1870bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1871bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1868bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69016bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69024bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69616bv64) == 1812bv64);
diff --git a/src/test/correct/basic_arrays_write/gcc/basic_arrays_write_gtirb.expected b/src/test/correct/basic_arrays_write/gcc/basic_arrays_write_gtirb.expected
index db3755058..f2284d404 100644
--- a/src/test/correct/basic_arrays_write/gcc/basic_arrays_write_gtirb.expected
+++ b/src/test/correct/basic_arrays_write/gcc/basic_arrays_write_gtirb.expected
@@ -10,7 +10,7 @@ var {:extern} mem: [bv64]bv8;
 var {:extern} stack: [bv64]bv8;
 const {:extern} $arr_addr: bv64;
 axiom ($arr_addr == 69656bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
   (if ((index == bvadd64($arr_addr, 4bv64)) || (index == bvadd64($arr_addr, 0bv64))) then false else false)
 }
 
@@ -31,10 +31,6 @@ function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv6
   (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
-}
-
 function {:extern} memory_store32_le(memory: [bv64]bv8, index: bv64, value: bv32) returns ([bv64]bv8) {
   memory[index := value[8:0]][bvadd64(index, 1bv64) := value[16:8]][bvadd64(index, 2bv64) := value[24:16]][bvadd64(index, 3bv64) := value[32:24]]
 }
@@ -44,10 +40,7 @@ procedure {:extern} rely();
   modifies Gamma_mem, mem;
   ensures (forall i: bv64 :: (((mem[i] == old(mem[i])) ==> (Gamma_mem[i] == old(Gamma_mem[i])))));
   ensures true;
-  free ensures (memory_load8_le(mem, 1868bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1869bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1870bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1871bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1868bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69016bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69024bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69616bv64) == 1812bv64);
@@ -83,20 +76,14 @@ procedure main();
   requires (Gamma_R0 == false);
   free requires (memory_load64_le(mem, 69632bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free requires (memory_load8_le(mem, 1868bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1869bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1870bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1871bv64) == 0bv8);
+  free requires (memory_load32_le(mem, 1868bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69016bv64) == 1808bv64);
   free requires (memory_load64_le(mem, 69024bv64) == 1728bv64);
   free requires (memory_load64_le(mem, 69616bv64) == 1812bv64);
   free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
   free ensures (Gamma_R31 == old(Gamma_R31));
   free ensures (R31 == old(R31));
-  free ensures (memory_load8_le(mem, 1868bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1869bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1870bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1871bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1868bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69016bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69024bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69616bv64) == 1812bv64);
diff --git a/src/test/correct/basic_arrays_write/gcc_O2/basic_arrays_write.expected b/src/test/correct/basic_arrays_write/gcc_O2/basic_arrays_write.expected
index 8f533dbc6..846543f7b 100644
--- a/src/test/correct/basic_arrays_write/gcc_O2/basic_arrays_write.expected
+++ b/src/test/correct/basic_arrays_write/gcc_O2/basic_arrays_write.expected
@@ -8,7 +8,7 @@ var {:extern} R2: bv64;
 var {:extern} mem: [bv64]bv8;
 const {:extern} $arr_addr: bv64;
 axiom ($arr_addr == 69656bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
   (if ((index == bvadd64($arr_addr, 4bv64)) || (index == bvadd64($arr_addr, 0bv64))) then false else false)
 }
 
@@ -25,10 +25,6 @@ function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv6
   (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
-}
-
 function {:extern} memory_store32_le(memory: [bv64]bv8, index: bv64, value: bv32) returns ([bv64]bv8) {
   memory[index := value[8:0]][bvadd64(index, 1bv64) := value[16:8]][bvadd64(index, 2bv64) := value[24:16]][bvadd64(index, 3bv64) := value[32:24]]
 }
@@ -38,10 +34,7 @@ procedure {:extern} rely();
   modifies Gamma_mem, mem;
   ensures (forall i: bv64 :: (((mem[i] == old(mem[i])) ==> (Gamma_mem[i] == old(Gamma_mem[i])))));
   ensures true;
-  free ensures (memory_load8_le(mem, 1896bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1897bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1898bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1899bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1896bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69016bv64) == 1872bv64);
   free ensures (memory_load64_le(mem, 69024bv64) == 1792bv64);
   free ensures (memory_load64_le(mem, 69616bv64) == 1536bv64);
@@ -77,18 +70,12 @@ procedure main();
   requires (Gamma_R0 == false);
   free requires (memory_load64_le(mem, 69632bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free requires (memory_load8_le(mem, 1896bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1897bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1898bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1899bv64) == 0bv8);
+  free requires (memory_load32_le(mem, 1896bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69016bv64) == 1872bv64);
   free requires (memory_load64_le(mem, 69024bv64) == 1792bv64);
   free requires (memory_load64_le(mem, 69616bv64) == 1536bv64);
   free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free ensures (memory_load8_le(mem, 1896bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1897bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1898bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1899bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1896bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69016bv64) == 1872bv64);
   free ensures (memory_load64_le(mem, 69024bv64) == 1792bv64);
   free ensures (memory_load64_le(mem, 69616bv64) == 1536bv64);
diff --git a/src/test/correct/basic_arrays_write/gcc_O2/basic_arrays_write_gtirb.expected b/src/test/correct/basic_arrays_write/gcc_O2/basic_arrays_write_gtirb.expected
index b212ef9a6..0fe8d5e9c 100644
--- a/src/test/correct/basic_arrays_write/gcc_O2/basic_arrays_write_gtirb.expected
+++ b/src/test/correct/basic_arrays_write/gcc_O2/basic_arrays_write_gtirb.expected
@@ -8,7 +8,7 @@ var {:extern} R2: bv64;
 var {:extern} mem: [bv64]bv8;
 const {:extern} $arr_addr: bv64;
 axiom ($arr_addr == 69656bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
   (if ((index == bvadd64($arr_addr, 4bv64)) || (index == bvadd64($arr_addr, 0bv64))) then false else false)
 }
 
@@ -25,10 +25,6 @@ function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv6
   (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
-}
-
 function {:extern} memory_store32_le(memory: [bv64]bv8, index: bv64, value: bv32) returns ([bv64]bv8) {
   memory[index := value[8:0]][bvadd64(index, 1bv64) := value[16:8]][bvadd64(index, 2bv64) := value[24:16]][bvadd64(index, 3bv64) := value[32:24]]
 }
@@ -38,10 +34,7 @@ procedure {:extern} rely();
   modifies Gamma_mem, mem;
   ensures (forall i: bv64 :: (((mem[i] == old(mem[i])) ==> (Gamma_mem[i] == old(Gamma_mem[i])))));
   ensures true;
-  free ensures (memory_load8_le(mem, 1896bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1897bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1898bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1899bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1896bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69016bv64) == 1872bv64);
   free ensures (memory_load64_le(mem, 69024bv64) == 1792bv64);
   free ensures (memory_load64_le(mem, 69616bv64) == 1536bv64);
@@ -77,18 +70,12 @@ procedure main();
   requires (Gamma_R0 == false);
   free requires (memory_load64_le(mem, 69632bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free requires (memory_load8_le(mem, 1896bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1897bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1898bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1899bv64) == 0bv8);
+  free requires (memory_load32_le(mem, 1896bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69016bv64) == 1872bv64);
   free requires (memory_load64_le(mem, 69024bv64) == 1792bv64);
   free requires (memory_load64_le(mem, 69616bv64) == 1536bv64);
   free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free ensures (memory_load8_le(mem, 1896bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1897bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1898bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1899bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1896bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69016bv64) == 1872bv64);
   free ensures (memory_load64_le(mem, 69024bv64) == 1792bv64);
   free ensures (memory_load64_le(mem, 69616bv64) == 1536bv64);
diff --git a/src/test/correct/basic_arrays_write/gcc_pic/basic_arrays_write.expected b/src/test/correct/basic_arrays_write/gcc_pic/basic_arrays_write.expected
index 40aa5a8db..244532440 100644
--- a/src/test/correct/basic_arrays_write/gcc_pic/basic_arrays_write.expected
+++ b/src/test/correct/basic_arrays_write/gcc_pic/basic_arrays_write.expected
@@ -10,7 +10,7 @@ var {:extern} mem: [bv64]bv8;
 var {:extern} stack: [bv64]bv8;
 const {:extern} $arr_addr: bv64;
 axiom ($arr_addr == 69656bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
   (if ((index == bvadd64($arr_addr, 4bv64)) || (index == bvadd64($arr_addr, 0bv64))) then false else false)
 }
 
@@ -35,10 +35,6 @@ function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv6
   (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
-}
-
 function {:extern} memory_store32_le(memory: [bv64]bv8, index: bv64, value: bv32) returns ([bv64]bv8) {
   memory[index := value[8:0]][bvadd64(index, 1bv64) := value[16:8]][bvadd64(index, 2bv64) := value[24:16]][bvadd64(index, 3bv64) := value[32:24]]
 }
@@ -48,15 +44,12 @@ procedure {:extern} rely();
   modifies Gamma_mem, mem;
   ensures (forall i: bv64 :: (((mem[i] == old(mem[i])) ==> (Gamma_mem[i] == old(Gamma_mem[i])))));
   ensures true;
-  free ensures (memory_load8_le(mem, 1932bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1933bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1934bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1935bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1932bv64) == 131073bv32);
+  free ensures (memory_load64_le(mem, 69008bv64) == 1872bv64);
+  free ensures (memory_load64_le(mem, 69016bv64) == 1792bv64);
   free ensures (memory_load64_le(mem, 69608bv64) == 1876bv64);
-  free ensures (memory_load64_le(mem, 69640bv64) == 69640bv64);
   free ensures (memory_load64_le(mem, 69616bv64) == 69656bv64);
-  free ensures (memory_load64_le(mem, 69016bv64) == 1792bv64);
-  free ensures (memory_load64_le(mem, 69008bv64) == 1872bv64);
+  free ensures (memory_load64_le(mem, 69640bv64) == 69640bv64);
 
 procedure {:extern} rely_transitive();
   modifies Gamma_mem, mem;
@@ -88,26 +81,20 @@ procedure main();
   requires (Gamma_R0 == false);
   free requires (memory_load64_le(mem, 69632bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free requires (memory_load8_le(mem, 1932bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1933bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1934bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1935bv64) == 0bv8);
+  free requires (memory_load32_le(mem, 1932bv64) == 131073bv32);
+  free requires (memory_load64_le(mem, 69008bv64) == 1872bv64);
+  free requires (memory_load64_le(mem, 69016bv64) == 1792bv64);
   free requires (memory_load64_le(mem, 69608bv64) == 1876bv64);
-  free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
   free requires (memory_load64_le(mem, 69616bv64) == 69656bv64);
-  free requires (memory_load64_le(mem, 69016bv64) == 1792bv64);
-  free requires (memory_load64_le(mem, 69008bv64) == 1872bv64);
+  free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
   free ensures (Gamma_R31 == old(Gamma_R31));
   free ensures (R31 == old(R31));
-  free ensures (memory_load8_le(mem, 1932bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1933bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1934bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1935bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1932bv64) == 131073bv32);
+  free ensures (memory_load64_le(mem, 69008bv64) == 1872bv64);
+  free ensures (memory_load64_le(mem, 69016bv64) == 1792bv64);
   free ensures (memory_load64_le(mem, 69608bv64) == 1876bv64);
-  free ensures (memory_load64_le(mem, 69640bv64) == 69640bv64);
   free ensures (memory_load64_le(mem, 69616bv64) == 69656bv64);
-  free ensures (memory_load64_le(mem, 69016bv64) == 1792bv64);
-  free ensures (memory_load64_le(mem, 69008bv64) == 1872bv64);
+  free ensures (memory_load64_le(mem, 69640bv64) == 69640bv64);
 
 implementation main()
 {
diff --git a/src/test/correct/basic_arrays_write/gcc_pic/basic_arrays_write_gtirb.expected b/src/test/correct/basic_arrays_write/gcc_pic/basic_arrays_write_gtirb.expected
index 76d4e4682..bffaf2ca4 100644
--- a/src/test/correct/basic_arrays_write/gcc_pic/basic_arrays_write_gtirb.expected
+++ b/src/test/correct/basic_arrays_write/gcc_pic/basic_arrays_write_gtirb.expected
@@ -10,7 +10,7 @@ var {:extern} mem: [bv64]bv8;
 var {:extern} stack: [bv64]bv8;
 const {:extern} $arr_addr: bv64;
 axiom ($arr_addr == 69656bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
   (if ((index == bvadd64($arr_addr, 4bv64)) || (index == bvadd64($arr_addr, 0bv64))) then false else false)
 }
 
@@ -35,10 +35,6 @@ function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv6
   (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
-}
-
 function {:extern} memory_store32_le(memory: [bv64]bv8, index: bv64, value: bv32) returns ([bv64]bv8) {
   memory[index := value[8:0]][bvadd64(index, 1bv64) := value[16:8]][bvadd64(index, 2bv64) := value[24:16]][bvadd64(index, 3bv64) := value[32:24]]
 }
@@ -48,15 +44,12 @@ procedure {:extern} rely();
   modifies Gamma_mem, mem;
   ensures (forall i: bv64 :: (((mem[i] == old(mem[i])) ==> (Gamma_mem[i] == old(Gamma_mem[i])))));
   ensures true;
-  free ensures (memory_load8_le(mem, 1932bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1933bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1934bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1935bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1932bv64) == 131073bv32);
+  free ensures (memory_load64_le(mem, 69008bv64) == 1872bv64);
+  free ensures (memory_load64_le(mem, 69016bv64) == 1792bv64);
   free ensures (memory_load64_le(mem, 69608bv64) == 1876bv64);
-  free ensures (memory_load64_le(mem, 69640bv64) == 69640bv64);
   free ensures (memory_load64_le(mem, 69616bv64) == 69656bv64);
-  free ensures (memory_load64_le(mem, 69016bv64) == 1792bv64);
-  free ensures (memory_load64_le(mem, 69008bv64) == 1872bv64);
+  free ensures (memory_load64_le(mem, 69640bv64) == 69640bv64);
 
 procedure {:extern} rely_transitive();
   modifies Gamma_mem, mem;
@@ -88,26 +81,20 @@ procedure main();
   requires (Gamma_R0 == false);
   free requires (memory_load64_le(mem, 69632bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free requires (memory_load8_le(mem, 1932bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1933bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1934bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1935bv64) == 0bv8);
+  free requires (memory_load32_le(mem, 1932bv64) == 131073bv32);
+  free requires (memory_load64_le(mem, 69008bv64) == 1872bv64);
+  free requires (memory_load64_le(mem, 69016bv64) == 1792bv64);
   free requires (memory_load64_le(mem, 69608bv64) == 1876bv64);
-  free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
   free requires (memory_load64_le(mem, 69616bv64) == 69656bv64);
-  free requires (memory_load64_le(mem, 69016bv64) == 1792bv64);
-  free requires (memory_load64_le(mem, 69008bv64) == 1872bv64);
+  free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
   free ensures (Gamma_R31 == old(Gamma_R31));
   free ensures (R31 == old(R31));
-  free ensures (memory_load8_le(mem, 1932bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1933bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1934bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1935bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1932bv64) == 131073bv32);
+  free ensures (memory_load64_le(mem, 69008bv64) == 1872bv64);
+  free ensures (memory_load64_le(mem, 69016bv64) == 1792bv64);
   free ensures (memory_load64_le(mem, 69608bv64) == 1876bv64);
-  free ensures (memory_load64_le(mem, 69640bv64) == 69640bv64);
   free ensures (memory_load64_le(mem, 69616bv64) == 69656bv64);
-  free ensures (memory_load64_le(mem, 69016bv64) == 1792bv64);
-  free ensures (memory_load64_le(mem, 69008bv64) == 1872bv64);
+  free ensures (memory_load64_le(mem, 69640bv64) == 69640bv64);
 
 implementation main()
 {
diff --git a/src/test/correct/basic_assign_assign/clang/basic_assign_assign.expected b/src/test/correct/basic_assign_assign/clang/basic_assign_assign.expected
index ebed184a4..4eac10daa 100644
--- a/src/test/correct/basic_assign_assign/clang/basic_assign_assign.expected
+++ b/src/test/correct/basic_assign_assign/clang/basic_assign_assign.expected
@@ -8,7 +8,7 @@ var {:extern} R9: bv64;
 var {:extern} mem: [bv64]bv8;
 const {:extern} $x_addr: bv64;
 axiom ($x_addr == 69684bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
   (if (index == $x_addr) then true else false)
 }
 
@@ -25,10 +25,6 @@ function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv6
   (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
-}
-
 function {:extern} memory_store32_le(memory: [bv64]bv8, index: bv64, value: bv32) returns ([bv64]bv8) {
   memory[index := value[8:0]][bvadd64(index, 1bv64) := value[16:8]][bvadd64(index, 2bv64) := value[24:16]][bvadd64(index, 3bv64) := value[32:24]]
 }
@@ -37,10 +33,7 @@ procedure {:extern} rely();
   modifies Gamma_mem, mem;
   ensures (forall i: bv64 :: (((mem[i] == old(mem[i])) ==> (Gamma_mem[i] == old(Gamma_mem[i])))));
   ensures (((memory_load32_le(mem, $x_addr) == old(memory_load32_le(mem, $x_addr))) || (memory_load32_le(mem, $x_addr) == 1bv32)) || (memory_load32_le(mem, $x_addr) == 6bv32));
-  free ensures (memory_load8_le(mem, 1852bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1853bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1854bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1855bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1852bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1812bv64);
@@ -76,19 +69,13 @@ procedure main();
   requires (memory_load32_le(mem, $x_addr) == 0bv32);
   free requires (memory_load64_le(mem, 69664bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
-  free requires (memory_load8_le(mem, 1852bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1853bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1854bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1855bv64) == 0bv8);
+  free requires (memory_load32_le(mem, 1852bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free requires (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free requires (memory_load64_le(mem, 69592bv64) == 1812bv64);
   free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
   ensures ((memory_load32_le(mem, $x_addr) == 5bv32) || (memory_load32_le(mem, $x_addr) == 6bv32));
-  free ensures (memory_load8_le(mem, 1852bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1853bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1854bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1855bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1852bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1812bv64);
diff --git a/src/test/correct/basic_assign_assign/clang/basic_assign_assign_gtirb.expected b/src/test/correct/basic_assign_assign/clang/basic_assign_assign_gtirb.expected
index ea5223b80..4b43006e8 100644
--- a/src/test/correct/basic_assign_assign/clang/basic_assign_assign_gtirb.expected
+++ b/src/test/correct/basic_assign_assign/clang/basic_assign_assign_gtirb.expected
@@ -8,7 +8,7 @@ var {:extern} R9: bv64;
 var {:extern} mem: [bv64]bv8;
 const {:extern} $x_addr: bv64;
 axiom ($x_addr == 69684bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
   (if (index == $x_addr) then true else false)
 }
 
@@ -25,10 +25,6 @@ function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv6
   (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
-}
-
 function {:extern} memory_store32_le(memory: [bv64]bv8, index: bv64, value: bv32) returns ([bv64]bv8) {
   memory[index := value[8:0]][bvadd64(index, 1bv64) := value[16:8]][bvadd64(index, 2bv64) := value[24:16]][bvadd64(index, 3bv64) := value[32:24]]
 }
@@ -37,10 +33,7 @@ procedure {:extern} rely();
   modifies Gamma_mem, mem;
   ensures (forall i: bv64 :: (((mem[i] == old(mem[i])) ==> (Gamma_mem[i] == old(Gamma_mem[i])))));
   ensures (((memory_load32_le(mem, $x_addr) == old(memory_load32_le(mem, $x_addr))) || (memory_load32_le(mem, $x_addr) == 1bv32)) || (memory_load32_le(mem, $x_addr) == 6bv32));
-  free ensures (memory_load8_le(mem, 1852bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1853bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1854bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1855bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1852bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1812bv64);
@@ -76,19 +69,13 @@ procedure main();
   requires (memory_load32_le(mem, $x_addr) == 0bv32);
   free requires (memory_load64_le(mem, 69664bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
-  free requires (memory_load8_le(mem, 1852bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1853bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1854bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1855bv64) == 0bv8);
+  free requires (memory_load32_le(mem, 1852bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free requires (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free requires (memory_load64_le(mem, 69592bv64) == 1812bv64);
   free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
   ensures ((memory_load32_le(mem, $x_addr) == 5bv32) || (memory_load32_le(mem, $x_addr) == 6bv32));
-  free ensures (memory_load8_le(mem, 1852bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1853bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1854bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1855bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1852bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1812bv64);
diff --git a/src/test/correct/basic_assign_assign/clang_pic/basic_assign_assign.expected b/src/test/correct/basic_assign_assign/clang_pic/basic_assign_assign.expected
index e25b839d2..254255f97 100644
--- a/src/test/correct/basic_assign_assign/clang_pic/basic_assign_assign.expected
+++ b/src/test/correct/basic_assign_assign/clang_pic/basic_assign_assign.expected
@@ -8,7 +8,7 @@ var {:extern} R9: bv64;
 var {:extern} mem: [bv64]bv8;
 const {:extern} $x_addr: bv64;
 axiom ($x_addr == 69684bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
   (if (index == $x_addr) then true else false)
 }
 
@@ -29,10 +29,6 @@ function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv6
   (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
-}
-
 function {:extern} memory_store32_le(memory: [bv64]bv8, index: bv64, value: bv32) returns ([bv64]bv8) {
   memory[index := value[8:0]][bvadd64(index, 1bv64) := value[16:8]][bvadd64(index, 2bv64) := value[24:16]][bvadd64(index, 3bv64) := value[32:24]]
 }
@@ -41,15 +37,12 @@ procedure {:extern} rely();
   modifies Gamma_mem, mem;
   ensures (forall i: bv64 :: (((mem[i] == old(mem[i])) ==> (Gamma_mem[i] == old(Gamma_mem[i])))));
   ensures (((memory_load32_le(mem, $x_addr) == old(memory_load32_le(mem, $x_addr))) || (memory_load32_le(mem, $x_addr) == 1bv32)) || (memory_load32_le(mem, $x_addr) == 6bv32));
-  free ensures (memory_load8_le(mem, 1920bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1921bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1922bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1923bv64) == 0bv8);
-  free ensures (memory_load64_le(mem, 69576bv64) == 69684bv64);
-  free ensures (memory_load64_le(mem, 69672bv64) == 69672bv64);
+  free ensures (memory_load32_le(mem, 1920bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69056bv64) == 1872bv64);
   free ensures (memory_load64_le(mem, 69064bv64) == 1792bv64);
+  free ensures (memory_load64_le(mem, 69576bv64) == 69684bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1876bv64);
+  free ensures (memory_load64_le(mem, 69672bv64) == 69672bv64);
 
 procedure {:extern} rely_transitive();
   modifies Gamma_mem, mem;
@@ -81,25 +74,19 @@ procedure main();
   requires (memory_load32_le(mem, $x_addr) == 0bv32);
   free requires (memory_load64_le(mem, 69664bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
-  free requires (memory_load8_le(mem, 1920bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1921bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1922bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1923bv64) == 0bv8);
-  free requires (memory_load64_le(mem, 69576bv64) == 69684bv64);
-  free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
+  free requires (memory_load32_le(mem, 1920bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69056bv64) == 1872bv64);
   free requires (memory_load64_le(mem, 69064bv64) == 1792bv64);
+  free requires (memory_load64_le(mem, 69576bv64) == 69684bv64);
   free requires (memory_load64_le(mem, 69592bv64) == 1876bv64);
+  free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
   ensures ((memory_load32_le(mem, $x_addr) == 5bv32) || (memory_load32_le(mem, $x_addr) == 6bv32));
-  free ensures (memory_load8_le(mem, 1920bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1921bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1922bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1923bv64) == 0bv8);
-  free ensures (memory_load64_le(mem, 69576bv64) == 69684bv64);
-  free ensures (memory_load64_le(mem, 69672bv64) == 69672bv64);
+  free ensures (memory_load32_le(mem, 1920bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69056bv64) == 1872bv64);
   free ensures (memory_load64_le(mem, 69064bv64) == 1792bv64);
+  free ensures (memory_load64_le(mem, 69576bv64) == 69684bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1876bv64);
+  free ensures (memory_load64_le(mem, 69672bv64) == 69672bv64);
 
 implementation main()
 {
diff --git a/src/test/correct/basic_assign_assign/clang_pic/basic_assign_assign_gtirb.expected b/src/test/correct/basic_assign_assign/clang_pic/basic_assign_assign_gtirb.expected
index 014cfafa6..e43de6329 100644
--- a/src/test/correct/basic_assign_assign/clang_pic/basic_assign_assign_gtirb.expected
+++ b/src/test/correct/basic_assign_assign/clang_pic/basic_assign_assign_gtirb.expected
@@ -8,7 +8,7 @@ var {:extern} R9: bv64;
 var {:extern} mem: [bv64]bv8;
 const {:extern} $x_addr: bv64;
 axiom ($x_addr == 69684bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
   (if (index == $x_addr) then true else false)
 }
 
@@ -29,10 +29,6 @@ function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv6
   (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
-}
-
 function {:extern} memory_store32_le(memory: [bv64]bv8, index: bv64, value: bv32) returns ([bv64]bv8) {
   memory[index := value[8:0]][bvadd64(index, 1bv64) := value[16:8]][bvadd64(index, 2bv64) := value[24:16]][bvadd64(index, 3bv64) := value[32:24]]
 }
@@ -41,15 +37,12 @@ procedure {:extern} rely();
   modifies Gamma_mem, mem;
   ensures (forall i: bv64 :: (((mem[i] == old(mem[i])) ==> (Gamma_mem[i] == old(Gamma_mem[i])))));
   ensures (((memory_load32_le(mem, $x_addr) == old(memory_load32_le(mem, $x_addr))) || (memory_load32_le(mem, $x_addr) == 1bv32)) || (memory_load32_le(mem, $x_addr) == 6bv32));
-  free ensures (memory_load8_le(mem, 1920bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1921bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1922bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1923bv64) == 0bv8);
-  free ensures (memory_load64_le(mem, 69576bv64) == 69684bv64);
-  free ensures (memory_load64_le(mem, 69672bv64) == 69672bv64);
+  free ensures (memory_load32_le(mem, 1920bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69056bv64) == 1872bv64);
   free ensures (memory_load64_le(mem, 69064bv64) == 1792bv64);
+  free ensures (memory_load64_le(mem, 69576bv64) == 69684bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1876bv64);
+  free ensures (memory_load64_le(mem, 69672bv64) == 69672bv64);
 
 procedure {:extern} rely_transitive();
   modifies Gamma_mem, mem;
@@ -81,25 +74,19 @@ procedure main();
   requires (memory_load32_le(mem, $x_addr) == 0bv32);
   free requires (memory_load64_le(mem, 69664bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
-  free requires (memory_load8_le(mem, 1920bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1921bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1922bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1923bv64) == 0bv8);
-  free requires (memory_load64_le(mem, 69576bv64) == 69684bv64);
-  free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
+  free requires (memory_load32_le(mem, 1920bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69056bv64) == 1872bv64);
   free requires (memory_load64_le(mem, 69064bv64) == 1792bv64);
+  free requires (memory_load64_le(mem, 69576bv64) == 69684bv64);
   free requires (memory_load64_le(mem, 69592bv64) == 1876bv64);
+  free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
   ensures ((memory_load32_le(mem, $x_addr) == 5bv32) || (memory_load32_le(mem, $x_addr) == 6bv32));
-  free ensures (memory_load8_le(mem, 1920bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1921bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1922bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1923bv64) == 0bv8);
-  free ensures (memory_load64_le(mem, 69576bv64) == 69684bv64);
-  free ensures (memory_load64_le(mem, 69672bv64) == 69672bv64);
+  free ensures (memory_load32_le(mem, 1920bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69056bv64) == 1872bv64);
   free ensures (memory_load64_le(mem, 69064bv64) == 1792bv64);
+  free ensures (memory_load64_le(mem, 69576bv64) == 69684bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1876bv64);
+  free ensures (memory_load64_le(mem, 69672bv64) == 69672bv64);
 
 implementation main()
 {
diff --git a/src/test/correct/basic_assign_assign/gcc/basic_assign_assign.expected b/src/test/correct/basic_assign_assign/gcc/basic_assign_assign.expected
index 38c1cfa92..2bc7acf80 100644
--- a/src/test/correct/basic_assign_assign/gcc/basic_assign_assign.expected
+++ b/src/test/correct/basic_assign_assign/gcc/basic_assign_assign.expected
@@ -6,7 +6,7 @@ var {:extern} R1: bv64;
 var {:extern} mem: [bv64]bv8;
 const {:extern} $x_addr: bv64;
 axiom ($x_addr == 69652bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
   (if (index == $x_addr) then true else false)
 }
 
@@ -23,10 +23,6 @@ function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv6
   (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
-}
-
 function {:extern} memory_store32_le(memory: [bv64]bv8, index: bv64, value: bv32) returns ([bv64]bv8) {
   memory[index := value[8:0]][bvadd64(index, 1bv64) := value[16:8]][bvadd64(index, 2bv64) := value[24:16]][bvadd64(index, 3bv64) := value[32:24]]
 }
@@ -35,10 +31,7 @@ procedure {:extern} rely();
   modifies Gamma_mem, mem;
   ensures (forall i: bv64 :: (((mem[i] == old(mem[i])) ==> (Gamma_mem[i] == old(Gamma_mem[i])))));
   ensures (((memory_load32_le(mem, $x_addr) == old(memory_load32_le(mem, $x_addr))) || (memory_load32_le(mem, $x_addr) == 1bv32)) || (memory_load32_le(mem, $x_addr) == 6bv32));
-  free ensures (memory_load8_le(mem, 1856bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1857bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1858bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1859bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1856bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69016bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69024bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69616bv64) == 1812bv64);
@@ -74,19 +67,13 @@ procedure main();
   requires (memory_load32_le(mem, $x_addr) == 0bv32);
   free requires (memory_load64_le(mem, 69632bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free requires (memory_load8_le(mem, 1856bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1857bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1858bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1859bv64) == 0bv8);
+  free requires (memory_load32_le(mem, 1856bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69016bv64) == 1808bv64);
   free requires (memory_load64_le(mem, 69024bv64) == 1728bv64);
   free requires (memory_load64_le(mem, 69616bv64) == 1812bv64);
   free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
   ensures ((memory_load32_le(mem, $x_addr) == 5bv32) || (memory_load32_le(mem, $x_addr) == 6bv32));
-  free ensures (memory_load8_le(mem, 1856bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1857bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1858bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1859bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1856bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69016bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69024bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69616bv64) == 1812bv64);
diff --git a/src/test/correct/basic_assign_assign/gcc/basic_assign_assign_gtirb.expected b/src/test/correct/basic_assign_assign/gcc/basic_assign_assign_gtirb.expected
index 1d976c8ea..163ad1ce6 100644
--- a/src/test/correct/basic_assign_assign/gcc/basic_assign_assign_gtirb.expected
+++ b/src/test/correct/basic_assign_assign/gcc/basic_assign_assign_gtirb.expected
@@ -6,7 +6,7 @@ var {:extern} R1: bv64;
 var {:extern} mem: [bv64]bv8;
 const {:extern} $x_addr: bv64;
 axiom ($x_addr == 69652bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
   (if (index == $x_addr) then true else false)
 }
 
@@ -23,10 +23,6 @@ function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv6
   (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
-}
-
 function {:extern} memory_store32_le(memory: [bv64]bv8, index: bv64, value: bv32) returns ([bv64]bv8) {
   memory[index := value[8:0]][bvadd64(index, 1bv64) := value[16:8]][bvadd64(index, 2bv64) := value[24:16]][bvadd64(index, 3bv64) := value[32:24]]
 }
@@ -35,10 +31,7 @@ procedure {:extern} rely();
   modifies Gamma_mem, mem;
   ensures (forall i: bv64 :: (((mem[i] == old(mem[i])) ==> (Gamma_mem[i] == old(Gamma_mem[i])))));
   ensures (((memory_load32_le(mem, $x_addr) == old(memory_load32_le(mem, $x_addr))) || (memory_load32_le(mem, $x_addr) == 1bv32)) || (memory_load32_le(mem, $x_addr) == 6bv32));
-  free ensures (memory_load8_le(mem, 1856bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1857bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1858bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1859bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1856bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69016bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69024bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69616bv64) == 1812bv64);
@@ -74,19 +67,13 @@ procedure main();
   requires (memory_load32_le(mem, $x_addr) == 0bv32);
   free requires (memory_load64_le(mem, 69632bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free requires (memory_load8_le(mem, 1856bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1857bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1858bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1859bv64) == 0bv8);
+  free requires (memory_load32_le(mem, 1856bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69016bv64) == 1808bv64);
   free requires (memory_load64_le(mem, 69024bv64) == 1728bv64);
   free requires (memory_load64_le(mem, 69616bv64) == 1812bv64);
   free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
   ensures ((memory_load32_le(mem, $x_addr) == 5bv32) || (memory_load32_le(mem, $x_addr) == 6bv32));
-  free ensures (memory_load8_le(mem, 1856bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1857bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1858bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1859bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1856bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69016bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69024bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69616bv64) == 1812bv64);
diff --git a/src/test/correct/basic_assign_assign/gcc_O2/basic_assign_assign.expected b/src/test/correct/basic_assign_assign/gcc_O2/basic_assign_assign.expected
index 374ce9ba2..962054198 100644
--- a/src/test/correct/basic_assign_assign/gcc_O2/basic_assign_assign.expected
+++ b/src/test/correct/basic_assign_assign/gcc_O2/basic_assign_assign.expected
@@ -8,7 +8,7 @@ var {:extern} R2: bv64;
 var {:extern} mem: [bv64]bv8;
 const {:extern} $x_addr: bv64;
 axiom ($x_addr == 69652bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
   (if (index == $x_addr) then true else false)
 }
 
@@ -25,10 +25,6 @@ function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv6
   (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
-}
-
 function {:extern} memory_store32_le(memory: [bv64]bv8, index: bv64, value: bv32) returns ([bv64]bv8) {
   memory[index := value[8:0]][bvadd64(index, 1bv64) := value[16:8]][bvadd64(index, 2bv64) := value[24:16]][bvadd64(index, 3bv64) := value[32:24]]
 }
@@ -37,10 +33,7 @@ procedure {:extern} rely();
   modifies Gamma_mem, mem;
   ensures (forall i: bv64 :: (((mem[i] == old(mem[i])) ==> (Gamma_mem[i] == old(Gamma_mem[i])))));
   ensures (((memory_load32_le(mem, $x_addr) == old(memory_load32_le(mem, $x_addr))) || (memory_load32_le(mem, $x_addr) == 1bv32)) || (memory_load32_le(mem, $x_addr) == 6bv32));
-  free ensures (memory_load8_le(mem, 1896bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1897bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1898bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1899bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1896bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69016bv64) == 1872bv64);
   free ensures (memory_load64_le(mem, 69024bv64) == 1792bv64);
   free ensures (memory_load64_le(mem, 69616bv64) == 1536bv64);
@@ -76,19 +69,13 @@ procedure main();
   requires (memory_load32_le(mem, $x_addr) == 0bv32);
   free requires (memory_load64_le(mem, 69632bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free requires (memory_load8_le(mem, 1896bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1897bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1898bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1899bv64) == 0bv8);
+  free requires (memory_load32_le(mem, 1896bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69016bv64) == 1872bv64);
   free requires (memory_load64_le(mem, 69024bv64) == 1792bv64);
   free requires (memory_load64_le(mem, 69616bv64) == 1536bv64);
   free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
   ensures ((memory_load32_le(mem, $x_addr) == 5bv32) || (memory_load32_le(mem, $x_addr) == 6bv32));
-  free ensures (memory_load8_le(mem, 1896bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1897bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1898bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1899bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1896bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69016bv64) == 1872bv64);
   free ensures (memory_load64_le(mem, 69024bv64) == 1792bv64);
   free ensures (memory_load64_le(mem, 69616bv64) == 1536bv64);
diff --git a/src/test/correct/basic_assign_assign/gcc_O2/basic_assign_assign_gtirb.expected b/src/test/correct/basic_assign_assign/gcc_O2/basic_assign_assign_gtirb.expected
index b19a1ad94..b581f7d08 100644
--- a/src/test/correct/basic_assign_assign/gcc_O2/basic_assign_assign_gtirb.expected
+++ b/src/test/correct/basic_assign_assign/gcc_O2/basic_assign_assign_gtirb.expected
@@ -8,7 +8,7 @@ var {:extern} R2: bv64;
 var {:extern} mem: [bv64]bv8;
 const {:extern} $x_addr: bv64;
 axiom ($x_addr == 69652bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
   (if (index == $x_addr) then true else false)
 }
 
@@ -25,10 +25,6 @@ function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv6
   (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
-}
-
 function {:extern} memory_store32_le(memory: [bv64]bv8, index: bv64, value: bv32) returns ([bv64]bv8) {
   memory[index := value[8:0]][bvadd64(index, 1bv64) := value[16:8]][bvadd64(index, 2bv64) := value[24:16]][bvadd64(index, 3bv64) := value[32:24]]
 }
@@ -37,10 +33,7 @@ procedure {:extern} rely();
   modifies Gamma_mem, mem;
   ensures (forall i: bv64 :: (((mem[i] == old(mem[i])) ==> (Gamma_mem[i] == old(Gamma_mem[i])))));
   ensures (((memory_load32_le(mem, $x_addr) == old(memory_load32_le(mem, $x_addr))) || (memory_load32_le(mem, $x_addr) == 1bv32)) || (memory_load32_le(mem, $x_addr) == 6bv32));
-  free ensures (memory_load8_le(mem, 1896bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1897bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1898bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1899bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1896bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69016bv64) == 1872bv64);
   free ensures (memory_load64_le(mem, 69024bv64) == 1792bv64);
   free ensures (memory_load64_le(mem, 69616bv64) == 1536bv64);
@@ -76,19 +69,13 @@ procedure main();
   requires (memory_load32_le(mem, $x_addr) == 0bv32);
   free requires (memory_load64_le(mem, 69632bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free requires (memory_load8_le(mem, 1896bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1897bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1898bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1899bv64) == 0bv8);
+  free requires (memory_load32_le(mem, 1896bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69016bv64) == 1872bv64);
   free requires (memory_load64_le(mem, 69024bv64) == 1792bv64);
   free requires (memory_load64_le(mem, 69616bv64) == 1536bv64);
   free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
   ensures ((memory_load32_le(mem, $x_addr) == 5bv32) || (memory_load32_le(mem, $x_addr) == 6bv32));
-  free ensures (memory_load8_le(mem, 1896bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1897bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1898bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1899bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1896bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69016bv64) == 1872bv64);
   free ensures (memory_load64_le(mem, 69024bv64) == 1792bv64);
   free ensures (memory_load64_le(mem, 69616bv64) == 1536bv64);
diff --git a/src/test/correct/basic_assign_assign/gcc_pic/basic_assign_assign.expected b/src/test/correct/basic_assign_assign/gcc_pic/basic_assign_assign.expected
index ef3087e5a..07cde5e52 100644
--- a/src/test/correct/basic_assign_assign/gcc_pic/basic_assign_assign.expected
+++ b/src/test/correct/basic_assign_assign/gcc_pic/basic_assign_assign.expected
@@ -6,7 +6,7 @@ var {:extern} R1: bv64;
 var {:extern} mem: [bv64]bv8;
 const {:extern} $x_addr: bv64;
 axiom ($x_addr == 69652bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
   (if (index == $x_addr) then true else false)
 }
 
@@ -27,10 +27,6 @@ function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv6
   (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
-}
-
 function {:extern} memory_store32_le(memory: [bv64]bv8, index: bv64, value: bv32) returns ([bv64]bv8) {
   memory[index := value[8:0]][bvadd64(index, 1bv64) := value[16:8]][bvadd64(index, 2bv64) := value[24:16]][bvadd64(index, 3bv64) := value[32:24]]
 }
@@ -39,15 +35,12 @@ procedure {:extern} rely();
   modifies Gamma_mem, mem;
   ensures (forall i: bv64 :: (((mem[i] == old(mem[i])) ==> (Gamma_mem[i] == old(Gamma_mem[i])))));
   ensures (((memory_load32_le(mem, $x_addr) == old(memory_load32_le(mem, $x_addr))) || (memory_load32_le(mem, $x_addr) == 1bv32)) || (memory_load32_le(mem, $x_addr) == 6bv32));
-  free ensures (memory_load8_le(mem, 1920bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1921bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1922bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1923bv64) == 0bv8);
-  free ensures (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free ensures (memory_load64_le(mem, 69616bv64) == 1876bv64);
+  free ensures (memory_load32_le(mem, 1920bv64) == 131073bv32);
+  free ensures (memory_load64_le(mem, 69008bv64) == 1872bv64);
   free ensures (memory_load64_le(mem, 69016bv64) == 1792bv64);
   free ensures (memory_load64_le(mem, 69600bv64) == 69652bv64);
-  free ensures (memory_load64_le(mem, 69008bv64) == 1872bv64);
+  free ensures (memory_load64_le(mem, 69616bv64) == 1876bv64);
+  free ensures (memory_load64_le(mem, 69640bv64) == 69640bv64);
 
 procedure {:extern} rely_transitive();
   modifies Gamma_mem, mem;
@@ -79,25 +72,19 @@ procedure main();
   requires (memory_load32_le(mem, $x_addr) == 0bv32);
   free requires (memory_load64_le(mem, 69632bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free requires (memory_load8_le(mem, 1920bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1921bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1922bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1923bv64) == 0bv8);
-  free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free requires (memory_load64_le(mem, 69616bv64) == 1876bv64);
+  free requires (memory_load32_le(mem, 1920bv64) == 131073bv32);
+  free requires (memory_load64_le(mem, 69008bv64) == 1872bv64);
   free requires (memory_load64_le(mem, 69016bv64) == 1792bv64);
   free requires (memory_load64_le(mem, 69600bv64) == 69652bv64);
-  free requires (memory_load64_le(mem, 69008bv64) == 1872bv64);
+  free requires (memory_load64_le(mem, 69616bv64) == 1876bv64);
+  free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
   ensures ((memory_load32_le(mem, $x_addr) == 5bv32) || (memory_load32_le(mem, $x_addr) == 6bv32));
-  free ensures (memory_load8_le(mem, 1920bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1921bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1922bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1923bv64) == 0bv8);
-  free ensures (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free ensures (memory_load64_le(mem, 69616bv64) == 1876bv64);
+  free ensures (memory_load32_le(mem, 1920bv64) == 131073bv32);
+  free ensures (memory_load64_le(mem, 69008bv64) == 1872bv64);
   free ensures (memory_load64_le(mem, 69016bv64) == 1792bv64);
   free ensures (memory_load64_le(mem, 69600bv64) == 69652bv64);
-  free ensures (memory_load64_le(mem, 69008bv64) == 1872bv64);
+  free ensures (memory_load64_le(mem, 69616bv64) == 1876bv64);
+  free ensures (memory_load64_le(mem, 69640bv64) == 69640bv64);
 
 implementation main()
 {
diff --git a/src/test/correct/basic_assign_assign/gcc_pic/basic_assign_assign_gtirb.expected b/src/test/correct/basic_assign_assign/gcc_pic/basic_assign_assign_gtirb.expected
index 97ff0a4b6..57456a981 100644
--- a/src/test/correct/basic_assign_assign/gcc_pic/basic_assign_assign_gtirb.expected
+++ b/src/test/correct/basic_assign_assign/gcc_pic/basic_assign_assign_gtirb.expected
@@ -6,7 +6,7 @@ var {:extern} R1: bv64;
 var {:extern} mem: [bv64]bv8;
 const {:extern} $x_addr: bv64;
 axiom ($x_addr == 69652bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
   (if (index == $x_addr) then true else false)
 }
 
@@ -27,10 +27,6 @@ function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv6
   (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
-}
-
 function {:extern} memory_store32_le(memory: [bv64]bv8, index: bv64, value: bv32) returns ([bv64]bv8) {
   memory[index := value[8:0]][bvadd64(index, 1bv64) := value[16:8]][bvadd64(index, 2bv64) := value[24:16]][bvadd64(index, 3bv64) := value[32:24]]
 }
@@ -39,15 +35,12 @@ procedure {:extern} rely();
   modifies Gamma_mem, mem;
   ensures (forall i: bv64 :: (((mem[i] == old(mem[i])) ==> (Gamma_mem[i] == old(Gamma_mem[i])))));
   ensures (((memory_load32_le(mem, $x_addr) == old(memory_load32_le(mem, $x_addr))) || (memory_load32_le(mem, $x_addr) == 1bv32)) || (memory_load32_le(mem, $x_addr) == 6bv32));
-  free ensures (memory_load8_le(mem, 1920bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1921bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1922bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1923bv64) == 0bv8);
-  free ensures (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free ensures (memory_load64_le(mem, 69616bv64) == 1876bv64);
+  free ensures (memory_load32_le(mem, 1920bv64) == 131073bv32);
+  free ensures (memory_load64_le(mem, 69008bv64) == 1872bv64);
   free ensures (memory_load64_le(mem, 69016bv64) == 1792bv64);
   free ensures (memory_load64_le(mem, 69600bv64) == 69652bv64);
-  free ensures (memory_load64_le(mem, 69008bv64) == 1872bv64);
+  free ensures (memory_load64_le(mem, 69616bv64) == 1876bv64);
+  free ensures (memory_load64_le(mem, 69640bv64) == 69640bv64);
 
 procedure {:extern} rely_transitive();
   modifies Gamma_mem, mem;
@@ -79,25 +72,19 @@ procedure main();
   requires (memory_load32_le(mem, $x_addr) == 0bv32);
   free requires (memory_load64_le(mem, 69632bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free requires (memory_load8_le(mem, 1920bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1921bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1922bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1923bv64) == 0bv8);
-  free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free requires (memory_load64_le(mem, 69616bv64) == 1876bv64);
+  free requires (memory_load32_le(mem, 1920bv64) == 131073bv32);
+  free requires (memory_load64_le(mem, 69008bv64) == 1872bv64);
   free requires (memory_load64_le(mem, 69016bv64) == 1792bv64);
   free requires (memory_load64_le(mem, 69600bv64) == 69652bv64);
-  free requires (memory_load64_le(mem, 69008bv64) == 1872bv64);
+  free requires (memory_load64_le(mem, 69616bv64) == 1876bv64);
+  free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
   ensures ((memory_load32_le(mem, $x_addr) == 5bv32) || (memory_load32_le(mem, $x_addr) == 6bv32));
-  free ensures (memory_load8_le(mem, 1920bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1921bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1922bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1923bv64) == 0bv8);
-  free ensures (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free ensures (memory_load64_le(mem, 69616bv64) == 1876bv64);
+  free ensures (memory_load32_le(mem, 1920bv64) == 131073bv32);
+  free ensures (memory_load64_le(mem, 69008bv64) == 1872bv64);
   free ensures (memory_load64_le(mem, 69016bv64) == 1792bv64);
   free ensures (memory_load64_le(mem, 69600bv64) == 69652bv64);
-  free ensures (memory_load64_le(mem, 69008bv64) == 1872bv64);
+  free ensures (memory_load64_le(mem, 69616bv64) == 1876bv64);
+  free ensures (memory_load64_le(mem, 69640bv64) == 69640bv64);
 
 implementation main()
 {
diff --git a/src/test/correct/basic_assign_increment/clang/basic_assign_increment.expected b/src/test/correct/basic_assign_increment/clang/basic_assign_increment.expected
index a2e5ac8d9..812b609e6 100644
--- a/src/test/correct/basic_assign_increment/clang/basic_assign_increment.expected
+++ b/src/test/correct/basic_assign_increment/clang/basic_assign_increment.expected
@@ -8,7 +8,7 @@ var {:extern} R9: bv64;
 var {:extern} mem: [bv64]bv8;
 const {:extern} $x_addr: bv64;
 axiom ($x_addr == 69684bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
   (if (index == $x_addr) then true else false)
 }
 
@@ -30,10 +30,6 @@ function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv6
   (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
-}
-
 function {:extern} memory_store32_le(memory: [bv64]bv8, index: bv64, value: bv32) returns ([bv64]bv8) {
   memory[index := value[8:0]][bvadd64(index, 1bv64) := value[16:8]][bvadd64(index, 2bv64) := value[24:16]][bvadd64(index, 3bv64) := value[32:24]]
 }
@@ -43,10 +39,7 @@ procedure {:extern} rely();
   modifies Gamma_mem, mem;
   ensures (forall i: bv64 :: (((mem[i] == old(mem[i])) ==> (Gamma_mem[i] == old(Gamma_mem[i])))));
   ensures ((memory_load32_le(mem, $x_addr) == old(memory_load32_le(mem, $x_addr))) || (memory_load32_le(mem, $x_addr) == 5bv32));
-  free ensures (memory_load8_le(mem, 1856bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1857bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1858bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1859bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1856bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1812bv64);
@@ -82,19 +75,13 @@ procedure main();
   requires (memory_load32_le(mem, $x_addr) == 0bv32);
   free requires (memory_load64_le(mem, 69664bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
-  free requires (memory_load8_le(mem, 1856bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1857bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1858bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1859bv64) == 0bv8);
+  free requires (memory_load32_le(mem, 1856bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free requires (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free requires (memory_load64_le(mem, 69592bv64) == 1812bv64);
   free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
   ensures (((memory_load32_le(mem, $x_addr) == 1bv32) || (memory_load32_le(mem, $x_addr) == 5bv32)) || (memory_load32_le(mem, $x_addr) == 6bv32));
-  free ensures (memory_load8_le(mem, 1856bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1857bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1858bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1859bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1856bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1812bv64);
diff --git a/src/test/correct/basic_assign_increment/clang/basic_assign_increment_gtirb.expected b/src/test/correct/basic_assign_increment/clang/basic_assign_increment_gtirb.expected
index 4b8981424..ef78d2241 100644
--- a/src/test/correct/basic_assign_increment/clang/basic_assign_increment_gtirb.expected
+++ b/src/test/correct/basic_assign_increment/clang/basic_assign_increment_gtirb.expected
@@ -8,7 +8,7 @@ var {:extern} R9: bv64;
 var {:extern} mem: [bv64]bv8;
 const {:extern} $x_addr: bv64;
 axiom ($x_addr == 69684bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
   (if (index == $x_addr) then true else false)
 }
 
@@ -30,10 +30,6 @@ function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv6
   (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
-}
-
 function {:extern} memory_store32_le(memory: [bv64]bv8, index: bv64, value: bv32) returns ([bv64]bv8) {
   memory[index := value[8:0]][bvadd64(index, 1bv64) := value[16:8]][bvadd64(index, 2bv64) := value[24:16]][bvadd64(index, 3bv64) := value[32:24]]
 }
@@ -43,10 +39,7 @@ procedure {:extern} rely();
   modifies Gamma_mem, mem;
   ensures (forall i: bv64 :: (((mem[i] == old(mem[i])) ==> (Gamma_mem[i] == old(Gamma_mem[i])))));
   ensures ((memory_load32_le(mem, $x_addr) == old(memory_load32_le(mem, $x_addr))) || (memory_load32_le(mem, $x_addr) == 5bv32));
-  free ensures (memory_load8_le(mem, 1856bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1857bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1858bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1859bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1856bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1812bv64);
@@ -82,19 +75,13 @@ procedure main();
   requires (memory_load32_le(mem, $x_addr) == 0bv32);
   free requires (memory_load64_le(mem, 69664bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
-  free requires (memory_load8_le(mem, 1856bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1857bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1858bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1859bv64) == 0bv8);
+  free requires (memory_load32_le(mem, 1856bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free requires (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free requires (memory_load64_le(mem, 69592bv64) == 1812bv64);
   free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
   ensures (((memory_load32_le(mem, $x_addr) == 1bv32) || (memory_load32_le(mem, $x_addr) == 5bv32)) || (memory_load32_le(mem, $x_addr) == 6bv32));
-  free ensures (memory_load8_le(mem, 1856bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1857bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1858bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1859bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1856bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1812bv64);
diff --git a/src/test/correct/basic_assign_increment/clang_pic/basic_assign_increment.expected b/src/test/correct/basic_assign_increment/clang_pic/basic_assign_increment.expected
index ae5a4a00a..e4e53c315 100644
--- a/src/test/correct/basic_assign_increment/clang_pic/basic_assign_increment.expected
+++ b/src/test/correct/basic_assign_increment/clang_pic/basic_assign_increment.expected
@@ -8,7 +8,7 @@ var {:extern} R9: bv64;
 var {:extern} mem: [bv64]bv8;
 const {:extern} $x_addr: bv64;
 axiom ($x_addr == 69684bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
   (if (index == $x_addr) then true else false)
 }
 
@@ -34,10 +34,6 @@ function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv6
   (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
-}
-
 function {:extern} memory_store32_le(memory: [bv64]bv8, index: bv64, value: bv32) returns ([bv64]bv8) {
   memory[index := value[8:0]][bvadd64(index, 1bv64) := value[16:8]][bvadd64(index, 2bv64) := value[24:16]][bvadd64(index, 3bv64) := value[32:24]]
 }
@@ -47,15 +43,12 @@ procedure {:extern} rely();
   modifies Gamma_mem, mem;
   ensures (forall i: bv64 :: (((mem[i] == old(mem[i])) ==> (Gamma_mem[i] == old(Gamma_mem[i])))));
   ensures ((memory_load32_le(mem, $x_addr) == old(memory_load32_le(mem, $x_addr))) || (memory_load32_le(mem, $x_addr) == 5bv32));
-  free ensures (memory_load8_le(mem, 1924bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1925bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1926bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1927bv64) == 0bv8);
-  free ensures (memory_load64_le(mem, 69576bv64) == 69684bv64);
-  free ensures (memory_load64_le(mem, 69672bv64) == 69672bv64);
+  free ensures (memory_load32_le(mem, 1924bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69056bv64) == 1872bv64);
   free ensures (memory_load64_le(mem, 69064bv64) == 1792bv64);
+  free ensures (memory_load64_le(mem, 69576bv64) == 69684bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1876bv64);
+  free ensures (memory_load64_le(mem, 69672bv64) == 69672bv64);
 
 procedure {:extern} rely_transitive();
   modifies Gamma_mem, mem;
@@ -87,25 +80,19 @@ procedure main();
   requires (memory_load32_le(mem, $x_addr) == 0bv32);
   free requires (memory_load64_le(mem, 69664bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
-  free requires (memory_load8_le(mem, 1924bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1925bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1926bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1927bv64) == 0bv8);
-  free requires (memory_load64_le(mem, 69576bv64) == 69684bv64);
-  free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
+  free requires (memory_load32_le(mem, 1924bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69056bv64) == 1872bv64);
   free requires (memory_load64_le(mem, 69064bv64) == 1792bv64);
+  free requires (memory_load64_le(mem, 69576bv64) == 69684bv64);
   free requires (memory_load64_le(mem, 69592bv64) == 1876bv64);
+  free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
   ensures (((memory_load32_le(mem, $x_addr) == 1bv32) || (memory_load32_le(mem, $x_addr) == 5bv32)) || (memory_load32_le(mem, $x_addr) == 6bv32));
-  free ensures (memory_load8_le(mem, 1924bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1925bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1926bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1927bv64) == 0bv8);
-  free ensures (memory_load64_le(mem, 69576bv64) == 69684bv64);
-  free ensures (memory_load64_le(mem, 69672bv64) == 69672bv64);
+  free ensures (memory_load32_le(mem, 1924bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69056bv64) == 1872bv64);
   free ensures (memory_load64_le(mem, 69064bv64) == 1792bv64);
+  free ensures (memory_load64_le(mem, 69576bv64) == 69684bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1876bv64);
+  free ensures (memory_load64_le(mem, 69672bv64) == 69672bv64);
 
 implementation main()
 {
diff --git a/src/test/correct/basic_assign_increment/clang_pic/basic_assign_increment_gtirb.expected b/src/test/correct/basic_assign_increment/clang_pic/basic_assign_increment_gtirb.expected
index af0c7855a..330e91d98 100644
--- a/src/test/correct/basic_assign_increment/clang_pic/basic_assign_increment_gtirb.expected
+++ b/src/test/correct/basic_assign_increment/clang_pic/basic_assign_increment_gtirb.expected
@@ -8,7 +8,7 @@ var {:extern} R9: bv64;
 var {:extern} mem: [bv64]bv8;
 const {:extern} $x_addr: bv64;
 axiom ($x_addr == 69684bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
   (if (index == $x_addr) then true else false)
 }
 
@@ -34,10 +34,6 @@ function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv6
   (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
-}
-
 function {:extern} memory_store32_le(memory: [bv64]bv8, index: bv64, value: bv32) returns ([bv64]bv8) {
   memory[index := value[8:0]][bvadd64(index, 1bv64) := value[16:8]][bvadd64(index, 2bv64) := value[24:16]][bvadd64(index, 3bv64) := value[32:24]]
 }
@@ -47,15 +43,12 @@ procedure {:extern} rely();
   modifies Gamma_mem, mem;
   ensures (forall i: bv64 :: (((mem[i] == old(mem[i])) ==> (Gamma_mem[i] == old(Gamma_mem[i])))));
   ensures ((memory_load32_le(mem, $x_addr) == old(memory_load32_le(mem, $x_addr))) || (memory_load32_le(mem, $x_addr) == 5bv32));
-  free ensures (memory_load8_le(mem, 1924bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1925bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1926bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1927bv64) == 0bv8);
-  free ensures (memory_load64_le(mem, 69576bv64) == 69684bv64);
-  free ensures (memory_load64_le(mem, 69672bv64) == 69672bv64);
+  free ensures (memory_load32_le(mem, 1924bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69056bv64) == 1872bv64);
   free ensures (memory_load64_le(mem, 69064bv64) == 1792bv64);
+  free ensures (memory_load64_le(mem, 69576bv64) == 69684bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1876bv64);
+  free ensures (memory_load64_le(mem, 69672bv64) == 69672bv64);
 
 procedure {:extern} rely_transitive();
   modifies Gamma_mem, mem;
@@ -87,25 +80,19 @@ procedure main();
   requires (memory_load32_le(mem, $x_addr) == 0bv32);
   free requires (memory_load64_le(mem, 69664bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
-  free requires (memory_load8_le(mem, 1924bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1925bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1926bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1927bv64) == 0bv8);
-  free requires (memory_load64_le(mem, 69576bv64) == 69684bv64);
-  free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
+  free requires (memory_load32_le(mem, 1924bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69056bv64) == 1872bv64);
   free requires (memory_load64_le(mem, 69064bv64) == 1792bv64);
+  free requires (memory_load64_le(mem, 69576bv64) == 69684bv64);
   free requires (memory_load64_le(mem, 69592bv64) == 1876bv64);
+  free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
   ensures (((memory_load32_le(mem, $x_addr) == 1bv32) || (memory_load32_le(mem, $x_addr) == 5bv32)) || (memory_load32_le(mem, $x_addr) == 6bv32));
-  free ensures (memory_load8_le(mem, 1924bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1925bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1926bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1927bv64) == 0bv8);
-  free ensures (memory_load64_le(mem, 69576bv64) == 69684bv64);
-  free ensures (memory_load64_le(mem, 69672bv64) == 69672bv64);
+  free ensures (memory_load32_le(mem, 1924bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69056bv64) == 1872bv64);
   free ensures (memory_load64_le(mem, 69064bv64) == 1792bv64);
+  free ensures (memory_load64_le(mem, 69576bv64) == 69684bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1876bv64);
+  free ensures (memory_load64_le(mem, 69672bv64) == 69672bv64);
 
 implementation main()
 {
diff --git a/src/test/correct/basic_assign_increment/gcc/basic_assign_increment.expected b/src/test/correct/basic_assign_increment/gcc/basic_assign_increment.expected
index 1b156c659..78dc01415 100644
--- a/src/test/correct/basic_assign_increment/gcc/basic_assign_increment.expected
+++ b/src/test/correct/basic_assign_increment/gcc/basic_assign_increment.expected
@@ -6,7 +6,7 @@ var {:extern} R1: bv64;
 var {:extern} mem: [bv64]bv8;
 const {:extern} $x_addr: bv64;
 axiom ($x_addr == 69652bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
   (if (index == $x_addr) then true else false)
 }
 
@@ -28,10 +28,6 @@ function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv6
   (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
-}
-
 function {:extern} memory_store32_le(memory: [bv64]bv8, index: bv64, value: bv32) returns ([bv64]bv8) {
   memory[index := value[8:0]][bvadd64(index, 1bv64) := value[16:8]][bvadd64(index, 2bv64) := value[24:16]][bvadd64(index, 3bv64) := value[32:24]]
 }
@@ -41,10 +37,7 @@ procedure {:extern} rely();
   modifies Gamma_mem, mem;
   ensures (forall i: bv64 :: (((mem[i] == old(mem[i])) ==> (Gamma_mem[i] == old(Gamma_mem[i])))));
   ensures ((memory_load32_le(mem, $x_addr) == old(memory_load32_le(mem, $x_addr))) || (memory_load32_le(mem, $x_addr) == 5bv32));
-  free ensures (memory_load8_le(mem, 1868bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1869bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1870bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1871bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1868bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69016bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69024bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69616bv64) == 1812bv64);
@@ -80,19 +73,13 @@ procedure main();
   requires (memory_load32_le(mem, $x_addr) == 0bv32);
   free requires (memory_load64_le(mem, 69632bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free requires (memory_load8_le(mem, 1868bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1869bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1870bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1871bv64) == 0bv8);
+  free requires (memory_load32_le(mem, 1868bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69016bv64) == 1808bv64);
   free requires (memory_load64_le(mem, 69024bv64) == 1728bv64);
   free requires (memory_load64_le(mem, 69616bv64) == 1812bv64);
   free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
   ensures (((memory_load32_le(mem, $x_addr) == 1bv32) || (memory_load32_le(mem, $x_addr) == 5bv32)) || (memory_load32_le(mem, $x_addr) == 6bv32));
-  free ensures (memory_load8_le(mem, 1868bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1869bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1870bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1871bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1868bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69016bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69024bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69616bv64) == 1812bv64);
diff --git a/src/test/correct/basic_assign_increment/gcc/basic_assign_increment_gtirb.expected b/src/test/correct/basic_assign_increment/gcc/basic_assign_increment_gtirb.expected
index 3130f1279..ca01cce2f 100644
--- a/src/test/correct/basic_assign_increment/gcc/basic_assign_increment_gtirb.expected
+++ b/src/test/correct/basic_assign_increment/gcc/basic_assign_increment_gtirb.expected
@@ -6,7 +6,7 @@ var {:extern} R1: bv64;
 var {:extern} mem: [bv64]bv8;
 const {:extern} $x_addr: bv64;
 axiom ($x_addr == 69652bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
   (if (index == $x_addr) then true else false)
 }
 
@@ -28,10 +28,6 @@ function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv6
   (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
-}
-
 function {:extern} memory_store32_le(memory: [bv64]bv8, index: bv64, value: bv32) returns ([bv64]bv8) {
   memory[index := value[8:0]][bvadd64(index, 1bv64) := value[16:8]][bvadd64(index, 2bv64) := value[24:16]][bvadd64(index, 3bv64) := value[32:24]]
 }
@@ -41,10 +37,7 @@ procedure {:extern} rely();
   modifies Gamma_mem, mem;
   ensures (forall i: bv64 :: (((mem[i] == old(mem[i])) ==> (Gamma_mem[i] == old(Gamma_mem[i])))));
   ensures ((memory_load32_le(mem, $x_addr) == old(memory_load32_le(mem, $x_addr))) || (memory_load32_le(mem, $x_addr) == 5bv32));
-  free ensures (memory_load8_le(mem, 1868bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1869bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1870bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1871bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1868bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69016bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69024bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69616bv64) == 1812bv64);
@@ -80,19 +73,13 @@ procedure main();
   requires (memory_load32_le(mem, $x_addr) == 0bv32);
   free requires (memory_load64_le(mem, 69632bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free requires (memory_load8_le(mem, 1868bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1869bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1870bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1871bv64) == 0bv8);
+  free requires (memory_load32_le(mem, 1868bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69016bv64) == 1808bv64);
   free requires (memory_load64_le(mem, 69024bv64) == 1728bv64);
   free requires (memory_load64_le(mem, 69616bv64) == 1812bv64);
   free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
   ensures (((memory_load32_le(mem, $x_addr) == 1bv32) || (memory_load32_le(mem, $x_addr) == 5bv32)) || (memory_load32_le(mem, $x_addr) == 6bv32));
-  free ensures (memory_load8_le(mem, 1868bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1869bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1870bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1871bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1868bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69016bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69024bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69616bv64) == 1812bv64);
diff --git a/src/test/correct/basic_assign_increment/gcc_O2/basic_assign_increment.expected b/src/test/correct/basic_assign_increment/gcc_O2/basic_assign_increment.expected
index 695b9a5d7..960b020dc 100644
--- a/src/test/correct/basic_assign_increment/gcc_O2/basic_assign_increment.expected
+++ b/src/test/correct/basic_assign_increment/gcc_O2/basic_assign_increment.expected
@@ -8,7 +8,7 @@ var {:extern} R2: bv64;
 var {:extern} mem: [bv64]bv8;
 const {:extern} $x_addr: bv64;
 axiom ($x_addr == 69652bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
   (if (index == $x_addr) then true else false)
 }
 
@@ -30,10 +30,6 @@ function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv6
   (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
-}
-
 function {:extern} memory_store32_le(memory: [bv64]bv8, index: bv64, value: bv32) returns ([bv64]bv8) {
   memory[index := value[8:0]][bvadd64(index, 1bv64) := value[16:8]][bvadd64(index, 2bv64) := value[24:16]][bvadd64(index, 3bv64) := value[32:24]]
 }
@@ -43,10 +39,7 @@ procedure {:extern} rely();
   modifies Gamma_mem, mem;
   ensures (forall i: bv64 :: (((mem[i] == old(mem[i])) ==> (Gamma_mem[i] == old(Gamma_mem[i])))));
   ensures ((memory_load32_le(mem, $x_addr) == old(memory_load32_le(mem, $x_addr))) || (memory_load32_le(mem, $x_addr) == 5bv32));
-  free ensures (memory_load8_le(mem, 1896bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1897bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1898bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1899bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1896bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69016bv64) == 1872bv64);
   free ensures (memory_load64_le(mem, 69024bv64) == 1792bv64);
   free ensures (memory_load64_le(mem, 69616bv64) == 1536bv64);
@@ -82,19 +75,13 @@ procedure main();
   requires (memory_load32_le(mem, $x_addr) == 0bv32);
   free requires (memory_load64_le(mem, 69632bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free requires (memory_load8_le(mem, 1896bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1897bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1898bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1899bv64) == 0bv8);
+  free requires (memory_load32_le(mem, 1896bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69016bv64) == 1872bv64);
   free requires (memory_load64_le(mem, 69024bv64) == 1792bv64);
   free requires (memory_load64_le(mem, 69616bv64) == 1536bv64);
   free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
   ensures (((memory_load32_le(mem, $x_addr) == 1bv32) || (memory_load32_le(mem, $x_addr) == 5bv32)) || (memory_load32_le(mem, $x_addr) == 6bv32));
-  free ensures (memory_load8_le(mem, 1896bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1897bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1898bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1899bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1896bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69016bv64) == 1872bv64);
   free ensures (memory_load64_le(mem, 69024bv64) == 1792bv64);
   free ensures (memory_load64_le(mem, 69616bv64) == 1536bv64);
diff --git a/src/test/correct/basic_assign_increment/gcc_O2/basic_assign_increment_gtirb.expected b/src/test/correct/basic_assign_increment/gcc_O2/basic_assign_increment_gtirb.expected
index fbd0b4264..04b71a74b 100644
--- a/src/test/correct/basic_assign_increment/gcc_O2/basic_assign_increment_gtirb.expected
+++ b/src/test/correct/basic_assign_increment/gcc_O2/basic_assign_increment_gtirb.expected
@@ -8,7 +8,7 @@ var {:extern} R2: bv64;
 var {:extern} mem: [bv64]bv8;
 const {:extern} $x_addr: bv64;
 axiom ($x_addr == 69652bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
   (if (index == $x_addr) then true else false)
 }
 
@@ -30,10 +30,6 @@ function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv6
   (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
-}
-
 function {:extern} memory_store32_le(memory: [bv64]bv8, index: bv64, value: bv32) returns ([bv64]bv8) {
   memory[index := value[8:0]][bvadd64(index, 1bv64) := value[16:8]][bvadd64(index, 2bv64) := value[24:16]][bvadd64(index, 3bv64) := value[32:24]]
 }
@@ -43,10 +39,7 @@ procedure {:extern} rely();
   modifies Gamma_mem, mem;
   ensures (forall i: bv64 :: (((mem[i] == old(mem[i])) ==> (Gamma_mem[i] == old(Gamma_mem[i])))));
   ensures ((memory_load32_le(mem, $x_addr) == old(memory_load32_le(mem, $x_addr))) || (memory_load32_le(mem, $x_addr) == 5bv32));
-  free ensures (memory_load8_le(mem, 1896bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1897bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1898bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1899bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1896bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69016bv64) == 1872bv64);
   free ensures (memory_load64_le(mem, 69024bv64) == 1792bv64);
   free ensures (memory_load64_le(mem, 69616bv64) == 1536bv64);
@@ -82,19 +75,13 @@ procedure main();
   requires (memory_load32_le(mem, $x_addr) == 0bv32);
   free requires (memory_load64_le(mem, 69632bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free requires (memory_load8_le(mem, 1896bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1897bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1898bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1899bv64) == 0bv8);
+  free requires (memory_load32_le(mem, 1896bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69016bv64) == 1872bv64);
   free requires (memory_load64_le(mem, 69024bv64) == 1792bv64);
   free requires (memory_load64_le(mem, 69616bv64) == 1536bv64);
   free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
   ensures (((memory_load32_le(mem, $x_addr) == 1bv32) || (memory_load32_le(mem, $x_addr) == 5bv32)) || (memory_load32_le(mem, $x_addr) == 6bv32));
-  free ensures (memory_load8_le(mem, 1896bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1897bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1898bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1899bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1896bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69016bv64) == 1872bv64);
   free ensures (memory_load64_le(mem, 69024bv64) == 1792bv64);
   free ensures (memory_load64_le(mem, 69616bv64) == 1536bv64);
diff --git a/src/test/correct/basic_assign_increment/gcc_pic/basic_assign_increment.expected b/src/test/correct/basic_assign_increment/gcc_pic/basic_assign_increment.expected
index 284230f1f..7fa9d9aee 100644
--- a/src/test/correct/basic_assign_increment/gcc_pic/basic_assign_increment.expected
+++ b/src/test/correct/basic_assign_increment/gcc_pic/basic_assign_increment.expected
@@ -6,7 +6,7 @@ var {:extern} R1: bv64;
 var {:extern} mem: [bv64]bv8;
 const {:extern} $x_addr: bv64;
 axiom ($x_addr == 69652bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
   (if (index == $x_addr) then true else false)
 }
 
@@ -32,10 +32,6 @@ function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv6
   (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
-}
-
 function {:extern} memory_store32_le(memory: [bv64]bv8, index: bv64, value: bv32) returns ([bv64]bv8) {
   memory[index := value[8:0]][bvadd64(index, 1bv64) := value[16:8]][bvadd64(index, 2bv64) := value[24:16]][bvadd64(index, 3bv64) := value[32:24]]
 }
@@ -45,15 +41,12 @@ procedure {:extern} rely();
   modifies Gamma_mem, mem;
   ensures (forall i: bv64 :: (((mem[i] == old(mem[i])) ==> (Gamma_mem[i] == old(Gamma_mem[i])))));
   ensures ((memory_load32_le(mem, $x_addr) == old(memory_load32_le(mem, $x_addr))) || (memory_load32_le(mem, $x_addr) == 5bv32));
-  free ensures (memory_load8_le(mem, 1932bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1933bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1934bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1935bv64) == 0bv8);
-  free ensures (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free ensures (memory_load64_le(mem, 69616bv64) == 1876bv64);
+  free ensures (memory_load32_le(mem, 1932bv64) == 131073bv32);
+  free ensures (memory_load64_le(mem, 69008bv64) == 1872bv64);
   free ensures (memory_load64_le(mem, 69016bv64) == 1792bv64);
   free ensures (memory_load64_le(mem, 69600bv64) == 69652bv64);
-  free ensures (memory_load64_le(mem, 69008bv64) == 1872bv64);
+  free ensures (memory_load64_le(mem, 69616bv64) == 1876bv64);
+  free ensures (memory_load64_le(mem, 69640bv64) == 69640bv64);
 
 procedure {:extern} rely_transitive();
   modifies Gamma_mem, mem;
@@ -85,25 +78,19 @@ procedure main();
   requires (memory_load32_le(mem, $x_addr) == 0bv32);
   free requires (memory_load64_le(mem, 69632bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free requires (memory_load8_le(mem, 1932bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1933bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1934bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1935bv64) == 0bv8);
-  free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free requires (memory_load64_le(mem, 69616bv64) == 1876bv64);
+  free requires (memory_load32_le(mem, 1932bv64) == 131073bv32);
+  free requires (memory_load64_le(mem, 69008bv64) == 1872bv64);
   free requires (memory_load64_le(mem, 69016bv64) == 1792bv64);
   free requires (memory_load64_le(mem, 69600bv64) == 69652bv64);
-  free requires (memory_load64_le(mem, 69008bv64) == 1872bv64);
+  free requires (memory_load64_le(mem, 69616bv64) == 1876bv64);
+  free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
   ensures (((memory_load32_le(mem, $x_addr) == 1bv32) || (memory_load32_le(mem, $x_addr) == 5bv32)) || (memory_load32_le(mem, $x_addr) == 6bv32));
-  free ensures (memory_load8_le(mem, 1932bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1933bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1934bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1935bv64) == 0bv8);
-  free ensures (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free ensures (memory_load64_le(mem, 69616bv64) == 1876bv64);
+  free ensures (memory_load32_le(mem, 1932bv64) == 131073bv32);
+  free ensures (memory_load64_le(mem, 69008bv64) == 1872bv64);
   free ensures (memory_load64_le(mem, 69016bv64) == 1792bv64);
   free ensures (memory_load64_le(mem, 69600bv64) == 69652bv64);
-  free ensures (memory_load64_le(mem, 69008bv64) == 1872bv64);
+  free ensures (memory_load64_le(mem, 69616bv64) == 1876bv64);
+  free ensures (memory_load64_le(mem, 69640bv64) == 69640bv64);
 
 implementation main()
 {
diff --git a/src/test/correct/basic_assign_increment/gcc_pic/basic_assign_increment_gtirb.expected b/src/test/correct/basic_assign_increment/gcc_pic/basic_assign_increment_gtirb.expected
index eec10c1a0..b429d97d2 100644
--- a/src/test/correct/basic_assign_increment/gcc_pic/basic_assign_increment_gtirb.expected
+++ b/src/test/correct/basic_assign_increment/gcc_pic/basic_assign_increment_gtirb.expected
@@ -6,7 +6,7 @@ var {:extern} R1: bv64;
 var {:extern} mem: [bv64]bv8;
 const {:extern} $x_addr: bv64;
 axiom ($x_addr == 69652bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
   (if (index == $x_addr) then true else false)
 }
 
@@ -32,10 +32,6 @@ function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv6
   (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
-}
-
 function {:extern} memory_store32_le(memory: [bv64]bv8, index: bv64, value: bv32) returns ([bv64]bv8) {
   memory[index := value[8:0]][bvadd64(index, 1bv64) := value[16:8]][bvadd64(index, 2bv64) := value[24:16]][bvadd64(index, 3bv64) := value[32:24]]
 }
@@ -45,15 +41,12 @@ procedure {:extern} rely();
   modifies Gamma_mem, mem;
   ensures (forall i: bv64 :: (((mem[i] == old(mem[i])) ==> (Gamma_mem[i] == old(Gamma_mem[i])))));
   ensures ((memory_load32_le(mem, $x_addr) == old(memory_load32_le(mem, $x_addr))) || (memory_load32_le(mem, $x_addr) == 5bv32));
-  free ensures (memory_load8_le(mem, 1932bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1933bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1934bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1935bv64) == 0bv8);
-  free ensures (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free ensures (memory_load64_le(mem, 69616bv64) == 1876bv64);
+  free ensures (memory_load32_le(mem, 1932bv64) == 131073bv32);
+  free ensures (memory_load64_le(mem, 69008bv64) == 1872bv64);
   free ensures (memory_load64_le(mem, 69016bv64) == 1792bv64);
   free ensures (memory_load64_le(mem, 69600bv64) == 69652bv64);
-  free ensures (memory_load64_le(mem, 69008bv64) == 1872bv64);
+  free ensures (memory_load64_le(mem, 69616bv64) == 1876bv64);
+  free ensures (memory_load64_le(mem, 69640bv64) == 69640bv64);
 
 procedure {:extern} rely_transitive();
   modifies Gamma_mem, mem;
@@ -85,25 +78,19 @@ procedure main();
   requires (memory_load32_le(mem, $x_addr) == 0bv32);
   free requires (memory_load64_le(mem, 69632bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free requires (memory_load8_le(mem, 1932bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1933bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1934bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1935bv64) == 0bv8);
-  free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free requires (memory_load64_le(mem, 69616bv64) == 1876bv64);
+  free requires (memory_load32_le(mem, 1932bv64) == 131073bv32);
+  free requires (memory_load64_le(mem, 69008bv64) == 1872bv64);
   free requires (memory_load64_le(mem, 69016bv64) == 1792bv64);
   free requires (memory_load64_le(mem, 69600bv64) == 69652bv64);
-  free requires (memory_load64_le(mem, 69008bv64) == 1872bv64);
+  free requires (memory_load64_le(mem, 69616bv64) == 1876bv64);
+  free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
   ensures (((memory_load32_le(mem, $x_addr) == 1bv32) || (memory_load32_le(mem, $x_addr) == 5bv32)) || (memory_load32_le(mem, $x_addr) == 6bv32));
-  free ensures (memory_load8_le(mem, 1932bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1933bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1934bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1935bv64) == 0bv8);
-  free ensures (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free ensures (memory_load64_le(mem, 69616bv64) == 1876bv64);
+  free ensures (memory_load32_le(mem, 1932bv64) == 131073bv32);
+  free ensures (memory_load64_le(mem, 69008bv64) == 1872bv64);
   free ensures (memory_load64_le(mem, 69016bv64) == 1792bv64);
   free ensures (memory_load64_le(mem, 69600bv64) == 69652bv64);
-  free ensures (memory_load64_le(mem, 69008bv64) == 1872bv64);
+  free ensures (memory_load64_le(mem, 69616bv64) == 1876bv64);
+  free ensures (memory_load64_le(mem, 69640bv64) == 69640bv64);
 
 implementation main()
 {
diff --git a/src/test/correct/basic_function_call_caller/clang/basic_function_call_caller.expected b/src/test/correct/basic_function_call_caller/clang/basic_function_call_caller.expected
index f38be33df..cb29dbcb0 100644
--- a/src/test/correct/basic_function_call_caller/clang/basic_function_call_caller.expected
+++ b/src/test/correct/basic_function_call_caller/clang/basic_function_call_caller.expected
@@ -18,8 +18,8 @@ const {:extern} $x_addr: bv64;
 axiom ($x_addr == 69684bv64);
 const {:extern} $y_addr: bv64;
 axiom ($y_addr == 69688bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
-  (if (index == $y_addr) then (memory_load32_le(memory, $x_addr) == 1bv32) else (if (index == $x_addr) then true else false))
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
+  (if (index == $y_addr) then (memory_load32_le(mem$in, $x_addr) == 1bv32) else (if (index == $x_addr) then true else false))
 }
 
 function {:extern} {:bvbuiltin "bvadd"} bvadd64(bv64, bv64) returns (bv64);
@@ -47,10 +47,6 @@ function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv6
   (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
-}
-
 function {:extern} memory_store32_le(memory: [bv64]bv8, index: bv64, value: bv32) returns ([bv64]bv8) {
   memory[index := value[8:0]][bvadd64(index, 1bv64) := value[16:8]][bvadd64(index, 2bv64) := value[24:16]][bvadd64(index, 3bv64) := value[32:24]]
 }
@@ -65,10 +61,7 @@ procedure {:extern} rely();
   ensures (forall i: bv64 :: (((mem[i] == old(mem[i])) ==> (Gamma_mem[i] == old(Gamma_mem[i])))));
   ensures (memory_load32_le(mem, $x_addr) == old(memory_load32_le(mem, $x_addr)));
   ensures (memory_load32_le(mem, $y_addr) == old(memory_load32_le(mem, $y_addr)));
-  free ensures (memory_load8_le(mem, 1896bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1897bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1898bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1899bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1896bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1820bv64);
@@ -107,10 +100,7 @@ procedure main();
   requires (Gamma_R0 == false);
   free requires (memory_load64_le(mem, 69664bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
-  free requires (memory_load8_le(mem, 1896bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1897bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1898bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1899bv64) == 0bv8);
+  free requires (memory_load32_le(mem, 1896bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free requires (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free requires (memory_load64_le(mem, 69592bv64) == 1820bv64);
@@ -119,10 +109,7 @@ procedure main();
   free ensures (Gamma_R31 == old(Gamma_R31));
   free ensures (R29 == old(R29));
   free ensures (R31 == old(R31));
-  free ensures (memory_load8_le(mem, 1896bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1897bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1898bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1899bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1896bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1820bv64);
@@ -186,19 +173,13 @@ implementation main()
 
 procedure zero();
   modifies Gamma_R0, R0;
-  free requires (memory_load8_le(mem, 1896bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1897bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1898bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1899bv64) == 0bv8);
+  free requires (memory_load32_le(mem, 1896bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free requires (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free requires (memory_load64_le(mem, 69592bv64) == 1820bv64);
   free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
   ensures ((R0[32:0] == 0bv32) && Gamma_R0);
-  free ensures (memory_load8_le(mem, 1896bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1897bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1898bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1899bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1896bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1820bv64);
diff --git a/src/test/correct/basic_function_call_caller/clang/basic_function_call_caller_gtirb.expected b/src/test/correct/basic_function_call_caller/clang/basic_function_call_caller_gtirb.expected
index 302d78df0..d9bbf3d49 100644
--- a/src/test/correct/basic_function_call_caller/clang/basic_function_call_caller_gtirb.expected
+++ b/src/test/correct/basic_function_call_caller/clang/basic_function_call_caller_gtirb.expected
@@ -18,8 +18,8 @@ const {:extern} $x_addr: bv64;
 axiom ($x_addr == 69684bv64);
 const {:extern} $y_addr: bv64;
 axiom ($y_addr == 69688bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
-  (if (index == $y_addr) then (memory_load32_le(memory, $x_addr) == 1bv32) else (if (index == $x_addr) then true else false))
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
+  (if (index == $y_addr) then (memory_load32_le(mem$in, $x_addr) == 1bv32) else (if (index == $x_addr) then true else false))
 }
 
 function {:extern} {:bvbuiltin "bvadd"} bvadd64(bv64, bv64) returns (bv64);
@@ -47,10 +47,6 @@ function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv6
   (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
-}
-
 function {:extern} memory_store32_le(memory: [bv64]bv8, index: bv64, value: bv32) returns ([bv64]bv8) {
   memory[index := value[8:0]][bvadd64(index, 1bv64) := value[16:8]][bvadd64(index, 2bv64) := value[24:16]][bvadd64(index, 3bv64) := value[32:24]]
 }
@@ -65,10 +61,7 @@ procedure {:extern} rely();
   ensures (forall i: bv64 :: (((mem[i] == old(mem[i])) ==> (Gamma_mem[i] == old(Gamma_mem[i])))));
   ensures (memory_load32_le(mem, $x_addr) == old(memory_load32_le(mem, $x_addr)));
   ensures (memory_load32_le(mem, $y_addr) == old(memory_load32_le(mem, $y_addr)));
-  free ensures (memory_load8_le(mem, 1896bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1897bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1898bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1899bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1896bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1820bv64);
@@ -107,10 +100,7 @@ procedure main();
   requires (Gamma_R0 == false);
   free requires (memory_load64_le(mem, 69664bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
-  free requires (memory_load8_le(mem, 1896bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1897bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1898bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1899bv64) == 0bv8);
+  free requires (memory_load32_le(mem, 1896bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free requires (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free requires (memory_load64_le(mem, 69592bv64) == 1820bv64);
@@ -119,10 +109,7 @@ procedure main();
   free ensures (Gamma_R31 == old(Gamma_R31));
   free ensures (R29 == old(R29));
   free ensures (R31 == old(R31));
-  free ensures (memory_load8_le(mem, 1896bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1897bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1898bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1899bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1896bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1820bv64);
@@ -186,19 +173,13 @@ implementation main()
 
 procedure zero();
   modifies Gamma_R0, R0;
-  free requires (memory_load8_le(mem, 1896bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1897bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1898bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1899bv64) == 0bv8);
+  free requires (memory_load32_le(mem, 1896bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free requires (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free requires (memory_load64_le(mem, 69592bv64) == 1820bv64);
   free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
   ensures ((R0[32:0] == 0bv32) && Gamma_R0);
-  free ensures (memory_load8_le(mem, 1896bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1897bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1898bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1899bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1896bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1820bv64);
diff --git a/src/test/correct/basic_function_call_caller/clang_O2/basic_function_call_caller.expected b/src/test/correct/basic_function_call_caller/clang_O2/basic_function_call_caller.expected
index 959449774..21551088c 100644
--- a/src/test/correct/basic_function_call_caller/clang_O2/basic_function_call_caller.expected
+++ b/src/test/correct/basic_function_call_caller/clang_O2/basic_function_call_caller.expected
@@ -12,8 +12,8 @@ const {:extern} $x_addr: bv64;
 axiom ($x_addr == 69684bv64);
 const {:extern} $y_addr: bv64;
 axiom ($y_addr == 69688bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
-  (if (index == $y_addr) then (memory_load32_le(memory, $x_addr) == 1bv32) else (if (index == $x_addr) then true else false))
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
+  (if (index == $y_addr) then (memory_load32_le(mem$in, $x_addr) == 1bv32) else (if (index == $x_addr) then true else false))
 }
 
 function {:extern} {:bvbuiltin "bvadd"} bvadd64(bv64, bv64) returns (bv64);
@@ -33,10 +33,6 @@ function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv6
   (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
-}
-
 function {:extern} memory_store32_le(memory: [bv64]bv8, index: bv64, value: bv32) returns ([bv64]bv8) {
   memory[index := value[8:0]][bvadd64(index, 1bv64) := value[16:8]][bvadd64(index, 2bv64) := value[24:16]][bvadd64(index, 3bv64) := value[32:24]]
 }
@@ -47,10 +43,7 @@ procedure {:extern} rely();
   ensures (forall i: bv64 :: (((mem[i] == old(mem[i])) ==> (Gamma_mem[i] == old(Gamma_mem[i])))));
   ensures (memory_load32_le(mem, $x_addr) == old(memory_load32_le(mem, $x_addr)));
   ensures (memory_load32_le(mem, $y_addr) == old(memory_load32_le(mem, $y_addr)));
-  free ensures (memory_load8_le(mem, 1868bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1869bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1870bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1871bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1868bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1820bv64);
@@ -89,18 +82,12 @@ procedure main();
   requires (Gamma_R0 == false);
   free requires (memory_load64_le(mem, 69664bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
-  free requires (memory_load8_le(mem, 1868bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1869bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1870bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1871bv64) == 0bv8);
+  free requires (memory_load32_le(mem, 1868bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free requires (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free requires (memory_load64_le(mem, 69592bv64) == 1820bv64);
   free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
-  free ensures (memory_load8_le(mem, 1868bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1869bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1870bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1871bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1868bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1820bv64);
diff --git a/src/test/correct/basic_function_call_caller/clang_O2/basic_function_call_caller_gtirb.expected b/src/test/correct/basic_function_call_caller/clang_O2/basic_function_call_caller_gtirb.expected
index 7368de672..60c056c27 100644
--- a/src/test/correct/basic_function_call_caller/clang_O2/basic_function_call_caller_gtirb.expected
+++ b/src/test/correct/basic_function_call_caller/clang_O2/basic_function_call_caller_gtirb.expected
@@ -12,8 +12,8 @@ const {:extern} $x_addr: bv64;
 axiom ($x_addr == 69684bv64);
 const {:extern} $y_addr: bv64;
 axiom ($y_addr == 69688bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
-  (if (index == $y_addr) then (memory_load32_le(memory, $x_addr) == 1bv32) else (if (index == $x_addr) then true else false))
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
+  (if (index == $y_addr) then (memory_load32_le(mem$in, $x_addr) == 1bv32) else (if (index == $x_addr) then true else false))
 }
 
 function {:extern} {:bvbuiltin "bvadd"} bvadd64(bv64, bv64) returns (bv64);
@@ -33,10 +33,6 @@ function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv6
   (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
-}
-
 function {:extern} memory_store32_le(memory: [bv64]bv8, index: bv64, value: bv32) returns ([bv64]bv8) {
   memory[index := value[8:0]][bvadd64(index, 1bv64) := value[16:8]][bvadd64(index, 2bv64) := value[24:16]][bvadd64(index, 3bv64) := value[32:24]]
 }
@@ -47,10 +43,7 @@ procedure {:extern} rely();
   ensures (forall i: bv64 :: (((mem[i] == old(mem[i])) ==> (Gamma_mem[i] == old(Gamma_mem[i])))));
   ensures (memory_load32_le(mem, $x_addr) == old(memory_load32_le(mem, $x_addr)));
   ensures (memory_load32_le(mem, $y_addr) == old(memory_load32_le(mem, $y_addr)));
-  free ensures (memory_load8_le(mem, 1868bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1869bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1870bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1871bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1868bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1820bv64);
@@ -89,18 +82,12 @@ procedure main();
   requires (Gamma_R0 == false);
   free requires (memory_load64_le(mem, 69664bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
-  free requires (memory_load8_le(mem, 1868bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1869bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1870bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1871bv64) == 0bv8);
+  free requires (memory_load32_le(mem, 1868bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free requires (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free requires (memory_load64_le(mem, 69592bv64) == 1820bv64);
   free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
-  free ensures (memory_load8_le(mem, 1868bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1869bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1870bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1871bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1868bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1820bv64);
diff --git a/src/test/correct/basic_function_call_caller/clang_pic/basic_function_call_caller.expected b/src/test/correct/basic_function_call_caller/clang_pic/basic_function_call_caller.expected
index dc1090bb5..826223e20 100644
--- a/src/test/correct/basic_function_call_caller/clang_pic/basic_function_call_caller.expected
+++ b/src/test/correct/basic_function_call_caller/clang_pic/basic_function_call_caller.expected
@@ -18,8 +18,8 @@ const {:extern} $x_addr: bv64;
 axiom ($x_addr == 69684bv64);
 const {:extern} $y_addr: bv64;
 axiom ($y_addr == 69688bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
-  (if (index == $y_addr) then (memory_load32_le(memory, $x_addr) == 1bv32) else (if (index == $x_addr) then true else false))
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
+  (if (index == $y_addr) then (memory_load32_le(mem$in, $x_addr) == 1bv32) else (if (index == $x_addr) then true else false))
 }
 
 function {:extern} {:bvbuiltin "bvadd"} bvadd64(bv64, bv64) returns (bv64);
@@ -47,10 +47,6 @@ function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv6
   (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
-}
-
 function {:extern} memory_store32_le(memory: [bv64]bv8, index: bv64, value: bv32) returns ([bv64]bv8) {
   memory[index := value[8:0]][bvadd64(index, 1bv64) := value[16:8]][bvadd64(index, 2bv64) := value[24:16]][bvadd64(index, 3bv64) := value[32:24]]
 }
@@ -65,16 +61,13 @@ procedure {:extern} rely();
   ensures (forall i: bv64 :: (((mem[i] == old(mem[i])) ==> (Gamma_mem[i] == old(Gamma_mem[i])))));
   ensures (memory_load32_le(mem, $x_addr) == old(memory_load32_le(mem, $x_addr)));
   ensures (memory_load32_le(mem, $y_addr) == old(memory_load32_le(mem, $y_addr)));
-  free ensures (memory_load8_le(mem, 1968bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1969bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1970bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1971bv64) == 0bv8);
-  free ensures (memory_load64_le(mem, 69672bv64) == 69672bv64);
-  free ensures (memory_load64_le(mem, 69584bv64) == 69688bv64);
+  free ensures (memory_load32_le(mem, 1968bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69048bv64) == 1872bv64);
+  free ensures (memory_load64_le(mem, 69056bv64) == 1792bv64);
   free ensures (memory_load64_le(mem, 69568bv64) == 69684bv64);
+  free ensures (memory_load64_le(mem, 69584bv64) == 69688bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1884bv64);
-  free ensures (memory_load64_le(mem, 69056bv64) == 1792bv64);
+  free ensures (memory_load64_le(mem, 69672bv64) == 69672bv64);
 
 procedure {:extern} rely_transitive();
   modifies Gamma_mem, mem;
@@ -109,30 +102,24 @@ procedure main();
   requires (Gamma_R0 == false);
   free requires (memory_load64_le(mem, 69664bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
-  free requires (memory_load8_le(mem, 1968bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1969bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1970bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1971bv64) == 0bv8);
-  free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
-  free requires (memory_load64_le(mem, 69584bv64) == 69688bv64);
+  free requires (memory_load32_le(mem, 1968bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69048bv64) == 1872bv64);
+  free requires (memory_load64_le(mem, 69056bv64) == 1792bv64);
   free requires (memory_load64_le(mem, 69568bv64) == 69684bv64);
+  free requires (memory_load64_le(mem, 69584bv64) == 69688bv64);
   free requires (memory_load64_le(mem, 69592bv64) == 1884bv64);
-  free requires (memory_load64_le(mem, 69056bv64) == 1792bv64);
+  free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
   free ensures (Gamma_R29 == old(Gamma_R29));
   free ensures (Gamma_R31 == old(Gamma_R31));
   free ensures (R29 == old(R29));
   free ensures (R31 == old(R31));
-  free ensures (memory_load8_le(mem, 1968bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1969bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1970bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1971bv64) == 0bv8);
-  free ensures (memory_load64_le(mem, 69672bv64) == 69672bv64);
-  free ensures (memory_load64_le(mem, 69584bv64) == 69688bv64);
+  free ensures (memory_load32_le(mem, 1968bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69048bv64) == 1872bv64);
+  free ensures (memory_load64_le(mem, 69056bv64) == 1792bv64);
   free ensures (memory_load64_le(mem, 69568bv64) == 69684bv64);
+  free ensures (memory_load64_le(mem, 69584bv64) == 69688bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1884bv64);
-  free ensures (memory_load64_le(mem, 69056bv64) == 1792bv64);
+  free ensures (memory_load64_le(mem, 69672bv64) == 69672bv64);
 
 implementation main()
 {
@@ -196,27 +183,21 @@ implementation main()
 
 procedure zero();
   modifies Gamma_R0, R0;
-  free requires (memory_load8_le(mem, 1968bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1969bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1970bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1971bv64) == 0bv8);
-  free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
-  free requires (memory_load64_le(mem, 69584bv64) == 69688bv64);
+  free requires (memory_load32_le(mem, 1968bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69048bv64) == 1872bv64);
+  free requires (memory_load64_le(mem, 69056bv64) == 1792bv64);
   free requires (memory_load64_le(mem, 69568bv64) == 69684bv64);
+  free requires (memory_load64_le(mem, 69584bv64) == 69688bv64);
   free requires (memory_load64_le(mem, 69592bv64) == 1884bv64);
-  free requires (memory_load64_le(mem, 69056bv64) == 1792bv64);
+  free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
   ensures ((R0[32:0] == 0bv32) && Gamma_R0);
-  free ensures (memory_load8_le(mem, 1968bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1969bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1970bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1971bv64) == 0bv8);
-  free ensures (memory_load64_le(mem, 69672bv64) == 69672bv64);
-  free ensures (memory_load64_le(mem, 69584bv64) == 69688bv64);
+  free ensures (memory_load32_le(mem, 1968bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69048bv64) == 1872bv64);
+  free ensures (memory_load64_le(mem, 69056bv64) == 1792bv64);
   free ensures (memory_load64_le(mem, 69568bv64) == 69684bv64);
+  free ensures (memory_load64_le(mem, 69584bv64) == 69688bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1884bv64);
-  free ensures (memory_load64_le(mem, 69056bv64) == 1792bv64);
+  free ensures (memory_load64_le(mem, 69672bv64) == 69672bv64);
 
 implementation zero()
 {
diff --git a/src/test/correct/basic_function_call_caller/clang_pic/basic_function_call_caller_gtirb.expected b/src/test/correct/basic_function_call_caller/clang_pic/basic_function_call_caller_gtirb.expected
index fe88b304a..8d53aaa0e 100644
--- a/src/test/correct/basic_function_call_caller/clang_pic/basic_function_call_caller_gtirb.expected
+++ b/src/test/correct/basic_function_call_caller/clang_pic/basic_function_call_caller_gtirb.expected
@@ -18,8 +18,8 @@ const {:extern} $x_addr: bv64;
 axiom ($x_addr == 69684bv64);
 const {:extern} $y_addr: bv64;
 axiom ($y_addr == 69688bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
-  (if (index == $y_addr) then (memory_load32_le(memory, $x_addr) == 1bv32) else (if (index == $x_addr) then true else false))
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
+  (if (index == $y_addr) then (memory_load32_le(mem$in, $x_addr) == 1bv32) else (if (index == $x_addr) then true else false))
 }
 
 function {:extern} {:bvbuiltin "bvadd"} bvadd64(bv64, bv64) returns (bv64);
@@ -47,10 +47,6 @@ function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv6
   (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
-}
-
 function {:extern} memory_store32_le(memory: [bv64]bv8, index: bv64, value: bv32) returns ([bv64]bv8) {
   memory[index := value[8:0]][bvadd64(index, 1bv64) := value[16:8]][bvadd64(index, 2bv64) := value[24:16]][bvadd64(index, 3bv64) := value[32:24]]
 }
@@ -65,16 +61,13 @@ procedure {:extern} rely();
   ensures (forall i: bv64 :: (((mem[i] == old(mem[i])) ==> (Gamma_mem[i] == old(Gamma_mem[i])))));
   ensures (memory_load32_le(mem, $x_addr) == old(memory_load32_le(mem, $x_addr)));
   ensures (memory_load32_le(mem, $y_addr) == old(memory_load32_le(mem, $y_addr)));
-  free ensures (memory_load8_le(mem, 1968bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1969bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1970bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1971bv64) == 0bv8);
-  free ensures (memory_load64_le(mem, 69672bv64) == 69672bv64);
-  free ensures (memory_load64_le(mem, 69584bv64) == 69688bv64);
+  free ensures (memory_load32_le(mem, 1968bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69048bv64) == 1872bv64);
+  free ensures (memory_load64_le(mem, 69056bv64) == 1792bv64);
   free ensures (memory_load64_le(mem, 69568bv64) == 69684bv64);
+  free ensures (memory_load64_le(mem, 69584bv64) == 69688bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1884bv64);
-  free ensures (memory_load64_le(mem, 69056bv64) == 1792bv64);
+  free ensures (memory_load64_le(mem, 69672bv64) == 69672bv64);
 
 procedure {:extern} rely_transitive();
   modifies Gamma_mem, mem;
@@ -106,27 +99,21 @@ implementation {:extern} guarantee_reflexive()
 
 procedure zero();
   modifies Gamma_R0, R0;
-  free requires (memory_load8_le(mem, 1968bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1969bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1970bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1971bv64) == 0bv8);
-  free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
-  free requires (memory_load64_le(mem, 69584bv64) == 69688bv64);
+  free requires (memory_load32_le(mem, 1968bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69048bv64) == 1872bv64);
+  free requires (memory_load64_le(mem, 69056bv64) == 1792bv64);
   free requires (memory_load64_le(mem, 69568bv64) == 69684bv64);
+  free requires (memory_load64_le(mem, 69584bv64) == 69688bv64);
   free requires (memory_load64_le(mem, 69592bv64) == 1884bv64);
-  free requires (memory_load64_le(mem, 69056bv64) == 1792bv64);
+  free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
   ensures ((R0[32:0] == 0bv32) && Gamma_R0);
-  free ensures (memory_load8_le(mem, 1968bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1969bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1970bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1971bv64) == 0bv8);
-  free ensures (memory_load64_le(mem, 69672bv64) == 69672bv64);
-  free ensures (memory_load64_le(mem, 69584bv64) == 69688bv64);
+  free ensures (memory_load32_le(mem, 1968bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69048bv64) == 1872bv64);
+  free ensures (memory_load64_le(mem, 69056bv64) == 1792bv64);
   free ensures (memory_load64_le(mem, 69568bv64) == 69684bv64);
+  free ensures (memory_load64_le(mem, 69584bv64) == 69688bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1884bv64);
-  free ensures (memory_load64_le(mem, 69056bv64) == 1792bv64);
+  free ensures (memory_load64_le(mem, 69672bv64) == 69672bv64);
 
 implementation zero()
 {
@@ -144,30 +131,24 @@ procedure main();
   requires (Gamma_R0 == false);
   free requires (memory_load64_le(mem, 69664bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
-  free requires (memory_load8_le(mem, 1968bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1969bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1970bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1971bv64) == 0bv8);
-  free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
-  free requires (memory_load64_le(mem, 69584bv64) == 69688bv64);
+  free requires (memory_load32_le(mem, 1968bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69048bv64) == 1872bv64);
+  free requires (memory_load64_le(mem, 69056bv64) == 1792bv64);
   free requires (memory_load64_le(mem, 69568bv64) == 69684bv64);
+  free requires (memory_load64_le(mem, 69584bv64) == 69688bv64);
   free requires (memory_load64_le(mem, 69592bv64) == 1884bv64);
-  free requires (memory_load64_le(mem, 69056bv64) == 1792bv64);
+  free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
   free ensures (Gamma_R29 == old(Gamma_R29));
   free ensures (Gamma_R31 == old(Gamma_R31));
   free ensures (R29 == old(R29));
   free ensures (R31 == old(R31));
-  free ensures (memory_load8_le(mem, 1968bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1969bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1970bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1971bv64) == 0bv8);
-  free ensures (memory_load64_le(mem, 69672bv64) == 69672bv64);
-  free ensures (memory_load64_le(mem, 69584bv64) == 69688bv64);
+  free ensures (memory_load32_le(mem, 1968bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69048bv64) == 1872bv64);
+  free ensures (memory_load64_le(mem, 69056bv64) == 1792bv64);
   free ensures (memory_load64_le(mem, 69568bv64) == 69684bv64);
+  free ensures (memory_load64_le(mem, 69584bv64) == 69688bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1884bv64);
-  free ensures (memory_load64_le(mem, 69056bv64) == 1792bv64);
+  free ensures (memory_load64_le(mem, 69672bv64) == 69672bv64);
 
 implementation main()
 {
diff --git a/src/test/correct/basic_function_call_caller/gcc/basic_function_call_caller.expected b/src/test/correct/basic_function_call_caller/gcc/basic_function_call_caller.expected
index 4d6d47afc..617c5bbf6 100644
--- a/src/test/correct/basic_function_call_caller/gcc/basic_function_call_caller.expected
+++ b/src/test/correct/basic_function_call_caller/gcc/basic_function_call_caller.expected
@@ -16,8 +16,8 @@ const {:extern} $x_addr: bv64;
 axiom ($x_addr == 69652bv64);
 const {:extern} $y_addr: bv64;
 axiom ($y_addr == 69656bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
-  (if (index == $y_addr) then (memory_load32_le(memory, $x_addr) == 1bv32) else (if (index == $x_addr) then true else false))
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
+  (if (index == $y_addr) then (memory_load32_le(mem$in, $x_addr) == 1bv32) else (if (index == $x_addr) then true else false))
 }
 
 function {:extern} {:bvbuiltin "bvadd"} bvadd64(bv64, bv64) returns (bv64);
@@ -45,10 +45,6 @@ function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv6
   (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
-}
-
 function {:extern} memory_store32_le(memory: [bv64]bv8, index: bv64, value: bv32) returns ([bv64]bv8) {
   memory[index := value[8:0]][bvadd64(index, 1bv64) := value[16:8]][bvadd64(index, 2bv64) := value[24:16]][bvadd64(index, 3bv64) := value[32:24]]
 }
@@ -63,10 +59,7 @@ procedure {:extern} rely();
   ensures (forall i: bv64 :: (((mem[i] == old(mem[i])) ==> (Gamma_mem[i] == old(Gamma_mem[i])))));
   ensures (memory_load32_le(mem, $x_addr) == old(memory_load32_le(mem, $x_addr)));
   ensures (memory_load32_le(mem, $y_addr) == old(memory_load32_le(mem, $y_addr)));
-  free ensures (memory_load8_le(mem, 1900bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1901bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1902bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1903bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1900bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69016bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69024bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69616bv64) == 1820bv64);
@@ -105,10 +98,7 @@ procedure main();
   requires (Gamma_R0 == false);
   free requires (memory_load64_le(mem, 69632bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free requires (memory_load8_le(mem, 1900bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1901bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1902bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1903bv64) == 0bv8);
+  free requires (memory_load32_le(mem, 1900bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69016bv64) == 1808bv64);
   free requires (memory_load64_le(mem, 69024bv64) == 1728bv64);
   free requires (memory_load64_le(mem, 69616bv64) == 1820bv64);
@@ -117,10 +107,7 @@ procedure main();
   free ensures (Gamma_R31 == old(Gamma_R31));
   free ensures (R29 == old(R29));
   free ensures (R31 == old(R31));
-  free ensures (memory_load8_le(mem, 1900bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1901bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1902bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1903bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1900bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69016bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69024bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69616bv64) == 1820bv64);
@@ -184,19 +171,13 @@ implementation main()
 
 procedure zero();
   modifies Gamma_R0, R0;
-  free requires (memory_load8_le(mem, 1900bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1901bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1902bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1903bv64) == 0bv8);
+  free requires (memory_load32_le(mem, 1900bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69016bv64) == 1808bv64);
   free requires (memory_load64_le(mem, 69024bv64) == 1728bv64);
   free requires (memory_load64_le(mem, 69616bv64) == 1820bv64);
   free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
   ensures ((R0[32:0] == 0bv32) && Gamma_R0);
-  free ensures (memory_load8_le(mem, 1900bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1901bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1902bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1903bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1900bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69016bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69024bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69616bv64) == 1820bv64);
diff --git a/src/test/correct/basic_function_call_caller/gcc/basic_function_call_caller_gtirb.expected b/src/test/correct/basic_function_call_caller/gcc/basic_function_call_caller_gtirb.expected
index aff11e014..ce6869d8e 100644
--- a/src/test/correct/basic_function_call_caller/gcc/basic_function_call_caller_gtirb.expected
+++ b/src/test/correct/basic_function_call_caller/gcc/basic_function_call_caller_gtirb.expected
@@ -16,8 +16,8 @@ const {:extern} $x_addr: bv64;
 axiom ($x_addr == 69652bv64);
 const {:extern} $y_addr: bv64;
 axiom ($y_addr == 69656bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
-  (if (index == $y_addr) then (memory_load32_le(memory, $x_addr) == 1bv32) else (if (index == $x_addr) then true else false))
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
+  (if (index == $y_addr) then (memory_load32_le(mem$in, $x_addr) == 1bv32) else (if (index == $x_addr) then true else false))
 }
 
 function {:extern} {:bvbuiltin "bvadd"} bvadd64(bv64, bv64) returns (bv64);
@@ -45,10 +45,6 @@ function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv6
   (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
-}
-
 function {:extern} memory_store32_le(memory: [bv64]bv8, index: bv64, value: bv32) returns ([bv64]bv8) {
   memory[index := value[8:0]][bvadd64(index, 1bv64) := value[16:8]][bvadd64(index, 2bv64) := value[24:16]][bvadd64(index, 3bv64) := value[32:24]]
 }
@@ -63,10 +59,7 @@ procedure {:extern} rely();
   ensures (forall i: bv64 :: (((mem[i] == old(mem[i])) ==> (Gamma_mem[i] == old(Gamma_mem[i])))));
   ensures (memory_load32_le(mem, $x_addr) == old(memory_load32_le(mem, $x_addr)));
   ensures (memory_load32_le(mem, $y_addr) == old(memory_load32_le(mem, $y_addr)));
-  free ensures (memory_load8_le(mem, 1900bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1901bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1902bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1903bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1900bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69016bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69024bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69616bv64) == 1820bv64);
@@ -105,10 +98,7 @@ procedure main();
   requires (Gamma_R0 == false);
   free requires (memory_load64_le(mem, 69632bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free requires (memory_load8_le(mem, 1900bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1901bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1902bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1903bv64) == 0bv8);
+  free requires (memory_load32_le(mem, 1900bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69016bv64) == 1808bv64);
   free requires (memory_load64_le(mem, 69024bv64) == 1728bv64);
   free requires (memory_load64_le(mem, 69616bv64) == 1820bv64);
@@ -117,10 +107,7 @@ procedure main();
   free ensures (Gamma_R31 == old(Gamma_R31));
   free ensures (R29 == old(R29));
   free ensures (R31 == old(R31));
-  free ensures (memory_load8_le(mem, 1900bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1901bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1902bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1903bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1900bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69016bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69024bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69616bv64) == 1820bv64);
@@ -184,19 +171,13 @@ implementation main()
 
 procedure zero();
   modifies Gamma_R0, R0;
-  free requires (memory_load8_le(mem, 1900bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1901bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1902bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1903bv64) == 0bv8);
+  free requires (memory_load32_le(mem, 1900bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69016bv64) == 1808bv64);
   free requires (memory_load64_le(mem, 69024bv64) == 1728bv64);
   free requires (memory_load64_le(mem, 69616bv64) == 1820bv64);
   free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
   ensures ((R0[32:0] == 0bv32) && Gamma_R0);
-  free ensures (memory_load8_le(mem, 1900bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1901bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1902bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1903bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1900bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69016bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69024bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69616bv64) == 1820bv64);
diff --git a/src/test/correct/basic_function_call_caller/gcc_O2/basic_function_call_caller.expected b/src/test/correct/basic_function_call_caller/gcc_O2/basic_function_call_caller.expected
index d47bc54a9..19ed4fbb5 100644
--- a/src/test/correct/basic_function_call_caller/gcc_O2/basic_function_call_caller.expected
+++ b/src/test/correct/basic_function_call_caller/gcc_O2/basic_function_call_caller.expected
@@ -12,8 +12,8 @@ const {:extern} $x_addr: bv64;
 axiom ($x_addr == 69652bv64);
 const {:extern} $y_addr: bv64;
 axiom ($y_addr == 69656bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
-  (if (index == $y_addr) then (memory_load32_le(memory, $x_addr) == 1bv32) else (if (index == $x_addr) then true else false))
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
+  (if (index == $y_addr) then (memory_load32_le(mem$in, $x_addr) == 1bv32) else (if (index == $x_addr) then true else false))
 }
 
 function {:extern} {:bvbuiltin "bvadd"} bvadd64(bv64, bv64) returns (bv64);
@@ -33,10 +33,6 @@ function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv6
   (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
-}
-
 function {:extern} memory_store32_le(memory: [bv64]bv8, index: bv64, value: bv32) returns ([bv64]bv8) {
   memory[index := value[8:0]][bvadd64(index, 1bv64) := value[16:8]][bvadd64(index, 2bv64) := value[24:16]][bvadd64(index, 3bv64) := value[32:24]]
 }
@@ -47,10 +43,7 @@ procedure {:extern} rely();
   ensures (forall i: bv64 :: (((mem[i] == old(mem[i])) ==> (Gamma_mem[i] == old(Gamma_mem[i])))));
   ensures (memory_load32_le(mem, $x_addr) == old(memory_load32_le(mem, $x_addr)));
   ensures (memory_load32_le(mem, $y_addr) == old(memory_load32_le(mem, $y_addr)));
-  free ensures (memory_load8_le(mem, 1916bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1917bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1918bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1919bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1916bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69016bv64) == 1872bv64);
   free ensures (memory_load64_le(mem, 69024bv64) == 1792bv64);
   free ensures (memory_load64_le(mem, 69616bv64) == 1536bv64);
@@ -89,18 +82,12 @@ procedure main();
   requires (Gamma_R0 == false);
   free requires (memory_load64_le(mem, 69632bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free requires (memory_load8_le(mem, 1916bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1917bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1918bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1919bv64) == 0bv8);
+  free requires (memory_load32_le(mem, 1916bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69016bv64) == 1872bv64);
   free requires (memory_load64_le(mem, 69024bv64) == 1792bv64);
   free requires (memory_load64_le(mem, 69616bv64) == 1536bv64);
   free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free ensures (memory_load8_le(mem, 1916bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1917bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1918bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1919bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1916bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69016bv64) == 1872bv64);
   free ensures (memory_load64_le(mem, 69024bv64) == 1792bv64);
   free ensures (memory_load64_le(mem, 69616bv64) == 1536bv64);
diff --git a/src/test/correct/basic_function_call_caller/gcc_O2/basic_function_call_caller_gtirb.expected b/src/test/correct/basic_function_call_caller/gcc_O2/basic_function_call_caller_gtirb.expected
index d6a304240..e86cb65ba 100644
--- a/src/test/correct/basic_function_call_caller/gcc_O2/basic_function_call_caller_gtirb.expected
+++ b/src/test/correct/basic_function_call_caller/gcc_O2/basic_function_call_caller_gtirb.expected
@@ -12,8 +12,8 @@ const {:extern} $x_addr: bv64;
 axiom ($x_addr == 69652bv64);
 const {:extern} $y_addr: bv64;
 axiom ($y_addr == 69656bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
-  (if (index == $y_addr) then (memory_load32_le(memory, $x_addr) == 1bv32) else (if (index == $x_addr) then true else false))
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
+  (if (index == $y_addr) then (memory_load32_le(mem$in, $x_addr) == 1bv32) else (if (index == $x_addr) then true else false))
 }
 
 function {:extern} {:bvbuiltin "bvadd"} bvadd64(bv64, bv64) returns (bv64);
@@ -33,10 +33,6 @@ function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv6
   (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
-}
-
 function {:extern} memory_store32_le(memory: [bv64]bv8, index: bv64, value: bv32) returns ([bv64]bv8) {
   memory[index := value[8:0]][bvadd64(index, 1bv64) := value[16:8]][bvadd64(index, 2bv64) := value[24:16]][bvadd64(index, 3bv64) := value[32:24]]
 }
@@ -47,10 +43,7 @@ procedure {:extern} rely();
   ensures (forall i: bv64 :: (((mem[i] == old(mem[i])) ==> (Gamma_mem[i] == old(Gamma_mem[i])))));
   ensures (memory_load32_le(mem, $x_addr) == old(memory_load32_le(mem, $x_addr)));
   ensures (memory_load32_le(mem, $y_addr) == old(memory_load32_le(mem, $y_addr)));
-  free ensures (memory_load8_le(mem, 1916bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1917bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1918bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1919bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1916bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69016bv64) == 1872bv64);
   free ensures (memory_load64_le(mem, 69024bv64) == 1792bv64);
   free ensures (memory_load64_le(mem, 69616bv64) == 1536bv64);
@@ -89,18 +82,12 @@ procedure main();
   requires (Gamma_R0 == false);
   free requires (memory_load64_le(mem, 69632bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free requires (memory_load8_le(mem, 1916bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1917bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1918bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1919bv64) == 0bv8);
+  free requires (memory_load32_le(mem, 1916bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69016bv64) == 1872bv64);
   free requires (memory_load64_le(mem, 69024bv64) == 1792bv64);
   free requires (memory_load64_le(mem, 69616bv64) == 1536bv64);
   free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free ensures (memory_load8_le(mem, 1916bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1917bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1918bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1919bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1916bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69016bv64) == 1872bv64);
   free ensures (memory_load64_le(mem, 69024bv64) == 1792bv64);
   free ensures (memory_load64_le(mem, 69616bv64) == 1536bv64);
diff --git a/src/test/correct/basic_function_call_caller/gcc_pic/basic_function_call_caller.expected b/src/test/correct/basic_function_call_caller/gcc_pic/basic_function_call_caller.expected
index 4928f00aa..14f153a77 100644
--- a/src/test/correct/basic_function_call_caller/gcc_pic/basic_function_call_caller.expected
+++ b/src/test/correct/basic_function_call_caller/gcc_pic/basic_function_call_caller.expected
@@ -16,8 +16,8 @@ const {:extern} $x_addr: bv64;
 axiom ($x_addr == 69652bv64);
 const {:extern} $y_addr: bv64;
 axiom ($y_addr == 69656bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
-  (if (index == $y_addr) then (memory_load32_le(memory, $x_addr) == 1bv32) else (if (index == $x_addr) then true else false))
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
+  (if (index == $y_addr) then (memory_load32_le(mem$in, $x_addr) == 1bv32) else (if (index == $x_addr) then true else false))
 }
 
 function {:extern} {:bvbuiltin "bvadd"} bvadd64(bv64, bv64) returns (bv64);
@@ -45,10 +45,6 @@ function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv6
   (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
-}
-
 function {:extern} memory_store32_le(memory: [bv64]bv8, index: bv64, value: bv32) returns ([bv64]bv8) {
   memory[index := value[8:0]][bvadd64(index, 1bv64) := value[16:8]][bvadd64(index, 2bv64) := value[24:16]][bvadd64(index, 3bv64) := value[32:24]]
 }
@@ -63,16 +59,13 @@ procedure {:extern} rely();
   ensures (forall i: bv64 :: (((mem[i] == old(mem[i])) ==> (Gamma_mem[i] == old(Gamma_mem[i])))));
   ensures (memory_load32_le(mem, $x_addr) == old(memory_load32_le(mem, $x_addr)));
   ensures (memory_load32_le(mem, $y_addr) == old(memory_load32_le(mem, $y_addr)));
-  free ensures (memory_load8_le(mem, 1964bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1965bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1966bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1967bv64) == 0bv8);
-  free ensures (memory_load64_le(mem, 69608bv64) == 69656bv64);
-  free ensures (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free ensures (memory_load64_le(mem, 69616bv64) == 1884bv64);
+  free ensures (memory_load32_le(mem, 1964bv64) == 131073bv32);
+  free ensures (memory_load64_le(mem, 69000bv64) == 1872bv64);
   free ensures (memory_load64_le(mem, 69008bv64) == 1792bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 69652bv64);
-  free ensures (memory_load64_le(mem, 69000bv64) == 1872bv64);
+  free ensures (memory_load64_le(mem, 69608bv64) == 69656bv64);
+  free ensures (memory_load64_le(mem, 69616bv64) == 1884bv64);
+  free ensures (memory_load64_le(mem, 69640bv64) == 69640bv64);
 
 procedure {:extern} rely_transitive();
   modifies Gamma_mem, mem;
@@ -107,30 +100,24 @@ procedure main();
   requires (Gamma_R0 == false);
   free requires (memory_load64_le(mem, 69632bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free requires (memory_load8_le(mem, 1964bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1965bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1966bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1967bv64) == 0bv8);
-  free requires (memory_load64_le(mem, 69608bv64) == 69656bv64);
-  free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free requires (memory_load64_le(mem, 69616bv64) == 1884bv64);
+  free requires (memory_load32_le(mem, 1964bv64) == 131073bv32);
+  free requires (memory_load64_le(mem, 69000bv64) == 1872bv64);
   free requires (memory_load64_le(mem, 69008bv64) == 1792bv64);
   free requires (memory_load64_le(mem, 69592bv64) == 69652bv64);
-  free requires (memory_load64_le(mem, 69000bv64) == 1872bv64);
+  free requires (memory_load64_le(mem, 69608bv64) == 69656bv64);
+  free requires (memory_load64_le(mem, 69616bv64) == 1884bv64);
+  free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
   free ensures (Gamma_R29 == old(Gamma_R29));
   free ensures (Gamma_R31 == old(Gamma_R31));
   free ensures (R29 == old(R29));
   free ensures (R31 == old(R31));
-  free ensures (memory_load8_le(mem, 1964bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1965bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1966bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1967bv64) == 0bv8);
-  free ensures (memory_load64_le(mem, 69608bv64) == 69656bv64);
-  free ensures (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free ensures (memory_load64_le(mem, 69616bv64) == 1884bv64);
+  free ensures (memory_load32_le(mem, 1964bv64) == 131073bv32);
+  free ensures (memory_load64_le(mem, 69000bv64) == 1872bv64);
   free ensures (memory_load64_le(mem, 69008bv64) == 1792bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 69652bv64);
-  free ensures (memory_load64_le(mem, 69000bv64) == 1872bv64);
+  free ensures (memory_load64_le(mem, 69608bv64) == 69656bv64);
+  free ensures (memory_load64_le(mem, 69616bv64) == 1884bv64);
+  free ensures (memory_load64_le(mem, 69640bv64) == 69640bv64);
 
 implementation main()
 {
@@ -192,27 +179,21 @@ implementation main()
 
 procedure zero();
   modifies Gamma_R0, R0;
-  free requires (memory_load8_le(mem, 1964bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1965bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1966bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1967bv64) == 0bv8);
-  free requires (memory_load64_le(mem, 69608bv64) == 69656bv64);
-  free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free requires (memory_load64_le(mem, 69616bv64) == 1884bv64);
+  free requires (memory_load32_le(mem, 1964bv64) == 131073bv32);
+  free requires (memory_load64_le(mem, 69000bv64) == 1872bv64);
   free requires (memory_load64_le(mem, 69008bv64) == 1792bv64);
   free requires (memory_load64_le(mem, 69592bv64) == 69652bv64);
-  free requires (memory_load64_le(mem, 69000bv64) == 1872bv64);
+  free requires (memory_load64_le(mem, 69608bv64) == 69656bv64);
+  free requires (memory_load64_le(mem, 69616bv64) == 1884bv64);
+  free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
   ensures ((R0[32:0] == 0bv32) && Gamma_R0);
-  free ensures (memory_load8_le(mem, 1964bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1965bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1966bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1967bv64) == 0bv8);
-  free ensures (memory_load64_le(mem, 69608bv64) == 69656bv64);
-  free ensures (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free ensures (memory_load64_le(mem, 69616bv64) == 1884bv64);
+  free ensures (memory_load32_le(mem, 1964bv64) == 131073bv32);
+  free ensures (memory_load64_le(mem, 69000bv64) == 1872bv64);
   free ensures (memory_load64_le(mem, 69008bv64) == 1792bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 69652bv64);
-  free ensures (memory_load64_le(mem, 69000bv64) == 1872bv64);
+  free ensures (memory_load64_le(mem, 69608bv64) == 69656bv64);
+  free ensures (memory_load64_le(mem, 69616bv64) == 1884bv64);
+  free ensures (memory_load64_le(mem, 69640bv64) == 69640bv64);
 
 implementation zero()
 {
diff --git a/src/test/correct/basic_function_call_caller/gcc_pic/basic_function_call_caller_gtirb.expected b/src/test/correct/basic_function_call_caller/gcc_pic/basic_function_call_caller_gtirb.expected
index 81c0626c8..1bfcdb325 100644
--- a/src/test/correct/basic_function_call_caller/gcc_pic/basic_function_call_caller_gtirb.expected
+++ b/src/test/correct/basic_function_call_caller/gcc_pic/basic_function_call_caller_gtirb.expected
@@ -16,8 +16,8 @@ const {:extern} $x_addr: bv64;
 axiom ($x_addr == 69652bv64);
 const {:extern} $y_addr: bv64;
 axiom ($y_addr == 69656bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
-  (if (index == $y_addr) then (memory_load32_le(memory, $x_addr) == 1bv32) else (if (index == $x_addr) then true else false))
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
+  (if (index == $y_addr) then (memory_load32_le(mem$in, $x_addr) == 1bv32) else (if (index == $x_addr) then true else false))
 }
 
 function {:extern} {:bvbuiltin "bvadd"} bvadd64(bv64, bv64) returns (bv64);
@@ -45,10 +45,6 @@ function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv6
   (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
-}
-
 function {:extern} memory_store32_le(memory: [bv64]bv8, index: bv64, value: bv32) returns ([bv64]bv8) {
   memory[index := value[8:0]][bvadd64(index, 1bv64) := value[16:8]][bvadd64(index, 2bv64) := value[24:16]][bvadd64(index, 3bv64) := value[32:24]]
 }
@@ -63,16 +59,13 @@ procedure {:extern} rely();
   ensures (forall i: bv64 :: (((mem[i] == old(mem[i])) ==> (Gamma_mem[i] == old(Gamma_mem[i])))));
   ensures (memory_load32_le(mem, $x_addr) == old(memory_load32_le(mem, $x_addr)));
   ensures (memory_load32_le(mem, $y_addr) == old(memory_load32_le(mem, $y_addr)));
-  free ensures (memory_load8_le(mem, 1964bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1965bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1966bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1967bv64) == 0bv8);
-  free ensures (memory_load64_le(mem, 69608bv64) == 69656bv64);
-  free ensures (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free ensures (memory_load64_le(mem, 69616bv64) == 1884bv64);
+  free ensures (memory_load32_le(mem, 1964bv64) == 131073bv32);
+  free ensures (memory_load64_le(mem, 69000bv64) == 1872bv64);
   free ensures (memory_load64_le(mem, 69008bv64) == 1792bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 69652bv64);
-  free ensures (memory_load64_le(mem, 69000bv64) == 1872bv64);
+  free ensures (memory_load64_le(mem, 69608bv64) == 69656bv64);
+  free ensures (memory_load64_le(mem, 69616bv64) == 1884bv64);
+  free ensures (memory_load64_le(mem, 69640bv64) == 69640bv64);
 
 procedure {:extern} rely_transitive();
   modifies Gamma_mem, mem;
@@ -104,27 +97,21 @@ implementation {:extern} guarantee_reflexive()
 
 procedure zero();
   modifies Gamma_R0, R0;
-  free requires (memory_load8_le(mem, 1964bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1965bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1966bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1967bv64) == 0bv8);
-  free requires (memory_load64_le(mem, 69608bv64) == 69656bv64);
-  free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free requires (memory_load64_le(mem, 69616bv64) == 1884bv64);
+  free requires (memory_load32_le(mem, 1964bv64) == 131073bv32);
+  free requires (memory_load64_le(mem, 69000bv64) == 1872bv64);
   free requires (memory_load64_le(mem, 69008bv64) == 1792bv64);
   free requires (memory_load64_le(mem, 69592bv64) == 69652bv64);
-  free requires (memory_load64_le(mem, 69000bv64) == 1872bv64);
+  free requires (memory_load64_le(mem, 69608bv64) == 69656bv64);
+  free requires (memory_load64_le(mem, 69616bv64) == 1884bv64);
+  free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
   ensures ((R0[32:0] == 0bv32) && Gamma_R0);
-  free ensures (memory_load8_le(mem, 1964bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1965bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1966bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1967bv64) == 0bv8);
-  free ensures (memory_load64_le(mem, 69608bv64) == 69656bv64);
-  free ensures (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free ensures (memory_load64_le(mem, 69616bv64) == 1884bv64);
+  free ensures (memory_load32_le(mem, 1964bv64) == 131073bv32);
+  free ensures (memory_load64_le(mem, 69000bv64) == 1872bv64);
   free ensures (memory_load64_le(mem, 69008bv64) == 1792bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 69652bv64);
-  free ensures (memory_load64_le(mem, 69000bv64) == 1872bv64);
+  free ensures (memory_load64_le(mem, 69608bv64) == 69656bv64);
+  free ensures (memory_load64_le(mem, 69616bv64) == 1884bv64);
+  free ensures (memory_load64_le(mem, 69640bv64) == 69640bv64);
 
 implementation zero()
 {
@@ -142,30 +129,24 @@ procedure main();
   requires (Gamma_R0 == false);
   free requires (memory_load64_le(mem, 69632bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free requires (memory_load8_le(mem, 1964bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1965bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1966bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1967bv64) == 0bv8);
-  free requires (memory_load64_le(mem, 69608bv64) == 69656bv64);
-  free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free requires (memory_load64_le(mem, 69616bv64) == 1884bv64);
+  free requires (memory_load32_le(mem, 1964bv64) == 131073bv32);
+  free requires (memory_load64_le(mem, 69000bv64) == 1872bv64);
   free requires (memory_load64_le(mem, 69008bv64) == 1792bv64);
   free requires (memory_load64_le(mem, 69592bv64) == 69652bv64);
-  free requires (memory_load64_le(mem, 69000bv64) == 1872bv64);
+  free requires (memory_load64_le(mem, 69608bv64) == 69656bv64);
+  free requires (memory_load64_le(mem, 69616bv64) == 1884bv64);
+  free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
   free ensures (Gamma_R29 == old(Gamma_R29));
   free ensures (Gamma_R31 == old(Gamma_R31));
   free ensures (R29 == old(R29));
   free ensures (R31 == old(R31));
-  free ensures (memory_load8_le(mem, 1964bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1965bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1966bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1967bv64) == 0bv8);
-  free ensures (memory_load64_le(mem, 69608bv64) == 69656bv64);
-  free ensures (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free ensures (memory_load64_le(mem, 69616bv64) == 1884bv64);
+  free ensures (memory_load32_le(mem, 1964bv64) == 131073bv32);
+  free ensures (memory_load64_le(mem, 69000bv64) == 1872bv64);
   free ensures (memory_load64_le(mem, 69008bv64) == 1792bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 69652bv64);
-  free ensures (memory_load64_le(mem, 69000bv64) == 1872bv64);
+  free ensures (memory_load64_le(mem, 69608bv64) == 69656bv64);
+  free ensures (memory_load64_le(mem, 69616bv64) == 1884bv64);
+  free ensures (memory_load64_le(mem, 69640bv64) == 69640bv64);
 
 implementation main()
 {
diff --git a/src/test/correct/basic_function_call_reader/clang/basic_function_call_reader.expected b/src/test/correct/basic_function_call_reader/clang/basic_function_call_reader.expected
index fc411c73f..04f4f6581 100644
--- a/src/test/correct/basic_function_call_reader/clang/basic_function_call_reader.expected
+++ b/src/test/correct/basic_function_call_reader/clang/basic_function_call_reader.expected
@@ -20,8 +20,8 @@ const {:extern} $x_addr: bv64;
 axiom ($x_addr == 69688bv64);
 const {:extern} $y_addr: bv64;
 axiom ($y_addr == 69684bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
-  (if (index == $y_addr) then (memory_load32_le(memory, $x_addr) == 1bv32) else (if (index == $x_addr) then true else false))
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
+  (if (index == $y_addr) then (memory_load32_le(mem$in, $x_addr) == 1bv32) else (if (index == $x_addr) then true else false))
 }
 
 function {:extern} {:bvbuiltin "bvadd"} bvadd32(bv32, bv32) returns (bv32);
@@ -47,10 +47,6 @@ function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv6
   (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
-}
-
 function {:extern} memory_store32_le(memory: [bv64]bv8, index: bv64, value: bv32) returns ([bv64]bv8) {
   memory[index := value[8:0]][bvadd64(index, 1bv64) := value[16:8]][bvadd64(index, 2bv64) := value[24:16]][bvadd64(index, 3bv64) := value[32:24]]
 }
@@ -63,10 +59,7 @@ procedure {:extern} rely();
   ensures (forall i: bv64 :: (((mem[i] == old(mem[i])) ==> (Gamma_mem[i] == old(Gamma_mem[i])))));
   ensures ((old(memory_load32_le(mem, $x_addr)) == 0bv32) ==> (memory_load32_le(mem, $x_addr) == 0bv32));
   ensures (old(gamma_load32(Gamma_mem, $y_addr)) ==> ((memory_load32_le(mem, $x_addr) == 0bv32) || gamma_load32(Gamma_mem, $y_addr)));
-  free ensures (memory_load8_le(mem, 1908bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1909bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1910bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1911bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1908bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1812bv64);
@@ -104,20 +97,14 @@ procedure main();
   modifies CF, Gamma_CF, Gamma_NF, Gamma_R0, Gamma_R31, Gamma_R8, Gamma_VF, Gamma_ZF, Gamma_mem, Gamma_stack, NF, R0, R31, R8, VF, ZF, mem, stack;
   free requires (memory_load64_le(mem, 69664bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
-  free requires (memory_load8_le(mem, 1908bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1909bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1910bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1911bv64) == 0bv8);
+  free requires (memory_load32_le(mem, 1908bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free requires (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free requires (memory_load64_le(mem, 69592bv64) == 1812bv64);
   free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
   free ensures (Gamma_R31 == old(Gamma_R31));
   free ensures (R31 == old(R31));
-  free ensures (memory_load8_le(mem, 1908bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1909bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1910bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1911bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1908bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1812bv64);
diff --git a/src/test/correct/basic_function_call_reader/clang/basic_function_call_reader_gtirb.expected b/src/test/correct/basic_function_call_reader/clang/basic_function_call_reader_gtirb.expected
index 40693258f..ee71f1b77 100644
--- a/src/test/correct/basic_function_call_reader/clang/basic_function_call_reader_gtirb.expected
+++ b/src/test/correct/basic_function_call_reader/clang/basic_function_call_reader_gtirb.expected
@@ -20,8 +20,8 @@ const {:extern} $x_addr: bv64;
 axiom ($x_addr == 69688bv64);
 const {:extern} $y_addr: bv64;
 axiom ($y_addr == 69684bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
-  (if (index == $y_addr) then (memory_load32_le(memory, $x_addr) == 1bv32) else (if (index == $x_addr) then true else false))
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
+  (if (index == $y_addr) then (memory_load32_le(mem$in, $x_addr) == 1bv32) else (if (index == $x_addr) then true else false))
 }
 
 function {:extern} {:bvbuiltin "bvadd"} bvadd32(bv32, bv32) returns (bv32);
@@ -46,10 +46,6 @@ function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv6
   (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
-}
-
 function {:extern} memory_store32_le(memory: [bv64]bv8, index: bv64, value: bv32) returns ([bv64]bv8) {
   memory[index := value[8:0]][bvadd64(index, 1bv64) := value[16:8]][bvadd64(index, 2bv64) := value[24:16]][bvadd64(index, 3bv64) := value[32:24]]
 }
@@ -61,10 +57,7 @@ procedure {:extern} rely();
   ensures (forall i: bv64 :: (((mem[i] == old(mem[i])) ==> (Gamma_mem[i] == old(Gamma_mem[i])))));
   ensures ((old(memory_load32_le(mem, $x_addr)) == 0bv32) ==> (memory_load32_le(mem, $x_addr) == 0bv32));
   ensures (old(gamma_load32(Gamma_mem, $y_addr)) ==> ((memory_load32_le(mem, $x_addr) == 0bv32) || gamma_load32(Gamma_mem, $y_addr)));
-  free ensures (memory_load8_le(mem, 1908bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1909bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1910bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1911bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1908bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1812bv64);
@@ -102,20 +95,14 @@ procedure main();
   modifies CF, Gamma_CF, Gamma_NF, Gamma_R0, Gamma_R31, Gamma_R8, Gamma_VF, Gamma_ZF, Gamma_mem, Gamma_stack, NF, R0, R31, R8, VF, ZF, mem, stack;
   free requires (memory_load64_le(mem, 69664bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
-  free requires (memory_load8_le(mem, 1908bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1909bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1910bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1911bv64) == 0bv8);
+  free requires (memory_load32_le(mem, 1908bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free requires (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free requires (memory_load64_le(mem, 69592bv64) == 1812bv64);
   free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
   free ensures (Gamma_R31 == old(Gamma_R31));
   free ensures (R31 == old(R31));
-  free ensures (memory_load8_le(mem, 1908bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1909bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1910bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1911bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1908bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1812bv64);
diff --git a/src/test/correct/basic_function_call_reader/clang_O2/basic_function_call_reader.expected b/src/test/correct/basic_function_call_reader/clang_O2/basic_function_call_reader.expected
index 3ff9f7584..4e8bfd232 100644
--- a/src/test/correct/basic_function_call_reader/clang_O2/basic_function_call_reader.expected
+++ b/src/test/correct/basic_function_call_reader/clang_O2/basic_function_call_reader.expected
@@ -18,8 +18,8 @@ const {:extern} $x_addr: bv64;
 axiom ($x_addr == 69688bv64);
 const {:extern} $y_addr: bv64;
 axiom ($y_addr == 69684bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
-  (if (index == $y_addr) then (memory_load32_le(memory, $x_addr) == 1bv32) else (if (index == $x_addr) then true else false))
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
+  (if (index == $y_addr) then (memory_load32_le(mem$in, $x_addr) == 1bv32) else (if (index == $x_addr) then true else false))
 }
 
 function {:extern} {:bvbuiltin "bvadd"} bvadd32(bv32, bv32) returns (bv32);
@@ -41,10 +41,6 @@ function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv6
   (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
-}
-
 function {:extern} {:bvbuiltin "sign_extend 1"} sign_extend1_32(bv32) returns (bv33);
 function {:extern} {:bvbuiltin "zero_extend 1"} zero_extend1_32(bv32) returns (bv33);
 function {:extern} {:bvbuiltin "zero_extend 32"} zero_extend32_32(bv32) returns (bv64);
@@ -53,10 +49,7 @@ procedure {:extern} rely();
   ensures (forall i: bv64 :: (((mem[i] == old(mem[i])) ==> (Gamma_mem[i] == old(Gamma_mem[i])))));
   ensures ((old(memory_load32_le(mem, $x_addr)) == 0bv32) ==> (memory_load32_le(mem, $x_addr) == 0bv32));
   ensures (old(gamma_load32(Gamma_mem, $y_addr)) ==> ((memory_load32_le(mem, $x_addr) == 0bv32) || gamma_load32(Gamma_mem, $y_addr)));
-  free ensures (memory_load8_le(mem, 1860bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1861bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1862bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1863bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1860bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1812bv64);
@@ -94,18 +87,12 @@ procedure main();
   modifies CF, Gamma_CF, Gamma_NF, Gamma_R0, Gamma_R8, Gamma_R9, Gamma_VF, Gamma_ZF, Gamma_mem, NF, R0, R8, R9, VF, ZF, mem;
   free requires (memory_load64_le(mem, 69664bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
-  free requires (memory_load8_le(mem, 1860bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1861bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1862bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1863bv64) == 0bv8);
+  free requires (memory_load32_le(mem, 1860bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free requires (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free requires (memory_load64_le(mem, 69592bv64) == 1812bv64);
   free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
-  free ensures (memory_load8_le(mem, 1860bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1861bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1862bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1863bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1860bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1812bv64);
diff --git a/src/test/correct/basic_function_call_reader/clang_O2/basic_function_call_reader_gtirb.expected b/src/test/correct/basic_function_call_reader/clang_O2/basic_function_call_reader_gtirb.expected
index 3b8806447..e49a87798 100644
--- a/src/test/correct/basic_function_call_reader/clang_O2/basic_function_call_reader_gtirb.expected
+++ b/src/test/correct/basic_function_call_reader/clang_O2/basic_function_call_reader_gtirb.expected
@@ -18,8 +18,8 @@ const {:extern} $x_addr: bv64;
 axiom ($x_addr == 69688bv64);
 const {:extern} $y_addr: bv64;
 axiom ($y_addr == 69684bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
-  (if (index == $y_addr) then (memory_load32_le(memory, $x_addr) == 1bv32) else (if (index == $x_addr) then true else false))
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
+  (if (index == $y_addr) then (memory_load32_le(mem$in, $x_addr) == 1bv32) else (if (index == $x_addr) then true else false))
 }
 
 function {:extern} {:bvbuiltin "bvadd"} bvadd32(bv32, bv32) returns (bv32);
@@ -40,10 +40,6 @@ function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv6
   (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
-}
-
 function {:extern} {:bvbuiltin "zero_extend 1"} zero_extend1_32(bv32) returns (bv33);
 function {:extern} {:bvbuiltin "zero_extend 32"} zero_extend32_32(bv32) returns (bv64);
 procedure {:extern} rely();
@@ -51,10 +47,7 @@ procedure {:extern} rely();
   ensures (forall i: bv64 :: (((mem[i] == old(mem[i])) ==> (Gamma_mem[i] == old(Gamma_mem[i])))));
   ensures ((old(memory_load32_le(mem, $x_addr)) == 0bv32) ==> (memory_load32_le(mem, $x_addr) == 0bv32));
   ensures (old(gamma_load32(Gamma_mem, $y_addr)) ==> ((memory_load32_le(mem, $x_addr) == 0bv32) || gamma_load32(Gamma_mem, $y_addr)));
-  free ensures (memory_load8_le(mem, 1860bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1861bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1862bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1863bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1860bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1812bv64);
@@ -92,18 +85,12 @@ procedure main();
   modifies CF, Gamma_CF, Gamma_NF, Gamma_R0, Gamma_R8, Gamma_R9, Gamma_VF, Gamma_ZF, Gamma_mem, NF, R0, R8, R9, VF, ZF, mem;
   free requires (memory_load64_le(mem, 69664bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
-  free requires (memory_load8_le(mem, 1860bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1861bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1862bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1863bv64) == 0bv8);
+  free requires (memory_load32_le(mem, 1860bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free requires (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free requires (memory_load64_le(mem, 69592bv64) == 1812bv64);
   free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
-  free ensures (memory_load8_le(mem, 1860bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1861bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1862bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1863bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1860bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1812bv64);
diff --git a/src/test/correct/basic_function_call_reader/clang_pic/basic_function_call_reader.expected b/src/test/correct/basic_function_call_reader/clang_pic/basic_function_call_reader.expected
index c739e16a6..1e3a52e27 100644
--- a/src/test/correct/basic_function_call_reader/clang_pic/basic_function_call_reader.expected
+++ b/src/test/correct/basic_function_call_reader/clang_pic/basic_function_call_reader.expected
@@ -20,8 +20,8 @@ const {:extern} $x_addr: bv64;
 axiom ($x_addr == 69688bv64);
 const {:extern} $y_addr: bv64;
 axiom ($y_addr == 69684bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
-  (if (index == $y_addr) then (memory_load32_le(memory, $x_addr) == 1bv32) else (if (index == $x_addr) then true else false))
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
+  (if (index == $y_addr) then (memory_load32_le(mem$in, $x_addr) == 1bv32) else (if (index == $x_addr) then true else false))
 }
 
 function {:extern} {:bvbuiltin "bvadd"} bvadd32(bv32, bv32) returns (bv32);
@@ -51,10 +51,6 @@ function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv6
   (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
-}
-
 function {:extern} memory_store32_le(memory: [bv64]bv8, index: bv64, value: bv32) returns ([bv64]bv8) {
   memory[index := value[8:0]][bvadd64(index, 1bv64) := value[16:8]][bvadd64(index, 2bv64) := value[24:16]][bvadd64(index, 3bv64) := value[32:24]]
 }
@@ -67,16 +63,13 @@ procedure {:extern} rely();
   ensures (forall i: bv64 :: (((mem[i] == old(mem[i])) ==> (Gamma_mem[i] == old(Gamma_mem[i])))));
   ensures ((old(memory_load32_le(mem, $x_addr)) == 0bv32) ==> (memory_load32_le(mem, $x_addr) == 0bv32));
   ensures (old(gamma_load32(Gamma_mem, $y_addr)) ==> ((memory_load32_le(mem, $x_addr) == 0bv32) || gamma_load32(Gamma_mem, $y_addr)));
-  free ensures (memory_load8_le(mem, 1980bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1981bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1982bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1983bv64) == 0bv8);
-  free ensures (memory_load64_le(mem, 69672bv64) == 69672bv64);
-  free ensures (memory_load64_le(mem, 69584bv64) == 69684bv64);
+  free ensures (memory_load32_le(mem, 1980bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69048bv64) == 1872bv64);
+  free ensures (memory_load64_le(mem, 69056bv64) == 1792bv64);
   free ensures (memory_load64_le(mem, 69568bv64) == 69688bv64);
+  free ensures (memory_load64_le(mem, 69584bv64) == 69684bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1876bv64);
-  free ensures (memory_load64_le(mem, 69056bv64) == 1792bv64);
+  free ensures (memory_load64_le(mem, 69672bv64) == 69672bv64);
 
 procedure {:extern} rely_transitive();
   modifies Gamma_mem, mem;
@@ -110,28 +103,22 @@ procedure main();
   modifies CF, Gamma_CF, Gamma_NF, Gamma_R0, Gamma_R31, Gamma_R8, Gamma_VF, Gamma_ZF, Gamma_mem, Gamma_stack, NF, R0, R31, R8, VF, ZF, mem, stack;
   free requires (memory_load64_le(mem, 69664bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
-  free requires (memory_load8_le(mem, 1980bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1981bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1982bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1983bv64) == 0bv8);
-  free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
-  free requires (memory_load64_le(mem, 69584bv64) == 69684bv64);
+  free requires (memory_load32_le(mem, 1980bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69048bv64) == 1872bv64);
+  free requires (memory_load64_le(mem, 69056bv64) == 1792bv64);
   free requires (memory_load64_le(mem, 69568bv64) == 69688bv64);
+  free requires (memory_load64_le(mem, 69584bv64) == 69684bv64);
   free requires (memory_load64_le(mem, 69592bv64) == 1876bv64);
-  free requires (memory_load64_le(mem, 69056bv64) == 1792bv64);
+  free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
   free ensures (Gamma_R31 == old(Gamma_R31));
   free ensures (R31 == old(R31));
-  free ensures (memory_load8_le(mem, 1980bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1981bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1982bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1983bv64) == 0bv8);
-  free ensures (memory_load64_le(mem, 69672bv64) == 69672bv64);
-  free ensures (memory_load64_le(mem, 69584bv64) == 69684bv64);
+  free ensures (memory_load32_le(mem, 1980bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69048bv64) == 1872bv64);
+  free ensures (memory_load64_le(mem, 69056bv64) == 1792bv64);
   free ensures (memory_load64_le(mem, 69568bv64) == 69688bv64);
+  free ensures (memory_load64_le(mem, 69584bv64) == 69684bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1876bv64);
-  free ensures (memory_load64_le(mem, 69056bv64) == 1792bv64);
+  free ensures (memory_load64_le(mem, 69672bv64) == 69672bv64);
 
 implementation main()
 {
diff --git a/src/test/correct/basic_function_call_reader/clang_pic/basic_function_call_reader_gtirb.expected b/src/test/correct/basic_function_call_reader/clang_pic/basic_function_call_reader_gtirb.expected
index 18e1b94d5..2cfb9fb78 100644
--- a/src/test/correct/basic_function_call_reader/clang_pic/basic_function_call_reader_gtirb.expected
+++ b/src/test/correct/basic_function_call_reader/clang_pic/basic_function_call_reader_gtirb.expected
@@ -20,8 +20,8 @@ const {:extern} $x_addr: bv64;
 axiom ($x_addr == 69688bv64);
 const {:extern} $y_addr: bv64;
 axiom ($y_addr == 69684bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
-  (if (index == $y_addr) then (memory_load32_le(memory, $x_addr) == 1bv32) else (if (index == $x_addr) then true else false))
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
+  (if (index == $y_addr) then (memory_load32_le(mem$in, $x_addr) == 1bv32) else (if (index == $x_addr) then true else false))
 }
 
 function {:extern} {:bvbuiltin "bvadd"} bvadd32(bv32, bv32) returns (bv32);
@@ -50,10 +50,6 @@ function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv6
   (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
-}
-
 function {:extern} memory_store32_le(memory: [bv64]bv8, index: bv64, value: bv32) returns ([bv64]bv8) {
   memory[index := value[8:0]][bvadd64(index, 1bv64) := value[16:8]][bvadd64(index, 2bv64) := value[24:16]][bvadd64(index, 3bv64) := value[32:24]]
 }
@@ -65,16 +61,13 @@ procedure {:extern} rely();
   ensures (forall i: bv64 :: (((mem[i] == old(mem[i])) ==> (Gamma_mem[i] == old(Gamma_mem[i])))));
   ensures ((old(memory_load32_le(mem, $x_addr)) == 0bv32) ==> (memory_load32_le(mem, $x_addr) == 0bv32));
   ensures (old(gamma_load32(Gamma_mem, $y_addr)) ==> ((memory_load32_le(mem, $x_addr) == 0bv32) || gamma_load32(Gamma_mem, $y_addr)));
-  free ensures (memory_load8_le(mem, 1980bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1981bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1982bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1983bv64) == 0bv8);
-  free ensures (memory_load64_le(mem, 69672bv64) == 69672bv64);
-  free ensures (memory_load64_le(mem, 69584bv64) == 69684bv64);
+  free ensures (memory_load32_le(mem, 1980bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69048bv64) == 1872bv64);
+  free ensures (memory_load64_le(mem, 69056bv64) == 1792bv64);
   free ensures (memory_load64_le(mem, 69568bv64) == 69688bv64);
+  free ensures (memory_load64_le(mem, 69584bv64) == 69684bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1876bv64);
-  free ensures (memory_load64_le(mem, 69056bv64) == 1792bv64);
+  free ensures (memory_load64_le(mem, 69672bv64) == 69672bv64);
 
 procedure {:extern} rely_transitive();
   modifies Gamma_mem, mem;
@@ -108,28 +101,22 @@ procedure main();
   modifies CF, Gamma_CF, Gamma_NF, Gamma_R0, Gamma_R31, Gamma_R8, Gamma_VF, Gamma_ZF, Gamma_mem, Gamma_stack, NF, R0, R31, R8, VF, ZF, mem, stack;
   free requires (memory_load64_le(mem, 69664bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
-  free requires (memory_load8_le(mem, 1980bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1981bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1982bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1983bv64) == 0bv8);
-  free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
-  free requires (memory_load64_le(mem, 69584bv64) == 69684bv64);
+  free requires (memory_load32_le(mem, 1980bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69048bv64) == 1872bv64);
+  free requires (memory_load64_le(mem, 69056bv64) == 1792bv64);
   free requires (memory_load64_le(mem, 69568bv64) == 69688bv64);
+  free requires (memory_load64_le(mem, 69584bv64) == 69684bv64);
   free requires (memory_load64_le(mem, 69592bv64) == 1876bv64);
-  free requires (memory_load64_le(mem, 69056bv64) == 1792bv64);
+  free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
   free ensures (Gamma_R31 == old(Gamma_R31));
   free ensures (R31 == old(R31));
-  free ensures (memory_load8_le(mem, 1980bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1981bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1982bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1983bv64) == 0bv8);
-  free ensures (memory_load64_le(mem, 69672bv64) == 69672bv64);
-  free ensures (memory_load64_le(mem, 69584bv64) == 69684bv64);
+  free ensures (memory_load32_le(mem, 1980bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69048bv64) == 1872bv64);
+  free ensures (memory_load64_le(mem, 69056bv64) == 1792bv64);
   free ensures (memory_load64_le(mem, 69568bv64) == 69688bv64);
+  free ensures (memory_load64_le(mem, 69584bv64) == 69684bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1876bv64);
-  free ensures (memory_load64_le(mem, 69056bv64) == 1792bv64);
+  free ensures (memory_load64_le(mem, 69672bv64) == 69672bv64);
 
 implementation main()
 {
diff --git a/src/test/correct/basic_function_call_reader/gcc/basic_function_call_reader.expected b/src/test/correct/basic_function_call_reader/gcc/basic_function_call_reader.expected
index 874baad70..0298d6790 100644
--- a/src/test/correct/basic_function_call_reader/gcc/basic_function_call_reader.expected
+++ b/src/test/correct/basic_function_call_reader/gcc/basic_function_call_reader.expected
@@ -18,8 +18,8 @@ const {:extern} $x_addr: bv64;
 axiom ($x_addr == 69652bv64);
 const {:extern} $y_addr: bv64;
 axiom ($y_addr == 69656bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
-  (if (index == $y_addr) then (memory_load32_le(memory, $x_addr) == 1bv32) else (if (index == $x_addr) then true else false))
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
+  (if (index == $y_addr) then (memory_load32_le(mem$in, $x_addr) == 1bv32) else (if (index == $x_addr) then true else false))
 }
 
 function {:extern} {:bvbuiltin "bvadd"} bvadd32(bv32, bv32) returns (bv32);
@@ -45,10 +45,6 @@ function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv6
   (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
-}
-
 function {:extern} memory_store32_le(memory: [bv64]bv8, index: bv64, value: bv32) returns ([bv64]bv8) {
   memory[index := value[8:0]][bvadd64(index, 1bv64) := value[16:8]][bvadd64(index, 2bv64) := value[24:16]][bvadd64(index, 3bv64) := value[32:24]]
 }
@@ -61,10 +57,7 @@ procedure {:extern} rely();
   ensures (forall i: bv64 :: (((mem[i] == old(mem[i])) ==> (Gamma_mem[i] == old(Gamma_mem[i])))));
   ensures ((old(memory_load32_le(mem, $x_addr)) == 0bv32) ==> (memory_load32_le(mem, $x_addr) == 0bv32));
   ensures (old(gamma_load32(Gamma_mem, $y_addr)) ==> ((memory_load32_le(mem, $x_addr) == 0bv32) || gamma_load32(Gamma_mem, $y_addr)));
-  free ensures (memory_load8_le(mem, 1892bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1893bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1894bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1895bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1892bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69016bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69024bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69616bv64) == 1812bv64);
@@ -102,20 +95,14 @@ procedure main();
   modifies CF, Gamma_CF, Gamma_NF, Gamma_R0, Gamma_R31, Gamma_VF, Gamma_ZF, Gamma_mem, Gamma_stack, NF, R0, R31, VF, ZF, mem, stack;
   free requires (memory_load64_le(mem, 69632bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free requires (memory_load8_le(mem, 1892bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1893bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1894bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1895bv64) == 0bv8);
+  free requires (memory_load32_le(mem, 1892bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69016bv64) == 1808bv64);
   free requires (memory_load64_le(mem, 69024bv64) == 1728bv64);
   free requires (memory_load64_le(mem, 69616bv64) == 1812bv64);
   free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
   free ensures (Gamma_R31 == old(Gamma_R31));
   free ensures (R31 == old(R31));
-  free ensures (memory_load8_le(mem, 1892bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1893bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1894bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1895bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1892bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69016bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69024bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69616bv64) == 1812bv64);
diff --git a/src/test/correct/basic_function_call_reader/gcc/basic_function_call_reader_gtirb.expected b/src/test/correct/basic_function_call_reader/gcc/basic_function_call_reader_gtirb.expected
index 36c5088ff..6c7a57163 100644
--- a/src/test/correct/basic_function_call_reader/gcc/basic_function_call_reader_gtirb.expected
+++ b/src/test/correct/basic_function_call_reader/gcc/basic_function_call_reader_gtirb.expected
@@ -18,8 +18,8 @@ const {:extern} $x_addr: bv64;
 axiom ($x_addr == 69652bv64);
 const {:extern} $y_addr: bv64;
 axiom ($y_addr == 69656bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
-  (if (index == $y_addr) then (memory_load32_le(memory, $x_addr) == 1bv32) else (if (index == $x_addr) then true else false))
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
+  (if (index == $y_addr) then (memory_load32_le(mem$in, $x_addr) == 1bv32) else (if (index == $x_addr) then true else false))
 }
 
 function {:extern} {:bvbuiltin "bvadd"} bvadd32(bv32, bv32) returns (bv32);
@@ -44,10 +44,6 @@ function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv6
   (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
-}
-
 function {:extern} memory_store32_le(memory: [bv64]bv8, index: bv64, value: bv32) returns ([bv64]bv8) {
   memory[index := value[8:0]][bvadd64(index, 1bv64) := value[16:8]][bvadd64(index, 2bv64) := value[24:16]][bvadd64(index, 3bv64) := value[32:24]]
 }
@@ -59,10 +55,7 @@ procedure {:extern} rely();
   ensures (forall i: bv64 :: (((mem[i] == old(mem[i])) ==> (Gamma_mem[i] == old(Gamma_mem[i])))));
   ensures ((old(memory_load32_le(mem, $x_addr)) == 0bv32) ==> (memory_load32_le(mem, $x_addr) == 0bv32));
   ensures (old(gamma_load32(Gamma_mem, $y_addr)) ==> ((memory_load32_le(mem, $x_addr) == 0bv32) || gamma_load32(Gamma_mem, $y_addr)));
-  free ensures (memory_load8_le(mem, 1892bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1893bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1894bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1895bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1892bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69016bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69024bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69616bv64) == 1812bv64);
@@ -100,20 +93,14 @@ procedure main();
   modifies CF, Gamma_CF, Gamma_NF, Gamma_R0, Gamma_R31, Gamma_VF, Gamma_ZF, Gamma_mem, Gamma_stack, NF, R0, R31, VF, ZF, mem, stack;
   free requires (memory_load64_le(mem, 69632bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free requires (memory_load8_le(mem, 1892bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1893bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1894bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1895bv64) == 0bv8);
+  free requires (memory_load32_le(mem, 1892bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69016bv64) == 1808bv64);
   free requires (memory_load64_le(mem, 69024bv64) == 1728bv64);
   free requires (memory_load64_le(mem, 69616bv64) == 1812bv64);
   free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
   free ensures (Gamma_R31 == old(Gamma_R31));
   free ensures (R31 == old(R31));
-  free ensures (memory_load8_le(mem, 1892bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1893bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1894bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1895bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1892bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69016bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69024bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69616bv64) == 1812bv64);
diff --git a/src/test/correct/basic_function_call_reader/gcc_O2/basic_function_call_reader.expected b/src/test/correct/basic_function_call_reader/gcc_O2/basic_function_call_reader.expected
index daf05e75b..24b255d49 100644
--- a/src/test/correct/basic_function_call_reader/gcc_O2/basic_function_call_reader.expected
+++ b/src/test/correct/basic_function_call_reader/gcc_O2/basic_function_call_reader.expected
@@ -8,8 +8,8 @@ const {:extern} $x_addr: bv64;
 axiom ($x_addr == 69652bv64);
 const {:extern} $y_addr: bv64;
 axiom ($y_addr == 69656bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
-  (if (index == $y_addr) then (memory_load32_le(memory, $x_addr) == 1bv32) else (if (index == $x_addr) then true else false))
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
+  (if (index == $y_addr) then (memory_load32_le(mem$in, $x_addr) == 1bv32) else (if (index == $x_addr) then true else false))
 }
 
 function {:extern} {:bvbuiltin "bvadd"} bvadd64(bv64, bv64) returns (bv64);
@@ -26,20 +26,13 @@ function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv6
   (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
-}
-
 function {:extern} {:bvbuiltin "zero_extend 32"} zero_extend32_32(bv32) returns (bv64);
 procedure {:extern} rely();
   modifies Gamma_mem, mem;
   ensures (forall i: bv64 :: (((mem[i] == old(mem[i])) ==> (Gamma_mem[i] == old(Gamma_mem[i])))));
   ensures ((old(memory_load32_le(mem, $x_addr)) == 0bv32) ==> (memory_load32_le(mem, $x_addr) == 0bv32));
   ensures (old(gamma_load32(Gamma_mem, $y_addr)) ==> ((memory_load32_le(mem, $x_addr) == 0bv32) || gamma_load32(Gamma_mem, $y_addr)));
-  free ensures (memory_load8_le(mem, 1896bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1897bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1898bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1899bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1896bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69016bv64) == 1872bv64);
   free ensures (memory_load64_le(mem, 69024bv64) == 1792bv64);
   free ensures (memory_load64_le(mem, 69616bv64) == 1536bv64);
@@ -77,18 +70,12 @@ procedure main();
   modifies Gamma_R0, Gamma_R1, Gamma_mem, R0, R1, mem;
   free requires (memory_load64_le(mem, 69632bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free requires (memory_load8_le(mem, 1896bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1897bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1898bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1899bv64) == 0bv8);
+  free requires (memory_load32_le(mem, 1896bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69016bv64) == 1872bv64);
   free requires (memory_load64_le(mem, 69024bv64) == 1792bv64);
   free requires (memory_load64_le(mem, 69616bv64) == 1536bv64);
   free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free ensures (memory_load8_le(mem, 1896bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1897bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1898bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1899bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1896bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69016bv64) == 1872bv64);
   free ensures (memory_load64_le(mem, 69024bv64) == 1792bv64);
   free ensures (memory_load64_le(mem, 69616bv64) == 1536bv64);
diff --git a/src/test/correct/basic_function_call_reader/gcc_O2/basic_function_call_reader_gtirb.expected b/src/test/correct/basic_function_call_reader/gcc_O2/basic_function_call_reader_gtirb.expected
index 404c6e24c..e70c005df 100644
--- a/src/test/correct/basic_function_call_reader/gcc_O2/basic_function_call_reader_gtirb.expected
+++ b/src/test/correct/basic_function_call_reader/gcc_O2/basic_function_call_reader_gtirb.expected
@@ -8,8 +8,8 @@ const {:extern} $x_addr: bv64;
 axiom ($x_addr == 69652bv64);
 const {:extern} $y_addr: bv64;
 axiom ($y_addr == 69656bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
-  (if (index == $y_addr) then (memory_load32_le(memory, $x_addr) == 1bv32) else (if (index == $x_addr) then true else false))
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
+  (if (index == $y_addr) then (memory_load32_le(mem$in, $x_addr) == 1bv32) else (if (index == $x_addr) then true else false))
 }
 
 function {:extern} {:bvbuiltin "bvadd"} bvadd64(bv64, bv64) returns (bv64);
@@ -25,20 +25,13 @@ function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv6
   (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
-}
-
 function {:extern} {:bvbuiltin "zero_extend 32"} zero_extend32_32(bv32) returns (bv64);
 procedure {:extern} rely();
   modifies Gamma_mem, mem;
   ensures (forall i: bv64 :: (((mem[i] == old(mem[i])) ==> (Gamma_mem[i] == old(Gamma_mem[i])))));
   ensures ((old(memory_load32_le(mem, $x_addr)) == 0bv32) ==> (memory_load32_le(mem, $x_addr) == 0bv32));
   ensures (old(gamma_load32(Gamma_mem, $y_addr)) ==> ((memory_load32_le(mem, $x_addr) == 0bv32) || gamma_load32(Gamma_mem, $y_addr)));
-  free ensures (memory_load8_le(mem, 1896bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1897bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1898bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1899bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1896bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69016bv64) == 1872bv64);
   free ensures (memory_load64_le(mem, 69024bv64) == 1792bv64);
   free ensures (memory_load64_le(mem, 69616bv64) == 1536bv64);
@@ -76,18 +69,12 @@ procedure main();
   modifies Gamma_R0, Gamma_R1, Gamma_mem, R0, R1, mem;
   free requires (memory_load64_le(mem, 69632bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free requires (memory_load8_le(mem, 1896bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1897bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1898bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1899bv64) == 0bv8);
+  free requires (memory_load32_le(mem, 1896bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69016bv64) == 1872bv64);
   free requires (memory_load64_le(mem, 69024bv64) == 1792bv64);
   free requires (memory_load64_le(mem, 69616bv64) == 1536bv64);
   free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free ensures (memory_load8_le(mem, 1896bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1897bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1898bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1899bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1896bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69016bv64) == 1872bv64);
   free ensures (memory_load64_le(mem, 69024bv64) == 1792bv64);
   free ensures (memory_load64_le(mem, 69616bv64) == 1536bv64);
diff --git a/src/test/correct/basic_function_call_reader/gcc_pic/basic_function_call_reader.expected b/src/test/correct/basic_function_call_reader/gcc_pic/basic_function_call_reader.expected
index 4dee04924..8b7fd2872 100644
--- a/src/test/correct/basic_function_call_reader/gcc_pic/basic_function_call_reader.expected
+++ b/src/test/correct/basic_function_call_reader/gcc_pic/basic_function_call_reader.expected
@@ -18,8 +18,8 @@ const {:extern} $x_addr: bv64;
 axiom ($x_addr == 69652bv64);
 const {:extern} $y_addr: bv64;
 axiom ($y_addr == 69656bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
-  (if (index == $y_addr) then (memory_load32_le(memory, $x_addr) == 1bv32) else (if (index == $x_addr) then true else false))
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
+  (if (index == $y_addr) then (memory_load32_le(mem$in, $x_addr) == 1bv32) else (if (index == $x_addr) then true else false))
 }
 
 function {:extern} {:bvbuiltin "bvadd"} bvadd32(bv32, bv32) returns (bv32);
@@ -49,10 +49,6 @@ function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv6
   (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
-}
-
 function {:extern} memory_store32_le(memory: [bv64]bv8, index: bv64, value: bv32) returns ([bv64]bv8) {
   memory[index := value[8:0]][bvadd64(index, 1bv64) := value[16:8]][bvadd64(index, 2bv64) := value[24:16]][bvadd64(index, 3bv64) := value[32:24]]
 }
@@ -65,16 +61,13 @@ procedure {:extern} rely();
   ensures (forall i: bv64 :: (((mem[i] == old(mem[i])) ==> (Gamma_mem[i] == old(Gamma_mem[i])))));
   ensures ((old(memory_load32_le(mem, $x_addr)) == 0bv32) ==> (memory_load32_le(mem, $x_addr) == 0bv32));
   ensures (old(gamma_load32(Gamma_mem, $y_addr)) ==> ((memory_load32_le(mem, $x_addr) == 0bv32) || gamma_load32(Gamma_mem, $y_addr)));
-  free ensures (memory_load8_le(mem, 1956bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1957bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1958bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1959bv64) == 0bv8);
-  free ensures (memory_load64_le(mem, 69608bv64) == 69656bv64);
-  free ensures (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free ensures (memory_load64_le(mem, 69616bv64) == 1876bv64);
+  free ensures (memory_load32_le(mem, 1956bv64) == 131073bv32);
+  free ensures (memory_load64_le(mem, 69000bv64) == 1872bv64);
   free ensures (memory_load64_le(mem, 69008bv64) == 1792bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 69652bv64);
-  free ensures (memory_load64_le(mem, 69000bv64) == 1872bv64);
+  free ensures (memory_load64_le(mem, 69608bv64) == 69656bv64);
+  free ensures (memory_load64_le(mem, 69616bv64) == 1876bv64);
+  free ensures (memory_load64_le(mem, 69640bv64) == 69640bv64);
 
 procedure {:extern} rely_transitive();
   modifies Gamma_mem, mem;
@@ -108,28 +101,22 @@ procedure main();
   modifies CF, Gamma_CF, Gamma_NF, Gamma_R0, Gamma_R31, Gamma_VF, Gamma_ZF, Gamma_mem, Gamma_stack, NF, R0, R31, VF, ZF, mem, stack;
   free requires (memory_load64_le(mem, 69632bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free requires (memory_load8_le(mem, 1956bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1957bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1958bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1959bv64) == 0bv8);
-  free requires (memory_load64_le(mem, 69608bv64) == 69656bv64);
-  free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free requires (memory_load64_le(mem, 69616bv64) == 1876bv64);
+  free requires (memory_load32_le(mem, 1956bv64) == 131073bv32);
+  free requires (memory_load64_le(mem, 69000bv64) == 1872bv64);
   free requires (memory_load64_le(mem, 69008bv64) == 1792bv64);
   free requires (memory_load64_le(mem, 69592bv64) == 69652bv64);
-  free requires (memory_load64_le(mem, 69000bv64) == 1872bv64);
+  free requires (memory_load64_le(mem, 69608bv64) == 69656bv64);
+  free requires (memory_load64_le(mem, 69616bv64) == 1876bv64);
+  free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
   free ensures (Gamma_R31 == old(Gamma_R31));
   free ensures (R31 == old(R31));
-  free ensures (memory_load8_le(mem, 1956bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1957bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1958bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1959bv64) == 0bv8);
-  free ensures (memory_load64_le(mem, 69608bv64) == 69656bv64);
-  free ensures (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free ensures (memory_load64_le(mem, 69616bv64) == 1876bv64);
+  free ensures (memory_load32_le(mem, 1956bv64) == 131073bv32);
+  free ensures (memory_load64_le(mem, 69000bv64) == 1872bv64);
   free ensures (memory_load64_le(mem, 69008bv64) == 1792bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 69652bv64);
-  free ensures (memory_load64_le(mem, 69000bv64) == 1872bv64);
+  free ensures (memory_load64_le(mem, 69608bv64) == 69656bv64);
+  free ensures (memory_load64_le(mem, 69616bv64) == 1876bv64);
+  free ensures (memory_load64_le(mem, 69640bv64) == 69640bv64);
 
 implementation main()
 {
diff --git a/src/test/correct/basic_function_call_reader/gcc_pic/basic_function_call_reader_gtirb.expected b/src/test/correct/basic_function_call_reader/gcc_pic/basic_function_call_reader_gtirb.expected
index 080e84267..fece62d2b 100644
--- a/src/test/correct/basic_function_call_reader/gcc_pic/basic_function_call_reader_gtirb.expected
+++ b/src/test/correct/basic_function_call_reader/gcc_pic/basic_function_call_reader_gtirb.expected
@@ -18,8 +18,8 @@ const {:extern} $x_addr: bv64;
 axiom ($x_addr == 69652bv64);
 const {:extern} $y_addr: bv64;
 axiom ($y_addr == 69656bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
-  (if (index == $y_addr) then (memory_load32_le(memory, $x_addr) == 1bv32) else (if (index == $x_addr) then true else false))
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
+  (if (index == $y_addr) then (memory_load32_le(mem$in, $x_addr) == 1bv32) else (if (index == $x_addr) then true else false))
 }
 
 function {:extern} {:bvbuiltin "bvadd"} bvadd32(bv32, bv32) returns (bv32);
@@ -48,10 +48,6 @@ function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv6
   (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
-}
-
 function {:extern} memory_store32_le(memory: [bv64]bv8, index: bv64, value: bv32) returns ([bv64]bv8) {
   memory[index := value[8:0]][bvadd64(index, 1bv64) := value[16:8]][bvadd64(index, 2bv64) := value[24:16]][bvadd64(index, 3bv64) := value[32:24]]
 }
@@ -63,16 +59,13 @@ procedure {:extern} rely();
   ensures (forall i: bv64 :: (((mem[i] == old(mem[i])) ==> (Gamma_mem[i] == old(Gamma_mem[i])))));
   ensures ((old(memory_load32_le(mem, $x_addr)) == 0bv32) ==> (memory_load32_le(mem, $x_addr) == 0bv32));
   ensures (old(gamma_load32(Gamma_mem, $y_addr)) ==> ((memory_load32_le(mem, $x_addr) == 0bv32) || gamma_load32(Gamma_mem, $y_addr)));
-  free ensures (memory_load8_le(mem, 1956bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1957bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1958bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1959bv64) == 0bv8);
-  free ensures (memory_load64_le(mem, 69608bv64) == 69656bv64);
-  free ensures (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free ensures (memory_load64_le(mem, 69616bv64) == 1876bv64);
+  free ensures (memory_load32_le(mem, 1956bv64) == 131073bv32);
+  free ensures (memory_load64_le(mem, 69000bv64) == 1872bv64);
   free ensures (memory_load64_le(mem, 69008bv64) == 1792bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 69652bv64);
-  free ensures (memory_load64_le(mem, 69000bv64) == 1872bv64);
+  free ensures (memory_load64_le(mem, 69608bv64) == 69656bv64);
+  free ensures (memory_load64_le(mem, 69616bv64) == 1876bv64);
+  free ensures (memory_load64_le(mem, 69640bv64) == 69640bv64);
 
 procedure {:extern} rely_transitive();
   modifies Gamma_mem, mem;
@@ -106,28 +99,22 @@ procedure main();
   modifies CF, Gamma_CF, Gamma_NF, Gamma_R0, Gamma_R31, Gamma_VF, Gamma_ZF, Gamma_mem, Gamma_stack, NF, R0, R31, VF, ZF, mem, stack;
   free requires (memory_load64_le(mem, 69632bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free requires (memory_load8_le(mem, 1956bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1957bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1958bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1959bv64) == 0bv8);
-  free requires (memory_load64_le(mem, 69608bv64) == 69656bv64);
-  free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free requires (memory_load64_le(mem, 69616bv64) == 1876bv64);
+  free requires (memory_load32_le(mem, 1956bv64) == 131073bv32);
+  free requires (memory_load64_le(mem, 69000bv64) == 1872bv64);
   free requires (memory_load64_le(mem, 69008bv64) == 1792bv64);
   free requires (memory_load64_le(mem, 69592bv64) == 69652bv64);
-  free requires (memory_load64_le(mem, 69000bv64) == 1872bv64);
+  free requires (memory_load64_le(mem, 69608bv64) == 69656bv64);
+  free requires (memory_load64_le(mem, 69616bv64) == 1876bv64);
+  free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
   free ensures (Gamma_R31 == old(Gamma_R31));
   free ensures (R31 == old(R31));
-  free ensures (memory_load8_le(mem, 1956bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1957bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1958bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1959bv64) == 0bv8);
-  free ensures (memory_load64_le(mem, 69608bv64) == 69656bv64);
-  free ensures (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free ensures (memory_load64_le(mem, 69616bv64) == 1876bv64);
+  free ensures (memory_load32_le(mem, 1956bv64) == 131073bv32);
+  free ensures (memory_load64_le(mem, 69000bv64) == 1872bv64);
   free ensures (memory_load64_le(mem, 69008bv64) == 1792bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 69652bv64);
-  free ensures (memory_load64_le(mem, 69000bv64) == 1872bv64);
+  free ensures (memory_load64_le(mem, 69608bv64) == 69656bv64);
+  free ensures (memory_load64_le(mem, 69616bv64) == 1876bv64);
+  free ensures (memory_load64_le(mem, 69640bv64) == 69640bv64);
 
 implementation main()
 {
diff --git a/src/test/correct/basic_lock_read/clang/basic_lock_read.expected b/src/test/correct/basic_lock_read/clang/basic_lock_read.expected
index 4b0e5107e..318bf0e75 100644
--- a/src/test/correct/basic_lock_read/clang/basic_lock_read.expected
+++ b/src/test/correct/basic_lock_read/clang/basic_lock_read.expected
@@ -20,7 +20,7 @@ const {:extern} $x_addr: bv64;
 axiom ($x_addr == 69688bv64);
 const {:extern} $z_addr: bv64;
 axiom ($z_addr == 69684bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
   (if (index == $x_addr) then true else (if (index == $z_addr) then true else false))
 }
 
@@ -47,10 +47,6 @@ function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv6
   (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
-}
-
 function {:extern} memory_store32_le(memory: [bv64]bv8, index: bv64, value: bv32) returns ([bv64]bv8) {
   memory[index := value[8:0]][bvadd64(index, 1bv64) := value[16:8]][bvadd64(index, 2bv64) := value[24:16]][bvadd64(index, 3bv64) := value[32:24]]
 }
@@ -62,10 +58,7 @@ procedure {:extern} rely();
   modifies Gamma_mem, mem;
   ensures (forall i: bv64 :: (((mem[i] == old(mem[i])) ==> (Gamma_mem[i] == old(Gamma_mem[i])))));
   ensures ((old(memory_load32_le(mem, $z_addr)) == 0bv32) ==> ((memory_load32_le(mem, $x_addr) == old(memory_load32_le(mem, $x_addr))) && (memory_load32_le(mem, $z_addr) == old(memory_load32_le(mem, $z_addr)))));
-  free ensures (memory_load8_le(mem, 1900bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1901bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1902bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1903bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1900bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1812bv64);
@@ -100,10 +93,7 @@ procedure main();
   modifies CF, Gamma_CF, Gamma_NF, Gamma_R0, Gamma_R31, Gamma_R8, Gamma_VF, Gamma_ZF, Gamma_mem, Gamma_stack, NF, R0, R31, R8, VF, ZF, mem, stack;
   free requires (memory_load64_le(mem, 69664bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
-  free requires (memory_load8_le(mem, 1900bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1901bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1902bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1903bv64) == 0bv8);
+  free requires (memory_load32_le(mem, 1900bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free requires (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free requires (memory_load64_le(mem, 69592bv64) == 1812bv64);
@@ -111,10 +101,7 @@ procedure main();
   ensures (R0[32:0] == 0bv32);
   free ensures (Gamma_R31 == old(Gamma_R31));
   free ensures (R31 == old(R31));
-  free ensures (memory_load8_le(mem, 1900bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1901bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1902bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1903bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1900bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1812bv64);
diff --git a/src/test/correct/basic_lock_read/clang/basic_lock_read_gtirb.expected b/src/test/correct/basic_lock_read/clang/basic_lock_read_gtirb.expected
index 613afcdf3..e4f7d61f9 100644
--- a/src/test/correct/basic_lock_read/clang/basic_lock_read_gtirb.expected
+++ b/src/test/correct/basic_lock_read/clang/basic_lock_read_gtirb.expected
@@ -20,7 +20,7 @@ const {:extern} $x_addr: bv64;
 axiom ($x_addr == 69688bv64);
 const {:extern} $z_addr: bv64;
 axiom ($z_addr == 69684bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
   (if (index == $x_addr) then true else (if (index == $z_addr) then true else false))
 }
 
@@ -46,10 +46,6 @@ function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv6
   (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
-}
-
 function {:extern} memory_store32_le(memory: [bv64]bv8, index: bv64, value: bv32) returns ([bv64]bv8) {
   memory[index := value[8:0]][bvadd64(index, 1bv64) := value[16:8]][bvadd64(index, 2bv64) := value[24:16]][bvadd64(index, 3bv64) := value[32:24]]
 }
@@ -60,10 +56,7 @@ procedure {:extern} rely();
   modifies Gamma_mem, mem;
   ensures (forall i: bv64 :: (((mem[i] == old(mem[i])) ==> (Gamma_mem[i] == old(Gamma_mem[i])))));
   ensures ((old(memory_load32_le(mem, $z_addr)) == 0bv32) ==> ((memory_load32_le(mem, $x_addr) == old(memory_load32_le(mem, $x_addr))) && (memory_load32_le(mem, $z_addr) == old(memory_load32_le(mem, $z_addr)))));
-  free ensures (memory_load8_le(mem, 1900bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1901bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1902bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1903bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1900bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1812bv64);
@@ -98,10 +91,7 @@ procedure main();
   modifies CF, Gamma_CF, Gamma_NF, Gamma_R0, Gamma_R31, Gamma_R8, Gamma_VF, Gamma_ZF, Gamma_mem, Gamma_stack, NF, R0, R31, R8, VF, ZF, mem, stack;
   free requires (memory_load64_le(mem, 69664bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
-  free requires (memory_load8_le(mem, 1900bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1901bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1902bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1903bv64) == 0bv8);
+  free requires (memory_load32_le(mem, 1900bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free requires (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free requires (memory_load64_le(mem, 69592bv64) == 1812bv64);
@@ -109,10 +99,7 @@ procedure main();
   ensures (R0[32:0] == 0bv32);
   free ensures (Gamma_R31 == old(Gamma_R31));
   free ensures (R31 == old(R31));
-  free ensures (memory_load8_le(mem, 1900bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1901bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1902bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1903bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1900bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1812bv64);
diff --git a/src/test/correct/basic_lock_read/clang_O2/basic_lock_read.expected b/src/test/correct/basic_lock_read/clang_O2/basic_lock_read.expected
index 95305362e..2391ae1ea 100644
--- a/src/test/correct/basic_lock_read/clang_O2/basic_lock_read.expected
+++ b/src/test/correct/basic_lock_read/clang_O2/basic_lock_read.expected
@@ -8,7 +8,7 @@ const {:extern} $x_addr: bv64;
 axiom ($x_addr == 69688bv64);
 const {:extern} $z_addr: bv64;
 axiom ($z_addr == 69684bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
   (if (index == $x_addr) then true else (if (index == $z_addr) then true else false))
 }
 
@@ -30,10 +30,6 @@ function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv6
   (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
-}
-
 function {:extern} memory_store32_le(memory: [bv64]bv8, index: bv64, value: bv32) returns ([bv64]bv8) {
   memory[index := value[8:0]][bvadd64(index, 1bv64) := value[16:8]][bvadd64(index, 2bv64) := value[24:16]][bvadd64(index, 3bv64) := value[32:24]]
 }
@@ -43,10 +39,7 @@ procedure {:extern} rely();
   modifies Gamma_mem, mem;
   ensures (forall i: bv64 :: (((mem[i] == old(mem[i])) ==> (Gamma_mem[i] == old(Gamma_mem[i])))));
   ensures ((old(memory_load32_le(mem, $z_addr)) == 0bv32) ==> ((memory_load32_le(mem, $x_addr) == old(memory_load32_le(mem, $x_addr))) && (memory_load32_le(mem, $z_addr) == old(memory_load32_le(mem, $z_addr)))));
-  free ensures (memory_load8_le(mem, 1868bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1869bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1870bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1871bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1868bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1812bv64);
@@ -81,19 +74,13 @@ procedure main();
   modifies Gamma_R0, Gamma_R8, Gamma_mem, R0, R8, mem;
   free requires (memory_load64_le(mem, 69664bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
-  free requires (memory_load8_le(mem, 1868bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1869bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1870bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1871bv64) == 0bv8);
+  free requires (memory_load32_le(mem, 1868bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free requires (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free requires (memory_load64_le(mem, 69592bv64) == 1812bv64);
   free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
   ensures (R0[32:0] == 0bv32);
-  free ensures (memory_load8_le(mem, 1868bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1869bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1870bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1871bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1868bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1812bv64);
diff --git a/src/test/correct/basic_lock_read/clang_O2/basic_lock_read_gtirb.expected b/src/test/correct/basic_lock_read/clang_O2/basic_lock_read_gtirb.expected
index 7d1102980..117b59484 100644
--- a/src/test/correct/basic_lock_read/clang_O2/basic_lock_read_gtirb.expected
+++ b/src/test/correct/basic_lock_read/clang_O2/basic_lock_read_gtirb.expected
@@ -8,7 +8,7 @@ const {:extern} $x_addr: bv64;
 axiom ($x_addr == 69688bv64);
 const {:extern} $z_addr: bv64;
 axiom ($z_addr == 69684bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
   (if (index == $x_addr) then true else (if (index == $z_addr) then true else false))
 }
 
@@ -29,10 +29,6 @@ function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv6
   (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
-}
-
 function {:extern} memory_store32_le(memory: [bv64]bv8, index: bv64, value: bv32) returns ([bv64]bv8) {
   memory[index := value[8:0]][bvadd64(index, 1bv64) := value[16:8]][bvadd64(index, 2bv64) := value[24:16]][bvadd64(index, 3bv64) := value[32:24]]
 }
@@ -42,10 +38,7 @@ procedure {:extern} rely();
   modifies Gamma_mem, mem;
   ensures (forall i: bv64 :: (((mem[i] == old(mem[i])) ==> (Gamma_mem[i] == old(Gamma_mem[i])))));
   ensures ((old(memory_load32_le(mem, $z_addr)) == 0bv32) ==> ((memory_load32_le(mem, $x_addr) == old(memory_load32_le(mem, $x_addr))) && (memory_load32_le(mem, $z_addr) == old(memory_load32_le(mem, $z_addr)))));
-  free ensures (memory_load8_le(mem, 1868bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1869bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1870bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1871bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1868bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1812bv64);
@@ -80,19 +73,13 @@ procedure main();
   modifies Gamma_R0, Gamma_R8, Gamma_mem, R0, R8, mem;
   free requires (memory_load64_le(mem, 69664bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
-  free requires (memory_load8_le(mem, 1868bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1869bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1870bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1871bv64) == 0bv8);
+  free requires (memory_load32_le(mem, 1868bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free requires (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free requires (memory_load64_le(mem, 69592bv64) == 1812bv64);
   free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
   ensures (R0[32:0] == 0bv32);
-  free ensures (memory_load8_le(mem, 1868bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1869bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1870bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1871bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1868bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1812bv64);
diff --git a/src/test/correct/basic_lock_read/clang_pic/basic_lock_read.expected b/src/test/correct/basic_lock_read/clang_pic/basic_lock_read.expected
index 6a6ad0a7b..a46a23494 100644
--- a/src/test/correct/basic_lock_read/clang_pic/basic_lock_read.expected
+++ b/src/test/correct/basic_lock_read/clang_pic/basic_lock_read.expected
@@ -20,7 +20,7 @@ const {:extern} $x_addr: bv64;
 axiom ($x_addr == 69688bv64);
 const {:extern} $z_addr: bv64;
 axiom ($z_addr == 69684bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
   (if (index == $x_addr) then true else (if (index == $z_addr) then true else false))
 }
 
@@ -51,10 +51,6 @@ function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv6
   (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
-}
-
 function {:extern} memory_store32_le(memory: [bv64]bv8, index: bv64, value: bv32) returns ([bv64]bv8) {
   memory[index := value[8:0]][bvadd64(index, 1bv64) := value[16:8]][bvadd64(index, 2bv64) := value[24:16]][bvadd64(index, 3bv64) := value[32:24]]
 }
@@ -66,16 +62,13 @@ procedure {:extern} rely();
   modifies Gamma_mem, mem;
   ensures (forall i: bv64 :: (((mem[i] == old(mem[i])) ==> (Gamma_mem[i] == old(Gamma_mem[i])))));
   ensures ((old(memory_load32_le(mem, $z_addr)) == 0bv32) ==> ((memory_load32_le(mem, $x_addr) == old(memory_load32_le(mem, $x_addr))) && (memory_load32_le(mem, $z_addr) == old(memory_load32_le(mem, $z_addr)))));
-  free ensures (memory_load8_le(mem, 1972bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1973bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1974bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1975bv64) == 0bv8);
-  free ensures (memory_load64_le(mem, 69576bv64) == 69688bv64);
-  free ensures (memory_load64_le(mem, 69672bv64) == 69672bv64);
+  free ensures (memory_load32_le(mem, 1972bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69048bv64) == 1872bv64);
+  free ensures (memory_load64_le(mem, 69056bv64) == 1792bv64);
   free ensures (memory_load64_le(mem, 69568bv64) == 69684bv64);
+  free ensures (memory_load64_le(mem, 69576bv64) == 69688bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1876bv64);
-  free ensures (memory_load64_le(mem, 69056bv64) == 1792bv64);
+  free ensures (memory_load64_le(mem, 69672bv64) == 69672bv64);
 
 procedure {:extern} rely_transitive();
   modifies Gamma_mem, mem;
@@ -106,29 +99,23 @@ procedure main();
   modifies CF, Gamma_CF, Gamma_NF, Gamma_R0, Gamma_R31, Gamma_R8, Gamma_VF, Gamma_ZF, Gamma_mem, Gamma_stack, NF, R0, R31, R8, VF, ZF, mem, stack;
   free requires (memory_load64_le(mem, 69664bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
-  free requires (memory_load8_le(mem, 1972bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1973bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1974bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1975bv64) == 0bv8);
-  free requires (memory_load64_le(mem, 69576bv64) == 69688bv64);
-  free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
+  free requires (memory_load32_le(mem, 1972bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69048bv64) == 1872bv64);
+  free requires (memory_load64_le(mem, 69056bv64) == 1792bv64);
   free requires (memory_load64_le(mem, 69568bv64) == 69684bv64);
+  free requires (memory_load64_le(mem, 69576bv64) == 69688bv64);
   free requires (memory_load64_le(mem, 69592bv64) == 1876bv64);
-  free requires (memory_load64_le(mem, 69056bv64) == 1792bv64);
+  free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
   ensures (R0[32:0] == 0bv32);
   free ensures (Gamma_R31 == old(Gamma_R31));
   free ensures (R31 == old(R31));
-  free ensures (memory_load8_le(mem, 1972bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1973bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1974bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1975bv64) == 0bv8);
-  free ensures (memory_load64_le(mem, 69576bv64) == 69688bv64);
-  free ensures (memory_load64_le(mem, 69672bv64) == 69672bv64);
+  free ensures (memory_load32_le(mem, 1972bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69048bv64) == 1872bv64);
+  free ensures (memory_load64_le(mem, 69056bv64) == 1792bv64);
   free ensures (memory_load64_le(mem, 69568bv64) == 69684bv64);
+  free ensures (memory_load64_le(mem, 69576bv64) == 69688bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1876bv64);
-  free ensures (memory_load64_le(mem, 69056bv64) == 1792bv64);
+  free ensures (memory_load64_le(mem, 69672bv64) == 69672bv64);
 
 implementation main()
 {
diff --git a/src/test/correct/basic_lock_read/clang_pic/basic_lock_read_gtirb.expected b/src/test/correct/basic_lock_read/clang_pic/basic_lock_read_gtirb.expected
index de5c71aa8..141222e9a 100644
--- a/src/test/correct/basic_lock_read/clang_pic/basic_lock_read_gtirb.expected
+++ b/src/test/correct/basic_lock_read/clang_pic/basic_lock_read_gtirb.expected
@@ -20,7 +20,7 @@ const {:extern} $x_addr: bv64;
 axiom ($x_addr == 69688bv64);
 const {:extern} $z_addr: bv64;
 axiom ($z_addr == 69684bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
   (if (index == $x_addr) then true else (if (index == $z_addr) then true else false))
 }
 
@@ -50,10 +50,6 @@ function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv6
   (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
-}
-
 function {:extern} memory_store32_le(memory: [bv64]bv8, index: bv64, value: bv32) returns ([bv64]bv8) {
   memory[index := value[8:0]][bvadd64(index, 1bv64) := value[16:8]][bvadd64(index, 2bv64) := value[24:16]][bvadd64(index, 3bv64) := value[32:24]]
 }
@@ -64,16 +60,13 @@ procedure {:extern} rely();
   modifies Gamma_mem, mem;
   ensures (forall i: bv64 :: (((mem[i] == old(mem[i])) ==> (Gamma_mem[i] == old(Gamma_mem[i])))));
   ensures ((old(memory_load32_le(mem, $z_addr)) == 0bv32) ==> ((memory_load32_le(mem, $x_addr) == old(memory_load32_le(mem, $x_addr))) && (memory_load32_le(mem, $z_addr) == old(memory_load32_le(mem, $z_addr)))));
-  free ensures (memory_load8_le(mem, 1972bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1973bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1974bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1975bv64) == 0bv8);
-  free ensures (memory_load64_le(mem, 69576bv64) == 69688bv64);
-  free ensures (memory_load64_le(mem, 69672bv64) == 69672bv64);
+  free ensures (memory_load32_le(mem, 1972bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69048bv64) == 1872bv64);
+  free ensures (memory_load64_le(mem, 69056bv64) == 1792bv64);
   free ensures (memory_load64_le(mem, 69568bv64) == 69684bv64);
+  free ensures (memory_load64_le(mem, 69576bv64) == 69688bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1876bv64);
-  free ensures (memory_load64_le(mem, 69056bv64) == 1792bv64);
+  free ensures (memory_load64_le(mem, 69672bv64) == 69672bv64);
 
 procedure {:extern} rely_transitive();
   modifies Gamma_mem, mem;
@@ -104,29 +97,23 @@ procedure main();
   modifies CF, Gamma_CF, Gamma_NF, Gamma_R0, Gamma_R31, Gamma_R8, Gamma_VF, Gamma_ZF, Gamma_mem, Gamma_stack, NF, R0, R31, R8, VF, ZF, mem, stack;
   free requires (memory_load64_le(mem, 69664bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
-  free requires (memory_load8_le(mem, 1972bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1973bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1974bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1975bv64) == 0bv8);
-  free requires (memory_load64_le(mem, 69576bv64) == 69688bv64);
-  free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
+  free requires (memory_load32_le(mem, 1972bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69048bv64) == 1872bv64);
+  free requires (memory_load64_le(mem, 69056bv64) == 1792bv64);
   free requires (memory_load64_le(mem, 69568bv64) == 69684bv64);
+  free requires (memory_load64_le(mem, 69576bv64) == 69688bv64);
   free requires (memory_load64_le(mem, 69592bv64) == 1876bv64);
-  free requires (memory_load64_le(mem, 69056bv64) == 1792bv64);
+  free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
   ensures (R0[32:0] == 0bv32);
   free ensures (Gamma_R31 == old(Gamma_R31));
   free ensures (R31 == old(R31));
-  free ensures (memory_load8_le(mem, 1972bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1973bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1974bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1975bv64) == 0bv8);
-  free ensures (memory_load64_le(mem, 69576bv64) == 69688bv64);
-  free ensures (memory_load64_le(mem, 69672bv64) == 69672bv64);
+  free ensures (memory_load32_le(mem, 1972bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69048bv64) == 1872bv64);
+  free ensures (memory_load64_le(mem, 69056bv64) == 1792bv64);
   free ensures (memory_load64_le(mem, 69568bv64) == 69684bv64);
+  free ensures (memory_load64_le(mem, 69576bv64) == 69688bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1876bv64);
-  free ensures (memory_load64_le(mem, 69056bv64) == 1792bv64);
+  free ensures (memory_load64_le(mem, 69672bv64) == 69672bv64);
 
 implementation main()
 {
diff --git a/src/test/correct/basic_lock_read/gcc/basic_lock_read.expected b/src/test/correct/basic_lock_read/gcc/basic_lock_read.expected
index a99b5a5e3..c4a5478c8 100644
--- a/src/test/correct/basic_lock_read/gcc/basic_lock_read.expected
+++ b/src/test/correct/basic_lock_read/gcc/basic_lock_read.expected
@@ -18,7 +18,7 @@ const {:extern} $x_addr: bv64;
 axiom ($x_addr == 69652bv64);
 const {:extern} $z_addr: bv64;
 axiom ($z_addr == 69656bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
   (if (index == $x_addr) then true else (if (index == $z_addr) then true else false))
 }
 
@@ -45,10 +45,6 @@ function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv6
   (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
-}
-
 function {:extern} memory_store32_le(memory: [bv64]bv8, index: bv64, value: bv32) returns ([bv64]bv8) {
   memory[index := value[8:0]][bvadd64(index, 1bv64) := value[16:8]][bvadd64(index, 2bv64) := value[24:16]][bvadd64(index, 3bv64) := value[32:24]]
 }
@@ -60,10 +56,7 @@ procedure {:extern} rely();
   modifies Gamma_mem, mem;
   ensures (forall i: bv64 :: (((mem[i] == old(mem[i])) ==> (Gamma_mem[i] == old(Gamma_mem[i])))));
   ensures ((old(memory_load32_le(mem, $z_addr)) == 0bv32) ==> ((memory_load32_le(mem, $x_addr) == old(memory_load32_le(mem, $x_addr))) && (memory_load32_le(mem, $z_addr) == old(memory_load32_le(mem, $z_addr)))));
-  free ensures (memory_load8_le(mem, 1900bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1901bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1902bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1903bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1900bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69016bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69024bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69616bv64) == 1812bv64);
@@ -98,10 +91,7 @@ procedure main();
   modifies CF, Gamma_CF, Gamma_NF, Gamma_R0, Gamma_R31, Gamma_VF, Gamma_ZF, Gamma_mem, Gamma_stack, NF, R0, R31, VF, ZF, mem, stack;
   free requires (memory_load64_le(mem, 69632bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free requires (memory_load8_le(mem, 1900bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1901bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1902bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1903bv64) == 0bv8);
+  free requires (memory_load32_le(mem, 1900bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69016bv64) == 1808bv64);
   free requires (memory_load64_le(mem, 69024bv64) == 1728bv64);
   free requires (memory_load64_le(mem, 69616bv64) == 1812bv64);
@@ -109,10 +99,7 @@ procedure main();
   ensures (R0[32:0] == 0bv32);
   free ensures (Gamma_R31 == old(Gamma_R31));
   free ensures (R31 == old(R31));
-  free ensures (memory_load8_le(mem, 1900bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1901bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1902bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1903bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1900bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69016bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69024bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69616bv64) == 1812bv64);
diff --git a/src/test/correct/basic_lock_read/gcc/basic_lock_read_gtirb.expected b/src/test/correct/basic_lock_read/gcc/basic_lock_read_gtirb.expected
index e7c5751a8..79302e24b 100644
--- a/src/test/correct/basic_lock_read/gcc/basic_lock_read_gtirb.expected
+++ b/src/test/correct/basic_lock_read/gcc/basic_lock_read_gtirb.expected
@@ -18,7 +18,7 @@ const {:extern} $x_addr: bv64;
 axiom ($x_addr == 69652bv64);
 const {:extern} $z_addr: bv64;
 axiom ($z_addr == 69656bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
   (if (index == $x_addr) then true else (if (index == $z_addr) then true else false))
 }
 
@@ -44,10 +44,6 @@ function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv6
   (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
-}
-
 function {:extern} memory_store32_le(memory: [bv64]bv8, index: bv64, value: bv32) returns ([bv64]bv8) {
   memory[index := value[8:0]][bvadd64(index, 1bv64) := value[16:8]][bvadd64(index, 2bv64) := value[24:16]][bvadd64(index, 3bv64) := value[32:24]]
 }
@@ -58,10 +54,7 @@ procedure {:extern} rely();
   modifies Gamma_mem, mem;
   ensures (forall i: bv64 :: (((mem[i] == old(mem[i])) ==> (Gamma_mem[i] == old(Gamma_mem[i])))));
   ensures ((old(memory_load32_le(mem, $z_addr)) == 0bv32) ==> ((memory_load32_le(mem, $x_addr) == old(memory_load32_le(mem, $x_addr))) && (memory_load32_le(mem, $z_addr) == old(memory_load32_le(mem, $z_addr)))));
-  free ensures (memory_load8_le(mem, 1900bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1901bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1902bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1903bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1900bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69016bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69024bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69616bv64) == 1812bv64);
@@ -96,10 +89,7 @@ procedure main();
   modifies CF, Gamma_CF, Gamma_NF, Gamma_R0, Gamma_R31, Gamma_VF, Gamma_ZF, Gamma_mem, Gamma_stack, NF, R0, R31, VF, ZF, mem, stack;
   free requires (memory_load64_le(mem, 69632bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free requires (memory_load8_le(mem, 1900bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1901bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1902bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1903bv64) == 0bv8);
+  free requires (memory_load32_le(mem, 1900bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69016bv64) == 1808bv64);
   free requires (memory_load64_le(mem, 69024bv64) == 1728bv64);
   free requires (memory_load64_le(mem, 69616bv64) == 1812bv64);
@@ -107,10 +97,7 @@ procedure main();
   ensures (R0[32:0] == 0bv32);
   free ensures (Gamma_R31 == old(Gamma_R31));
   free ensures (R31 == old(R31));
-  free ensures (memory_load8_le(mem, 1900bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1901bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1902bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1903bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1900bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69016bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69024bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69616bv64) == 1812bv64);
diff --git a/src/test/correct/basic_lock_read/gcc_O2/basic_lock_read.expected b/src/test/correct/basic_lock_read/gcc_O2/basic_lock_read.expected
index d2727ac66..4a49039ba 100644
--- a/src/test/correct/basic_lock_read/gcc_O2/basic_lock_read.expected
+++ b/src/test/correct/basic_lock_read/gcc_O2/basic_lock_read.expected
@@ -8,7 +8,7 @@ const {:extern} $x_addr: bv64;
 axiom ($x_addr == 69656bv64);
 const {:extern} $z_addr: bv64;
 axiom ($z_addr == 69652bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
   (if (index == $x_addr) then true else (if (index == $z_addr) then true else false))
 }
 
@@ -31,10 +31,6 @@ function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv6
   (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
-}
-
 function {:extern} memory_store32_le(memory: [bv64]bv8, index: bv64, value: bv32) returns ([bv64]bv8) {
   memory[index := value[8:0]][bvadd64(index, 1bv64) := value[16:8]][bvadd64(index, 2bv64) := value[24:16]][bvadd64(index, 3bv64) := value[32:24]]
 }
@@ -44,10 +40,7 @@ procedure {:extern} rely();
   modifies Gamma_mem, mem;
   ensures (forall i: bv64 :: (((mem[i] == old(mem[i])) ==> (Gamma_mem[i] == old(Gamma_mem[i])))));
   ensures ((old(memory_load32_le(mem, $z_addr)) == 0bv32) ==> ((memory_load32_le(mem, $x_addr) == old(memory_load32_le(mem, $x_addr))) && (memory_load32_le(mem, $z_addr) == old(memory_load32_le(mem, $z_addr)))));
-  free ensures (memory_load8_le(mem, 1896bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1897bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1898bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1899bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1896bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69016bv64) == 1872bv64);
   free ensures (memory_load64_le(mem, 69024bv64) == 1792bv64);
   free ensures (memory_load64_le(mem, 69616bv64) == 1536bv64);
@@ -82,19 +75,13 @@ procedure main();
   modifies Gamma_R0, Gamma_R1, Gamma_mem, R0, R1, mem;
   free requires (memory_load64_le(mem, 69632bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free requires (memory_load8_le(mem, 1896bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1897bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1898bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1899bv64) == 0bv8);
+  free requires (memory_load32_le(mem, 1896bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69016bv64) == 1872bv64);
   free requires (memory_load64_le(mem, 69024bv64) == 1792bv64);
   free requires (memory_load64_le(mem, 69616bv64) == 1536bv64);
   free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
   ensures (R0[32:0] == 0bv32);
-  free ensures (memory_load8_le(mem, 1896bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1897bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1898bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1899bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1896bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69016bv64) == 1872bv64);
   free ensures (memory_load64_le(mem, 69024bv64) == 1792bv64);
   free ensures (memory_load64_le(mem, 69616bv64) == 1536bv64);
diff --git a/src/test/correct/basic_lock_read/gcc_O2/basic_lock_read_gtirb.expected b/src/test/correct/basic_lock_read/gcc_O2/basic_lock_read_gtirb.expected
index 748845185..0376b9c06 100644
--- a/src/test/correct/basic_lock_read/gcc_O2/basic_lock_read_gtirb.expected
+++ b/src/test/correct/basic_lock_read/gcc_O2/basic_lock_read_gtirb.expected
@@ -8,7 +8,7 @@ const {:extern} $x_addr: bv64;
 axiom ($x_addr == 69656bv64);
 const {:extern} $z_addr: bv64;
 axiom ($z_addr == 69652bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
   (if (index == $x_addr) then true else (if (index == $z_addr) then true else false))
 }
 
@@ -29,10 +29,6 @@ function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv6
   (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
-}
-
 function {:extern} memory_store32_le(memory: [bv64]bv8, index: bv64, value: bv32) returns ([bv64]bv8) {
   memory[index := value[8:0]][bvadd64(index, 1bv64) := value[16:8]][bvadd64(index, 2bv64) := value[24:16]][bvadd64(index, 3bv64) := value[32:24]]
 }
@@ -42,10 +38,7 @@ procedure {:extern} rely();
   modifies Gamma_mem, mem;
   ensures (forall i: bv64 :: (((mem[i] == old(mem[i])) ==> (Gamma_mem[i] == old(Gamma_mem[i])))));
   ensures ((old(memory_load32_le(mem, $z_addr)) == 0bv32) ==> ((memory_load32_le(mem, $x_addr) == old(memory_load32_le(mem, $x_addr))) && (memory_load32_le(mem, $z_addr) == old(memory_load32_le(mem, $z_addr)))));
-  free ensures (memory_load8_le(mem, 1896bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1897bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1898bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1899bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1896bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69016bv64) == 1872bv64);
   free ensures (memory_load64_le(mem, 69024bv64) == 1792bv64);
   free ensures (memory_load64_le(mem, 69616bv64) == 1536bv64);
@@ -80,19 +73,13 @@ procedure main();
   modifies Gamma_R0, Gamma_R1, Gamma_mem, R0, R1, mem;
   free requires (memory_load64_le(mem, 69632bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free requires (memory_load8_le(mem, 1896bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1897bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1898bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1899bv64) == 0bv8);
+  free requires (memory_load32_le(mem, 1896bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69016bv64) == 1872bv64);
   free requires (memory_load64_le(mem, 69024bv64) == 1792bv64);
   free requires (memory_load64_le(mem, 69616bv64) == 1536bv64);
   free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
   ensures (R0[32:0] == 0bv32);
-  free ensures (memory_load8_le(mem, 1896bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1897bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1898bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1899bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1896bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69016bv64) == 1872bv64);
   free ensures (memory_load64_le(mem, 69024bv64) == 1792bv64);
   free ensures (memory_load64_le(mem, 69616bv64) == 1536bv64);
diff --git a/src/test/correct/basic_lock_read/gcc_pic/basic_lock_read.expected b/src/test/correct/basic_lock_read/gcc_pic/basic_lock_read.expected
index c8e365ec9..857950775 100644
--- a/src/test/correct/basic_lock_read/gcc_pic/basic_lock_read.expected
+++ b/src/test/correct/basic_lock_read/gcc_pic/basic_lock_read.expected
@@ -18,7 +18,7 @@ const {:extern} $x_addr: bv64;
 axiom ($x_addr == 69652bv64);
 const {:extern} $z_addr: bv64;
 axiom ($z_addr == 69656bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
   (if (index == $x_addr) then true else (if (index == $z_addr) then true else false))
 }
 
@@ -49,10 +49,6 @@ function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv6
   (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
-}
-
 function {:extern} memory_store32_le(memory: [bv64]bv8, index: bv64, value: bv32) returns ([bv64]bv8) {
   memory[index := value[8:0]][bvadd64(index, 1bv64) := value[16:8]][bvadd64(index, 2bv64) := value[24:16]][bvadd64(index, 3bv64) := value[32:24]]
 }
@@ -64,16 +60,13 @@ procedure {:extern} rely();
   modifies Gamma_mem, mem;
   ensures (forall i: bv64 :: (((mem[i] == old(mem[i])) ==> (Gamma_mem[i] == old(Gamma_mem[i])))));
   ensures ((old(memory_load32_le(mem, $z_addr)) == 0bv32) ==> ((memory_load32_le(mem, $x_addr) == old(memory_load32_le(mem, $x_addr))) && (memory_load32_le(mem, $z_addr) == old(memory_load32_le(mem, $z_addr)))));
-  free ensures (memory_load8_le(mem, 1964bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1965bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1966bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1967bv64) == 0bv8);
-  free ensures (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free ensures (memory_load64_le(mem, 69616bv64) == 1876bv64);
-  free ensures (memory_load64_le(mem, 69600bv64) == 69652bv64);
+  free ensures (memory_load32_le(mem, 1964bv64) == 131073bv32);
+  free ensures (memory_load64_le(mem, 69000bv64) == 1872bv64);
   free ensures (memory_load64_le(mem, 69008bv64) == 1792bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 69656bv64);
-  free ensures (memory_load64_le(mem, 69000bv64) == 1872bv64);
+  free ensures (memory_load64_le(mem, 69600bv64) == 69652bv64);
+  free ensures (memory_load64_le(mem, 69616bv64) == 1876bv64);
+  free ensures (memory_load64_le(mem, 69640bv64) == 69640bv64);
 
 procedure {:extern} rely_transitive();
   modifies Gamma_mem, mem;
@@ -104,29 +97,23 @@ procedure main();
   modifies CF, Gamma_CF, Gamma_NF, Gamma_R0, Gamma_R31, Gamma_VF, Gamma_ZF, Gamma_mem, Gamma_stack, NF, R0, R31, VF, ZF, mem, stack;
   free requires (memory_load64_le(mem, 69632bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free requires (memory_load8_le(mem, 1964bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1965bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1966bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1967bv64) == 0bv8);
-  free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free requires (memory_load64_le(mem, 69616bv64) == 1876bv64);
-  free requires (memory_load64_le(mem, 69600bv64) == 69652bv64);
+  free requires (memory_load32_le(mem, 1964bv64) == 131073bv32);
+  free requires (memory_load64_le(mem, 69000bv64) == 1872bv64);
   free requires (memory_load64_le(mem, 69008bv64) == 1792bv64);
   free requires (memory_load64_le(mem, 69592bv64) == 69656bv64);
-  free requires (memory_load64_le(mem, 69000bv64) == 1872bv64);
+  free requires (memory_load64_le(mem, 69600bv64) == 69652bv64);
+  free requires (memory_load64_le(mem, 69616bv64) == 1876bv64);
+  free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
   ensures (R0[32:0] == 0bv32);
   free ensures (Gamma_R31 == old(Gamma_R31));
   free ensures (R31 == old(R31));
-  free ensures (memory_load8_le(mem, 1964bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1965bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1966bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1967bv64) == 0bv8);
-  free ensures (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free ensures (memory_load64_le(mem, 69616bv64) == 1876bv64);
-  free ensures (memory_load64_le(mem, 69600bv64) == 69652bv64);
+  free ensures (memory_load32_le(mem, 1964bv64) == 131073bv32);
+  free ensures (memory_load64_le(mem, 69000bv64) == 1872bv64);
   free ensures (memory_load64_le(mem, 69008bv64) == 1792bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 69656bv64);
-  free ensures (memory_load64_le(mem, 69000bv64) == 1872bv64);
+  free ensures (memory_load64_le(mem, 69600bv64) == 69652bv64);
+  free ensures (memory_load64_le(mem, 69616bv64) == 1876bv64);
+  free ensures (memory_load64_le(mem, 69640bv64) == 69640bv64);
 
 implementation main()
 {
diff --git a/src/test/correct/basic_lock_read/gcc_pic/basic_lock_read_gtirb.expected b/src/test/correct/basic_lock_read/gcc_pic/basic_lock_read_gtirb.expected
index 033884fa7..7234dcc85 100644
--- a/src/test/correct/basic_lock_read/gcc_pic/basic_lock_read_gtirb.expected
+++ b/src/test/correct/basic_lock_read/gcc_pic/basic_lock_read_gtirb.expected
@@ -18,7 +18,7 @@ const {:extern} $x_addr: bv64;
 axiom ($x_addr == 69652bv64);
 const {:extern} $z_addr: bv64;
 axiom ($z_addr == 69656bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
   (if (index == $x_addr) then true else (if (index == $z_addr) then true else false))
 }
 
@@ -48,10 +48,6 @@ function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv6
   (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
-}
-
 function {:extern} memory_store32_le(memory: [bv64]bv8, index: bv64, value: bv32) returns ([bv64]bv8) {
   memory[index := value[8:0]][bvadd64(index, 1bv64) := value[16:8]][bvadd64(index, 2bv64) := value[24:16]][bvadd64(index, 3bv64) := value[32:24]]
 }
@@ -62,16 +58,13 @@ procedure {:extern} rely();
   modifies Gamma_mem, mem;
   ensures (forall i: bv64 :: (((mem[i] == old(mem[i])) ==> (Gamma_mem[i] == old(Gamma_mem[i])))));
   ensures ((old(memory_load32_le(mem, $z_addr)) == 0bv32) ==> ((memory_load32_le(mem, $x_addr) == old(memory_load32_le(mem, $x_addr))) && (memory_load32_le(mem, $z_addr) == old(memory_load32_le(mem, $z_addr)))));
-  free ensures (memory_load8_le(mem, 1964bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1965bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1966bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1967bv64) == 0bv8);
-  free ensures (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free ensures (memory_load64_le(mem, 69616bv64) == 1876bv64);
-  free ensures (memory_load64_le(mem, 69600bv64) == 69652bv64);
+  free ensures (memory_load32_le(mem, 1964bv64) == 131073bv32);
+  free ensures (memory_load64_le(mem, 69000bv64) == 1872bv64);
   free ensures (memory_load64_le(mem, 69008bv64) == 1792bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 69656bv64);
-  free ensures (memory_load64_le(mem, 69000bv64) == 1872bv64);
+  free ensures (memory_load64_le(mem, 69600bv64) == 69652bv64);
+  free ensures (memory_load64_le(mem, 69616bv64) == 1876bv64);
+  free ensures (memory_load64_le(mem, 69640bv64) == 69640bv64);
 
 procedure {:extern} rely_transitive();
   modifies Gamma_mem, mem;
@@ -102,29 +95,23 @@ procedure main();
   modifies CF, Gamma_CF, Gamma_NF, Gamma_R0, Gamma_R31, Gamma_VF, Gamma_ZF, Gamma_mem, Gamma_stack, NF, R0, R31, VF, ZF, mem, stack;
   free requires (memory_load64_le(mem, 69632bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free requires (memory_load8_le(mem, 1964bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1965bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1966bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1967bv64) == 0bv8);
-  free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free requires (memory_load64_le(mem, 69616bv64) == 1876bv64);
-  free requires (memory_load64_le(mem, 69600bv64) == 69652bv64);
+  free requires (memory_load32_le(mem, 1964bv64) == 131073bv32);
+  free requires (memory_load64_le(mem, 69000bv64) == 1872bv64);
   free requires (memory_load64_le(mem, 69008bv64) == 1792bv64);
   free requires (memory_load64_le(mem, 69592bv64) == 69656bv64);
-  free requires (memory_load64_le(mem, 69000bv64) == 1872bv64);
+  free requires (memory_load64_le(mem, 69600bv64) == 69652bv64);
+  free requires (memory_load64_le(mem, 69616bv64) == 1876bv64);
+  free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
   ensures (R0[32:0] == 0bv32);
   free ensures (Gamma_R31 == old(Gamma_R31));
   free ensures (R31 == old(R31));
-  free ensures (memory_load8_le(mem, 1964bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1965bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1966bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1967bv64) == 0bv8);
-  free ensures (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free ensures (memory_load64_le(mem, 69616bv64) == 1876bv64);
-  free ensures (memory_load64_le(mem, 69600bv64) == 69652bv64);
+  free ensures (memory_load32_le(mem, 1964bv64) == 131073bv32);
+  free ensures (memory_load64_le(mem, 69000bv64) == 1872bv64);
   free ensures (memory_load64_le(mem, 69008bv64) == 1792bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 69656bv64);
-  free ensures (memory_load64_le(mem, 69000bv64) == 1872bv64);
+  free ensures (memory_load64_le(mem, 69600bv64) == 69652bv64);
+  free ensures (memory_load64_le(mem, 69616bv64) == 1876bv64);
+  free ensures (memory_load64_le(mem, 69640bv64) == 69640bv64);
 
 implementation main()
 {
diff --git a/src/test/correct/basic_lock_security_read/clang/basic_lock_security_read.expected b/src/test/correct/basic_lock_security_read/clang/basic_lock_security_read.expected
index 06964678d..0bc9f6c39 100644
--- a/src/test/correct/basic_lock_security_read/clang/basic_lock_security_read.expected
+++ b/src/test/correct/basic_lock_security_read/clang/basic_lock_security_read.expected
@@ -20,8 +20,8 @@ const {:extern} $x_addr: bv64;
 axiom ($x_addr == 69688bv64);
 const {:extern} $z_addr: bv64;
 axiom ($z_addr == 69684bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
-  (if (index == $x_addr) then (memory_load32_le(memory, $z_addr) == 0bv32) else (if (index == $z_addr) then true else false))
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
+  (if (index == $x_addr) then (memory_load32_le(mem$in, $z_addr) == 0bv32) else (if (index == $z_addr) then true else false))
 }
 
 function {:extern} {:bvbuiltin "bvadd"} bvadd32(bv32, bv32) returns (bv32);
@@ -47,10 +47,6 @@ function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv6
   (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
-}
-
 function {:extern} memory_store32_le(memory: [bv64]bv8, index: bv64, value: bv32) returns ([bv64]bv8) {
   memory[index := value[8:0]][bvadd64(index, 1bv64) := value[16:8]][bvadd64(index, 2bv64) := value[24:16]][bvadd64(index, 3bv64) := value[32:24]]
 }
@@ -62,10 +58,7 @@ procedure {:extern} rely();
   modifies Gamma_mem, mem;
   ensures (forall i: bv64 :: (((mem[i] == old(mem[i])) ==> (Gamma_mem[i] == old(Gamma_mem[i])))));
   ensures ((old(memory_load32_le(mem, $z_addr)) == 0bv32) ==> ((memory_load32_le(mem, $x_addr) == old(memory_load32_le(mem, $x_addr))) && (memory_load32_le(mem, $z_addr) == old(memory_load32_le(mem, $z_addr)))));
-  free ensures (memory_load8_le(mem, 1896bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1897bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1898bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1899bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1896bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1812bv64);
@@ -100,20 +93,14 @@ procedure main();
   modifies CF, Gamma_CF, Gamma_NF, Gamma_R0, Gamma_R31, Gamma_R8, Gamma_VF, Gamma_ZF, Gamma_mem, Gamma_stack, NF, R0, R31, R8, VF, ZF, mem, stack;
   free requires (memory_load64_le(mem, 69664bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
-  free requires (memory_load8_le(mem, 1896bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1897bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1898bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1899bv64) == 0bv8);
+  free requires (memory_load32_le(mem, 1896bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free requires (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free requires (memory_load64_le(mem, 69592bv64) == 1812bv64);
   free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
   free ensures (Gamma_R31 == old(Gamma_R31));
   free ensures (R31 == old(R31));
-  free ensures (memory_load8_le(mem, 1896bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1897bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1898bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1899bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1896bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1812bv64);
diff --git a/src/test/correct/basic_lock_security_read/clang/basic_lock_security_read_gtirb.expected b/src/test/correct/basic_lock_security_read/clang/basic_lock_security_read_gtirb.expected
index c05516f99..689765c63 100644
--- a/src/test/correct/basic_lock_security_read/clang/basic_lock_security_read_gtirb.expected
+++ b/src/test/correct/basic_lock_security_read/clang/basic_lock_security_read_gtirb.expected
@@ -20,8 +20,8 @@ const {:extern} $x_addr: bv64;
 axiom ($x_addr == 69688bv64);
 const {:extern} $z_addr: bv64;
 axiom ($z_addr == 69684bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
-  (if (index == $x_addr) then (memory_load32_le(memory, $z_addr) == 0bv32) else (if (index == $z_addr) then true else false))
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
+  (if (index == $x_addr) then (memory_load32_le(mem$in, $z_addr) == 0bv32) else (if (index == $z_addr) then true else false))
 }
 
 function {:extern} {:bvbuiltin "bvadd"} bvadd32(bv32, bv32) returns (bv32);
@@ -46,10 +46,6 @@ function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv6
   (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
-}
-
 function {:extern} memory_store32_le(memory: [bv64]bv8, index: bv64, value: bv32) returns ([bv64]bv8) {
   memory[index := value[8:0]][bvadd64(index, 1bv64) := value[16:8]][bvadd64(index, 2bv64) := value[24:16]][bvadd64(index, 3bv64) := value[32:24]]
 }
@@ -60,10 +56,7 @@ procedure {:extern} rely();
   modifies Gamma_mem, mem;
   ensures (forall i: bv64 :: (((mem[i] == old(mem[i])) ==> (Gamma_mem[i] == old(Gamma_mem[i])))));
   ensures ((old(memory_load32_le(mem, $z_addr)) == 0bv32) ==> ((memory_load32_le(mem, $x_addr) == old(memory_load32_le(mem, $x_addr))) && (memory_load32_le(mem, $z_addr) == old(memory_load32_le(mem, $z_addr)))));
-  free ensures (memory_load8_le(mem, 1896bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1897bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1898bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1899bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1896bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1812bv64);
@@ -98,20 +91,14 @@ procedure main();
   modifies CF, Gamma_CF, Gamma_NF, Gamma_R0, Gamma_R31, Gamma_R8, Gamma_VF, Gamma_ZF, Gamma_mem, Gamma_stack, NF, R0, R31, R8, VF, ZF, mem, stack;
   free requires (memory_load64_le(mem, 69664bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
-  free requires (memory_load8_le(mem, 1896bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1897bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1898bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1899bv64) == 0bv8);
+  free requires (memory_load32_le(mem, 1896bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free requires (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free requires (memory_load64_le(mem, 69592bv64) == 1812bv64);
   free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
   free ensures (Gamma_R31 == old(Gamma_R31));
   free ensures (R31 == old(R31));
-  free ensures (memory_load8_le(mem, 1896bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1897bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1898bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1899bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1896bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1812bv64);
diff --git a/src/test/correct/basic_lock_security_read/clang_O2/basic_lock_security_read.expected b/src/test/correct/basic_lock_security_read/clang_O2/basic_lock_security_read.expected
index ced4f97ac..1732e2d7d 100644
--- a/src/test/correct/basic_lock_security_read/clang_O2/basic_lock_security_read.expected
+++ b/src/test/correct/basic_lock_security_read/clang_O2/basic_lock_security_read.expected
@@ -18,8 +18,8 @@ const {:extern} $x_addr: bv64;
 axiom ($x_addr == 69688bv64);
 const {:extern} $z_addr: bv64;
 axiom ($z_addr == 69684bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
-  (if (index == $x_addr) then (memory_load32_le(memory, $z_addr) == 0bv32) else (if (index == $z_addr) then true else false))
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
+  (if (index == $x_addr) then (memory_load32_le(mem$in, $z_addr) == 0bv32) else (if (index == $z_addr) then true else false))
 }
 
 function {:extern} {:bvbuiltin "bvadd"} bvadd32(bv32, bv32) returns (bv32);
@@ -41,10 +41,6 @@ function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv6
   (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
-}
-
 function {:extern} {:bvbuiltin "sign_extend 1"} sign_extend1_32(bv32) returns (bv33);
 function {:extern} {:bvbuiltin "zero_extend 1"} zero_extend1_32(bv32) returns (bv33);
 function {:extern} {:bvbuiltin "zero_extend 32"} zero_extend32_32(bv32) returns (bv64);
@@ -52,10 +48,7 @@ procedure {:extern} rely();
   modifies Gamma_mem, mem;
   ensures (forall i: bv64 :: (((mem[i] == old(mem[i])) ==> (Gamma_mem[i] == old(Gamma_mem[i])))));
   ensures ((old(memory_load32_le(mem, $z_addr)) == 0bv32) ==> ((memory_load32_le(mem, $x_addr) == old(memory_load32_le(mem, $x_addr))) && (memory_load32_le(mem, $z_addr) == old(memory_load32_le(mem, $z_addr)))));
-  free ensures (memory_load8_le(mem, 1860bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1861bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1862bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1863bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1860bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1812bv64);
@@ -90,18 +83,12 @@ procedure main();
   modifies CF, Gamma_CF, Gamma_NF, Gamma_R0, Gamma_R8, Gamma_R9, Gamma_VF, Gamma_ZF, Gamma_mem, NF, R0, R8, R9, VF, ZF, mem;
   free requires (memory_load64_le(mem, 69664bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
-  free requires (memory_load8_le(mem, 1860bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1861bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1862bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1863bv64) == 0bv8);
+  free requires (memory_load32_le(mem, 1860bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free requires (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free requires (memory_load64_le(mem, 69592bv64) == 1812bv64);
   free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
-  free ensures (memory_load8_le(mem, 1860bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1861bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1862bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1863bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1860bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1812bv64);
diff --git a/src/test/correct/basic_lock_security_read/clang_O2/basic_lock_security_read_gtirb.expected b/src/test/correct/basic_lock_security_read/clang_O2/basic_lock_security_read_gtirb.expected
index 98833ec9e..5f851e084 100644
--- a/src/test/correct/basic_lock_security_read/clang_O2/basic_lock_security_read_gtirb.expected
+++ b/src/test/correct/basic_lock_security_read/clang_O2/basic_lock_security_read_gtirb.expected
@@ -18,8 +18,8 @@ const {:extern} $x_addr: bv64;
 axiom ($x_addr == 69688bv64);
 const {:extern} $z_addr: bv64;
 axiom ($z_addr == 69684bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
-  (if (index == $x_addr) then (memory_load32_le(memory, $z_addr) == 0bv32) else (if (index == $z_addr) then true else false))
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
+  (if (index == $x_addr) then (memory_load32_le(mem$in, $z_addr) == 0bv32) else (if (index == $z_addr) then true else false))
 }
 
 function {:extern} {:bvbuiltin "bvadd"} bvadd32(bv32, bv32) returns (bv32);
@@ -40,20 +40,13 @@ function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv6
   (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
-}
-
 function {:extern} {:bvbuiltin "zero_extend 1"} zero_extend1_32(bv32) returns (bv33);
 function {:extern} {:bvbuiltin "zero_extend 32"} zero_extend32_32(bv32) returns (bv64);
 procedure {:extern} rely();
   modifies Gamma_mem, mem;
   ensures (forall i: bv64 :: (((mem[i] == old(mem[i])) ==> (Gamma_mem[i] == old(Gamma_mem[i])))));
   ensures ((old(memory_load32_le(mem, $z_addr)) == 0bv32) ==> ((memory_load32_le(mem, $x_addr) == old(memory_load32_le(mem, $x_addr))) && (memory_load32_le(mem, $z_addr) == old(memory_load32_le(mem, $z_addr)))));
-  free ensures (memory_load8_le(mem, 1860bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1861bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1862bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1863bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1860bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1812bv64);
@@ -88,18 +81,12 @@ procedure main();
   modifies CF, Gamma_CF, Gamma_NF, Gamma_R0, Gamma_R8, Gamma_R9, Gamma_VF, Gamma_ZF, Gamma_mem, NF, R0, R8, R9, VF, ZF, mem;
   free requires (memory_load64_le(mem, 69664bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
-  free requires (memory_load8_le(mem, 1860bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1861bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1862bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1863bv64) == 0bv8);
+  free requires (memory_load32_le(mem, 1860bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free requires (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free requires (memory_load64_le(mem, 69592bv64) == 1812bv64);
   free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
-  free ensures (memory_load8_le(mem, 1860bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1861bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1862bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1863bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1860bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1812bv64);
diff --git a/src/test/correct/basic_lock_security_read/clang_pic/basic_lock_security_read.expected b/src/test/correct/basic_lock_security_read/clang_pic/basic_lock_security_read.expected
index 52fc57311..72842e0fe 100644
--- a/src/test/correct/basic_lock_security_read/clang_pic/basic_lock_security_read.expected
+++ b/src/test/correct/basic_lock_security_read/clang_pic/basic_lock_security_read.expected
@@ -20,8 +20,8 @@ const {:extern} $x_addr: bv64;
 axiom ($x_addr == 69688bv64);
 const {:extern} $z_addr: bv64;
 axiom ($z_addr == 69684bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
-  (if (index == $x_addr) then (memory_load32_le(memory, $z_addr) == 0bv32) else (if (index == $z_addr) then true else false))
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
+  (if (index == $x_addr) then (memory_load32_le(mem$in, $z_addr) == 0bv32) else (if (index == $z_addr) then true else false))
 }
 
 function {:extern} {:bvbuiltin "bvadd"} bvadd32(bv32, bv32) returns (bv32);
@@ -51,10 +51,6 @@ function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv6
   (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
-}
-
 function {:extern} memory_store32_le(memory: [bv64]bv8, index: bv64, value: bv32) returns ([bv64]bv8) {
   memory[index := value[8:0]][bvadd64(index, 1bv64) := value[16:8]][bvadd64(index, 2bv64) := value[24:16]][bvadd64(index, 3bv64) := value[32:24]]
 }
@@ -66,16 +62,13 @@ procedure {:extern} rely();
   modifies Gamma_mem, mem;
   ensures (forall i: bv64 :: (((mem[i] == old(mem[i])) ==> (Gamma_mem[i] == old(Gamma_mem[i])))));
   ensures ((old(memory_load32_le(mem, $z_addr)) == 0bv32) ==> ((memory_load32_le(mem, $x_addr) == old(memory_load32_le(mem, $x_addr))) && (memory_load32_le(mem, $z_addr) == old(memory_load32_le(mem, $z_addr)))));
-  free ensures (memory_load8_le(mem, 1968bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1969bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1970bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1971bv64) == 0bv8);
-  free ensures (memory_load64_le(mem, 69576bv64) == 69688bv64);
-  free ensures (memory_load64_le(mem, 69672bv64) == 69672bv64);
+  free ensures (memory_load32_le(mem, 1968bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69048bv64) == 1872bv64);
+  free ensures (memory_load64_le(mem, 69056bv64) == 1792bv64);
   free ensures (memory_load64_le(mem, 69568bv64) == 69684bv64);
+  free ensures (memory_load64_le(mem, 69576bv64) == 69688bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1876bv64);
-  free ensures (memory_load64_le(mem, 69056bv64) == 1792bv64);
+  free ensures (memory_load64_le(mem, 69672bv64) == 69672bv64);
 
 procedure {:extern} rely_transitive();
   modifies Gamma_mem, mem;
@@ -106,28 +99,22 @@ procedure main();
   modifies CF, Gamma_CF, Gamma_NF, Gamma_R0, Gamma_R31, Gamma_R8, Gamma_VF, Gamma_ZF, Gamma_mem, Gamma_stack, NF, R0, R31, R8, VF, ZF, mem, stack;
   free requires (memory_load64_le(mem, 69664bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
-  free requires (memory_load8_le(mem, 1968bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1969bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1970bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1971bv64) == 0bv8);
-  free requires (memory_load64_le(mem, 69576bv64) == 69688bv64);
-  free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
+  free requires (memory_load32_le(mem, 1968bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69048bv64) == 1872bv64);
+  free requires (memory_load64_le(mem, 69056bv64) == 1792bv64);
   free requires (memory_load64_le(mem, 69568bv64) == 69684bv64);
+  free requires (memory_load64_le(mem, 69576bv64) == 69688bv64);
   free requires (memory_load64_le(mem, 69592bv64) == 1876bv64);
-  free requires (memory_load64_le(mem, 69056bv64) == 1792bv64);
+  free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
   free ensures (Gamma_R31 == old(Gamma_R31));
   free ensures (R31 == old(R31));
-  free ensures (memory_load8_le(mem, 1968bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1969bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1970bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1971bv64) == 0bv8);
-  free ensures (memory_load64_le(mem, 69576bv64) == 69688bv64);
-  free ensures (memory_load64_le(mem, 69672bv64) == 69672bv64);
+  free ensures (memory_load32_le(mem, 1968bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69048bv64) == 1872bv64);
+  free ensures (memory_load64_le(mem, 69056bv64) == 1792bv64);
   free ensures (memory_load64_le(mem, 69568bv64) == 69684bv64);
+  free ensures (memory_load64_le(mem, 69576bv64) == 69688bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1876bv64);
-  free ensures (memory_load64_le(mem, 69056bv64) == 1792bv64);
+  free ensures (memory_load64_le(mem, 69672bv64) == 69672bv64);
 
 implementation main()
 {
diff --git a/src/test/correct/basic_lock_security_read/clang_pic/basic_lock_security_read_gtirb.expected b/src/test/correct/basic_lock_security_read/clang_pic/basic_lock_security_read_gtirb.expected
index 989c887b8..ec5b9443d 100644
--- a/src/test/correct/basic_lock_security_read/clang_pic/basic_lock_security_read_gtirb.expected
+++ b/src/test/correct/basic_lock_security_read/clang_pic/basic_lock_security_read_gtirb.expected
@@ -20,8 +20,8 @@ const {:extern} $x_addr: bv64;
 axiom ($x_addr == 69688bv64);
 const {:extern} $z_addr: bv64;
 axiom ($z_addr == 69684bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
-  (if (index == $x_addr) then (memory_load32_le(memory, $z_addr) == 0bv32) else (if (index == $z_addr) then true else false))
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
+  (if (index == $x_addr) then (memory_load32_le(mem$in, $z_addr) == 0bv32) else (if (index == $z_addr) then true else false))
 }
 
 function {:extern} {:bvbuiltin "bvadd"} bvadd32(bv32, bv32) returns (bv32);
@@ -50,10 +50,6 @@ function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv6
   (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
-}
-
 function {:extern} memory_store32_le(memory: [bv64]bv8, index: bv64, value: bv32) returns ([bv64]bv8) {
   memory[index := value[8:0]][bvadd64(index, 1bv64) := value[16:8]][bvadd64(index, 2bv64) := value[24:16]][bvadd64(index, 3bv64) := value[32:24]]
 }
@@ -64,16 +60,13 @@ procedure {:extern} rely();
   modifies Gamma_mem, mem;
   ensures (forall i: bv64 :: (((mem[i] == old(mem[i])) ==> (Gamma_mem[i] == old(Gamma_mem[i])))));
   ensures ((old(memory_load32_le(mem, $z_addr)) == 0bv32) ==> ((memory_load32_le(mem, $x_addr) == old(memory_load32_le(mem, $x_addr))) && (memory_load32_le(mem, $z_addr) == old(memory_load32_le(mem, $z_addr)))));
-  free ensures (memory_load8_le(mem, 1968bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1969bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1970bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1971bv64) == 0bv8);
-  free ensures (memory_load64_le(mem, 69576bv64) == 69688bv64);
-  free ensures (memory_load64_le(mem, 69672bv64) == 69672bv64);
+  free ensures (memory_load32_le(mem, 1968bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69048bv64) == 1872bv64);
+  free ensures (memory_load64_le(mem, 69056bv64) == 1792bv64);
   free ensures (memory_load64_le(mem, 69568bv64) == 69684bv64);
+  free ensures (memory_load64_le(mem, 69576bv64) == 69688bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1876bv64);
-  free ensures (memory_load64_le(mem, 69056bv64) == 1792bv64);
+  free ensures (memory_load64_le(mem, 69672bv64) == 69672bv64);
 
 procedure {:extern} rely_transitive();
   modifies Gamma_mem, mem;
@@ -104,28 +97,22 @@ procedure main();
   modifies CF, Gamma_CF, Gamma_NF, Gamma_R0, Gamma_R31, Gamma_R8, Gamma_VF, Gamma_ZF, Gamma_mem, Gamma_stack, NF, R0, R31, R8, VF, ZF, mem, stack;
   free requires (memory_load64_le(mem, 69664bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
-  free requires (memory_load8_le(mem, 1968bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1969bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1970bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1971bv64) == 0bv8);
-  free requires (memory_load64_le(mem, 69576bv64) == 69688bv64);
-  free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
+  free requires (memory_load32_le(mem, 1968bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69048bv64) == 1872bv64);
+  free requires (memory_load64_le(mem, 69056bv64) == 1792bv64);
   free requires (memory_load64_le(mem, 69568bv64) == 69684bv64);
+  free requires (memory_load64_le(mem, 69576bv64) == 69688bv64);
   free requires (memory_load64_le(mem, 69592bv64) == 1876bv64);
-  free requires (memory_load64_le(mem, 69056bv64) == 1792bv64);
+  free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
   free ensures (Gamma_R31 == old(Gamma_R31));
   free ensures (R31 == old(R31));
-  free ensures (memory_load8_le(mem, 1968bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1969bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1970bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1971bv64) == 0bv8);
-  free ensures (memory_load64_le(mem, 69576bv64) == 69688bv64);
-  free ensures (memory_load64_le(mem, 69672bv64) == 69672bv64);
+  free ensures (memory_load32_le(mem, 1968bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69048bv64) == 1872bv64);
+  free ensures (memory_load64_le(mem, 69056bv64) == 1792bv64);
   free ensures (memory_load64_le(mem, 69568bv64) == 69684bv64);
+  free ensures (memory_load64_le(mem, 69576bv64) == 69688bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1876bv64);
-  free ensures (memory_load64_le(mem, 69056bv64) == 1792bv64);
+  free ensures (memory_load64_le(mem, 69672bv64) == 69672bv64);
 
 implementation main()
 {
diff --git a/src/test/correct/basic_lock_security_read/gcc/basic_lock_security_read.expected b/src/test/correct/basic_lock_security_read/gcc/basic_lock_security_read.expected
index 78970f6a4..2c29e93fa 100644
--- a/src/test/correct/basic_lock_security_read/gcc/basic_lock_security_read.expected
+++ b/src/test/correct/basic_lock_security_read/gcc/basic_lock_security_read.expected
@@ -18,8 +18,8 @@ const {:extern} $x_addr: bv64;
 axiom ($x_addr == 69652bv64);
 const {:extern} $z_addr: bv64;
 axiom ($z_addr == 69656bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
-  (if (index == $x_addr) then (memory_load32_le(memory, $z_addr) == 0bv32) else (if (index == $z_addr) then true else false))
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
+  (if (index == $x_addr) then (memory_load32_le(mem$in, $z_addr) == 0bv32) else (if (index == $z_addr) then true else false))
 }
 
 function {:extern} {:bvbuiltin "bvadd"} bvadd32(bv32, bv32) returns (bv32);
@@ -45,10 +45,6 @@ function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv6
   (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
-}
-
 function {:extern} memory_store32_le(memory: [bv64]bv8, index: bv64, value: bv32) returns ([bv64]bv8) {
   memory[index := value[8:0]][bvadd64(index, 1bv64) := value[16:8]][bvadd64(index, 2bv64) := value[24:16]][bvadd64(index, 3bv64) := value[32:24]]
 }
@@ -60,10 +56,7 @@ procedure {:extern} rely();
   modifies Gamma_mem, mem;
   ensures (forall i: bv64 :: (((mem[i] == old(mem[i])) ==> (Gamma_mem[i] == old(Gamma_mem[i])))));
   ensures ((old(memory_load32_le(mem, $z_addr)) == 0bv32) ==> ((memory_load32_le(mem, $x_addr) == old(memory_load32_le(mem, $x_addr))) && (memory_load32_le(mem, $z_addr) == old(memory_load32_le(mem, $z_addr)))));
-  free ensures (memory_load8_le(mem, 1888bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1889bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1890bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1891bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1888bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69016bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69024bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69616bv64) == 1812bv64);
@@ -98,20 +91,14 @@ procedure main();
   modifies CF, Gamma_CF, Gamma_NF, Gamma_R0, Gamma_R31, Gamma_VF, Gamma_ZF, Gamma_mem, Gamma_stack, NF, R0, R31, VF, ZF, mem, stack;
   free requires (memory_load64_le(mem, 69632bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free requires (memory_load8_le(mem, 1888bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1889bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1890bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1891bv64) == 0bv8);
+  free requires (memory_load32_le(mem, 1888bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69016bv64) == 1808bv64);
   free requires (memory_load64_le(mem, 69024bv64) == 1728bv64);
   free requires (memory_load64_le(mem, 69616bv64) == 1812bv64);
   free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
   free ensures (Gamma_R31 == old(Gamma_R31));
   free ensures (R31 == old(R31));
-  free ensures (memory_load8_le(mem, 1888bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1889bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1890bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1891bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1888bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69016bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69024bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69616bv64) == 1812bv64);
diff --git a/src/test/correct/basic_lock_security_read/gcc/basic_lock_security_read_gtirb.expected b/src/test/correct/basic_lock_security_read/gcc/basic_lock_security_read_gtirb.expected
index a85f2dc3f..0fba39a39 100644
--- a/src/test/correct/basic_lock_security_read/gcc/basic_lock_security_read_gtirb.expected
+++ b/src/test/correct/basic_lock_security_read/gcc/basic_lock_security_read_gtirb.expected
@@ -18,8 +18,8 @@ const {:extern} $x_addr: bv64;
 axiom ($x_addr == 69652bv64);
 const {:extern} $z_addr: bv64;
 axiom ($z_addr == 69656bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
-  (if (index == $x_addr) then (memory_load32_le(memory, $z_addr) == 0bv32) else (if (index == $z_addr) then true else false))
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
+  (if (index == $x_addr) then (memory_load32_le(mem$in, $z_addr) == 0bv32) else (if (index == $z_addr) then true else false))
 }
 
 function {:extern} {:bvbuiltin "bvadd"} bvadd32(bv32, bv32) returns (bv32);
@@ -44,10 +44,6 @@ function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv6
   (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
-}
-
 function {:extern} memory_store32_le(memory: [bv64]bv8, index: bv64, value: bv32) returns ([bv64]bv8) {
   memory[index := value[8:0]][bvadd64(index, 1bv64) := value[16:8]][bvadd64(index, 2bv64) := value[24:16]][bvadd64(index, 3bv64) := value[32:24]]
 }
@@ -58,10 +54,7 @@ procedure {:extern} rely();
   modifies Gamma_mem, mem;
   ensures (forall i: bv64 :: (((mem[i] == old(mem[i])) ==> (Gamma_mem[i] == old(Gamma_mem[i])))));
   ensures ((old(memory_load32_le(mem, $z_addr)) == 0bv32) ==> ((memory_load32_le(mem, $x_addr) == old(memory_load32_le(mem, $x_addr))) && (memory_load32_le(mem, $z_addr) == old(memory_load32_le(mem, $z_addr)))));
-  free ensures (memory_load8_le(mem, 1888bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1889bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1890bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1891bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1888bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69016bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69024bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69616bv64) == 1812bv64);
@@ -96,20 +89,14 @@ procedure main();
   modifies CF, Gamma_CF, Gamma_NF, Gamma_R0, Gamma_R31, Gamma_VF, Gamma_ZF, Gamma_mem, Gamma_stack, NF, R0, R31, VF, ZF, mem, stack;
   free requires (memory_load64_le(mem, 69632bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free requires (memory_load8_le(mem, 1888bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1889bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1890bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1891bv64) == 0bv8);
+  free requires (memory_load32_le(mem, 1888bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69016bv64) == 1808bv64);
   free requires (memory_load64_le(mem, 69024bv64) == 1728bv64);
   free requires (memory_load64_le(mem, 69616bv64) == 1812bv64);
   free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
   free ensures (Gamma_R31 == old(Gamma_R31));
   free ensures (R31 == old(R31));
-  free ensures (memory_load8_le(mem, 1888bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1889bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1890bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1891bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1888bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69016bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69024bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69616bv64) == 1812bv64);
diff --git a/src/test/correct/basic_lock_security_read/gcc_O2/basic_lock_security_read.expected b/src/test/correct/basic_lock_security_read/gcc_O2/basic_lock_security_read.expected
index 8c6b8310d..c05476c3a 100644
--- a/src/test/correct/basic_lock_security_read/gcc_O2/basic_lock_security_read.expected
+++ b/src/test/correct/basic_lock_security_read/gcc_O2/basic_lock_security_read.expected
@@ -10,8 +10,8 @@ const {:extern} $x_addr: bv64;
 axiom ($x_addr == 69656bv64);
 const {:extern} $z_addr: bv64;
 axiom ($z_addr == 69652bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
-  (if (index == $x_addr) then (memory_load32_le(memory, $z_addr) == 0bv32) else (if (index == $z_addr) then true else false))
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
+  (if (index == $x_addr) then (memory_load32_le(mem$in, $z_addr) == 0bv32) else (if (index == $z_addr) then true else false))
 }
 
 function {:extern} {:bvbuiltin "bvadd"} bvadd64(bv64, bv64) returns (bv64);
@@ -29,19 +29,12 @@ function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv6
   (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
-}
-
 function {:extern} {:bvbuiltin "zero_extend 32"} zero_extend32_32(bv32) returns (bv64);
 procedure {:extern} rely();
   modifies Gamma_mem, mem;
   ensures (forall i: bv64 :: (((mem[i] == old(mem[i])) ==> (Gamma_mem[i] == old(Gamma_mem[i])))));
   ensures ((old(memory_load32_le(mem, $z_addr)) == 0bv32) ==> ((memory_load32_le(mem, $x_addr) == old(memory_load32_le(mem, $x_addr))) && (memory_load32_le(mem, $z_addr) == old(memory_load32_le(mem, $z_addr)))));
-  free ensures (memory_load8_le(mem, 1896bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1897bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1898bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1899bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1896bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69016bv64) == 1872bv64);
   free ensures (memory_load64_le(mem, 69024bv64) == 1792bv64);
   free ensures (memory_load64_le(mem, 69616bv64) == 1536bv64);
@@ -76,18 +69,12 @@ procedure main();
   modifies Gamma_R0, Gamma_R1, Gamma_R2, Gamma_mem, R0, R1, R2, mem;
   free requires (memory_load64_le(mem, 69632bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free requires (memory_load8_le(mem, 1896bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1897bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1898bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1899bv64) == 0bv8);
+  free requires (memory_load32_le(mem, 1896bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69016bv64) == 1872bv64);
   free requires (memory_load64_le(mem, 69024bv64) == 1792bv64);
   free requires (memory_load64_le(mem, 69616bv64) == 1536bv64);
   free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free ensures (memory_load8_le(mem, 1896bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1897bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1898bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1899bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1896bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69016bv64) == 1872bv64);
   free ensures (memory_load64_le(mem, 69024bv64) == 1792bv64);
   free ensures (memory_load64_le(mem, 69616bv64) == 1536bv64);
diff --git a/src/test/correct/basic_lock_security_read/gcc_O2/basic_lock_security_read_gtirb.expected b/src/test/correct/basic_lock_security_read/gcc_O2/basic_lock_security_read_gtirb.expected
index 82e9c9896..33d8384af 100644
--- a/src/test/correct/basic_lock_security_read/gcc_O2/basic_lock_security_read_gtirb.expected
+++ b/src/test/correct/basic_lock_security_read/gcc_O2/basic_lock_security_read_gtirb.expected
@@ -10,8 +10,8 @@ const {:extern} $x_addr: bv64;
 axiom ($x_addr == 69656bv64);
 const {:extern} $z_addr: bv64;
 axiom ($z_addr == 69652bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
-  (if (index == $x_addr) then (memory_load32_le(memory, $z_addr) == 0bv32) else (if (index == $z_addr) then true else false))
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
+  (if (index == $x_addr) then (memory_load32_le(mem$in, $z_addr) == 0bv32) else (if (index == $z_addr) then true else false))
 }
 
 function {:extern} {:bvbuiltin "bvadd"} bvadd64(bv64, bv64) returns (bv64);
@@ -27,19 +27,12 @@ function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv6
   (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
-}
-
 function {:extern} {:bvbuiltin "zero_extend 32"} zero_extend32_32(bv32) returns (bv64);
 procedure {:extern} rely();
   modifies Gamma_mem, mem;
   ensures (forall i: bv64 :: (((mem[i] == old(mem[i])) ==> (Gamma_mem[i] == old(Gamma_mem[i])))));
   ensures ((old(memory_load32_le(mem, $z_addr)) == 0bv32) ==> ((memory_load32_le(mem, $x_addr) == old(memory_load32_le(mem, $x_addr))) && (memory_load32_le(mem, $z_addr) == old(memory_load32_le(mem, $z_addr)))));
-  free ensures (memory_load8_le(mem, 1896bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1897bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1898bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1899bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1896bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69016bv64) == 1872bv64);
   free ensures (memory_load64_le(mem, 69024bv64) == 1792bv64);
   free ensures (memory_load64_le(mem, 69616bv64) == 1536bv64);
@@ -74,18 +67,12 @@ procedure main();
   modifies Gamma_R0, Gamma_R1, Gamma_R2, Gamma_mem, R0, R1, R2, mem;
   free requires (memory_load64_le(mem, 69632bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free requires (memory_load8_le(mem, 1896bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1897bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1898bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1899bv64) == 0bv8);
+  free requires (memory_load32_le(mem, 1896bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69016bv64) == 1872bv64);
   free requires (memory_load64_le(mem, 69024bv64) == 1792bv64);
   free requires (memory_load64_le(mem, 69616bv64) == 1536bv64);
   free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free ensures (memory_load8_le(mem, 1896bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1897bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1898bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1899bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1896bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69016bv64) == 1872bv64);
   free ensures (memory_load64_le(mem, 69024bv64) == 1792bv64);
   free ensures (memory_load64_le(mem, 69616bv64) == 1536bv64);
diff --git a/src/test/correct/basic_lock_security_read/gcc_pic/basic_lock_security_read.expected b/src/test/correct/basic_lock_security_read/gcc_pic/basic_lock_security_read.expected
index e509b20d8..f3c6100fa 100644
--- a/src/test/correct/basic_lock_security_read/gcc_pic/basic_lock_security_read.expected
+++ b/src/test/correct/basic_lock_security_read/gcc_pic/basic_lock_security_read.expected
@@ -18,8 +18,8 @@ const {:extern} $x_addr: bv64;
 axiom ($x_addr == 69652bv64);
 const {:extern} $z_addr: bv64;
 axiom ($z_addr == 69656bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
-  (if (index == $x_addr) then (memory_load32_le(memory, $z_addr) == 0bv32) else (if (index == $z_addr) then true else false))
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
+  (if (index == $x_addr) then (memory_load32_le(mem$in, $z_addr) == 0bv32) else (if (index == $z_addr) then true else false))
 }
 
 function {:extern} {:bvbuiltin "bvadd"} bvadd32(bv32, bv32) returns (bv32);
@@ -49,10 +49,6 @@ function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv6
   (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
-}
-
 function {:extern} memory_store32_le(memory: [bv64]bv8, index: bv64, value: bv32) returns ([bv64]bv8) {
   memory[index := value[8:0]][bvadd64(index, 1bv64) := value[16:8]][bvadd64(index, 2bv64) := value[24:16]][bvadd64(index, 3bv64) := value[32:24]]
 }
@@ -64,16 +60,13 @@ procedure {:extern} rely();
   modifies Gamma_mem, mem;
   ensures (forall i: bv64 :: (((mem[i] == old(mem[i])) ==> (Gamma_mem[i] == old(Gamma_mem[i])))));
   ensures ((old(memory_load32_le(mem, $z_addr)) == 0bv32) ==> ((memory_load32_le(mem, $x_addr) == old(memory_load32_le(mem, $x_addr))) && (memory_load32_le(mem, $z_addr) == old(memory_load32_le(mem, $z_addr)))));
-  free ensures (memory_load8_le(mem, 1952bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1953bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1954bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1955bv64) == 0bv8);
-  free ensures (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free ensures (memory_load64_le(mem, 69616bv64) == 1876bv64);
-  free ensures (memory_load64_le(mem, 69600bv64) == 69652bv64);
+  free ensures (memory_load32_le(mem, 1952bv64) == 131073bv32);
+  free ensures (memory_load64_le(mem, 69000bv64) == 1872bv64);
   free ensures (memory_load64_le(mem, 69008bv64) == 1792bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 69656bv64);
-  free ensures (memory_load64_le(mem, 69000bv64) == 1872bv64);
+  free ensures (memory_load64_le(mem, 69600bv64) == 69652bv64);
+  free ensures (memory_load64_le(mem, 69616bv64) == 1876bv64);
+  free ensures (memory_load64_le(mem, 69640bv64) == 69640bv64);
 
 procedure {:extern} rely_transitive();
   modifies Gamma_mem, mem;
@@ -104,28 +97,22 @@ procedure main();
   modifies CF, Gamma_CF, Gamma_NF, Gamma_R0, Gamma_R31, Gamma_VF, Gamma_ZF, Gamma_mem, Gamma_stack, NF, R0, R31, VF, ZF, mem, stack;
   free requires (memory_load64_le(mem, 69632bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free requires (memory_load8_le(mem, 1952bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1953bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1954bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1955bv64) == 0bv8);
-  free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free requires (memory_load64_le(mem, 69616bv64) == 1876bv64);
-  free requires (memory_load64_le(mem, 69600bv64) == 69652bv64);
+  free requires (memory_load32_le(mem, 1952bv64) == 131073bv32);
+  free requires (memory_load64_le(mem, 69000bv64) == 1872bv64);
   free requires (memory_load64_le(mem, 69008bv64) == 1792bv64);
   free requires (memory_load64_le(mem, 69592bv64) == 69656bv64);
-  free requires (memory_load64_le(mem, 69000bv64) == 1872bv64);
+  free requires (memory_load64_le(mem, 69600bv64) == 69652bv64);
+  free requires (memory_load64_le(mem, 69616bv64) == 1876bv64);
+  free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
   free ensures (Gamma_R31 == old(Gamma_R31));
   free ensures (R31 == old(R31));
-  free ensures (memory_load8_le(mem, 1952bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1953bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1954bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1955bv64) == 0bv8);
-  free ensures (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free ensures (memory_load64_le(mem, 69616bv64) == 1876bv64);
-  free ensures (memory_load64_le(mem, 69600bv64) == 69652bv64);
+  free ensures (memory_load32_le(mem, 1952bv64) == 131073bv32);
+  free ensures (memory_load64_le(mem, 69000bv64) == 1872bv64);
   free ensures (memory_load64_le(mem, 69008bv64) == 1792bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 69656bv64);
-  free ensures (memory_load64_le(mem, 69000bv64) == 1872bv64);
+  free ensures (memory_load64_le(mem, 69600bv64) == 69652bv64);
+  free ensures (memory_load64_le(mem, 69616bv64) == 1876bv64);
+  free ensures (memory_load64_le(mem, 69640bv64) == 69640bv64);
 
 implementation main()
 {
diff --git a/src/test/correct/basic_lock_security_read/gcc_pic/basic_lock_security_read_gtirb.expected b/src/test/correct/basic_lock_security_read/gcc_pic/basic_lock_security_read_gtirb.expected
index edf6b0af5..ad9c37b62 100644
--- a/src/test/correct/basic_lock_security_read/gcc_pic/basic_lock_security_read_gtirb.expected
+++ b/src/test/correct/basic_lock_security_read/gcc_pic/basic_lock_security_read_gtirb.expected
@@ -18,8 +18,8 @@ const {:extern} $x_addr: bv64;
 axiom ($x_addr == 69652bv64);
 const {:extern} $z_addr: bv64;
 axiom ($z_addr == 69656bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
-  (if (index == $x_addr) then (memory_load32_le(memory, $z_addr) == 0bv32) else (if (index == $z_addr) then true else false))
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
+  (if (index == $x_addr) then (memory_load32_le(mem$in, $z_addr) == 0bv32) else (if (index == $z_addr) then true else false))
 }
 
 function {:extern} {:bvbuiltin "bvadd"} bvadd32(bv32, bv32) returns (bv32);
@@ -48,10 +48,6 @@ function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv6
   (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
-}
-
 function {:extern} memory_store32_le(memory: [bv64]bv8, index: bv64, value: bv32) returns ([bv64]bv8) {
   memory[index := value[8:0]][bvadd64(index, 1bv64) := value[16:8]][bvadd64(index, 2bv64) := value[24:16]][bvadd64(index, 3bv64) := value[32:24]]
 }
@@ -62,16 +58,13 @@ procedure {:extern} rely();
   modifies Gamma_mem, mem;
   ensures (forall i: bv64 :: (((mem[i] == old(mem[i])) ==> (Gamma_mem[i] == old(Gamma_mem[i])))));
   ensures ((old(memory_load32_le(mem, $z_addr)) == 0bv32) ==> ((memory_load32_le(mem, $x_addr) == old(memory_load32_le(mem, $x_addr))) && (memory_load32_le(mem, $z_addr) == old(memory_load32_le(mem, $z_addr)))));
-  free ensures (memory_load8_le(mem, 1952bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1953bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1954bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1955bv64) == 0bv8);
-  free ensures (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free ensures (memory_load64_le(mem, 69616bv64) == 1876bv64);
-  free ensures (memory_load64_le(mem, 69600bv64) == 69652bv64);
+  free ensures (memory_load32_le(mem, 1952bv64) == 131073bv32);
+  free ensures (memory_load64_le(mem, 69000bv64) == 1872bv64);
   free ensures (memory_load64_le(mem, 69008bv64) == 1792bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 69656bv64);
-  free ensures (memory_load64_le(mem, 69000bv64) == 1872bv64);
+  free ensures (memory_load64_le(mem, 69600bv64) == 69652bv64);
+  free ensures (memory_load64_le(mem, 69616bv64) == 1876bv64);
+  free ensures (memory_load64_le(mem, 69640bv64) == 69640bv64);
 
 procedure {:extern} rely_transitive();
   modifies Gamma_mem, mem;
@@ -102,28 +95,22 @@ procedure main();
   modifies CF, Gamma_CF, Gamma_NF, Gamma_R0, Gamma_R31, Gamma_VF, Gamma_ZF, Gamma_mem, Gamma_stack, NF, R0, R31, VF, ZF, mem, stack;
   free requires (memory_load64_le(mem, 69632bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free requires (memory_load8_le(mem, 1952bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1953bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1954bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1955bv64) == 0bv8);
-  free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free requires (memory_load64_le(mem, 69616bv64) == 1876bv64);
-  free requires (memory_load64_le(mem, 69600bv64) == 69652bv64);
+  free requires (memory_load32_le(mem, 1952bv64) == 131073bv32);
+  free requires (memory_load64_le(mem, 69000bv64) == 1872bv64);
   free requires (memory_load64_le(mem, 69008bv64) == 1792bv64);
   free requires (memory_load64_le(mem, 69592bv64) == 69656bv64);
-  free requires (memory_load64_le(mem, 69000bv64) == 1872bv64);
+  free requires (memory_load64_le(mem, 69600bv64) == 69652bv64);
+  free requires (memory_load64_le(mem, 69616bv64) == 1876bv64);
+  free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
   free ensures (Gamma_R31 == old(Gamma_R31));
   free ensures (R31 == old(R31));
-  free ensures (memory_load8_le(mem, 1952bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1953bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1954bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1955bv64) == 0bv8);
-  free ensures (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free ensures (memory_load64_le(mem, 69616bv64) == 1876bv64);
-  free ensures (memory_load64_le(mem, 69600bv64) == 69652bv64);
+  free ensures (memory_load32_le(mem, 1952bv64) == 131073bv32);
+  free ensures (memory_load64_le(mem, 69000bv64) == 1872bv64);
   free ensures (memory_load64_le(mem, 69008bv64) == 1792bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 69656bv64);
-  free ensures (memory_load64_le(mem, 69000bv64) == 1872bv64);
+  free ensures (memory_load64_le(mem, 69600bv64) == 69652bv64);
+  free ensures (memory_load64_le(mem, 69616bv64) == 1876bv64);
+  free ensures (memory_load64_le(mem, 69640bv64) == 69640bv64);
 
 implementation main()
 {
diff --git a/src/test/correct/basic_lock_security_write/clang/basic_lock_security_write.expected b/src/test/correct/basic_lock_security_write/clang/basic_lock_security_write.expected
index 18d97f346..c44be0179 100644
--- a/src/test/correct/basic_lock_security_write/clang/basic_lock_security_write.expected
+++ b/src/test/correct/basic_lock_security_write/clang/basic_lock_security_write.expected
@@ -16,8 +16,8 @@ const {:extern} $x_addr: bv64;
 axiom ($x_addr == 69688bv64);
 const {:extern} $z_addr: bv64;
 axiom ($z_addr == 69684bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
-  (if (index == $x_addr) then (memory_load32_le(memory, $z_addr) == 0bv32) else (if (index == $z_addr) then true else false))
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
+  (if (index == $x_addr) then (memory_load32_le(mem$in, $z_addr) == 0bv32) else (if (index == $z_addr) then true else false))
 }
 
 function {:extern} {:bvbuiltin "bvadd"} bvadd64(bv64, bv64) returns (bv64);
@@ -37,10 +37,6 @@ function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv6
   (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
-}
-
 function {:extern} memory_store32_le(memory: [bv64]bv8, index: bv64, value: bv32) returns ([bv64]bv8) {
   memory[index := value[8:0]][bvadd64(index, 1bv64) := value[16:8]][bvadd64(index, 2bv64) := value[24:16]][bvadd64(index, 3bv64) := value[32:24]]
 }
@@ -50,10 +46,7 @@ procedure {:extern} rely();
   modifies Gamma_mem, mem;
   ensures (forall i: bv64 :: (((mem[i] == old(mem[i])) ==> (Gamma_mem[i] == old(Gamma_mem[i])))));
   ensures ((memory_load32_le(mem, $z_addr) == old(memory_load32_le(mem, $z_addr))) && (memory_load32_le(mem, $x_addr) == old(memory_load32_le(mem, $x_addr))));
-  free ensures (memory_load8_le(mem, 1884bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1885bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1886bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1887bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1884bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1812bv64);
@@ -90,20 +83,14 @@ procedure main();
   requires (Gamma_R0 == false);
   free requires (memory_load64_le(mem, 69664bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
-  free requires (memory_load8_le(mem, 1884bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1885bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1886bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1887bv64) == 0bv8);
+  free requires (memory_load32_le(mem, 1884bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free requires (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free requires (memory_load64_le(mem, 69592bv64) == 1812bv64);
   free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
   free ensures (Gamma_R31 == old(Gamma_R31));
   free ensures (R31 == old(R31));
-  free ensures (memory_load8_le(mem, 1884bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1885bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1886bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1887bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1884bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1812bv64);
diff --git a/src/test/correct/basic_lock_security_write/clang/basic_lock_security_write_gtirb.expected b/src/test/correct/basic_lock_security_write/clang/basic_lock_security_write_gtirb.expected
index 02034dd80..3e3676047 100644
--- a/src/test/correct/basic_lock_security_write/clang/basic_lock_security_write_gtirb.expected
+++ b/src/test/correct/basic_lock_security_write/clang/basic_lock_security_write_gtirb.expected
@@ -16,8 +16,8 @@ const {:extern} $x_addr: bv64;
 axiom ($x_addr == 69688bv64);
 const {:extern} $z_addr: bv64;
 axiom ($z_addr == 69684bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
-  (if (index == $x_addr) then (memory_load32_le(memory, $z_addr) == 0bv32) else (if (index == $z_addr) then true else false))
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
+  (if (index == $x_addr) then (memory_load32_le(mem$in, $z_addr) == 0bv32) else (if (index == $z_addr) then true else false))
 }
 
 function {:extern} {:bvbuiltin "bvadd"} bvadd64(bv64, bv64) returns (bv64);
@@ -37,10 +37,6 @@ function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv6
   (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
-}
-
 function {:extern} memory_store32_le(memory: [bv64]bv8, index: bv64, value: bv32) returns ([bv64]bv8) {
   memory[index := value[8:0]][bvadd64(index, 1bv64) := value[16:8]][bvadd64(index, 2bv64) := value[24:16]][bvadd64(index, 3bv64) := value[32:24]]
 }
@@ -50,10 +46,7 @@ procedure {:extern} rely();
   modifies Gamma_mem, mem;
   ensures (forall i: bv64 :: (((mem[i] == old(mem[i])) ==> (Gamma_mem[i] == old(Gamma_mem[i])))));
   ensures ((memory_load32_le(mem, $z_addr) == old(memory_load32_le(mem, $z_addr))) && (memory_load32_le(mem, $x_addr) == old(memory_load32_le(mem, $x_addr))));
-  free ensures (memory_load8_le(mem, 1884bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1885bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1886bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1887bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1884bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1812bv64);
@@ -90,20 +83,14 @@ procedure main();
   requires (Gamma_R0 == false);
   free requires (memory_load64_le(mem, 69664bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
-  free requires (memory_load8_le(mem, 1884bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1885bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1886bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1887bv64) == 0bv8);
+  free requires (memory_load32_le(mem, 1884bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free requires (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free requires (memory_load64_le(mem, 69592bv64) == 1812bv64);
   free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
   free ensures (Gamma_R31 == old(Gamma_R31));
   free ensures (R31 == old(R31));
-  free ensures (memory_load8_le(mem, 1884bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1885bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1886bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1887bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1884bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1812bv64);
diff --git a/src/test/correct/basic_lock_security_write/clang_O2/basic_lock_security_write.expected b/src/test/correct/basic_lock_security_write/clang_O2/basic_lock_security_write.expected
index ee50b1b52..9696e1c13 100644
--- a/src/test/correct/basic_lock_security_write/clang_O2/basic_lock_security_write.expected
+++ b/src/test/correct/basic_lock_security_write/clang_O2/basic_lock_security_write.expected
@@ -10,8 +10,8 @@ const {:extern} $x_addr: bv64;
 axiom ($x_addr == 69688bv64);
 const {:extern} $z_addr: bv64;
 axiom ($z_addr == 69684bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
-  (if (index == $x_addr) then (memory_load32_le(memory, $z_addr) == 0bv32) else (if (index == $z_addr) then true else false))
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
+  (if (index == $x_addr) then (memory_load32_le(mem$in, $z_addr) == 0bv32) else (if (index == $z_addr) then true else false))
 }
 
 function {:extern} {:bvbuiltin "bvadd"} bvadd64(bv64, bv64) returns (bv64);
@@ -31,10 +31,6 @@ function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv6
   (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
-}
-
 function {:extern} memory_store32_le(memory: [bv64]bv8, index: bv64, value: bv32) returns ([bv64]bv8) {
   memory[index := value[8:0]][bvadd64(index, 1bv64) := value[16:8]][bvadd64(index, 2bv64) := value[24:16]][bvadd64(index, 3bv64) := value[32:24]]
 }
@@ -43,10 +39,7 @@ procedure {:extern} rely();
   modifies Gamma_mem, mem;
   ensures (forall i: bv64 :: (((mem[i] == old(mem[i])) ==> (Gamma_mem[i] == old(Gamma_mem[i])))));
   ensures ((memory_load32_le(mem, $z_addr) == old(memory_load32_le(mem, $z_addr))) && (memory_load32_le(mem, $x_addr) == old(memory_load32_le(mem, $x_addr))));
-  free ensures (memory_load8_le(mem, 1856bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1857bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1858bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1859bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1856bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1812bv64);
@@ -83,18 +76,12 @@ procedure main();
   requires (Gamma_R0 == false);
   free requires (memory_load64_le(mem, 69664bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
-  free requires (memory_load8_le(mem, 1856bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1857bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1858bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1859bv64) == 0bv8);
+  free requires (memory_load32_le(mem, 1856bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free requires (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free requires (memory_load64_le(mem, 69592bv64) == 1812bv64);
   free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
-  free ensures (memory_load8_le(mem, 1856bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1857bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1858bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1859bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1856bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1812bv64);
diff --git a/src/test/correct/basic_lock_security_write/clang_O2/basic_lock_security_write_gtirb.expected b/src/test/correct/basic_lock_security_write/clang_O2/basic_lock_security_write_gtirb.expected
index a0d345a2e..95b42776d 100644
--- a/src/test/correct/basic_lock_security_write/clang_O2/basic_lock_security_write_gtirb.expected
+++ b/src/test/correct/basic_lock_security_write/clang_O2/basic_lock_security_write_gtirb.expected
@@ -10,8 +10,8 @@ const {:extern} $x_addr: bv64;
 axiom ($x_addr == 69688bv64);
 const {:extern} $z_addr: bv64;
 axiom ($z_addr == 69684bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
-  (if (index == $x_addr) then (memory_load32_le(memory, $z_addr) == 0bv32) else (if (index == $z_addr) then true else false))
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
+  (if (index == $x_addr) then (memory_load32_le(mem$in, $z_addr) == 0bv32) else (if (index == $z_addr) then true else false))
 }
 
 function {:extern} {:bvbuiltin "bvadd"} bvadd64(bv64, bv64) returns (bv64);
@@ -31,10 +31,6 @@ function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv6
   (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
-}
-
 function {:extern} memory_store32_le(memory: [bv64]bv8, index: bv64, value: bv32) returns ([bv64]bv8) {
   memory[index := value[8:0]][bvadd64(index, 1bv64) := value[16:8]][bvadd64(index, 2bv64) := value[24:16]][bvadd64(index, 3bv64) := value[32:24]]
 }
@@ -43,10 +39,7 @@ procedure {:extern} rely();
   modifies Gamma_mem, mem;
   ensures (forall i: bv64 :: (((mem[i] == old(mem[i])) ==> (Gamma_mem[i] == old(Gamma_mem[i])))));
   ensures ((memory_load32_le(mem, $z_addr) == old(memory_load32_le(mem, $z_addr))) && (memory_load32_le(mem, $x_addr) == old(memory_load32_le(mem, $x_addr))));
-  free ensures (memory_load8_le(mem, 1856bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1857bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1858bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1859bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1856bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1812bv64);
@@ -83,18 +76,12 @@ procedure main();
   requires (Gamma_R0 == false);
   free requires (memory_load64_le(mem, 69664bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
-  free requires (memory_load8_le(mem, 1856bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1857bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1858bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1859bv64) == 0bv8);
+  free requires (memory_load32_le(mem, 1856bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free requires (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free requires (memory_load64_le(mem, 69592bv64) == 1812bv64);
   free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
-  free ensures (memory_load8_le(mem, 1856bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1857bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1858bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1859bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1856bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1812bv64);
diff --git a/src/test/correct/basic_lock_security_write/clang_pic/basic_lock_security_write.expected b/src/test/correct/basic_lock_security_write/clang_pic/basic_lock_security_write.expected
index a161c995d..7760307dc 100644
--- a/src/test/correct/basic_lock_security_write/clang_pic/basic_lock_security_write.expected
+++ b/src/test/correct/basic_lock_security_write/clang_pic/basic_lock_security_write.expected
@@ -16,8 +16,8 @@ const {:extern} $x_addr: bv64;
 axiom ($x_addr == 69688bv64);
 const {:extern} $z_addr: bv64;
 axiom ($z_addr == 69684bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
-  (if (index == $x_addr) then (memory_load32_le(memory, $z_addr) == 0bv32) else (if (index == $z_addr) then true else false))
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
+  (if (index == $x_addr) then (memory_load32_le(mem$in, $z_addr) == 0bv32) else (if (index == $z_addr) then true else false))
 }
 
 function {:extern} {:bvbuiltin "bvadd"} bvadd64(bv64, bv64) returns (bv64);
@@ -41,10 +41,6 @@ function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv6
   (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
-}
-
 function {:extern} memory_store32_le(memory: [bv64]bv8, index: bv64, value: bv32) returns ([bv64]bv8) {
   memory[index := value[8:0]][bvadd64(index, 1bv64) := value[16:8]][bvadd64(index, 2bv64) := value[24:16]][bvadd64(index, 3bv64) := value[32:24]]
 }
@@ -54,16 +50,13 @@ procedure {:extern} rely();
   modifies Gamma_mem, mem;
   ensures (forall i: bv64 :: (((mem[i] == old(mem[i])) ==> (Gamma_mem[i] == old(Gamma_mem[i])))));
   ensures ((memory_load32_le(mem, $z_addr) == old(memory_load32_le(mem, $z_addr))) && (memory_load32_le(mem, $x_addr) == old(memory_load32_le(mem, $x_addr))));
-  free ensures (memory_load8_le(mem, 1956bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1957bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1958bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1959bv64) == 0bv8);
-  free ensures (memory_load64_le(mem, 69576bv64) == 69688bv64);
-  free ensures (memory_load64_le(mem, 69672bv64) == 69672bv64);
+  free ensures (memory_load32_le(mem, 1956bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69048bv64) == 1872bv64);
+  free ensures (memory_load64_le(mem, 69056bv64) == 1792bv64);
   free ensures (memory_load64_le(mem, 69568bv64) == 69684bv64);
+  free ensures (memory_load64_le(mem, 69576bv64) == 69688bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1876bv64);
-  free ensures (memory_load64_le(mem, 69056bv64) == 1792bv64);
+  free ensures (memory_load64_le(mem, 69672bv64) == 69672bv64);
 
 procedure {:extern} rely_transitive();
   modifies Gamma_mem, mem;
@@ -96,28 +89,22 @@ procedure main();
   requires (Gamma_R0 == false);
   free requires (memory_load64_le(mem, 69664bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
-  free requires (memory_load8_le(mem, 1956bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1957bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1958bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1959bv64) == 0bv8);
-  free requires (memory_load64_le(mem, 69576bv64) == 69688bv64);
-  free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
+  free requires (memory_load32_le(mem, 1956bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69048bv64) == 1872bv64);
+  free requires (memory_load64_le(mem, 69056bv64) == 1792bv64);
   free requires (memory_load64_le(mem, 69568bv64) == 69684bv64);
+  free requires (memory_load64_le(mem, 69576bv64) == 69688bv64);
   free requires (memory_load64_le(mem, 69592bv64) == 1876bv64);
-  free requires (memory_load64_le(mem, 69056bv64) == 1792bv64);
+  free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
   free ensures (Gamma_R31 == old(Gamma_R31));
   free ensures (R31 == old(R31));
-  free ensures (memory_load8_le(mem, 1956bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1957bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1958bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1959bv64) == 0bv8);
-  free ensures (memory_load64_le(mem, 69576bv64) == 69688bv64);
-  free ensures (memory_load64_le(mem, 69672bv64) == 69672bv64);
+  free ensures (memory_load32_le(mem, 1956bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69048bv64) == 1872bv64);
+  free ensures (memory_load64_le(mem, 69056bv64) == 1792bv64);
   free ensures (memory_load64_le(mem, 69568bv64) == 69684bv64);
+  free ensures (memory_load64_le(mem, 69576bv64) == 69688bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1876bv64);
-  free ensures (memory_load64_le(mem, 69056bv64) == 1792bv64);
+  free ensures (memory_load64_le(mem, 69672bv64) == 69672bv64);
 
 implementation main()
 {
diff --git a/src/test/correct/basic_lock_security_write/clang_pic/basic_lock_security_write_gtirb.expected b/src/test/correct/basic_lock_security_write/clang_pic/basic_lock_security_write_gtirb.expected
index 151193748..be7dfc3fa 100644
--- a/src/test/correct/basic_lock_security_write/clang_pic/basic_lock_security_write_gtirb.expected
+++ b/src/test/correct/basic_lock_security_write/clang_pic/basic_lock_security_write_gtirb.expected
@@ -16,8 +16,8 @@ const {:extern} $x_addr: bv64;
 axiom ($x_addr == 69688bv64);
 const {:extern} $z_addr: bv64;
 axiom ($z_addr == 69684bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
-  (if (index == $x_addr) then (memory_load32_le(memory, $z_addr) == 0bv32) else (if (index == $z_addr) then true else false))
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
+  (if (index == $x_addr) then (memory_load32_le(mem$in, $z_addr) == 0bv32) else (if (index == $z_addr) then true else false))
 }
 
 function {:extern} {:bvbuiltin "bvadd"} bvadd64(bv64, bv64) returns (bv64);
@@ -41,10 +41,6 @@ function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv6
   (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
-}
-
 function {:extern} memory_store32_le(memory: [bv64]bv8, index: bv64, value: bv32) returns ([bv64]bv8) {
   memory[index := value[8:0]][bvadd64(index, 1bv64) := value[16:8]][bvadd64(index, 2bv64) := value[24:16]][bvadd64(index, 3bv64) := value[32:24]]
 }
@@ -54,16 +50,13 @@ procedure {:extern} rely();
   modifies Gamma_mem, mem;
   ensures (forall i: bv64 :: (((mem[i] == old(mem[i])) ==> (Gamma_mem[i] == old(Gamma_mem[i])))));
   ensures ((memory_load32_le(mem, $z_addr) == old(memory_load32_le(mem, $z_addr))) && (memory_load32_le(mem, $x_addr) == old(memory_load32_le(mem, $x_addr))));
-  free ensures (memory_load8_le(mem, 1956bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1957bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1958bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1959bv64) == 0bv8);
-  free ensures (memory_load64_le(mem, 69576bv64) == 69688bv64);
-  free ensures (memory_load64_le(mem, 69672bv64) == 69672bv64);
+  free ensures (memory_load32_le(mem, 1956bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69048bv64) == 1872bv64);
+  free ensures (memory_load64_le(mem, 69056bv64) == 1792bv64);
   free ensures (memory_load64_le(mem, 69568bv64) == 69684bv64);
+  free ensures (memory_load64_le(mem, 69576bv64) == 69688bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1876bv64);
-  free ensures (memory_load64_le(mem, 69056bv64) == 1792bv64);
+  free ensures (memory_load64_le(mem, 69672bv64) == 69672bv64);
 
 procedure {:extern} rely_transitive();
   modifies Gamma_mem, mem;
@@ -96,28 +89,22 @@ procedure main();
   requires (Gamma_R0 == false);
   free requires (memory_load64_le(mem, 69664bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
-  free requires (memory_load8_le(mem, 1956bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1957bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1958bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1959bv64) == 0bv8);
-  free requires (memory_load64_le(mem, 69576bv64) == 69688bv64);
-  free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
+  free requires (memory_load32_le(mem, 1956bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69048bv64) == 1872bv64);
+  free requires (memory_load64_le(mem, 69056bv64) == 1792bv64);
   free requires (memory_load64_le(mem, 69568bv64) == 69684bv64);
+  free requires (memory_load64_le(mem, 69576bv64) == 69688bv64);
   free requires (memory_load64_le(mem, 69592bv64) == 1876bv64);
-  free requires (memory_load64_le(mem, 69056bv64) == 1792bv64);
+  free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
   free ensures (Gamma_R31 == old(Gamma_R31));
   free ensures (R31 == old(R31));
-  free ensures (memory_load8_le(mem, 1956bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1957bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1958bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1959bv64) == 0bv8);
-  free ensures (memory_load64_le(mem, 69576bv64) == 69688bv64);
-  free ensures (memory_load64_le(mem, 69672bv64) == 69672bv64);
+  free ensures (memory_load32_le(mem, 1956bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69048bv64) == 1872bv64);
+  free ensures (memory_load64_le(mem, 69056bv64) == 1792bv64);
   free ensures (memory_load64_le(mem, 69568bv64) == 69684bv64);
+  free ensures (memory_load64_le(mem, 69576bv64) == 69688bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1876bv64);
-  free ensures (memory_load64_le(mem, 69056bv64) == 1792bv64);
+  free ensures (memory_load64_le(mem, 69672bv64) == 69672bv64);
 
 implementation main()
 {
diff --git a/src/test/correct/basic_lock_security_write/gcc/basic_lock_security_write.expected b/src/test/correct/basic_lock_security_write/gcc/basic_lock_security_write.expected
index 58316b080..2429e5c62 100644
--- a/src/test/correct/basic_lock_security_write/gcc/basic_lock_security_write.expected
+++ b/src/test/correct/basic_lock_security_write/gcc/basic_lock_security_write.expected
@@ -12,8 +12,8 @@ const {:extern} $x_addr: bv64;
 axiom ($x_addr == 69652bv64);
 const {:extern} $z_addr: bv64;
 axiom ($z_addr == 69656bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
-  (if (index == $x_addr) then (memory_load32_le(memory, $z_addr) == 0bv32) else (if (index == $z_addr) then true else false))
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
+  (if (index == $x_addr) then (memory_load32_le(mem$in, $z_addr) == 0bv32) else (if (index == $z_addr) then true else false))
 }
 
 function {:extern} {:bvbuiltin "bvadd"} bvadd64(bv64, bv64) returns (bv64);
@@ -33,10 +33,6 @@ function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv6
   (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
-}
-
 function {:extern} memory_store32_le(memory: [bv64]bv8, index: bv64, value: bv32) returns ([bv64]bv8) {
   memory[index := value[8:0]][bvadd64(index, 1bv64) := value[16:8]][bvadd64(index, 2bv64) := value[24:16]][bvadd64(index, 3bv64) := value[32:24]]
 }
@@ -46,10 +42,7 @@ procedure {:extern} rely();
   modifies Gamma_mem, mem;
   ensures (forall i: bv64 :: (((mem[i] == old(mem[i])) ==> (Gamma_mem[i] == old(Gamma_mem[i])))));
   ensures ((memory_load32_le(mem, $z_addr) == old(memory_load32_le(mem, $z_addr))) && (memory_load32_le(mem, $x_addr) == old(memory_load32_le(mem, $x_addr))));
-  free ensures (memory_load8_le(mem, 1908bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1909bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1910bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1911bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1908bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69016bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69024bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69616bv64) == 1812bv64);
@@ -86,20 +79,14 @@ procedure main();
   requires (Gamma_R0 == false);
   free requires (memory_load64_le(mem, 69632bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free requires (memory_load8_le(mem, 1908bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1909bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1910bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1911bv64) == 0bv8);
+  free requires (memory_load32_le(mem, 1908bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69016bv64) == 1808bv64);
   free requires (memory_load64_le(mem, 69024bv64) == 1728bv64);
   free requires (memory_load64_le(mem, 69616bv64) == 1812bv64);
   free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
   free ensures (Gamma_R31 == old(Gamma_R31));
   free ensures (R31 == old(R31));
-  free ensures (memory_load8_le(mem, 1908bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1909bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1910bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1911bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1908bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69016bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69024bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69616bv64) == 1812bv64);
@@ -120,8 +107,8 @@ implementation main()
     R1, Gamma_R1 := 1bv64, true;
     call rely();
     assert (L(mem, R0) ==> Gamma_R1);
-    z_old := memory_load32_le(mem, $z_addr);
     x_old := memory_load32_le(mem, $x_addr);
+    z_old := memory_load32_le(mem, $z_addr);
     Gamma_x_old := (gamma_load32(Gamma_mem, $x_addr) || L(mem, $x_addr));
     mem, Gamma_mem := memory_store32_le(mem, R0, R1[32:0]), gamma_store32(Gamma_mem, R0, Gamma_R1);
     assert ((R0 == $z_addr) ==> (L(mem, $x_addr) ==> Gamma_x_old));
@@ -132,8 +119,8 @@ implementation main()
     R1, Gamma_R1 := zero_extend32_32(memory_load32_le(stack, bvadd64(R31, 12bv64))), gamma_load32(Gamma_stack, bvadd64(R31, 12bv64));
     call rely();
     assert (L(mem, R0) ==> Gamma_R1);
-    z_old := memory_load32_le(mem, $z_addr);
     x_old := memory_load32_le(mem, $x_addr);
+    z_old := memory_load32_le(mem, $z_addr);
     Gamma_x_old := (gamma_load32(Gamma_mem, $x_addr) || L(mem, $x_addr));
     mem, Gamma_mem := memory_store32_le(mem, R0, R1[32:0]), gamma_store32(Gamma_mem, R0, Gamma_R1);
     assert ((R0 == $z_addr) ==> (L(mem, $x_addr) ==> Gamma_x_old));
@@ -143,8 +130,8 @@ implementation main()
     R0, Gamma_R0 := bvadd64(R0, 20bv64), Gamma_R0;
     call rely();
     assert (L(mem, R0) ==> true);
-    z_old := memory_load32_le(mem, $z_addr);
     x_old := memory_load32_le(mem, $x_addr);
+    z_old := memory_load32_le(mem, $z_addr);
     Gamma_x_old := (gamma_load32(Gamma_mem, $x_addr) || L(mem, $x_addr));
     mem, Gamma_mem := memory_store32_le(mem, R0, 0bv32), gamma_store32(Gamma_mem, R0, true);
     assert ((R0 == $z_addr) ==> (L(mem, $x_addr) ==> Gamma_x_old));
@@ -154,8 +141,8 @@ implementation main()
     R0, Gamma_R0 := bvadd64(R0, 24bv64), Gamma_R0;
     call rely();
     assert (L(mem, R0) ==> true);
-    z_old := memory_load32_le(mem, $z_addr);
     x_old := memory_load32_le(mem, $x_addr);
+    z_old := memory_load32_le(mem, $z_addr);
     Gamma_x_old := (gamma_load32(Gamma_mem, $x_addr) || L(mem, $x_addr));
     mem, Gamma_mem := memory_store32_le(mem, R0, 0bv32), gamma_store32(Gamma_mem, R0, true);
     assert ((R0 == $z_addr) ==> (L(mem, $x_addr) ==> Gamma_x_old));
diff --git a/src/test/correct/basic_lock_security_write/gcc/basic_lock_security_write_gtirb.expected b/src/test/correct/basic_lock_security_write/gcc/basic_lock_security_write_gtirb.expected
index b09f64f99..376db824c 100644
--- a/src/test/correct/basic_lock_security_write/gcc/basic_lock_security_write_gtirb.expected
+++ b/src/test/correct/basic_lock_security_write/gcc/basic_lock_security_write_gtirb.expected
@@ -12,8 +12,8 @@ const {:extern} $x_addr: bv64;
 axiom ($x_addr == 69652bv64);
 const {:extern} $z_addr: bv64;
 axiom ($z_addr == 69656bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
-  (if (index == $x_addr) then (memory_load32_le(memory, $z_addr) == 0bv32) else (if (index == $z_addr) then true else false))
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
+  (if (index == $x_addr) then (memory_load32_le(mem$in, $z_addr) == 0bv32) else (if (index == $z_addr) then true else false))
 }
 
 function {:extern} {:bvbuiltin "bvadd"} bvadd64(bv64, bv64) returns (bv64);
@@ -33,10 +33,6 @@ function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv6
   (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
-}
-
 function {:extern} memory_store32_le(memory: [bv64]bv8, index: bv64, value: bv32) returns ([bv64]bv8) {
   memory[index := value[8:0]][bvadd64(index, 1bv64) := value[16:8]][bvadd64(index, 2bv64) := value[24:16]][bvadd64(index, 3bv64) := value[32:24]]
 }
@@ -46,10 +42,7 @@ procedure {:extern} rely();
   modifies Gamma_mem, mem;
   ensures (forall i: bv64 :: (((mem[i] == old(mem[i])) ==> (Gamma_mem[i] == old(Gamma_mem[i])))));
   ensures ((memory_load32_le(mem, $z_addr) == old(memory_load32_le(mem, $z_addr))) && (memory_load32_le(mem, $x_addr) == old(memory_load32_le(mem, $x_addr))));
-  free ensures (memory_load8_le(mem, 1908bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1909bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1910bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1911bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1908bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69016bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69024bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69616bv64) == 1812bv64);
@@ -86,20 +79,14 @@ procedure main();
   requires (Gamma_R0 == false);
   free requires (memory_load64_le(mem, 69632bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free requires (memory_load8_le(mem, 1908bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1909bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1910bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1911bv64) == 0bv8);
+  free requires (memory_load32_le(mem, 1908bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69016bv64) == 1808bv64);
   free requires (memory_load64_le(mem, 69024bv64) == 1728bv64);
   free requires (memory_load64_le(mem, 69616bv64) == 1812bv64);
   free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
   free ensures (Gamma_R31 == old(Gamma_R31));
   free ensures (R31 == old(R31));
-  free ensures (memory_load8_le(mem, 1908bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1909bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1910bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1911bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1908bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69016bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69024bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69616bv64) == 1812bv64);
@@ -120,8 +107,8 @@ implementation main()
     R1, Gamma_R1 := 1bv64, true;
     call rely();
     assert (L(mem, R0) ==> Gamma_R1);
-    z_old := memory_load32_le(mem, $z_addr);
     x_old := memory_load32_le(mem, $x_addr);
+    z_old := memory_load32_le(mem, $z_addr);
     Gamma_x_old := (gamma_load32(Gamma_mem, $x_addr) || L(mem, $x_addr));
     mem, Gamma_mem := memory_store32_le(mem, R0, R1[32:0]), gamma_store32(Gamma_mem, R0, Gamma_R1);
     assert ((R0 == $z_addr) ==> (L(mem, $x_addr) ==> Gamma_x_old));
@@ -132,8 +119,8 @@ implementation main()
     R1, Gamma_R1 := zero_extend32_32(memory_load32_le(stack, bvadd64(R31, 12bv64))), gamma_load32(Gamma_stack, bvadd64(R31, 12bv64));
     call rely();
     assert (L(mem, R0) ==> Gamma_R1);
-    z_old := memory_load32_le(mem, $z_addr);
     x_old := memory_load32_le(mem, $x_addr);
+    z_old := memory_load32_le(mem, $z_addr);
     Gamma_x_old := (gamma_load32(Gamma_mem, $x_addr) || L(mem, $x_addr));
     mem, Gamma_mem := memory_store32_le(mem, R0, R1[32:0]), gamma_store32(Gamma_mem, R0, Gamma_R1);
     assert ((R0 == $z_addr) ==> (L(mem, $x_addr) ==> Gamma_x_old));
@@ -143,8 +130,8 @@ implementation main()
     R0, Gamma_R0 := bvadd64(R0, 20bv64), Gamma_R0;
     call rely();
     assert (L(mem, R0) ==> true);
-    z_old := memory_load32_le(mem, $z_addr);
     x_old := memory_load32_le(mem, $x_addr);
+    z_old := memory_load32_le(mem, $z_addr);
     Gamma_x_old := (gamma_load32(Gamma_mem, $x_addr) || L(mem, $x_addr));
     mem, Gamma_mem := memory_store32_le(mem, R0, 0bv32), gamma_store32(Gamma_mem, R0, true);
     assert ((R0 == $z_addr) ==> (L(mem, $x_addr) ==> Gamma_x_old));
@@ -154,8 +141,8 @@ implementation main()
     R0, Gamma_R0 := bvadd64(R0, 24bv64), Gamma_R0;
     call rely();
     assert (L(mem, R0) ==> true);
-    z_old := memory_load32_le(mem, $z_addr);
     x_old := memory_load32_le(mem, $x_addr);
+    z_old := memory_load32_le(mem, $z_addr);
     Gamma_x_old := (gamma_load32(Gamma_mem, $x_addr) || L(mem, $x_addr));
     mem, Gamma_mem := memory_store32_le(mem, R0, 0bv32), gamma_store32(Gamma_mem, R0, true);
     assert ((R0 == $z_addr) ==> (L(mem, $x_addr) ==> Gamma_x_old));
diff --git a/src/test/correct/basic_lock_security_write/gcc_O2/basic_lock_security_write.expected b/src/test/correct/basic_lock_security_write/gcc_O2/basic_lock_security_write.expected
index 142ca8ac7..4c3d6f081 100644
--- a/src/test/correct/basic_lock_security_write/gcc_O2/basic_lock_security_write.expected
+++ b/src/test/correct/basic_lock_security_write/gcc_O2/basic_lock_security_write.expected
@@ -10,8 +10,8 @@ const {:extern} $x_addr: bv64;
 axiom ($x_addr == 69652bv64);
 const {:extern} $z_addr: bv64;
 axiom ($z_addr == 69656bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
-  (if (index == $x_addr) then (memory_load32_le(memory, $z_addr) == 0bv32) else (if (index == $z_addr) then true else false))
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
+  (if (index == $x_addr) then (memory_load32_le(mem$in, $z_addr) == 0bv32) else (if (index == $z_addr) then true else false))
 }
 
 function {:extern} {:bvbuiltin "bvadd"} bvadd64(bv64, bv64) returns (bv64);
@@ -31,10 +31,6 @@ function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv6
   (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
-}
-
 function {:extern} memory_store32_le(memory: [bv64]bv8, index: bv64, value: bv32) returns ([bv64]bv8) {
   memory[index := value[8:0]][bvadd64(index, 1bv64) := value[16:8]][bvadd64(index, 2bv64) := value[24:16]][bvadd64(index, 3bv64) := value[32:24]]
 }
@@ -43,10 +39,7 @@ procedure {:extern} rely();
   modifies Gamma_mem, mem;
   ensures (forall i: bv64 :: (((mem[i] == old(mem[i])) ==> (Gamma_mem[i] == old(Gamma_mem[i])))));
   ensures ((memory_load32_le(mem, $z_addr) == old(memory_load32_le(mem, $z_addr))) && (memory_load32_le(mem, $x_addr) == old(memory_load32_le(mem, $x_addr))));
-  free ensures (memory_load8_le(mem, 1896bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1897bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1898bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1899bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1896bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69016bv64) == 1872bv64);
   free ensures (memory_load64_le(mem, 69024bv64) == 1792bv64);
   free ensures (memory_load64_le(mem, 69616bv64) == 1536bv64);
@@ -83,18 +76,12 @@ procedure main();
   requires (Gamma_R0 == false);
   free requires (memory_load64_le(mem, 69632bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free requires (memory_load8_le(mem, 1896bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1897bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1898bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1899bv64) == 0bv8);
+  free requires (memory_load32_le(mem, 1896bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69016bv64) == 1872bv64);
   free requires (memory_load64_le(mem, 69024bv64) == 1792bv64);
   free requires (memory_load64_le(mem, 69616bv64) == 1536bv64);
   free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free ensures (memory_load8_le(mem, 1896bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1897bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1898bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1899bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1896bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69016bv64) == 1872bv64);
   free ensures (memory_load64_le(mem, 69024bv64) == 1792bv64);
   free ensures (memory_load64_le(mem, 69616bv64) == 1536bv64);
@@ -112,8 +99,8 @@ implementation main()
     R0, Gamma_R0 := 0bv64, true;
     call rely();
     assert (L(mem, bvadd64(R1, 20bv64)) ==> true);
-    z_old := memory_load32_le(mem, $z_addr);
     x_old := memory_load32_le(mem, $x_addr);
+    z_old := memory_load32_le(mem, $z_addr);
     Gamma_x_old := (gamma_load32(Gamma_mem, $x_addr) || L(mem, $x_addr));
     mem, Gamma_mem := memory_store32_le(mem, bvadd64(R1, 20bv64), 0bv32), gamma_store32(Gamma_mem, bvadd64(R1, 20bv64), true);
     assert ((bvadd64(R1, 20bv64) == $z_addr) ==> (L(mem, $x_addr) ==> Gamma_x_old));
@@ -121,8 +108,8 @@ implementation main()
     assume {:captureState "%000001bd"} true;
     call rely();
     assert (L(mem, bvadd64(R2, 4bv64)) ==> true);
-    z_old := memory_load32_le(mem, $z_addr);
     x_old := memory_load32_le(mem, $x_addr);
+    z_old := memory_load32_le(mem, $z_addr);
     Gamma_x_old := (gamma_load32(Gamma_mem, $x_addr) || L(mem, $x_addr));
     mem, Gamma_mem := memory_store32_le(mem, bvadd64(R2, 4bv64), 0bv32), gamma_store32(Gamma_mem, bvadd64(R2, 4bv64), true);
     assert ((bvadd64(R2, 4bv64) == $z_addr) ==> (L(mem, $x_addr) ==> Gamma_x_old));
diff --git a/src/test/correct/basic_lock_security_write/gcc_O2/basic_lock_security_write_gtirb.expected b/src/test/correct/basic_lock_security_write/gcc_O2/basic_lock_security_write_gtirb.expected
index 346670a0f..d70a6810b 100644
--- a/src/test/correct/basic_lock_security_write/gcc_O2/basic_lock_security_write_gtirb.expected
+++ b/src/test/correct/basic_lock_security_write/gcc_O2/basic_lock_security_write_gtirb.expected
@@ -10,8 +10,8 @@ const {:extern} $x_addr: bv64;
 axiom ($x_addr == 69652bv64);
 const {:extern} $z_addr: bv64;
 axiom ($z_addr == 69656bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
-  (if (index == $x_addr) then (memory_load32_le(memory, $z_addr) == 0bv32) else (if (index == $z_addr) then true else false))
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
+  (if (index == $x_addr) then (memory_load32_le(mem$in, $z_addr) == 0bv32) else (if (index == $z_addr) then true else false))
 }
 
 function {:extern} {:bvbuiltin "bvadd"} bvadd64(bv64, bv64) returns (bv64);
@@ -31,10 +31,6 @@ function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv6
   (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
-}
-
 function {:extern} memory_store32_le(memory: [bv64]bv8, index: bv64, value: bv32) returns ([bv64]bv8) {
   memory[index := value[8:0]][bvadd64(index, 1bv64) := value[16:8]][bvadd64(index, 2bv64) := value[24:16]][bvadd64(index, 3bv64) := value[32:24]]
 }
@@ -43,10 +39,7 @@ procedure {:extern} rely();
   modifies Gamma_mem, mem;
   ensures (forall i: bv64 :: (((mem[i] == old(mem[i])) ==> (Gamma_mem[i] == old(Gamma_mem[i])))));
   ensures ((memory_load32_le(mem, $z_addr) == old(memory_load32_le(mem, $z_addr))) && (memory_load32_le(mem, $x_addr) == old(memory_load32_le(mem, $x_addr))));
-  free ensures (memory_load8_le(mem, 1896bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1897bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1898bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1899bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1896bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69016bv64) == 1872bv64);
   free ensures (memory_load64_le(mem, 69024bv64) == 1792bv64);
   free ensures (memory_load64_le(mem, 69616bv64) == 1536bv64);
@@ -83,18 +76,12 @@ procedure main();
   requires (Gamma_R0 == false);
   free requires (memory_load64_le(mem, 69632bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free requires (memory_load8_le(mem, 1896bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1897bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1898bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1899bv64) == 0bv8);
+  free requires (memory_load32_le(mem, 1896bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69016bv64) == 1872bv64);
   free requires (memory_load64_le(mem, 69024bv64) == 1792bv64);
   free requires (memory_load64_le(mem, 69616bv64) == 1536bv64);
   free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free ensures (memory_load8_le(mem, 1896bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1897bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1898bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1899bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1896bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69016bv64) == 1872bv64);
   free ensures (memory_load64_le(mem, 69024bv64) == 1792bv64);
   free ensures (memory_load64_le(mem, 69616bv64) == 1536bv64);
@@ -112,8 +99,8 @@ implementation main()
     R0, Gamma_R0 := 0bv64, true;
     call rely();
     assert (L(mem, bvadd64(R1, 20bv64)) ==> true);
-    z_old := memory_load32_le(mem, $z_addr);
     x_old := memory_load32_le(mem, $x_addr);
+    z_old := memory_load32_le(mem, $z_addr);
     Gamma_x_old := (gamma_load32(Gamma_mem, $x_addr) || L(mem, $x_addr));
     mem, Gamma_mem := memory_store32_le(mem, bvadd64(R1, 20bv64), 0bv32), gamma_store32(Gamma_mem, bvadd64(R1, 20bv64), true);
     assert ((bvadd64(R1, 20bv64) == $z_addr) ==> (L(mem, $x_addr) ==> Gamma_x_old));
@@ -121,8 +108,8 @@ implementation main()
     assume {:captureState "1548$0"} true;
     call rely();
     assert (L(mem, bvadd64(R2, 4bv64)) ==> true);
-    z_old := memory_load32_le(mem, $z_addr);
     x_old := memory_load32_le(mem, $x_addr);
+    z_old := memory_load32_le(mem, $z_addr);
     Gamma_x_old := (gamma_load32(Gamma_mem, $x_addr) || L(mem, $x_addr));
     mem, Gamma_mem := memory_store32_le(mem, bvadd64(R2, 4bv64), 0bv32), gamma_store32(Gamma_mem, bvadd64(R2, 4bv64), true);
     assert ((bvadd64(R2, 4bv64) == $z_addr) ==> (L(mem, $x_addr) ==> Gamma_x_old));
diff --git a/src/test/correct/basic_lock_security_write/gcc_pic/basic_lock_security_write.expected b/src/test/correct/basic_lock_security_write/gcc_pic/basic_lock_security_write.expected
index e9c34ead8..91e7850ba 100644
--- a/src/test/correct/basic_lock_security_write/gcc_pic/basic_lock_security_write.expected
+++ b/src/test/correct/basic_lock_security_write/gcc_pic/basic_lock_security_write.expected
@@ -12,8 +12,8 @@ const {:extern} $x_addr: bv64;
 axiom ($x_addr == 69652bv64);
 const {:extern} $z_addr: bv64;
 axiom ($z_addr == 69656bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
-  (if (index == $x_addr) then (memory_load32_le(memory, $z_addr) == 0bv32) else (if (index == $z_addr) then true else false))
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
+  (if (index == $x_addr) then (memory_load32_le(mem$in, $z_addr) == 0bv32) else (if (index == $z_addr) then true else false))
 }
 
 function {:extern} {:bvbuiltin "bvadd"} bvadd64(bv64, bv64) returns (bv64);
@@ -37,10 +37,6 @@ function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv6
   (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
-}
-
 function {:extern} memory_store32_le(memory: [bv64]bv8, index: bv64, value: bv32) returns ([bv64]bv8) {
   memory[index := value[8:0]][bvadd64(index, 1bv64) := value[16:8]][bvadd64(index, 2bv64) := value[24:16]][bvadd64(index, 3bv64) := value[32:24]]
 }
@@ -50,16 +46,13 @@ procedure {:extern} rely();
   modifies Gamma_mem, mem;
   ensures (forall i: bv64 :: (((mem[i] == old(mem[i])) ==> (Gamma_mem[i] == old(Gamma_mem[i])))));
   ensures ((memory_load32_le(mem, $z_addr) == old(memory_load32_le(mem, $z_addr))) && (memory_load32_le(mem, $x_addr) == old(memory_load32_le(mem, $x_addr))));
-  free ensures (memory_load8_le(mem, 1972bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1973bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1974bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1975bv64) == 0bv8);
-  free ensures (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free ensures (memory_load64_le(mem, 69616bv64) == 1876bv64);
-  free ensures (memory_load64_le(mem, 69600bv64) == 69652bv64);
+  free ensures (memory_load32_le(mem, 1972bv64) == 131073bv32);
+  free ensures (memory_load64_le(mem, 69000bv64) == 1872bv64);
   free ensures (memory_load64_le(mem, 69008bv64) == 1792bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 69656bv64);
-  free ensures (memory_load64_le(mem, 69000bv64) == 1872bv64);
+  free ensures (memory_load64_le(mem, 69600bv64) == 69652bv64);
+  free ensures (memory_load64_le(mem, 69616bv64) == 1876bv64);
+  free ensures (memory_load64_le(mem, 69640bv64) == 69640bv64);
 
 procedure {:extern} rely_transitive();
   modifies Gamma_mem, mem;
@@ -92,28 +85,22 @@ procedure main();
   requires (Gamma_R0 == false);
   free requires (memory_load64_le(mem, 69632bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free requires (memory_load8_le(mem, 1972bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1973bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1974bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1975bv64) == 0bv8);
-  free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free requires (memory_load64_le(mem, 69616bv64) == 1876bv64);
-  free requires (memory_load64_le(mem, 69600bv64) == 69652bv64);
+  free requires (memory_load32_le(mem, 1972bv64) == 131073bv32);
+  free requires (memory_load64_le(mem, 69000bv64) == 1872bv64);
   free requires (memory_load64_le(mem, 69008bv64) == 1792bv64);
   free requires (memory_load64_le(mem, 69592bv64) == 69656bv64);
-  free requires (memory_load64_le(mem, 69000bv64) == 1872bv64);
+  free requires (memory_load64_le(mem, 69600bv64) == 69652bv64);
+  free requires (memory_load64_le(mem, 69616bv64) == 1876bv64);
+  free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
   free ensures (Gamma_R31 == old(Gamma_R31));
   free ensures (R31 == old(R31));
-  free ensures (memory_load8_le(mem, 1972bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1973bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1974bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1975bv64) == 0bv8);
-  free ensures (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free ensures (memory_load64_le(mem, 69616bv64) == 1876bv64);
-  free ensures (memory_load64_le(mem, 69600bv64) == 69652bv64);
+  free ensures (memory_load32_le(mem, 1972bv64) == 131073bv32);
+  free ensures (memory_load64_le(mem, 69000bv64) == 1872bv64);
   free ensures (memory_load64_le(mem, 69008bv64) == 1792bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 69656bv64);
-  free ensures (memory_load64_le(mem, 69000bv64) == 1872bv64);
+  free ensures (memory_load64_le(mem, 69600bv64) == 69652bv64);
+  free ensures (memory_load64_le(mem, 69616bv64) == 1876bv64);
+  free ensures (memory_load64_le(mem, 69640bv64) == 69640bv64);
 
 implementation main()
 {
@@ -131,8 +118,8 @@ implementation main()
     R1, Gamma_R1 := 1bv64, true;
     call rely();
     assert (L(mem, R0) ==> Gamma_R1);
-    z_old := memory_load32_le(mem, $z_addr);
     x_old := memory_load32_le(mem, $x_addr);
+    z_old := memory_load32_le(mem, $z_addr);
     Gamma_x_old := (gamma_load32(Gamma_mem, $x_addr) || L(mem, $x_addr));
     mem, Gamma_mem := memory_store32_le(mem, R0, R1[32:0]), gamma_store32(Gamma_mem, R0, Gamma_R1);
     assert ((R0 == $z_addr) ==> (L(mem, $x_addr) ==> Gamma_x_old));
@@ -144,8 +131,8 @@ implementation main()
     R1, Gamma_R1 := zero_extend32_32(memory_load32_le(stack, bvadd64(R31, 12bv64))), gamma_load32(Gamma_stack, bvadd64(R31, 12bv64));
     call rely();
     assert (L(mem, R0) ==> Gamma_R1);
-    z_old := memory_load32_le(mem, $z_addr);
     x_old := memory_load32_le(mem, $x_addr);
+    z_old := memory_load32_le(mem, $z_addr);
     Gamma_x_old := (gamma_load32(Gamma_mem, $x_addr) || L(mem, $x_addr));
     mem, Gamma_mem := memory_store32_le(mem, R0, R1[32:0]), gamma_store32(Gamma_mem, R0, Gamma_R1);
     assert ((R0 == $z_addr) ==> (L(mem, $x_addr) ==> Gamma_x_old));
@@ -156,8 +143,8 @@ implementation main()
     R0, Gamma_R0 := memory_load64_le(mem, bvadd64(R0, 4064bv64)), (gamma_load64(Gamma_mem, bvadd64(R0, 4064bv64)) || L(mem, bvadd64(R0, 4064bv64)));
     call rely();
     assert (L(mem, R0) ==> true);
-    z_old := memory_load32_le(mem, $z_addr);
     x_old := memory_load32_le(mem, $x_addr);
+    z_old := memory_load32_le(mem, $z_addr);
     Gamma_x_old := (gamma_load32(Gamma_mem, $x_addr) || L(mem, $x_addr));
     mem, Gamma_mem := memory_store32_le(mem, R0, 0bv32), gamma_store32(Gamma_mem, R0, true);
     assert ((R0 == $z_addr) ==> (L(mem, $x_addr) ==> Gamma_x_old));
@@ -168,8 +155,8 @@ implementation main()
     R0, Gamma_R0 := memory_load64_le(mem, bvadd64(R0, 4056bv64)), (gamma_load64(Gamma_mem, bvadd64(R0, 4056bv64)) || L(mem, bvadd64(R0, 4056bv64)));
     call rely();
     assert (L(mem, R0) ==> true);
-    z_old := memory_load32_le(mem, $z_addr);
     x_old := memory_load32_le(mem, $x_addr);
+    z_old := memory_load32_le(mem, $z_addr);
     Gamma_x_old := (gamma_load32(Gamma_mem, $x_addr) || L(mem, $x_addr));
     mem, Gamma_mem := memory_store32_le(mem, R0, 0bv32), gamma_store32(Gamma_mem, R0, true);
     assert ((R0 == $z_addr) ==> (L(mem, $x_addr) ==> Gamma_x_old));
diff --git a/src/test/correct/basic_lock_security_write/gcc_pic/basic_lock_security_write_gtirb.expected b/src/test/correct/basic_lock_security_write/gcc_pic/basic_lock_security_write_gtirb.expected
index b955f39f5..28daee648 100644
--- a/src/test/correct/basic_lock_security_write/gcc_pic/basic_lock_security_write_gtirb.expected
+++ b/src/test/correct/basic_lock_security_write/gcc_pic/basic_lock_security_write_gtirb.expected
@@ -12,8 +12,8 @@ const {:extern} $x_addr: bv64;
 axiom ($x_addr == 69652bv64);
 const {:extern} $z_addr: bv64;
 axiom ($z_addr == 69656bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
-  (if (index == $x_addr) then (memory_load32_le(memory, $z_addr) == 0bv32) else (if (index == $z_addr) then true else false))
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
+  (if (index == $x_addr) then (memory_load32_le(mem$in, $z_addr) == 0bv32) else (if (index == $z_addr) then true else false))
 }
 
 function {:extern} {:bvbuiltin "bvadd"} bvadd64(bv64, bv64) returns (bv64);
@@ -37,10 +37,6 @@ function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv6
   (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
-}
-
 function {:extern} memory_store32_le(memory: [bv64]bv8, index: bv64, value: bv32) returns ([bv64]bv8) {
   memory[index := value[8:0]][bvadd64(index, 1bv64) := value[16:8]][bvadd64(index, 2bv64) := value[24:16]][bvadd64(index, 3bv64) := value[32:24]]
 }
@@ -50,16 +46,13 @@ procedure {:extern} rely();
   modifies Gamma_mem, mem;
   ensures (forall i: bv64 :: (((mem[i] == old(mem[i])) ==> (Gamma_mem[i] == old(Gamma_mem[i])))));
   ensures ((memory_load32_le(mem, $z_addr) == old(memory_load32_le(mem, $z_addr))) && (memory_load32_le(mem, $x_addr) == old(memory_load32_le(mem, $x_addr))));
-  free ensures (memory_load8_le(mem, 1972bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1973bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1974bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1975bv64) == 0bv8);
-  free ensures (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free ensures (memory_load64_le(mem, 69616bv64) == 1876bv64);
-  free ensures (memory_load64_le(mem, 69600bv64) == 69652bv64);
+  free ensures (memory_load32_le(mem, 1972bv64) == 131073bv32);
+  free ensures (memory_load64_le(mem, 69000bv64) == 1872bv64);
   free ensures (memory_load64_le(mem, 69008bv64) == 1792bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 69656bv64);
-  free ensures (memory_load64_le(mem, 69000bv64) == 1872bv64);
+  free ensures (memory_load64_le(mem, 69600bv64) == 69652bv64);
+  free ensures (memory_load64_le(mem, 69616bv64) == 1876bv64);
+  free ensures (memory_load64_le(mem, 69640bv64) == 69640bv64);
 
 procedure {:extern} rely_transitive();
   modifies Gamma_mem, mem;
@@ -92,28 +85,22 @@ procedure main();
   requires (Gamma_R0 == false);
   free requires (memory_load64_le(mem, 69632bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free requires (memory_load8_le(mem, 1972bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1973bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1974bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1975bv64) == 0bv8);
-  free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free requires (memory_load64_le(mem, 69616bv64) == 1876bv64);
-  free requires (memory_load64_le(mem, 69600bv64) == 69652bv64);
+  free requires (memory_load32_le(mem, 1972bv64) == 131073bv32);
+  free requires (memory_load64_le(mem, 69000bv64) == 1872bv64);
   free requires (memory_load64_le(mem, 69008bv64) == 1792bv64);
   free requires (memory_load64_le(mem, 69592bv64) == 69656bv64);
-  free requires (memory_load64_le(mem, 69000bv64) == 1872bv64);
+  free requires (memory_load64_le(mem, 69600bv64) == 69652bv64);
+  free requires (memory_load64_le(mem, 69616bv64) == 1876bv64);
+  free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
   free ensures (Gamma_R31 == old(Gamma_R31));
   free ensures (R31 == old(R31));
-  free ensures (memory_load8_le(mem, 1972bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1973bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1974bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1975bv64) == 0bv8);
-  free ensures (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free ensures (memory_load64_le(mem, 69616bv64) == 1876bv64);
-  free ensures (memory_load64_le(mem, 69600bv64) == 69652bv64);
+  free ensures (memory_load32_le(mem, 1972bv64) == 131073bv32);
+  free ensures (memory_load64_le(mem, 69000bv64) == 1872bv64);
   free ensures (memory_load64_le(mem, 69008bv64) == 1792bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 69656bv64);
-  free ensures (memory_load64_le(mem, 69000bv64) == 1872bv64);
+  free ensures (memory_load64_le(mem, 69600bv64) == 69652bv64);
+  free ensures (memory_load64_le(mem, 69616bv64) == 1876bv64);
+  free ensures (memory_load64_le(mem, 69640bv64) == 69640bv64);
 
 implementation main()
 {
@@ -131,8 +118,8 @@ implementation main()
     R1, Gamma_R1 := 1bv64, true;
     call rely();
     assert (L(mem, R0) ==> Gamma_R1);
-    z_old := memory_load32_le(mem, $z_addr);
     x_old := memory_load32_le(mem, $x_addr);
+    z_old := memory_load32_le(mem, $z_addr);
     Gamma_x_old := (gamma_load32(Gamma_mem, $x_addr) || L(mem, $x_addr));
     mem, Gamma_mem := memory_store32_le(mem, R0, R1[32:0]), gamma_store32(Gamma_mem, R0, Gamma_R1);
     assert ((R0 == $z_addr) ==> (L(mem, $x_addr) ==> Gamma_x_old));
@@ -144,8 +131,8 @@ implementation main()
     R1, Gamma_R1 := zero_extend32_32(memory_load32_le(stack, bvadd64(R31, 12bv64))), gamma_load32(Gamma_stack, bvadd64(R31, 12bv64));
     call rely();
     assert (L(mem, R0) ==> Gamma_R1);
-    z_old := memory_load32_le(mem, $z_addr);
     x_old := memory_load32_le(mem, $x_addr);
+    z_old := memory_load32_le(mem, $z_addr);
     Gamma_x_old := (gamma_load32(Gamma_mem, $x_addr) || L(mem, $x_addr));
     mem, Gamma_mem := memory_store32_le(mem, R0, R1[32:0]), gamma_store32(Gamma_mem, R0, Gamma_R1);
     assert ((R0 == $z_addr) ==> (L(mem, $x_addr) ==> Gamma_x_old));
@@ -156,8 +143,8 @@ implementation main()
     R0, Gamma_R0 := memory_load64_le(mem, bvadd64(R0, 4064bv64)), (gamma_load64(Gamma_mem, bvadd64(R0, 4064bv64)) || L(mem, bvadd64(R0, 4064bv64)));
     call rely();
     assert (L(mem, R0) ==> true);
-    z_old := memory_load32_le(mem, $z_addr);
     x_old := memory_load32_le(mem, $x_addr);
+    z_old := memory_load32_le(mem, $z_addr);
     Gamma_x_old := (gamma_load32(Gamma_mem, $x_addr) || L(mem, $x_addr));
     mem, Gamma_mem := memory_store32_le(mem, R0, 0bv32), gamma_store32(Gamma_mem, R0, true);
     assert ((R0 == $z_addr) ==> (L(mem, $x_addr) ==> Gamma_x_old));
@@ -168,8 +155,8 @@ implementation main()
     R0, Gamma_R0 := memory_load64_le(mem, bvadd64(R0, 4056bv64)), (gamma_load64(Gamma_mem, bvadd64(R0, 4056bv64)) || L(mem, bvadd64(R0, 4056bv64)));
     call rely();
     assert (L(mem, R0) ==> true);
-    z_old := memory_load32_le(mem, $z_addr);
     x_old := memory_load32_le(mem, $x_addr);
+    z_old := memory_load32_le(mem, $z_addr);
     Gamma_x_old := (gamma_load32(Gamma_mem, $x_addr) || L(mem, $x_addr));
     mem, Gamma_mem := memory_store32_le(mem, R0, 0bv32), gamma_store32(Gamma_mem, R0, true);
     assert ((R0 == $z_addr) ==> (L(mem, $x_addr) ==> Gamma_x_old));
diff --git a/src/test/correct/basic_lock_unlock/clang/basic_lock_unlock.expected b/src/test/correct/basic_lock_unlock/clang/basic_lock_unlock.expected
index de81ded1c..29577149e 100644
--- a/src/test/correct/basic_lock_unlock/clang/basic_lock_unlock.expected
+++ b/src/test/correct/basic_lock_unlock/clang/basic_lock_unlock.expected
@@ -10,7 +10,7 @@ const {:extern} $x_addr: bv64;
 axiom ($x_addr == 69684bv64);
 const {:extern} $z_addr: bv64;
 axiom ($z_addr == 69688bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
   (if (index == $x_addr) then true else (if (index == $z_addr) then true else false))
 }
 
@@ -27,10 +27,6 @@ function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv6
   (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
-}
-
 function {:extern} memory_store32_le(memory: [bv64]bv8, index: bv64, value: bv32) returns ([bv64]bv8) {
   memory[index := value[8:0]][bvadd64(index, 1bv64) := value[16:8]][bvadd64(index, 2bv64) := value[24:16]][bvadd64(index, 3bv64) := value[32:24]]
 }
@@ -39,10 +35,7 @@ procedure {:extern} rely();
   modifies Gamma_mem, mem;
   ensures (forall i: bv64 :: (((mem[i] == old(mem[i])) ==> (Gamma_mem[i] == old(Gamma_mem[i])))));
   ensures (memory_load32_le(mem, $z_addr) == old(memory_load32_le(mem, $z_addr)));
-  free ensures (memory_load8_le(mem, 1860bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1861bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1862bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1863bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1860bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1812bv64);
@@ -78,18 +71,12 @@ procedure main();
   requires (memory_load32_le(mem, $z_addr) == 1bv32);
   free requires (memory_load64_le(mem, 69664bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
-  free requires (memory_load8_le(mem, 1860bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1861bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1862bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1863bv64) == 0bv8);
+  free requires (memory_load32_le(mem, 1860bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free requires (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free requires (memory_load64_le(mem, 69592bv64) == 1812bv64);
   free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
-  free ensures (memory_load8_le(mem, 1860bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1861bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1862bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1863bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1860bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1812bv64);
@@ -105,8 +92,8 @@ implementation main()
     R8, Gamma_R8 := 1bv64, true;
     call rely();
     assert (L(mem, bvadd64(R9, 52bv64)) ==> Gamma_R8);
-    z_old := memory_load32_le(mem, $z_addr);
     x_old := memory_load32_le(mem, $x_addr);
+    z_old := memory_load32_le(mem, $z_addr);
     mem, Gamma_mem := memory_store32_le(mem, bvadd64(R9, 52bv64), R8[32:0]), gamma_store32(Gamma_mem, bvadd64(R9, 52bv64), Gamma_R8);
     assert ((z_old == 0bv32) ==> ((memory_load32_le(mem, $x_addr) == x_old) && (memory_load32_le(mem, $z_addr) == z_old)));
     assume {:captureState "%000002d6"} true;
@@ -114,8 +101,8 @@ implementation main()
     R0, Gamma_R0 := 0bv64, true;
     call rely();
     assert (L(mem, bvadd64(R8, 56bv64)) ==> true);
-    z_old := memory_load32_le(mem, $z_addr);
     x_old := memory_load32_le(mem, $x_addr);
+    z_old := memory_load32_le(mem, $z_addr);
     mem, Gamma_mem := memory_store32_le(mem, bvadd64(R8, 56bv64), 0bv32), gamma_store32(Gamma_mem, bvadd64(R8, 56bv64), true);
     assert ((z_old == 0bv32) ==> ((memory_load32_le(mem, $x_addr) == x_old) && (memory_load32_le(mem, $z_addr) == z_old)));
     assume {:captureState "%000002e7"} true;
diff --git a/src/test/correct/basic_lock_unlock/clang/basic_lock_unlock_gtirb.expected b/src/test/correct/basic_lock_unlock/clang/basic_lock_unlock_gtirb.expected
index 06d4ae629..bf9abb037 100644
--- a/src/test/correct/basic_lock_unlock/clang/basic_lock_unlock_gtirb.expected
+++ b/src/test/correct/basic_lock_unlock/clang/basic_lock_unlock_gtirb.expected
@@ -10,7 +10,7 @@ const {:extern} $x_addr: bv64;
 axiom ($x_addr == 69684bv64);
 const {:extern} $z_addr: bv64;
 axiom ($z_addr == 69688bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
   (if (index == $x_addr) then true else (if (index == $z_addr) then true else false))
 }
 
@@ -27,10 +27,6 @@ function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv6
   (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
-}
-
 function {:extern} memory_store32_le(memory: [bv64]bv8, index: bv64, value: bv32) returns ([bv64]bv8) {
   memory[index := value[8:0]][bvadd64(index, 1bv64) := value[16:8]][bvadd64(index, 2bv64) := value[24:16]][bvadd64(index, 3bv64) := value[32:24]]
 }
@@ -39,10 +35,7 @@ procedure {:extern} rely();
   modifies Gamma_mem, mem;
   ensures (forall i: bv64 :: (((mem[i] == old(mem[i])) ==> (Gamma_mem[i] == old(Gamma_mem[i])))));
   ensures (memory_load32_le(mem, $z_addr) == old(memory_load32_le(mem, $z_addr)));
-  free ensures (memory_load8_le(mem, 1860bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1861bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1862bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1863bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1860bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1812bv64);
@@ -78,18 +71,12 @@ procedure main();
   requires (memory_load32_le(mem, $z_addr) == 1bv32);
   free requires (memory_load64_le(mem, 69664bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
-  free requires (memory_load8_le(mem, 1860bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1861bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1862bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1863bv64) == 0bv8);
+  free requires (memory_load32_le(mem, 1860bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free requires (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free requires (memory_load64_le(mem, 69592bv64) == 1812bv64);
   free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
-  free ensures (memory_load8_le(mem, 1860bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1861bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1862bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1863bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1860bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1812bv64);
@@ -105,8 +92,8 @@ implementation main()
     R8, Gamma_R8 := 1bv64, true;
     call rely();
     assert (L(mem, bvadd64(R9, 52bv64)) ==> Gamma_R8);
-    z_old := memory_load32_le(mem, $z_addr);
     x_old := memory_load32_le(mem, $x_addr);
+    z_old := memory_load32_le(mem, $z_addr);
     mem, Gamma_mem := memory_store32_le(mem, bvadd64(R9, 52bv64), R8[32:0]), gamma_store32(Gamma_mem, bvadd64(R9, 52bv64), Gamma_R8);
     assert ((z_old == 0bv32) ==> ((memory_load32_le(mem, $x_addr) == x_old) && (memory_load32_le(mem, $z_addr) == z_old)));
     assume {:captureState "1820$0"} true;
@@ -114,8 +101,8 @@ implementation main()
     R0, Gamma_R0 := 0bv64, true;
     call rely();
     assert (L(mem, bvadd64(R8, 56bv64)) ==> true);
-    z_old := memory_load32_le(mem, $z_addr);
     x_old := memory_load32_le(mem, $x_addr);
+    z_old := memory_load32_le(mem, $z_addr);
     mem, Gamma_mem := memory_store32_le(mem, bvadd64(R8, 56bv64), 0bv32), gamma_store32(Gamma_mem, bvadd64(R8, 56bv64), true);
     assert ((z_old == 0bv32) ==> ((memory_load32_le(mem, $x_addr) == x_old) && (memory_load32_le(mem, $z_addr) == z_old)));
     assume {:captureState "1832$0"} true;
diff --git a/src/test/correct/basic_lock_unlock/clang_pic/basic_lock_unlock.expected b/src/test/correct/basic_lock_unlock/clang_pic/basic_lock_unlock.expected
index 652cd6a09..2cee414a8 100644
--- a/src/test/correct/basic_lock_unlock/clang_pic/basic_lock_unlock.expected
+++ b/src/test/correct/basic_lock_unlock/clang_pic/basic_lock_unlock.expected
@@ -10,7 +10,7 @@ const {:extern} $x_addr: bv64;
 axiom ($x_addr == 69684bv64);
 const {:extern} $z_addr: bv64;
 axiom ($z_addr == 69688bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
   (if (index == $x_addr) then true else (if (index == $z_addr) then true else false))
 }
 
@@ -31,10 +31,6 @@ function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv6
   (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
-}
-
 function {:extern} memory_store32_le(memory: [bv64]bv8, index: bv64, value: bv32) returns ([bv64]bv8) {
   memory[index := value[8:0]][bvadd64(index, 1bv64) := value[16:8]][bvadd64(index, 2bv64) := value[24:16]][bvadd64(index, 3bv64) := value[32:24]]
 }
@@ -43,16 +39,13 @@ procedure {:extern} rely();
   modifies Gamma_mem, mem;
   ensures (forall i: bv64 :: (((mem[i] == old(mem[i])) ==> (Gamma_mem[i] == old(Gamma_mem[i])))));
   ensures (memory_load32_le(mem, $z_addr) == old(memory_load32_le(mem, $z_addr)));
-  free ensures (memory_load8_le(mem, 1932bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1933bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1934bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1935bv64) == 0bv8);
-  free ensures (memory_load64_le(mem, 69576bv64) == 69684bv64);
-  free ensures (memory_load64_le(mem, 69672bv64) == 69672bv64);
+  free ensures (memory_load32_le(mem, 1932bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69048bv64) == 1872bv64);
+  free ensures (memory_load64_le(mem, 69056bv64) == 1792bv64);
   free ensures (memory_load64_le(mem, 69568bv64) == 69688bv64);
+  free ensures (memory_load64_le(mem, 69576bv64) == 69684bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1876bv64);
-  free ensures (memory_load64_le(mem, 69056bv64) == 1792bv64);
+  free ensures (memory_load64_le(mem, 69672bv64) == 69672bv64);
 
 procedure {:extern} rely_transitive();
   modifies Gamma_mem, mem;
@@ -84,26 +77,20 @@ procedure main();
   requires (memory_load32_le(mem, $z_addr) == 1bv32);
   free requires (memory_load64_le(mem, 69664bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
-  free requires (memory_load8_le(mem, 1932bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1933bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1934bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1935bv64) == 0bv8);
-  free requires (memory_load64_le(mem, 69576bv64) == 69684bv64);
-  free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
+  free requires (memory_load32_le(mem, 1932bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69048bv64) == 1872bv64);
+  free requires (memory_load64_le(mem, 69056bv64) == 1792bv64);
   free requires (memory_load64_le(mem, 69568bv64) == 69688bv64);
+  free requires (memory_load64_le(mem, 69576bv64) == 69684bv64);
   free requires (memory_load64_le(mem, 69592bv64) == 1876bv64);
-  free requires (memory_load64_le(mem, 69056bv64) == 1792bv64);
-  free ensures (memory_load8_le(mem, 1932bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1933bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1934bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1935bv64) == 0bv8);
-  free ensures (memory_load64_le(mem, 69576bv64) == 69684bv64);
-  free ensures (memory_load64_le(mem, 69672bv64) == 69672bv64);
+  free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
+  free ensures (memory_load32_le(mem, 1932bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69048bv64) == 1872bv64);
+  free ensures (memory_load64_le(mem, 69056bv64) == 1792bv64);
   free ensures (memory_load64_le(mem, 69568bv64) == 69688bv64);
+  free ensures (memory_load64_le(mem, 69576bv64) == 69684bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1876bv64);
-  free ensures (memory_load64_le(mem, 69056bv64) == 1792bv64);
+  free ensures (memory_load64_le(mem, 69672bv64) == 69672bv64);
 
 implementation main()
 {
@@ -117,8 +104,8 @@ implementation main()
     R8, Gamma_R8 := 1bv64, true;
     call rely();
     assert (L(mem, R9) ==> Gamma_R8);
-    z_old := memory_load32_le(mem, $z_addr);
     x_old := memory_load32_le(mem, $x_addr);
+    z_old := memory_load32_le(mem, $z_addr);
     mem, Gamma_mem := memory_store32_le(mem, R9, R8[32:0]), gamma_store32(Gamma_mem, R9, Gamma_R8);
     assert ((z_old == 0bv32) ==> ((memory_load32_le(mem, $x_addr) == x_old) && (memory_load32_le(mem, $z_addr) == z_old)));
     assume {:captureState "%000002e5"} true;
@@ -128,8 +115,8 @@ implementation main()
     R0, Gamma_R0 := 0bv64, true;
     call rely();
     assert (L(mem, R8) ==> true);
-    z_old := memory_load32_le(mem, $z_addr);
     x_old := memory_load32_le(mem, $x_addr);
+    z_old := memory_load32_le(mem, $z_addr);
     mem, Gamma_mem := memory_store32_le(mem, R8, 0bv32), gamma_store32(Gamma_mem, R8, true);
     assert ((z_old == 0bv32) ==> ((memory_load32_le(mem, $x_addr) == x_old) && (memory_load32_le(mem, $z_addr) == z_old)));
     assume {:captureState "%000002fd"} true;
diff --git a/src/test/correct/basic_lock_unlock/clang_pic/basic_lock_unlock_gtirb.expected b/src/test/correct/basic_lock_unlock/clang_pic/basic_lock_unlock_gtirb.expected
index 923456543..d4173aa27 100644
--- a/src/test/correct/basic_lock_unlock/clang_pic/basic_lock_unlock_gtirb.expected
+++ b/src/test/correct/basic_lock_unlock/clang_pic/basic_lock_unlock_gtirb.expected
@@ -10,7 +10,7 @@ const {:extern} $x_addr: bv64;
 axiom ($x_addr == 69684bv64);
 const {:extern} $z_addr: bv64;
 axiom ($z_addr == 69688bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
   (if (index == $x_addr) then true else (if (index == $z_addr) then true else false))
 }
 
@@ -31,10 +31,6 @@ function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv6
   (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
-}
-
 function {:extern} memory_store32_le(memory: [bv64]bv8, index: bv64, value: bv32) returns ([bv64]bv8) {
   memory[index := value[8:0]][bvadd64(index, 1bv64) := value[16:8]][bvadd64(index, 2bv64) := value[24:16]][bvadd64(index, 3bv64) := value[32:24]]
 }
@@ -43,16 +39,13 @@ procedure {:extern} rely();
   modifies Gamma_mem, mem;
   ensures (forall i: bv64 :: (((mem[i] == old(mem[i])) ==> (Gamma_mem[i] == old(Gamma_mem[i])))));
   ensures (memory_load32_le(mem, $z_addr) == old(memory_load32_le(mem, $z_addr)));
-  free ensures (memory_load8_le(mem, 1932bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1933bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1934bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1935bv64) == 0bv8);
-  free ensures (memory_load64_le(mem, 69576bv64) == 69684bv64);
-  free ensures (memory_load64_le(mem, 69672bv64) == 69672bv64);
+  free ensures (memory_load32_le(mem, 1932bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69048bv64) == 1872bv64);
+  free ensures (memory_load64_le(mem, 69056bv64) == 1792bv64);
   free ensures (memory_load64_le(mem, 69568bv64) == 69688bv64);
+  free ensures (memory_load64_le(mem, 69576bv64) == 69684bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1876bv64);
-  free ensures (memory_load64_le(mem, 69056bv64) == 1792bv64);
+  free ensures (memory_load64_le(mem, 69672bv64) == 69672bv64);
 
 procedure {:extern} rely_transitive();
   modifies Gamma_mem, mem;
@@ -84,26 +77,20 @@ procedure main();
   requires (memory_load32_le(mem, $z_addr) == 1bv32);
   free requires (memory_load64_le(mem, 69664bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
-  free requires (memory_load8_le(mem, 1932bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1933bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1934bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1935bv64) == 0bv8);
-  free requires (memory_load64_le(mem, 69576bv64) == 69684bv64);
-  free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
+  free requires (memory_load32_le(mem, 1932bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69048bv64) == 1872bv64);
+  free requires (memory_load64_le(mem, 69056bv64) == 1792bv64);
   free requires (memory_load64_le(mem, 69568bv64) == 69688bv64);
+  free requires (memory_load64_le(mem, 69576bv64) == 69684bv64);
   free requires (memory_load64_le(mem, 69592bv64) == 1876bv64);
-  free requires (memory_load64_le(mem, 69056bv64) == 1792bv64);
-  free ensures (memory_load8_le(mem, 1932bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1933bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1934bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1935bv64) == 0bv8);
-  free ensures (memory_load64_le(mem, 69576bv64) == 69684bv64);
-  free ensures (memory_load64_le(mem, 69672bv64) == 69672bv64);
+  free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
+  free ensures (memory_load32_le(mem, 1932bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69048bv64) == 1872bv64);
+  free ensures (memory_load64_le(mem, 69056bv64) == 1792bv64);
   free ensures (memory_load64_le(mem, 69568bv64) == 69688bv64);
+  free ensures (memory_load64_le(mem, 69576bv64) == 69684bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1876bv64);
-  free ensures (memory_load64_le(mem, 69056bv64) == 1792bv64);
+  free ensures (memory_load64_le(mem, 69672bv64) == 69672bv64);
 
 implementation main()
 {
@@ -117,8 +104,8 @@ implementation main()
     R8, Gamma_R8 := 1bv64, true;
     call rely();
     assert (L(mem, R9) ==> Gamma_R8);
-    z_old := memory_load32_le(mem, $z_addr);
     x_old := memory_load32_le(mem, $x_addr);
+    z_old := memory_load32_le(mem, $z_addr);
     mem, Gamma_mem := memory_store32_le(mem, R9, R8[32:0]), gamma_store32(Gamma_mem, R9, Gamma_R8);
     assert ((z_old == 0bv32) ==> ((memory_load32_le(mem, $x_addr) == x_old) && (memory_load32_le(mem, $z_addr) == z_old)));
     assume {:captureState "1888$0"} true;
@@ -128,8 +115,8 @@ implementation main()
     R0, Gamma_R0 := 0bv64, true;
     call rely();
     assert (L(mem, R8) ==> true);
-    z_old := memory_load32_le(mem, $z_addr);
     x_old := memory_load32_le(mem, $x_addr);
+    z_old := memory_load32_le(mem, $z_addr);
     mem, Gamma_mem := memory_store32_le(mem, R8, 0bv32), gamma_store32(Gamma_mem, R8, true);
     assert ((z_old == 0bv32) ==> ((memory_load32_le(mem, $x_addr) == x_old) && (memory_load32_le(mem, $z_addr) == z_old)));
     assume {:captureState "1904$0"} true;
diff --git a/src/test/correct/basic_lock_unlock/gcc/basic_lock_unlock.expected b/src/test/correct/basic_lock_unlock/gcc/basic_lock_unlock.expected
index a65434ffb..3b4d7df9b 100644
--- a/src/test/correct/basic_lock_unlock/gcc/basic_lock_unlock.expected
+++ b/src/test/correct/basic_lock_unlock/gcc/basic_lock_unlock.expected
@@ -8,7 +8,7 @@ const {:extern} $x_addr: bv64;
 axiom ($x_addr == 69652bv64);
 const {:extern} $z_addr: bv64;
 axiom ($z_addr == 69656bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
   (if (index == $x_addr) then true else (if (index == $z_addr) then true else false))
 }
 
@@ -25,10 +25,6 @@ function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv6
   (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
-}
-
 function {:extern} memory_store32_le(memory: [bv64]bv8, index: bv64, value: bv32) returns ([bv64]bv8) {
   memory[index := value[8:0]][bvadd64(index, 1bv64) := value[16:8]][bvadd64(index, 2bv64) := value[24:16]][bvadd64(index, 3bv64) := value[32:24]]
 }
@@ -37,10 +33,7 @@ procedure {:extern} rely();
   modifies Gamma_mem, mem;
   ensures (forall i: bv64 :: (((mem[i] == old(mem[i])) ==> (Gamma_mem[i] == old(Gamma_mem[i])))));
   ensures (memory_load32_le(mem, $z_addr) == old(memory_load32_le(mem, $z_addr)));
-  free ensures (memory_load8_le(mem, 1868bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1869bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1870bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1871bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1868bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69016bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69024bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69616bv64) == 1812bv64);
@@ -76,18 +69,12 @@ procedure main();
   requires (memory_load32_le(mem, $z_addr) == 1bv32);
   free requires (memory_load64_le(mem, 69632bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free requires (memory_load8_le(mem, 1868bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1869bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1870bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1871bv64) == 0bv8);
+  free requires (memory_load32_le(mem, 1868bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69016bv64) == 1808bv64);
   free requires (memory_load64_le(mem, 69024bv64) == 1728bv64);
   free requires (memory_load64_le(mem, 69616bv64) == 1812bv64);
   free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free ensures (memory_load8_le(mem, 1868bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1869bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1870bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1871bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1868bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69016bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69024bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69616bv64) == 1812bv64);
@@ -104,8 +91,8 @@ implementation main()
     R1, Gamma_R1 := 1bv64, true;
     call rely();
     assert (L(mem, R0) ==> Gamma_R1);
-    z_old := memory_load32_le(mem, $z_addr);
     x_old := memory_load32_le(mem, $x_addr);
+    z_old := memory_load32_le(mem, $z_addr);
     mem, Gamma_mem := memory_store32_le(mem, R0, R1[32:0]), gamma_store32(Gamma_mem, R0, Gamma_R1);
     assert ((z_old == 0bv32) ==> ((memory_load32_le(mem, $x_addr) == x_old) && (memory_load32_le(mem, $z_addr) == z_old)));
     assume {:captureState "%000002e4"} true;
@@ -113,8 +100,8 @@ implementation main()
     R0, Gamma_R0 := bvadd64(R0, 24bv64), Gamma_R0;
     call rely();
     assert (L(mem, R0) ==> true);
-    z_old := memory_load32_le(mem, $z_addr);
     x_old := memory_load32_le(mem, $x_addr);
+    z_old := memory_load32_le(mem, $z_addr);
     mem, Gamma_mem := memory_store32_le(mem, R0, 0bv32), gamma_store32(Gamma_mem, R0, true);
     assert ((z_old == 0bv32) ==> ((memory_load32_le(mem, $x_addr) == x_old) && (memory_load32_le(mem, $z_addr) == z_old)));
     assume {:captureState "%000002f6"} true;
diff --git a/src/test/correct/basic_lock_unlock/gcc/basic_lock_unlock_gtirb.expected b/src/test/correct/basic_lock_unlock/gcc/basic_lock_unlock_gtirb.expected
index dd838e366..0e359f034 100644
--- a/src/test/correct/basic_lock_unlock/gcc/basic_lock_unlock_gtirb.expected
+++ b/src/test/correct/basic_lock_unlock/gcc/basic_lock_unlock_gtirb.expected
@@ -8,7 +8,7 @@ const {:extern} $x_addr: bv64;
 axiom ($x_addr == 69652bv64);
 const {:extern} $z_addr: bv64;
 axiom ($z_addr == 69656bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
   (if (index == $x_addr) then true else (if (index == $z_addr) then true else false))
 }
 
@@ -25,10 +25,6 @@ function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv6
   (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
-}
-
 function {:extern} memory_store32_le(memory: [bv64]bv8, index: bv64, value: bv32) returns ([bv64]bv8) {
   memory[index := value[8:0]][bvadd64(index, 1bv64) := value[16:8]][bvadd64(index, 2bv64) := value[24:16]][bvadd64(index, 3bv64) := value[32:24]]
 }
@@ -37,10 +33,7 @@ procedure {:extern} rely();
   modifies Gamma_mem, mem;
   ensures (forall i: bv64 :: (((mem[i] == old(mem[i])) ==> (Gamma_mem[i] == old(Gamma_mem[i])))));
   ensures (memory_load32_le(mem, $z_addr) == old(memory_load32_le(mem, $z_addr)));
-  free ensures (memory_load8_le(mem, 1868bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1869bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1870bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1871bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1868bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69016bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69024bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69616bv64) == 1812bv64);
@@ -76,18 +69,12 @@ procedure main();
   requires (memory_load32_le(mem, $z_addr) == 1bv32);
   free requires (memory_load64_le(mem, 69632bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free requires (memory_load8_le(mem, 1868bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1869bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1870bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1871bv64) == 0bv8);
+  free requires (memory_load32_le(mem, 1868bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69016bv64) == 1808bv64);
   free requires (memory_load64_le(mem, 69024bv64) == 1728bv64);
   free requires (memory_load64_le(mem, 69616bv64) == 1812bv64);
   free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free ensures (memory_load8_le(mem, 1868bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1869bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1870bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1871bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1868bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69016bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69024bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69616bv64) == 1812bv64);
@@ -104,8 +91,8 @@ implementation main()
     R1, Gamma_R1 := 1bv64, true;
     call rely();
     assert (L(mem, R0) ==> Gamma_R1);
-    z_old := memory_load32_le(mem, $z_addr);
     x_old := memory_load32_le(mem, $x_addr);
+    z_old := memory_load32_le(mem, $z_addr);
     mem, Gamma_mem := memory_store32_le(mem, R0, R1[32:0]), gamma_store32(Gamma_mem, R0, Gamma_R1);
     assert ((z_old == 0bv32) ==> ((memory_load32_le(mem, $x_addr) == x_old) && (memory_load32_le(mem, $z_addr) == z_old)));
     assume {:captureState "1824$0"} true;
@@ -113,8 +100,8 @@ implementation main()
     R0, Gamma_R0 := bvadd64(R0, 24bv64), Gamma_R0;
     call rely();
     assert (L(mem, R0) ==> true);
-    z_old := memory_load32_le(mem, $z_addr);
     x_old := memory_load32_le(mem, $x_addr);
+    z_old := memory_load32_le(mem, $z_addr);
     mem, Gamma_mem := memory_store32_le(mem, R0, 0bv32), gamma_store32(Gamma_mem, R0, true);
     assert ((z_old == 0bv32) ==> ((memory_load32_le(mem, $x_addr) == x_old) && (memory_load32_le(mem, $z_addr) == z_old)));
     assume {:captureState "1836$0"} true;
diff --git a/src/test/correct/basic_lock_unlock/gcc_O2/basic_lock_unlock.expected b/src/test/correct/basic_lock_unlock/gcc_O2/basic_lock_unlock.expected
index e05f293a4..eec3701a1 100644
--- a/src/test/correct/basic_lock_unlock/gcc_O2/basic_lock_unlock.expected
+++ b/src/test/correct/basic_lock_unlock/gcc_O2/basic_lock_unlock.expected
@@ -12,7 +12,7 @@ const {:extern} $x_addr: bv64;
 axiom ($x_addr == 69652bv64);
 const {:extern} $z_addr: bv64;
 axiom ($z_addr == 69656bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
   (if (index == $x_addr) then true else (if (index == $z_addr) then true else false))
 }
 
@@ -29,10 +29,6 @@ function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv6
   (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
-}
-
 function {:extern} memory_store32_le(memory: [bv64]bv8, index: bv64, value: bv32) returns ([bv64]bv8) {
   memory[index := value[8:0]][bvadd64(index, 1bv64) := value[16:8]][bvadd64(index, 2bv64) := value[24:16]][bvadd64(index, 3bv64) := value[32:24]]
 }
@@ -41,10 +37,7 @@ procedure {:extern} rely();
   modifies Gamma_mem, mem;
   ensures (forall i: bv64 :: (((mem[i] == old(mem[i])) ==> (Gamma_mem[i] == old(Gamma_mem[i])))));
   ensures (memory_load32_le(mem, $z_addr) == old(memory_load32_le(mem, $z_addr)));
-  free ensures (memory_load8_le(mem, 1896bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1897bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1898bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1899bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1896bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69016bv64) == 1872bv64);
   free ensures (memory_load64_le(mem, 69024bv64) == 1792bv64);
   free ensures (memory_load64_le(mem, 69616bv64) == 1536bv64);
@@ -80,18 +73,12 @@ procedure main();
   requires (memory_load32_le(mem, $z_addr) == 1bv32);
   free requires (memory_load64_le(mem, 69632bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free requires (memory_load8_le(mem, 1896bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1897bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1898bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1899bv64) == 0bv8);
+  free requires (memory_load32_le(mem, 1896bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69016bv64) == 1872bv64);
   free requires (memory_load64_le(mem, 69024bv64) == 1792bv64);
   free requires (memory_load64_le(mem, 69616bv64) == 1536bv64);
   free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free ensures (memory_load8_le(mem, 1896bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1897bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1898bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1899bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1896bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69016bv64) == 1872bv64);
   free ensures (memory_load64_le(mem, 69024bv64) == 1792bv64);
   free ensures (memory_load64_le(mem, 69616bv64) == 1536bv64);
@@ -109,15 +96,15 @@ implementation main()
     R0, Gamma_R0 := 0bv64, true;
     call rely();
     assert (L(mem, bvadd64(R1, 20bv64)) ==> Gamma_R3);
-    z_old := memory_load32_le(mem, $z_addr);
     x_old := memory_load32_le(mem, $x_addr);
+    z_old := memory_load32_le(mem, $z_addr);
     mem, Gamma_mem := memory_store32_le(mem, bvadd64(R1, 20bv64), R3[32:0]), gamma_store32(Gamma_mem, bvadd64(R1, 20bv64), Gamma_R3);
     assert ((z_old == 0bv32) ==> ((memory_load32_le(mem, $x_addr) == x_old) && (memory_load32_le(mem, $z_addr) == z_old)));
     assume {:captureState "%000001c3"} true;
     call rely();
     assert (L(mem, bvadd64(R2, 4bv64)) ==> true);
-    z_old := memory_load32_le(mem, $z_addr);
     x_old := memory_load32_le(mem, $x_addr);
+    z_old := memory_load32_le(mem, $z_addr);
     mem, Gamma_mem := memory_store32_le(mem, bvadd64(R2, 4bv64), 0bv32), gamma_store32(Gamma_mem, bvadd64(R2, 4bv64), true);
     assert ((z_old == 0bv32) ==> ((memory_load32_le(mem, $x_addr) == x_old) && (memory_load32_le(mem, $z_addr) == z_old)));
     assume {:captureState "%000001ca"} true;
diff --git a/src/test/correct/basic_lock_unlock/gcc_O2/basic_lock_unlock_gtirb.expected b/src/test/correct/basic_lock_unlock/gcc_O2/basic_lock_unlock_gtirb.expected
index 59bd7e039..00dbd52b5 100644
--- a/src/test/correct/basic_lock_unlock/gcc_O2/basic_lock_unlock_gtirb.expected
+++ b/src/test/correct/basic_lock_unlock/gcc_O2/basic_lock_unlock_gtirb.expected
@@ -12,7 +12,7 @@ const {:extern} $x_addr: bv64;
 axiom ($x_addr == 69652bv64);
 const {:extern} $z_addr: bv64;
 axiom ($z_addr == 69656bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
   (if (index == $x_addr) then true else (if (index == $z_addr) then true else false))
 }
 
@@ -29,10 +29,6 @@ function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv6
   (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
-}
-
 function {:extern} memory_store32_le(memory: [bv64]bv8, index: bv64, value: bv32) returns ([bv64]bv8) {
   memory[index := value[8:0]][bvadd64(index, 1bv64) := value[16:8]][bvadd64(index, 2bv64) := value[24:16]][bvadd64(index, 3bv64) := value[32:24]]
 }
@@ -41,10 +37,7 @@ procedure {:extern} rely();
   modifies Gamma_mem, mem;
   ensures (forall i: bv64 :: (((mem[i] == old(mem[i])) ==> (Gamma_mem[i] == old(Gamma_mem[i])))));
   ensures (memory_load32_le(mem, $z_addr) == old(memory_load32_le(mem, $z_addr)));
-  free ensures (memory_load8_le(mem, 1896bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1897bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1898bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1899bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1896bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69016bv64) == 1872bv64);
   free ensures (memory_load64_le(mem, 69024bv64) == 1792bv64);
   free ensures (memory_load64_le(mem, 69616bv64) == 1536bv64);
@@ -80,18 +73,12 @@ procedure main();
   requires (memory_load32_le(mem, $z_addr) == 1bv32);
   free requires (memory_load64_le(mem, 69632bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free requires (memory_load8_le(mem, 1896bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1897bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1898bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1899bv64) == 0bv8);
+  free requires (memory_load32_le(mem, 1896bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69016bv64) == 1872bv64);
   free requires (memory_load64_le(mem, 69024bv64) == 1792bv64);
   free requires (memory_load64_le(mem, 69616bv64) == 1536bv64);
   free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free ensures (memory_load8_le(mem, 1896bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1897bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1898bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1899bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1896bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69016bv64) == 1872bv64);
   free ensures (memory_load64_le(mem, 69024bv64) == 1792bv64);
   free ensures (memory_load64_le(mem, 69616bv64) == 1536bv64);
@@ -109,15 +96,15 @@ implementation main()
     R0, Gamma_R0 := 0bv64, true;
     call rely();
     assert (L(mem, bvadd64(R1, 20bv64)) ==> Gamma_R3);
-    z_old := memory_load32_le(mem, $z_addr);
     x_old := memory_load32_le(mem, $x_addr);
+    z_old := memory_load32_le(mem, $z_addr);
     mem, Gamma_mem := memory_store32_le(mem, bvadd64(R1, 20bv64), R3[32:0]), gamma_store32(Gamma_mem, bvadd64(R1, 20bv64), Gamma_R3);
     assert ((z_old == 0bv32) ==> ((memory_load32_le(mem, $x_addr) == x_old) && (memory_load32_le(mem, $z_addr) == z_old)));
     assume {:captureState "1552$0"} true;
     call rely();
     assert (L(mem, bvadd64(R2, 4bv64)) ==> true);
-    z_old := memory_load32_le(mem, $z_addr);
     x_old := memory_load32_le(mem, $x_addr);
+    z_old := memory_load32_le(mem, $z_addr);
     mem, Gamma_mem := memory_store32_le(mem, bvadd64(R2, 4bv64), 0bv32), gamma_store32(Gamma_mem, bvadd64(R2, 4bv64), true);
     assert ((z_old == 0bv32) ==> ((memory_load32_le(mem, $x_addr) == x_old) && (memory_load32_le(mem, $z_addr) == z_old)));
     assume {:captureState "1556$0"} true;
diff --git a/src/test/correct/basic_lock_unlock/gcc_pic/basic_lock_unlock.expected b/src/test/correct/basic_lock_unlock/gcc_pic/basic_lock_unlock.expected
index 25a9043d3..da9677480 100644
--- a/src/test/correct/basic_lock_unlock/gcc_pic/basic_lock_unlock.expected
+++ b/src/test/correct/basic_lock_unlock/gcc_pic/basic_lock_unlock.expected
@@ -8,7 +8,7 @@ const {:extern} $x_addr: bv64;
 axiom ($x_addr == 69652bv64);
 const {:extern} $z_addr: bv64;
 axiom ($z_addr == 69656bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
   (if (index == $x_addr) then true else (if (index == $z_addr) then true else false))
 }
 
@@ -29,10 +29,6 @@ function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv6
   (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
-}
-
 function {:extern} memory_store32_le(memory: [bv64]bv8, index: bv64, value: bv32) returns ([bv64]bv8) {
   memory[index := value[8:0]][bvadd64(index, 1bv64) := value[16:8]][bvadd64(index, 2bv64) := value[24:16]][bvadd64(index, 3bv64) := value[32:24]]
 }
@@ -41,16 +37,13 @@ procedure {:extern} rely();
   modifies Gamma_mem, mem;
   ensures (forall i: bv64 :: (((mem[i] == old(mem[i])) ==> (Gamma_mem[i] == old(Gamma_mem[i])))));
   ensures (memory_load32_le(mem, $z_addr) == old(memory_load32_le(mem, $z_addr)));
-  free ensures (memory_load8_le(mem, 1932bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1933bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1934bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1935bv64) == 0bv8);
-  free ensures (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free ensures (memory_load64_le(mem, 69616bv64) == 1876bv64);
-  free ensures (memory_load64_le(mem, 69600bv64) == 69652bv64);
+  free ensures (memory_load32_le(mem, 1932bv64) == 131073bv32);
+  free ensures (memory_load64_le(mem, 69000bv64) == 1872bv64);
   free ensures (memory_load64_le(mem, 69008bv64) == 1792bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 69656bv64);
-  free ensures (memory_load64_le(mem, 69000bv64) == 1872bv64);
+  free ensures (memory_load64_le(mem, 69600bv64) == 69652bv64);
+  free ensures (memory_load64_le(mem, 69616bv64) == 1876bv64);
+  free ensures (memory_load64_le(mem, 69640bv64) == 69640bv64);
 
 procedure {:extern} rely_transitive();
   modifies Gamma_mem, mem;
@@ -82,26 +75,20 @@ procedure main();
   requires (memory_load32_le(mem, $z_addr) == 1bv32);
   free requires (memory_load64_le(mem, 69632bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free requires (memory_load8_le(mem, 1932bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1933bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1934bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1935bv64) == 0bv8);
-  free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free requires (memory_load64_le(mem, 69616bv64) == 1876bv64);
-  free requires (memory_load64_le(mem, 69600bv64) == 69652bv64);
+  free requires (memory_load32_le(mem, 1932bv64) == 131073bv32);
+  free requires (memory_load64_le(mem, 69000bv64) == 1872bv64);
   free requires (memory_load64_le(mem, 69008bv64) == 1792bv64);
   free requires (memory_load64_le(mem, 69592bv64) == 69656bv64);
-  free requires (memory_load64_le(mem, 69000bv64) == 1872bv64);
-  free ensures (memory_load8_le(mem, 1932bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1933bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1934bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1935bv64) == 0bv8);
-  free ensures (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free ensures (memory_load64_le(mem, 69616bv64) == 1876bv64);
-  free ensures (memory_load64_le(mem, 69600bv64) == 69652bv64);
+  free requires (memory_load64_le(mem, 69600bv64) == 69652bv64);
+  free requires (memory_load64_le(mem, 69616bv64) == 1876bv64);
+  free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
+  free ensures (memory_load32_le(mem, 1932bv64) == 131073bv32);
+  free ensures (memory_load64_le(mem, 69000bv64) == 1872bv64);
   free ensures (memory_load64_le(mem, 69008bv64) == 1792bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 69656bv64);
-  free ensures (memory_load64_le(mem, 69000bv64) == 1872bv64);
+  free ensures (memory_load64_le(mem, 69600bv64) == 69652bv64);
+  free ensures (memory_load64_le(mem, 69616bv64) == 1876bv64);
+  free ensures (memory_load64_le(mem, 69640bv64) == 69640bv64);
 
 implementation main()
 {
@@ -115,8 +102,8 @@ implementation main()
     R1, Gamma_R1 := 1bv64, true;
     call rely();
     assert (L(mem, R0) ==> Gamma_R1);
-    z_old := memory_load32_le(mem, $z_addr);
     x_old := memory_load32_le(mem, $x_addr);
+    z_old := memory_load32_le(mem, $z_addr);
     mem, Gamma_mem := memory_store32_le(mem, R0, R1[32:0]), gamma_store32(Gamma_mem, R0, Gamma_R1);
     assert ((z_old == 0bv32) ==> ((memory_load32_le(mem, $x_addr) == x_old) && (memory_load32_le(mem, $z_addr) == z_old)));
     assume {:captureState "%000002e5"} true;
@@ -125,8 +112,8 @@ implementation main()
     R0, Gamma_R0 := memory_load64_le(mem, bvadd64(R0, 4056bv64)), (gamma_load64(Gamma_mem, bvadd64(R0, 4056bv64)) || L(mem, bvadd64(R0, 4056bv64)));
     call rely();
     assert (L(mem, R0) ==> true);
-    z_old := memory_load32_le(mem, $z_addr);
     x_old := memory_load32_le(mem, $x_addr);
+    z_old := memory_load32_le(mem, $z_addr);
     mem, Gamma_mem := memory_store32_le(mem, R0, 0bv32), gamma_store32(Gamma_mem, R0, true);
     assert ((z_old == 0bv32) ==> ((memory_load32_le(mem, $x_addr) == x_old) && (memory_load32_le(mem, $z_addr) == z_old)));
     assume {:captureState "%000002f8"} true;
diff --git a/src/test/correct/basic_lock_unlock/gcc_pic/basic_lock_unlock_gtirb.expected b/src/test/correct/basic_lock_unlock/gcc_pic/basic_lock_unlock_gtirb.expected
index 94a34679d..65c38fdf8 100644
--- a/src/test/correct/basic_lock_unlock/gcc_pic/basic_lock_unlock_gtirb.expected
+++ b/src/test/correct/basic_lock_unlock/gcc_pic/basic_lock_unlock_gtirb.expected
@@ -8,7 +8,7 @@ const {:extern} $x_addr: bv64;
 axiom ($x_addr == 69652bv64);
 const {:extern} $z_addr: bv64;
 axiom ($z_addr == 69656bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
   (if (index == $x_addr) then true else (if (index == $z_addr) then true else false))
 }
 
@@ -29,10 +29,6 @@ function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv6
   (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
-}
-
 function {:extern} memory_store32_le(memory: [bv64]bv8, index: bv64, value: bv32) returns ([bv64]bv8) {
   memory[index := value[8:0]][bvadd64(index, 1bv64) := value[16:8]][bvadd64(index, 2bv64) := value[24:16]][bvadd64(index, 3bv64) := value[32:24]]
 }
@@ -41,16 +37,13 @@ procedure {:extern} rely();
   modifies Gamma_mem, mem;
   ensures (forall i: bv64 :: (((mem[i] == old(mem[i])) ==> (Gamma_mem[i] == old(Gamma_mem[i])))));
   ensures (memory_load32_le(mem, $z_addr) == old(memory_load32_le(mem, $z_addr)));
-  free ensures (memory_load8_le(mem, 1932bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1933bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1934bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1935bv64) == 0bv8);
-  free ensures (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free ensures (memory_load64_le(mem, 69616bv64) == 1876bv64);
-  free ensures (memory_load64_le(mem, 69600bv64) == 69652bv64);
+  free ensures (memory_load32_le(mem, 1932bv64) == 131073bv32);
+  free ensures (memory_load64_le(mem, 69000bv64) == 1872bv64);
   free ensures (memory_load64_le(mem, 69008bv64) == 1792bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 69656bv64);
-  free ensures (memory_load64_le(mem, 69000bv64) == 1872bv64);
+  free ensures (memory_load64_le(mem, 69600bv64) == 69652bv64);
+  free ensures (memory_load64_le(mem, 69616bv64) == 1876bv64);
+  free ensures (memory_load64_le(mem, 69640bv64) == 69640bv64);
 
 procedure {:extern} rely_transitive();
   modifies Gamma_mem, mem;
@@ -82,26 +75,20 @@ procedure main();
   requires (memory_load32_le(mem, $z_addr) == 1bv32);
   free requires (memory_load64_le(mem, 69632bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free requires (memory_load8_le(mem, 1932bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1933bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1934bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1935bv64) == 0bv8);
-  free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free requires (memory_load64_le(mem, 69616bv64) == 1876bv64);
-  free requires (memory_load64_le(mem, 69600bv64) == 69652bv64);
+  free requires (memory_load32_le(mem, 1932bv64) == 131073bv32);
+  free requires (memory_load64_le(mem, 69000bv64) == 1872bv64);
   free requires (memory_load64_le(mem, 69008bv64) == 1792bv64);
   free requires (memory_load64_le(mem, 69592bv64) == 69656bv64);
-  free requires (memory_load64_le(mem, 69000bv64) == 1872bv64);
-  free ensures (memory_load8_le(mem, 1932bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1933bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1934bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1935bv64) == 0bv8);
-  free ensures (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free ensures (memory_load64_le(mem, 69616bv64) == 1876bv64);
-  free ensures (memory_load64_le(mem, 69600bv64) == 69652bv64);
+  free requires (memory_load64_le(mem, 69600bv64) == 69652bv64);
+  free requires (memory_load64_le(mem, 69616bv64) == 1876bv64);
+  free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
+  free ensures (memory_load32_le(mem, 1932bv64) == 131073bv32);
+  free ensures (memory_load64_le(mem, 69000bv64) == 1872bv64);
   free ensures (memory_load64_le(mem, 69008bv64) == 1792bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 69656bv64);
-  free ensures (memory_load64_le(mem, 69000bv64) == 1872bv64);
+  free ensures (memory_load64_le(mem, 69600bv64) == 69652bv64);
+  free ensures (memory_load64_le(mem, 69616bv64) == 1876bv64);
+  free ensures (memory_load64_le(mem, 69640bv64) == 69640bv64);
 
 implementation main()
 {
@@ -115,8 +102,8 @@ implementation main()
     R1, Gamma_R1 := 1bv64, true;
     call rely();
     assert (L(mem, R0) ==> Gamma_R1);
-    z_old := memory_load32_le(mem, $z_addr);
     x_old := memory_load32_le(mem, $x_addr);
+    z_old := memory_load32_le(mem, $z_addr);
     mem, Gamma_mem := memory_store32_le(mem, R0, R1[32:0]), gamma_store32(Gamma_mem, R0, Gamma_R1);
     assert ((z_old == 0bv32) ==> ((memory_load32_le(mem, $x_addr) == x_old) && (memory_load32_le(mem, $z_addr) == z_old)));
     assume {:captureState "1888$0"} true;
@@ -125,8 +112,8 @@ implementation main()
     R0, Gamma_R0 := memory_load64_le(mem, bvadd64(R0, 4056bv64)), (gamma_load64(Gamma_mem, bvadd64(R0, 4056bv64)) || L(mem, bvadd64(R0, 4056bv64)));
     call rely();
     assert (L(mem, R0) ==> true);
-    z_old := memory_load32_le(mem, $z_addr);
     x_old := memory_load32_le(mem, $x_addr);
+    z_old := memory_load32_le(mem, $z_addr);
     mem, Gamma_mem := memory_store32_le(mem, R0, 0bv32), gamma_store32(Gamma_mem, R0, true);
     assert ((z_old == 0bv32) ==> ((memory_load32_le(mem, $x_addr) == x_old) && (memory_load32_le(mem, $z_addr) == z_old)));
     assume {:captureState "1900$0"} true;
diff --git a/src/test/correct/basic_loop_assign/clang/basic_loop_assign.expected b/src/test/correct/basic_loop_assign/clang/basic_loop_assign.expected
index 619574ba1..ee929dc6b 100644
--- a/src/test/correct/basic_loop_assign/clang/basic_loop_assign.expected
+++ b/src/test/correct/basic_loop_assign/clang/basic_loop_assign.expected
@@ -8,7 +8,7 @@ var {:extern} R9: bv64;
 var {:extern} mem: [bv64]bv8;
 const {:extern} $x_addr: bv64;
 axiom ($x_addr == 69684bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
   (if (index == $x_addr) then true else false)
 }
 
@@ -27,10 +27,6 @@ function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv6
   (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
-}
-
 function {:extern} memory_store32_le(memory: [bv64]bv8, index: bv64, value: bv32) returns ([bv64]bv8) {
   memory[index := value[8:0]][bvadd64(index, 1bv64) := value[16:8]][bvadd64(index, 2bv64) := value[24:16]][bvadd64(index, 3bv64) := value[32:24]]
 }
@@ -39,10 +35,7 @@ procedure {:extern} rely();
   modifies Gamma_mem, mem;
   ensures (forall i: bv64 :: (((mem[i] == old(mem[i])) ==> (Gamma_mem[i] == old(Gamma_mem[i])))));
   ensures (((memory_load32_le(mem, $x_addr) == old(memory_load32_le(mem, $x_addr))) || (bvsle32(memory_load32_le(mem, $x_addr), 10bv32) && bvslt32(old(memory_load32_le(mem, $x_addr)), 10bv32))) || ((memory_load32_le(mem, $x_addr) == 21bv32) && (old(memory_load32_le(mem, $x_addr)) == 20bv32)));
-  free ensures (memory_load8_le(mem, 1852bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1853bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1854bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1855bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1852bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1812bv64);
@@ -78,19 +71,13 @@ procedure main();
   requires (memory_load32_le(mem, $x_addr) == 0bv32);
   free requires (memory_load64_le(mem, 69664bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
-  free requires (memory_load8_le(mem, 1852bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1853bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1854bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1855bv64) == 0bv8);
+  free requires (memory_load32_le(mem, 1852bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free requires (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free requires (memory_load64_le(mem, 69592bv64) == 1812bv64);
   free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
   ensures ((memory_load32_le(mem, $x_addr) == 20bv32) || (memory_load32_le(mem, $x_addr) == 21bv32));
-  free ensures (memory_load8_le(mem, 1852bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1853bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1854bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1855bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1852bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1812bv64);
diff --git a/src/test/correct/basic_loop_assign/clang/basic_loop_assign_gtirb.expected b/src/test/correct/basic_loop_assign/clang/basic_loop_assign_gtirb.expected
index 09495b51b..1360f86d7 100644
--- a/src/test/correct/basic_loop_assign/clang/basic_loop_assign_gtirb.expected
+++ b/src/test/correct/basic_loop_assign/clang/basic_loop_assign_gtirb.expected
@@ -8,7 +8,7 @@ var {:extern} R9: bv64;
 var {:extern} mem: [bv64]bv8;
 const {:extern} $x_addr: bv64;
 axiom ($x_addr == 69684bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
   (if (index == $x_addr) then true else false)
 }
 
@@ -27,10 +27,6 @@ function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv6
   (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
-}
-
 function {:extern} memory_store32_le(memory: [bv64]bv8, index: bv64, value: bv32) returns ([bv64]bv8) {
   memory[index := value[8:0]][bvadd64(index, 1bv64) := value[16:8]][bvadd64(index, 2bv64) := value[24:16]][bvadd64(index, 3bv64) := value[32:24]]
 }
@@ -39,10 +35,7 @@ procedure {:extern} rely();
   modifies Gamma_mem, mem;
   ensures (forall i: bv64 :: (((mem[i] == old(mem[i])) ==> (Gamma_mem[i] == old(Gamma_mem[i])))));
   ensures (((memory_load32_le(mem, $x_addr) == old(memory_load32_le(mem, $x_addr))) || (bvsle32(memory_load32_le(mem, $x_addr), 10bv32) && bvslt32(old(memory_load32_le(mem, $x_addr)), 10bv32))) || ((memory_load32_le(mem, $x_addr) == 21bv32) && (old(memory_load32_le(mem, $x_addr)) == 20bv32)));
-  free ensures (memory_load8_le(mem, 1852bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1853bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1854bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1855bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1852bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1812bv64);
@@ -78,19 +71,13 @@ procedure main();
   requires (memory_load32_le(mem, $x_addr) == 0bv32);
   free requires (memory_load64_le(mem, 69664bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
-  free requires (memory_load8_le(mem, 1852bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1853bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1854bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1855bv64) == 0bv8);
+  free requires (memory_load32_le(mem, 1852bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free requires (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free requires (memory_load64_le(mem, 69592bv64) == 1812bv64);
   free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
   ensures ((memory_load32_le(mem, $x_addr) == 20bv32) || (memory_load32_le(mem, $x_addr) == 21bv32));
-  free ensures (memory_load8_le(mem, 1852bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1853bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1854bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1855bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1852bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1812bv64);
diff --git a/src/test/correct/basic_loop_assign/clang_pic/basic_loop_assign.expected b/src/test/correct/basic_loop_assign/clang_pic/basic_loop_assign.expected
index 774f8bda5..83c27b684 100644
--- a/src/test/correct/basic_loop_assign/clang_pic/basic_loop_assign.expected
+++ b/src/test/correct/basic_loop_assign/clang_pic/basic_loop_assign.expected
@@ -8,7 +8,7 @@ var {:extern} R9: bv64;
 var {:extern} mem: [bv64]bv8;
 const {:extern} $x_addr: bv64;
 axiom ($x_addr == 69684bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
   (if (index == $x_addr) then true else false)
 }
 
@@ -31,10 +31,6 @@ function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv6
   (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
-}
-
 function {:extern} memory_store32_le(memory: [bv64]bv8, index: bv64, value: bv32) returns ([bv64]bv8) {
   memory[index := value[8:0]][bvadd64(index, 1bv64) := value[16:8]][bvadd64(index, 2bv64) := value[24:16]][bvadd64(index, 3bv64) := value[32:24]]
 }
@@ -43,15 +39,12 @@ procedure {:extern} rely();
   modifies Gamma_mem, mem;
   ensures (forall i: bv64 :: (((mem[i] == old(mem[i])) ==> (Gamma_mem[i] == old(Gamma_mem[i])))));
   ensures (((memory_load32_le(mem, $x_addr) == old(memory_load32_le(mem, $x_addr))) || (bvsle32(memory_load32_le(mem, $x_addr), 10bv32) && bvslt32(old(memory_load32_le(mem, $x_addr)), 10bv32))) || ((memory_load32_le(mem, $x_addr) == 21bv32) && (old(memory_load32_le(mem, $x_addr)) == 20bv32)));
-  free ensures (memory_load8_le(mem, 1920bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1921bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1922bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1923bv64) == 0bv8);
-  free ensures (memory_load64_le(mem, 69576bv64) == 69684bv64);
-  free ensures (memory_load64_le(mem, 69672bv64) == 69672bv64);
+  free ensures (memory_load32_le(mem, 1920bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69056bv64) == 1872bv64);
   free ensures (memory_load64_le(mem, 69064bv64) == 1792bv64);
+  free ensures (memory_load64_le(mem, 69576bv64) == 69684bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1876bv64);
+  free ensures (memory_load64_le(mem, 69672bv64) == 69672bv64);
 
 procedure {:extern} rely_transitive();
   modifies Gamma_mem, mem;
@@ -83,25 +76,19 @@ procedure main();
   requires (memory_load32_le(mem, $x_addr) == 0bv32);
   free requires (memory_load64_le(mem, 69664bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
-  free requires (memory_load8_le(mem, 1920bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1921bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1922bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1923bv64) == 0bv8);
-  free requires (memory_load64_le(mem, 69576bv64) == 69684bv64);
-  free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
+  free requires (memory_load32_le(mem, 1920bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69056bv64) == 1872bv64);
   free requires (memory_load64_le(mem, 69064bv64) == 1792bv64);
+  free requires (memory_load64_le(mem, 69576bv64) == 69684bv64);
   free requires (memory_load64_le(mem, 69592bv64) == 1876bv64);
+  free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
   ensures ((memory_load32_le(mem, $x_addr) == 20bv32) || (memory_load32_le(mem, $x_addr) == 21bv32));
-  free ensures (memory_load8_le(mem, 1920bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1921bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1922bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1923bv64) == 0bv8);
-  free ensures (memory_load64_le(mem, 69576bv64) == 69684bv64);
-  free ensures (memory_load64_le(mem, 69672bv64) == 69672bv64);
+  free ensures (memory_load32_le(mem, 1920bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69056bv64) == 1872bv64);
   free ensures (memory_load64_le(mem, 69064bv64) == 1792bv64);
+  free ensures (memory_load64_le(mem, 69576bv64) == 69684bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1876bv64);
+  free ensures (memory_load64_le(mem, 69672bv64) == 69672bv64);
 
 implementation main()
 {
diff --git a/src/test/correct/basic_loop_assign/clang_pic/basic_loop_assign_gtirb.expected b/src/test/correct/basic_loop_assign/clang_pic/basic_loop_assign_gtirb.expected
index bb96a23c0..f0747770f 100644
--- a/src/test/correct/basic_loop_assign/clang_pic/basic_loop_assign_gtirb.expected
+++ b/src/test/correct/basic_loop_assign/clang_pic/basic_loop_assign_gtirb.expected
@@ -8,7 +8,7 @@ var {:extern} R9: bv64;
 var {:extern} mem: [bv64]bv8;
 const {:extern} $x_addr: bv64;
 axiom ($x_addr == 69684bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
   (if (index == $x_addr) then true else false)
 }
 
@@ -31,10 +31,6 @@ function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv6
   (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
-}
-
 function {:extern} memory_store32_le(memory: [bv64]bv8, index: bv64, value: bv32) returns ([bv64]bv8) {
   memory[index := value[8:0]][bvadd64(index, 1bv64) := value[16:8]][bvadd64(index, 2bv64) := value[24:16]][bvadd64(index, 3bv64) := value[32:24]]
 }
@@ -43,15 +39,12 @@ procedure {:extern} rely();
   modifies Gamma_mem, mem;
   ensures (forall i: bv64 :: (((mem[i] == old(mem[i])) ==> (Gamma_mem[i] == old(Gamma_mem[i])))));
   ensures (((memory_load32_le(mem, $x_addr) == old(memory_load32_le(mem, $x_addr))) || (bvsle32(memory_load32_le(mem, $x_addr), 10bv32) && bvslt32(old(memory_load32_le(mem, $x_addr)), 10bv32))) || ((memory_load32_le(mem, $x_addr) == 21bv32) && (old(memory_load32_le(mem, $x_addr)) == 20bv32)));
-  free ensures (memory_load8_le(mem, 1920bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1921bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1922bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1923bv64) == 0bv8);
-  free ensures (memory_load64_le(mem, 69576bv64) == 69684bv64);
-  free ensures (memory_load64_le(mem, 69672bv64) == 69672bv64);
+  free ensures (memory_load32_le(mem, 1920bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69056bv64) == 1872bv64);
   free ensures (memory_load64_le(mem, 69064bv64) == 1792bv64);
+  free ensures (memory_load64_le(mem, 69576bv64) == 69684bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1876bv64);
+  free ensures (memory_load64_le(mem, 69672bv64) == 69672bv64);
 
 procedure {:extern} rely_transitive();
   modifies Gamma_mem, mem;
@@ -83,25 +76,19 @@ procedure main();
   requires (memory_load32_le(mem, $x_addr) == 0bv32);
   free requires (memory_load64_le(mem, 69664bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
-  free requires (memory_load8_le(mem, 1920bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1921bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1922bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1923bv64) == 0bv8);
-  free requires (memory_load64_le(mem, 69576bv64) == 69684bv64);
-  free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
+  free requires (memory_load32_le(mem, 1920bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69056bv64) == 1872bv64);
   free requires (memory_load64_le(mem, 69064bv64) == 1792bv64);
+  free requires (memory_load64_le(mem, 69576bv64) == 69684bv64);
   free requires (memory_load64_le(mem, 69592bv64) == 1876bv64);
+  free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
   ensures ((memory_load32_le(mem, $x_addr) == 20bv32) || (memory_load32_le(mem, $x_addr) == 21bv32));
-  free ensures (memory_load8_le(mem, 1920bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1921bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1922bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1923bv64) == 0bv8);
-  free ensures (memory_load64_le(mem, 69576bv64) == 69684bv64);
-  free ensures (memory_load64_le(mem, 69672bv64) == 69672bv64);
+  free ensures (memory_load32_le(mem, 1920bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69056bv64) == 1872bv64);
   free ensures (memory_load64_le(mem, 69064bv64) == 1792bv64);
+  free ensures (memory_load64_le(mem, 69576bv64) == 69684bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1876bv64);
+  free ensures (memory_load64_le(mem, 69672bv64) == 69672bv64);
 
 implementation main()
 {
diff --git a/src/test/correct/basic_loop_assign/gcc/basic_loop_assign.expected b/src/test/correct/basic_loop_assign/gcc/basic_loop_assign.expected
index 03d3a3556..e0062a835 100644
--- a/src/test/correct/basic_loop_assign/gcc/basic_loop_assign.expected
+++ b/src/test/correct/basic_loop_assign/gcc/basic_loop_assign.expected
@@ -6,7 +6,7 @@ var {:extern} R1: bv64;
 var {:extern} mem: [bv64]bv8;
 const {:extern} $x_addr: bv64;
 axiom ($x_addr == 69652bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
   (if (index == $x_addr) then true else false)
 }
 
@@ -25,10 +25,6 @@ function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv6
   (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
-}
-
 function {:extern} memory_store32_le(memory: [bv64]bv8, index: bv64, value: bv32) returns ([bv64]bv8) {
   memory[index := value[8:0]][bvadd64(index, 1bv64) := value[16:8]][bvadd64(index, 2bv64) := value[24:16]][bvadd64(index, 3bv64) := value[32:24]]
 }
@@ -37,10 +33,7 @@ procedure {:extern} rely();
   modifies Gamma_mem, mem;
   ensures (forall i: bv64 :: (((mem[i] == old(mem[i])) ==> (Gamma_mem[i] == old(Gamma_mem[i])))));
   ensures (((memory_load32_le(mem, $x_addr) == old(memory_load32_le(mem, $x_addr))) || (bvsle32(memory_load32_le(mem, $x_addr), 10bv32) && bvslt32(old(memory_load32_le(mem, $x_addr)), 10bv32))) || ((memory_load32_le(mem, $x_addr) == 21bv32) && (old(memory_load32_le(mem, $x_addr)) == 20bv32)));
-  free ensures (memory_load8_le(mem, 1856bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1857bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1858bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1859bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1856bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69016bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69024bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69616bv64) == 1812bv64);
@@ -76,19 +69,13 @@ procedure main();
   requires (memory_load32_le(mem, $x_addr) == 0bv32);
   free requires (memory_load64_le(mem, 69632bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free requires (memory_load8_le(mem, 1856bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1857bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1858bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1859bv64) == 0bv8);
+  free requires (memory_load32_le(mem, 1856bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69016bv64) == 1808bv64);
   free requires (memory_load64_le(mem, 69024bv64) == 1728bv64);
   free requires (memory_load64_le(mem, 69616bv64) == 1812bv64);
   free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
   ensures ((memory_load32_le(mem, $x_addr) == 20bv32) || (memory_load32_le(mem, $x_addr) == 21bv32));
-  free ensures (memory_load8_le(mem, 1856bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1857bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1858bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1859bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1856bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69016bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69024bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69616bv64) == 1812bv64);
diff --git a/src/test/correct/basic_loop_assign/gcc/basic_loop_assign_gtirb.expected b/src/test/correct/basic_loop_assign/gcc/basic_loop_assign_gtirb.expected
index f01e436af..0af511b16 100644
--- a/src/test/correct/basic_loop_assign/gcc/basic_loop_assign_gtirb.expected
+++ b/src/test/correct/basic_loop_assign/gcc/basic_loop_assign_gtirb.expected
@@ -6,7 +6,7 @@ var {:extern} R1: bv64;
 var {:extern} mem: [bv64]bv8;
 const {:extern} $x_addr: bv64;
 axiom ($x_addr == 69652bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
   (if (index == $x_addr) then true else false)
 }
 
@@ -25,10 +25,6 @@ function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv6
   (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
-}
-
 function {:extern} memory_store32_le(memory: [bv64]bv8, index: bv64, value: bv32) returns ([bv64]bv8) {
   memory[index := value[8:0]][bvadd64(index, 1bv64) := value[16:8]][bvadd64(index, 2bv64) := value[24:16]][bvadd64(index, 3bv64) := value[32:24]]
 }
@@ -37,10 +33,7 @@ procedure {:extern} rely();
   modifies Gamma_mem, mem;
   ensures (forall i: bv64 :: (((mem[i] == old(mem[i])) ==> (Gamma_mem[i] == old(Gamma_mem[i])))));
   ensures (((memory_load32_le(mem, $x_addr) == old(memory_load32_le(mem, $x_addr))) || (bvsle32(memory_load32_le(mem, $x_addr), 10bv32) && bvslt32(old(memory_load32_le(mem, $x_addr)), 10bv32))) || ((memory_load32_le(mem, $x_addr) == 21bv32) && (old(memory_load32_le(mem, $x_addr)) == 20bv32)));
-  free ensures (memory_load8_le(mem, 1856bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1857bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1858bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1859bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1856bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69016bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69024bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69616bv64) == 1812bv64);
@@ -76,19 +69,13 @@ procedure main();
   requires (memory_load32_le(mem, $x_addr) == 0bv32);
   free requires (memory_load64_le(mem, 69632bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free requires (memory_load8_le(mem, 1856bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1857bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1858bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1859bv64) == 0bv8);
+  free requires (memory_load32_le(mem, 1856bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69016bv64) == 1808bv64);
   free requires (memory_load64_le(mem, 69024bv64) == 1728bv64);
   free requires (memory_load64_le(mem, 69616bv64) == 1812bv64);
   free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
   ensures ((memory_load32_le(mem, $x_addr) == 20bv32) || (memory_load32_le(mem, $x_addr) == 21bv32));
-  free ensures (memory_load8_le(mem, 1856bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1857bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1858bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1859bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1856bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69016bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69024bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69616bv64) == 1812bv64);
diff --git a/src/test/correct/basic_loop_assign/gcc_O2/basic_loop_assign.expected b/src/test/correct/basic_loop_assign/gcc_O2/basic_loop_assign.expected
index 3b2cc89e6..ba3a372d4 100644
--- a/src/test/correct/basic_loop_assign/gcc_O2/basic_loop_assign.expected
+++ b/src/test/correct/basic_loop_assign/gcc_O2/basic_loop_assign.expected
@@ -8,7 +8,7 @@ var {:extern} R2: bv64;
 var {:extern} mem: [bv64]bv8;
 const {:extern} $x_addr: bv64;
 axiom ($x_addr == 69652bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
   (if (index == $x_addr) then true else false)
 }
 
@@ -27,10 +27,6 @@ function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv6
   (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
-}
-
 function {:extern} memory_store32_le(memory: [bv64]bv8, index: bv64, value: bv32) returns ([bv64]bv8) {
   memory[index := value[8:0]][bvadd64(index, 1bv64) := value[16:8]][bvadd64(index, 2bv64) := value[24:16]][bvadd64(index, 3bv64) := value[32:24]]
 }
@@ -39,10 +35,7 @@ procedure {:extern} rely();
   modifies Gamma_mem, mem;
   ensures (forall i: bv64 :: (((mem[i] == old(mem[i])) ==> (Gamma_mem[i] == old(Gamma_mem[i])))));
   ensures (((memory_load32_le(mem, $x_addr) == old(memory_load32_le(mem, $x_addr))) || (bvsle32(memory_load32_le(mem, $x_addr), 10bv32) && bvslt32(old(memory_load32_le(mem, $x_addr)), 10bv32))) || ((memory_load32_le(mem, $x_addr) == 21bv32) && (old(memory_load32_le(mem, $x_addr)) == 20bv32)));
-  free ensures (memory_load8_le(mem, 1896bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1897bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1898bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1899bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1896bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69016bv64) == 1872bv64);
   free ensures (memory_load64_le(mem, 69024bv64) == 1792bv64);
   free ensures (memory_load64_le(mem, 69616bv64) == 1536bv64);
@@ -78,19 +71,13 @@ procedure main();
   requires (memory_load32_le(mem, $x_addr) == 0bv32);
   free requires (memory_load64_le(mem, 69632bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free requires (memory_load8_le(mem, 1896bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1897bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1898bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1899bv64) == 0bv8);
+  free requires (memory_load32_le(mem, 1896bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69016bv64) == 1872bv64);
   free requires (memory_load64_le(mem, 69024bv64) == 1792bv64);
   free requires (memory_load64_le(mem, 69616bv64) == 1536bv64);
   free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
   ensures ((memory_load32_le(mem, $x_addr) == 20bv32) || (memory_load32_le(mem, $x_addr) == 21bv32));
-  free ensures (memory_load8_le(mem, 1896bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1897bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1898bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1899bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1896bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69016bv64) == 1872bv64);
   free ensures (memory_load64_le(mem, 69024bv64) == 1792bv64);
   free ensures (memory_load64_le(mem, 69616bv64) == 1536bv64);
diff --git a/src/test/correct/basic_loop_assign/gcc_O2/basic_loop_assign_gtirb.expected b/src/test/correct/basic_loop_assign/gcc_O2/basic_loop_assign_gtirb.expected
index 2b0945da1..a6dc84191 100644
--- a/src/test/correct/basic_loop_assign/gcc_O2/basic_loop_assign_gtirb.expected
+++ b/src/test/correct/basic_loop_assign/gcc_O2/basic_loop_assign_gtirb.expected
@@ -8,7 +8,7 @@ var {:extern} R2: bv64;
 var {:extern} mem: [bv64]bv8;
 const {:extern} $x_addr: bv64;
 axiom ($x_addr == 69652bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
   (if (index == $x_addr) then true else false)
 }
 
@@ -27,10 +27,6 @@ function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv6
   (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
-}
-
 function {:extern} memory_store32_le(memory: [bv64]bv8, index: bv64, value: bv32) returns ([bv64]bv8) {
   memory[index := value[8:0]][bvadd64(index, 1bv64) := value[16:8]][bvadd64(index, 2bv64) := value[24:16]][bvadd64(index, 3bv64) := value[32:24]]
 }
@@ -39,10 +35,7 @@ procedure {:extern} rely();
   modifies Gamma_mem, mem;
   ensures (forall i: bv64 :: (((mem[i] == old(mem[i])) ==> (Gamma_mem[i] == old(Gamma_mem[i])))));
   ensures (((memory_load32_le(mem, $x_addr) == old(memory_load32_le(mem, $x_addr))) || (bvsle32(memory_load32_le(mem, $x_addr), 10bv32) && bvslt32(old(memory_load32_le(mem, $x_addr)), 10bv32))) || ((memory_load32_le(mem, $x_addr) == 21bv32) && (old(memory_load32_le(mem, $x_addr)) == 20bv32)));
-  free ensures (memory_load8_le(mem, 1896bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1897bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1898bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1899bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1896bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69016bv64) == 1872bv64);
   free ensures (memory_load64_le(mem, 69024bv64) == 1792bv64);
   free ensures (memory_load64_le(mem, 69616bv64) == 1536bv64);
@@ -78,19 +71,13 @@ procedure main();
   requires (memory_load32_le(mem, $x_addr) == 0bv32);
   free requires (memory_load64_le(mem, 69632bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free requires (memory_load8_le(mem, 1896bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1897bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1898bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1899bv64) == 0bv8);
+  free requires (memory_load32_le(mem, 1896bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69016bv64) == 1872bv64);
   free requires (memory_load64_le(mem, 69024bv64) == 1792bv64);
   free requires (memory_load64_le(mem, 69616bv64) == 1536bv64);
   free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
   ensures ((memory_load32_le(mem, $x_addr) == 20bv32) || (memory_load32_le(mem, $x_addr) == 21bv32));
-  free ensures (memory_load8_le(mem, 1896bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1897bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1898bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1899bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1896bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69016bv64) == 1872bv64);
   free ensures (memory_load64_le(mem, 69024bv64) == 1792bv64);
   free ensures (memory_load64_le(mem, 69616bv64) == 1536bv64);
diff --git a/src/test/correct/basic_loop_assign/gcc_pic/basic_loop_assign.expected b/src/test/correct/basic_loop_assign/gcc_pic/basic_loop_assign.expected
index 026236fd8..17b1df7e3 100644
--- a/src/test/correct/basic_loop_assign/gcc_pic/basic_loop_assign.expected
+++ b/src/test/correct/basic_loop_assign/gcc_pic/basic_loop_assign.expected
@@ -6,7 +6,7 @@ var {:extern} R1: bv64;
 var {:extern} mem: [bv64]bv8;
 const {:extern} $x_addr: bv64;
 axiom ($x_addr == 69652bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
   (if (index == $x_addr) then true else false)
 }
 
@@ -29,10 +29,6 @@ function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv6
   (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
-}
-
 function {:extern} memory_store32_le(memory: [bv64]bv8, index: bv64, value: bv32) returns ([bv64]bv8) {
   memory[index := value[8:0]][bvadd64(index, 1bv64) := value[16:8]][bvadd64(index, 2bv64) := value[24:16]][bvadd64(index, 3bv64) := value[32:24]]
 }
@@ -41,15 +37,12 @@ procedure {:extern} rely();
   modifies Gamma_mem, mem;
   ensures (forall i: bv64 :: (((mem[i] == old(mem[i])) ==> (Gamma_mem[i] == old(Gamma_mem[i])))));
   ensures (((memory_load32_le(mem, $x_addr) == old(memory_load32_le(mem, $x_addr))) || (bvsle32(memory_load32_le(mem, $x_addr), 10bv32) && bvslt32(old(memory_load32_le(mem, $x_addr)), 10bv32))) || ((memory_load32_le(mem, $x_addr) == 21bv32) && (old(memory_load32_le(mem, $x_addr)) == 20bv32)));
-  free ensures (memory_load8_le(mem, 1920bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1921bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1922bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1923bv64) == 0bv8);
-  free ensures (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free ensures (memory_load64_le(mem, 69616bv64) == 1876bv64);
+  free ensures (memory_load32_le(mem, 1920bv64) == 131073bv32);
+  free ensures (memory_load64_le(mem, 69008bv64) == 1872bv64);
   free ensures (memory_load64_le(mem, 69016bv64) == 1792bv64);
   free ensures (memory_load64_le(mem, 69600bv64) == 69652bv64);
-  free ensures (memory_load64_le(mem, 69008bv64) == 1872bv64);
+  free ensures (memory_load64_le(mem, 69616bv64) == 1876bv64);
+  free ensures (memory_load64_le(mem, 69640bv64) == 69640bv64);
 
 procedure {:extern} rely_transitive();
   modifies Gamma_mem, mem;
@@ -81,25 +74,19 @@ procedure main();
   requires (memory_load32_le(mem, $x_addr) == 0bv32);
   free requires (memory_load64_le(mem, 69632bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free requires (memory_load8_le(mem, 1920bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1921bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1922bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1923bv64) == 0bv8);
-  free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free requires (memory_load64_le(mem, 69616bv64) == 1876bv64);
+  free requires (memory_load32_le(mem, 1920bv64) == 131073bv32);
+  free requires (memory_load64_le(mem, 69008bv64) == 1872bv64);
   free requires (memory_load64_le(mem, 69016bv64) == 1792bv64);
   free requires (memory_load64_le(mem, 69600bv64) == 69652bv64);
-  free requires (memory_load64_le(mem, 69008bv64) == 1872bv64);
+  free requires (memory_load64_le(mem, 69616bv64) == 1876bv64);
+  free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
   ensures ((memory_load32_le(mem, $x_addr) == 20bv32) || (memory_load32_le(mem, $x_addr) == 21bv32));
-  free ensures (memory_load8_le(mem, 1920bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1921bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1922bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1923bv64) == 0bv8);
-  free ensures (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free ensures (memory_load64_le(mem, 69616bv64) == 1876bv64);
+  free ensures (memory_load32_le(mem, 1920bv64) == 131073bv32);
+  free ensures (memory_load64_le(mem, 69008bv64) == 1872bv64);
   free ensures (memory_load64_le(mem, 69016bv64) == 1792bv64);
   free ensures (memory_load64_le(mem, 69600bv64) == 69652bv64);
-  free ensures (memory_load64_le(mem, 69008bv64) == 1872bv64);
+  free ensures (memory_load64_le(mem, 69616bv64) == 1876bv64);
+  free ensures (memory_load64_le(mem, 69640bv64) == 69640bv64);
 
 implementation main()
 {
diff --git a/src/test/correct/basic_loop_assign/gcc_pic/basic_loop_assign_gtirb.expected b/src/test/correct/basic_loop_assign/gcc_pic/basic_loop_assign_gtirb.expected
index 89072a4ba..399b13120 100644
--- a/src/test/correct/basic_loop_assign/gcc_pic/basic_loop_assign_gtirb.expected
+++ b/src/test/correct/basic_loop_assign/gcc_pic/basic_loop_assign_gtirb.expected
@@ -6,7 +6,7 @@ var {:extern} R1: bv64;
 var {:extern} mem: [bv64]bv8;
 const {:extern} $x_addr: bv64;
 axiom ($x_addr == 69652bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
   (if (index == $x_addr) then true else false)
 }
 
@@ -29,10 +29,6 @@ function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv6
   (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
-}
-
 function {:extern} memory_store32_le(memory: [bv64]bv8, index: bv64, value: bv32) returns ([bv64]bv8) {
   memory[index := value[8:0]][bvadd64(index, 1bv64) := value[16:8]][bvadd64(index, 2bv64) := value[24:16]][bvadd64(index, 3bv64) := value[32:24]]
 }
@@ -41,15 +37,12 @@ procedure {:extern} rely();
   modifies Gamma_mem, mem;
   ensures (forall i: bv64 :: (((mem[i] == old(mem[i])) ==> (Gamma_mem[i] == old(Gamma_mem[i])))));
   ensures (((memory_load32_le(mem, $x_addr) == old(memory_load32_le(mem, $x_addr))) || (bvsle32(memory_load32_le(mem, $x_addr), 10bv32) && bvslt32(old(memory_load32_le(mem, $x_addr)), 10bv32))) || ((memory_load32_le(mem, $x_addr) == 21bv32) && (old(memory_load32_le(mem, $x_addr)) == 20bv32)));
-  free ensures (memory_load8_le(mem, 1920bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1921bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1922bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1923bv64) == 0bv8);
-  free ensures (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free ensures (memory_load64_le(mem, 69616bv64) == 1876bv64);
+  free ensures (memory_load32_le(mem, 1920bv64) == 131073bv32);
+  free ensures (memory_load64_le(mem, 69008bv64) == 1872bv64);
   free ensures (memory_load64_le(mem, 69016bv64) == 1792bv64);
   free ensures (memory_load64_le(mem, 69600bv64) == 69652bv64);
-  free ensures (memory_load64_le(mem, 69008bv64) == 1872bv64);
+  free ensures (memory_load64_le(mem, 69616bv64) == 1876bv64);
+  free ensures (memory_load64_le(mem, 69640bv64) == 69640bv64);
 
 procedure {:extern} rely_transitive();
   modifies Gamma_mem, mem;
@@ -81,25 +74,19 @@ procedure main();
   requires (memory_load32_le(mem, $x_addr) == 0bv32);
   free requires (memory_load64_le(mem, 69632bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free requires (memory_load8_le(mem, 1920bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1921bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1922bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1923bv64) == 0bv8);
-  free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free requires (memory_load64_le(mem, 69616bv64) == 1876bv64);
+  free requires (memory_load32_le(mem, 1920bv64) == 131073bv32);
+  free requires (memory_load64_le(mem, 69008bv64) == 1872bv64);
   free requires (memory_load64_le(mem, 69016bv64) == 1792bv64);
   free requires (memory_load64_le(mem, 69600bv64) == 69652bv64);
-  free requires (memory_load64_le(mem, 69008bv64) == 1872bv64);
+  free requires (memory_load64_le(mem, 69616bv64) == 1876bv64);
+  free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
   ensures ((memory_load32_le(mem, $x_addr) == 20bv32) || (memory_load32_le(mem, $x_addr) == 21bv32));
-  free ensures (memory_load8_le(mem, 1920bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1921bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1922bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1923bv64) == 0bv8);
-  free ensures (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free ensures (memory_load64_le(mem, 69616bv64) == 1876bv64);
+  free ensures (memory_load32_le(mem, 1920bv64) == 131073bv32);
+  free ensures (memory_load64_le(mem, 69008bv64) == 1872bv64);
   free ensures (memory_load64_le(mem, 69016bv64) == 1792bv64);
   free ensures (memory_load64_le(mem, 69600bv64) == 69652bv64);
-  free ensures (memory_load64_le(mem, 69008bv64) == 1872bv64);
+  free ensures (memory_load64_le(mem, 69616bv64) == 1876bv64);
+  free ensures (memory_load64_le(mem, 69640bv64) == 69640bv64);
 
 implementation main()
 {
diff --git a/src/test/correct/basic_operation_evaluation/clang/basic_operation_evaluation.expected b/src/test/correct/basic_operation_evaluation/clang/basic_operation_evaluation.expected
index e2c00441a..97c370685 100644
--- a/src/test/correct/basic_operation_evaluation/clang/basic_operation_evaluation.expected
+++ b/src/test/correct/basic_operation_evaluation/clang/basic_operation_evaluation.expected
@@ -55,10 +55,6 @@ function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv6
   (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
-}
-
 function {:extern} memory_store32_le(memory: [bv64]bv8, index: bv64, value: bv32) returns ([bv64]bv8) {
   memory[index := value[8:0]][bvadd64(index, 1bv64) := value[16:8]][bvadd64(index, 2bv64) := value[24:16]][bvadd64(index, 3bv64) := value[32:24]]
 }
@@ -72,12 +68,9 @@ function {:extern} {:bvbuiltin "zero_extend 1"} zero_extend1_32(bv32) returns (b
 function {:extern} {:bvbuiltin "zero_extend 32"} zero_extend32_32(bv32) returns (bv64);
 procedure {:extern} rely();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
-  free ensures (memory_load8_le(mem, 1952bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1953bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1954bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1955bv64) == 0bv8);
+  ensures (mem == old(mem));
+  free ensures (memory_load32_le(mem, 1952bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1812bv64);
@@ -85,8 +78,8 @@ procedure {:extern} rely();
 
 procedure {:extern} rely_transitive();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
+  ensures (mem == old(mem));
 
 implementation {:extern} rely_transitive()
 {
@@ -103,20 +96,14 @@ procedure main();
   modifies CF, Gamma_CF, Gamma_NF, Gamma_R0, Gamma_R10, Gamma_R31, Gamma_R8, Gamma_R9, Gamma_VF, Gamma_ZF, Gamma_stack, NF, R0, R10, R31, R8, R9, VF, ZF, stack;
   free requires (memory_load64_le(mem, 69664bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
-  free requires (memory_load8_le(mem, 1952bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1953bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1954bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1955bv64) == 0bv8);
+  free requires (memory_load32_le(mem, 1952bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free requires (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free requires (memory_load64_le(mem, 69592bv64) == 1812bv64);
   free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
   free ensures (Gamma_R31 == old(Gamma_R31));
   free ensures (R31 == old(R31));
-  free ensures (memory_load8_le(mem, 1952bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1953bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1954bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1955bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1952bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1812bv64);
diff --git a/src/test/correct/basic_operation_evaluation/clang/basic_operation_evaluation_gtirb.expected b/src/test/correct/basic_operation_evaluation/clang/basic_operation_evaluation_gtirb.expected
index bd0a36ae5..cf9b45fac 100644
--- a/src/test/correct/basic_operation_evaluation/clang/basic_operation_evaluation_gtirb.expected
+++ b/src/test/correct/basic_operation_evaluation/clang/basic_operation_evaluation_gtirb.expected
@@ -55,10 +55,6 @@ function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv6
   (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
-}
-
 function {:extern} memory_store32_le(memory: [bv64]bv8, index: bv64, value: bv32) returns ([bv64]bv8) {
   memory[index := value[8:0]][bvadd64(index, 1bv64) := value[16:8]][bvadd64(index, 2bv64) := value[24:16]][bvadd64(index, 3bv64) := value[32:24]]
 }
@@ -72,12 +68,9 @@ function {:extern} {:bvbuiltin "zero_extend 1"} zero_extend1_32(bv32) returns (b
 function {:extern} {:bvbuiltin "zero_extend 32"} zero_extend32_32(bv32) returns (bv64);
 procedure {:extern} rely();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
-  free ensures (memory_load8_le(mem, 1952bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1953bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1954bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1955bv64) == 0bv8);
+  ensures (mem == old(mem));
+  free ensures (memory_load32_le(mem, 1952bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1812bv64);
@@ -85,8 +78,8 @@ procedure {:extern} rely();
 
 procedure {:extern} rely_transitive();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
+  ensures (mem == old(mem));
 
 implementation {:extern} rely_transitive()
 {
@@ -103,20 +96,14 @@ procedure main();
   modifies CF, Gamma_CF, Gamma_NF, Gamma_R0, Gamma_R10, Gamma_R31, Gamma_R8, Gamma_R9, Gamma_VF, Gamma_ZF, Gamma_stack, NF, R0, R10, R31, R8, R9, VF, ZF, stack;
   free requires (memory_load64_le(mem, 69664bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
-  free requires (memory_load8_le(mem, 1952bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1953bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1954bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1955bv64) == 0bv8);
+  free requires (memory_load32_le(mem, 1952bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free requires (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free requires (memory_load64_le(mem, 69592bv64) == 1812bv64);
   free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
   free ensures (Gamma_R31 == old(Gamma_R31));
   free ensures (R31 == old(R31));
-  free ensures (memory_load8_le(mem, 1952bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1953bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1954bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1955bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1952bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1812bv64);
diff --git a/src/test/correct/basic_operation_evaluation/gcc/basic_operation_evaluation.expected b/src/test/correct/basic_operation_evaluation/gcc/basic_operation_evaluation.expected
index c51655fb8..44bceb181 100644
--- a/src/test/correct/basic_operation_evaluation/gcc/basic_operation_evaluation.expected
+++ b/src/test/correct/basic_operation_evaluation/gcc/basic_operation_evaluation.expected
@@ -40,10 +40,6 @@ function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv6
   (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
-}
-
 function {:extern} memory_store32_le(memory: [bv64]bv8, index: bv64, value: bv32) returns ([bv64]bv8) {
   memory[index := value[8:0]][bvadd64(index, 1bv64) := value[16:8]][bvadd64(index, 2bv64) := value[24:16]][bvadd64(index, 3bv64) := value[32:24]]
 }
@@ -56,12 +52,9 @@ function {:extern} {:bvbuiltin "sign_extend 1"} sign_extend1_32(bv32) returns (b
 function {:extern} {:bvbuiltin "zero_extend 32"} zero_extend32_32(bv32) returns (bv64);
 procedure {:extern} rely();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
-  free ensures (memory_load8_le(mem, 1948bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1949bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1950bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1951bv64) == 0bv8);
+  ensures (mem == old(mem));
+  free ensures (memory_load32_le(mem, 1948bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69016bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69024bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69616bv64) == 1812bv64);
@@ -69,8 +62,8 @@ procedure {:extern} rely();
 
 procedure {:extern} rely_transitive();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
+  ensures (mem == old(mem));
 
 implementation {:extern} rely_transitive()
 {
@@ -87,20 +80,14 @@ procedure main();
   modifies Gamma_R0, Gamma_R1, Gamma_R2, Gamma_R31, Gamma_stack, R0, R1, R2, R31, stack;
   free requires (memory_load64_le(mem, 69632bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free requires (memory_load8_le(mem, 1948bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1949bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1950bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1951bv64) == 0bv8);
+  free requires (memory_load32_le(mem, 1948bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69016bv64) == 1808bv64);
   free requires (memory_load64_le(mem, 69024bv64) == 1728bv64);
   free requires (memory_load64_le(mem, 69616bv64) == 1812bv64);
   free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
   free ensures (Gamma_R31 == old(Gamma_R31));
   free ensures (R31 == old(R31));
-  free ensures (memory_load8_le(mem, 1948bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1949bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1950bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1951bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1948bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69016bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69024bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69616bv64) == 1812bv64);
diff --git a/src/test/correct/basic_operation_evaluation/gcc/basic_operation_evaluation_gtirb.expected b/src/test/correct/basic_operation_evaluation/gcc/basic_operation_evaluation_gtirb.expected
index c85b41e05..b5ec9e0ac 100644
--- a/src/test/correct/basic_operation_evaluation/gcc/basic_operation_evaluation_gtirb.expected
+++ b/src/test/correct/basic_operation_evaluation/gcc/basic_operation_evaluation_gtirb.expected
@@ -39,10 +39,6 @@ function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv6
   (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
-}
-
 function {:extern} memory_store32_le(memory: [bv64]bv8, index: bv64, value: bv32) returns ([bv64]bv8) {
   memory[index := value[8:0]][bvadd64(index, 1bv64) := value[16:8]][bvadd64(index, 2bv64) := value[24:16]][bvadd64(index, 3bv64) := value[32:24]]
 }
@@ -55,12 +51,9 @@ function {:extern} {:bvbuiltin "sign_extend 1"} sign_extend1_32(bv32) returns (b
 function {:extern} {:bvbuiltin "zero_extend 32"} zero_extend32_32(bv32) returns (bv64);
 procedure {:extern} rely();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
-  free ensures (memory_load8_le(mem, 1948bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1949bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1950bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1951bv64) == 0bv8);
+  ensures (mem == old(mem));
+  free ensures (memory_load32_le(mem, 1948bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69016bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69024bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69616bv64) == 1812bv64);
@@ -68,8 +61,8 @@ procedure {:extern} rely();
 
 procedure {:extern} rely_transitive();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
+  ensures (mem == old(mem));
 
 implementation {:extern} rely_transitive()
 {
@@ -86,20 +79,14 @@ procedure main();
   modifies Gamma_R0, Gamma_R1, Gamma_R2, Gamma_R31, Gamma_stack, R0, R1, R2, R31, stack;
   free requires (memory_load64_le(mem, 69632bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free requires (memory_load8_le(mem, 1948bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1949bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1950bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1951bv64) == 0bv8);
+  free requires (memory_load32_le(mem, 1948bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69016bv64) == 1808bv64);
   free requires (memory_load64_le(mem, 69024bv64) == 1728bv64);
   free requires (memory_load64_le(mem, 69616bv64) == 1812bv64);
   free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
   free ensures (Gamma_R31 == old(Gamma_R31));
   free ensures (R31 == old(R31));
-  free ensures (memory_load8_le(mem, 1948bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1949bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1950bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1951bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1948bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69016bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69024bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69616bv64) == 1812bv64);
diff --git a/src/test/correct/basic_sec_policy_read/clang/basic_sec_policy_read.expected b/src/test/correct/basic_sec_policy_read/clang/basic_sec_policy_read.expected
index 461154d55..c8bb1c0d2 100644
--- a/src/test/correct/basic_sec_policy_read/clang/basic_sec_policy_read.expected
+++ b/src/test/correct/basic_sec_policy_read/clang/basic_sec_policy_read.expected
@@ -20,8 +20,8 @@ const {:extern} $x_addr: bv64;
 axiom ($x_addr == 69684bv64);
 const {:extern} $z_addr: bv64;
 axiom ($z_addr == 69688bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
-  (if (index == $z_addr) then true else (if (index == $x_addr) then (memory_load32_le(memory, $z_addr) == 0bv32) else false))
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
+  (if (index == $z_addr) then true else (if (index == $x_addr) then (memory_load32_le(mem$in, $z_addr) == 0bv32) else false))
 }
 
 function {:extern} {:bvbuiltin "bvadd"} bvadd32(bv32, bv32) returns (bv32);
@@ -47,10 +47,6 @@ function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv6
   (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
-}
-
 function {:extern} memory_store32_le(memory: [bv64]bv8, index: bv64, value: bv32) returns ([bv64]bv8) {
   memory[index := value[8:0]][bvadd64(index, 1bv64) := value[16:8]][bvadd64(index, 2bv64) := value[24:16]][bvadd64(index, 3bv64) := value[32:24]]
 }
@@ -62,10 +58,7 @@ procedure {:extern} rely();
   modifies Gamma_mem, mem;
   ensures (forall i: bv64 :: (((mem[i] == old(mem[i])) ==> (Gamma_mem[i] == old(Gamma_mem[i])))));
   ensures ((old(memory_load32_le(mem, $z_addr)) != 0bv32) ==> (memory_load32_le(mem, $z_addr) != 0bv32));
-  free ensures (memory_load8_le(mem, 1896bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1897bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1898bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1899bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1896bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1812bv64);
@@ -100,20 +93,14 @@ procedure main();
   modifies CF, Gamma_CF, Gamma_NF, Gamma_R0, Gamma_R31, Gamma_R8, Gamma_VF, Gamma_ZF, Gamma_mem, Gamma_stack, NF, R0, R31, R8, VF, ZF, mem, stack;
   free requires (memory_load64_le(mem, 69664bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
-  free requires (memory_load8_le(mem, 1896bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1897bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1898bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1899bv64) == 0bv8);
+  free requires (memory_load32_le(mem, 1896bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free requires (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free requires (memory_load64_le(mem, 69592bv64) == 1812bv64);
   free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
   free ensures (Gamma_R31 == old(Gamma_R31));
   free ensures (R31 == old(R31));
-  free ensures (memory_load8_le(mem, 1896bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1897bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1898bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1899bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1896bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1812bv64);
diff --git a/src/test/correct/basic_sec_policy_read/clang/basic_sec_policy_read_gtirb.expected b/src/test/correct/basic_sec_policy_read/clang/basic_sec_policy_read_gtirb.expected
index 818a0a62d..ab49772d7 100644
--- a/src/test/correct/basic_sec_policy_read/clang/basic_sec_policy_read_gtirb.expected
+++ b/src/test/correct/basic_sec_policy_read/clang/basic_sec_policy_read_gtirb.expected
@@ -20,8 +20,8 @@ const {:extern} $x_addr: bv64;
 axiom ($x_addr == 69684bv64);
 const {:extern} $z_addr: bv64;
 axiom ($z_addr == 69688bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
-  (if (index == $z_addr) then true else (if (index == $x_addr) then (memory_load32_le(memory, $z_addr) == 0bv32) else false))
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
+  (if (index == $z_addr) then true else (if (index == $x_addr) then (memory_load32_le(mem$in, $z_addr) == 0bv32) else false))
 }
 
 function {:extern} {:bvbuiltin "bvadd"} bvadd32(bv32, bv32) returns (bv32);
@@ -46,10 +46,6 @@ function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv6
   (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
-}
-
 function {:extern} memory_store32_le(memory: [bv64]bv8, index: bv64, value: bv32) returns ([bv64]bv8) {
   memory[index := value[8:0]][bvadd64(index, 1bv64) := value[16:8]][bvadd64(index, 2bv64) := value[24:16]][bvadd64(index, 3bv64) := value[32:24]]
 }
@@ -60,10 +56,7 @@ procedure {:extern} rely();
   modifies Gamma_mem, mem;
   ensures (forall i: bv64 :: (((mem[i] == old(mem[i])) ==> (Gamma_mem[i] == old(Gamma_mem[i])))));
   ensures ((old(memory_load32_le(mem, $z_addr)) != 0bv32) ==> (memory_load32_le(mem, $z_addr) != 0bv32));
-  free ensures (memory_load8_le(mem, 1896bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1897bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1898bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1899bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1896bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1812bv64);
@@ -98,20 +91,14 @@ procedure main();
   modifies CF, Gamma_CF, Gamma_NF, Gamma_R0, Gamma_R31, Gamma_R8, Gamma_VF, Gamma_ZF, Gamma_mem, Gamma_stack, NF, R0, R31, R8, VF, ZF, mem, stack;
   free requires (memory_load64_le(mem, 69664bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
-  free requires (memory_load8_le(mem, 1896bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1897bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1898bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1899bv64) == 0bv8);
+  free requires (memory_load32_le(mem, 1896bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free requires (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free requires (memory_load64_le(mem, 69592bv64) == 1812bv64);
   free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
   free ensures (Gamma_R31 == old(Gamma_R31));
   free ensures (R31 == old(R31));
-  free ensures (memory_load8_le(mem, 1896bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1897bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1898bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1899bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1896bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1812bv64);
diff --git a/src/test/correct/basic_sec_policy_read/clang_O2/basic_sec_policy_read.expected b/src/test/correct/basic_sec_policy_read/clang_O2/basic_sec_policy_read.expected
index d45dc06e1..570c5a400 100644
--- a/src/test/correct/basic_sec_policy_read/clang_O2/basic_sec_policy_read.expected
+++ b/src/test/correct/basic_sec_policy_read/clang_O2/basic_sec_policy_read.expected
@@ -18,8 +18,8 @@ const {:extern} $x_addr: bv64;
 axiom ($x_addr == 69684bv64);
 const {:extern} $z_addr: bv64;
 axiom ($z_addr == 69688bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
-  (if (index == $z_addr) then true else (if (index == $x_addr) then (memory_load32_le(memory, $z_addr) == 0bv32) else false))
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
+  (if (index == $z_addr) then true else (if (index == $x_addr) then (memory_load32_le(mem$in, $z_addr) == 0bv32) else false))
 }
 
 function {:extern} {:bvbuiltin "bvadd"} bvadd32(bv32, bv32) returns (bv32);
@@ -41,10 +41,6 @@ function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv6
   (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
-}
-
 function {:extern} {:bvbuiltin "sign_extend 1"} sign_extend1_32(bv32) returns (bv33);
 function {:extern} {:bvbuiltin "zero_extend 1"} zero_extend1_32(bv32) returns (bv33);
 function {:extern} {:bvbuiltin "zero_extend 32"} zero_extend32_32(bv32) returns (bv64);
@@ -52,10 +48,7 @@ procedure {:extern} rely();
   modifies Gamma_mem, mem;
   ensures (forall i: bv64 :: (((mem[i] == old(mem[i])) ==> (Gamma_mem[i] == old(Gamma_mem[i])))));
   ensures ((old(memory_load32_le(mem, $z_addr)) != 0bv32) ==> (memory_load32_le(mem, $z_addr) != 0bv32));
-  free ensures (memory_load8_le(mem, 1860bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1861bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1862bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1863bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1860bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1812bv64);
@@ -90,18 +83,12 @@ procedure main();
   modifies CF, Gamma_CF, Gamma_NF, Gamma_R0, Gamma_R8, Gamma_R9, Gamma_VF, Gamma_ZF, Gamma_mem, NF, R0, R8, R9, VF, ZF, mem;
   free requires (memory_load64_le(mem, 69664bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
-  free requires (memory_load8_le(mem, 1860bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1861bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1862bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1863bv64) == 0bv8);
+  free requires (memory_load32_le(mem, 1860bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free requires (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free requires (memory_load64_le(mem, 69592bv64) == 1812bv64);
   free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
-  free ensures (memory_load8_le(mem, 1860bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1861bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1862bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1863bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1860bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1812bv64);
diff --git a/src/test/correct/basic_sec_policy_read/clang_O2/basic_sec_policy_read_gtirb.expected b/src/test/correct/basic_sec_policy_read/clang_O2/basic_sec_policy_read_gtirb.expected
index 95b1fe31e..14bd77436 100644
--- a/src/test/correct/basic_sec_policy_read/clang_O2/basic_sec_policy_read_gtirb.expected
+++ b/src/test/correct/basic_sec_policy_read/clang_O2/basic_sec_policy_read_gtirb.expected
@@ -18,8 +18,8 @@ const {:extern} $x_addr: bv64;
 axiom ($x_addr == 69684bv64);
 const {:extern} $z_addr: bv64;
 axiom ($z_addr == 69688bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
-  (if (index == $z_addr) then true else (if (index == $x_addr) then (memory_load32_le(memory, $z_addr) == 0bv32) else false))
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
+  (if (index == $z_addr) then true else (if (index == $x_addr) then (memory_load32_le(mem$in, $z_addr) == 0bv32) else false))
 }
 
 function {:extern} {:bvbuiltin "bvadd"} bvadd32(bv32, bv32) returns (bv32);
@@ -40,20 +40,13 @@ function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv6
   (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
-}
-
 function {:extern} {:bvbuiltin "zero_extend 1"} zero_extend1_32(bv32) returns (bv33);
 function {:extern} {:bvbuiltin "zero_extend 32"} zero_extend32_32(bv32) returns (bv64);
 procedure {:extern} rely();
   modifies Gamma_mem, mem;
   ensures (forall i: bv64 :: (((mem[i] == old(mem[i])) ==> (Gamma_mem[i] == old(Gamma_mem[i])))));
   ensures ((old(memory_load32_le(mem, $z_addr)) != 0bv32) ==> (memory_load32_le(mem, $z_addr) != 0bv32));
-  free ensures (memory_load8_le(mem, 1860bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1861bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1862bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1863bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1860bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1812bv64);
@@ -88,18 +81,12 @@ procedure main();
   modifies CF, Gamma_CF, Gamma_NF, Gamma_R0, Gamma_R8, Gamma_R9, Gamma_VF, Gamma_ZF, Gamma_mem, NF, R0, R8, R9, VF, ZF, mem;
   free requires (memory_load64_le(mem, 69664bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
-  free requires (memory_load8_le(mem, 1860bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1861bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1862bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1863bv64) == 0bv8);
+  free requires (memory_load32_le(mem, 1860bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free requires (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free requires (memory_load64_le(mem, 69592bv64) == 1812bv64);
   free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
-  free ensures (memory_load8_le(mem, 1860bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1861bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1862bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1863bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1860bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1812bv64);
diff --git a/src/test/correct/basic_sec_policy_read/clang_pic/basic_sec_policy_read.expected b/src/test/correct/basic_sec_policy_read/clang_pic/basic_sec_policy_read.expected
index cf1f9fc9c..d01c59e33 100644
--- a/src/test/correct/basic_sec_policy_read/clang_pic/basic_sec_policy_read.expected
+++ b/src/test/correct/basic_sec_policy_read/clang_pic/basic_sec_policy_read.expected
@@ -20,8 +20,8 @@ const {:extern} $x_addr: bv64;
 axiom ($x_addr == 69684bv64);
 const {:extern} $z_addr: bv64;
 axiom ($z_addr == 69688bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
-  (if (index == $z_addr) then true else (if (index == $x_addr) then (memory_load32_le(memory, $z_addr) == 0bv32) else false))
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
+  (if (index == $z_addr) then true else (if (index == $x_addr) then (memory_load32_le(mem$in, $z_addr) == 0bv32) else false))
 }
 
 function {:extern} {:bvbuiltin "bvadd"} bvadd32(bv32, bv32) returns (bv32);
@@ -51,10 +51,6 @@ function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv6
   (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
-}
-
 function {:extern} memory_store32_le(memory: [bv64]bv8, index: bv64, value: bv32) returns ([bv64]bv8) {
   memory[index := value[8:0]][bvadd64(index, 1bv64) := value[16:8]][bvadd64(index, 2bv64) := value[24:16]][bvadd64(index, 3bv64) := value[32:24]]
 }
@@ -66,16 +62,13 @@ procedure {:extern} rely();
   modifies Gamma_mem, mem;
   ensures (forall i: bv64 :: (((mem[i] == old(mem[i])) ==> (Gamma_mem[i] == old(Gamma_mem[i])))));
   ensures ((old(memory_load32_le(mem, $z_addr)) != 0bv32) ==> (memory_load32_le(mem, $z_addr) != 0bv32));
-  free ensures (memory_load8_le(mem, 1968bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1969bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1970bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1971bv64) == 0bv8);
-  free ensures (memory_load64_le(mem, 69576bv64) == 69684bv64);
-  free ensures (memory_load64_le(mem, 69672bv64) == 69672bv64);
+  free ensures (memory_load32_le(mem, 1968bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69048bv64) == 1872bv64);
+  free ensures (memory_load64_le(mem, 69056bv64) == 1792bv64);
   free ensures (memory_load64_le(mem, 69568bv64) == 69688bv64);
+  free ensures (memory_load64_le(mem, 69576bv64) == 69684bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1876bv64);
-  free ensures (memory_load64_le(mem, 69056bv64) == 1792bv64);
+  free ensures (memory_load64_le(mem, 69672bv64) == 69672bv64);
 
 procedure {:extern} rely_transitive();
   modifies Gamma_mem, mem;
@@ -106,28 +99,22 @@ procedure main();
   modifies CF, Gamma_CF, Gamma_NF, Gamma_R0, Gamma_R31, Gamma_R8, Gamma_VF, Gamma_ZF, Gamma_mem, Gamma_stack, NF, R0, R31, R8, VF, ZF, mem, stack;
   free requires (memory_load64_le(mem, 69664bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
-  free requires (memory_load8_le(mem, 1968bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1969bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1970bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1971bv64) == 0bv8);
-  free requires (memory_load64_le(mem, 69576bv64) == 69684bv64);
-  free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
+  free requires (memory_load32_le(mem, 1968bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69048bv64) == 1872bv64);
+  free requires (memory_load64_le(mem, 69056bv64) == 1792bv64);
   free requires (memory_load64_le(mem, 69568bv64) == 69688bv64);
+  free requires (memory_load64_le(mem, 69576bv64) == 69684bv64);
   free requires (memory_load64_le(mem, 69592bv64) == 1876bv64);
-  free requires (memory_load64_le(mem, 69056bv64) == 1792bv64);
+  free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
   free ensures (Gamma_R31 == old(Gamma_R31));
   free ensures (R31 == old(R31));
-  free ensures (memory_load8_le(mem, 1968bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1969bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1970bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1971bv64) == 0bv8);
-  free ensures (memory_load64_le(mem, 69576bv64) == 69684bv64);
-  free ensures (memory_load64_le(mem, 69672bv64) == 69672bv64);
+  free ensures (memory_load32_le(mem, 1968bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69048bv64) == 1872bv64);
+  free ensures (memory_load64_le(mem, 69056bv64) == 1792bv64);
   free ensures (memory_load64_le(mem, 69568bv64) == 69688bv64);
+  free ensures (memory_load64_le(mem, 69576bv64) == 69684bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1876bv64);
-  free ensures (memory_load64_le(mem, 69056bv64) == 1792bv64);
+  free ensures (memory_load64_le(mem, 69672bv64) == 69672bv64);
 
 implementation main()
 {
diff --git a/src/test/correct/basic_sec_policy_read/clang_pic/basic_sec_policy_read_gtirb.expected b/src/test/correct/basic_sec_policy_read/clang_pic/basic_sec_policy_read_gtirb.expected
index d74b467e4..66e17bf7d 100644
--- a/src/test/correct/basic_sec_policy_read/clang_pic/basic_sec_policy_read_gtirb.expected
+++ b/src/test/correct/basic_sec_policy_read/clang_pic/basic_sec_policy_read_gtirb.expected
@@ -20,8 +20,8 @@ const {:extern} $x_addr: bv64;
 axiom ($x_addr == 69684bv64);
 const {:extern} $z_addr: bv64;
 axiom ($z_addr == 69688bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
-  (if (index == $z_addr) then true else (if (index == $x_addr) then (memory_load32_le(memory, $z_addr) == 0bv32) else false))
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
+  (if (index == $z_addr) then true else (if (index == $x_addr) then (memory_load32_le(mem$in, $z_addr) == 0bv32) else false))
 }
 
 function {:extern} {:bvbuiltin "bvadd"} bvadd32(bv32, bv32) returns (bv32);
@@ -50,10 +50,6 @@ function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv6
   (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
-}
-
 function {:extern} memory_store32_le(memory: [bv64]bv8, index: bv64, value: bv32) returns ([bv64]bv8) {
   memory[index := value[8:0]][bvadd64(index, 1bv64) := value[16:8]][bvadd64(index, 2bv64) := value[24:16]][bvadd64(index, 3bv64) := value[32:24]]
 }
@@ -64,16 +60,13 @@ procedure {:extern} rely();
   modifies Gamma_mem, mem;
   ensures (forall i: bv64 :: (((mem[i] == old(mem[i])) ==> (Gamma_mem[i] == old(Gamma_mem[i])))));
   ensures ((old(memory_load32_le(mem, $z_addr)) != 0bv32) ==> (memory_load32_le(mem, $z_addr) != 0bv32));
-  free ensures (memory_load8_le(mem, 1968bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1969bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1970bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1971bv64) == 0bv8);
-  free ensures (memory_load64_le(mem, 69576bv64) == 69684bv64);
-  free ensures (memory_load64_le(mem, 69672bv64) == 69672bv64);
+  free ensures (memory_load32_le(mem, 1968bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69048bv64) == 1872bv64);
+  free ensures (memory_load64_le(mem, 69056bv64) == 1792bv64);
   free ensures (memory_load64_le(mem, 69568bv64) == 69688bv64);
+  free ensures (memory_load64_le(mem, 69576bv64) == 69684bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1876bv64);
-  free ensures (memory_load64_le(mem, 69056bv64) == 1792bv64);
+  free ensures (memory_load64_le(mem, 69672bv64) == 69672bv64);
 
 procedure {:extern} rely_transitive();
   modifies Gamma_mem, mem;
@@ -104,28 +97,22 @@ procedure main();
   modifies CF, Gamma_CF, Gamma_NF, Gamma_R0, Gamma_R31, Gamma_R8, Gamma_VF, Gamma_ZF, Gamma_mem, Gamma_stack, NF, R0, R31, R8, VF, ZF, mem, stack;
   free requires (memory_load64_le(mem, 69664bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
-  free requires (memory_load8_le(mem, 1968bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1969bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1970bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1971bv64) == 0bv8);
-  free requires (memory_load64_le(mem, 69576bv64) == 69684bv64);
-  free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
+  free requires (memory_load32_le(mem, 1968bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69048bv64) == 1872bv64);
+  free requires (memory_load64_le(mem, 69056bv64) == 1792bv64);
   free requires (memory_load64_le(mem, 69568bv64) == 69688bv64);
+  free requires (memory_load64_le(mem, 69576bv64) == 69684bv64);
   free requires (memory_load64_le(mem, 69592bv64) == 1876bv64);
-  free requires (memory_load64_le(mem, 69056bv64) == 1792bv64);
+  free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
   free ensures (Gamma_R31 == old(Gamma_R31));
   free ensures (R31 == old(R31));
-  free ensures (memory_load8_le(mem, 1968bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1969bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1970bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1971bv64) == 0bv8);
-  free ensures (memory_load64_le(mem, 69576bv64) == 69684bv64);
-  free ensures (memory_load64_le(mem, 69672bv64) == 69672bv64);
+  free ensures (memory_load32_le(mem, 1968bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69048bv64) == 1872bv64);
+  free ensures (memory_load64_le(mem, 69056bv64) == 1792bv64);
   free ensures (memory_load64_le(mem, 69568bv64) == 69688bv64);
+  free ensures (memory_load64_le(mem, 69576bv64) == 69684bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1876bv64);
-  free ensures (memory_load64_le(mem, 69056bv64) == 1792bv64);
+  free ensures (memory_load64_le(mem, 69672bv64) == 69672bv64);
 
 implementation main()
 {
diff --git a/src/test/correct/basic_sec_policy_read/gcc/basic_sec_policy_read.expected b/src/test/correct/basic_sec_policy_read/gcc/basic_sec_policy_read.expected
index d4870579e..7f1f47659 100644
--- a/src/test/correct/basic_sec_policy_read/gcc/basic_sec_policy_read.expected
+++ b/src/test/correct/basic_sec_policy_read/gcc/basic_sec_policy_read.expected
@@ -18,8 +18,8 @@ const {:extern} $x_addr: bv64;
 axiom ($x_addr == 69652bv64);
 const {:extern} $z_addr: bv64;
 axiom ($z_addr == 69656bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
-  (if (index == $z_addr) then true else (if (index == $x_addr) then (memory_load32_le(memory, $z_addr) == 0bv32) else false))
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
+  (if (index == $z_addr) then true else (if (index == $x_addr) then (memory_load32_le(mem$in, $z_addr) == 0bv32) else false))
 }
 
 function {:extern} {:bvbuiltin "bvadd"} bvadd32(bv32, bv32) returns (bv32);
@@ -45,10 +45,6 @@ function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv6
   (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
-}
-
 function {:extern} memory_store32_le(memory: [bv64]bv8, index: bv64, value: bv32) returns ([bv64]bv8) {
   memory[index := value[8:0]][bvadd64(index, 1bv64) := value[16:8]][bvadd64(index, 2bv64) := value[24:16]][bvadd64(index, 3bv64) := value[32:24]]
 }
@@ -60,10 +56,7 @@ procedure {:extern} rely();
   modifies Gamma_mem, mem;
   ensures (forall i: bv64 :: (((mem[i] == old(mem[i])) ==> (Gamma_mem[i] == old(Gamma_mem[i])))));
   ensures ((old(memory_load32_le(mem, $z_addr)) != 0bv32) ==> (memory_load32_le(mem, $z_addr) != 0bv32));
-  free ensures (memory_load8_le(mem, 1888bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1889bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1890bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1891bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1888bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69016bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69024bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69616bv64) == 1812bv64);
@@ -98,20 +91,14 @@ procedure main();
   modifies CF, Gamma_CF, Gamma_NF, Gamma_R0, Gamma_R31, Gamma_VF, Gamma_ZF, Gamma_mem, Gamma_stack, NF, R0, R31, VF, ZF, mem, stack;
   free requires (memory_load64_le(mem, 69632bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free requires (memory_load8_le(mem, 1888bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1889bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1890bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1891bv64) == 0bv8);
+  free requires (memory_load32_le(mem, 1888bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69016bv64) == 1808bv64);
   free requires (memory_load64_le(mem, 69024bv64) == 1728bv64);
   free requires (memory_load64_le(mem, 69616bv64) == 1812bv64);
   free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
   free ensures (Gamma_R31 == old(Gamma_R31));
   free ensures (R31 == old(R31));
-  free ensures (memory_load8_le(mem, 1888bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1889bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1890bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1891bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1888bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69016bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69024bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69616bv64) == 1812bv64);
diff --git a/src/test/correct/basic_sec_policy_read/gcc/basic_sec_policy_read_gtirb.expected b/src/test/correct/basic_sec_policy_read/gcc/basic_sec_policy_read_gtirb.expected
index fa9e9fab6..eaf8bfed3 100644
--- a/src/test/correct/basic_sec_policy_read/gcc/basic_sec_policy_read_gtirb.expected
+++ b/src/test/correct/basic_sec_policy_read/gcc/basic_sec_policy_read_gtirb.expected
@@ -18,8 +18,8 @@ const {:extern} $x_addr: bv64;
 axiom ($x_addr == 69652bv64);
 const {:extern} $z_addr: bv64;
 axiom ($z_addr == 69656bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
-  (if (index == $z_addr) then true else (if (index == $x_addr) then (memory_load32_le(memory, $z_addr) == 0bv32) else false))
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
+  (if (index == $z_addr) then true else (if (index == $x_addr) then (memory_load32_le(mem$in, $z_addr) == 0bv32) else false))
 }
 
 function {:extern} {:bvbuiltin "bvadd"} bvadd32(bv32, bv32) returns (bv32);
@@ -44,10 +44,6 @@ function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv6
   (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
-}
-
 function {:extern} memory_store32_le(memory: [bv64]bv8, index: bv64, value: bv32) returns ([bv64]bv8) {
   memory[index := value[8:0]][bvadd64(index, 1bv64) := value[16:8]][bvadd64(index, 2bv64) := value[24:16]][bvadd64(index, 3bv64) := value[32:24]]
 }
@@ -58,10 +54,7 @@ procedure {:extern} rely();
   modifies Gamma_mem, mem;
   ensures (forall i: bv64 :: (((mem[i] == old(mem[i])) ==> (Gamma_mem[i] == old(Gamma_mem[i])))));
   ensures ((old(memory_load32_le(mem, $z_addr)) != 0bv32) ==> (memory_load32_le(mem, $z_addr) != 0bv32));
-  free ensures (memory_load8_le(mem, 1888bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1889bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1890bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1891bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1888bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69016bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69024bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69616bv64) == 1812bv64);
@@ -96,20 +89,14 @@ procedure main();
   modifies CF, Gamma_CF, Gamma_NF, Gamma_R0, Gamma_R31, Gamma_VF, Gamma_ZF, Gamma_mem, Gamma_stack, NF, R0, R31, VF, ZF, mem, stack;
   free requires (memory_load64_le(mem, 69632bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free requires (memory_load8_le(mem, 1888bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1889bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1890bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1891bv64) == 0bv8);
+  free requires (memory_load32_le(mem, 1888bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69016bv64) == 1808bv64);
   free requires (memory_load64_le(mem, 69024bv64) == 1728bv64);
   free requires (memory_load64_le(mem, 69616bv64) == 1812bv64);
   free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
   free ensures (Gamma_R31 == old(Gamma_R31));
   free ensures (R31 == old(R31));
-  free ensures (memory_load8_le(mem, 1888bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1889bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1890bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1891bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1888bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69016bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69024bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69616bv64) == 1812bv64);
diff --git a/src/test/correct/basic_sec_policy_read/gcc_O2/basic_sec_policy_read.expected b/src/test/correct/basic_sec_policy_read/gcc_O2/basic_sec_policy_read.expected
index 62e0c7e6d..1d55828ab 100644
--- a/src/test/correct/basic_sec_policy_read/gcc_O2/basic_sec_policy_read.expected
+++ b/src/test/correct/basic_sec_policy_read/gcc_O2/basic_sec_policy_read.expected
@@ -10,8 +10,8 @@ const {:extern} $x_addr: bv64;
 axiom ($x_addr == 69656bv64);
 const {:extern} $z_addr: bv64;
 axiom ($z_addr == 69652bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
-  (if (index == $z_addr) then true else (if (index == $x_addr) then (memory_load32_le(memory, $z_addr) == 0bv32) else false))
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
+  (if (index == $z_addr) then true else (if (index == $x_addr) then (memory_load32_le(mem$in, $z_addr) == 0bv32) else false))
 }
 
 function {:extern} {:bvbuiltin "bvadd"} bvadd64(bv64, bv64) returns (bv64);
@@ -29,19 +29,12 @@ function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv6
   (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
-}
-
 function {:extern} {:bvbuiltin "zero_extend 32"} zero_extend32_32(bv32) returns (bv64);
 procedure {:extern} rely();
   modifies Gamma_mem, mem;
   ensures (forall i: bv64 :: (((mem[i] == old(mem[i])) ==> (Gamma_mem[i] == old(Gamma_mem[i])))));
   ensures ((old(memory_load32_le(mem, $z_addr)) != 0bv32) ==> (memory_load32_le(mem, $z_addr) != 0bv32));
-  free ensures (memory_load8_le(mem, 1896bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1897bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1898bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1899bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1896bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69016bv64) == 1872bv64);
   free ensures (memory_load64_le(mem, 69024bv64) == 1792bv64);
   free ensures (memory_load64_le(mem, 69616bv64) == 1536bv64);
@@ -76,18 +69,12 @@ procedure main();
   modifies Gamma_R0, Gamma_R1, Gamma_R2, Gamma_mem, R0, R1, R2, mem;
   free requires (memory_load64_le(mem, 69632bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free requires (memory_load8_le(mem, 1896bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1897bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1898bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1899bv64) == 0bv8);
+  free requires (memory_load32_le(mem, 1896bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69016bv64) == 1872bv64);
   free requires (memory_load64_le(mem, 69024bv64) == 1792bv64);
   free requires (memory_load64_le(mem, 69616bv64) == 1536bv64);
   free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free ensures (memory_load8_le(mem, 1896bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1897bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1898bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1899bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1896bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69016bv64) == 1872bv64);
   free ensures (memory_load64_le(mem, 69024bv64) == 1792bv64);
   free ensures (memory_load64_le(mem, 69616bv64) == 1536bv64);
diff --git a/src/test/correct/basic_sec_policy_read/gcc_O2/basic_sec_policy_read_gtirb.expected b/src/test/correct/basic_sec_policy_read/gcc_O2/basic_sec_policy_read_gtirb.expected
index a4f5cbd03..332049bab 100644
--- a/src/test/correct/basic_sec_policy_read/gcc_O2/basic_sec_policy_read_gtirb.expected
+++ b/src/test/correct/basic_sec_policy_read/gcc_O2/basic_sec_policy_read_gtirb.expected
@@ -10,8 +10,8 @@ const {:extern} $x_addr: bv64;
 axiom ($x_addr == 69656bv64);
 const {:extern} $z_addr: bv64;
 axiom ($z_addr == 69652bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
-  (if (index == $z_addr) then true else (if (index == $x_addr) then (memory_load32_le(memory, $z_addr) == 0bv32) else false))
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
+  (if (index == $z_addr) then true else (if (index == $x_addr) then (memory_load32_le(mem$in, $z_addr) == 0bv32) else false))
 }
 
 function {:extern} {:bvbuiltin "bvadd"} bvadd64(bv64, bv64) returns (bv64);
@@ -27,19 +27,12 @@ function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv6
   (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
-}
-
 function {:extern} {:bvbuiltin "zero_extend 32"} zero_extend32_32(bv32) returns (bv64);
 procedure {:extern} rely();
   modifies Gamma_mem, mem;
   ensures (forall i: bv64 :: (((mem[i] == old(mem[i])) ==> (Gamma_mem[i] == old(Gamma_mem[i])))));
   ensures ((old(memory_load32_le(mem, $z_addr)) != 0bv32) ==> (memory_load32_le(mem, $z_addr) != 0bv32));
-  free ensures (memory_load8_le(mem, 1896bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1897bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1898bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1899bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1896bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69016bv64) == 1872bv64);
   free ensures (memory_load64_le(mem, 69024bv64) == 1792bv64);
   free ensures (memory_load64_le(mem, 69616bv64) == 1536bv64);
@@ -74,18 +67,12 @@ procedure main();
   modifies Gamma_R0, Gamma_R1, Gamma_R2, Gamma_mem, R0, R1, R2, mem;
   free requires (memory_load64_le(mem, 69632bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free requires (memory_load8_le(mem, 1896bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1897bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1898bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1899bv64) == 0bv8);
+  free requires (memory_load32_le(mem, 1896bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69016bv64) == 1872bv64);
   free requires (memory_load64_le(mem, 69024bv64) == 1792bv64);
   free requires (memory_load64_le(mem, 69616bv64) == 1536bv64);
   free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free ensures (memory_load8_le(mem, 1896bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1897bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1898bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1899bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1896bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69016bv64) == 1872bv64);
   free ensures (memory_load64_le(mem, 69024bv64) == 1792bv64);
   free ensures (memory_load64_le(mem, 69616bv64) == 1536bv64);
diff --git a/src/test/correct/basic_sec_policy_read/gcc_pic/basic_sec_policy_read.expected b/src/test/correct/basic_sec_policy_read/gcc_pic/basic_sec_policy_read.expected
index 5c536f15f..cd3bca542 100644
--- a/src/test/correct/basic_sec_policy_read/gcc_pic/basic_sec_policy_read.expected
+++ b/src/test/correct/basic_sec_policy_read/gcc_pic/basic_sec_policy_read.expected
@@ -18,8 +18,8 @@ const {:extern} $x_addr: bv64;
 axiom ($x_addr == 69652bv64);
 const {:extern} $z_addr: bv64;
 axiom ($z_addr == 69656bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
-  (if (index == $z_addr) then true else (if (index == $x_addr) then (memory_load32_le(memory, $z_addr) == 0bv32) else false))
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
+  (if (index == $z_addr) then true else (if (index == $x_addr) then (memory_load32_le(mem$in, $z_addr) == 0bv32) else false))
 }
 
 function {:extern} {:bvbuiltin "bvadd"} bvadd32(bv32, bv32) returns (bv32);
@@ -49,10 +49,6 @@ function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv6
   (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
-}
-
 function {:extern} memory_store32_le(memory: [bv64]bv8, index: bv64, value: bv32) returns ([bv64]bv8) {
   memory[index := value[8:0]][bvadd64(index, 1bv64) := value[16:8]][bvadd64(index, 2bv64) := value[24:16]][bvadd64(index, 3bv64) := value[32:24]]
 }
@@ -64,16 +60,13 @@ procedure {:extern} rely();
   modifies Gamma_mem, mem;
   ensures (forall i: bv64 :: (((mem[i] == old(mem[i])) ==> (Gamma_mem[i] == old(Gamma_mem[i])))));
   ensures ((old(memory_load32_le(mem, $z_addr)) != 0bv32) ==> (memory_load32_le(mem, $z_addr) != 0bv32));
-  free ensures (memory_load8_le(mem, 1952bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1953bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1954bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1955bv64) == 0bv8);
-  free ensures (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free ensures (memory_load64_le(mem, 69616bv64) == 1876bv64);
-  free ensures (memory_load64_le(mem, 69600bv64) == 69652bv64);
+  free ensures (memory_load32_le(mem, 1952bv64) == 131073bv32);
+  free ensures (memory_load64_le(mem, 69000bv64) == 1872bv64);
   free ensures (memory_load64_le(mem, 69008bv64) == 1792bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 69656bv64);
-  free ensures (memory_load64_le(mem, 69000bv64) == 1872bv64);
+  free ensures (memory_load64_le(mem, 69600bv64) == 69652bv64);
+  free ensures (memory_load64_le(mem, 69616bv64) == 1876bv64);
+  free ensures (memory_load64_le(mem, 69640bv64) == 69640bv64);
 
 procedure {:extern} rely_transitive();
   modifies Gamma_mem, mem;
@@ -104,28 +97,22 @@ procedure main();
   modifies CF, Gamma_CF, Gamma_NF, Gamma_R0, Gamma_R31, Gamma_VF, Gamma_ZF, Gamma_mem, Gamma_stack, NF, R0, R31, VF, ZF, mem, stack;
   free requires (memory_load64_le(mem, 69632bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free requires (memory_load8_le(mem, 1952bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1953bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1954bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1955bv64) == 0bv8);
-  free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free requires (memory_load64_le(mem, 69616bv64) == 1876bv64);
-  free requires (memory_load64_le(mem, 69600bv64) == 69652bv64);
+  free requires (memory_load32_le(mem, 1952bv64) == 131073bv32);
+  free requires (memory_load64_le(mem, 69000bv64) == 1872bv64);
   free requires (memory_load64_le(mem, 69008bv64) == 1792bv64);
   free requires (memory_load64_le(mem, 69592bv64) == 69656bv64);
-  free requires (memory_load64_le(mem, 69000bv64) == 1872bv64);
+  free requires (memory_load64_le(mem, 69600bv64) == 69652bv64);
+  free requires (memory_load64_le(mem, 69616bv64) == 1876bv64);
+  free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
   free ensures (Gamma_R31 == old(Gamma_R31));
   free ensures (R31 == old(R31));
-  free ensures (memory_load8_le(mem, 1952bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1953bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1954bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1955bv64) == 0bv8);
-  free ensures (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free ensures (memory_load64_le(mem, 69616bv64) == 1876bv64);
-  free ensures (memory_load64_le(mem, 69600bv64) == 69652bv64);
+  free ensures (memory_load32_le(mem, 1952bv64) == 131073bv32);
+  free ensures (memory_load64_le(mem, 69000bv64) == 1872bv64);
   free ensures (memory_load64_le(mem, 69008bv64) == 1792bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 69656bv64);
-  free ensures (memory_load64_le(mem, 69000bv64) == 1872bv64);
+  free ensures (memory_load64_le(mem, 69600bv64) == 69652bv64);
+  free ensures (memory_load64_le(mem, 69616bv64) == 1876bv64);
+  free ensures (memory_load64_le(mem, 69640bv64) == 69640bv64);
 
 implementation main()
 {
diff --git a/src/test/correct/basic_sec_policy_read/gcc_pic/basic_sec_policy_read_gtirb.expected b/src/test/correct/basic_sec_policy_read/gcc_pic/basic_sec_policy_read_gtirb.expected
index 9f286dc48..196da7a8f 100644
--- a/src/test/correct/basic_sec_policy_read/gcc_pic/basic_sec_policy_read_gtirb.expected
+++ b/src/test/correct/basic_sec_policy_read/gcc_pic/basic_sec_policy_read_gtirb.expected
@@ -18,8 +18,8 @@ const {:extern} $x_addr: bv64;
 axiom ($x_addr == 69652bv64);
 const {:extern} $z_addr: bv64;
 axiom ($z_addr == 69656bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
-  (if (index == $z_addr) then true else (if (index == $x_addr) then (memory_load32_le(memory, $z_addr) == 0bv32) else false))
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
+  (if (index == $z_addr) then true else (if (index == $x_addr) then (memory_load32_le(mem$in, $z_addr) == 0bv32) else false))
 }
 
 function {:extern} {:bvbuiltin "bvadd"} bvadd32(bv32, bv32) returns (bv32);
@@ -48,10 +48,6 @@ function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv6
   (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
-}
-
 function {:extern} memory_store32_le(memory: [bv64]bv8, index: bv64, value: bv32) returns ([bv64]bv8) {
   memory[index := value[8:0]][bvadd64(index, 1bv64) := value[16:8]][bvadd64(index, 2bv64) := value[24:16]][bvadd64(index, 3bv64) := value[32:24]]
 }
@@ -62,16 +58,13 @@ procedure {:extern} rely();
   modifies Gamma_mem, mem;
   ensures (forall i: bv64 :: (((mem[i] == old(mem[i])) ==> (Gamma_mem[i] == old(Gamma_mem[i])))));
   ensures ((old(memory_load32_le(mem, $z_addr)) != 0bv32) ==> (memory_load32_le(mem, $z_addr) != 0bv32));
-  free ensures (memory_load8_le(mem, 1952bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1953bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1954bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1955bv64) == 0bv8);
-  free ensures (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free ensures (memory_load64_le(mem, 69616bv64) == 1876bv64);
-  free ensures (memory_load64_le(mem, 69600bv64) == 69652bv64);
+  free ensures (memory_load32_le(mem, 1952bv64) == 131073bv32);
+  free ensures (memory_load64_le(mem, 69000bv64) == 1872bv64);
   free ensures (memory_load64_le(mem, 69008bv64) == 1792bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 69656bv64);
-  free ensures (memory_load64_le(mem, 69000bv64) == 1872bv64);
+  free ensures (memory_load64_le(mem, 69600bv64) == 69652bv64);
+  free ensures (memory_load64_le(mem, 69616bv64) == 1876bv64);
+  free ensures (memory_load64_le(mem, 69640bv64) == 69640bv64);
 
 procedure {:extern} rely_transitive();
   modifies Gamma_mem, mem;
@@ -102,28 +95,22 @@ procedure main();
   modifies CF, Gamma_CF, Gamma_NF, Gamma_R0, Gamma_R31, Gamma_VF, Gamma_ZF, Gamma_mem, Gamma_stack, NF, R0, R31, VF, ZF, mem, stack;
   free requires (memory_load64_le(mem, 69632bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free requires (memory_load8_le(mem, 1952bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1953bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1954bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1955bv64) == 0bv8);
-  free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free requires (memory_load64_le(mem, 69616bv64) == 1876bv64);
-  free requires (memory_load64_le(mem, 69600bv64) == 69652bv64);
+  free requires (memory_load32_le(mem, 1952bv64) == 131073bv32);
+  free requires (memory_load64_le(mem, 69000bv64) == 1872bv64);
   free requires (memory_load64_le(mem, 69008bv64) == 1792bv64);
   free requires (memory_load64_le(mem, 69592bv64) == 69656bv64);
-  free requires (memory_load64_le(mem, 69000bv64) == 1872bv64);
+  free requires (memory_load64_le(mem, 69600bv64) == 69652bv64);
+  free requires (memory_load64_le(mem, 69616bv64) == 1876bv64);
+  free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
   free ensures (Gamma_R31 == old(Gamma_R31));
   free ensures (R31 == old(R31));
-  free ensures (memory_load8_le(mem, 1952bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1953bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1954bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1955bv64) == 0bv8);
-  free ensures (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free ensures (memory_load64_le(mem, 69616bv64) == 1876bv64);
-  free ensures (memory_load64_le(mem, 69600bv64) == 69652bv64);
+  free ensures (memory_load32_le(mem, 1952bv64) == 131073bv32);
+  free ensures (memory_load64_le(mem, 69000bv64) == 1872bv64);
   free ensures (memory_load64_le(mem, 69008bv64) == 1792bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 69656bv64);
-  free ensures (memory_load64_le(mem, 69000bv64) == 1872bv64);
+  free ensures (memory_load64_le(mem, 69600bv64) == 69652bv64);
+  free ensures (memory_load64_le(mem, 69616bv64) == 1876bv64);
+  free ensures (memory_load64_le(mem, 69640bv64) == 69640bv64);
 
 implementation main()
 {
diff --git a/src/test/correct/basic_sec_policy_write/clang/basic_sec_policy_write.expected b/src/test/correct/basic_sec_policy_write/clang/basic_sec_policy_write.expected
index 87caaee9d..a3979b57c 100644
--- a/src/test/correct/basic_sec_policy_write/clang/basic_sec_policy_write.expected
+++ b/src/test/correct/basic_sec_policy_write/clang/basic_sec_policy_write.expected
@@ -16,8 +16,8 @@ const {:extern} $x_addr: bv64;
 axiom ($x_addr == 69688bv64);
 const {:extern} $z_addr: bv64;
 axiom ($z_addr == 69684bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
-  (if (index == $z_addr) then true else (if (index == $x_addr) then (memory_load32_le(memory, $z_addr) == 0bv32) else false))
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
+  (if (index == $z_addr) then true else (if (index == $x_addr) then (memory_load32_le(mem$in, $z_addr) == 0bv32) else false))
 }
 
 function {:extern} {:bvbuiltin "bvadd"} bvadd64(bv64, bv64) returns (bv64);
@@ -37,10 +37,6 @@ function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv6
   (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
-}
-
 function {:extern} memory_store32_le(memory: [bv64]bv8, index: bv64, value: bv32) returns ([bv64]bv8) {
   memory[index := value[8:0]][bvadd64(index, 1bv64) := value[16:8]][bvadd64(index, 2bv64) := value[24:16]][bvadd64(index, 3bv64) := value[32:24]]
 }
@@ -50,10 +46,7 @@ procedure {:extern} rely();
   modifies Gamma_mem, mem;
   ensures (forall i: bv64 :: (((mem[i] == old(mem[i])) ==> (Gamma_mem[i] == old(Gamma_mem[i])))));
   ensures (old(memory_load32_le(mem, $z_addr)) == memory_load32_le(mem, $z_addr));
-  free ensures (memory_load8_le(mem, 1888bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1889bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1890bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1891bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1888bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1812bv64);
@@ -89,20 +82,14 @@ procedure main();
   requires (Gamma_R0 == false);
   free requires (memory_load64_le(mem, 69664bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
-  free requires (memory_load8_le(mem, 1888bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1889bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1890bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1891bv64) == 0bv8);
+  free requires (memory_load32_le(mem, 1888bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free requires (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free requires (memory_load64_le(mem, 69592bv64) == 1812bv64);
   free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
   free ensures (Gamma_R31 == old(Gamma_R31));
   free ensures (R31 == old(R31));
-  free ensures (memory_load8_le(mem, 1888bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1889bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1890bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1891bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1888bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1812bv64);
diff --git a/src/test/correct/basic_sec_policy_write/clang/basic_sec_policy_write_gtirb.expected b/src/test/correct/basic_sec_policy_write/clang/basic_sec_policy_write_gtirb.expected
index 57ae9842b..9070091b0 100644
--- a/src/test/correct/basic_sec_policy_write/clang/basic_sec_policy_write_gtirb.expected
+++ b/src/test/correct/basic_sec_policy_write/clang/basic_sec_policy_write_gtirb.expected
@@ -16,8 +16,8 @@ const {:extern} $x_addr: bv64;
 axiom ($x_addr == 69688bv64);
 const {:extern} $z_addr: bv64;
 axiom ($z_addr == 69684bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
-  (if (index == $z_addr) then true else (if (index == $x_addr) then (memory_load32_le(memory, $z_addr) == 0bv32) else false))
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
+  (if (index == $z_addr) then true else (if (index == $x_addr) then (memory_load32_le(mem$in, $z_addr) == 0bv32) else false))
 }
 
 function {:extern} {:bvbuiltin "bvadd"} bvadd64(bv64, bv64) returns (bv64);
@@ -37,10 +37,6 @@ function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv6
   (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
-}
-
 function {:extern} memory_store32_le(memory: [bv64]bv8, index: bv64, value: bv32) returns ([bv64]bv8) {
   memory[index := value[8:0]][bvadd64(index, 1bv64) := value[16:8]][bvadd64(index, 2bv64) := value[24:16]][bvadd64(index, 3bv64) := value[32:24]]
 }
@@ -50,10 +46,7 @@ procedure {:extern} rely();
   modifies Gamma_mem, mem;
   ensures (forall i: bv64 :: (((mem[i] == old(mem[i])) ==> (Gamma_mem[i] == old(Gamma_mem[i])))));
   ensures (old(memory_load32_le(mem, $z_addr)) == memory_load32_le(mem, $z_addr));
-  free ensures (memory_load8_le(mem, 1888bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1889bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1890bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1891bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1888bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1812bv64);
@@ -89,20 +82,14 @@ procedure main();
   requires (Gamma_R0 == false);
   free requires (memory_load64_le(mem, 69664bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
-  free requires (memory_load8_le(mem, 1888bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1889bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1890bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1891bv64) == 0bv8);
+  free requires (memory_load32_le(mem, 1888bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free requires (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free requires (memory_load64_le(mem, 69592bv64) == 1812bv64);
   free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
   free ensures (Gamma_R31 == old(Gamma_R31));
   free ensures (R31 == old(R31));
-  free ensures (memory_load8_le(mem, 1888bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1889bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1890bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1891bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1888bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1812bv64);
diff --git a/src/test/correct/basic_sec_policy_write/clang_O2/basic_sec_policy_write.expected b/src/test/correct/basic_sec_policy_write/clang_O2/basic_sec_policy_write.expected
index 4eefb0b59..bfe1831a9 100644
--- a/src/test/correct/basic_sec_policy_write/clang_O2/basic_sec_policy_write.expected
+++ b/src/test/correct/basic_sec_policy_write/clang_O2/basic_sec_policy_write.expected
@@ -12,8 +12,8 @@ const {:extern} $x_addr: bv64;
 axiom ($x_addr == 69688bv64);
 const {:extern} $z_addr: bv64;
 axiom ($z_addr == 69684bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
-  (if (index == $z_addr) then true else (if (index == $x_addr) then (memory_load32_le(memory, $z_addr) == 0bv32) else false))
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
+  (if (index == $z_addr) then true else (if (index == $x_addr) then (memory_load32_le(mem$in, $z_addr) == 0bv32) else false))
 }
 
 function {:extern} {:bvbuiltin "bvadd"} bvadd64(bv64, bv64) returns (bv64);
@@ -33,10 +33,6 @@ function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv6
   (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
-}
-
 function {:extern} memory_store32_le(memory: [bv64]bv8, index: bv64, value: bv32) returns ([bv64]bv8) {
   memory[index := value[8:0]][bvadd64(index, 1bv64) := value[16:8]][bvadd64(index, 2bv64) := value[24:16]][bvadd64(index, 3bv64) := value[32:24]]
 }
@@ -45,10 +41,7 @@ procedure {:extern} rely();
   modifies Gamma_mem, mem;
   ensures (forall i: bv64 :: (((mem[i] == old(mem[i])) ==> (Gamma_mem[i] == old(Gamma_mem[i])))));
   ensures (old(memory_load32_le(mem, $z_addr)) == memory_load32_le(mem, $z_addr));
-  free ensures (memory_load8_le(mem, 1860bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1861bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1862bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1863bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1860bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1812bv64);
@@ -84,18 +77,12 @@ procedure main();
   requires (Gamma_R0 == false);
   free requires (memory_load64_le(mem, 69664bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
-  free requires (memory_load8_le(mem, 1860bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1861bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1862bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1863bv64) == 0bv8);
+  free requires (memory_load32_le(mem, 1860bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free requires (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free requires (memory_load64_le(mem, 69592bv64) == 1812bv64);
   free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
-  free ensures (memory_load8_le(mem, 1860bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1861bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1862bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1863bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1860bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1812bv64);
diff --git a/src/test/correct/basic_sec_policy_write/clang_O2/basic_sec_policy_write_gtirb.expected b/src/test/correct/basic_sec_policy_write/clang_O2/basic_sec_policy_write_gtirb.expected
index 9082fce74..7e4ff7591 100644
--- a/src/test/correct/basic_sec_policy_write/clang_O2/basic_sec_policy_write_gtirb.expected
+++ b/src/test/correct/basic_sec_policy_write/clang_O2/basic_sec_policy_write_gtirb.expected
@@ -12,8 +12,8 @@ const {:extern} $x_addr: bv64;
 axiom ($x_addr == 69688bv64);
 const {:extern} $z_addr: bv64;
 axiom ($z_addr == 69684bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
-  (if (index == $z_addr) then true else (if (index == $x_addr) then (memory_load32_le(memory, $z_addr) == 0bv32) else false))
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
+  (if (index == $z_addr) then true else (if (index == $x_addr) then (memory_load32_le(mem$in, $z_addr) == 0bv32) else false))
 }
 
 function {:extern} {:bvbuiltin "bvadd"} bvadd64(bv64, bv64) returns (bv64);
@@ -33,10 +33,6 @@ function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv6
   (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
-}
-
 function {:extern} memory_store32_le(memory: [bv64]bv8, index: bv64, value: bv32) returns ([bv64]bv8) {
   memory[index := value[8:0]][bvadd64(index, 1bv64) := value[16:8]][bvadd64(index, 2bv64) := value[24:16]][bvadd64(index, 3bv64) := value[32:24]]
 }
@@ -45,10 +41,7 @@ procedure {:extern} rely();
   modifies Gamma_mem, mem;
   ensures (forall i: bv64 :: (((mem[i] == old(mem[i])) ==> (Gamma_mem[i] == old(Gamma_mem[i])))));
   ensures (old(memory_load32_le(mem, $z_addr)) == memory_load32_le(mem, $z_addr));
-  free ensures (memory_load8_le(mem, 1860bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1861bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1862bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1863bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1860bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1812bv64);
@@ -84,18 +77,12 @@ procedure main();
   requires (Gamma_R0 == false);
   free requires (memory_load64_le(mem, 69664bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
-  free requires (memory_load8_le(mem, 1860bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1861bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1862bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1863bv64) == 0bv8);
+  free requires (memory_load32_le(mem, 1860bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free requires (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free requires (memory_load64_le(mem, 69592bv64) == 1812bv64);
   free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
-  free ensures (memory_load8_le(mem, 1860bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1861bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1862bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1863bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1860bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1812bv64);
diff --git a/src/test/correct/basic_sec_policy_write/clang_pic/basic_sec_policy_write.expected b/src/test/correct/basic_sec_policy_write/clang_pic/basic_sec_policy_write.expected
index 89f6dc312..f306f9dd4 100644
--- a/src/test/correct/basic_sec_policy_write/clang_pic/basic_sec_policy_write.expected
+++ b/src/test/correct/basic_sec_policy_write/clang_pic/basic_sec_policy_write.expected
@@ -16,8 +16,8 @@ const {:extern} $x_addr: bv64;
 axiom ($x_addr == 69688bv64);
 const {:extern} $z_addr: bv64;
 axiom ($z_addr == 69684bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
-  (if (index == $z_addr) then true else (if (index == $x_addr) then (memory_load32_le(memory, $z_addr) == 0bv32) else false))
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
+  (if (index == $z_addr) then true else (if (index == $x_addr) then (memory_load32_le(mem$in, $z_addr) == 0bv32) else false))
 }
 
 function {:extern} {:bvbuiltin "bvadd"} bvadd64(bv64, bv64) returns (bv64);
@@ -41,10 +41,6 @@ function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv6
   (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
-}
-
 function {:extern} memory_store32_le(memory: [bv64]bv8, index: bv64, value: bv32) returns ([bv64]bv8) {
   memory[index := value[8:0]][bvadd64(index, 1bv64) := value[16:8]][bvadd64(index, 2bv64) := value[24:16]][bvadd64(index, 3bv64) := value[32:24]]
 }
@@ -54,16 +50,13 @@ procedure {:extern} rely();
   modifies Gamma_mem, mem;
   ensures (forall i: bv64 :: (((mem[i] == old(mem[i])) ==> (Gamma_mem[i] == old(Gamma_mem[i])))));
   ensures (old(memory_load32_le(mem, $z_addr)) == memory_load32_le(mem, $z_addr));
-  free ensures (memory_load8_le(mem, 1960bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1961bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1962bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1963bv64) == 0bv8);
-  free ensures (memory_load64_le(mem, 69576bv64) == 69688bv64);
-  free ensures (memory_load64_le(mem, 69672bv64) == 69672bv64);
+  free ensures (memory_load32_le(mem, 1960bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69048bv64) == 1872bv64);
+  free ensures (memory_load64_le(mem, 69056bv64) == 1792bv64);
   free ensures (memory_load64_le(mem, 69568bv64) == 69684bv64);
+  free ensures (memory_load64_le(mem, 69576bv64) == 69688bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1876bv64);
-  free ensures (memory_load64_le(mem, 69056bv64) == 1792bv64);
+  free ensures (memory_load64_le(mem, 69672bv64) == 69672bv64);
 
 procedure {:extern} rely_transitive();
   modifies Gamma_mem, mem;
@@ -95,28 +88,22 @@ procedure main();
   requires (Gamma_R0 == false);
   free requires (memory_load64_le(mem, 69664bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
-  free requires (memory_load8_le(mem, 1960bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1961bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1962bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1963bv64) == 0bv8);
-  free requires (memory_load64_le(mem, 69576bv64) == 69688bv64);
-  free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
+  free requires (memory_load32_le(mem, 1960bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69048bv64) == 1872bv64);
+  free requires (memory_load64_le(mem, 69056bv64) == 1792bv64);
   free requires (memory_load64_le(mem, 69568bv64) == 69684bv64);
+  free requires (memory_load64_le(mem, 69576bv64) == 69688bv64);
   free requires (memory_load64_le(mem, 69592bv64) == 1876bv64);
-  free requires (memory_load64_le(mem, 69056bv64) == 1792bv64);
+  free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
   free ensures (Gamma_R31 == old(Gamma_R31));
   free ensures (R31 == old(R31));
-  free ensures (memory_load8_le(mem, 1960bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1961bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1962bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1963bv64) == 0bv8);
-  free ensures (memory_load64_le(mem, 69576bv64) == 69688bv64);
-  free ensures (memory_load64_le(mem, 69672bv64) == 69672bv64);
+  free ensures (memory_load32_le(mem, 1960bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69048bv64) == 1872bv64);
+  free ensures (memory_load64_le(mem, 69056bv64) == 1792bv64);
   free ensures (memory_load64_le(mem, 69568bv64) == 69684bv64);
+  free ensures (memory_load64_le(mem, 69576bv64) == 69688bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1876bv64);
-  free ensures (memory_load64_le(mem, 69056bv64) == 1792bv64);
+  free ensures (memory_load64_le(mem, 69672bv64) == 69672bv64);
 
 implementation main()
 {
diff --git a/src/test/correct/basic_sec_policy_write/clang_pic/basic_sec_policy_write_gtirb.expected b/src/test/correct/basic_sec_policy_write/clang_pic/basic_sec_policy_write_gtirb.expected
index 4f2b3c6e1..7bb922ca1 100644
--- a/src/test/correct/basic_sec_policy_write/clang_pic/basic_sec_policy_write_gtirb.expected
+++ b/src/test/correct/basic_sec_policy_write/clang_pic/basic_sec_policy_write_gtirb.expected
@@ -16,8 +16,8 @@ const {:extern} $x_addr: bv64;
 axiom ($x_addr == 69688bv64);
 const {:extern} $z_addr: bv64;
 axiom ($z_addr == 69684bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
-  (if (index == $z_addr) then true else (if (index == $x_addr) then (memory_load32_le(memory, $z_addr) == 0bv32) else false))
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
+  (if (index == $z_addr) then true else (if (index == $x_addr) then (memory_load32_le(mem$in, $z_addr) == 0bv32) else false))
 }
 
 function {:extern} {:bvbuiltin "bvadd"} bvadd64(bv64, bv64) returns (bv64);
@@ -41,10 +41,6 @@ function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv6
   (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
-}
-
 function {:extern} memory_store32_le(memory: [bv64]bv8, index: bv64, value: bv32) returns ([bv64]bv8) {
   memory[index := value[8:0]][bvadd64(index, 1bv64) := value[16:8]][bvadd64(index, 2bv64) := value[24:16]][bvadd64(index, 3bv64) := value[32:24]]
 }
@@ -54,16 +50,13 @@ procedure {:extern} rely();
   modifies Gamma_mem, mem;
   ensures (forall i: bv64 :: (((mem[i] == old(mem[i])) ==> (Gamma_mem[i] == old(Gamma_mem[i])))));
   ensures (old(memory_load32_le(mem, $z_addr)) == memory_load32_le(mem, $z_addr));
-  free ensures (memory_load8_le(mem, 1960bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1961bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1962bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1963bv64) == 0bv8);
-  free ensures (memory_load64_le(mem, 69576bv64) == 69688bv64);
-  free ensures (memory_load64_le(mem, 69672bv64) == 69672bv64);
+  free ensures (memory_load32_le(mem, 1960bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69048bv64) == 1872bv64);
+  free ensures (memory_load64_le(mem, 69056bv64) == 1792bv64);
   free ensures (memory_load64_le(mem, 69568bv64) == 69684bv64);
+  free ensures (memory_load64_le(mem, 69576bv64) == 69688bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1876bv64);
-  free ensures (memory_load64_le(mem, 69056bv64) == 1792bv64);
+  free ensures (memory_load64_le(mem, 69672bv64) == 69672bv64);
 
 procedure {:extern} rely_transitive();
   modifies Gamma_mem, mem;
@@ -95,28 +88,22 @@ procedure main();
   requires (Gamma_R0 == false);
   free requires (memory_load64_le(mem, 69664bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
-  free requires (memory_load8_le(mem, 1960bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1961bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1962bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1963bv64) == 0bv8);
-  free requires (memory_load64_le(mem, 69576bv64) == 69688bv64);
-  free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
+  free requires (memory_load32_le(mem, 1960bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69048bv64) == 1872bv64);
+  free requires (memory_load64_le(mem, 69056bv64) == 1792bv64);
   free requires (memory_load64_le(mem, 69568bv64) == 69684bv64);
+  free requires (memory_load64_le(mem, 69576bv64) == 69688bv64);
   free requires (memory_load64_le(mem, 69592bv64) == 1876bv64);
-  free requires (memory_load64_le(mem, 69056bv64) == 1792bv64);
+  free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
   free ensures (Gamma_R31 == old(Gamma_R31));
   free ensures (R31 == old(R31));
-  free ensures (memory_load8_le(mem, 1960bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1961bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1962bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1963bv64) == 0bv8);
-  free ensures (memory_load64_le(mem, 69576bv64) == 69688bv64);
-  free ensures (memory_load64_le(mem, 69672bv64) == 69672bv64);
+  free ensures (memory_load32_le(mem, 1960bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69048bv64) == 1872bv64);
+  free ensures (memory_load64_le(mem, 69056bv64) == 1792bv64);
   free ensures (memory_load64_le(mem, 69568bv64) == 69684bv64);
+  free ensures (memory_load64_le(mem, 69576bv64) == 69688bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1876bv64);
-  free ensures (memory_load64_le(mem, 69056bv64) == 1792bv64);
+  free ensures (memory_load64_le(mem, 69672bv64) == 69672bv64);
 
 implementation main()
 {
diff --git a/src/test/correct/basic_sec_policy_write/gcc/basic_sec_policy_write.expected b/src/test/correct/basic_sec_policy_write/gcc/basic_sec_policy_write.expected
index d0a626a88..e759f7728 100644
--- a/src/test/correct/basic_sec_policy_write/gcc/basic_sec_policy_write.expected
+++ b/src/test/correct/basic_sec_policy_write/gcc/basic_sec_policy_write.expected
@@ -12,8 +12,8 @@ const {:extern} $x_addr: bv64;
 axiom ($x_addr == 69652bv64);
 const {:extern} $z_addr: bv64;
 axiom ($z_addr == 69656bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
-  (if (index == $z_addr) then true else (if (index == $x_addr) then (memory_load32_le(memory, $z_addr) == 0bv32) else false))
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
+  (if (index == $z_addr) then true else (if (index == $x_addr) then (memory_load32_le(mem$in, $z_addr) == 0bv32) else false))
 }
 
 function {:extern} {:bvbuiltin "bvadd"} bvadd64(bv64, bv64) returns (bv64);
@@ -33,10 +33,6 @@ function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv6
   (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
-}
-
 function {:extern} memory_store32_le(memory: [bv64]bv8, index: bv64, value: bv32) returns ([bv64]bv8) {
   memory[index := value[8:0]][bvadd64(index, 1bv64) := value[16:8]][bvadd64(index, 2bv64) := value[24:16]][bvadd64(index, 3bv64) := value[32:24]]
 }
@@ -46,10 +42,7 @@ procedure {:extern} rely();
   modifies Gamma_mem, mem;
   ensures (forall i: bv64 :: (((mem[i] == old(mem[i])) ==> (Gamma_mem[i] == old(Gamma_mem[i])))));
   ensures (old(memory_load32_le(mem, $z_addr)) == memory_load32_le(mem, $z_addr));
-  free ensures (memory_load8_le(mem, 1912bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1913bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1914bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1915bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1912bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69016bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69024bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69616bv64) == 1812bv64);
@@ -85,20 +78,14 @@ procedure main();
   requires (Gamma_R0 == false);
   free requires (memory_load64_le(mem, 69632bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free requires (memory_load8_le(mem, 1912bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1913bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1914bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1915bv64) == 0bv8);
+  free requires (memory_load32_le(mem, 1912bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69016bv64) == 1808bv64);
   free requires (memory_load64_le(mem, 69024bv64) == 1728bv64);
   free requires (memory_load64_le(mem, 69616bv64) == 1812bv64);
   free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
   free ensures (Gamma_R31 == old(Gamma_R31));
   free ensures (R31 == old(R31));
-  free ensures (memory_load8_le(mem, 1912bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1913bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1914bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1915bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1912bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69016bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69024bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69616bv64) == 1812bv64);
diff --git a/src/test/correct/basic_sec_policy_write/gcc/basic_sec_policy_write_gtirb.expected b/src/test/correct/basic_sec_policy_write/gcc/basic_sec_policy_write_gtirb.expected
index c3e3810f0..7ca7ac1e3 100644
--- a/src/test/correct/basic_sec_policy_write/gcc/basic_sec_policy_write_gtirb.expected
+++ b/src/test/correct/basic_sec_policy_write/gcc/basic_sec_policy_write_gtirb.expected
@@ -12,8 +12,8 @@ const {:extern} $x_addr: bv64;
 axiom ($x_addr == 69652bv64);
 const {:extern} $z_addr: bv64;
 axiom ($z_addr == 69656bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
-  (if (index == $z_addr) then true else (if (index == $x_addr) then (memory_load32_le(memory, $z_addr) == 0bv32) else false))
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
+  (if (index == $z_addr) then true else (if (index == $x_addr) then (memory_load32_le(mem$in, $z_addr) == 0bv32) else false))
 }
 
 function {:extern} {:bvbuiltin "bvadd"} bvadd64(bv64, bv64) returns (bv64);
@@ -33,10 +33,6 @@ function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv6
   (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
-}
-
 function {:extern} memory_store32_le(memory: [bv64]bv8, index: bv64, value: bv32) returns ([bv64]bv8) {
   memory[index := value[8:0]][bvadd64(index, 1bv64) := value[16:8]][bvadd64(index, 2bv64) := value[24:16]][bvadd64(index, 3bv64) := value[32:24]]
 }
@@ -46,10 +42,7 @@ procedure {:extern} rely();
   modifies Gamma_mem, mem;
   ensures (forall i: bv64 :: (((mem[i] == old(mem[i])) ==> (Gamma_mem[i] == old(Gamma_mem[i])))));
   ensures (old(memory_load32_le(mem, $z_addr)) == memory_load32_le(mem, $z_addr));
-  free ensures (memory_load8_le(mem, 1912bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1913bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1914bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1915bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1912bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69016bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69024bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69616bv64) == 1812bv64);
@@ -85,20 +78,14 @@ procedure main();
   requires (Gamma_R0 == false);
   free requires (memory_load64_le(mem, 69632bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free requires (memory_load8_le(mem, 1912bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1913bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1914bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1915bv64) == 0bv8);
+  free requires (memory_load32_le(mem, 1912bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69016bv64) == 1808bv64);
   free requires (memory_load64_le(mem, 69024bv64) == 1728bv64);
   free requires (memory_load64_le(mem, 69616bv64) == 1812bv64);
   free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
   free ensures (Gamma_R31 == old(Gamma_R31));
   free ensures (R31 == old(R31));
-  free ensures (memory_load8_le(mem, 1912bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1913bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1914bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1915bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1912bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69016bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69024bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69616bv64) == 1812bv64);
diff --git a/src/test/correct/basic_sec_policy_write/gcc_O2/basic_sec_policy_write.expected b/src/test/correct/basic_sec_policy_write/gcc_O2/basic_sec_policy_write.expected
index 3555af022..77502d30d 100644
--- a/src/test/correct/basic_sec_policy_write/gcc_O2/basic_sec_policy_write.expected
+++ b/src/test/correct/basic_sec_policy_write/gcc_O2/basic_sec_policy_write.expected
@@ -12,8 +12,8 @@ const {:extern} $x_addr: bv64;
 axiom ($x_addr == 69652bv64);
 const {:extern} $z_addr: bv64;
 axiom ($z_addr == 69656bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
-  (if (index == $z_addr) then true else (if (index == $x_addr) then (memory_load32_le(memory, $z_addr) == 0bv32) else false))
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
+  (if (index == $z_addr) then true else (if (index == $x_addr) then (memory_load32_le(mem$in, $z_addr) == 0bv32) else false))
 }
 
 function {:extern} {:bvbuiltin "bvadd"} bvadd64(bv64, bv64) returns (bv64);
@@ -33,10 +33,6 @@ function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv6
   (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
-}
-
 function {:extern} memory_store32_le(memory: [bv64]bv8, index: bv64, value: bv32) returns ([bv64]bv8) {
   memory[index := value[8:0]][bvadd64(index, 1bv64) := value[16:8]][bvadd64(index, 2bv64) := value[24:16]][bvadd64(index, 3bv64) := value[32:24]]
 }
@@ -45,10 +41,7 @@ procedure {:extern} rely();
   modifies Gamma_mem, mem;
   ensures (forall i: bv64 :: (((mem[i] == old(mem[i])) ==> (Gamma_mem[i] == old(Gamma_mem[i])))));
   ensures (old(memory_load32_le(mem, $z_addr)) == memory_load32_le(mem, $z_addr));
-  free ensures (memory_load8_le(mem, 1896bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1897bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1898bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1899bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1896bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69016bv64) == 1872bv64);
   free ensures (memory_load64_le(mem, 69024bv64) == 1792bv64);
   free ensures (memory_load64_le(mem, 69616bv64) == 1536bv64);
@@ -84,18 +77,12 @@ procedure main();
   requires (Gamma_R0 == false);
   free requires (memory_load64_le(mem, 69632bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free requires (memory_load8_le(mem, 1896bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1897bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1898bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1899bv64) == 0bv8);
+  free requires (memory_load32_le(mem, 1896bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69016bv64) == 1872bv64);
   free requires (memory_load64_le(mem, 69024bv64) == 1792bv64);
   free requires (memory_load64_le(mem, 69616bv64) == 1536bv64);
   free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free ensures (memory_load8_le(mem, 1896bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1897bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1898bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1899bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1896bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69016bv64) == 1872bv64);
   free ensures (memory_load64_le(mem, 69024bv64) == 1792bv64);
   free ensures (memory_load64_le(mem, 69616bv64) == 1536bv64);
diff --git a/src/test/correct/basic_sec_policy_write/gcc_O2/basic_sec_policy_write_gtirb.expected b/src/test/correct/basic_sec_policy_write/gcc_O2/basic_sec_policy_write_gtirb.expected
index e7ca31254..f1873f412 100644
--- a/src/test/correct/basic_sec_policy_write/gcc_O2/basic_sec_policy_write_gtirb.expected
+++ b/src/test/correct/basic_sec_policy_write/gcc_O2/basic_sec_policy_write_gtirb.expected
@@ -12,8 +12,8 @@ const {:extern} $x_addr: bv64;
 axiom ($x_addr == 69652bv64);
 const {:extern} $z_addr: bv64;
 axiom ($z_addr == 69656bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
-  (if (index == $z_addr) then true else (if (index == $x_addr) then (memory_load32_le(memory, $z_addr) == 0bv32) else false))
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
+  (if (index == $z_addr) then true else (if (index == $x_addr) then (memory_load32_le(mem$in, $z_addr) == 0bv32) else false))
 }
 
 function {:extern} {:bvbuiltin "bvadd"} bvadd64(bv64, bv64) returns (bv64);
@@ -33,10 +33,6 @@ function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv6
   (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
-}
-
 function {:extern} memory_store32_le(memory: [bv64]bv8, index: bv64, value: bv32) returns ([bv64]bv8) {
   memory[index := value[8:0]][bvadd64(index, 1bv64) := value[16:8]][bvadd64(index, 2bv64) := value[24:16]][bvadd64(index, 3bv64) := value[32:24]]
 }
@@ -45,10 +41,7 @@ procedure {:extern} rely();
   modifies Gamma_mem, mem;
   ensures (forall i: bv64 :: (((mem[i] == old(mem[i])) ==> (Gamma_mem[i] == old(Gamma_mem[i])))));
   ensures (old(memory_load32_le(mem, $z_addr)) == memory_load32_le(mem, $z_addr));
-  free ensures (memory_load8_le(mem, 1896bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1897bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1898bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1899bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1896bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69016bv64) == 1872bv64);
   free ensures (memory_load64_le(mem, 69024bv64) == 1792bv64);
   free ensures (memory_load64_le(mem, 69616bv64) == 1536bv64);
@@ -84,18 +77,12 @@ procedure main();
   requires (Gamma_R0 == false);
   free requires (memory_load64_le(mem, 69632bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free requires (memory_load8_le(mem, 1896bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1897bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1898bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1899bv64) == 0bv8);
+  free requires (memory_load32_le(mem, 1896bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69016bv64) == 1872bv64);
   free requires (memory_load64_le(mem, 69024bv64) == 1792bv64);
   free requires (memory_load64_le(mem, 69616bv64) == 1536bv64);
   free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free ensures (memory_load8_le(mem, 1896bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1897bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1898bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1899bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1896bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69016bv64) == 1872bv64);
   free ensures (memory_load64_le(mem, 69024bv64) == 1792bv64);
   free ensures (memory_load64_le(mem, 69616bv64) == 1536bv64);
diff --git a/src/test/correct/basic_sec_policy_write/gcc_pic/basic_sec_policy_write.expected b/src/test/correct/basic_sec_policy_write/gcc_pic/basic_sec_policy_write.expected
index bddbe8673..aa7a508bf 100644
--- a/src/test/correct/basic_sec_policy_write/gcc_pic/basic_sec_policy_write.expected
+++ b/src/test/correct/basic_sec_policy_write/gcc_pic/basic_sec_policy_write.expected
@@ -12,8 +12,8 @@ const {:extern} $x_addr: bv64;
 axiom ($x_addr == 69652bv64);
 const {:extern} $z_addr: bv64;
 axiom ($z_addr == 69656bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
-  (if (index == $z_addr) then true else (if (index == $x_addr) then (memory_load32_le(memory, $z_addr) == 0bv32) else false))
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
+  (if (index == $z_addr) then true else (if (index == $x_addr) then (memory_load32_le(mem$in, $z_addr) == 0bv32) else false))
 }
 
 function {:extern} {:bvbuiltin "bvadd"} bvadd64(bv64, bv64) returns (bv64);
@@ -37,10 +37,6 @@ function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv6
   (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
-}
-
 function {:extern} memory_store32_le(memory: [bv64]bv8, index: bv64, value: bv32) returns ([bv64]bv8) {
   memory[index := value[8:0]][bvadd64(index, 1bv64) := value[16:8]][bvadd64(index, 2bv64) := value[24:16]][bvadd64(index, 3bv64) := value[32:24]]
 }
@@ -50,16 +46,13 @@ procedure {:extern} rely();
   modifies Gamma_mem, mem;
   ensures (forall i: bv64 :: (((mem[i] == old(mem[i])) ==> (Gamma_mem[i] == old(Gamma_mem[i])))));
   ensures (old(memory_load32_le(mem, $z_addr)) == memory_load32_le(mem, $z_addr));
-  free ensures (memory_load8_le(mem, 1976bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1977bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1978bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1979bv64) == 0bv8);
-  free ensures (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free ensures (memory_load64_le(mem, 69616bv64) == 1876bv64);
-  free ensures (memory_load64_le(mem, 69600bv64) == 69652bv64);
+  free ensures (memory_load32_le(mem, 1976bv64) == 131073bv32);
+  free ensures (memory_load64_le(mem, 69000bv64) == 1872bv64);
   free ensures (memory_load64_le(mem, 69008bv64) == 1792bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 69656bv64);
-  free ensures (memory_load64_le(mem, 69000bv64) == 1872bv64);
+  free ensures (memory_load64_le(mem, 69600bv64) == 69652bv64);
+  free ensures (memory_load64_le(mem, 69616bv64) == 1876bv64);
+  free ensures (memory_load64_le(mem, 69640bv64) == 69640bv64);
 
 procedure {:extern} rely_transitive();
   modifies Gamma_mem, mem;
@@ -91,28 +84,22 @@ procedure main();
   requires (Gamma_R0 == false);
   free requires (memory_load64_le(mem, 69632bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free requires (memory_load8_le(mem, 1976bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1977bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1978bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1979bv64) == 0bv8);
-  free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free requires (memory_load64_le(mem, 69616bv64) == 1876bv64);
-  free requires (memory_load64_le(mem, 69600bv64) == 69652bv64);
+  free requires (memory_load32_le(mem, 1976bv64) == 131073bv32);
+  free requires (memory_load64_le(mem, 69000bv64) == 1872bv64);
   free requires (memory_load64_le(mem, 69008bv64) == 1792bv64);
   free requires (memory_load64_le(mem, 69592bv64) == 69656bv64);
-  free requires (memory_load64_le(mem, 69000bv64) == 1872bv64);
+  free requires (memory_load64_le(mem, 69600bv64) == 69652bv64);
+  free requires (memory_load64_le(mem, 69616bv64) == 1876bv64);
+  free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
   free ensures (Gamma_R31 == old(Gamma_R31));
   free ensures (R31 == old(R31));
-  free ensures (memory_load8_le(mem, 1976bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1977bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1978bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1979bv64) == 0bv8);
-  free ensures (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free ensures (memory_load64_le(mem, 69616bv64) == 1876bv64);
-  free ensures (memory_load64_le(mem, 69600bv64) == 69652bv64);
+  free ensures (memory_load32_le(mem, 1976bv64) == 131073bv32);
+  free ensures (memory_load64_le(mem, 69000bv64) == 1872bv64);
   free ensures (memory_load64_le(mem, 69008bv64) == 1792bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 69656bv64);
-  free ensures (memory_load64_le(mem, 69000bv64) == 1872bv64);
+  free ensures (memory_load64_le(mem, 69600bv64) == 69652bv64);
+  free ensures (memory_load64_le(mem, 69616bv64) == 1876bv64);
+  free ensures (memory_load64_le(mem, 69640bv64) == 69640bv64);
 
 implementation main()
 {
diff --git a/src/test/correct/basic_sec_policy_write/gcc_pic/basic_sec_policy_write_gtirb.expected b/src/test/correct/basic_sec_policy_write/gcc_pic/basic_sec_policy_write_gtirb.expected
index fec869bf6..700334cdf 100644
--- a/src/test/correct/basic_sec_policy_write/gcc_pic/basic_sec_policy_write_gtirb.expected
+++ b/src/test/correct/basic_sec_policy_write/gcc_pic/basic_sec_policy_write_gtirb.expected
@@ -12,8 +12,8 @@ const {:extern} $x_addr: bv64;
 axiom ($x_addr == 69652bv64);
 const {:extern} $z_addr: bv64;
 axiom ($z_addr == 69656bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
-  (if (index == $z_addr) then true else (if (index == $x_addr) then (memory_load32_le(memory, $z_addr) == 0bv32) else false))
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
+  (if (index == $z_addr) then true else (if (index == $x_addr) then (memory_load32_le(mem$in, $z_addr) == 0bv32) else false))
 }
 
 function {:extern} {:bvbuiltin "bvadd"} bvadd64(bv64, bv64) returns (bv64);
@@ -37,10 +37,6 @@ function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv6
   (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
-}
-
 function {:extern} memory_store32_le(memory: [bv64]bv8, index: bv64, value: bv32) returns ([bv64]bv8) {
   memory[index := value[8:0]][bvadd64(index, 1bv64) := value[16:8]][bvadd64(index, 2bv64) := value[24:16]][bvadd64(index, 3bv64) := value[32:24]]
 }
@@ -50,16 +46,13 @@ procedure {:extern} rely();
   modifies Gamma_mem, mem;
   ensures (forall i: bv64 :: (((mem[i] == old(mem[i])) ==> (Gamma_mem[i] == old(Gamma_mem[i])))));
   ensures (old(memory_load32_le(mem, $z_addr)) == memory_load32_le(mem, $z_addr));
-  free ensures (memory_load8_le(mem, 1976bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1977bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1978bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1979bv64) == 0bv8);
-  free ensures (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free ensures (memory_load64_le(mem, 69616bv64) == 1876bv64);
-  free ensures (memory_load64_le(mem, 69600bv64) == 69652bv64);
+  free ensures (memory_load32_le(mem, 1976bv64) == 131073bv32);
+  free ensures (memory_load64_le(mem, 69000bv64) == 1872bv64);
   free ensures (memory_load64_le(mem, 69008bv64) == 1792bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 69656bv64);
-  free ensures (memory_load64_le(mem, 69000bv64) == 1872bv64);
+  free ensures (memory_load64_le(mem, 69600bv64) == 69652bv64);
+  free ensures (memory_load64_le(mem, 69616bv64) == 1876bv64);
+  free ensures (memory_load64_le(mem, 69640bv64) == 69640bv64);
 
 procedure {:extern} rely_transitive();
   modifies Gamma_mem, mem;
@@ -91,28 +84,22 @@ procedure main();
   requires (Gamma_R0 == false);
   free requires (memory_load64_le(mem, 69632bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free requires (memory_load8_le(mem, 1976bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1977bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1978bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1979bv64) == 0bv8);
-  free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free requires (memory_load64_le(mem, 69616bv64) == 1876bv64);
-  free requires (memory_load64_le(mem, 69600bv64) == 69652bv64);
+  free requires (memory_load32_le(mem, 1976bv64) == 131073bv32);
+  free requires (memory_load64_le(mem, 69000bv64) == 1872bv64);
   free requires (memory_load64_le(mem, 69008bv64) == 1792bv64);
   free requires (memory_load64_le(mem, 69592bv64) == 69656bv64);
-  free requires (memory_load64_le(mem, 69000bv64) == 1872bv64);
+  free requires (memory_load64_le(mem, 69600bv64) == 69652bv64);
+  free requires (memory_load64_le(mem, 69616bv64) == 1876bv64);
+  free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
   free ensures (Gamma_R31 == old(Gamma_R31));
   free ensures (R31 == old(R31));
-  free ensures (memory_load8_le(mem, 1976bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1977bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1978bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1979bv64) == 0bv8);
-  free ensures (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free ensures (memory_load64_le(mem, 69616bv64) == 1876bv64);
-  free ensures (memory_load64_le(mem, 69600bv64) == 69652bv64);
+  free ensures (memory_load32_le(mem, 1976bv64) == 131073bv32);
+  free ensures (memory_load64_le(mem, 69000bv64) == 1872bv64);
   free ensures (memory_load64_le(mem, 69008bv64) == 1792bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 69656bv64);
-  free ensures (memory_load64_le(mem, 69000bv64) == 1872bv64);
+  free ensures (memory_load64_le(mem, 69600bv64) == 69652bv64);
+  free ensures (memory_load64_le(mem, 69616bv64) == 1876bv64);
+  free ensures (memory_load64_le(mem, 69640bv64) == 69640bv64);
 
 implementation main()
 {
diff --git a/src/test/correct/basicassign_gamma0/clang/basicassign_gamma0.expected b/src/test/correct/basicassign_gamma0/clang/basicassign_gamma0.expected
index 90c2af906..665a042aa 100644
--- a/src/test/correct/basicassign_gamma0/clang/basicassign_gamma0.expected
+++ b/src/test/correct/basicassign_gamma0/clang/basicassign_gamma0.expected
@@ -10,7 +10,7 @@ const {:extern} $secret_addr: bv64;
 axiom ($secret_addr == 69684bv64);
 const {:extern} $x_addr: bv64;
 axiom ($x_addr == 69688bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
   (if (index == $x_addr) then true else (if (index == $secret_addr) then false else false))
 }
 
@@ -31,10 +31,6 @@ function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv6
   (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
-}
-
 function {:extern} memory_store32_le(memory: [bv64]bv8, index: bv64, value: bv32) returns ([bv64]bv8) {
   memory[index := value[8:0]][bvadd64(index, 1bv64) := value[16:8]][bvadd64(index, 2bv64) := value[24:16]][bvadd64(index, 3bv64) := value[32:24]]
 }
@@ -44,10 +40,7 @@ procedure {:extern} rely();
   modifies Gamma_mem, mem;
   ensures (forall i: bv64 :: (((mem[i] == old(mem[i])) ==> (Gamma_mem[i] == old(Gamma_mem[i])))));
   ensures (memory_load32_le(mem, $secret_addr) == old(memory_load32_le(mem, $secret_addr)));
-  free ensures (memory_load8_le(mem, 1856bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1857bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1858bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1859bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1856bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1812bv64);
@@ -78,18 +71,12 @@ procedure main();
   requires (gamma_load32(Gamma_mem, $secret_addr) == true);
   free requires (memory_load64_le(mem, 69664bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
-  free requires (memory_load8_le(mem, 1856bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1857bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1858bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1859bv64) == 0bv8);
+  free requires (memory_load32_le(mem, 1856bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free requires (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free requires (memory_load64_le(mem, 69592bv64) == 1812bv64);
   free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
-  free ensures (memory_load8_le(mem, 1856bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1857bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1858bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1859bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1856bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1812bv64);
diff --git a/src/test/correct/basicassign_gamma0/clang/basicassign_gamma0_gtirb.expected b/src/test/correct/basicassign_gamma0/clang/basicassign_gamma0_gtirb.expected
index 84d1b7a26..08553b2a1 100644
--- a/src/test/correct/basicassign_gamma0/clang/basicassign_gamma0_gtirb.expected
+++ b/src/test/correct/basicassign_gamma0/clang/basicassign_gamma0_gtirb.expected
@@ -10,7 +10,7 @@ const {:extern} $secret_addr: bv64;
 axiom ($secret_addr == 69684bv64);
 const {:extern} $x_addr: bv64;
 axiom ($x_addr == 69688bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
   (if (index == $x_addr) then true else (if (index == $secret_addr) then false else false))
 }
 
@@ -31,10 +31,6 @@ function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv6
   (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
-}
-
 function {:extern} memory_store32_le(memory: [bv64]bv8, index: bv64, value: bv32) returns ([bv64]bv8) {
   memory[index := value[8:0]][bvadd64(index, 1bv64) := value[16:8]][bvadd64(index, 2bv64) := value[24:16]][bvadd64(index, 3bv64) := value[32:24]]
 }
@@ -44,10 +40,7 @@ procedure {:extern} rely();
   modifies Gamma_mem, mem;
   ensures (forall i: bv64 :: (((mem[i] == old(mem[i])) ==> (Gamma_mem[i] == old(Gamma_mem[i])))));
   ensures (memory_load32_le(mem, $secret_addr) == old(memory_load32_le(mem, $secret_addr)));
-  free ensures (memory_load8_le(mem, 1856bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1857bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1858bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1859bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1856bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1812bv64);
@@ -78,18 +71,12 @@ procedure main();
   requires (gamma_load32(Gamma_mem, $secret_addr) == true);
   free requires (memory_load64_le(mem, 69664bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
-  free requires (memory_load8_le(mem, 1856bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1857bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1858bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1859bv64) == 0bv8);
+  free requires (memory_load32_le(mem, 1856bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free requires (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free requires (memory_load64_le(mem, 69592bv64) == 1812bv64);
   free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
-  free ensures (memory_load8_le(mem, 1856bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1857bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1858bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1859bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1856bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1812bv64);
diff --git a/src/test/correct/basicassign_gamma0/clang_pic/basicassign_gamma0.expected b/src/test/correct/basicassign_gamma0/clang_pic/basicassign_gamma0.expected
index c6b1cbea4..ca1f84813 100644
--- a/src/test/correct/basicassign_gamma0/clang_pic/basicassign_gamma0.expected
+++ b/src/test/correct/basicassign_gamma0/clang_pic/basicassign_gamma0.expected
@@ -10,7 +10,7 @@ const {:extern} $secret_addr: bv64;
 axiom ($secret_addr == 69684bv64);
 const {:extern} $x_addr: bv64;
 axiom ($x_addr == 69688bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
   (if (index == $x_addr) then true else (if (index == $secret_addr) then false else false))
 }
 
@@ -35,10 +35,6 @@ function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv6
   (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
-}
-
 function {:extern} memory_store32_le(memory: [bv64]bv8, index: bv64, value: bv32) returns ([bv64]bv8) {
   memory[index := value[8:0]][bvadd64(index, 1bv64) := value[16:8]][bvadd64(index, 2bv64) := value[24:16]][bvadd64(index, 3bv64) := value[32:24]]
 }
@@ -48,16 +44,13 @@ procedure {:extern} rely();
   modifies Gamma_mem, mem;
   ensures (forall i: bv64 :: (((mem[i] == old(mem[i])) ==> (Gamma_mem[i] == old(Gamma_mem[i])))));
   ensures (memory_load32_le(mem, $secret_addr) == old(memory_load32_le(mem, $secret_addr)));
-  free ensures (memory_load8_le(mem, 1928bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1929bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1930bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1931bv64) == 0bv8);
-  free ensures (memory_load64_le(mem, 69672bv64) == 69672bv64);
-  free ensures (memory_load64_le(mem, 69584bv64) == 69684bv64);
+  free ensures (memory_load32_le(mem, 1928bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69048bv64) == 1872bv64);
+  free ensures (memory_load64_le(mem, 69056bv64) == 1792bv64);
   free ensures (memory_load64_le(mem, 69568bv64) == 69688bv64);
+  free ensures (memory_load64_le(mem, 69584bv64) == 69684bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1876bv64);
-  free ensures (memory_load64_le(mem, 69056bv64) == 1792bv64);
+  free ensures (memory_load64_le(mem, 69672bv64) == 69672bv64);
 
 procedure {:extern} rely_transitive();
   modifies Gamma_mem, mem;
@@ -84,26 +77,20 @@ procedure main();
   requires (gamma_load32(Gamma_mem, $secret_addr) == true);
   free requires (memory_load64_le(mem, 69664bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
-  free requires (memory_load8_le(mem, 1928bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1929bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1930bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1931bv64) == 0bv8);
-  free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
-  free requires (memory_load64_le(mem, 69584bv64) == 69684bv64);
+  free requires (memory_load32_le(mem, 1928bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69048bv64) == 1872bv64);
+  free requires (memory_load64_le(mem, 69056bv64) == 1792bv64);
   free requires (memory_load64_le(mem, 69568bv64) == 69688bv64);
+  free requires (memory_load64_le(mem, 69584bv64) == 69684bv64);
   free requires (memory_load64_le(mem, 69592bv64) == 1876bv64);
-  free requires (memory_load64_le(mem, 69056bv64) == 1792bv64);
-  free ensures (memory_load8_le(mem, 1928bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1929bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1930bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1931bv64) == 0bv8);
-  free ensures (memory_load64_le(mem, 69672bv64) == 69672bv64);
-  free ensures (memory_load64_le(mem, 69584bv64) == 69684bv64);
+  free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
+  free ensures (memory_load32_le(mem, 1928bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69048bv64) == 1872bv64);
+  free ensures (memory_load64_le(mem, 69056bv64) == 1792bv64);
   free ensures (memory_load64_le(mem, 69568bv64) == 69688bv64);
+  free ensures (memory_load64_le(mem, 69584bv64) == 69684bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1876bv64);
-  free ensures (memory_load64_le(mem, 69056bv64) == 1792bv64);
+  free ensures (memory_load64_le(mem, 69672bv64) == 69672bv64);
 
 implementation main()
 {
diff --git a/src/test/correct/basicassign_gamma0/clang_pic/basicassign_gamma0_gtirb.expected b/src/test/correct/basicassign_gamma0/clang_pic/basicassign_gamma0_gtirb.expected
index e8be112ec..011c7af6c 100644
--- a/src/test/correct/basicassign_gamma0/clang_pic/basicassign_gamma0_gtirb.expected
+++ b/src/test/correct/basicassign_gamma0/clang_pic/basicassign_gamma0_gtirb.expected
@@ -10,7 +10,7 @@ const {:extern} $secret_addr: bv64;
 axiom ($secret_addr == 69684bv64);
 const {:extern} $x_addr: bv64;
 axiom ($x_addr == 69688bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
   (if (index == $x_addr) then true else (if (index == $secret_addr) then false else false))
 }
 
@@ -35,10 +35,6 @@ function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv6
   (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
-}
-
 function {:extern} memory_store32_le(memory: [bv64]bv8, index: bv64, value: bv32) returns ([bv64]bv8) {
   memory[index := value[8:0]][bvadd64(index, 1bv64) := value[16:8]][bvadd64(index, 2bv64) := value[24:16]][bvadd64(index, 3bv64) := value[32:24]]
 }
@@ -48,16 +44,13 @@ procedure {:extern} rely();
   modifies Gamma_mem, mem;
   ensures (forall i: bv64 :: (((mem[i] == old(mem[i])) ==> (Gamma_mem[i] == old(Gamma_mem[i])))));
   ensures (memory_load32_le(mem, $secret_addr) == old(memory_load32_le(mem, $secret_addr)));
-  free ensures (memory_load8_le(mem, 1928bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1929bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1930bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1931bv64) == 0bv8);
-  free ensures (memory_load64_le(mem, 69672bv64) == 69672bv64);
-  free ensures (memory_load64_le(mem, 69584bv64) == 69684bv64);
+  free ensures (memory_load32_le(mem, 1928bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69048bv64) == 1872bv64);
+  free ensures (memory_load64_le(mem, 69056bv64) == 1792bv64);
   free ensures (memory_load64_le(mem, 69568bv64) == 69688bv64);
+  free ensures (memory_load64_le(mem, 69584bv64) == 69684bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1876bv64);
-  free ensures (memory_load64_le(mem, 69056bv64) == 1792bv64);
+  free ensures (memory_load64_le(mem, 69672bv64) == 69672bv64);
 
 procedure {:extern} rely_transitive();
   modifies Gamma_mem, mem;
@@ -84,26 +77,20 @@ procedure main();
   requires (gamma_load32(Gamma_mem, $secret_addr) == true);
   free requires (memory_load64_le(mem, 69664bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
-  free requires (memory_load8_le(mem, 1928bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1929bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1930bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1931bv64) == 0bv8);
-  free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
-  free requires (memory_load64_le(mem, 69584bv64) == 69684bv64);
+  free requires (memory_load32_le(mem, 1928bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69048bv64) == 1872bv64);
+  free requires (memory_load64_le(mem, 69056bv64) == 1792bv64);
   free requires (memory_load64_le(mem, 69568bv64) == 69688bv64);
+  free requires (memory_load64_le(mem, 69584bv64) == 69684bv64);
   free requires (memory_load64_le(mem, 69592bv64) == 1876bv64);
-  free requires (memory_load64_le(mem, 69056bv64) == 1792bv64);
-  free ensures (memory_load8_le(mem, 1928bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1929bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1930bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1931bv64) == 0bv8);
-  free ensures (memory_load64_le(mem, 69672bv64) == 69672bv64);
-  free ensures (memory_load64_le(mem, 69584bv64) == 69684bv64);
+  free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
+  free ensures (memory_load32_le(mem, 1928bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69048bv64) == 1872bv64);
+  free ensures (memory_load64_le(mem, 69056bv64) == 1792bv64);
   free ensures (memory_load64_le(mem, 69568bv64) == 69688bv64);
+  free ensures (memory_load64_le(mem, 69584bv64) == 69684bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1876bv64);
-  free ensures (memory_load64_le(mem, 69056bv64) == 1792bv64);
+  free ensures (memory_load64_le(mem, 69672bv64) == 69672bv64);
 
 implementation main()
 {
diff --git a/src/test/correct/basicassign_gamma0/gcc/basicassign_gamma0.expected b/src/test/correct/basicassign_gamma0/gcc/basicassign_gamma0.expected
index da167b58a..360bde82a 100644
--- a/src/test/correct/basicassign_gamma0/gcc/basicassign_gamma0.expected
+++ b/src/test/correct/basicassign_gamma0/gcc/basicassign_gamma0.expected
@@ -8,7 +8,7 @@ const {:extern} $secret_addr: bv64;
 axiom ($secret_addr == 69656bv64);
 const {:extern} $x_addr: bv64;
 axiom ($x_addr == 69652bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
   (if (index == $x_addr) then true else (if (index == $secret_addr) then false else false))
 }
 
@@ -29,10 +29,6 @@ function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv6
   (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
-}
-
 function {:extern} memory_store32_le(memory: [bv64]bv8, index: bv64, value: bv32) returns ([bv64]bv8) {
   memory[index := value[8:0]][bvadd64(index, 1bv64) := value[16:8]][bvadd64(index, 2bv64) := value[24:16]][bvadd64(index, 3bv64) := value[32:24]]
 }
@@ -42,10 +38,7 @@ procedure {:extern} rely();
   modifies Gamma_mem, mem;
   ensures (forall i: bv64 :: (((mem[i] == old(mem[i])) ==> (Gamma_mem[i] == old(Gamma_mem[i])))));
   ensures (memory_load32_le(mem, $secret_addr) == old(memory_load32_le(mem, $secret_addr)));
-  free ensures (memory_load8_le(mem, 1864bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1865bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1866bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1867bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1864bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69016bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69024bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69616bv64) == 1812bv64);
@@ -76,18 +69,12 @@ procedure main();
   requires (gamma_load32(Gamma_mem, $secret_addr) == true);
   free requires (memory_load64_le(mem, 69632bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free requires (memory_load8_le(mem, 1864bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1865bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1866bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1867bv64) == 0bv8);
+  free requires (memory_load32_le(mem, 1864bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69016bv64) == 1808bv64);
   free requires (memory_load64_le(mem, 69024bv64) == 1728bv64);
   free requires (memory_load64_le(mem, 69616bv64) == 1812bv64);
   free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free ensures (memory_load8_le(mem, 1864bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1865bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1866bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1867bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1864bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69016bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69024bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69616bv64) == 1812bv64);
diff --git a/src/test/correct/basicassign_gamma0/gcc/basicassign_gamma0_gtirb.expected b/src/test/correct/basicassign_gamma0/gcc/basicassign_gamma0_gtirb.expected
index f94eea40c..8e56ac1a2 100644
--- a/src/test/correct/basicassign_gamma0/gcc/basicassign_gamma0_gtirb.expected
+++ b/src/test/correct/basicassign_gamma0/gcc/basicassign_gamma0_gtirb.expected
@@ -8,7 +8,7 @@ const {:extern} $secret_addr: bv64;
 axiom ($secret_addr == 69656bv64);
 const {:extern} $x_addr: bv64;
 axiom ($x_addr == 69652bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
   (if (index == $x_addr) then true else (if (index == $secret_addr) then false else false))
 }
 
@@ -29,10 +29,6 @@ function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv6
   (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
-}
-
 function {:extern} memory_store32_le(memory: [bv64]bv8, index: bv64, value: bv32) returns ([bv64]bv8) {
   memory[index := value[8:0]][bvadd64(index, 1bv64) := value[16:8]][bvadd64(index, 2bv64) := value[24:16]][bvadd64(index, 3bv64) := value[32:24]]
 }
@@ -42,10 +38,7 @@ procedure {:extern} rely();
   modifies Gamma_mem, mem;
   ensures (forall i: bv64 :: (((mem[i] == old(mem[i])) ==> (Gamma_mem[i] == old(Gamma_mem[i])))));
   ensures (memory_load32_le(mem, $secret_addr) == old(memory_load32_le(mem, $secret_addr)));
-  free ensures (memory_load8_le(mem, 1864bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1865bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1866bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1867bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1864bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69016bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69024bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69616bv64) == 1812bv64);
@@ -76,18 +69,12 @@ procedure main();
   requires (gamma_load32(Gamma_mem, $secret_addr) == true);
   free requires (memory_load64_le(mem, 69632bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free requires (memory_load8_le(mem, 1864bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1865bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1866bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1867bv64) == 0bv8);
+  free requires (memory_load32_le(mem, 1864bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69016bv64) == 1808bv64);
   free requires (memory_load64_le(mem, 69024bv64) == 1728bv64);
   free requires (memory_load64_le(mem, 69616bv64) == 1812bv64);
   free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free ensures (memory_load8_le(mem, 1864bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1865bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1866bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1867bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1864bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69016bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69024bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69616bv64) == 1812bv64);
diff --git a/src/test/correct/basicassign_gamma0/gcc_O2/basicassign_gamma0.expected b/src/test/correct/basicassign_gamma0/gcc_O2/basicassign_gamma0.expected
index 23e72c990..a6c4c2b09 100644
--- a/src/test/correct/basicassign_gamma0/gcc_O2/basicassign_gamma0.expected
+++ b/src/test/correct/basicassign_gamma0/gcc_O2/basicassign_gamma0.expected
@@ -10,7 +10,7 @@ const {:extern} $secret_addr: bv64;
 axiom ($secret_addr == 69656bv64);
 const {:extern} $x_addr: bv64;
 axiom ($x_addr == 69652bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
   (if (index == $x_addr) then true else (if (index == $secret_addr) then false else false))
 }
 
@@ -31,10 +31,6 @@ function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv6
   (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
-}
-
 function {:extern} memory_store32_le(memory: [bv64]bv8, index: bv64, value: bv32) returns ([bv64]bv8) {
   memory[index := value[8:0]][bvadd64(index, 1bv64) := value[16:8]][bvadd64(index, 2bv64) := value[24:16]][bvadd64(index, 3bv64) := value[32:24]]
 }
@@ -44,10 +40,7 @@ procedure {:extern} rely();
   modifies Gamma_mem, mem;
   ensures (forall i: bv64 :: (((mem[i] == old(mem[i])) ==> (Gamma_mem[i] == old(Gamma_mem[i])))));
   ensures (memory_load32_le(mem, $secret_addr) == old(memory_load32_le(mem, $secret_addr)));
-  free ensures (memory_load8_le(mem, 1896bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1897bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1898bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1899bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1896bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69016bv64) == 1872bv64);
   free ensures (memory_load64_le(mem, 69024bv64) == 1792bv64);
   free ensures (memory_load64_le(mem, 69616bv64) == 1536bv64);
@@ -78,18 +71,12 @@ procedure main();
   requires (gamma_load32(Gamma_mem, $secret_addr) == true);
   free requires (memory_load64_le(mem, 69632bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free requires (memory_load8_le(mem, 1896bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1897bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1898bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1899bv64) == 0bv8);
+  free requires (memory_load32_le(mem, 1896bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69016bv64) == 1872bv64);
   free requires (memory_load64_le(mem, 69024bv64) == 1792bv64);
   free requires (memory_load64_le(mem, 69616bv64) == 1536bv64);
   free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free ensures (memory_load8_le(mem, 1896bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1897bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1898bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1899bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1896bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69016bv64) == 1872bv64);
   free ensures (memory_load64_le(mem, 69024bv64) == 1792bv64);
   free ensures (memory_load64_le(mem, 69616bv64) == 1536bv64);
diff --git a/src/test/correct/basicassign_gamma0/gcc_O2/basicassign_gamma0_gtirb.expected b/src/test/correct/basicassign_gamma0/gcc_O2/basicassign_gamma0_gtirb.expected
index 20b34ec43..18d09ccfd 100644
--- a/src/test/correct/basicassign_gamma0/gcc_O2/basicassign_gamma0_gtirb.expected
+++ b/src/test/correct/basicassign_gamma0/gcc_O2/basicassign_gamma0_gtirb.expected
@@ -10,7 +10,7 @@ const {:extern} $secret_addr: bv64;
 axiom ($secret_addr == 69656bv64);
 const {:extern} $x_addr: bv64;
 axiom ($x_addr == 69652bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
   (if (index == $x_addr) then true else (if (index == $secret_addr) then false else false))
 }
 
@@ -31,10 +31,6 @@ function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv6
   (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
-}
-
 function {:extern} memory_store32_le(memory: [bv64]bv8, index: bv64, value: bv32) returns ([bv64]bv8) {
   memory[index := value[8:0]][bvadd64(index, 1bv64) := value[16:8]][bvadd64(index, 2bv64) := value[24:16]][bvadd64(index, 3bv64) := value[32:24]]
 }
@@ -44,10 +40,7 @@ procedure {:extern} rely();
   modifies Gamma_mem, mem;
   ensures (forall i: bv64 :: (((mem[i] == old(mem[i])) ==> (Gamma_mem[i] == old(Gamma_mem[i])))));
   ensures (memory_load32_le(mem, $secret_addr) == old(memory_load32_le(mem, $secret_addr)));
-  free ensures (memory_load8_le(mem, 1896bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1897bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1898bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1899bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1896bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69016bv64) == 1872bv64);
   free ensures (memory_load64_le(mem, 69024bv64) == 1792bv64);
   free ensures (memory_load64_le(mem, 69616bv64) == 1536bv64);
@@ -78,18 +71,12 @@ procedure main();
   requires (gamma_load32(Gamma_mem, $secret_addr) == true);
   free requires (memory_load64_le(mem, 69632bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free requires (memory_load8_le(mem, 1896bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1897bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1898bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1899bv64) == 0bv8);
+  free requires (memory_load32_le(mem, 1896bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69016bv64) == 1872bv64);
   free requires (memory_load64_le(mem, 69024bv64) == 1792bv64);
   free requires (memory_load64_le(mem, 69616bv64) == 1536bv64);
   free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free ensures (memory_load8_le(mem, 1896bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1897bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1898bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1899bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1896bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69016bv64) == 1872bv64);
   free ensures (memory_load64_le(mem, 69024bv64) == 1792bv64);
   free ensures (memory_load64_le(mem, 69616bv64) == 1536bv64);
diff --git a/src/test/correct/basicassign_gamma0/gcc_pic/basicassign_gamma0.expected b/src/test/correct/basicassign_gamma0/gcc_pic/basicassign_gamma0.expected
index 5465e2352..ced19431d 100644
--- a/src/test/correct/basicassign_gamma0/gcc_pic/basicassign_gamma0.expected
+++ b/src/test/correct/basicassign_gamma0/gcc_pic/basicassign_gamma0.expected
@@ -8,7 +8,7 @@ const {:extern} $secret_addr: bv64;
 axiom ($secret_addr == 69656bv64);
 const {:extern} $x_addr: bv64;
 axiom ($x_addr == 69652bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
   (if (index == $x_addr) then true else (if (index == $secret_addr) then false else false))
 }
 
@@ -33,10 +33,6 @@ function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv6
   (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
-}
-
 function {:extern} memory_store32_le(memory: [bv64]bv8, index: bv64, value: bv32) returns ([bv64]bv8) {
   memory[index := value[8:0]][bvadd64(index, 1bv64) := value[16:8]][bvadd64(index, 2bv64) := value[24:16]][bvadd64(index, 3bv64) := value[32:24]]
 }
@@ -46,16 +42,13 @@ procedure {:extern} rely();
   modifies Gamma_mem, mem;
   ensures (forall i: bv64 :: (((mem[i] == old(mem[i])) ==> (Gamma_mem[i] == old(Gamma_mem[i])))));
   ensures (memory_load32_le(mem, $secret_addr) == old(memory_load32_le(mem, $secret_addr)));
-  free ensures (memory_load8_le(mem, 1928bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1929bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1930bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1931bv64) == 0bv8);
-  free ensures (memory_load64_le(mem, 69608bv64) == 69656bv64);
-  free ensures (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free ensures (memory_load64_le(mem, 69616bv64) == 1876bv64);
+  free ensures (memory_load32_le(mem, 1928bv64) == 131073bv32);
+  free ensures (memory_load64_le(mem, 69000bv64) == 1872bv64);
   free ensures (memory_load64_le(mem, 69008bv64) == 1792bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 69652bv64);
-  free ensures (memory_load64_le(mem, 69000bv64) == 1872bv64);
+  free ensures (memory_load64_le(mem, 69608bv64) == 69656bv64);
+  free ensures (memory_load64_le(mem, 69616bv64) == 1876bv64);
+  free ensures (memory_load64_le(mem, 69640bv64) == 69640bv64);
 
 procedure {:extern} rely_transitive();
   modifies Gamma_mem, mem;
@@ -82,26 +75,20 @@ procedure main();
   requires (gamma_load32(Gamma_mem, $secret_addr) == true);
   free requires (memory_load64_le(mem, 69632bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free requires (memory_load8_le(mem, 1928bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1929bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1930bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1931bv64) == 0bv8);
-  free requires (memory_load64_le(mem, 69608bv64) == 69656bv64);
-  free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free requires (memory_load64_le(mem, 69616bv64) == 1876bv64);
+  free requires (memory_load32_le(mem, 1928bv64) == 131073bv32);
+  free requires (memory_load64_le(mem, 69000bv64) == 1872bv64);
   free requires (memory_load64_le(mem, 69008bv64) == 1792bv64);
   free requires (memory_load64_le(mem, 69592bv64) == 69652bv64);
-  free requires (memory_load64_le(mem, 69000bv64) == 1872bv64);
-  free ensures (memory_load8_le(mem, 1928bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1929bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1930bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1931bv64) == 0bv8);
-  free ensures (memory_load64_le(mem, 69608bv64) == 69656bv64);
-  free ensures (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free ensures (memory_load64_le(mem, 69616bv64) == 1876bv64);
+  free requires (memory_load64_le(mem, 69608bv64) == 69656bv64);
+  free requires (memory_load64_le(mem, 69616bv64) == 1876bv64);
+  free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
+  free ensures (memory_load32_le(mem, 1928bv64) == 131073bv32);
+  free ensures (memory_load64_le(mem, 69000bv64) == 1872bv64);
   free ensures (memory_load64_le(mem, 69008bv64) == 1792bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 69652bv64);
-  free ensures (memory_load64_le(mem, 69000bv64) == 1872bv64);
+  free ensures (memory_load64_le(mem, 69608bv64) == 69656bv64);
+  free ensures (memory_load64_le(mem, 69616bv64) == 1876bv64);
+  free ensures (memory_load64_le(mem, 69640bv64) == 69640bv64);
 
 implementation main()
 {
diff --git a/src/test/correct/basicassign_gamma0/gcc_pic/basicassign_gamma0_gtirb.expected b/src/test/correct/basicassign_gamma0/gcc_pic/basicassign_gamma0_gtirb.expected
index d66c514cb..653ba335f 100644
--- a/src/test/correct/basicassign_gamma0/gcc_pic/basicassign_gamma0_gtirb.expected
+++ b/src/test/correct/basicassign_gamma0/gcc_pic/basicassign_gamma0_gtirb.expected
@@ -8,7 +8,7 @@ const {:extern} $secret_addr: bv64;
 axiom ($secret_addr == 69656bv64);
 const {:extern} $x_addr: bv64;
 axiom ($x_addr == 69652bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
   (if (index == $x_addr) then true else (if (index == $secret_addr) then false else false))
 }
 
@@ -33,10 +33,6 @@ function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv6
   (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
-}
-
 function {:extern} memory_store32_le(memory: [bv64]bv8, index: bv64, value: bv32) returns ([bv64]bv8) {
   memory[index := value[8:0]][bvadd64(index, 1bv64) := value[16:8]][bvadd64(index, 2bv64) := value[24:16]][bvadd64(index, 3bv64) := value[32:24]]
 }
@@ -46,16 +42,13 @@ procedure {:extern} rely();
   modifies Gamma_mem, mem;
   ensures (forall i: bv64 :: (((mem[i] == old(mem[i])) ==> (Gamma_mem[i] == old(Gamma_mem[i])))));
   ensures (memory_load32_le(mem, $secret_addr) == old(memory_load32_le(mem, $secret_addr)));
-  free ensures (memory_load8_le(mem, 1928bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1929bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1930bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1931bv64) == 0bv8);
-  free ensures (memory_load64_le(mem, 69608bv64) == 69656bv64);
-  free ensures (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free ensures (memory_load64_le(mem, 69616bv64) == 1876bv64);
+  free ensures (memory_load32_le(mem, 1928bv64) == 131073bv32);
+  free ensures (memory_load64_le(mem, 69000bv64) == 1872bv64);
   free ensures (memory_load64_le(mem, 69008bv64) == 1792bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 69652bv64);
-  free ensures (memory_load64_le(mem, 69000bv64) == 1872bv64);
+  free ensures (memory_load64_le(mem, 69608bv64) == 69656bv64);
+  free ensures (memory_load64_le(mem, 69616bv64) == 1876bv64);
+  free ensures (memory_load64_le(mem, 69640bv64) == 69640bv64);
 
 procedure {:extern} rely_transitive();
   modifies Gamma_mem, mem;
@@ -82,26 +75,20 @@ procedure main();
   requires (gamma_load32(Gamma_mem, $secret_addr) == true);
   free requires (memory_load64_le(mem, 69632bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free requires (memory_load8_le(mem, 1928bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1929bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1930bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1931bv64) == 0bv8);
-  free requires (memory_load64_le(mem, 69608bv64) == 69656bv64);
-  free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free requires (memory_load64_le(mem, 69616bv64) == 1876bv64);
+  free requires (memory_load32_le(mem, 1928bv64) == 131073bv32);
+  free requires (memory_load64_le(mem, 69000bv64) == 1872bv64);
   free requires (memory_load64_le(mem, 69008bv64) == 1792bv64);
   free requires (memory_load64_le(mem, 69592bv64) == 69652bv64);
-  free requires (memory_load64_le(mem, 69000bv64) == 1872bv64);
-  free ensures (memory_load8_le(mem, 1928bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1929bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1930bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1931bv64) == 0bv8);
-  free ensures (memory_load64_le(mem, 69608bv64) == 69656bv64);
-  free ensures (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free ensures (memory_load64_le(mem, 69616bv64) == 1876bv64);
+  free requires (memory_load64_le(mem, 69608bv64) == 69656bv64);
+  free requires (memory_load64_le(mem, 69616bv64) == 1876bv64);
+  free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
+  free ensures (memory_load32_le(mem, 1928bv64) == 131073bv32);
+  free ensures (memory_load64_le(mem, 69000bv64) == 1872bv64);
   free ensures (memory_load64_le(mem, 69008bv64) == 1792bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 69652bv64);
-  free ensures (memory_load64_le(mem, 69000bv64) == 1872bv64);
+  free ensures (memory_load64_le(mem, 69608bv64) == 69656bv64);
+  free ensures (memory_load64_le(mem, 69616bv64) == 1876bv64);
+  free ensures (memory_load64_le(mem, 69640bv64) == 69640bv64);
 
 implementation main()
 {
diff --git a/src/test/correct/basicfree/clang/basicfree.expected b/src/test/correct/basicfree/clang/basicfree.expected
index b76efd72b..1224cf5b2 100644
--- a/src/test/correct/basicfree/clang/basicfree.expected
+++ b/src/test/correct/basicfree/clang/basicfree.expected
@@ -20,7 +20,7 @@ var {:extern} mem: [bv64]bv8;
 var {:extern} stack: [bv64]bv8;
 const {:extern} $_IO_stdin_used_addr: bv64;
 axiom ($_IO_stdin_used_addr == 2080bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
   false
 }
 
@@ -37,12 +37,12 @@ function {:extern} gamma_store64(gammaMap: [bv64]bool, index: bv64, value: bool)
   gammaMap[index := value][bvadd64(index, 1bv64) := value][bvadd64(index, 2bv64) := value][bvadd64(index, 3bv64) := value][bvadd64(index, 4bv64) := value][bvadd64(index, 5bv64) := value][bvadd64(index, 6bv64) := value][bvadd64(index, 7bv64) := value]
 }
 
-function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv64) {
-  (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
+function {:extern} memory_load32_le(memory: [bv64]bv8, index: bv64) returns (bv32) {
+  (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
+function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv64) {
+  (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
 function {:extern} memory_store32_le(memory: [bv64]bv8, index: bv64, value: bv32) returns ([bv64]bv8) {
@@ -55,12 +55,9 @@ function {:extern} memory_store64_le(memory: [bv64]bv8, index: bv64, value: bv64
 
 procedure {:extern} rely();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
-  free ensures (memory_load8_le(mem, 2080bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 2081bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 2082bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 2083bv64) == 0bv8);
+  ensures (mem == old(mem));
+  free ensures (memory_load32_le(mem, 2080bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69064bv64) == 2000bv64);
   free ensures (memory_load64_le(mem, 69072bv64) == 1920bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 2004bv64);
@@ -68,8 +65,8 @@ procedure {:extern} rely();
 
 procedure {:extern} rely_transitive();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
+  ensures (mem == old(mem));
 
 implementation {:extern} rely_transitive()
 {
@@ -84,18 +81,12 @@ procedure {:extern} guarantee_reflexive();
 
 procedure #free();
   modifies Gamma_R16, Gamma_R17, R16, R17;
-  free requires (memory_load8_le(mem, 2080bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 2081bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 2082bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 2083bv64) == 0bv8);
+  free requires (memory_load32_le(mem, 2080bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69064bv64) == 2000bv64);
   free requires (memory_load64_le(mem, 69072bv64) == 1920bv64);
   free requires (memory_load64_le(mem, 69592bv64) == 2004bv64);
   free requires (memory_load64_le(mem, 69688bv64) == 69688bv64);
-  free ensures (memory_load8_le(mem, 2080bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 2081bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 2082bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 2083bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 2080bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69064bv64) == 2000bv64);
   free ensures (memory_load64_le(mem, 69072bv64) == 1920bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 2004bv64);
@@ -105,10 +96,7 @@ procedure main();
   modifies Gamma_R0, Gamma_R16, Gamma_R17, Gamma_R29, Gamma_R30, Gamma_R31, Gamma_R8, Gamma_R9, Gamma_mem, Gamma_stack, R0, R16, R17, R29, R30, R31, R8, R9, mem, stack;
   free requires (memory_load64_le(mem, 69680bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69688bv64) == 69688bv64);
-  free requires (memory_load8_le(mem, 2080bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 2081bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 2082bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 2083bv64) == 0bv8);
+  free requires (memory_load32_le(mem, 2080bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69064bv64) == 2000bv64);
   free requires (memory_load64_le(mem, 69072bv64) == 1920bv64);
   free requires (memory_load64_le(mem, 69592bv64) == 2004bv64);
@@ -117,10 +105,7 @@ procedure main();
   free ensures (Gamma_R31 == old(Gamma_R31));
   free ensures (R29 == old(R29));
   free ensures (R31 == old(R31));
-  free ensures (memory_load8_le(mem, 2080bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 2081bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 2082bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 2083bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 2080bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69064bv64) == 2000bv64);
   free ensures (memory_load64_le(mem, 69072bv64) == 1920bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 2004bv64);
@@ -173,18 +158,12 @@ implementation main()
 
 procedure malloc();
   modifies Gamma_R16, Gamma_R17, R16, R17;
-  free requires (memory_load8_le(mem, 2080bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 2081bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 2082bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 2083bv64) == 0bv8);
+  free requires (memory_load32_le(mem, 2080bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69064bv64) == 2000bv64);
   free requires (memory_load64_le(mem, 69072bv64) == 1920bv64);
   free requires (memory_load64_le(mem, 69592bv64) == 2004bv64);
   free requires (memory_load64_le(mem, 69688bv64) == 69688bv64);
-  free ensures (memory_load8_le(mem, 2080bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 2081bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 2082bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 2083bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 2080bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69064bv64) == 2000bv64);
   free ensures (memory_load64_le(mem, 69072bv64) == 1920bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 2004bv64);
diff --git a/src/test/correct/basicfree/clang/basicfree_gtirb.expected b/src/test/correct/basicfree/clang/basicfree_gtirb.expected
index 0afab7180..53b48009a 100644
--- a/src/test/correct/basicfree/clang/basicfree_gtirb.expected
+++ b/src/test/correct/basicfree/clang/basicfree_gtirb.expected
@@ -20,7 +20,7 @@ var {:extern} mem: [bv64]bv8;
 var {:extern} stack: [bv64]bv8;
 const {:extern} $_IO_stdin_used_addr: bv64;
 axiom ($_IO_stdin_used_addr == 2080bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
   false
 }
 
@@ -37,12 +37,12 @@ function {:extern} gamma_store64(gammaMap: [bv64]bool, index: bv64, value: bool)
   gammaMap[index := value][bvadd64(index, 1bv64) := value][bvadd64(index, 2bv64) := value][bvadd64(index, 3bv64) := value][bvadd64(index, 4bv64) := value][bvadd64(index, 5bv64) := value][bvadd64(index, 6bv64) := value][bvadd64(index, 7bv64) := value]
 }
 
-function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv64) {
-  (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
+function {:extern} memory_load32_le(memory: [bv64]bv8, index: bv64) returns (bv32) {
+  (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
+function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv64) {
+  (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
 function {:extern} memory_store32_le(memory: [bv64]bv8, index: bv64, value: bv32) returns ([bv64]bv8) {
@@ -55,12 +55,9 @@ function {:extern} memory_store64_le(memory: [bv64]bv8, index: bv64, value: bv64
 
 procedure {:extern} rely();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
-  free ensures (memory_load8_le(mem, 2080bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 2081bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 2082bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 2083bv64) == 0bv8);
+  ensures (mem == old(mem));
+  free ensures (memory_load32_le(mem, 2080bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69064bv64) == 2000bv64);
   free ensures (memory_load64_le(mem, 69072bv64) == 1920bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 2004bv64);
@@ -68,8 +65,8 @@ procedure {:extern} rely();
 
 procedure {:extern} rely_transitive();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
+  ensures (mem == old(mem));
 
 implementation {:extern} rely_transitive()
 {
@@ -84,18 +81,12 @@ procedure {:extern} guarantee_reflexive();
 
 procedure FUN_650();
   modifies Gamma_R16, Gamma_R17, Gamma_mem, R16, R17, mem;
-  free requires (memory_load8_le(mem, 2080bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 2081bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 2082bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 2083bv64) == 0bv8);
+  free requires (memory_load32_le(mem, 2080bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69064bv64) == 2000bv64);
   free requires (memory_load64_le(mem, 69072bv64) == 1920bv64);
   free requires (memory_load64_le(mem, 69592bv64) == 2004bv64);
   free requires (memory_load64_le(mem, 69688bv64) == 69688bv64);
-  free ensures (memory_load8_le(mem, 2080bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 2081bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 2082bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 2083bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 2080bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69064bv64) == 2000bv64);
   free ensures (memory_load64_le(mem, 69072bv64) == 1920bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 2004bv64);
@@ -115,18 +106,12 @@ implementation FUN_650()
 
 procedure FUN_680();
   modifies Gamma_R16, Gamma_R17, Gamma_mem, R16, R17, mem;
-  free requires (memory_load8_le(mem, 2080bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 2081bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 2082bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 2083bv64) == 0bv8);
+  free requires (memory_load32_le(mem, 2080bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69064bv64) == 2000bv64);
   free requires (memory_load64_le(mem, 69072bv64) == 1920bv64);
   free requires (memory_load64_le(mem, 69592bv64) == 2004bv64);
   free requires (memory_load64_le(mem, 69688bv64) == 69688bv64);
-  free ensures (memory_load8_le(mem, 2080bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 2081bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 2082bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 2083bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 2080bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69064bv64) == 2000bv64);
   free ensures (memory_load64_le(mem, 69072bv64) == 1920bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 2004bv64);
@@ -148,10 +133,7 @@ procedure main();
   modifies Gamma_R0, Gamma_R16, Gamma_R17, Gamma_R29, Gamma_R30, Gamma_R31, Gamma_R8, Gamma_R9, Gamma_mem, Gamma_stack, R0, R16, R17, R29, R30, R31, R8, R9, mem, stack;
   free requires (memory_load64_le(mem, 69680bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69688bv64) == 69688bv64);
-  free requires (memory_load8_le(mem, 2080bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 2081bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 2082bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 2083bv64) == 0bv8);
+  free requires (memory_load32_le(mem, 2080bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69064bv64) == 2000bv64);
   free requires (memory_load64_le(mem, 69072bv64) == 1920bv64);
   free requires (memory_load64_le(mem, 69592bv64) == 2004bv64);
@@ -160,10 +142,7 @@ procedure main();
   free ensures (Gamma_R31 == old(Gamma_R31));
   free ensures (R29 == old(R29));
   free ensures (R31 == old(R31));
-  free ensures (memory_load8_le(mem, 2080bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 2081bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 2082bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 2083bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 2080bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69064bv64) == 2000bv64);
   free ensures (memory_load64_le(mem, 69072bv64) == 1920bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 2004bv64);
@@ -215,36 +194,24 @@ implementation main()
 }
 
 procedure malloc();
-  free requires (memory_load8_le(mem, 2080bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 2081bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 2082bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 2083bv64) == 0bv8);
+  free requires (memory_load32_le(mem, 2080bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69064bv64) == 2000bv64);
   free requires (memory_load64_le(mem, 69072bv64) == 1920bv64);
   free requires (memory_load64_le(mem, 69592bv64) == 2004bv64);
   free requires (memory_load64_le(mem, 69688bv64) == 69688bv64);
-  free ensures (memory_load8_le(mem, 2080bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 2081bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 2082bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 2083bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 2080bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69064bv64) == 2000bv64);
   free ensures (memory_load64_le(mem, 69072bv64) == 1920bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 2004bv64);
   free ensures (memory_load64_le(mem, 69688bv64) == 69688bv64);
 
 procedure #free();
-  free requires (memory_load8_le(mem, 2080bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 2081bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 2082bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 2083bv64) == 0bv8);
+  free requires (memory_load32_le(mem, 2080bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69064bv64) == 2000bv64);
   free requires (memory_load64_le(mem, 69072bv64) == 1920bv64);
   free requires (memory_load64_le(mem, 69592bv64) == 2004bv64);
   free requires (memory_load64_le(mem, 69688bv64) == 69688bv64);
-  free ensures (memory_load8_le(mem, 2080bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 2081bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 2082bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 2083bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 2080bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69064bv64) == 2000bv64);
   free ensures (memory_load64_le(mem, 69072bv64) == 1920bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 2004bv64);
diff --git a/src/test/correct/basicfree/gcc/basicfree.expected b/src/test/correct/basicfree/gcc/basicfree.expected
index ef418f173..bf81fd5ac 100644
--- a/src/test/correct/basicfree/gcc/basicfree.expected
+++ b/src/test/correct/basicfree/gcc/basicfree.expected
@@ -18,7 +18,7 @@ var {:extern} mem: [bv64]bv8;
 var {:extern} stack: [bv64]bv8;
 const {:extern} $_IO_stdin_used_addr: bv64;
 axiom ($_IO_stdin_used_addr == 2076bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
   false
 }
 
@@ -35,12 +35,12 @@ function {:extern} gamma_store64(gammaMap: [bv64]bool, index: bv64, value: bool)
   gammaMap[index := value][bvadd64(index, 1bv64) := value][bvadd64(index, 2bv64) := value][bvadd64(index, 3bv64) := value][bvadd64(index, 4bv64) := value][bvadd64(index, 5bv64) := value][bvadd64(index, 6bv64) := value][bvadd64(index, 7bv64) := value]
 }
 
-function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv64) {
-  (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
+function {:extern} memory_load32_le(memory: [bv64]bv8, index: bv64) returns (bv32) {
+  (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
+function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv64) {
+  (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
 function {:extern} memory_store32_le(memory: [bv64]bv8, index: bv64, value: bv32) returns ([bv64]bv8) {
@@ -53,12 +53,9 @@ function {:extern} memory_store64_le(memory: [bv64]bv8, index: bv64, value: bv64
 
 procedure {:extern} rely();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
-  free ensures (memory_load8_le(mem, 2076bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 2077bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 2078bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 2079bv64) == 0bv8);
+  ensures (mem == old(mem));
+  free ensures (memory_load32_le(mem, 2076bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69000bv64) == 2000bv64);
   free ensures (memory_load64_le(mem, 69008bv64) == 1920bv64);
   free ensures (memory_load64_le(mem, 69616bv64) == 2004bv64);
@@ -66,8 +63,8 @@ procedure {:extern} rely();
 
 procedure {:extern} rely_transitive();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
+  ensures (mem == old(mem));
 
 implementation {:extern} rely_transitive()
 {
@@ -82,18 +79,12 @@ procedure {:extern} guarantee_reflexive();
 
 procedure #free();
   modifies Gamma_R16, Gamma_R17, R16, R17;
-  free requires (memory_load8_le(mem, 2076bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 2077bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 2078bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 2079bv64) == 0bv8);
+  free requires (memory_load32_le(mem, 2076bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69000bv64) == 2000bv64);
   free requires (memory_load64_le(mem, 69008bv64) == 1920bv64);
   free requires (memory_load64_le(mem, 69616bv64) == 2004bv64);
   free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free ensures (memory_load8_le(mem, 2076bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 2077bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 2078bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 2079bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 2076bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69000bv64) == 2000bv64);
   free ensures (memory_load64_le(mem, 69008bv64) == 1920bv64);
   free ensures (memory_load64_le(mem, 69616bv64) == 2004bv64);
@@ -103,10 +94,7 @@ procedure main();
   modifies Gamma_R0, Gamma_R1, Gamma_R16, Gamma_R17, Gamma_R29, Gamma_R30, Gamma_R31, Gamma_mem, Gamma_stack, R0, R1, R16, R17, R29, R30, R31, mem, stack;
   free requires (memory_load64_le(mem, 69632bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free requires (memory_load8_le(mem, 2076bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 2077bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 2078bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 2079bv64) == 0bv8);
+  free requires (memory_load32_le(mem, 2076bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69000bv64) == 2000bv64);
   free requires (memory_load64_le(mem, 69008bv64) == 1920bv64);
   free requires (memory_load64_le(mem, 69616bv64) == 2004bv64);
@@ -115,10 +103,7 @@ procedure main();
   free ensures (Gamma_R31 == old(Gamma_R31));
   free ensures (R29 == old(R29));
   free ensures (R31 == old(R31));
-  free ensures (memory_load8_le(mem, 2076bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 2077bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 2078bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 2079bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 2076bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69000bv64) == 2000bv64);
   free ensures (memory_load64_le(mem, 69008bv64) == 1920bv64);
   free ensures (memory_load64_le(mem, 69616bv64) == 2004bv64);
@@ -168,18 +153,12 @@ implementation main()
 
 procedure malloc();
   modifies Gamma_R16, Gamma_R17, R16, R17;
-  free requires (memory_load8_le(mem, 2076bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 2077bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 2078bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 2079bv64) == 0bv8);
+  free requires (memory_load32_le(mem, 2076bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69000bv64) == 2000bv64);
   free requires (memory_load64_le(mem, 69008bv64) == 1920bv64);
   free requires (memory_load64_le(mem, 69616bv64) == 2004bv64);
   free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free ensures (memory_load8_le(mem, 2076bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 2077bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 2078bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 2079bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 2076bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69000bv64) == 2000bv64);
   free ensures (memory_load64_le(mem, 69008bv64) == 1920bv64);
   free ensures (memory_load64_le(mem, 69616bv64) == 2004bv64);
diff --git a/src/test/correct/basicfree/gcc/basicfree_gtirb.expected b/src/test/correct/basicfree/gcc/basicfree_gtirb.expected
index 9b75b6fd3..e9dfa741d 100644
--- a/src/test/correct/basicfree/gcc/basicfree_gtirb.expected
+++ b/src/test/correct/basicfree/gcc/basicfree_gtirb.expected
@@ -18,7 +18,7 @@ var {:extern} mem: [bv64]bv8;
 var {:extern} stack: [bv64]bv8;
 const {:extern} $_IO_stdin_used_addr: bv64;
 axiom ($_IO_stdin_used_addr == 2076bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
   false
 }
 
@@ -35,12 +35,12 @@ function {:extern} gamma_store64(gammaMap: [bv64]bool, index: bv64, value: bool)
   gammaMap[index := value][bvadd64(index, 1bv64) := value][bvadd64(index, 2bv64) := value][bvadd64(index, 3bv64) := value][bvadd64(index, 4bv64) := value][bvadd64(index, 5bv64) := value][bvadd64(index, 6bv64) := value][bvadd64(index, 7bv64) := value]
 }
 
-function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv64) {
-  (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
+function {:extern} memory_load32_le(memory: [bv64]bv8, index: bv64) returns (bv32) {
+  (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
+function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv64) {
+  (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
 function {:extern} memory_store32_le(memory: [bv64]bv8, index: bv64, value: bv32) returns ([bv64]bv8) {
@@ -53,12 +53,9 @@ function {:extern} memory_store64_le(memory: [bv64]bv8, index: bv64, value: bv64
 
 procedure {:extern} rely();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
-  free ensures (memory_load8_le(mem, 2076bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 2077bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 2078bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 2079bv64) == 0bv8);
+  ensures (mem == old(mem));
+  free ensures (memory_load32_le(mem, 2076bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69000bv64) == 2000bv64);
   free ensures (memory_load64_le(mem, 69008bv64) == 1920bv64);
   free ensures (memory_load64_le(mem, 69616bv64) == 2004bv64);
@@ -66,8 +63,8 @@ procedure {:extern} rely();
 
 procedure {:extern} rely_transitive();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
+  ensures (mem == old(mem));
 
 implementation {:extern} rely_transitive()
 {
@@ -82,18 +79,12 @@ procedure {:extern} guarantee_reflexive();
 
 procedure FUN_680();
   modifies Gamma_R16, Gamma_R17, Gamma_mem, R16, R17, mem;
-  free requires (memory_load8_le(mem, 2076bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 2077bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 2078bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 2079bv64) == 0bv8);
+  free requires (memory_load32_le(mem, 2076bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69000bv64) == 2000bv64);
   free requires (memory_load64_le(mem, 69008bv64) == 1920bv64);
   free requires (memory_load64_le(mem, 69616bv64) == 2004bv64);
   free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free ensures (memory_load8_le(mem, 2076bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 2077bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 2078bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 2079bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 2076bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69000bv64) == 2000bv64);
   free ensures (memory_load64_le(mem, 69008bv64) == 1920bv64);
   free ensures (memory_load64_le(mem, 69616bv64) == 2004bv64);
@@ -115,10 +106,7 @@ procedure main();
   modifies Gamma_R0, Gamma_R1, Gamma_R16, Gamma_R17, Gamma_R29, Gamma_R30, Gamma_R31, Gamma_mem, Gamma_stack, R0, R1, R16, R17, R29, R30, R31, mem, stack;
   free requires (memory_load64_le(mem, 69632bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free requires (memory_load8_le(mem, 2076bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 2077bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 2078bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 2079bv64) == 0bv8);
+  free requires (memory_load32_le(mem, 2076bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69000bv64) == 2000bv64);
   free requires (memory_load64_le(mem, 69008bv64) == 1920bv64);
   free requires (memory_load64_le(mem, 69616bv64) == 2004bv64);
@@ -127,10 +115,7 @@ procedure main();
   free ensures (Gamma_R31 == old(Gamma_R31));
   free ensures (R29 == old(R29));
   free ensures (R31 == old(R31));
-  free ensures (memory_load8_le(mem, 2076bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 2077bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 2078bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 2079bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 2076bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69000bv64) == 2000bv64);
   free ensures (memory_load64_le(mem, 69008bv64) == 1920bv64);
   free ensures (memory_load64_le(mem, 69616bv64) == 2004bv64);
@@ -180,18 +165,12 @@ implementation main()
 
 procedure FUN_650();
   modifies Gamma_R16, Gamma_R17, Gamma_mem, R16, R17, mem;
-  free requires (memory_load8_le(mem, 2076bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 2077bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 2078bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 2079bv64) == 0bv8);
+  free requires (memory_load32_le(mem, 2076bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69000bv64) == 2000bv64);
   free requires (memory_load64_le(mem, 69008bv64) == 1920bv64);
   free requires (memory_load64_le(mem, 69616bv64) == 2004bv64);
   free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free ensures (memory_load8_le(mem, 2076bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 2077bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 2078bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 2079bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 2076bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69000bv64) == 2000bv64);
   free ensures (memory_load64_le(mem, 69008bv64) == 1920bv64);
   free ensures (memory_load64_le(mem, 69616bv64) == 2004bv64);
@@ -210,36 +189,24 @@ implementation FUN_650()
 }
 
 procedure #free();
-  free requires (memory_load8_le(mem, 2076bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 2077bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 2078bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 2079bv64) == 0bv8);
+  free requires (memory_load32_le(mem, 2076bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69000bv64) == 2000bv64);
   free requires (memory_load64_le(mem, 69008bv64) == 1920bv64);
   free requires (memory_load64_le(mem, 69616bv64) == 2004bv64);
   free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free ensures (memory_load8_le(mem, 2076bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 2077bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 2078bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 2079bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 2076bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69000bv64) == 2000bv64);
   free ensures (memory_load64_le(mem, 69008bv64) == 1920bv64);
   free ensures (memory_load64_le(mem, 69616bv64) == 2004bv64);
   free ensures (memory_load64_le(mem, 69640bv64) == 69640bv64);
 
 procedure malloc();
-  free requires (memory_load8_le(mem, 2076bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 2077bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 2078bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 2079bv64) == 0bv8);
+  free requires (memory_load32_le(mem, 2076bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69000bv64) == 2000bv64);
   free requires (memory_load64_le(mem, 69008bv64) == 1920bv64);
   free requires (memory_load64_le(mem, 69616bv64) == 2004bv64);
   free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free ensures (memory_load8_le(mem, 2076bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 2077bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 2078bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 2079bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 2076bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69000bv64) == 2000bv64);
   free ensures (memory_load64_le(mem, 69008bv64) == 1920bv64);
   free ensures (memory_load64_le(mem, 69616bv64) == 2004bv64);
diff --git a/src/test/correct/cjump/clang/cjump.expected b/src/test/correct/cjump/clang/cjump.expected
index bdc139149..e74e0ba9c 100644
--- a/src/test/correct/cjump/clang/cjump.expected
+++ b/src/test/correct/cjump/clang/cjump.expected
@@ -22,7 +22,7 @@ const {:extern} $x_addr: bv64;
 axiom ($x_addr == 69684bv64);
 const {:extern} $y_addr: bv64;
 axiom ($y_addr == 69688bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
   false
 }
 
@@ -49,10 +49,6 @@ function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv6
   (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
-}
-
 function {:extern} memory_store32_le(memory: [bv64]bv8, index: bv64, value: bv32) returns ([bv64]bv8) {
   memory[index := value[8:0]][bvadd64(index, 1bv64) := value[16:8]][bvadd64(index, 2bv64) := value[24:16]][bvadd64(index, 3bv64) := value[32:24]]
 }
@@ -62,12 +58,9 @@ function {:extern} {:bvbuiltin "zero_extend 1"} zero_extend1_32(bv32) returns (b
 function {:extern} {:bvbuiltin "zero_extend 32"} zero_extend32_32(bv32) returns (bv64);
 procedure {:extern} rely();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
-  free ensures (memory_load8_le(mem, 1916bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1917bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1918bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1919bv64) == 0bv8);
+  ensures (mem == old(mem));
+  free ensures (memory_load32_le(mem, 1916bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1812bv64);
@@ -75,8 +68,8 @@ procedure {:extern} rely();
 
 procedure {:extern} rely_transitive();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
+  ensures (mem == old(mem));
 
 implementation {:extern} rely_transitive()
 {
@@ -95,20 +88,14 @@ procedure main();
   requires (gamma_load32(Gamma_mem, $y_addr) == false);
   free requires (memory_load64_le(mem, 69664bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
-  free requires (memory_load8_le(mem, 1916bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1917bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1918bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1919bv64) == 0bv8);
+  free requires (memory_load32_le(mem, 1916bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free requires (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free requires (memory_load64_le(mem, 69592bv64) == 1812bv64);
   free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
   free ensures (Gamma_R31 == old(Gamma_R31));
   free ensures (R31 == old(R31));
-  free ensures (memory_load8_le(mem, 1916bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1917bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1918bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1919bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1916bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1812bv64);
diff --git a/src/test/correct/cjump/clang/cjump_gtirb.expected b/src/test/correct/cjump/clang/cjump_gtirb.expected
index 46eff7f81..db365724f 100644
--- a/src/test/correct/cjump/clang/cjump_gtirb.expected
+++ b/src/test/correct/cjump/clang/cjump_gtirb.expected
@@ -22,7 +22,7 @@ const {:extern} $x_addr: bv64;
 axiom ($x_addr == 69684bv64);
 const {:extern} $y_addr: bv64;
 axiom ($y_addr == 69688bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
   false
 }
 
@@ -48,10 +48,6 @@ function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv6
   (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
-}
-
 function {:extern} memory_store32_le(memory: [bv64]bv8, index: bv64, value: bv32) returns ([bv64]bv8) {
   memory[index := value[8:0]][bvadd64(index, 1bv64) := value[16:8]][bvadd64(index, 2bv64) := value[24:16]][bvadd64(index, 3bv64) := value[32:24]]
 }
@@ -60,12 +56,9 @@ function {:extern} {:bvbuiltin "zero_extend 1"} zero_extend1_32(bv32) returns (b
 function {:extern} {:bvbuiltin "zero_extend 32"} zero_extend32_32(bv32) returns (bv64);
 procedure {:extern} rely();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
-  free ensures (memory_load8_le(mem, 1916bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1917bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1918bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1919bv64) == 0bv8);
+  ensures (mem == old(mem));
+  free ensures (memory_load32_le(mem, 1916bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1812bv64);
@@ -73,8 +66,8 @@ procedure {:extern} rely();
 
 procedure {:extern} rely_transitive();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
+  ensures (mem == old(mem));
 
 implementation {:extern} rely_transitive()
 {
@@ -93,20 +86,14 @@ procedure main();
   requires (gamma_load32(Gamma_mem, $y_addr) == false);
   free requires (memory_load64_le(mem, 69664bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
-  free requires (memory_load8_le(mem, 1916bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1917bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1918bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1919bv64) == 0bv8);
+  free requires (memory_load32_le(mem, 1916bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free requires (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free requires (memory_load64_le(mem, 69592bv64) == 1812bv64);
   free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
   free ensures (Gamma_R31 == old(Gamma_R31));
   free ensures (R31 == old(R31));
-  free ensures (memory_load8_le(mem, 1916bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1917bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1918bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1919bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1916bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1812bv64);
diff --git a/src/test/correct/cjump/clang_pic/cjump.expected b/src/test/correct/cjump/clang_pic/cjump.expected
index 57808849f..b51a7b7e0 100644
--- a/src/test/correct/cjump/clang_pic/cjump.expected
+++ b/src/test/correct/cjump/clang_pic/cjump.expected
@@ -22,7 +22,7 @@ const {:extern} $x_addr: bv64;
 axiom ($x_addr == 69684bv64);
 const {:extern} $y_addr: bv64;
 axiom ($y_addr == 69688bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
   false
 }
 
@@ -53,10 +53,6 @@ function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv6
   (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
-}
-
 function {:extern} memory_store32_le(memory: [bv64]bv8, index: bv64, value: bv32) returns ([bv64]bv8) {
   memory[index := value[8:0]][bvadd64(index, 1bv64) := value[16:8]][bvadd64(index, 2bv64) := value[24:16]][bvadd64(index, 3bv64) := value[32:24]]
 }
@@ -66,23 +62,20 @@ function {:extern} {:bvbuiltin "zero_extend 1"} zero_extend1_32(bv32) returns (b
 function {:extern} {:bvbuiltin "zero_extend 32"} zero_extend32_32(bv32) returns (bv64);
 procedure {:extern} rely();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
-  free ensures (memory_load8_le(mem, 1992bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1993bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1994bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1995bv64) == 0bv8);
-  free ensures (memory_load64_le(mem, 69672bv64) == 69672bv64);
-  free ensures (memory_load64_le(mem, 69584bv64) == 69688bv64);
+  ensures (mem == old(mem));
+  free ensures (memory_load32_le(mem, 1992bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69048bv64) == 1872bv64);
+  free ensures (memory_load64_le(mem, 69056bv64) == 1792bv64);
   free ensures (memory_load64_le(mem, 69568bv64) == 69684bv64);
+  free ensures (memory_load64_le(mem, 69584bv64) == 69688bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1876bv64);
-  free ensures (memory_load64_le(mem, 69056bv64) == 1792bv64);
+  free ensures (memory_load64_le(mem, 69672bv64) == 69672bv64);
 
 procedure {:extern} rely_transitive();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
+  ensures (mem == old(mem));
 
 implementation {:extern} rely_transitive()
 {
@@ -101,28 +94,22 @@ procedure main();
   requires (gamma_load32(Gamma_mem, $y_addr) == false);
   free requires (memory_load64_le(mem, 69664bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
-  free requires (memory_load8_le(mem, 1992bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1993bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1994bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1995bv64) == 0bv8);
-  free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
-  free requires (memory_load64_le(mem, 69584bv64) == 69688bv64);
+  free requires (memory_load32_le(mem, 1992bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69048bv64) == 1872bv64);
+  free requires (memory_load64_le(mem, 69056bv64) == 1792bv64);
   free requires (memory_load64_le(mem, 69568bv64) == 69684bv64);
+  free requires (memory_load64_le(mem, 69584bv64) == 69688bv64);
   free requires (memory_load64_le(mem, 69592bv64) == 1876bv64);
-  free requires (memory_load64_le(mem, 69056bv64) == 1792bv64);
+  free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
   free ensures (Gamma_R31 == old(Gamma_R31));
   free ensures (R31 == old(R31));
-  free ensures (memory_load8_le(mem, 1992bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1993bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1994bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1995bv64) == 0bv8);
-  free ensures (memory_load64_le(mem, 69672bv64) == 69672bv64);
-  free ensures (memory_load64_le(mem, 69584bv64) == 69688bv64);
+  free ensures (memory_load32_le(mem, 1992bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69048bv64) == 1872bv64);
+  free ensures (memory_load64_le(mem, 69056bv64) == 1792bv64);
   free ensures (memory_load64_le(mem, 69568bv64) == 69684bv64);
+  free ensures (memory_load64_le(mem, 69584bv64) == 69688bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1876bv64);
-  free ensures (memory_load64_le(mem, 69056bv64) == 1792bv64);
+  free ensures (memory_load64_le(mem, 69672bv64) == 69672bv64);
 
 implementation main()
 {
diff --git a/src/test/correct/cjump/clang_pic/cjump_gtirb.expected b/src/test/correct/cjump/clang_pic/cjump_gtirb.expected
index efb0e4ac5..9d0935d98 100644
--- a/src/test/correct/cjump/clang_pic/cjump_gtirb.expected
+++ b/src/test/correct/cjump/clang_pic/cjump_gtirb.expected
@@ -22,7 +22,7 @@ const {:extern} $x_addr: bv64;
 axiom ($x_addr == 69684bv64);
 const {:extern} $y_addr: bv64;
 axiom ($y_addr == 69688bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
   false
 }
 
@@ -52,10 +52,6 @@ function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv6
   (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
-}
-
 function {:extern} memory_store32_le(memory: [bv64]bv8, index: bv64, value: bv32) returns ([bv64]bv8) {
   memory[index := value[8:0]][bvadd64(index, 1bv64) := value[16:8]][bvadd64(index, 2bv64) := value[24:16]][bvadd64(index, 3bv64) := value[32:24]]
 }
@@ -64,23 +60,20 @@ function {:extern} {:bvbuiltin "zero_extend 1"} zero_extend1_32(bv32) returns (b
 function {:extern} {:bvbuiltin "zero_extend 32"} zero_extend32_32(bv32) returns (bv64);
 procedure {:extern} rely();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
-  free ensures (memory_load8_le(mem, 1992bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1993bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1994bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1995bv64) == 0bv8);
-  free ensures (memory_load64_le(mem, 69672bv64) == 69672bv64);
-  free ensures (memory_load64_le(mem, 69584bv64) == 69688bv64);
+  ensures (mem == old(mem));
+  free ensures (memory_load32_le(mem, 1992bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69048bv64) == 1872bv64);
+  free ensures (memory_load64_le(mem, 69056bv64) == 1792bv64);
   free ensures (memory_load64_le(mem, 69568bv64) == 69684bv64);
+  free ensures (memory_load64_le(mem, 69584bv64) == 69688bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1876bv64);
-  free ensures (memory_load64_le(mem, 69056bv64) == 1792bv64);
+  free ensures (memory_load64_le(mem, 69672bv64) == 69672bv64);
 
 procedure {:extern} rely_transitive();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
+  ensures (mem == old(mem));
 
 implementation {:extern} rely_transitive()
 {
@@ -99,28 +92,22 @@ procedure main();
   requires (gamma_load32(Gamma_mem, $y_addr) == false);
   free requires (memory_load64_le(mem, 69664bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
-  free requires (memory_load8_le(mem, 1992bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1993bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1994bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1995bv64) == 0bv8);
-  free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
-  free requires (memory_load64_le(mem, 69584bv64) == 69688bv64);
+  free requires (memory_load32_le(mem, 1992bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69048bv64) == 1872bv64);
+  free requires (memory_load64_le(mem, 69056bv64) == 1792bv64);
   free requires (memory_load64_le(mem, 69568bv64) == 69684bv64);
+  free requires (memory_load64_le(mem, 69584bv64) == 69688bv64);
   free requires (memory_load64_le(mem, 69592bv64) == 1876bv64);
-  free requires (memory_load64_le(mem, 69056bv64) == 1792bv64);
+  free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
   free ensures (Gamma_R31 == old(Gamma_R31));
   free ensures (R31 == old(R31));
-  free ensures (memory_load8_le(mem, 1992bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1993bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1994bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1995bv64) == 0bv8);
-  free ensures (memory_load64_le(mem, 69672bv64) == 69672bv64);
-  free ensures (memory_load64_le(mem, 69584bv64) == 69688bv64);
+  free ensures (memory_load32_le(mem, 1992bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69048bv64) == 1872bv64);
+  free ensures (memory_load64_le(mem, 69056bv64) == 1792bv64);
   free ensures (memory_load64_le(mem, 69568bv64) == 69684bv64);
+  free ensures (memory_load64_le(mem, 69584bv64) == 69688bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1876bv64);
-  free ensures (memory_load64_le(mem, 69056bv64) == 1792bv64);
+  free ensures (memory_load64_le(mem, 69672bv64) == 69672bv64);
 
 implementation main()
 {
diff --git a/src/test/correct/cjump/gcc/cjump.expected b/src/test/correct/cjump/gcc/cjump.expected
index 870950bb8..136b5251d 100644
--- a/src/test/correct/cjump/gcc/cjump.expected
+++ b/src/test/correct/cjump/gcc/cjump.expected
@@ -16,7 +16,7 @@ const {:extern} $x_addr: bv64;
 axiom ($x_addr == 69652bv64);
 const {:extern} $y_addr: bv64;
 axiom ($y_addr == 69656bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
   false
 }
 
@@ -43,10 +43,6 @@ function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv6
   (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
-}
-
 function {:extern} memory_store32_le(memory: [bv64]bv8, index: bv64, value: bv32) returns ([bv64]bv8) {
   memory[index := value[8:0]][bvadd64(index, 1bv64) := value[16:8]][bvadd64(index, 2bv64) := value[24:16]][bvadd64(index, 3bv64) := value[32:24]]
 }
@@ -56,12 +52,9 @@ function {:extern} {:bvbuiltin "zero_extend 1"} zero_extend1_32(bv32) returns (b
 function {:extern} {:bvbuiltin "zero_extend 32"} zero_extend32_32(bv32) returns (bv64);
 procedure {:extern} rely();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
-  free ensures (memory_load8_le(mem, 1912bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1913bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1914bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1915bv64) == 0bv8);
+  ensures (mem == old(mem));
+  free ensures (memory_load32_le(mem, 1912bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69016bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69024bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69616bv64) == 1812bv64);
@@ -69,8 +62,8 @@ procedure {:extern} rely();
 
 procedure {:extern} rely_transitive();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
+  ensures (mem == old(mem));
 
 implementation {:extern} rely_transitive()
 {
@@ -89,18 +82,12 @@ procedure main();
   requires (gamma_load32(Gamma_mem, $y_addr) == false);
   free requires (memory_load64_le(mem, 69632bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free requires (memory_load8_le(mem, 1912bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1913bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1914bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1915bv64) == 0bv8);
+  free requires (memory_load32_le(mem, 1912bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69016bv64) == 1808bv64);
   free requires (memory_load64_le(mem, 69024bv64) == 1728bv64);
   free requires (memory_load64_le(mem, 69616bv64) == 1812bv64);
   free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free ensures (memory_load8_le(mem, 1912bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1913bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1914bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1915bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1912bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69016bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69024bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69616bv64) == 1812bv64);
diff --git a/src/test/correct/cjump/gcc/cjump_gtirb.expected b/src/test/correct/cjump/gcc/cjump_gtirb.expected
index 6a1713dfe..35ffd3da4 100644
--- a/src/test/correct/cjump/gcc/cjump_gtirb.expected
+++ b/src/test/correct/cjump/gcc/cjump_gtirb.expected
@@ -16,7 +16,7 @@ const {:extern} $x_addr: bv64;
 axiom ($x_addr == 69652bv64);
 const {:extern} $y_addr: bv64;
 axiom ($y_addr == 69656bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
   false
 }
 
@@ -42,10 +42,6 @@ function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv6
   (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
-}
-
 function {:extern} memory_store32_le(memory: [bv64]bv8, index: bv64, value: bv32) returns ([bv64]bv8) {
   memory[index := value[8:0]][bvadd64(index, 1bv64) := value[16:8]][bvadd64(index, 2bv64) := value[24:16]][bvadd64(index, 3bv64) := value[32:24]]
 }
@@ -54,12 +50,9 @@ function {:extern} {:bvbuiltin "zero_extend 1"} zero_extend1_32(bv32) returns (b
 function {:extern} {:bvbuiltin "zero_extend 32"} zero_extend32_32(bv32) returns (bv64);
 procedure {:extern} rely();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
-  free ensures (memory_load8_le(mem, 1912bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1913bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1914bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1915bv64) == 0bv8);
+  ensures (mem == old(mem));
+  free ensures (memory_load32_le(mem, 1912bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69016bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69024bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69616bv64) == 1812bv64);
@@ -67,8 +60,8 @@ procedure {:extern} rely();
 
 procedure {:extern} rely_transitive();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
+  ensures (mem == old(mem));
 
 implementation {:extern} rely_transitive()
 {
@@ -87,18 +80,12 @@ procedure main();
   requires (gamma_load32(Gamma_mem, $y_addr) == false);
   free requires (memory_load64_le(mem, 69632bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free requires (memory_load8_le(mem, 1912bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1913bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1914bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1915bv64) == 0bv8);
+  free requires (memory_load32_le(mem, 1912bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69016bv64) == 1808bv64);
   free requires (memory_load64_le(mem, 69024bv64) == 1728bv64);
   free requires (memory_load64_le(mem, 69616bv64) == 1812bv64);
   free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free ensures (memory_load8_le(mem, 1912bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1913bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1914bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1915bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1912bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69016bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69024bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69616bv64) == 1812bv64);
diff --git a/src/test/correct/cjump/gcc_pic/cjump.expected b/src/test/correct/cjump/gcc_pic/cjump.expected
index 1ea46d0bc..0162d3f40 100644
--- a/src/test/correct/cjump/gcc_pic/cjump.expected
+++ b/src/test/correct/cjump/gcc_pic/cjump.expected
@@ -16,7 +16,7 @@ const {:extern} $x_addr: bv64;
 axiom ($x_addr == 69652bv64);
 const {:extern} $y_addr: bv64;
 axiom ($y_addr == 69656bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
   false
 }
 
@@ -47,10 +47,6 @@ function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv6
   (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
-}
-
 function {:extern} memory_store32_le(memory: [bv64]bv8, index: bv64, value: bv32) returns ([bv64]bv8) {
   memory[index := value[8:0]][bvadd64(index, 1bv64) := value[16:8]][bvadd64(index, 2bv64) := value[24:16]][bvadd64(index, 3bv64) := value[32:24]]
 }
@@ -60,23 +56,20 @@ function {:extern} {:bvbuiltin "zero_extend 1"} zero_extend1_32(bv32) returns (b
 function {:extern} {:bvbuiltin "zero_extend 32"} zero_extend32_32(bv32) returns (bv64);
 procedure {:extern} rely();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
-  free ensures (memory_load8_le(mem, 1976bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1977bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1978bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1979bv64) == 0bv8);
-  free ensures (memory_load64_le(mem, 69608bv64) == 69656bv64);
-  free ensures (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free ensures (memory_load64_le(mem, 69616bv64) == 1876bv64);
+  ensures (mem == old(mem));
+  free ensures (memory_load32_le(mem, 1976bv64) == 131073bv32);
+  free ensures (memory_load64_le(mem, 69000bv64) == 1872bv64);
   free ensures (memory_load64_le(mem, 69008bv64) == 1792bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 69652bv64);
-  free ensures (memory_load64_le(mem, 69000bv64) == 1872bv64);
+  free ensures (memory_load64_le(mem, 69608bv64) == 69656bv64);
+  free ensures (memory_load64_le(mem, 69616bv64) == 1876bv64);
+  free ensures (memory_load64_le(mem, 69640bv64) == 69640bv64);
 
 procedure {:extern} rely_transitive();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
+  ensures (mem == old(mem));
 
 implementation {:extern} rely_transitive()
 {
@@ -95,26 +88,20 @@ procedure main();
   requires (gamma_load32(Gamma_mem, $y_addr) == false);
   free requires (memory_load64_le(mem, 69632bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free requires (memory_load8_le(mem, 1976bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1977bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1978bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1979bv64) == 0bv8);
-  free requires (memory_load64_le(mem, 69608bv64) == 69656bv64);
-  free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free requires (memory_load64_le(mem, 69616bv64) == 1876bv64);
+  free requires (memory_load32_le(mem, 1976bv64) == 131073bv32);
+  free requires (memory_load64_le(mem, 69000bv64) == 1872bv64);
   free requires (memory_load64_le(mem, 69008bv64) == 1792bv64);
   free requires (memory_load64_le(mem, 69592bv64) == 69652bv64);
-  free requires (memory_load64_le(mem, 69000bv64) == 1872bv64);
-  free ensures (memory_load8_le(mem, 1976bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1977bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1978bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1979bv64) == 0bv8);
-  free ensures (memory_load64_le(mem, 69608bv64) == 69656bv64);
-  free ensures (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free ensures (memory_load64_le(mem, 69616bv64) == 1876bv64);
+  free requires (memory_load64_le(mem, 69608bv64) == 69656bv64);
+  free requires (memory_load64_le(mem, 69616bv64) == 1876bv64);
+  free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
+  free ensures (memory_load32_le(mem, 1976bv64) == 131073bv32);
+  free ensures (memory_load64_le(mem, 69000bv64) == 1872bv64);
   free ensures (memory_load64_le(mem, 69008bv64) == 1792bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 69652bv64);
-  free ensures (memory_load64_le(mem, 69000bv64) == 1872bv64);
+  free ensures (memory_load64_le(mem, 69608bv64) == 69656bv64);
+  free ensures (memory_load64_le(mem, 69616bv64) == 1876bv64);
+  free ensures (memory_load64_le(mem, 69640bv64) == 69640bv64);
 
 implementation main()
 {
diff --git a/src/test/correct/cjump/gcc_pic/cjump_gtirb.expected b/src/test/correct/cjump/gcc_pic/cjump_gtirb.expected
index 7f8c66615..0e9fdc0b6 100644
--- a/src/test/correct/cjump/gcc_pic/cjump_gtirb.expected
+++ b/src/test/correct/cjump/gcc_pic/cjump_gtirb.expected
@@ -16,7 +16,7 @@ const {:extern} $x_addr: bv64;
 axiom ($x_addr == 69652bv64);
 const {:extern} $y_addr: bv64;
 axiom ($y_addr == 69656bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
   false
 }
 
@@ -46,10 +46,6 @@ function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv6
   (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
-}
-
 function {:extern} memory_store32_le(memory: [bv64]bv8, index: bv64, value: bv32) returns ([bv64]bv8) {
   memory[index := value[8:0]][bvadd64(index, 1bv64) := value[16:8]][bvadd64(index, 2bv64) := value[24:16]][bvadd64(index, 3bv64) := value[32:24]]
 }
@@ -58,23 +54,20 @@ function {:extern} {:bvbuiltin "zero_extend 1"} zero_extend1_32(bv32) returns (b
 function {:extern} {:bvbuiltin "zero_extend 32"} zero_extend32_32(bv32) returns (bv64);
 procedure {:extern} rely();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
-  free ensures (memory_load8_le(mem, 1976bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1977bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1978bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1979bv64) == 0bv8);
-  free ensures (memory_load64_le(mem, 69608bv64) == 69656bv64);
-  free ensures (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free ensures (memory_load64_le(mem, 69616bv64) == 1876bv64);
+  ensures (mem == old(mem));
+  free ensures (memory_load32_le(mem, 1976bv64) == 131073bv32);
+  free ensures (memory_load64_le(mem, 69000bv64) == 1872bv64);
   free ensures (memory_load64_le(mem, 69008bv64) == 1792bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 69652bv64);
-  free ensures (memory_load64_le(mem, 69000bv64) == 1872bv64);
+  free ensures (memory_load64_le(mem, 69608bv64) == 69656bv64);
+  free ensures (memory_load64_le(mem, 69616bv64) == 1876bv64);
+  free ensures (memory_load64_le(mem, 69640bv64) == 69640bv64);
 
 procedure {:extern} rely_transitive();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
+  ensures (mem == old(mem));
 
 implementation {:extern} rely_transitive()
 {
@@ -93,26 +86,20 @@ procedure main();
   requires (gamma_load32(Gamma_mem, $y_addr) == false);
   free requires (memory_load64_le(mem, 69632bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free requires (memory_load8_le(mem, 1976bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1977bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1978bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1979bv64) == 0bv8);
-  free requires (memory_load64_le(mem, 69608bv64) == 69656bv64);
-  free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free requires (memory_load64_le(mem, 69616bv64) == 1876bv64);
+  free requires (memory_load32_le(mem, 1976bv64) == 131073bv32);
+  free requires (memory_load64_le(mem, 69000bv64) == 1872bv64);
   free requires (memory_load64_le(mem, 69008bv64) == 1792bv64);
   free requires (memory_load64_le(mem, 69592bv64) == 69652bv64);
-  free requires (memory_load64_le(mem, 69000bv64) == 1872bv64);
-  free ensures (memory_load8_le(mem, 1976bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1977bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1978bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1979bv64) == 0bv8);
-  free ensures (memory_load64_le(mem, 69608bv64) == 69656bv64);
-  free ensures (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free ensures (memory_load64_le(mem, 69616bv64) == 1876bv64);
+  free requires (memory_load64_le(mem, 69608bv64) == 69656bv64);
+  free requires (memory_load64_le(mem, 69616bv64) == 1876bv64);
+  free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
+  free ensures (memory_load32_le(mem, 1976bv64) == 131073bv32);
+  free ensures (memory_load64_le(mem, 69000bv64) == 1872bv64);
   free ensures (memory_load64_le(mem, 69008bv64) == 1792bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 69652bv64);
-  free ensures (memory_load64_le(mem, 69000bv64) == 1872bv64);
+  free ensures (memory_load64_le(mem, 69608bv64) == 69656bv64);
+  free ensures (memory_load64_le(mem, 69616bv64) == 1876bv64);
+  free ensures (memory_load64_le(mem, 69640bv64) == 69640bv64);
 
 implementation main()
 {
diff --git a/src/test/correct/floatingpoint/clang/floatingpoint_gtirb.expected b/src/test/correct/floatingpoint/clang/floatingpoint_gtirb.expected
index eb7ad317b..376b609a9 100644
--- a/src/test/correct/floatingpoint/clang/floatingpoint_gtirb.expected
+++ b/src/test/correct/floatingpoint/clang/floatingpoint_gtirb.expected
@@ -29,7 +29,7 @@ function FPMul$64(bv64, bv64, bv32) returns (bv64);
 function FPSub$32(bv32, bv32, bv32) returns (bv32);
 function FPSub$64(bv64, bv64, bv32) returns (bv64);
 function FPToFixed$32$64(bv64, int, bool, bv32, int) returns (bv32);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
   false
 }
 
@@ -72,8 +72,8 @@ function {:extern} {:bvbuiltin "zero_extend 64"} zero_extend64_64(bv64) returns
 function {:extern} {:bvbuiltin "zero_extend 96"} zero_extend96_32(bv32) returns (bv128);
 procedure {:extern} rely();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
+  ensures (mem == old(mem));
   free ensures (memory_load64_le(mem, 2088bv64) == 131073bv64);
   free ensures (memory_load64_le(mem, 2096bv64) == 4767034467667331754bv64);
   free ensures (memory_load64_le(mem, 69064bv64) == 1808bv64);
@@ -83,8 +83,8 @@ procedure {:extern} rely();
 
 procedure {:extern} rely_transitive();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
+  ensures (mem == old(mem));
 
 implementation {:extern} rely_transitive()
 {
@@ -171,25 +171,25 @@ implementation main()
     assume {:captureState "1856$0"} true;
     V0, Gamma_V0 := zero_extend96_32(memory_load32_le(stack, bvadd64(R31, 44bv64))), gamma_load32(Gamma_stack, bvadd64(R31, 44bv64));
     V1, Gamma_V1 := zero_extend96_32(memory_load32_le(stack, bvadd64(R31, 40bv64))), gamma_load32(Gamma_stack, bvadd64(R31, 40bv64));
-    Exp9__5$0$14, Gamma_Exp9__5$0$14 := FPMul$32(V0[32:0], V1[32:0], FPCR), (Gamma_FPCR && (Gamma_V1 && Gamma_V0));
+    Exp9__5$0$14, Gamma_Exp9__5$0$14 := FPMul$32(V0[32:0], V1[32:0], FPCR), true;
     V0, Gamma_V0 := zero_extend96_32(Exp9__5$0$14), Gamma_Exp9__5$0$14;
     stack, Gamma_stack := memory_store32_le(stack, bvadd64(R31, 36bv64), V0[32:0]), gamma_store32(Gamma_stack, bvadd64(R31, 36bv64), Gamma_V0);
     assume {:captureState "1872$0"} true;
     V0, Gamma_V0 := zero_extend96_32(memory_load32_le(stack, bvadd64(R31, 44bv64))), gamma_load32(Gamma_stack, bvadd64(R31, 44bv64));
     V1, Gamma_V1 := zero_extend96_32(memory_load32_le(stack, bvadd64(R31, 40bv64))), gamma_load32(Gamma_stack, bvadd64(R31, 40bv64));
-    Exp9__5$0$18, Gamma_Exp9__5$0$18 := FPDiv$32(V0[32:0], V1[32:0], FPCR), (Gamma_FPCR && (Gamma_V1 && Gamma_V0));
+    Exp9__5$0$18, Gamma_Exp9__5$0$18 := FPDiv$32(V0[32:0], V1[32:0], FPCR), true;
     V0, Gamma_V0 := zero_extend96_32(Exp9__5$0$18), Gamma_Exp9__5$0$18;
     stack, Gamma_stack := memory_store32_le(stack, bvadd64(R31, 36bv64), V0[32:0]), gamma_store32(Gamma_stack, bvadd64(R31, 36bv64), Gamma_V0);
     assume {:captureState "1888$0"} true;
     V0, Gamma_V0 := zero_extend96_32(memory_load32_le(stack, bvadd64(R31, 44bv64))), gamma_load32(Gamma_stack, bvadd64(R31, 44bv64));
     V1, Gamma_V1 := zero_extend96_32(memory_load32_le(stack, bvadd64(R31, 40bv64))), gamma_load32(Gamma_stack, bvadd64(R31, 40bv64));
-    Exp9__5$0$22, Gamma_Exp9__5$0$22 := FPSub$32(V0[32:0], V1[32:0], FPCR), (Gamma_FPCR && (Gamma_V1 && Gamma_V0));
+    Exp9__5$0$22, Gamma_Exp9__5$0$22 := FPSub$32(V0[32:0], V1[32:0], FPCR), true;
     V0, Gamma_V0 := zero_extend96_32(Exp9__5$0$22), Gamma_Exp9__5$0$22;
     stack, Gamma_stack := memory_store32_le(stack, bvadd64(R31, 36bv64), V0[32:0]), gamma_store32(Gamma_stack, bvadd64(R31, 36bv64), Gamma_V0);
     assume {:captureState "1904$0"} true;
     V0, Gamma_V0 := zero_extend96_32(memory_load32_le(stack, bvadd64(R31, 44bv64))), gamma_load32(Gamma_stack, bvadd64(R31, 44bv64));
     V1, Gamma_V1 := zero_extend96_32(memory_load32_le(stack, bvadd64(R31, 40bv64))), gamma_load32(Gamma_stack, bvadd64(R31, 40bv64));
-    Exp9__5$0$26, Gamma_Exp9__5$0$26 := FPAdd$32(V0[32:0], V1[32:0], FPCR), (Gamma_FPCR && (Gamma_V1 && Gamma_V0));
+    Exp9__5$0$26, Gamma_Exp9__5$0$26 := FPAdd$32(V0[32:0], V1[32:0], FPCR), true;
     V0, Gamma_V0 := zero_extend96_32(Exp9__5$0$26), Gamma_Exp9__5$0$26;
     stack, Gamma_stack := memory_store32_le(stack, bvadd64(R31, 36bv64), V0[32:0]), gamma_store32(Gamma_stack, bvadd64(R31, 36bv64), Gamma_V0);
     assume {:captureState "1920$0"} true;
@@ -201,53 +201,53 @@ implementation main()
     V0, Gamma_V0 := zero_extend64_64(memory_load64_le(stack, bvadd64(R31, 24bv64))), gamma_load64(Gamma_stack, bvadd64(R31, 24bv64));
     V1, Gamma_V1 := zero_extend96_32(memory_load32_le(stack, bvadd64(R31, 40bv64))), gamma_load32(Gamma_stack, bvadd64(R31, 40bv64));
     FPDecodeRounding8__7, Gamma_FPDecodeRounding8__7 := zero_extend1_2(FPCR[24:22]), Gamma_FPCR;
-    Exp10__6$0$33, Gamma_Exp10__6$0$33 := FPConvert$64$32(V1[32:0], FPCR), (Gamma_FPCR && Gamma_V1);
+    Exp10__6$0$33, Gamma_Exp10__6$0$33 := FPConvert$64$32(V1[32:0], FPCR), true;
     V1, Gamma_V1 := zero_extend64_64(Exp10__6$0$33), Gamma_Exp10__6$0$33;
-    Exp9__5$0$34, Gamma_Exp9__5$0$34 := FPMul$64(V0[64:0], V1[64:0], FPCR), (Gamma_FPCR && (Gamma_V1 && Gamma_V0));
+    Exp9__5$0$34, Gamma_Exp9__5$0$34 := FPMul$64(V0[64:0], V1[64:0], FPCR), true;
     V0, Gamma_V0 := zero_extend64_64(Exp9__5$0$34), Gamma_Exp9__5$0$34;
     stack, Gamma_stack := memory_store64_le(stack, bvadd64(R31, 16bv64), V0[64:0]), gamma_store64(Gamma_stack, bvadd64(R31, 16bv64), Gamma_V0);
     assume {:captureState "1952$0"} true;
     V0, Gamma_V0 := zero_extend64_64(memory_load64_le(stack, bvadd64(R31, 24bv64))), gamma_load64(Gamma_stack, bvadd64(R31, 24bv64));
     V1, Gamma_V1 := zero_extend96_32(memory_load32_le(stack, bvadd64(R31, 40bv64))), gamma_load32(Gamma_stack, bvadd64(R31, 40bv64));
     FPDecodeRounding8__7, Gamma_FPDecodeRounding8__7 := zero_extend1_2(FPCR[24:22]), Gamma_FPCR;
-    Exp10__6$0$38, Gamma_Exp10__6$0$38 := FPConvert$64$32(V1[32:0], FPCR), (Gamma_FPCR && Gamma_V1);
+    Exp10__6$0$38, Gamma_Exp10__6$0$38 := FPConvert$64$32(V1[32:0], FPCR), true;
     V1, Gamma_V1 := zero_extend64_64(Exp10__6$0$38), Gamma_Exp10__6$0$38;
-    Exp9__5$0$39, Gamma_Exp9__5$0$39 := FPSub$64(V0[64:0], V1[64:0], FPCR), (Gamma_FPCR && (Gamma_V1 && Gamma_V0));
+    Exp9__5$0$39, Gamma_Exp9__5$0$39 := FPSub$64(V0[64:0], V1[64:0], FPCR), true;
     V0, Gamma_V0 := zero_extend64_64(Exp9__5$0$39), Gamma_Exp9__5$0$39;
     stack, Gamma_stack := memory_store64_le(stack, bvadd64(R31, 16bv64), V0[64:0]), gamma_store64(Gamma_stack, bvadd64(R31, 16bv64), Gamma_V0);
     assume {:captureState "1972$0"} true;
     V0, Gamma_V0 := zero_extend64_64(memory_load64_le(stack, bvadd64(R31, 24bv64))), gamma_load64(Gamma_stack, bvadd64(R31, 24bv64));
     V1, Gamma_V1 := zero_extend96_32(memory_load32_le(stack, bvadd64(R31, 40bv64))), gamma_load32(Gamma_stack, bvadd64(R31, 40bv64));
     FPDecodeRounding8__7, Gamma_FPDecodeRounding8__7 := zero_extend1_2(FPCR[24:22]), Gamma_FPCR;
-    Exp10__6$0$43, Gamma_Exp10__6$0$43 := FPConvert$64$32(V1[32:0], FPCR), (Gamma_FPCR && Gamma_V1);
+    Exp10__6$0$43, Gamma_Exp10__6$0$43 := FPConvert$64$32(V1[32:0], FPCR), true;
     V1, Gamma_V1 := zero_extend64_64(Exp10__6$0$43), Gamma_Exp10__6$0$43;
-    Exp9__5$0$44, Gamma_Exp9__5$0$44 := FPAdd$64(V0[64:0], V1[64:0], FPCR), (Gamma_FPCR && (Gamma_V1 && Gamma_V0));
+    Exp9__5$0$44, Gamma_Exp9__5$0$44 := FPAdd$64(V0[64:0], V1[64:0], FPCR), true;
     V0, Gamma_V0 := zero_extend64_64(Exp9__5$0$44), Gamma_Exp9__5$0$44;
     stack, Gamma_stack := memory_store64_le(stack, bvadd64(R31, 16bv64), V0[64:0]), gamma_store64(Gamma_stack, bvadd64(R31, 16bv64), Gamma_V0);
     assume {:captureState "1992$0"} true;
     V0, Gamma_V0 := zero_extend64_64(memory_load64_le(stack, bvadd64(R31, 24bv64))), gamma_load64(Gamma_stack, bvadd64(R31, 24bv64));
     V1, Gamma_V1 := zero_extend96_32(memory_load32_le(stack, bvadd64(R31, 40bv64))), gamma_load32(Gamma_stack, bvadd64(R31, 40bv64));
     FPDecodeRounding8__7, Gamma_FPDecodeRounding8__7 := zero_extend1_2(FPCR[24:22]), Gamma_FPCR;
-    Exp10__6$0$48, Gamma_Exp10__6$0$48 := FPConvert$64$32(V1[32:0], FPCR), (Gamma_FPCR && Gamma_V1);
+    Exp10__6$0$48, Gamma_Exp10__6$0$48 := FPConvert$64$32(V1[32:0], FPCR), true;
     V1, Gamma_V1 := zero_extend64_64(Exp10__6$0$48), Gamma_Exp10__6$0$48;
-    Exp9__5$0$49, Gamma_Exp9__5$0$49 := FPDiv$64(V0[64:0], V1[64:0], FPCR), (Gamma_FPCR && (Gamma_V1 && Gamma_V0));
+    Exp9__5$0$49, Gamma_Exp9__5$0$49 := FPDiv$64(V0[64:0], V1[64:0], FPCR), true;
     V0, Gamma_V0 := zero_extend64_64(Exp9__5$0$49), Gamma_Exp9__5$0$49;
     stack, Gamma_stack := memory_store64_le(stack, bvadd64(R31, 16bv64), V0[64:0]), gamma_store64(Gamma_stack, bvadd64(R31, 16bv64), Gamma_V0);
     assume {:captureState "2012$0"} true;
     V0, Gamma_V0 := zero_extend64_64(memory_load64_le(stack, bvadd64(R31, 16bv64))), gamma_load64(Gamma_stack, bvadd64(R31, 16bv64));
     FPDecodeRounding8__7, Gamma_FPDecodeRounding8__7 := zero_extend1_2(FPCR[24:22]), Gamma_FPCR;
-    Exp10__6$0$52, Gamma_Exp10__6$0$52 := FPConvert$32$64(V0[64:0], FPCR), (Gamma_FPCR && Gamma_V0);
+    Exp10__6$0$52, Gamma_Exp10__6$0$52 := FPConvert$32$64(V0[64:0], FPCR), true;
     V0, Gamma_V0 := zero_extend96_32(Exp10__6$0$52), Gamma_Exp10__6$0$52;
     stack, Gamma_stack := memory_store32_le(stack, bvadd64(R31, 44bv64), V0[32:0]), gamma_store32(Gamma_stack, bvadd64(R31, 44bv64), Gamma_V0);
     assume {:captureState "2024$0"} true;
     V0, Gamma_V0 := zero_extend96_32(memory_load32_le(stack, bvadd64(R31, 40bv64))), gamma_load32(Gamma_stack, bvadd64(R31, 40bv64));
     FPDecodeRounding8__7, Gamma_FPDecodeRounding8__7 := zero_extend1_2(FPCR[24:22]), Gamma_FPCR;
-    Exp10__6$0$55, Gamma_Exp10__6$0$55 := FPConvert$64$32(V0[32:0], FPCR), (Gamma_FPCR && Gamma_V0);
+    Exp10__6$0$55, Gamma_Exp10__6$0$55 := FPConvert$64$32(V0[32:0], FPCR), true;
     V0, Gamma_V0 := zero_extend64_64(Exp10__6$0$55), Gamma_Exp10__6$0$55;
     stack, Gamma_stack := memory_store64_le(stack, bvadd64(R31, 24bv64), V0[64:0]), gamma_store64(Gamma_stack, bvadd64(R31, 24bv64), Gamma_V0);
     assume {:captureState "2036$0"} true;
     V0, Gamma_V0 := zero_extend64_64(memory_load64_le(stack, bvadd64(R31, 16bv64))), gamma_load64(Gamma_stack, bvadd64(R31, 16bv64));
-    Exp7__5$0$58, Gamma_Exp7__5$0$58 := FPToFixed$32$64(V0[64:0], 0, false, FPCR, 3), (Gamma_FPCR && Gamma_V0);
+    Exp7__5$0$58, Gamma_Exp7__5$0$58 := FPToFixed$32$64(V0[64:0], 0, false, FPCR, 3), true;
     R8, Gamma_R8 := zero_extend32_32(Exp7__5$0$58), Gamma_Exp7__5$0$58;
     stack, Gamma_stack := memory_store32_le(stack, bvadd64(R31, 12bv64), R8[32:0]), gamma_store32(Gamma_stack, bvadd64(R31, 12bv64), Gamma_R8);
     assume {:captureState "2048$0"} true;
diff --git a/src/test/correct/floatingpoint/gcc/floatingpoint_gtirb.expected b/src/test/correct/floatingpoint/gcc/floatingpoint_gtirb.expected
index 065a70ac3..72d704dc3 100644
--- a/src/test/correct/floatingpoint/gcc/floatingpoint_gtirb.expected
+++ b/src/test/correct/floatingpoint/gcc/floatingpoint_gtirb.expected
@@ -27,7 +27,7 @@ function FPMul$64(bv64, bv64, bv32) returns (bv64);
 function FPSub$32(bv32, bv32, bv32) returns (bv32);
 function FPSub$64(bv64, bv64, bv32) returns (bv64);
 function FPToFixed$32$64(bv64, int, bool, bv32, int) returns (bv32);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
   false
 }
 
@@ -70,8 +70,8 @@ function {:extern} {:bvbuiltin "zero_extend 64"} zero_extend64_64(bv64) returns
 function {:extern} {:bvbuiltin "zero_extend 96"} zero_extend96_32(bv32) returns (bv128);
 procedure {:extern} rely();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
+  ensures (mem == old(mem));
   free ensures (memory_load64_le(mem, 2080bv64) == 131073bv64);
   free ensures (memory_load64_le(mem, 2088bv64) == 4767034467667331754bv64);
   free ensures (memory_load64_le(mem, 69016bv64) == 1808bv64);
@@ -81,8 +81,8 @@ procedure {:extern} rely();
 
 procedure {:extern} rely_transitive();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
+  ensures (mem == old(mem));
 
 implementation {:extern} rely_transitive()
 {
@@ -167,25 +167,25 @@ implementation main()
     assume {:captureState "1852$0"} true;
     V1, Gamma_V1 := zero_extend96_32(memory_load32_le(stack, bvadd64(R31, 16bv64))), gamma_load32(Gamma_stack, bvadd64(R31, 16bv64));
     V0, Gamma_V0 := zero_extend96_32(memory_load32_le(stack, bvadd64(R31, 20bv64))), gamma_load32(Gamma_stack, bvadd64(R31, 20bv64));
-    Exp9__5$0$13, Gamma_Exp9__5$0$13 := FPMul$32(V1[32:0], V0[32:0], FPCR), (Gamma_FPCR && (Gamma_V0 && Gamma_V1));
+    Exp9__5$0$13, Gamma_Exp9__5$0$13 := FPMul$32(V1[32:0], V0[32:0], FPCR), true;
     V0, Gamma_V0 := zero_extend96_32(Exp9__5$0$13), Gamma_Exp9__5$0$13;
     stack, Gamma_stack := memory_store32_le(stack, bvadd64(R31, 24bv64), V0[32:0]), gamma_store32(Gamma_stack, bvadd64(R31, 24bv64), Gamma_V0);
     assume {:captureState "1868$0"} true;
     V0, Gamma_V0 := zero_extend96_32(memory_load32_le(stack, bvadd64(R31, 20bv64))), gamma_load32(Gamma_stack, bvadd64(R31, 20bv64));
     V1, Gamma_V1 := zero_extend96_32(memory_load32_le(stack, bvadd64(R31, 16bv64))), gamma_load32(Gamma_stack, bvadd64(R31, 16bv64));
-    Exp9__5$0$17, Gamma_Exp9__5$0$17 := FPDiv$32(V1[32:0], V0[32:0], FPCR), (Gamma_FPCR && (Gamma_V0 && Gamma_V1));
+    Exp9__5$0$17, Gamma_Exp9__5$0$17 := FPDiv$32(V1[32:0], V0[32:0], FPCR), true;
     V0, Gamma_V0 := zero_extend96_32(Exp9__5$0$17), Gamma_Exp9__5$0$17;
     stack, Gamma_stack := memory_store32_le(stack, bvadd64(R31, 24bv64), V0[32:0]), gamma_store32(Gamma_stack, bvadd64(R31, 24bv64), Gamma_V0);
     assume {:captureState "1884$0"} true;
     V1, Gamma_V1 := zero_extend96_32(memory_load32_le(stack, bvadd64(R31, 16bv64))), gamma_load32(Gamma_stack, bvadd64(R31, 16bv64));
     V0, Gamma_V0 := zero_extend96_32(memory_load32_le(stack, bvadd64(R31, 20bv64))), gamma_load32(Gamma_stack, bvadd64(R31, 20bv64));
-    Exp9__5$0$21, Gamma_Exp9__5$0$21 := FPSub$32(V1[32:0], V0[32:0], FPCR), (Gamma_FPCR && (Gamma_V0 && Gamma_V1));
+    Exp9__5$0$21, Gamma_Exp9__5$0$21 := FPSub$32(V1[32:0], V0[32:0], FPCR), true;
     V0, Gamma_V0 := zero_extend96_32(Exp9__5$0$21), Gamma_Exp9__5$0$21;
     stack, Gamma_stack := memory_store32_le(stack, bvadd64(R31, 24bv64), V0[32:0]), gamma_store32(Gamma_stack, bvadd64(R31, 24bv64), Gamma_V0);
     assume {:captureState "1900$0"} true;
     V1, Gamma_V1 := zero_extend96_32(memory_load32_le(stack, bvadd64(R31, 16bv64))), gamma_load32(Gamma_stack, bvadd64(R31, 16bv64));
     V0, Gamma_V0 := zero_extend96_32(memory_load32_le(stack, bvadd64(R31, 20bv64))), gamma_load32(Gamma_stack, bvadd64(R31, 20bv64));
-    Exp9__5$0$25, Gamma_Exp9__5$0$25 := FPAdd$32(V1[32:0], V0[32:0], FPCR), (Gamma_FPCR && (Gamma_V0 && Gamma_V1));
+    Exp9__5$0$25, Gamma_Exp9__5$0$25 := FPAdd$32(V1[32:0], V0[32:0], FPCR), true;
     V0, Gamma_V0 := zero_extend96_32(Exp9__5$0$25), Gamma_Exp9__5$0$25;
     stack, Gamma_stack := memory_store32_le(stack, bvadd64(R31, 24bv64), V0[32:0]), gamma_store32(Gamma_stack, bvadd64(R31, 24bv64), Gamma_V0);
     assume {:captureState "1916$0"} true;
@@ -196,54 +196,54 @@ implementation main()
     assume {:captureState "1928$0"} true;
     V0, Gamma_V0 := zero_extend96_32(memory_load32_le(stack, bvadd64(R31, 20bv64))), gamma_load32(Gamma_stack, bvadd64(R31, 20bv64));
     FPDecodeRounding8__7, Gamma_FPDecodeRounding8__7 := zero_extend1_2(FPCR[24:22]), Gamma_FPCR;
-    Exp10__6$0$31, Gamma_Exp10__6$0$31 := FPConvert$64$32(V0[32:0], FPCR), (Gamma_FPCR && Gamma_V0);
+    Exp10__6$0$31, Gamma_Exp10__6$0$31 := FPConvert$64$32(V0[32:0], FPCR), true;
     V0, Gamma_V0 := zero_extend64_64(Exp10__6$0$31), Gamma_Exp10__6$0$31;
     V1, Gamma_V1 := zero_extend64_64(memory_load64_le(stack, bvadd64(R31, 32bv64))), gamma_load64(Gamma_stack, bvadd64(R31, 32bv64));
-    Exp9__5$0$33, Gamma_Exp9__5$0$33 := FPMul$64(V1[64:0], V0[64:0], FPCR), (Gamma_FPCR && (Gamma_V0 && Gamma_V1));
+    Exp9__5$0$33, Gamma_Exp9__5$0$33 := FPMul$64(V1[64:0], V0[64:0], FPCR), true;
     V0, Gamma_V0 := zero_extend64_64(Exp9__5$0$33), Gamma_Exp9__5$0$33;
     stack, Gamma_stack := memory_store64_le(stack, bvadd64(R31, 40bv64), V0[64:0]), gamma_store64(Gamma_stack, bvadd64(R31, 40bv64), Gamma_V0);
     assume {:captureState "1948$0"} true;
     V0, Gamma_V0 := zero_extend96_32(memory_load32_le(stack, bvadd64(R31, 20bv64))), gamma_load32(Gamma_stack, bvadd64(R31, 20bv64));
     FPDecodeRounding8__7, Gamma_FPDecodeRounding8__7 := zero_extend1_2(FPCR[24:22]), Gamma_FPCR;
-    Exp10__6$0$36, Gamma_Exp10__6$0$36 := FPConvert$64$32(V0[32:0], FPCR), (Gamma_FPCR && Gamma_V0);
+    Exp10__6$0$36, Gamma_Exp10__6$0$36 := FPConvert$64$32(V0[32:0], FPCR), true;
     V0, Gamma_V0 := zero_extend64_64(Exp10__6$0$36), Gamma_Exp10__6$0$36;
     V1, Gamma_V1 := zero_extend64_64(memory_load64_le(stack, bvadd64(R31, 32bv64))), gamma_load64(Gamma_stack, bvadd64(R31, 32bv64));
-    Exp9__5$0$38, Gamma_Exp9__5$0$38 := FPSub$64(V1[64:0], V0[64:0], FPCR), (Gamma_FPCR && (Gamma_V0 && Gamma_V1));
+    Exp9__5$0$38, Gamma_Exp9__5$0$38 := FPSub$64(V1[64:0], V0[64:0], FPCR), true;
     V0, Gamma_V0 := zero_extend64_64(Exp9__5$0$38), Gamma_Exp9__5$0$38;
     stack, Gamma_stack := memory_store64_le(stack, bvadd64(R31, 40bv64), V0[64:0]), gamma_store64(Gamma_stack, bvadd64(R31, 40bv64), Gamma_V0);
     assume {:captureState "1968$0"} true;
     V0, Gamma_V0 := zero_extend96_32(memory_load32_le(stack, bvadd64(R31, 20bv64))), gamma_load32(Gamma_stack, bvadd64(R31, 20bv64));
     FPDecodeRounding8__7, Gamma_FPDecodeRounding8__7 := zero_extend1_2(FPCR[24:22]), Gamma_FPCR;
-    Exp10__6$0$41, Gamma_Exp10__6$0$41 := FPConvert$64$32(V0[32:0], FPCR), (Gamma_FPCR && Gamma_V0);
+    Exp10__6$0$41, Gamma_Exp10__6$0$41 := FPConvert$64$32(V0[32:0], FPCR), true;
     V0, Gamma_V0 := zero_extend64_64(Exp10__6$0$41), Gamma_Exp10__6$0$41;
     V1, Gamma_V1 := zero_extend64_64(memory_load64_le(stack, bvadd64(R31, 32bv64))), gamma_load64(Gamma_stack, bvadd64(R31, 32bv64));
-    Exp9__5$0$43, Gamma_Exp9__5$0$43 := FPAdd$64(V1[64:0], V0[64:0], FPCR), (Gamma_FPCR && (Gamma_V0 && Gamma_V1));
+    Exp9__5$0$43, Gamma_Exp9__5$0$43 := FPAdd$64(V1[64:0], V0[64:0], FPCR), true;
     V0, Gamma_V0 := zero_extend64_64(Exp9__5$0$43), Gamma_Exp9__5$0$43;
     stack, Gamma_stack := memory_store64_le(stack, bvadd64(R31, 40bv64), V0[64:0]), gamma_store64(Gamma_stack, bvadd64(R31, 40bv64), Gamma_V0);
     assume {:captureState "1988$0"} true;
     V0, Gamma_V0 := zero_extend96_32(memory_load32_le(stack, bvadd64(R31, 20bv64))), gamma_load32(Gamma_stack, bvadd64(R31, 20bv64));
     FPDecodeRounding8__7, Gamma_FPDecodeRounding8__7 := zero_extend1_2(FPCR[24:22]), Gamma_FPCR;
-    Exp10__6$0$46, Gamma_Exp10__6$0$46 := FPConvert$64$32(V0[32:0], FPCR), (Gamma_FPCR && Gamma_V0);
+    Exp10__6$0$46, Gamma_Exp10__6$0$46 := FPConvert$64$32(V0[32:0], FPCR), true;
     V0, Gamma_V0 := zero_extend64_64(Exp10__6$0$46), Gamma_Exp10__6$0$46;
     V1, Gamma_V1 := zero_extend64_64(memory_load64_le(stack, bvadd64(R31, 32bv64))), gamma_load64(Gamma_stack, bvadd64(R31, 32bv64));
-    Exp9__5$0$48, Gamma_Exp9__5$0$48 := FPDiv$64(V1[64:0], V0[64:0], FPCR), (Gamma_FPCR && (Gamma_V0 && Gamma_V1));
+    Exp9__5$0$48, Gamma_Exp9__5$0$48 := FPDiv$64(V1[64:0], V0[64:0], FPCR), true;
     V0, Gamma_V0 := zero_extend64_64(Exp9__5$0$48), Gamma_Exp9__5$0$48;
     stack, Gamma_stack := memory_store64_le(stack, bvadd64(R31, 40bv64), V0[64:0]), gamma_store64(Gamma_stack, bvadd64(R31, 40bv64), Gamma_V0);
     assume {:captureState "2008$0"} true;
     V0, Gamma_V0 := zero_extend64_64(memory_load64_le(stack, bvadd64(R31, 40bv64))), gamma_load64(Gamma_stack, bvadd64(R31, 40bv64));
     FPDecodeRounding8__7, Gamma_FPDecodeRounding8__7 := zero_extend1_2(FPCR[24:22]), Gamma_FPCR;
-    Exp10__6$0$51, Gamma_Exp10__6$0$51 := FPConvert$32$64(V0[64:0], FPCR), (Gamma_FPCR && Gamma_V0);
+    Exp10__6$0$51, Gamma_Exp10__6$0$51 := FPConvert$32$64(V0[64:0], FPCR), true;
     V0, Gamma_V0 := zero_extend96_32(Exp10__6$0$51), Gamma_Exp10__6$0$51;
     stack, Gamma_stack := memory_store32_le(stack, bvadd64(R31, 16bv64), V0[32:0]), gamma_store32(Gamma_stack, bvadd64(R31, 16bv64), Gamma_V0);
     assume {:captureState "2020$0"} true;
     V0, Gamma_V0 := zero_extend96_32(memory_load32_le(stack, bvadd64(R31, 20bv64))), gamma_load32(Gamma_stack, bvadd64(R31, 20bv64));
     FPDecodeRounding8__7, Gamma_FPDecodeRounding8__7 := zero_extend1_2(FPCR[24:22]), Gamma_FPCR;
-    Exp10__6$0$54, Gamma_Exp10__6$0$54 := FPConvert$64$32(V0[32:0], FPCR), (Gamma_FPCR && Gamma_V0);
+    Exp10__6$0$54, Gamma_Exp10__6$0$54 := FPConvert$64$32(V0[32:0], FPCR), true;
     V0, Gamma_V0 := zero_extend64_64(Exp10__6$0$54), Gamma_Exp10__6$0$54;
     stack, Gamma_stack := memory_store64_le(stack, bvadd64(R31, 32bv64), V0[64:0]), gamma_store64(Gamma_stack, bvadd64(R31, 32bv64), Gamma_V0);
     assume {:captureState "2032$0"} true;
     V0, Gamma_V0 := zero_extend64_64(memory_load64_le(stack, bvadd64(R31, 40bv64))), gamma_load64(Gamma_stack, bvadd64(R31, 40bv64));
-    Exp7__5$0$57, Gamma_Exp7__5$0$57 := FPToFixed$32$64(V0[64:0], 0, false, FPCR, 3), (Gamma_FPCR && Gamma_V0);
+    Exp7__5$0$57, Gamma_Exp7__5$0$57 := FPToFixed$32$64(V0[64:0], 0, false, FPCR, 3), true;
     R0, Gamma_R0 := zero_extend32_32(Exp7__5$0$57), Gamma_Exp7__5$0$57;
     stack, Gamma_stack := memory_store32_le(stack, bvadd64(R31, 28bv64), R0[32:0]), gamma_store32(Gamma_stack, bvadd64(R31, 28bv64), Gamma_R0);
     assume {:captureState "2044$0"} true;
diff --git a/src/test/correct/function/clang/function.expected b/src/test/correct/function/clang/function.expected
index c1e865cdf..30f7cb520 100644
--- a/src/test/correct/function/clang/function.expected
+++ b/src/test/correct/function/clang/function.expected
@@ -18,7 +18,7 @@ const {:extern} $x_addr: bv64;
 axiom ($x_addr == 69684bv64);
 const {:extern} $y_addr: bv64;
 axiom ($y_addr == 69688bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
   false
 }
 
@@ -39,12 +39,12 @@ function {:extern} gamma_store64(gammaMap: [bv64]bool, index: bv64, value: bool)
   gammaMap[index := value][bvadd64(index, 1bv64) := value][bvadd64(index, 2bv64) := value][bvadd64(index, 3bv64) := value][bvadd64(index, 4bv64) := value][bvadd64(index, 5bv64) := value][bvadd64(index, 6bv64) := value][bvadd64(index, 7bv64) := value]
 }
 
-function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv64) {
-  (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
+function {:extern} memory_load32_le(memory: [bv64]bv8, index: bv64) returns (bv32) {
+  (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
+function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv64) {
+  (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
 function {:extern} memory_store32_le(memory: [bv64]bv8, index: bv64, value: bv32) returns ([bv64]bv8) {
@@ -57,12 +57,9 @@ function {:extern} memory_store64_le(memory: [bv64]bv8, index: bv64, value: bv64
 
 procedure {:extern} rely();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
-  free ensures (memory_load8_le(mem, 1884bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1885bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1886bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1887bv64) == 0bv8);
+  ensures (mem == old(mem));
+  free ensures (memory_load32_le(mem, 1884bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1812bv64);
@@ -70,8 +67,8 @@ procedure {:extern} rely();
 
 procedure {:extern} rely_transitive();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
+  ensures (mem == old(mem));
 
 implementation {:extern} rely_transitive()
 {
@@ -86,19 +83,13 @@ procedure {:extern} guarantee_reflexive();
 
 procedure get_two();
   modifies Gamma_R0, R0;
-  free requires (memory_load8_le(mem, 1884bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1885bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1886bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1887bv64) == 0bv8);
+  free requires (memory_load32_le(mem, 1884bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free requires (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free requires (memory_load64_le(mem, 69592bv64) == 1812bv64);
   free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
   ensures (Gamma_R0 == true);
-  free ensures (memory_load8_le(mem, 1884bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1885bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1886bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1887bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1884bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1812bv64);
@@ -121,10 +112,7 @@ procedure main();
   requires (gamma_load32(Gamma_mem, $y_addr) == true);
   free requires (memory_load64_le(mem, 69664bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
-  free requires (memory_load8_le(mem, 1884bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1885bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1886bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1887bv64) == 0bv8);
+  free requires (memory_load32_le(mem, 1884bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free requires (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free requires (memory_load64_le(mem, 69592bv64) == 1812bv64);
@@ -133,10 +121,7 @@ procedure main();
   free ensures (Gamma_R31 == old(Gamma_R31));
   free ensures (R29 == old(R29));
   free ensures (R31 == old(R31));
-  free ensures (memory_load8_le(mem, 1884bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1885bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1886bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1887bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1884bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1812bv64);
diff --git a/src/test/correct/function/clang/function_gtirb.expected b/src/test/correct/function/clang/function_gtirb.expected
index a72ab33b0..66b9258bb 100644
--- a/src/test/correct/function/clang/function_gtirb.expected
+++ b/src/test/correct/function/clang/function_gtirb.expected
@@ -18,7 +18,7 @@ const {:extern} $x_addr: bv64;
 axiom ($x_addr == 69684bv64);
 const {:extern} $y_addr: bv64;
 axiom ($y_addr == 69688bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
   false
 }
 
@@ -39,12 +39,12 @@ function {:extern} gamma_store64(gammaMap: [bv64]bool, index: bv64, value: bool)
   gammaMap[index := value][bvadd64(index, 1bv64) := value][bvadd64(index, 2bv64) := value][bvadd64(index, 3bv64) := value][bvadd64(index, 4bv64) := value][bvadd64(index, 5bv64) := value][bvadd64(index, 6bv64) := value][bvadd64(index, 7bv64) := value]
 }
 
-function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv64) {
-  (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
+function {:extern} memory_load32_le(memory: [bv64]bv8, index: bv64) returns (bv32) {
+  (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
+function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv64) {
+  (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
 function {:extern} memory_store32_le(memory: [bv64]bv8, index: bv64, value: bv32) returns ([bv64]bv8) {
@@ -57,12 +57,9 @@ function {:extern} memory_store64_le(memory: [bv64]bv8, index: bv64, value: bv64
 
 procedure {:extern} rely();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
-  free ensures (memory_load8_le(mem, 1884bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1885bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1886bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1887bv64) == 0bv8);
+  ensures (mem == old(mem));
+  free ensures (memory_load32_le(mem, 1884bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1812bv64);
@@ -70,8 +67,8 @@ procedure {:extern} rely();
 
 procedure {:extern} rely_transitive();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
+  ensures (mem == old(mem));
 
 implementation {:extern} rely_transitive()
 {
@@ -90,10 +87,7 @@ procedure main();
   requires (gamma_load32(Gamma_mem, $y_addr) == true);
   free requires (memory_load64_le(mem, 69664bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
-  free requires (memory_load8_le(mem, 1884bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1885bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1886bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1887bv64) == 0bv8);
+  free requires (memory_load32_le(mem, 1884bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free requires (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free requires (memory_load64_le(mem, 69592bv64) == 1812bv64);
@@ -102,10 +96,7 @@ procedure main();
   free ensures (Gamma_R31 == old(Gamma_R31));
   free ensures (R29 == old(R29));
   free ensures (R31 == old(R31));
-  free ensures (memory_load8_le(mem, 1884bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1885bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1886bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1887bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1884bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1812bv64);
@@ -152,19 +143,13 @@ implementation main()
 
 procedure get_two();
   modifies Gamma_R0, R0;
-  free requires (memory_load8_le(mem, 1884bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1885bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1886bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1887bv64) == 0bv8);
+  free requires (memory_load32_le(mem, 1884bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free requires (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free requires (memory_load64_le(mem, 69592bv64) == 1812bv64);
   free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
   ensures (Gamma_R0 == true);
-  free ensures (memory_load8_le(mem, 1884bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1885bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1886bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1887bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1884bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1812bv64);
diff --git a/src/test/correct/function/clang_pic/function.expected b/src/test/correct/function/clang_pic/function.expected
index 9ee11f3e1..648dee795 100644
--- a/src/test/correct/function/clang_pic/function.expected
+++ b/src/test/correct/function/clang_pic/function.expected
@@ -18,7 +18,7 @@ const {:extern} $x_addr: bv64;
 axiom ($x_addr == 69684bv64);
 const {:extern} $y_addr: bv64;
 axiom ($y_addr == 69688bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
   false
 }
 
@@ -39,12 +39,12 @@ function {:extern} gamma_store64(gammaMap: [bv64]bool, index: bv64, value: bool)
   gammaMap[index := value][bvadd64(index, 1bv64) := value][bvadd64(index, 2bv64) := value][bvadd64(index, 3bv64) := value][bvadd64(index, 4bv64) := value][bvadd64(index, 5bv64) := value][bvadd64(index, 6bv64) := value][bvadd64(index, 7bv64) := value]
 }
 
-function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv64) {
-  (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
+function {:extern} memory_load32_le(memory: [bv64]bv8, index: bv64) returns (bv32) {
+  (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
+function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv64) {
+  (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
 function {:extern} memory_store32_le(memory: [bv64]bv8, index: bv64, value: bv32) returns ([bv64]bv8) {
@@ -57,23 +57,20 @@ function {:extern} memory_store64_le(memory: [bv64]bv8, index: bv64, value: bv64
 
 procedure {:extern} rely();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
-  free ensures (memory_load8_le(mem, 1956bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1957bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1958bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1959bv64) == 0bv8);
-  free ensures (memory_load64_le(mem, 69672bv64) == 69672bv64);
-  free ensures (memory_load64_le(mem, 69584bv64) == 69688bv64);
+  ensures (mem == old(mem));
+  free ensures (memory_load32_le(mem, 1956bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69048bv64) == 1872bv64);
+  free ensures (memory_load64_le(mem, 69056bv64) == 1792bv64);
   free ensures (memory_load64_le(mem, 69568bv64) == 69684bv64);
+  free ensures (memory_load64_le(mem, 69584bv64) == 69688bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1876bv64);
-  free ensures (memory_load64_le(mem, 69056bv64) == 1792bv64);
+  free ensures (memory_load64_le(mem, 69672bv64) == 69672bv64);
 
 procedure {:extern} rely_transitive();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
+  ensures (mem == old(mem));
 
 implementation {:extern} rely_transitive()
 {
@@ -88,27 +85,21 @@ procedure {:extern} guarantee_reflexive();
 
 procedure get_two();
   modifies Gamma_R0, R0;
-  free requires (memory_load8_le(mem, 1956bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1957bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1958bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1959bv64) == 0bv8);
-  free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
-  free requires (memory_load64_le(mem, 69584bv64) == 69688bv64);
+  free requires (memory_load32_le(mem, 1956bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69048bv64) == 1872bv64);
+  free requires (memory_load64_le(mem, 69056bv64) == 1792bv64);
   free requires (memory_load64_le(mem, 69568bv64) == 69684bv64);
+  free requires (memory_load64_le(mem, 69584bv64) == 69688bv64);
   free requires (memory_load64_le(mem, 69592bv64) == 1876bv64);
-  free requires (memory_load64_le(mem, 69056bv64) == 1792bv64);
+  free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
   ensures (Gamma_R0 == true);
-  free ensures (memory_load8_le(mem, 1956bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1957bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1958bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1959bv64) == 0bv8);
-  free ensures (memory_load64_le(mem, 69672bv64) == 69672bv64);
-  free ensures (memory_load64_le(mem, 69584bv64) == 69688bv64);
+  free ensures (memory_load32_le(mem, 1956bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69048bv64) == 1872bv64);
+  free ensures (memory_load64_le(mem, 69056bv64) == 1792bv64);
   free ensures (memory_load64_le(mem, 69568bv64) == 69684bv64);
+  free ensures (memory_load64_le(mem, 69584bv64) == 69688bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1876bv64);
-  free ensures (memory_load64_le(mem, 69056bv64) == 1792bv64);
+  free ensures (memory_load64_le(mem, 69672bv64) == 69672bv64);
 
 implementation get_two()
 {
@@ -127,30 +118,24 @@ procedure main();
   requires (gamma_load32(Gamma_mem, $y_addr) == true);
   free requires (memory_load64_le(mem, 69664bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
-  free requires (memory_load8_le(mem, 1956bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1957bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1958bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1959bv64) == 0bv8);
-  free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
-  free requires (memory_load64_le(mem, 69584bv64) == 69688bv64);
+  free requires (memory_load32_le(mem, 1956bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69048bv64) == 1872bv64);
+  free requires (memory_load64_le(mem, 69056bv64) == 1792bv64);
   free requires (memory_load64_le(mem, 69568bv64) == 69684bv64);
+  free requires (memory_load64_le(mem, 69584bv64) == 69688bv64);
   free requires (memory_load64_le(mem, 69592bv64) == 1876bv64);
-  free requires (memory_load64_le(mem, 69056bv64) == 1792bv64);
+  free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
   free ensures (Gamma_R29 == old(Gamma_R29));
   free ensures (Gamma_R31 == old(Gamma_R31));
   free ensures (R29 == old(R29));
   free ensures (R31 == old(R31));
-  free ensures (memory_load8_le(mem, 1956bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1957bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1958bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1959bv64) == 0bv8);
-  free ensures (memory_load64_le(mem, 69672bv64) == 69672bv64);
-  free ensures (memory_load64_le(mem, 69584bv64) == 69688bv64);
+  free ensures (memory_load32_le(mem, 1956bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69048bv64) == 1872bv64);
+  free ensures (memory_load64_le(mem, 69056bv64) == 1792bv64);
   free ensures (memory_load64_le(mem, 69568bv64) == 69684bv64);
+  free ensures (memory_load64_le(mem, 69584bv64) == 69688bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1876bv64);
-  free ensures (memory_load64_le(mem, 69056bv64) == 1792bv64);
+  free ensures (memory_load64_le(mem, 69672bv64) == 69672bv64);
 
 implementation main()
 {
diff --git a/src/test/correct/function/clang_pic/function_gtirb.expected b/src/test/correct/function/clang_pic/function_gtirb.expected
index e594fca30..044491d73 100644
--- a/src/test/correct/function/clang_pic/function_gtirb.expected
+++ b/src/test/correct/function/clang_pic/function_gtirb.expected
@@ -18,7 +18,7 @@ const {:extern} $x_addr: bv64;
 axiom ($x_addr == 69684bv64);
 const {:extern} $y_addr: bv64;
 axiom ($y_addr == 69688bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
   false
 }
 
@@ -39,12 +39,12 @@ function {:extern} gamma_store64(gammaMap: [bv64]bool, index: bv64, value: bool)
   gammaMap[index := value][bvadd64(index, 1bv64) := value][bvadd64(index, 2bv64) := value][bvadd64(index, 3bv64) := value][bvadd64(index, 4bv64) := value][bvadd64(index, 5bv64) := value][bvadd64(index, 6bv64) := value][bvadd64(index, 7bv64) := value]
 }
 
-function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv64) {
-  (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
+function {:extern} memory_load32_le(memory: [bv64]bv8, index: bv64) returns (bv32) {
+  (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
+function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv64) {
+  (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
 function {:extern} memory_store32_le(memory: [bv64]bv8, index: bv64, value: bv32) returns ([bv64]bv8) {
@@ -57,23 +57,20 @@ function {:extern} memory_store64_le(memory: [bv64]bv8, index: bv64, value: bv64
 
 procedure {:extern} rely();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
-  free ensures (memory_load8_le(mem, 1956bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1957bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1958bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1959bv64) == 0bv8);
-  free ensures (memory_load64_le(mem, 69672bv64) == 69672bv64);
-  free ensures (memory_load64_le(mem, 69584bv64) == 69688bv64);
+  ensures (mem == old(mem));
+  free ensures (memory_load32_le(mem, 1956bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69048bv64) == 1872bv64);
+  free ensures (memory_load64_le(mem, 69056bv64) == 1792bv64);
   free ensures (memory_load64_le(mem, 69568bv64) == 69684bv64);
+  free ensures (memory_load64_le(mem, 69584bv64) == 69688bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1876bv64);
-  free ensures (memory_load64_le(mem, 69056bv64) == 1792bv64);
+  free ensures (memory_load64_le(mem, 69672bv64) == 69672bv64);
 
 procedure {:extern} rely_transitive();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
+  ensures (mem == old(mem));
 
 implementation {:extern} rely_transitive()
 {
@@ -92,30 +89,24 @@ procedure main();
   requires (gamma_load32(Gamma_mem, $y_addr) == true);
   free requires (memory_load64_le(mem, 69664bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
-  free requires (memory_load8_le(mem, 1956bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1957bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1958bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1959bv64) == 0bv8);
-  free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
-  free requires (memory_load64_le(mem, 69584bv64) == 69688bv64);
+  free requires (memory_load32_le(mem, 1956bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69048bv64) == 1872bv64);
+  free requires (memory_load64_le(mem, 69056bv64) == 1792bv64);
   free requires (memory_load64_le(mem, 69568bv64) == 69684bv64);
+  free requires (memory_load64_le(mem, 69584bv64) == 69688bv64);
   free requires (memory_load64_le(mem, 69592bv64) == 1876bv64);
-  free requires (memory_load64_le(mem, 69056bv64) == 1792bv64);
+  free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
   free ensures (Gamma_R29 == old(Gamma_R29));
   free ensures (Gamma_R31 == old(Gamma_R31));
   free ensures (R29 == old(R29));
   free ensures (R31 == old(R31));
-  free ensures (memory_load8_le(mem, 1956bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1957bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1958bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1959bv64) == 0bv8);
-  free ensures (memory_load64_le(mem, 69672bv64) == 69672bv64);
-  free ensures (memory_load64_le(mem, 69584bv64) == 69688bv64);
+  free ensures (memory_load32_le(mem, 1956bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69048bv64) == 1872bv64);
+  free ensures (memory_load64_le(mem, 69056bv64) == 1792bv64);
   free ensures (memory_load64_le(mem, 69568bv64) == 69684bv64);
+  free ensures (memory_load64_le(mem, 69584bv64) == 69688bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1876bv64);
-  free ensures (memory_load64_le(mem, 69056bv64) == 1792bv64);
+  free ensures (memory_load64_le(mem, 69672bv64) == 69672bv64);
 
 implementation main()
 {
@@ -162,27 +153,21 @@ implementation main()
 
 procedure get_two();
   modifies Gamma_R0, R0;
-  free requires (memory_load8_le(mem, 1956bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1957bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1958bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1959bv64) == 0bv8);
-  free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
-  free requires (memory_load64_le(mem, 69584bv64) == 69688bv64);
+  free requires (memory_load32_le(mem, 1956bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69048bv64) == 1872bv64);
+  free requires (memory_load64_le(mem, 69056bv64) == 1792bv64);
   free requires (memory_load64_le(mem, 69568bv64) == 69684bv64);
+  free requires (memory_load64_le(mem, 69584bv64) == 69688bv64);
   free requires (memory_load64_le(mem, 69592bv64) == 1876bv64);
-  free requires (memory_load64_le(mem, 69056bv64) == 1792bv64);
+  free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
   ensures (Gamma_R0 == true);
-  free ensures (memory_load8_le(mem, 1956bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1957bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1958bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1959bv64) == 0bv8);
-  free ensures (memory_load64_le(mem, 69672bv64) == 69672bv64);
-  free ensures (memory_load64_le(mem, 69584bv64) == 69688bv64);
+  free ensures (memory_load32_le(mem, 1956bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69048bv64) == 1872bv64);
+  free ensures (memory_load64_le(mem, 69056bv64) == 1792bv64);
   free ensures (memory_load64_le(mem, 69568bv64) == 69684bv64);
+  free ensures (memory_load64_le(mem, 69584bv64) == 69688bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1876bv64);
-  free ensures (memory_load64_le(mem, 69056bv64) == 1792bv64);
+  free ensures (memory_load64_le(mem, 69672bv64) == 69672bv64);
 
 implementation get_two()
 {
diff --git a/src/test/correct/function/gcc/function.expected b/src/test/correct/function/gcc/function.expected
index beb93a1bf..933d00e90 100644
--- a/src/test/correct/function/gcc/function.expected
+++ b/src/test/correct/function/gcc/function.expected
@@ -16,7 +16,7 @@ const {:extern} $x_addr: bv64;
 axiom ($x_addr == 69652bv64);
 const {:extern} $y_addr: bv64;
 axiom ($y_addr == 69656bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
   false
 }
 
@@ -37,12 +37,12 @@ function {:extern} gamma_store64(gammaMap: [bv64]bool, index: bv64, value: bool)
   gammaMap[index := value][bvadd64(index, 1bv64) := value][bvadd64(index, 2bv64) := value][bvadd64(index, 3bv64) := value][bvadd64(index, 4bv64) := value][bvadd64(index, 5bv64) := value][bvadd64(index, 6bv64) := value][bvadd64(index, 7bv64) := value]
 }
 
-function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv64) {
-  (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
+function {:extern} memory_load32_le(memory: [bv64]bv8, index: bv64) returns (bv32) {
+  (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
+function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv64) {
+  (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
 function {:extern} memory_store32_le(memory: [bv64]bv8, index: bv64, value: bv32) returns ([bv64]bv8) {
@@ -56,12 +56,9 @@ function {:extern} memory_store64_le(memory: [bv64]bv8, index: bv64, value: bv64
 function {:extern} {:bvbuiltin "zero_extend 32"} zero_extend32_32(bv32) returns (bv64);
 procedure {:extern} rely();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
-  free ensures (memory_load8_le(mem, 1896bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1897bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1898bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1899bv64) == 0bv8);
+  ensures (mem == old(mem));
+  free ensures (memory_load32_le(mem, 1896bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69016bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69024bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69616bv64) == 1812bv64);
@@ -69,8 +66,8 @@ procedure {:extern} rely();
 
 procedure {:extern} rely_transitive();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
+  ensures (mem == old(mem));
 
 implementation {:extern} rely_transitive()
 {
@@ -85,19 +82,13 @@ procedure {:extern} guarantee_reflexive();
 
 procedure get_two();
   modifies Gamma_R0, R0;
-  free requires (memory_load8_le(mem, 1896bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1897bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1898bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1899bv64) == 0bv8);
+  free requires (memory_load32_le(mem, 1896bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69016bv64) == 1808bv64);
   free requires (memory_load64_le(mem, 69024bv64) == 1728bv64);
   free requires (memory_load64_le(mem, 69616bv64) == 1812bv64);
   free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
   ensures (Gamma_R0 == true);
-  free ensures (memory_load8_le(mem, 1896bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1897bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1898bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1899bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1896bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69016bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69024bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69616bv64) == 1812bv64);
@@ -120,10 +111,7 @@ procedure main();
   requires (gamma_load32(Gamma_mem, $y_addr) == true);
   free requires (memory_load64_le(mem, 69632bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free requires (memory_load8_le(mem, 1896bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1897bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1898bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1899bv64) == 0bv8);
+  free requires (memory_load32_le(mem, 1896bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69016bv64) == 1808bv64);
   free requires (memory_load64_le(mem, 69024bv64) == 1728bv64);
   free requires (memory_load64_le(mem, 69616bv64) == 1812bv64);
@@ -132,10 +120,7 @@ procedure main();
   free ensures (Gamma_R31 == old(Gamma_R31));
   free ensures (R29 == old(R29));
   free ensures (R31 == old(R31));
-  free ensures (memory_load8_le(mem, 1896bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1897bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1898bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1899bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1896bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69016bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69024bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69616bv64) == 1812bv64);
diff --git a/src/test/correct/function/gcc/function_gtirb.expected b/src/test/correct/function/gcc/function_gtirb.expected
index ee39081b8..e1acd3896 100644
--- a/src/test/correct/function/gcc/function_gtirb.expected
+++ b/src/test/correct/function/gcc/function_gtirb.expected
@@ -16,7 +16,7 @@ const {:extern} $x_addr: bv64;
 axiom ($x_addr == 69652bv64);
 const {:extern} $y_addr: bv64;
 axiom ($y_addr == 69656bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
   false
 }
 
@@ -37,12 +37,12 @@ function {:extern} gamma_store64(gammaMap: [bv64]bool, index: bv64, value: bool)
   gammaMap[index := value][bvadd64(index, 1bv64) := value][bvadd64(index, 2bv64) := value][bvadd64(index, 3bv64) := value][bvadd64(index, 4bv64) := value][bvadd64(index, 5bv64) := value][bvadd64(index, 6bv64) := value][bvadd64(index, 7bv64) := value]
 }
 
-function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv64) {
-  (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
+function {:extern} memory_load32_le(memory: [bv64]bv8, index: bv64) returns (bv32) {
+  (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
+function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv64) {
+  (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
 function {:extern} memory_store32_le(memory: [bv64]bv8, index: bv64, value: bv32) returns ([bv64]bv8) {
@@ -56,12 +56,9 @@ function {:extern} memory_store64_le(memory: [bv64]bv8, index: bv64, value: bv64
 function {:extern} {:bvbuiltin "zero_extend 32"} zero_extend32_32(bv32) returns (bv64);
 procedure {:extern} rely();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
-  free ensures (memory_load8_le(mem, 1896bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1897bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1898bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1899bv64) == 0bv8);
+  ensures (mem == old(mem));
+  free ensures (memory_load32_le(mem, 1896bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69016bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69024bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69616bv64) == 1812bv64);
@@ -69,8 +66,8 @@ procedure {:extern} rely();
 
 procedure {:extern} rely_transitive();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
+  ensures (mem == old(mem));
 
 implementation {:extern} rely_transitive()
 {
@@ -85,19 +82,13 @@ procedure {:extern} guarantee_reflexive();
 
 procedure get_two();
   modifies Gamma_R0, R0;
-  free requires (memory_load8_le(mem, 1896bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1897bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1898bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1899bv64) == 0bv8);
+  free requires (memory_load32_le(mem, 1896bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69016bv64) == 1808bv64);
   free requires (memory_load64_le(mem, 69024bv64) == 1728bv64);
   free requires (memory_load64_le(mem, 69616bv64) == 1812bv64);
   free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
   ensures (Gamma_R0 == true);
-  free ensures (memory_load8_le(mem, 1896bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1897bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1898bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1899bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1896bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69016bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69024bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69616bv64) == 1812bv64);
@@ -120,10 +111,7 @@ procedure main();
   requires (gamma_load32(Gamma_mem, $y_addr) == true);
   free requires (memory_load64_le(mem, 69632bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free requires (memory_load8_le(mem, 1896bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1897bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1898bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1899bv64) == 0bv8);
+  free requires (memory_load32_le(mem, 1896bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69016bv64) == 1808bv64);
   free requires (memory_load64_le(mem, 69024bv64) == 1728bv64);
   free requires (memory_load64_le(mem, 69616bv64) == 1812bv64);
@@ -132,10 +120,7 @@ procedure main();
   free ensures (Gamma_R31 == old(Gamma_R31));
   free ensures (R29 == old(R29));
   free ensures (R31 == old(R31));
-  free ensures (memory_load8_le(mem, 1896bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1897bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1898bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1899bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1896bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69016bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69024bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69616bv64) == 1812bv64);
diff --git a/src/test/correct/function/gcc_pic/function.expected b/src/test/correct/function/gcc_pic/function.expected
index 46be66a06..cc6c7f4f6 100644
--- a/src/test/correct/function/gcc_pic/function.expected
+++ b/src/test/correct/function/gcc_pic/function.expected
@@ -16,7 +16,7 @@ const {:extern} $x_addr: bv64;
 axiom ($x_addr == 69652bv64);
 const {:extern} $y_addr: bv64;
 axiom ($y_addr == 69656bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
   false
 }
 
@@ -37,12 +37,12 @@ function {:extern} gamma_store64(gammaMap: [bv64]bool, index: bv64, value: bool)
   gammaMap[index := value][bvadd64(index, 1bv64) := value][bvadd64(index, 2bv64) := value][bvadd64(index, 3bv64) := value][bvadd64(index, 4bv64) := value][bvadd64(index, 5bv64) := value][bvadd64(index, 6bv64) := value][bvadd64(index, 7bv64) := value]
 }
 
-function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv64) {
-  (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
+function {:extern} memory_load32_le(memory: [bv64]bv8, index: bv64) returns (bv32) {
+  (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
+function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv64) {
+  (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
 function {:extern} memory_store32_le(memory: [bv64]bv8, index: bv64, value: bv32) returns ([bv64]bv8) {
@@ -56,23 +56,20 @@ function {:extern} memory_store64_le(memory: [bv64]bv8, index: bv64, value: bv64
 function {:extern} {:bvbuiltin "zero_extend 32"} zero_extend32_32(bv32) returns (bv64);
 procedure {:extern} rely();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
-  free ensures (memory_load8_le(mem, 1960bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1961bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1962bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1963bv64) == 0bv8);
-  free ensures (memory_load64_le(mem, 69608bv64) == 69656bv64);
-  free ensures (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free ensures (memory_load64_le(mem, 69616bv64) == 1876bv64);
+  ensures (mem == old(mem));
+  free ensures (memory_load32_le(mem, 1960bv64) == 131073bv32);
+  free ensures (memory_load64_le(mem, 69000bv64) == 1872bv64);
   free ensures (memory_load64_le(mem, 69008bv64) == 1792bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 69652bv64);
-  free ensures (memory_load64_le(mem, 69000bv64) == 1872bv64);
+  free ensures (memory_load64_le(mem, 69608bv64) == 69656bv64);
+  free ensures (memory_load64_le(mem, 69616bv64) == 1876bv64);
+  free ensures (memory_load64_le(mem, 69640bv64) == 69640bv64);
 
 procedure {:extern} rely_transitive();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
+  ensures (mem == old(mem));
 
 implementation {:extern} rely_transitive()
 {
@@ -87,27 +84,21 @@ procedure {:extern} guarantee_reflexive();
 
 procedure get_two();
   modifies Gamma_R0, R0;
-  free requires (memory_load8_le(mem, 1960bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1961bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1962bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1963bv64) == 0bv8);
-  free requires (memory_load64_le(mem, 69608bv64) == 69656bv64);
-  free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free requires (memory_load64_le(mem, 69616bv64) == 1876bv64);
+  free requires (memory_load32_le(mem, 1960bv64) == 131073bv32);
+  free requires (memory_load64_le(mem, 69000bv64) == 1872bv64);
   free requires (memory_load64_le(mem, 69008bv64) == 1792bv64);
   free requires (memory_load64_le(mem, 69592bv64) == 69652bv64);
-  free requires (memory_load64_le(mem, 69000bv64) == 1872bv64);
+  free requires (memory_load64_le(mem, 69608bv64) == 69656bv64);
+  free requires (memory_load64_le(mem, 69616bv64) == 1876bv64);
+  free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
   ensures (Gamma_R0 == true);
-  free ensures (memory_load8_le(mem, 1960bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1961bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1962bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1963bv64) == 0bv8);
-  free ensures (memory_load64_le(mem, 69608bv64) == 69656bv64);
-  free ensures (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free ensures (memory_load64_le(mem, 69616bv64) == 1876bv64);
+  free ensures (memory_load32_le(mem, 1960bv64) == 131073bv32);
+  free ensures (memory_load64_le(mem, 69000bv64) == 1872bv64);
   free ensures (memory_load64_le(mem, 69008bv64) == 1792bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 69652bv64);
-  free ensures (memory_load64_le(mem, 69000bv64) == 1872bv64);
+  free ensures (memory_load64_le(mem, 69608bv64) == 69656bv64);
+  free ensures (memory_load64_le(mem, 69616bv64) == 1876bv64);
+  free ensures (memory_load64_le(mem, 69640bv64) == 69640bv64);
 
 implementation get_two()
 {
@@ -126,30 +117,24 @@ procedure main();
   requires (gamma_load32(Gamma_mem, $y_addr) == true);
   free requires (memory_load64_le(mem, 69632bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free requires (memory_load8_le(mem, 1960bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1961bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1962bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1963bv64) == 0bv8);
-  free requires (memory_load64_le(mem, 69608bv64) == 69656bv64);
-  free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free requires (memory_load64_le(mem, 69616bv64) == 1876bv64);
+  free requires (memory_load32_le(mem, 1960bv64) == 131073bv32);
+  free requires (memory_load64_le(mem, 69000bv64) == 1872bv64);
   free requires (memory_load64_le(mem, 69008bv64) == 1792bv64);
   free requires (memory_load64_le(mem, 69592bv64) == 69652bv64);
-  free requires (memory_load64_le(mem, 69000bv64) == 1872bv64);
+  free requires (memory_load64_le(mem, 69608bv64) == 69656bv64);
+  free requires (memory_load64_le(mem, 69616bv64) == 1876bv64);
+  free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
   free ensures (Gamma_R29 == old(Gamma_R29));
   free ensures (Gamma_R31 == old(Gamma_R31));
   free ensures (R29 == old(R29));
   free ensures (R31 == old(R31));
-  free ensures (memory_load8_le(mem, 1960bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1961bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1962bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1963bv64) == 0bv8);
-  free ensures (memory_load64_le(mem, 69608bv64) == 69656bv64);
-  free ensures (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free ensures (memory_load64_le(mem, 69616bv64) == 1876bv64);
+  free ensures (memory_load32_le(mem, 1960bv64) == 131073bv32);
+  free ensures (memory_load64_le(mem, 69000bv64) == 1872bv64);
   free ensures (memory_load64_le(mem, 69008bv64) == 1792bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 69652bv64);
-  free ensures (memory_load64_le(mem, 69000bv64) == 1872bv64);
+  free ensures (memory_load64_le(mem, 69608bv64) == 69656bv64);
+  free ensures (memory_load64_le(mem, 69616bv64) == 1876bv64);
+  free ensures (memory_load64_le(mem, 69640bv64) == 69640bv64);
 
 implementation main()
 {
diff --git a/src/test/correct/function/gcc_pic/function_gtirb.expected b/src/test/correct/function/gcc_pic/function_gtirb.expected
index 9c9a51a5d..70b62c99d 100644
--- a/src/test/correct/function/gcc_pic/function_gtirb.expected
+++ b/src/test/correct/function/gcc_pic/function_gtirb.expected
@@ -16,7 +16,7 @@ const {:extern} $x_addr: bv64;
 axiom ($x_addr == 69652bv64);
 const {:extern} $y_addr: bv64;
 axiom ($y_addr == 69656bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
   false
 }
 
@@ -37,12 +37,12 @@ function {:extern} gamma_store64(gammaMap: [bv64]bool, index: bv64, value: bool)
   gammaMap[index := value][bvadd64(index, 1bv64) := value][bvadd64(index, 2bv64) := value][bvadd64(index, 3bv64) := value][bvadd64(index, 4bv64) := value][bvadd64(index, 5bv64) := value][bvadd64(index, 6bv64) := value][bvadd64(index, 7bv64) := value]
 }
 
-function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv64) {
-  (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
+function {:extern} memory_load32_le(memory: [bv64]bv8, index: bv64) returns (bv32) {
+  (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
+function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv64) {
+  (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
 function {:extern} memory_store32_le(memory: [bv64]bv8, index: bv64, value: bv32) returns ([bv64]bv8) {
@@ -56,23 +56,20 @@ function {:extern} memory_store64_le(memory: [bv64]bv8, index: bv64, value: bv64
 function {:extern} {:bvbuiltin "zero_extend 32"} zero_extend32_32(bv32) returns (bv64);
 procedure {:extern} rely();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
-  free ensures (memory_load8_le(mem, 1960bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1961bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1962bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1963bv64) == 0bv8);
-  free ensures (memory_load64_le(mem, 69608bv64) == 69656bv64);
-  free ensures (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free ensures (memory_load64_le(mem, 69616bv64) == 1876bv64);
+  ensures (mem == old(mem));
+  free ensures (memory_load32_le(mem, 1960bv64) == 131073bv32);
+  free ensures (memory_load64_le(mem, 69000bv64) == 1872bv64);
   free ensures (memory_load64_le(mem, 69008bv64) == 1792bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 69652bv64);
-  free ensures (memory_load64_le(mem, 69000bv64) == 1872bv64);
+  free ensures (memory_load64_le(mem, 69608bv64) == 69656bv64);
+  free ensures (memory_load64_le(mem, 69616bv64) == 1876bv64);
+  free ensures (memory_load64_le(mem, 69640bv64) == 69640bv64);
 
 procedure {:extern} rely_transitive();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
+  ensures (mem == old(mem));
 
 implementation {:extern} rely_transitive()
 {
@@ -91,30 +88,24 @@ procedure main();
   requires (gamma_load32(Gamma_mem, $y_addr) == true);
   free requires (memory_load64_le(mem, 69632bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free requires (memory_load8_le(mem, 1960bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1961bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1962bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1963bv64) == 0bv8);
-  free requires (memory_load64_le(mem, 69608bv64) == 69656bv64);
-  free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free requires (memory_load64_le(mem, 69616bv64) == 1876bv64);
+  free requires (memory_load32_le(mem, 1960bv64) == 131073bv32);
+  free requires (memory_load64_le(mem, 69000bv64) == 1872bv64);
   free requires (memory_load64_le(mem, 69008bv64) == 1792bv64);
   free requires (memory_load64_le(mem, 69592bv64) == 69652bv64);
-  free requires (memory_load64_le(mem, 69000bv64) == 1872bv64);
+  free requires (memory_load64_le(mem, 69608bv64) == 69656bv64);
+  free requires (memory_load64_le(mem, 69616bv64) == 1876bv64);
+  free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
   free ensures (Gamma_R29 == old(Gamma_R29));
   free ensures (Gamma_R31 == old(Gamma_R31));
   free ensures (R29 == old(R29));
   free ensures (R31 == old(R31));
-  free ensures (memory_load8_le(mem, 1960bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1961bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1962bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1963bv64) == 0bv8);
-  free ensures (memory_load64_le(mem, 69608bv64) == 69656bv64);
-  free ensures (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free ensures (memory_load64_le(mem, 69616bv64) == 1876bv64);
+  free ensures (memory_load32_le(mem, 1960bv64) == 131073bv32);
+  free ensures (memory_load64_le(mem, 69000bv64) == 1872bv64);
   free ensures (memory_load64_le(mem, 69008bv64) == 1792bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 69652bv64);
-  free ensures (memory_load64_le(mem, 69000bv64) == 1872bv64);
+  free ensures (memory_load64_le(mem, 69608bv64) == 69656bv64);
+  free ensures (memory_load64_le(mem, 69616bv64) == 1876bv64);
+  free ensures (memory_load64_le(mem, 69640bv64) == 69640bv64);
 
 implementation main()
 {
@@ -162,27 +153,21 @@ implementation main()
 
 procedure get_two();
   modifies Gamma_R0, R0;
-  free requires (memory_load8_le(mem, 1960bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1961bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1962bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1963bv64) == 0bv8);
-  free requires (memory_load64_le(mem, 69608bv64) == 69656bv64);
-  free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free requires (memory_load64_le(mem, 69616bv64) == 1876bv64);
+  free requires (memory_load32_le(mem, 1960bv64) == 131073bv32);
+  free requires (memory_load64_le(mem, 69000bv64) == 1872bv64);
   free requires (memory_load64_le(mem, 69008bv64) == 1792bv64);
   free requires (memory_load64_le(mem, 69592bv64) == 69652bv64);
-  free requires (memory_load64_le(mem, 69000bv64) == 1872bv64);
+  free requires (memory_load64_le(mem, 69608bv64) == 69656bv64);
+  free requires (memory_load64_le(mem, 69616bv64) == 1876bv64);
+  free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
   ensures (Gamma_R0 == true);
-  free ensures (memory_load8_le(mem, 1960bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1961bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1962bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1963bv64) == 0bv8);
-  free ensures (memory_load64_le(mem, 69608bv64) == 69656bv64);
-  free ensures (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free ensures (memory_load64_le(mem, 69616bv64) == 1876bv64);
+  free ensures (memory_load32_le(mem, 1960bv64) == 131073bv32);
+  free ensures (memory_load64_le(mem, 69000bv64) == 1872bv64);
   free ensures (memory_load64_le(mem, 69008bv64) == 1792bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 69652bv64);
-  free ensures (memory_load64_le(mem, 69000bv64) == 1872bv64);
+  free ensures (memory_load64_le(mem, 69608bv64) == 69656bv64);
+  free ensures (memory_load64_le(mem, 69616bv64) == 1876bv64);
+  free ensures (memory_load64_le(mem, 69640bv64) == 69640bv64);
 
 implementation get_two()
 {
diff --git a/src/test/correct/function1/clang/function1.expected b/src/test/correct/function1/clang/function1.expected
index c99be706b..458e75574 100644
--- a/src/test/correct/function1/clang/function1.expected
+++ b/src/test/correct/function1/clang/function1.expected
@@ -28,7 +28,7 @@ const {:extern} $x_addr: bv64;
 axiom ($x_addr == 69692bv64);
 const {:extern} $y_addr: bv64;
 axiom ($y_addr == 69696bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
   false
 }
 
@@ -87,8 +87,8 @@ function {:extern} {:bvbuiltin "zero_extend 32"} zero_extend32_32(bv32) returns
 function {:extern} {:bvbuiltin "zero_extend 56"} zero_extend56_8(bv8) returns (bv64);
 procedure {:extern} rely();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
+  ensures (mem == old(mem));
   free ensures (memory_load64_le(mem, 2024bv64) == 2924859843805185bv64);
   free ensures (memory_load64_le(mem, 69064bv64) == 1872bv64);
   free ensures (memory_load64_le(mem, 69072bv64) == 1792bv64);
@@ -97,8 +97,8 @@ procedure {:extern} rely();
 
 procedure {:extern} rely_transitive();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
+  ensures (mem == old(mem));
 
 implementation {:extern} rely_transitive()
 {
diff --git a/src/test/correct/function1/clang/function1_gtirb.expected b/src/test/correct/function1/clang/function1_gtirb.expected
index 6a09e1ad8..c05abc07c 100644
--- a/src/test/correct/function1/clang/function1_gtirb.expected
+++ b/src/test/correct/function1/clang/function1_gtirb.expected
@@ -28,7 +28,7 @@ const {:extern} $x_addr: bv64;
 axiom ($x_addr == 69692bv64);
 const {:extern} $y_addr: bv64;
 axiom ($y_addr == 69696bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
   false
 }
 
@@ -87,8 +87,8 @@ function {:extern} {:bvbuiltin "zero_extend 24"} zero_extend24_8(bv8) returns (b
 function {:extern} {:bvbuiltin "zero_extend 32"} zero_extend32_32(bv32) returns (bv64);
 procedure {:extern} rely();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
+  ensures (mem == old(mem));
   free ensures (memory_load64_le(mem, 2024bv64) == 2924859843805185bv64);
   free ensures (memory_load64_le(mem, 69064bv64) == 1872bv64);
   free ensures (memory_load64_le(mem, 69072bv64) == 1792bv64);
@@ -97,8 +97,8 @@ procedure {:extern} rely();
 
 procedure {:extern} rely_transitive();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
+  ensures (mem == old(mem));
 
 implementation {:extern} rely_transitive()
 {
diff --git a/src/test/correct/function1/clang_O2/function1.expected b/src/test/correct/function1/clang_O2/function1.expected
index 721d20a89..07be739dc 100644
--- a/src/test/correct/function1/clang_O2/function1.expected
+++ b/src/test/correct/function1/clang_O2/function1.expected
@@ -30,7 +30,7 @@ const {:extern} $x_addr: bv64;
 axiom ($x_addr == 69692bv64);
 const {:extern} $y_addr: bv64;
 axiom ($y_addr == 69696bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
   false
 }
 
@@ -62,8 +62,8 @@ function {:extern} memory_store64_le(memory: [bv64]bv8, index: bv64, value: bv64
 function {:extern} {:bvbuiltin "zero_extend 32"} zero_extend32_32(bv32) returns (bv64);
 procedure {:extern} rely();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
+  ensures (mem == old(mem));
   free ensures (memory_load64_le(mem, 1976bv64) == 2924859843805185bv64);
   free ensures (memory_load64_le(mem, 69064bv64) == 1872bv64);
   free ensures (memory_load64_le(mem, 69072bv64) == 1792bv64);
@@ -72,8 +72,8 @@ procedure {:extern} rely();
 
 procedure {:extern} rely_transitive();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
+  ensures (mem == old(mem));
 
 implementation {:extern} rely_transitive()
 {
diff --git a/src/test/correct/function1/clang_O2/function1_gtirb.expected b/src/test/correct/function1/clang_O2/function1_gtirb.expected
index a6814f2c8..15b52ffe0 100644
--- a/src/test/correct/function1/clang_O2/function1_gtirb.expected
+++ b/src/test/correct/function1/clang_O2/function1_gtirb.expected
@@ -30,7 +30,7 @@ const {:extern} $x_addr: bv64;
 axiom ($x_addr == 69692bv64);
 const {:extern} $y_addr: bv64;
 axiom ($y_addr == 69696bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
   false
 }
 
@@ -62,8 +62,8 @@ function {:extern} memory_store64_le(memory: [bv64]bv8, index: bv64, value: bv64
 function {:extern} {:bvbuiltin "zero_extend 32"} zero_extend32_32(bv32) returns (bv64);
 procedure {:extern} rely();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
+  ensures (mem == old(mem));
   free ensures (memory_load64_le(mem, 1976bv64) == 2924859843805185bv64);
   free ensures (memory_load64_le(mem, 69064bv64) == 1872bv64);
   free ensures (memory_load64_le(mem, 69072bv64) == 1792bv64);
@@ -72,8 +72,8 @@ procedure {:extern} rely();
 
 procedure {:extern} rely_transitive();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
+  ensures (mem == old(mem));
 
 implementation {:extern} rely_transitive()
 {
diff --git a/src/test/correct/function1/gcc/function1.expected b/src/test/correct/function1/gcc/function1.expected
index f1e751c67..7679162c5 100644
--- a/src/test/correct/function1/gcc/function1.expected
+++ b/src/test/correct/function1/gcc/function1.expected
@@ -24,7 +24,7 @@ const {:extern} $x_addr: bv64;
 axiom ($x_addr == 69652bv64);
 const {:extern} $y_addr: bv64;
 axiom ($y_addr == 69656bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
   false
 }
 
@@ -82,8 +82,8 @@ function {:extern} {:bvbuiltin "zero_extend 32"} zero_extend32_32(bv32) returns
 function {:extern} {:bvbuiltin "zero_extend 56"} zero_extend56_8(bv8) returns (bv64);
 procedure {:extern} rely();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
+  ensures (mem == old(mem));
   free ensures (memory_load64_le(mem, 2048bv64) == 131073bv64);
   free ensures (memory_load8_le(mem, 2056bv64) == 37bv8);
   free ensures (memory_load8_le(mem, 2057bv64) == 100bv8);
@@ -96,8 +96,8 @@ procedure {:extern} rely();
 
 procedure {:extern} rely_transitive();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
+  ensures (mem == old(mem));
 
 implementation {:extern} rely_transitive()
 {
diff --git a/src/test/correct/function1/gcc/function1_gtirb.expected b/src/test/correct/function1/gcc/function1_gtirb.expected
index d659b4364..7c618985e 100644
--- a/src/test/correct/function1/gcc/function1_gtirb.expected
+++ b/src/test/correct/function1/gcc/function1_gtirb.expected
@@ -24,7 +24,7 @@ const {:extern} $x_addr: bv64;
 axiom ($x_addr == 69652bv64);
 const {:extern} $y_addr: bv64;
 axiom ($y_addr == 69656bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
   false
 }
 
@@ -82,8 +82,8 @@ function {:extern} {:bvbuiltin "zero_extend 24"} zero_extend24_8(bv8) returns (b
 function {:extern} {:bvbuiltin "zero_extend 32"} zero_extend32_32(bv32) returns (bv64);
 procedure {:extern} rely();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
+  ensures (mem == old(mem));
   free ensures (memory_load64_le(mem, 2048bv64) == 131073bv64);
   free ensures (memory_load8_le(mem, 2056bv64) == 37bv8);
   free ensures (memory_load8_le(mem, 2057bv64) == 100bv8);
@@ -96,8 +96,8 @@ procedure {:extern} rely();
 
 procedure {:extern} rely_transitive();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
+  ensures (mem == old(mem));
 
 implementation {:extern} rely_transitive()
 {
diff --git a/src/test/correct/function1/gcc_O2/function1.expected b/src/test/correct/function1/gcc_O2/function1.expected
index ec235edf3..d2d1638ca 100644
--- a/src/test/correct/function1/gcc_O2/function1.expected
+++ b/src/test/correct/function1/gcc_O2/function1.expected
@@ -26,7 +26,7 @@ const {:extern} $x_addr: bv64;
 axiom ($x_addr == 69652bv64);
 const {:extern} $y_addr: bv64;
 axiom ($y_addr == 69656bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
   false
 }
 
@@ -62,8 +62,8 @@ function {:extern} memory_store64_le(memory: [bv64]bv8, index: bv64, value: bv64
 function {:extern} {:bvbuiltin "zero_extend 32"} zero_extend32_32(bv32) returns (bv64);
 procedure {:extern} rely();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
+  ensures (mem == old(mem));
   free ensures (memory_load64_le(mem, 2048bv64) == 131073bv64);
   free ensures (memory_load8_le(mem, 2056bv64) == 37bv8);
   free ensures (memory_load8_le(mem, 2057bv64) == 100bv8);
@@ -76,8 +76,8 @@ procedure {:extern} rely();
 
 procedure {:extern} rely_transitive();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
+  ensures (mem == old(mem));
 
 implementation {:extern} rely_transitive()
 {
diff --git a/src/test/correct/function1/gcc_O2/function1_gtirb.expected b/src/test/correct/function1/gcc_O2/function1_gtirb.expected
index c6c0b7514..65932f0f8 100644
--- a/src/test/correct/function1/gcc_O2/function1_gtirb.expected
+++ b/src/test/correct/function1/gcc_O2/function1_gtirb.expected
@@ -26,7 +26,7 @@ const {:extern} $x_addr: bv64;
 axiom ($x_addr == 69652bv64);
 const {:extern} $y_addr: bv64;
 axiom ($y_addr == 69656bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
   false
 }
 
@@ -62,8 +62,8 @@ function {:extern} memory_store64_le(memory: [bv64]bv8, index: bv64, value: bv64
 function {:extern} {:bvbuiltin "zero_extend 32"} zero_extend32_32(bv32) returns (bv64);
 procedure {:extern} rely();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
+  ensures (mem == old(mem));
   free ensures (memory_load64_le(mem, 2048bv64) == 131073bv64);
   free ensures (memory_load8_le(mem, 2056bv64) == 37bv8);
   free ensures (memory_load8_le(mem, 2057bv64) == 100bv8);
@@ -76,8 +76,8 @@ procedure {:extern} rely();
 
 procedure {:extern} rely_transitive();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
+  ensures (mem == old(mem));
 
 implementation {:extern} rely_transitive()
 {
diff --git a/src/test/correct/functionpointer/clang/functionpointer_gtirb.expected b/src/test/correct/functionpointer/clang/functionpointer_gtirb.expected
index 47885be86..291e95a84 100644
--- a/src/test/correct/functionpointer/clang/functionpointer_gtirb.expected
+++ b/src/test/correct/functionpointer/clang/functionpointer_gtirb.expected
@@ -22,7 +22,7 @@ var {:extern} VF: bv1;
 var {:extern} ZF: bv1;
 var {:extern} mem: [bv64]bv8;
 var {:extern} stack: [bv64]bv8;
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
   false
 }
 
@@ -56,10 +56,6 @@ function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv6
   (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
-}
-
 function {:extern} memory_store32_le(memory: [bv64]bv8, index: bv64, value: bv32) returns ([bv64]bv8) {
   memory[index := value[8:0]][bvadd64(index, 1bv64) := value[16:8]][bvadd64(index, 2bv64) := value[24:16]][bvadd64(index, 3bv64) := value[32:24]]
 }
@@ -73,12 +69,9 @@ function {:extern} {:bvbuiltin "zero_extend 1"} zero_extend1_32(bv32) returns (b
 function {:extern} {:bvbuiltin "zero_extend 32"} zero_extend32_32(bv32) returns (bv64);
 procedure {:extern} rely();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
-  free ensures (memory_load8_le(mem, 2052bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 2053bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 2054bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 2055bv64) == 0bv8);
+  ensures (mem == old(mem));
+  free ensures (memory_load32_le(mem, 2052bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1860bv64);
@@ -86,8 +79,8 @@ procedure {:extern} rely();
 
 procedure {:extern} rely_transitive();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
+  ensures (mem == old(mem));
 
 implementation {:extern} rely_transitive()
 {
@@ -102,18 +95,12 @@ procedure {:extern} guarantee_reflexive();
 
 procedure set_seven();
   modifies Gamma_R8, Gamma_R9, Gamma_mem, R8, R9, mem;
-  free requires (memory_load8_le(mem, 2052bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 2053bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 2054bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 2055bv64) == 0bv8);
+  free requires (memory_load32_le(mem, 2052bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free requires (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free requires (memory_load64_le(mem, 69592bv64) == 1860bv64);
   free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
-  free ensures (memory_load8_le(mem, 2052bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 2053bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 2054bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 2055bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 2052bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1860bv64);
@@ -137,18 +124,12 @@ implementation set_seven()
 
 procedure set_six();
   modifies Gamma_R8, Gamma_R9, Gamma_mem, R8, R9, mem;
-  free requires (memory_load8_le(mem, 2052bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 2053bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 2054bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 2055bv64) == 0bv8);
+  free requires (memory_load32_le(mem, 2052bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free requires (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free requires (memory_load64_le(mem, 69592bv64) == 1860bv64);
   free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
-  free ensures (memory_load8_le(mem, 2052bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 2053bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 2054bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 2055bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 2052bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1860bv64);
@@ -172,18 +153,12 @@ implementation set_six()
 
 procedure set_two();
   modifies Gamma_R8, Gamma_R9, Gamma_mem, R8, R9, mem;
-  free requires (memory_load8_le(mem, 2052bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 2053bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 2054bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 2055bv64) == 0bv8);
+  free requires (memory_load32_le(mem, 2052bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free requires (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free requires (memory_load64_le(mem, 69592bv64) == 1860bv64);
   free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
-  free ensures (memory_load8_le(mem, 2052bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 2053bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 2054bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 2055bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 2052bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1860bv64);
@@ -210,10 +185,7 @@ procedure main();
   requires (Gamma_R0 == true);
   free requires (memory_load64_le(mem, 69664bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
-  free requires (memory_load8_le(mem, 2052bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 2053bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 2054bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 2055bv64) == 0bv8);
+  free requires (memory_load32_le(mem, 2052bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free requires (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free requires (memory_load64_le(mem, 69592bv64) == 1860bv64);
@@ -222,10 +194,7 @@ procedure main();
   free ensures (Gamma_R31 == old(Gamma_R31));
   free ensures (R29 == old(R29));
   free ensures (R31 == old(R31));
-  free ensures (memory_load8_le(mem, 2052bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 2053bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 2054bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 2055bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 2052bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1860bv64);
diff --git a/src/test/correct/functionpointer/clang_pic/functionpointer_gtirb.expected b/src/test/correct/functionpointer/clang_pic/functionpointer_gtirb.expected
index 6ab5da5b5..520e1d13b 100644
--- a/src/test/correct/functionpointer/clang_pic/functionpointer_gtirb.expected
+++ b/src/test/correct/functionpointer/clang_pic/functionpointer_gtirb.expected
@@ -22,7 +22,7 @@ var {:extern} VF: bv1;
 var {:extern} ZF: bv1;
 var {:extern} mem: [bv64]bv8;
 var {:extern} stack: [bv64]bv8;
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
   false
 }
 
@@ -56,10 +56,6 @@ function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv6
   (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
-}
-
 function {:extern} memory_store32_le(memory: [bv64]bv8, index: bv64, value: bv32) returns ([bv64]bv8) {
   memory[index := value[8:0]][bvadd64(index, 1bv64) := value[16:8]][bvadd64(index, 2bv64) := value[24:16]][bvadd64(index, 3bv64) := value[32:24]]
 }
@@ -73,25 +69,22 @@ function {:extern} {:bvbuiltin "zero_extend 1"} zero_extend1_32(bv32) returns (b
 function {:extern} {:bvbuiltin "zero_extend 32"} zero_extend32_32(bv32) returns (bv64);
 procedure {:extern} rely();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
-  free ensures (memory_load8_le(mem, 2192bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 2193bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 2194bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 2195bv64) == 0bv8);
-  free ensures (memory_load64_le(mem, 69576bv64) == 1960bv64);
-  free ensures (memory_load64_le(mem, 69672bv64) == 69672bv64);
-  free ensures (memory_load64_le(mem, 69584bv64) == 2000bv64);
-  free ensures (memory_load64_le(mem, 69552bv64) == 69684bv64);
+  ensures (mem == old(mem));
+  free ensures (memory_load32_le(mem, 2192bv64) == 131073bv32);
+  free ensures (memory_load64_le(mem, 69032bv64) == 1936bv64);
   free ensures (memory_load64_le(mem, 69040bv64) == 1856bv64);
+  free ensures (memory_load64_le(mem, 69552bv64) == 69684bv64);
   free ensures (memory_load64_le(mem, 69568bv64) == 1940bv64);
+  free ensures (memory_load64_le(mem, 69576bv64) == 1960bv64);
+  free ensures (memory_load64_le(mem, 69584bv64) == 2000bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1980bv64);
-  free ensures (memory_load64_le(mem, 69032bv64) == 1936bv64);
+  free ensures (memory_load64_le(mem, 69672bv64) == 69672bv64);
 
 procedure {:extern} rely_transitive();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
+  ensures (mem == old(mem));
 
 implementation {:extern} rely_transitive()
 {
@@ -106,30 +99,24 @@ procedure {:extern} guarantee_reflexive();
 
 procedure set_seven();
   modifies Gamma_R8, Gamma_R9, Gamma_mem, R8, R9, mem;
-  free requires (memory_load8_le(mem, 2192bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 2193bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 2194bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 2195bv64) == 0bv8);
-  free requires (memory_load64_le(mem, 69576bv64) == 1960bv64);
-  free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
-  free requires (memory_load64_le(mem, 69584bv64) == 2000bv64);
-  free requires (memory_load64_le(mem, 69552bv64) == 69684bv64);
+  free requires (memory_load32_le(mem, 2192bv64) == 131073bv32);
+  free requires (memory_load64_le(mem, 69032bv64) == 1936bv64);
   free requires (memory_load64_le(mem, 69040bv64) == 1856bv64);
+  free requires (memory_load64_le(mem, 69552bv64) == 69684bv64);
   free requires (memory_load64_le(mem, 69568bv64) == 1940bv64);
+  free requires (memory_load64_le(mem, 69576bv64) == 1960bv64);
+  free requires (memory_load64_le(mem, 69584bv64) == 2000bv64);
   free requires (memory_load64_le(mem, 69592bv64) == 1980bv64);
-  free requires (memory_load64_le(mem, 69032bv64) == 1936bv64);
-  free ensures (memory_load8_le(mem, 2192bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 2193bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 2194bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 2195bv64) == 0bv8);
-  free ensures (memory_load64_le(mem, 69576bv64) == 1960bv64);
-  free ensures (memory_load64_le(mem, 69672bv64) == 69672bv64);
-  free ensures (memory_load64_le(mem, 69584bv64) == 2000bv64);
-  free ensures (memory_load64_le(mem, 69552bv64) == 69684bv64);
+  free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
+  free ensures (memory_load32_le(mem, 2192bv64) == 131073bv32);
+  free ensures (memory_load64_le(mem, 69032bv64) == 1936bv64);
   free ensures (memory_load64_le(mem, 69040bv64) == 1856bv64);
+  free ensures (memory_load64_le(mem, 69552bv64) == 69684bv64);
   free ensures (memory_load64_le(mem, 69568bv64) == 1940bv64);
+  free ensures (memory_load64_le(mem, 69576bv64) == 1960bv64);
+  free ensures (memory_load64_le(mem, 69584bv64) == 2000bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1980bv64);
-  free ensures (memory_load64_le(mem, 69032bv64) == 1936bv64);
+  free ensures (memory_load64_le(mem, 69672bv64) == 69672bv64);
 
 implementation set_seven()
 {
@@ -151,30 +138,24 @@ implementation set_seven()
 
 procedure set_six();
   modifies Gamma_R8, Gamma_R9, Gamma_mem, R8, R9, mem;
-  free requires (memory_load8_le(mem, 2192bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 2193bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 2194bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 2195bv64) == 0bv8);
-  free requires (memory_load64_le(mem, 69576bv64) == 1960bv64);
-  free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
-  free requires (memory_load64_le(mem, 69584bv64) == 2000bv64);
-  free requires (memory_load64_le(mem, 69552bv64) == 69684bv64);
+  free requires (memory_load32_le(mem, 2192bv64) == 131073bv32);
+  free requires (memory_load64_le(mem, 69032bv64) == 1936bv64);
   free requires (memory_load64_le(mem, 69040bv64) == 1856bv64);
+  free requires (memory_load64_le(mem, 69552bv64) == 69684bv64);
   free requires (memory_load64_le(mem, 69568bv64) == 1940bv64);
+  free requires (memory_load64_le(mem, 69576bv64) == 1960bv64);
+  free requires (memory_load64_le(mem, 69584bv64) == 2000bv64);
   free requires (memory_load64_le(mem, 69592bv64) == 1980bv64);
-  free requires (memory_load64_le(mem, 69032bv64) == 1936bv64);
-  free ensures (memory_load8_le(mem, 2192bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 2193bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 2194bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 2195bv64) == 0bv8);
-  free ensures (memory_load64_le(mem, 69576bv64) == 1960bv64);
-  free ensures (memory_load64_le(mem, 69672bv64) == 69672bv64);
-  free ensures (memory_load64_le(mem, 69584bv64) == 2000bv64);
-  free ensures (memory_load64_le(mem, 69552bv64) == 69684bv64);
+  free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
+  free ensures (memory_load32_le(mem, 2192bv64) == 131073bv32);
+  free ensures (memory_load64_le(mem, 69032bv64) == 1936bv64);
   free ensures (memory_load64_le(mem, 69040bv64) == 1856bv64);
+  free ensures (memory_load64_le(mem, 69552bv64) == 69684bv64);
   free ensures (memory_load64_le(mem, 69568bv64) == 1940bv64);
+  free ensures (memory_load64_le(mem, 69576bv64) == 1960bv64);
+  free ensures (memory_load64_le(mem, 69584bv64) == 2000bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1980bv64);
-  free ensures (memory_load64_le(mem, 69032bv64) == 1936bv64);
+  free ensures (memory_load64_le(mem, 69672bv64) == 69672bv64);
 
 implementation set_six()
 {
@@ -199,34 +180,28 @@ procedure main();
   requires (Gamma_R0 == true);
   free requires (memory_load64_le(mem, 69664bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
-  free requires (memory_load8_le(mem, 2192bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 2193bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 2194bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 2195bv64) == 0bv8);
-  free requires (memory_load64_le(mem, 69576bv64) == 1960bv64);
-  free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
-  free requires (memory_load64_le(mem, 69584bv64) == 2000bv64);
-  free requires (memory_load64_le(mem, 69552bv64) == 69684bv64);
+  free requires (memory_load32_le(mem, 2192bv64) == 131073bv32);
+  free requires (memory_load64_le(mem, 69032bv64) == 1936bv64);
   free requires (memory_load64_le(mem, 69040bv64) == 1856bv64);
+  free requires (memory_load64_le(mem, 69552bv64) == 69684bv64);
   free requires (memory_load64_le(mem, 69568bv64) == 1940bv64);
+  free requires (memory_load64_le(mem, 69576bv64) == 1960bv64);
+  free requires (memory_load64_le(mem, 69584bv64) == 2000bv64);
   free requires (memory_load64_le(mem, 69592bv64) == 1980bv64);
-  free requires (memory_load64_le(mem, 69032bv64) == 1936bv64);
+  free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
   free ensures (Gamma_R29 == old(Gamma_R29));
   free ensures (Gamma_R31 == old(Gamma_R31));
   free ensures (R29 == old(R29));
   free ensures (R31 == old(R31));
-  free ensures (memory_load8_le(mem, 2192bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 2193bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 2194bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 2195bv64) == 0bv8);
-  free ensures (memory_load64_le(mem, 69576bv64) == 1960bv64);
-  free ensures (memory_load64_le(mem, 69672bv64) == 69672bv64);
-  free ensures (memory_load64_le(mem, 69584bv64) == 2000bv64);
-  free ensures (memory_load64_le(mem, 69552bv64) == 69684bv64);
+  free ensures (memory_load32_le(mem, 2192bv64) == 131073bv32);
+  free ensures (memory_load64_le(mem, 69032bv64) == 1936bv64);
   free ensures (memory_load64_le(mem, 69040bv64) == 1856bv64);
+  free ensures (memory_load64_le(mem, 69552bv64) == 69684bv64);
   free ensures (memory_load64_le(mem, 69568bv64) == 1940bv64);
+  free ensures (memory_load64_le(mem, 69576bv64) == 1960bv64);
+  free ensures (memory_load64_le(mem, 69584bv64) == 2000bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1980bv64);
-  free ensures (memory_load64_le(mem, 69032bv64) == 1936bv64);
+  free ensures (memory_load64_le(mem, 69672bv64) == 69672bv64);
 
 implementation main()
 {
@@ -422,30 +397,24 @@ implementation main()
 
 procedure set_two();
   modifies Gamma_R8, Gamma_R9, Gamma_mem, R8, R9, mem;
-  free requires (memory_load8_le(mem, 2192bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 2193bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 2194bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 2195bv64) == 0bv8);
-  free requires (memory_load64_le(mem, 69576bv64) == 1960bv64);
-  free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
-  free requires (memory_load64_le(mem, 69584bv64) == 2000bv64);
-  free requires (memory_load64_le(mem, 69552bv64) == 69684bv64);
+  free requires (memory_load32_le(mem, 2192bv64) == 131073bv32);
+  free requires (memory_load64_le(mem, 69032bv64) == 1936bv64);
   free requires (memory_load64_le(mem, 69040bv64) == 1856bv64);
+  free requires (memory_load64_le(mem, 69552bv64) == 69684bv64);
   free requires (memory_load64_le(mem, 69568bv64) == 1940bv64);
+  free requires (memory_load64_le(mem, 69576bv64) == 1960bv64);
+  free requires (memory_load64_le(mem, 69584bv64) == 2000bv64);
   free requires (memory_load64_le(mem, 69592bv64) == 1980bv64);
-  free requires (memory_load64_le(mem, 69032bv64) == 1936bv64);
-  free ensures (memory_load8_le(mem, 2192bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 2193bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 2194bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 2195bv64) == 0bv8);
-  free ensures (memory_load64_le(mem, 69576bv64) == 1960bv64);
-  free ensures (memory_load64_le(mem, 69672bv64) == 69672bv64);
-  free ensures (memory_load64_le(mem, 69584bv64) == 2000bv64);
-  free ensures (memory_load64_le(mem, 69552bv64) == 69684bv64);
+  free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
+  free ensures (memory_load32_le(mem, 2192bv64) == 131073bv32);
+  free ensures (memory_load64_le(mem, 69032bv64) == 1936bv64);
   free ensures (memory_load64_le(mem, 69040bv64) == 1856bv64);
+  free ensures (memory_load64_le(mem, 69552bv64) == 69684bv64);
   free ensures (memory_load64_le(mem, 69568bv64) == 1940bv64);
+  free ensures (memory_load64_le(mem, 69576bv64) == 1960bv64);
+  free ensures (memory_load64_le(mem, 69584bv64) == 2000bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1980bv64);
-  free ensures (memory_load64_le(mem, 69032bv64) == 1936bv64);
+  free ensures (memory_load64_le(mem, 69672bv64) == 69672bv64);
 
 implementation set_two()
 {
diff --git a/src/test/correct/functionpointer/gcc/functionpointer_gtirb.expected b/src/test/correct/functionpointer/gcc/functionpointer_gtirb.expected
index 1533649c5..42c6797e6 100644
--- a/src/test/correct/functionpointer/gcc/functionpointer_gtirb.expected
+++ b/src/test/correct/functionpointer/gcc/functionpointer_gtirb.expected
@@ -20,7 +20,7 @@ var {:extern} VF: bv1;
 var {:extern} ZF: bv1;
 var {:extern} mem: [bv64]bv8;
 var {:extern} stack: [bv64]bv8;
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
   false
 }
 
@@ -54,10 +54,6 @@ function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv6
   (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
-}
-
 function {:extern} memory_store32_le(memory: [bv64]bv8, index: bv64, value: bv32) returns ([bv64]bv8) {
   memory[index := value[8:0]][bvadd64(index, 1bv64) := value[16:8]][bvadd64(index, 2bv64) := value[24:16]][bvadd64(index, 3bv64) := value[32:24]]
 }
@@ -71,12 +67,9 @@ function {:extern} {:bvbuiltin "zero_extend 1"} zero_extend1_32(bv32) returns (b
 function {:extern} {:bvbuiltin "zero_extend 32"} zero_extend32_32(bv32) returns (bv64);
 procedure {:extern} rely();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
-  free ensures (memory_load8_le(mem, 2052bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 2053bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 2054bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 2055bv64) == 0bv8);
+  ensures (mem == old(mem));
+  free ensures (memory_load32_le(mem, 2052bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69016bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69024bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69616bv64) == 1884bv64);
@@ -84,8 +77,8 @@ procedure {:extern} rely();
 
 procedure {:extern} rely_transitive();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
+  ensures (mem == old(mem));
 
 implementation {:extern} rely_transitive()
 {
@@ -100,18 +93,12 @@ procedure {:extern} guarantee_reflexive();
 
 procedure set_six();
   modifies Gamma_R0, Gamma_R1, Gamma_mem, R0, R1, mem;
-  free requires (memory_load8_le(mem, 2052bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 2053bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 2054bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 2055bv64) == 0bv8);
+  free requires (memory_load32_le(mem, 2052bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69016bv64) == 1808bv64);
   free requires (memory_load64_le(mem, 69024bv64) == 1728bv64);
   free requires (memory_load64_le(mem, 69616bv64) == 1884bv64);
   free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free ensures (memory_load8_le(mem, 2052bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 2053bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 2054bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 2055bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 2052bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69016bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69024bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69616bv64) == 1884bv64);
@@ -139,10 +126,7 @@ procedure main();
   requires (Gamma_R0 == true);
   free requires (memory_load64_le(mem, 69632bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free requires (memory_load8_le(mem, 2052bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 2053bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 2054bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 2055bv64) == 0bv8);
+  free requires (memory_load32_le(mem, 2052bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69016bv64) == 1808bv64);
   free requires (memory_load64_le(mem, 69024bv64) == 1728bv64);
   free requires (memory_load64_le(mem, 69616bv64) == 1884bv64);
@@ -151,10 +135,7 @@ procedure main();
   free ensures (Gamma_R31 == old(Gamma_R31));
   free ensures (R29 == old(R29));
   free ensures (R31 == old(R31));
-  free ensures (memory_load8_le(mem, 2052bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 2053bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 2054bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 2055bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 2052bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69016bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69024bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69616bv64) == 1884bv64);
@@ -318,18 +299,12 @@ implementation main()
 
 procedure set_seven();
   modifies Gamma_R0, Gamma_R1, Gamma_mem, R0, R1, mem;
-  free requires (memory_load8_le(mem, 2052bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 2053bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 2054bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 2055bv64) == 0bv8);
+  free requires (memory_load32_le(mem, 2052bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69016bv64) == 1808bv64);
   free requires (memory_load64_le(mem, 69024bv64) == 1728bv64);
   free requires (memory_load64_le(mem, 69616bv64) == 1884bv64);
   free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free ensures (memory_load8_le(mem, 2052bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 2053bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 2054bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 2055bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 2052bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69016bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69024bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69616bv64) == 1884bv64);
@@ -354,18 +329,12 @@ implementation set_seven()
 
 procedure set_two();
   modifies Gamma_R0, Gamma_R1, Gamma_mem, R0, R1, mem;
-  free requires (memory_load8_le(mem, 2052bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 2053bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 2054bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 2055bv64) == 0bv8);
+  free requires (memory_load32_le(mem, 2052bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69016bv64) == 1808bv64);
   free requires (memory_load64_le(mem, 69024bv64) == 1728bv64);
   free requires (memory_load64_le(mem, 69616bv64) == 1884bv64);
   free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free ensures (memory_load8_le(mem, 2052bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 2053bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 2054bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 2055bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 2052bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69016bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69024bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69616bv64) == 1884bv64);
diff --git a/src/test/correct/functionpointer/gcc_O2/functionpointer_gtirb.expected b/src/test/correct/functionpointer/gcc_O2/functionpointer_gtirb.expected
index 617efea08..5efba0883 100644
--- a/src/test/correct/functionpointer/gcc_O2/functionpointer_gtirb.expected
+++ b/src/test/correct/functionpointer/gcc_O2/functionpointer_gtirb.expected
@@ -20,7 +20,7 @@ var {:extern} VF: bv1;
 var {:extern} ZF: bv1;
 var {:extern} mem: [bv64]bv8;
 var {:extern} stack: [bv64]bv8;
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
   false
 }
 
@@ -42,12 +42,12 @@ function {:extern} gamma_store64(gammaMap: [bv64]bool, index: bv64, value: bool)
   gammaMap[index := value][bvadd64(index, 1bv64) := value][bvadd64(index, 2bv64) := value][bvadd64(index, 3bv64) := value][bvadd64(index, 4bv64) := value][bvadd64(index, 5bv64) := value][bvadd64(index, 6bv64) := value][bvadd64(index, 7bv64) := value]
 }
 
-function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv64) {
-  (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
+function {:extern} memory_load32_le(memory: [bv64]bv8, index: bv64) returns (bv32) {
+  (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
+function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv64) {
+  (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
 function {:extern} memory_store32_le(memory: [bv64]bv8, index: bv64, value: bv32) returns ([bv64]bv8) {
@@ -62,12 +62,9 @@ function {:extern} {:bvbuiltin "sign_extend 1"} sign_extend1_32(bv32) returns (b
 function {:extern} {:bvbuiltin "zero_extend 1"} zero_extend1_32(bv32) returns (bv33);
 procedure {:extern} rely();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
-  free ensures (memory_load8_le(mem, 2020bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 2021bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 2022bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 2023bv64) == 0bv8);
+  ensures (mem == old(mem));
+  free ensures (memory_load32_le(mem, 2020bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69016bv64) == 1936bv64);
   free ensures (memory_load64_le(mem, 69024bv64) == 1856bv64);
   free ensures (memory_load64_le(mem, 69616bv64) == 1536bv64);
@@ -75,8 +72,8 @@ procedure {:extern} rely();
 
 procedure {:extern} rely_transitive();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
+  ensures (mem == old(mem));
 
 implementation {:extern} rely_transitive()
 {
@@ -91,18 +88,12 @@ procedure {:extern} guarantee_reflexive();
 
 procedure set_six();
   modifies Gamma_R0, Gamma_R1, Gamma_mem, R0, R1, mem;
-  free requires (memory_load8_le(mem, 2020bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 2021bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 2022bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 2023bv64) == 0bv8);
+  free requires (memory_load32_le(mem, 2020bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69016bv64) == 1936bv64);
   free requires (memory_load64_le(mem, 69024bv64) == 1856bv64);
   free requires (memory_load64_le(mem, 69616bv64) == 1536bv64);
   free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free ensures (memory_load8_le(mem, 2020bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 2021bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 2022bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 2023bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 2020bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69016bv64) == 1936bv64);
   free ensures (memory_load64_le(mem, 69024bv64) == 1856bv64);
   free ensures (memory_load64_le(mem, 69616bv64) == 1536bv64);
@@ -129,10 +120,7 @@ procedure main();
   requires (Gamma_R0 == true);
   free requires (memory_load64_le(mem, 69632bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free requires (memory_load8_le(mem, 2020bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 2021bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 2022bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 2023bv64) == 0bv8);
+  free requires (memory_load32_le(mem, 2020bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69016bv64) == 1936bv64);
   free requires (memory_load64_le(mem, 69024bv64) == 1856bv64);
   free requires (memory_load64_le(mem, 69616bv64) == 1536bv64);
@@ -141,10 +129,7 @@ procedure main();
   free ensures (Gamma_R31 == old(Gamma_R31));
   free ensures (R29 == old(R29));
   free ensures (R31 == old(R31));
-  free ensures (memory_load8_le(mem, 2020bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 2021bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 2022bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 2023bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 2020bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69016bv64) == 1936bv64);
   free ensures (memory_load64_le(mem, 69024bv64) == 1856bv64);
   free ensures (memory_load64_le(mem, 69616bv64) == 1536bv64);
diff --git a/src/test/correct/functionpointer/gcc_pic/functionpointer_gtirb.expected b/src/test/correct/functionpointer/gcc_pic/functionpointer_gtirb.expected
index aa1b8397d..3e7676341 100644
--- a/src/test/correct/functionpointer/gcc_pic/functionpointer_gtirb.expected
+++ b/src/test/correct/functionpointer/gcc_pic/functionpointer_gtirb.expected
@@ -20,7 +20,7 @@ var {:extern} VF: bv1;
 var {:extern} ZF: bv1;
 var {:extern} mem: [bv64]bv8;
 var {:extern} stack: [bv64]bv8;
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
   false
 }
 
@@ -54,10 +54,6 @@ function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv6
   (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
-}
-
 function {:extern} memory_store32_le(memory: [bv64]bv8, index: bv64, value: bv32) returns ([bv64]bv8) {
   memory[index := value[8:0]][bvadd64(index, 1bv64) := value[16:8]][bvadd64(index, 2bv64) := value[24:16]][bvadd64(index, 3bv64) := value[32:24]]
 }
@@ -71,25 +67,22 @@ function {:extern} {:bvbuiltin "zero_extend 1"} zero_extend1_32(bv32) returns (b
 function {:extern} {:bvbuiltin "zero_extend 32"} zero_extend32_32(bv32) returns (bv64);
 procedure {:extern} rely();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
-  free ensures (memory_load8_le(mem, 2180bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 2181bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 2182bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 2183bv64) == 0bv8);
-  free ensures (memory_load64_le(mem, 69608bv64) == 2012bv64);
-  free ensures (memory_load64_le(mem, 69576bv64) == 69652bv64);
-  free ensures (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free ensures (memory_load64_le(mem, 69616bv64) == 1988bv64);
-  free ensures (memory_load64_le(mem, 69600bv64) == 1964bv64);
-  free ensures (memory_load64_le(mem, 68992bv64) == 1856bv64);
+  ensures (mem == old(mem));
+  free ensures (memory_load32_le(mem, 2180bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 68984bv64) == 1936bv64);
+  free ensures (memory_load64_le(mem, 68992bv64) == 1856bv64);
+  free ensures (memory_load64_le(mem, 69576bv64) == 69652bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1940bv64);
+  free ensures (memory_load64_le(mem, 69600bv64) == 1964bv64);
+  free ensures (memory_load64_le(mem, 69608bv64) == 2012bv64);
+  free ensures (memory_load64_le(mem, 69616bv64) == 1988bv64);
+  free ensures (memory_load64_le(mem, 69640bv64) == 69640bv64);
 
 procedure {:extern} rely_transitive();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
+  ensures (mem == old(mem));
 
 implementation {:extern} rely_transitive()
 {
@@ -104,30 +97,24 @@ procedure {:extern} guarantee_reflexive();
 
 procedure set_seven();
   modifies Gamma_R0, Gamma_R1, Gamma_mem, R0, R1, mem;
-  free requires (memory_load8_le(mem, 2180bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 2181bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 2182bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 2183bv64) == 0bv8);
-  free requires (memory_load64_le(mem, 69608bv64) == 2012bv64);
-  free requires (memory_load64_le(mem, 69576bv64) == 69652bv64);
-  free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free requires (memory_load64_le(mem, 69616bv64) == 1988bv64);
-  free requires (memory_load64_le(mem, 69600bv64) == 1964bv64);
-  free requires (memory_load64_le(mem, 68992bv64) == 1856bv64);
+  free requires (memory_load32_le(mem, 2180bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 68984bv64) == 1936bv64);
+  free requires (memory_load64_le(mem, 68992bv64) == 1856bv64);
+  free requires (memory_load64_le(mem, 69576bv64) == 69652bv64);
   free requires (memory_load64_le(mem, 69592bv64) == 1940bv64);
-  free ensures (memory_load8_le(mem, 2180bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 2181bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 2182bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 2183bv64) == 0bv8);
-  free ensures (memory_load64_le(mem, 69608bv64) == 2012bv64);
-  free ensures (memory_load64_le(mem, 69576bv64) == 69652bv64);
-  free ensures (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free ensures (memory_load64_le(mem, 69616bv64) == 1988bv64);
-  free ensures (memory_load64_le(mem, 69600bv64) == 1964bv64);
-  free ensures (memory_load64_le(mem, 68992bv64) == 1856bv64);
+  free requires (memory_load64_le(mem, 69600bv64) == 1964bv64);
+  free requires (memory_load64_le(mem, 69608bv64) == 2012bv64);
+  free requires (memory_load64_le(mem, 69616bv64) == 1988bv64);
+  free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
+  free ensures (memory_load32_le(mem, 2180bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 68984bv64) == 1936bv64);
+  free ensures (memory_load64_le(mem, 68992bv64) == 1856bv64);
+  free ensures (memory_load64_le(mem, 69576bv64) == 69652bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1940bv64);
+  free ensures (memory_load64_le(mem, 69600bv64) == 1964bv64);
+  free ensures (memory_load64_le(mem, 69608bv64) == 2012bv64);
+  free ensures (memory_load64_le(mem, 69616bv64) == 1988bv64);
+  free ensures (memory_load64_le(mem, 69640bv64) == 69640bv64);
 
 implementation set_seven()
 {
@@ -152,34 +139,28 @@ procedure main();
   requires (Gamma_R0 == true);
   free requires (memory_load64_le(mem, 69632bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free requires (memory_load8_le(mem, 2180bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 2181bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 2182bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 2183bv64) == 0bv8);
-  free requires (memory_load64_le(mem, 69608bv64) == 2012bv64);
-  free requires (memory_load64_le(mem, 69576bv64) == 69652bv64);
-  free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free requires (memory_load64_le(mem, 69616bv64) == 1988bv64);
-  free requires (memory_load64_le(mem, 69600bv64) == 1964bv64);
-  free requires (memory_load64_le(mem, 68992bv64) == 1856bv64);
+  free requires (memory_load32_le(mem, 2180bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 68984bv64) == 1936bv64);
+  free requires (memory_load64_le(mem, 68992bv64) == 1856bv64);
+  free requires (memory_load64_le(mem, 69576bv64) == 69652bv64);
   free requires (memory_load64_le(mem, 69592bv64) == 1940bv64);
+  free requires (memory_load64_le(mem, 69600bv64) == 1964bv64);
+  free requires (memory_load64_le(mem, 69608bv64) == 2012bv64);
+  free requires (memory_load64_le(mem, 69616bv64) == 1988bv64);
+  free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
   free ensures (Gamma_R29 == old(Gamma_R29));
   free ensures (Gamma_R31 == old(Gamma_R31));
   free ensures (R29 == old(R29));
   free ensures (R31 == old(R31));
-  free ensures (memory_load8_le(mem, 2180bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 2181bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 2182bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 2183bv64) == 0bv8);
-  free ensures (memory_load64_le(mem, 69608bv64) == 2012bv64);
-  free ensures (memory_load64_le(mem, 69576bv64) == 69652bv64);
-  free ensures (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free ensures (memory_load64_le(mem, 69616bv64) == 1988bv64);
-  free ensures (memory_load64_le(mem, 69600bv64) == 1964bv64);
-  free ensures (memory_load64_le(mem, 68992bv64) == 1856bv64);
+  free ensures (memory_load32_le(mem, 2180bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 68984bv64) == 1936bv64);
+  free ensures (memory_load64_le(mem, 68992bv64) == 1856bv64);
+  free ensures (memory_load64_le(mem, 69576bv64) == 69652bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1940bv64);
+  free ensures (memory_load64_le(mem, 69600bv64) == 1964bv64);
+  free ensures (memory_load64_le(mem, 69608bv64) == 2012bv64);
+  free ensures (memory_load64_le(mem, 69616bv64) == 1988bv64);
+  free ensures (memory_load64_le(mem, 69640bv64) == 69640bv64);
 
 implementation main()
 {
@@ -343,30 +324,24 @@ implementation main()
 
 procedure set_two();
   modifies Gamma_R0, Gamma_R1, Gamma_mem, R0, R1, mem;
-  free requires (memory_load8_le(mem, 2180bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 2181bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 2182bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 2183bv64) == 0bv8);
-  free requires (memory_load64_le(mem, 69608bv64) == 2012bv64);
-  free requires (memory_load64_le(mem, 69576bv64) == 69652bv64);
-  free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free requires (memory_load64_le(mem, 69616bv64) == 1988bv64);
-  free requires (memory_load64_le(mem, 69600bv64) == 1964bv64);
-  free requires (memory_load64_le(mem, 68992bv64) == 1856bv64);
+  free requires (memory_load32_le(mem, 2180bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 68984bv64) == 1936bv64);
+  free requires (memory_load64_le(mem, 68992bv64) == 1856bv64);
+  free requires (memory_load64_le(mem, 69576bv64) == 69652bv64);
   free requires (memory_load64_le(mem, 69592bv64) == 1940bv64);
-  free ensures (memory_load8_le(mem, 2180bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 2181bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 2182bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 2183bv64) == 0bv8);
-  free ensures (memory_load64_le(mem, 69608bv64) == 2012bv64);
-  free ensures (memory_load64_le(mem, 69576bv64) == 69652bv64);
-  free ensures (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free ensures (memory_load64_le(mem, 69616bv64) == 1988bv64);
-  free ensures (memory_load64_le(mem, 69600bv64) == 1964bv64);
-  free ensures (memory_load64_le(mem, 68992bv64) == 1856bv64);
+  free requires (memory_load64_le(mem, 69600bv64) == 1964bv64);
+  free requires (memory_load64_le(mem, 69608bv64) == 2012bv64);
+  free requires (memory_load64_le(mem, 69616bv64) == 1988bv64);
+  free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
+  free ensures (memory_load32_le(mem, 2180bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 68984bv64) == 1936bv64);
+  free ensures (memory_load64_le(mem, 68992bv64) == 1856bv64);
+  free ensures (memory_load64_le(mem, 69576bv64) == 69652bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1940bv64);
+  free ensures (memory_load64_le(mem, 69600bv64) == 1964bv64);
+  free ensures (memory_load64_le(mem, 69608bv64) == 2012bv64);
+  free ensures (memory_load64_le(mem, 69616bv64) == 1988bv64);
+  free ensures (memory_load64_le(mem, 69640bv64) == 69640bv64);
 
 implementation set_two()
 {
@@ -388,30 +363,24 @@ implementation set_two()
 
 procedure set_six();
   modifies Gamma_R0, Gamma_R1, Gamma_mem, R0, R1, mem;
-  free requires (memory_load8_le(mem, 2180bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 2181bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 2182bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 2183bv64) == 0bv8);
-  free requires (memory_load64_le(mem, 69608bv64) == 2012bv64);
-  free requires (memory_load64_le(mem, 69576bv64) == 69652bv64);
-  free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free requires (memory_load64_le(mem, 69616bv64) == 1988bv64);
-  free requires (memory_load64_le(mem, 69600bv64) == 1964bv64);
-  free requires (memory_load64_le(mem, 68992bv64) == 1856bv64);
+  free requires (memory_load32_le(mem, 2180bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 68984bv64) == 1936bv64);
+  free requires (memory_load64_le(mem, 68992bv64) == 1856bv64);
+  free requires (memory_load64_le(mem, 69576bv64) == 69652bv64);
   free requires (memory_load64_le(mem, 69592bv64) == 1940bv64);
-  free ensures (memory_load8_le(mem, 2180bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 2181bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 2182bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 2183bv64) == 0bv8);
-  free ensures (memory_load64_le(mem, 69608bv64) == 2012bv64);
-  free ensures (memory_load64_le(mem, 69576bv64) == 69652bv64);
-  free ensures (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free ensures (memory_load64_le(mem, 69616bv64) == 1988bv64);
-  free ensures (memory_load64_le(mem, 69600bv64) == 1964bv64);
-  free ensures (memory_load64_le(mem, 68992bv64) == 1856bv64);
+  free requires (memory_load64_le(mem, 69600bv64) == 1964bv64);
+  free requires (memory_load64_le(mem, 69608bv64) == 2012bv64);
+  free requires (memory_load64_le(mem, 69616bv64) == 1988bv64);
+  free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
+  free ensures (memory_load32_le(mem, 2180bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 68984bv64) == 1936bv64);
+  free ensures (memory_load64_le(mem, 68992bv64) == 1856bv64);
+  free ensures (memory_load64_le(mem, 69576bv64) == 69652bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1940bv64);
+  free ensures (memory_load64_le(mem, 69600bv64) == 1964bv64);
+  free ensures (memory_load64_le(mem, 69608bv64) == 2012bv64);
+  free ensures (memory_load64_le(mem, 69616bv64) == 1988bv64);
+  free ensures (memory_load64_le(mem, 69640bv64) == 69640bv64);
 
 implementation set_six()
 {
diff --git a/src/test/correct/functions_with_params/clang/functions_with_params.expected b/src/test/correct/functions_with_params/clang/functions_with_params.expected
index d2b236b8c..26a4ae5d6 100644
--- a/src/test/correct/functions_with_params/clang/functions_with_params.expected
+++ b/src/test/correct/functions_with_params/clang/functions_with_params.expected
@@ -40,10 +40,6 @@ function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv6
   (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
-}
-
 function {:extern} memory_store32_le(memory: [bv64]bv8, index: bv64, value: bv32) returns ([bv64]bv8) {
   memory[index := value[8:0]][bvadd64(index, 1bv64) := value[16:8]][bvadd64(index, 2bv64) := value[24:16]][bvadd64(index, 3bv64) := value[32:24]]
 }
@@ -55,12 +51,9 @@ function {:extern} memory_store64_le(memory: [bv64]bv8, index: bv64, value: bv64
 function {:extern} {:bvbuiltin "zero_extend 32"} zero_extend32_32(bv32) returns (bv64);
 procedure {:extern} rely();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
-  free ensures (memory_load8_le(mem, 1912bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1913bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1914bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1915bv64) == 0bv8);
+  ensures (mem == old(mem));
+  free ensures (memory_load32_le(mem, 1912bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1812bv64);
@@ -68,8 +61,8 @@ procedure {:extern} rely();
 
 procedure {:extern} rely_transitive();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
+  ensures (mem == old(mem));
 
 implementation {:extern} rely_transitive()
 {
@@ -86,10 +79,7 @@ procedure main();
   modifies Gamma_R0, Gamma_R29, Gamma_R30, Gamma_R31, Gamma_R8, Gamma_stack, R0, R29, R30, R31, R8, stack;
   free requires (memory_load64_le(mem, 69664bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
-  free requires (memory_load8_le(mem, 1912bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1913bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1914bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1915bv64) == 0bv8);
+  free requires (memory_load32_le(mem, 1912bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free requires (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free requires (memory_load64_le(mem, 69592bv64) == 1812bv64);
@@ -98,10 +88,7 @@ procedure main();
   free ensures (Gamma_R31 == old(Gamma_R31));
   free ensures (R29 == old(R29));
   free ensures (R31 == old(R31));
-  free ensures (memory_load8_le(mem, 1912bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1913bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1914bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1915bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1912bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1812bv64);
@@ -149,20 +136,14 @@ implementation main()
 
 procedure plus_one();
   modifies Gamma_R0, Gamma_R31, Gamma_R8, Gamma_stack, R0, R31, R8, stack;
-  free requires (memory_load8_le(mem, 1912bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1913bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1914bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1915bv64) == 0bv8);
+  free requires (memory_load32_le(mem, 1912bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free requires (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free requires (memory_load64_le(mem, 69592bv64) == 1812bv64);
   free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
   free ensures (Gamma_R31 == old(Gamma_R31));
   free ensures (R31 == old(R31));
-  free ensures (memory_load8_le(mem, 1912bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1913bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1914bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1915bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1912bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1812bv64);
diff --git a/src/test/correct/functions_with_params/clang/functions_with_params_gtirb.expected b/src/test/correct/functions_with_params/clang/functions_with_params_gtirb.expected
index 428eb1a3e..e73fc78e3 100644
--- a/src/test/correct/functions_with_params/clang/functions_with_params_gtirb.expected
+++ b/src/test/correct/functions_with_params/clang/functions_with_params_gtirb.expected
@@ -40,10 +40,6 @@ function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv6
   (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
-}
-
 function {:extern} memory_store32_le(memory: [bv64]bv8, index: bv64, value: bv32) returns ([bv64]bv8) {
   memory[index := value[8:0]][bvadd64(index, 1bv64) := value[16:8]][bvadd64(index, 2bv64) := value[24:16]][bvadd64(index, 3bv64) := value[32:24]]
 }
@@ -55,12 +51,9 @@ function {:extern} memory_store64_le(memory: [bv64]bv8, index: bv64, value: bv64
 function {:extern} {:bvbuiltin "zero_extend 32"} zero_extend32_32(bv32) returns (bv64);
 procedure {:extern} rely();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
-  free ensures (memory_load8_le(mem, 1912bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1913bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1914bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1915bv64) == 0bv8);
+  ensures (mem == old(mem));
+  free ensures (memory_load32_le(mem, 1912bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1812bv64);
@@ -68,8 +61,8 @@ procedure {:extern} rely();
 
 procedure {:extern} rely_transitive();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
+  ensures (mem == old(mem));
 
 implementation {:extern} rely_transitive()
 {
@@ -86,10 +79,7 @@ procedure main();
   modifies Gamma_R0, Gamma_R29, Gamma_R30, Gamma_R31, Gamma_R8, Gamma_stack, R0, R29, R30, R31, R8, stack;
   free requires (memory_load64_le(mem, 69664bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
-  free requires (memory_load8_le(mem, 1912bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1913bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1914bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1915bv64) == 0bv8);
+  free requires (memory_load32_le(mem, 1912bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free requires (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free requires (memory_load64_le(mem, 69592bv64) == 1812bv64);
@@ -98,10 +88,7 @@ procedure main();
   free ensures (Gamma_R31 == old(Gamma_R31));
   free ensures (R29 == old(R29));
   free ensures (R31 == old(R31));
-  free ensures (memory_load8_le(mem, 1912bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1913bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1914bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1915bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1912bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1812bv64);
@@ -149,20 +136,14 @@ implementation main()
 
 procedure plus_one();
   modifies Gamma_R0, Gamma_R31, Gamma_R8, Gamma_stack, R0, R31, R8, stack;
-  free requires (memory_load8_le(mem, 1912bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1913bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1914bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1915bv64) == 0bv8);
+  free requires (memory_load32_le(mem, 1912bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free requires (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free requires (memory_load64_le(mem, 69592bv64) == 1812bv64);
   free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
   free ensures (Gamma_R31 == old(Gamma_R31));
   free ensures (R31 == old(R31));
-  free ensures (memory_load8_le(mem, 1912bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1913bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1914bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1915bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1912bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1812bv64);
diff --git a/src/test/correct/functions_with_params/gcc/functions_with_params.expected b/src/test/correct/functions_with_params/gcc/functions_with_params.expected
index 2adfff70a..c1563536b 100644
--- a/src/test/correct/functions_with_params/gcc/functions_with_params.expected
+++ b/src/test/correct/functions_with_params/gcc/functions_with_params.expected
@@ -38,10 +38,6 @@ function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv6
   (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
-}
-
 function {:extern} memory_store32_le(memory: [bv64]bv8, index: bv64, value: bv32) returns ([bv64]bv8) {
   memory[index := value[8:0]][bvadd64(index, 1bv64) := value[16:8]][bvadd64(index, 2bv64) := value[24:16]][bvadd64(index, 3bv64) := value[32:24]]
 }
@@ -53,12 +49,9 @@ function {:extern} memory_store64_le(memory: [bv64]bv8, index: bv64, value: bv64
 function {:extern} {:bvbuiltin "zero_extend 32"} zero_extend32_32(bv32) returns (bv64);
 procedure {:extern} rely();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
-  free ensures (memory_load8_le(mem, 1904bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1905bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1906bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1907bv64) == 0bv8);
+  ensures (mem == old(mem));
+  free ensures (memory_load32_le(mem, 1904bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69016bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69024bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69616bv64) == 1812bv64);
@@ -66,8 +59,8 @@ procedure {:extern} rely();
 
 procedure {:extern} rely_transitive();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
+  ensures (mem == old(mem));
 
 implementation {:extern} rely_transitive()
 {
@@ -84,10 +77,7 @@ procedure main();
   modifies Gamma_R0, Gamma_R29, Gamma_R30, Gamma_R31, Gamma_stack, R0, R29, R30, R31, stack;
   free requires (memory_load64_le(mem, 69632bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free requires (memory_load8_le(mem, 1904bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1905bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1906bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1907bv64) == 0bv8);
+  free requires (memory_load32_le(mem, 1904bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69016bv64) == 1808bv64);
   free requires (memory_load64_le(mem, 69024bv64) == 1728bv64);
   free requires (memory_load64_le(mem, 69616bv64) == 1812bv64);
@@ -96,10 +86,7 @@ procedure main();
   free ensures (Gamma_R31 == old(Gamma_R31));
   free ensures (R29 == old(R29));
   free ensures (R31 == old(R31));
-  free ensures (memory_load8_le(mem, 1904bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1905bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1906bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1907bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1904bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69016bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69024bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69616bv64) == 1812bv64);
@@ -144,20 +131,14 @@ implementation main()
 
 procedure plus_one();
   modifies Gamma_R0, Gamma_R31, Gamma_stack, R0, R31, stack;
-  free requires (memory_load8_le(mem, 1904bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1905bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1906bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1907bv64) == 0bv8);
+  free requires (memory_load32_le(mem, 1904bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69016bv64) == 1808bv64);
   free requires (memory_load64_le(mem, 69024bv64) == 1728bv64);
   free requires (memory_load64_le(mem, 69616bv64) == 1812bv64);
   free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
   free ensures (Gamma_R31 == old(Gamma_R31));
   free ensures (R31 == old(R31));
-  free ensures (memory_load8_le(mem, 1904bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1905bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1906bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1907bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1904bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69016bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69024bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69616bv64) == 1812bv64);
diff --git a/src/test/correct/functions_with_params/gcc/functions_with_params_gtirb.expected b/src/test/correct/functions_with_params/gcc/functions_with_params_gtirb.expected
index aba4779b9..98806b657 100644
--- a/src/test/correct/functions_with_params/gcc/functions_with_params_gtirb.expected
+++ b/src/test/correct/functions_with_params/gcc/functions_with_params_gtirb.expected
@@ -38,10 +38,6 @@ function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv6
   (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
-}
-
 function {:extern} memory_store32_le(memory: [bv64]bv8, index: bv64, value: bv32) returns ([bv64]bv8) {
   memory[index := value[8:0]][bvadd64(index, 1bv64) := value[16:8]][bvadd64(index, 2bv64) := value[24:16]][bvadd64(index, 3bv64) := value[32:24]]
 }
@@ -53,12 +49,9 @@ function {:extern} memory_store64_le(memory: [bv64]bv8, index: bv64, value: bv64
 function {:extern} {:bvbuiltin "zero_extend 32"} zero_extend32_32(bv32) returns (bv64);
 procedure {:extern} rely();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
-  free ensures (memory_load8_le(mem, 1904bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1905bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1906bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1907bv64) == 0bv8);
+  ensures (mem == old(mem));
+  free ensures (memory_load32_le(mem, 1904bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69016bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69024bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69616bv64) == 1812bv64);
@@ -66,8 +59,8 @@ procedure {:extern} rely();
 
 procedure {:extern} rely_transitive();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
+  ensures (mem == old(mem));
 
 implementation {:extern} rely_transitive()
 {
@@ -82,20 +75,14 @@ procedure {:extern} guarantee_reflexive();
 
 procedure plus_one();
   modifies Gamma_R0, Gamma_R31, Gamma_stack, R0, R31, stack;
-  free requires (memory_load8_le(mem, 1904bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1905bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1906bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1907bv64) == 0bv8);
+  free requires (memory_load32_le(mem, 1904bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69016bv64) == 1808bv64);
   free requires (memory_load64_le(mem, 69024bv64) == 1728bv64);
   free requires (memory_load64_le(mem, 69616bv64) == 1812bv64);
   free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
   free ensures (Gamma_R31 == old(Gamma_R31));
   free ensures (R31 == old(R31));
-  free ensures (memory_load8_le(mem, 1904bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1905bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1906bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1907bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1904bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69016bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69024bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69616bv64) == 1812bv64);
@@ -121,10 +108,7 @@ procedure main();
   modifies Gamma_R0, Gamma_R29, Gamma_R30, Gamma_R31, Gamma_stack, R0, R29, R30, R31, stack;
   free requires (memory_load64_le(mem, 69632bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free requires (memory_load8_le(mem, 1904bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1905bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1906bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1907bv64) == 0bv8);
+  free requires (memory_load32_le(mem, 1904bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69016bv64) == 1808bv64);
   free requires (memory_load64_le(mem, 69024bv64) == 1728bv64);
   free requires (memory_load64_le(mem, 69616bv64) == 1812bv64);
@@ -133,10 +117,7 @@ procedure main();
   free ensures (Gamma_R31 == old(Gamma_R31));
   free ensures (R29 == old(R29));
   free ensures (R31 == old(R31));
-  free ensures (memory_load8_le(mem, 1904bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1905bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1906bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1907bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1904bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69016bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69024bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69616bv64) == 1812bv64);
diff --git a/src/test/correct/ifbranches/clang/ifbranches.expected b/src/test/correct/ifbranches/clang/ifbranches.expected
index 4c011a0ed..60d8d807e 100644
--- a/src/test/correct/ifbranches/clang/ifbranches.expected
+++ b/src/test/correct/ifbranches/clang/ifbranches.expected
@@ -45,10 +45,6 @@ function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv6
   (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
-}
-
 function {:extern} memory_store32_le(memory: [bv64]bv8, index: bv64, value: bv32) returns ([bv64]bv8) {
   memory[index := value[8:0]][bvadd64(index, 1bv64) := value[16:8]][bvadd64(index, 2bv64) := value[24:16]][bvadd64(index, 3bv64) := value[32:24]]
 }
@@ -62,12 +58,9 @@ function {:extern} {:bvbuiltin "zero_extend 1"} zero_extend1_32(bv32) returns (b
 function {:extern} {:bvbuiltin "zero_extend 32"} zero_extend32_32(bv32) returns (bv64);
 procedure {:extern} rely();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
-  free ensures (memory_load8_le(mem, 1920bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1921bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1922bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1923bv64) == 0bv8);
+  ensures (mem == old(mem));
+  free ensures (memory_load32_le(mem, 1920bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1812bv64);
@@ -75,8 +68,8 @@ procedure {:extern} rely();
 
 procedure {:extern} rely_transitive();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
+  ensures (mem == old(mem));
 
 implementation {:extern} rely_transitive()
 {
@@ -94,20 +87,14 @@ procedure main();
   requires (Gamma_R0 == true);
   free requires (memory_load64_le(mem, 69664bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
-  free requires (memory_load8_le(mem, 1920bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1921bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1922bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1923bv64) == 0bv8);
+  free requires (memory_load32_le(mem, 1920bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free requires (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free requires (memory_load64_le(mem, 69592bv64) == 1812bv64);
   free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
   free ensures (Gamma_R31 == old(Gamma_R31));
   free ensures (R31 == old(R31));
-  free ensures (memory_load8_le(mem, 1920bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1921bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1922bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1923bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1920bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1812bv64);
diff --git a/src/test/correct/ifbranches/clang/ifbranches_gtirb.expected b/src/test/correct/ifbranches/clang/ifbranches_gtirb.expected
index 63d86188d..19655971a 100644
--- a/src/test/correct/ifbranches/clang/ifbranches_gtirb.expected
+++ b/src/test/correct/ifbranches/clang/ifbranches_gtirb.expected
@@ -44,10 +44,6 @@ function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv6
   (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
-}
-
 function {:extern} memory_store32_le(memory: [bv64]bv8, index: bv64, value: bv32) returns ([bv64]bv8) {
   memory[index := value[8:0]][bvadd64(index, 1bv64) := value[16:8]][bvadd64(index, 2bv64) := value[24:16]][bvadd64(index, 3bv64) := value[32:24]]
 }
@@ -60,12 +56,9 @@ function {:extern} {:bvbuiltin "zero_extend 1"} zero_extend1_32(bv32) returns (b
 function {:extern} {:bvbuiltin "zero_extend 32"} zero_extend32_32(bv32) returns (bv64);
 procedure {:extern} rely();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
-  free ensures (memory_load8_le(mem, 1920bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1921bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1922bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1923bv64) == 0bv8);
+  ensures (mem == old(mem));
+  free ensures (memory_load32_le(mem, 1920bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1812bv64);
@@ -73,8 +66,8 @@ procedure {:extern} rely();
 
 procedure {:extern} rely_transitive();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
+  ensures (mem == old(mem));
 
 implementation {:extern} rely_transitive()
 {
@@ -92,20 +85,14 @@ procedure main();
   requires (Gamma_R0 == true);
   free requires (memory_load64_le(mem, 69664bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
-  free requires (memory_load8_le(mem, 1920bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1921bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1922bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1923bv64) == 0bv8);
+  free requires (memory_load32_le(mem, 1920bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free requires (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free requires (memory_load64_le(mem, 69592bv64) == 1812bv64);
   free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
   free ensures (Gamma_R31 == old(Gamma_R31));
   free ensures (R31 == old(R31));
-  free ensures (memory_load8_le(mem, 1920bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1921bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1922bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1923bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1920bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1812bv64);
diff --git a/src/test/correct/ifbranches/clang_O2/ifbranches.expected b/src/test/correct/ifbranches/clang_O2/ifbranches.expected
index edfefe37b..8f7c7b621 100644
--- a/src/test/correct/ifbranches/clang_O2/ifbranches.expected
+++ b/src/test/correct/ifbranches/clang_O2/ifbranches.expected
@@ -19,12 +19,12 @@ function {:extern} {:bvbuiltin "bvcomp"} bvcomp1(bv1, bv1) returns (bv1);
 function {:extern} {:bvbuiltin "bvcomp"} bvcomp32(bv32, bv32) returns (bv1);
 function {:extern} {:bvbuiltin "bvcomp"} bvcomp33(bv33, bv33) returns (bv1);
 function {:extern} {:bvbuiltin "bvnot"} bvnot1(bv1) returns (bv1);
-function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv64) {
-  (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
+function {:extern} memory_load32_le(memory: [bv64]bv8, index: bv64) returns (bv32) {
+  (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
+function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv64) {
+  (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
 function {:extern} {:bvbuiltin "sign_extend 1"} sign_extend1_32(bv32) returns (bv33);
@@ -32,12 +32,9 @@ function {:extern} {:bvbuiltin "zero_extend 1"} zero_extend1_32(bv32) returns (b
 function {:extern} {:bvbuiltin "zero_extend 32"} zero_extend32_32(bv32) returns (bv64);
 procedure {:extern} rely();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
-  free ensures (memory_load8_le(mem, 1848bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1849bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1850bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1851bv64) == 0bv8);
+  ensures (mem == old(mem));
+  free ensures (memory_load32_le(mem, 1848bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1812bv64);
@@ -45,8 +42,8 @@ procedure {:extern} rely();
 
 procedure {:extern} rely_transitive();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
+  ensures (mem == old(mem));
 
 implementation {:extern} rely_transitive()
 {
@@ -64,18 +61,12 @@ procedure main();
   requires (Gamma_R0 == true);
   free requires (memory_load64_le(mem, 69664bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
-  free requires (memory_load8_le(mem, 1848bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1849bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1850bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1851bv64) == 0bv8);
+  free requires (memory_load32_le(mem, 1848bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free requires (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free requires (memory_load64_le(mem, 69592bv64) == 1812bv64);
   free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
-  free ensures (memory_load8_le(mem, 1848bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1849bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1850bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1851bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1848bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1812bv64);
diff --git a/src/test/correct/ifbranches/clang_O2/ifbranches_gtirb.expected b/src/test/correct/ifbranches/clang_O2/ifbranches_gtirb.expected
index 3ce882dec..59e353194 100644
--- a/src/test/correct/ifbranches/clang_O2/ifbranches_gtirb.expected
+++ b/src/test/correct/ifbranches/clang_O2/ifbranches_gtirb.expected
@@ -18,24 +18,21 @@ function {:extern} {:bvbuiltin "bvadd"} bvadd64(bv64, bv64) returns (bv64);
 function {:extern} {:bvbuiltin "bvcomp"} bvcomp32(bv32, bv32) returns (bv1);
 function {:extern} {:bvbuiltin "bvcomp"} bvcomp33(bv33, bv33) returns (bv1);
 function {:extern} {:bvbuiltin "bvnot"} bvnot1(bv1) returns (bv1);
-function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv64) {
-  (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
+function {:extern} memory_load32_le(memory: [bv64]bv8, index: bv64) returns (bv32) {
+  (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
+function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv64) {
+  (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
 function {:extern} {:bvbuiltin "zero_extend 1"} zero_extend1_32(bv32) returns (bv33);
 function {:extern} {:bvbuiltin "zero_extend 32"} zero_extend32_32(bv32) returns (bv64);
 procedure {:extern} rely();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
-  free ensures (memory_load8_le(mem, 1848bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1849bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1850bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1851bv64) == 0bv8);
+  ensures (mem == old(mem));
+  free ensures (memory_load32_le(mem, 1848bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1812bv64);
@@ -43,8 +40,8 @@ procedure {:extern} rely();
 
 procedure {:extern} rely_transitive();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
+  ensures (mem == old(mem));
 
 implementation {:extern} rely_transitive()
 {
@@ -62,18 +59,12 @@ procedure main();
   requires (Gamma_R0 == true);
   free requires (memory_load64_le(mem, 69664bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
-  free requires (memory_load8_le(mem, 1848bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1849bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1850bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1851bv64) == 0bv8);
+  free requires (memory_load32_le(mem, 1848bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free requires (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free requires (memory_load64_le(mem, 69592bv64) == 1812bv64);
   free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
-  free ensures (memory_load8_le(mem, 1848bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1849bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1850bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1851bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1848bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1812bv64);
diff --git a/src/test/correct/ifbranches/gcc/ifbranches.expected b/src/test/correct/ifbranches/gcc/ifbranches.expected
index 248272d12..1488af65e 100644
--- a/src/test/correct/ifbranches/gcc/ifbranches.expected
+++ b/src/test/correct/ifbranches/gcc/ifbranches.expected
@@ -43,10 +43,6 @@ function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv6
   (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
-}
-
 function {:extern} memory_store32_le(memory: [bv64]bv8, index: bv64, value: bv32) returns ([bv64]bv8) {
   memory[index := value[8:0]][bvadd64(index, 1bv64) := value[16:8]][bvadd64(index, 2bv64) := value[24:16]][bvadd64(index, 3bv64) := value[32:24]]
 }
@@ -60,12 +56,9 @@ function {:extern} {:bvbuiltin "zero_extend 1"} zero_extend1_32(bv32) returns (b
 function {:extern} {:bvbuiltin "zero_extend 32"} zero_extend32_32(bv32) returns (bv64);
 procedure {:extern} rely();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
-  free ensures (memory_load8_le(mem, 1904bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1905bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1906bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1907bv64) == 0bv8);
+  ensures (mem == old(mem));
+  free ensures (memory_load32_le(mem, 1904bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69016bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69024bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69616bv64) == 1812bv64);
@@ -73,8 +66,8 @@ procedure {:extern} rely();
 
 procedure {:extern} rely_transitive();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
+  ensures (mem == old(mem));
 
 implementation {:extern} rely_transitive()
 {
@@ -92,20 +85,14 @@ procedure main();
   requires (Gamma_R0 == true);
   free requires (memory_load64_le(mem, 69632bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free requires (memory_load8_le(mem, 1904bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1905bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1906bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1907bv64) == 0bv8);
+  free requires (memory_load32_le(mem, 1904bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69016bv64) == 1808bv64);
   free requires (memory_load64_le(mem, 69024bv64) == 1728bv64);
   free requires (memory_load64_le(mem, 69616bv64) == 1812bv64);
   free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
   free ensures (Gamma_R31 == old(Gamma_R31));
   free ensures (R31 == old(R31));
-  free ensures (memory_load8_le(mem, 1904bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1905bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1906bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1907bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1904bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69016bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69024bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69616bv64) == 1812bv64);
diff --git a/src/test/correct/ifbranches/gcc/ifbranches_gtirb.expected b/src/test/correct/ifbranches/gcc/ifbranches_gtirb.expected
index 353031041..46089e34d 100644
--- a/src/test/correct/ifbranches/gcc/ifbranches_gtirb.expected
+++ b/src/test/correct/ifbranches/gcc/ifbranches_gtirb.expected
@@ -42,10 +42,6 @@ function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv6
   (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
-}
-
 function {:extern} memory_store32_le(memory: [bv64]bv8, index: bv64, value: bv32) returns ([bv64]bv8) {
   memory[index := value[8:0]][bvadd64(index, 1bv64) := value[16:8]][bvadd64(index, 2bv64) := value[24:16]][bvadd64(index, 3bv64) := value[32:24]]
 }
@@ -58,12 +54,9 @@ function {:extern} {:bvbuiltin "zero_extend 1"} zero_extend1_32(bv32) returns (b
 function {:extern} {:bvbuiltin "zero_extend 32"} zero_extend32_32(bv32) returns (bv64);
 procedure {:extern} rely();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
-  free ensures (memory_load8_le(mem, 1904bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1905bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1906bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1907bv64) == 0bv8);
+  ensures (mem == old(mem));
+  free ensures (memory_load32_le(mem, 1904bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69016bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69024bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69616bv64) == 1812bv64);
@@ -71,8 +64,8 @@ procedure {:extern} rely();
 
 procedure {:extern} rely_transitive();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
+  ensures (mem == old(mem));
 
 implementation {:extern} rely_transitive()
 {
@@ -90,20 +83,14 @@ procedure main();
   requires (Gamma_R0 == true);
   free requires (memory_load64_le(mem, 69632bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free requires (memory_load8_le(mem, 1904bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1905bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1906bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1907bv64) == 0bv8);
+  free requires (memory_load32_le(mem, 1904bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69016bv64) == 1808bv64);
   free requires (memory_load64_le(mem, 69024bv64) == 1728bv64);
   free requires (memory_load64_le(mem, 69616bv64) == 1812bv64);
   free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
   free ensures (Gamma_R31 == old(Gamma_R31));
   free ensures (R31 == old(R31));
-  free ensures (memory_load8_le(mem, 1904bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1905bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1906bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1907bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1904bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69016bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69024bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69616bv64) == 1812bv64);
diff --git a/src/test/correct/ifbranches/gcc_O2/ifbranches.expected b/src/test/correct/ifbranches/gcc_O2/ifbranches.expected
index 6745e11ac..1fd37da61 100644
--- a/src/test/correct/ifbranches/gcc_O2/ifbranches.expected
+++ b/src/test/correct/ifbranches/gcc_O2/ifbranches.expected
@@ -17,12 +17,12 @@ function {:extern} {:bvbuiltin "bvcomp"} bvcomp1(bv1, bv1) returns (bv1);
 function {:extern} {:bvbuiltin "bvcomp"} bvcomp32(bv32, bv32) returns (bv1);
 function {:extern} {:bvbuiltin "bvcomp"} bvcomp33(bv33, bv33) returns (bv1);
 function {:extern} {:bvbuiltin "bvnot"} bvnot1(bv1) returns (bv1);
-function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv64) {
-  (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
+function {:extern} memory_load32_le(memory: [bv64]bv8, index: bv64) returns (bv32) {
+  (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
+function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv64) {
+  (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
 function {:extern} {:bvbuiltin "sign_extend 1"} sign_extend1_32(bv32) returns (bv33);
@@ -30,12 +30,9 @@ function {:extern} {:bvbuiltin "zero_extend 1"} zero_extend1_32(bv32) returns (b
 function {:extern} {:bvbuiltin "zero_extend 32"} zero_extend32_32(bv32) returns (bv64);
 procedure {:extern} rely();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
-  free ensures (memory_load8_le(mem, 1896bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1897bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1898bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1899bv64) == 0bv8);
+  ensures (mem == old(mem));
+  free ensures (memory_load32_le(mem, 1896bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69016bv64) == 1872bv64);
   free ensures (memory_load64_le(mem, 69024bv64) == 1792bv64);
   free ensures (memory_load64_le(mem, 69616bv64) == 1536bv64);
@@ -43,8 +40,8 @@ procedure {:extern} rely();
 
 procedure {:extern} rely_transitive();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
+  ensures (mem == old(mem));
 
 implementation {:extern} rely_transitive()
 {
@@ -62,18 +59,12 @@ procedure main();
   requires (Gamma_R0 == true);
   free requires (memory_load64_le(mem, 69632bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free requires (memory_load8_le(mem, 1896bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1897bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1898bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1899bv64) == 0bv8);
+  free requires (memory_load32_le(mem, 1896bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69016bv64) == 1872bv64);
   free requires (memory_load64_le(mem, 69024bv64) == 1792bv64);
   free requires (memory_load64_le(mem, 69616bv64) == 1536bv64);
   free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free ensures (memory_load8_le(mem, 1896bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1897bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1898bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1899bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1896bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69016bv64) == 1872bv64);
   free ensures (memory_load64_le(mem, 69024bv64) == 1792bv64);
   free ensures (memory_load64_le(mem, 69616bv64) == 1536bv64);
diff --git a/src/test/correct/ifbranches/gcc_O2/ifbranches_gtirb.expected b/src/test/correct/ifbranches/gcc_O2/ifbranches_gtirb.expected
index a2b4c6448..54cf79dd7 100644
--- a/src/test/correct/ifbranches/gcc_O2/ifbranches_gtirb.expected
+++ b/src/test/correct/ifbranches/gcc_O2/ifbranches_gtirb.expected
@@ -16,24 +16,21 @@ function {:extern} {:bvbuiltin "bvadd"} bvadd64(bv64, bv64) returns (bv64);
 function {:extern} {:bvbuiltin "bvcomp"} bvcomp32(bv32, bv32) returns (bv1);
 function {:extern} {:bvbuiltin "bvcomp"} bvcomp33(bv33, bv33) returns (bv1);
 function {:extern} {:bvbuiltin "bvnot"} bvnot1(bv1) returns (bv1);
-function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv64) {
-  (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
+function {:extern} memory_load32_le(memory: [bv64]bv8, index: bv64) returns (bv32) {
+  (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
+function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv64) {
+  (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
 function {:extern} {:bvbuiltin "zero_extend 1"} zero_extend1_32(bv32) returns (bv33);
 function {:extern} {:bvbuiltin "zero_extend 32"} zero_extend32_32(bv32) returns (bv64);
 procedure {:extern} rely();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
-  free ensures (memory_load8_le(mem, 1896bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1897bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1898bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1899bv64) == 0bv8);
+  ensures (mem == old(mem));
+  free ensures (memory_load32_le(mem, 1896bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69016bv64) == 1872bv64);
   free ensures (memory_load64_le(mem, 69024bv64) == 1792bv64);
   free ensures (memory_load64_le(mem, 69616bv64) == 1536bv64);
@@ -41,8 +38,8 @@ procedure {:extern} rely();
 
 procedure {:extern} rely_transitive();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
+  ensures (mem == old(mem));
 
 implementation {:extern} rely_transitive()
 {
@@ -60,18 +57,12 @@ procedure main();
   requires (Gamma_R0 == true);
   free requires (memory_load64_le(mem, 69632bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free requires (memory_load8_le(mem, 1896bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1897bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1898bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1899bv64) == 0bv8);
+  free requires (memory_load32_le(mem, 1896bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69016bv64) == 1872bv64);
   free requires (memory_load64_le(mem, 69024bv64) == 1792bv64);
   free requires (memory_load64_le(mem, 69616bv64) == 1536bv64);
   free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free ensures (memory_load8_le(mem, 1896bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1897bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1898bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1899bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1896bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69016bv64) == 1872bv64);
   free ensures (memory_load64_le(mem, 69024bv64) == 1792bv64);
   free ensures (memory_load64_le(mem, 69616bv64) == 1536bv64);
diff --git a/src/test/correct/ifglobal/clang/ifglobal.expected b/src/test/correct/ifglobal/clang/ifglobal.expected
index 04908c696..a049e2d90 100644
--- a/src/test/correct/ifglobal/clang/ifglobal.expected
+++ b/src/test/correct/ifglobal/clang/ifglobal.expected
@@ -20,7 +20,7 @@ var {:extern} mem: [bv64]bv8;
 var {:extern} stack: [bv64]bv8;
 const {:extern} $x_addr: bv64;
 axiom ($x_addr == 69684bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
   (if (index == $x_addr) then true else false)
 }
 
@@ -47,10 +47,6 @@ function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv6
   (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
-}
-
 function {:extern} memory_store32_le(memory: [bv64]bv8, index: bv64, value: bv32) returns ([bv64]bv8) {
   memory[index := value[8:0]][bvadd64(index, 1bv64) := value[16:8]][bvadd64(index, 2bv64) := value[24:16]][bvadd64(index, 3bv64) := value[32:24]]
 }
@@ -60,12 +56,9 @@ function {:extern} {:bvbuiltin "zero_extend 1"} zero_extend1_32(bv32) returns (b
 function {:extern} {:bvbuiltin "zero_extend 32"} zero_extend32_32(bv32) returns (bv64);
 procedure {:extern} rely();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
-  free ensures (memory_load8_le(mem, 1892bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1893bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1894bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1895bv64) == 0bv8);
+  ensures (mem == old(mem));
+  free ensures (memory_load32_le(mem, 1892bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1812bv64);
@@ -73,8 +66,8 @@ procedure {:extern} rely();
 
 procedure {:extern} rely_transitive();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
+  ensures (mem == old(mem));
 
 implementation {:extern} rely_transitive()
 {
@@ -91,20 +84,14 @@ procedure main();
   modifies CF, Gamma_CF, Gamma_NF, Gamma_R0, Gamma_R31, Gamma_R8, Gamma_R9, Gamma_VF, Gamma_ZF, Gamma_mem, Gamma_stack, NF, R0, R31, R8, R9, VF, ZF, mem, stack;
   free requires (memory_load64_le(mem, 69664bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
-  free requires (memory_load8_le(mem, 1892bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1893bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1894bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1895bv64) == 0bv8);
+  free requires (memory_load32_le(mem, 1892bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free requires (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free requires (memory_load64_le(mem, 69592bv64) == 1812bv64);
   free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
   free ensures (Gamma_R31 == old(Gamma_R31));
   free ensures (R31 == old(R31));
-  free ensures (memory_load8_le(mem, 1892bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1893bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1894bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1895bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1892bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1812bv64);
diff --git a/src/test/correct/ifglobal/clang/ifglobal_gtirb.expected b/src/test/correct/ifglobal/clang/ifglobal_gtirb.expected
index dcf8b5a82..2e6edff1d 100644
--- a/src/test/correct/ifglobal/clang/ifglobal_gtirb.expected
+++ b/src/test/correct/ifglobal/clang/ifglobal_gtirb.expected
@@ -20,7 +20,7 @@ var {:extern} mem: [bv64]bv8;
 var {:extern} stack: [bv64]bv8;
 const {:extern} $x_addr: bv64;
 axiom ($x_addr == 69684bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
   (if (index == $x_addr) then true else false)
 }
 
@@ -46,10 +46,6 @@ function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv6
   (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
-}
-
 function {:extern} memory_store32_le(memory: [bv64]bv8, index: bv64, value: bv32) returns ([bv64]bv8) {
   memory[index := value[8:0]][bvadd64(index, 1bv64) := value[16:8]][bvadd64(index, 2bv64) := value[24:16]][bvadd64(index, 3bv64) := value[32:24]]
 }
@@ -58,12 +54,9 @@ function {:extern} {:bvbuiltin "zero_extend 1"} zero_extend1_32(bv32) returns (b
 function {:extern} {:bvbuiltin "zero_extend 32"} zero_extend32_32(bv32) returns (bv64);
 procedure {:extern} rely();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
-  free ensures (memory_load8_le(mem, 1892bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1893bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1894bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1895bv64) == 0bv8);
+  ensures (mem == old(mem));
+  free ensures (memory_load32_le(mem, 1892bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1812bv64);
@@ -71,8 +64,8 @@ procedure {:extern} rely();
 
 procedure {:extern} rely_transitive();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
+  ensures (mem == old(mem));
 
 implementation {:extern} rely_transitive()
 {
@@ -89,20 +82,14 @@ procedure main();
   modifies CF, Gamma_CF, Gamma_NF, Gamma_R0, Gamma_R31, Gamma_R8, Gamma_R9, Gamma_VF, Gamma_ZF, Gamma_mem, Gamma_stack, NF, R0, R31, R8, R9, VF, ZF, mem, stack;
   free requires (memory_load64_le(mem, 69664bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
-  free requires (memory_load8_le(mem, 1892bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1893bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1894bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1895bv64) == 0bv8);
+  free requires (memory_load32_le(mem, 1892bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free requires (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free requires (memory_load64_le(mem, 69592bv64) == 1812bv64);
   free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
   free ensures (Gamma_R31 == old(Gamma_R31));
   free ensures (R31 == old(R31));
-  free ensures (memory_load8_le(mem, 1892bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1893bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1894bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1895bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1892bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1812bv64);
diff --git a/src/test/correct/ifglobal/clang_O2/ifglobal.expected b/src/test/correct/ifglobal/clang_O2/ifglobal.expected
index 3841ba288..9c75c68c6 100644
--- a/src/test/correct/ifglobal/clang_O2/ifglobal.expected
+++ b/src/test/correct/ifglobal/clang_O2/ifglobal.expected
@@ -8,7 +8,7 @@ var {:extern} R9: bv64;
 var {:extern} mem: [bv64]bv8;
 const {:extern} $x_addr: bv64;
 axiom ($x_addr == 69684bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
   (if (index == $x_addr) then true else false)
 }
 
@@ -30,10 +30,6 @@ function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv6
   (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
-}
-
 function {:extern} memory_store32_le(memory: [bv64]bv8, index: bv64, value: bv32) returns ([bv64]bv8) {
   memory[index := value[8:0]][bvadd64(index, 1bv64) := value[16:8]][bvadd64(index, 2bv64) := value[24:16]][bvadd64(index, 3bv64) := value[32:24]]
 }
@@ -41,12 +37,9 @@ function {:extern} memory_store32_le(memory: [bv64]bv8, index: bv64, value: bv32
 function {:extern} {:bvbuiltin "zero_extend 32"} zero_extend32_32(bv32) returns (bv64);
 procedure {:extern} rely();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
-  free ensures (memory_load8_le(mem, 1868bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1869bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1870bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1871bv64) == 0bv8);
+  ensures (mem == old(mem));
+  free ensures (memory_load32_le(mem, 1868bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1812bv64);
@@ -54,8 +47,8 @@ procedure {:extern} rely();
 
 procedure {:extern} rely_transitive();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
+  ensures (mem == old(mem));
 
 implementation {:extern} rely_transitive()
 {
@@ -72,18 +65,12 @@ procedure main();
   modifies Gamma_R0, Gamma_R8, Gamma_R9, Gamma_mem, R0, R8, R9, mem;
   free requires (memory_load64_le(mem, 69664bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
-  free requires (memory_load8_le(mem, 1868bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1869bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1870bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1871bv64) == 0bv8);
+  free requires (memory_load32_le(mem, 1868bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free requires (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free requires (memory_load64_le(mem, 69592bv64) == 1812bv64);
   free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
-  free ensures (memory_load8_le(mem, 1868bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1869bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1870bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1871bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1868bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1812bv64);
diff --git a/src/test/correct/ifglobal/clang_O2/ifglobal_gtirb.expected b/src/test/correct/ifglobal/clang_O2/ifglobal_gtirb.expected
index ff90bf950..4d0aa9470 100644
--- a/src/test/correct/ifglobal/clang_O2/ifglobal_gtirb.expected
+++ b/src/test/correct/ifglobal/clang_O2/ifglobal_gtirb.expected
@@ -8,7 +8,7 @@ var {:extern} R9: bv64;
 var {:extern} mem: [bv64]bv8;
 const {:extern} $x_addr: bv64;
 axiom ($x_addr == 69684bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
   (if (index == $x_addr) then true else false)
 }
 
@@ -29,10 +29,6 @@ function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv6
   (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
-}
-
 function {:extern} memory_store32_le(memory: [bv64]bv8, index: bv64, value: bv32) returns ([bv64]bv8) {
   memory[index := value[8:0]][bvadd64(index, 1bv64) := value[16:8]][bvadd64(index, 2bv64) := value[24:16]][bvadd64(index, 3bv64) := value[32:24]]
 }
@@ -40,12 +36,9 @@ function {:extern} memory_store32_le(memory: [bv64]bv8, index: bv64, value: bv32
 function {:extern} {:bvbuiltin "zero_extend 32"} zero_extend32_32(bv32) returns (bv64);
 procedure {:extern} rely();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
-  free ensures (memory_load8_le(mem, 1868bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1869bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1870bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1871bv64) == 0bv8);
+  ensures (mem == old(mem));
+  free ensures (memory_load32_le(mem, 1868bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1812bv64);
@@ -53,8 +46,8 @@ procedure {:extern} rely();
 
 procedure {:extern} rely_transitive();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
+  ensures (mem == old(mem));
 
 implementation {:extern} rely_transitive()
 {
@@ -71,18 +64,12 @@ procedure main();
   modifies Gamma_R0, Gamma_R8, Gamma_R9, Gamma_mem, R0, R8, R9, mem;
   free requires (memory_load64_le(mem, 69664bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
-  free requires (memory_load8_le(mem, 1868bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1869bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1870bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1871bv64) == 0bv8);
+  free requires (memory_load32_le(mem, 1868bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free requires (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free requires (memory_load64_le(mem, 69592bv64) == 1812bv64);
   free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
-  free ensures (memory_load8_le(mem, 1868bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1869bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1870bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1871bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1868bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1812bv64);
diff --git a/src/test/correct/ifglobal/clang_pic/ifglobal.expected b/src/test/correct/ifglobal/clang_pic/ifglobal.expected
index 6be997683..2c79a79e3 100644
--- a/src/test/correct/ifglobal/clang_pic/ifglobal.expected
+++ b/src/test/correct/ifglobal/clang_pic/ifglobal.expected
@@ -20,7 +20,7 @@ var {:extern} mem: [bv64]bv8;
 var {:extern} stack: [bv64]bv8;
 const {:extern} $x_addr: bv64;
 axiom ($x_addr == 69684bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
   (if (index == $x_addr) then true else false)
 }
 
@@ -51,10 +51,6 @@ function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv6
   (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
-}
-
 function {:extern} memory_store32_le(memory: [bv64]bv8, index: bv64, value: bv32) returns ([bv64]bv8) {
   memory[index := value[8:0]][bvadd64(index, 1bv64) := value[16:8]][bvadd64(index, 2bv64) := value[24:16]][bvadd64(index, 3bv64) := value[32:24]]
 }
@@ -64,22 +60,19 @@ function {:extern} {:bvbuiltin "zero_extend 1"} zero_extend1_32(bv32) returns (b
 function {:extern} {:bvbuiltin "zero_extend 32"} zero_extend32_32(bv32) returns (bv64);
 procedure {:extern} rely();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
-  free ensures (memory_load8_le(mem, 1964bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1965bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1966bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1967bv64) == 0bv8);
-  free ensures (memory_load64_le(mem, 69576bv64) == 69684bv64);
-  free ensures (memory_load64_le(mem, 69672bv64) == 69672bv64);
+  ensures (mem == old(mem));
+  free ensures (memory_load32_le(mem, 1964bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69056bv64) == 1872bv64);
   free ensures (memory_load64_le(mem, 69064bv64) == 1792bv64);
+  free ensures (memory_load64_le(mem, 69576bv64) == 69684bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1876bv64);
+  free ensures (memory_load64_le(mem, 69672bv64) == 69672bv64);
 
 procedure {:extern} rely_transitive();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
+  ensures (mem == old(mem));
 
 implementation {:extern} rely_transitive()
 {
@@ -96,26 +89,20 @@ procedure main();
   modifies CF, Gamma_CF, Gamma_NF, Gamma_R0, Gamma_R31, Gamma_R8, Gamma_R9, Gamma_VF, Gamma_ZF, Gamma_mem, Gamma_stack, NF, R0, R31, R8, R9, VF, ZF, mem, stack;
   free requires (memory_load64_le(mem, 69664bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
-  free requires (memory_load8_le(mem, 1964bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1965bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1966bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1967bv64) == 0bv8);
-  free requires (memory_load64_le(mem, 69576bv64) == 69684bv64);
-  free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
+  free requires (memory_load32_le(mem, 1964bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69056bv64) == 1872bv64);
   free requires (memory_load64_le(mem, 69064bv64) == 1792bv64);
+  free requires (memory_load64_le(mem, 69576bv64) == 69684bv64);
   free requires (memory_load64_le(mem, 69592bv64) == 1876bv64);
+  free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
   free ensures (Gamma_R31 == old(Gamma_R31));
   free ensures (R31 == old(R31));
-  free ensures (memory_load8_le(mem, 1964bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1965bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1966bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1967bv64) == 0bv8);
-  free ensures (memory_load64_le(mem, 69576bv64) == 69684bv64);
-  free ensures (memory_load64_le(mem, 69672bv64) == 69672bv64);
+  free ensures (memory_load32_le(mem, 1964bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69056bv64) == 1872bv64);
   free ensures (memory_load64_le(mem, 69064bv64) == 1792bv64);
+  free ensures (memory_load64_le(mem, 69576bv64) == 69684bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1876bv64);
+  free ensures (memory_load64_le(mem, 69672bv64) == 69672bv64);
 
 implementation main()
 {
diff --git a/src/test/correct/ifglobal/clang_pic/ifglobal_gtirb.expected b/src/test/correct/ifglobal/clang_pic/ifglobal_gtirb.expected
index fe3a8d399..3491452f3 100644
--- a/src/test/correct/ifglobal/clang_pic/ifglobal_gtirb.expected
+++ b/src/test/correct/ifglobal/clang_pic/ifglobal_gtirb.expected
@@ -20,7 +20,7 @@ var {:extern} mem: [bv64]bv8;
 var {:extern} stack: [bv64]bv8;
 const {:extern} $x_addr: bv64;
 axiom ($x_addr == 69684bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
   (if (index == $x_addr) then true else false)
 }
 
@@ -50,10 +50,6 @@ function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv6
   (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
-}
-
 function {:extern} memory_store32_le(memory: [bv64]bv8, index: bv64, value: bv32) returns ([bv64]bv8) {
   memory[index := value[8:0]][bvadd64(index, 1bv64) := value[16:8]][bvadd64(index, 2bv64) := value[24:16]][bvadd64(index, 3bv64) := value[32:24]]
 }
@@ -62,22 +58,19 @@ function {:extern} {:bvbuiltin "zero_extend 1"} zero_extend1_32(bv32) returns (b
 function {:extern} {:bvbuiltin "zero_extend 32"} zero_extend32_32(bv32) returns (bv64);
 procedure {:extern} rely();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
-  free ensures (memory_load8_le(mem, 1964bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1965bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1966bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1967bv64) == 0bv8);
-  free ensures (memory_load64_le(mem, 69576bv64) == 69684bv64);
-  free ensures (memory_load64_le(mem, 69672bv64) == 69672bv64);
+  ensures (mem == old(mem));
+  free ensures (memory_load32_le(mem, 1964bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69056bv64) == 1872bv64);
   free ensures (memory_load64_le(mem, 69064bv64) == 1792bv64);
+  free ensures (memory_load64_le(mem, 69576bv64) == 69684bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1876bv64);
+  free ensures (memory_load64_le(mem, 69672bv64) == 69672bv64);
 
 procedure {:extern} rely_transitive();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
+  ensures (mem == old(mem));
 
 implementation {:extern} rely_transitive()
 {
@@ -94,26 +87,20 @@ procedure main();
   modifies CF, Gamma_CF, Gamma_NF, Gamma_R0, Gamma_R31, Gamma_R8, Gamma_R9, Gamma_VF, Gamma_ZF, Gamma_mem, Gamma_stack, NF, R0, R31, R8, R9, VF, ZF, mem, stack;
   free requires (memory_load64_le(mem, 69664bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
-  free requires (memory_load8_le(mem, 1964bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1965bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1966bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1967bv64) == 0bv8);
-  free requires (memory_load64_le(mem, 69576bv64) == 69684bv64);
-  free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
+  free requires (memory_load32_le(mem, 1964bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69056bv64) == 1872bv64);
   free requires (memory_load64_le(mem, 69064bv64) == 1792bv64);
+  free requires (memory_load64_le(mem, 69576bv64) == 69684bv64);
   free requires (memory_load64_le(mem, 69592bv64) == 1876bv64);
+  free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
   free ensures (Gamma_R31 == old(Gamma_R31));
   free ensures (R31 == old(R31));
-  free ensures (memory_load8_le(mem, 1964bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1965bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1966bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1967bv64) == 0bv8);
-  free ensures (memory_load64_le(mem, 69576bv64) == 69684bv64);
-  free ensures (memory_load64_le(mem, 69672bv64) == 69672bv64);
+  free ensures (memory_load32_le(mem, 1964bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69056bv64) == 1872bv64);
   free ensures (memory_load64_le(mem, 69064bv64) == 1792bv64);
+  free ensures (memory_load64_le(mem, 69576bv64) == 69684bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1876bv64);
+  free ensures (memory_load64_le(mem, 69672bv64) == 69672bv64);
 
 implementation main()
 {
diff --git a/src/test/correct/ifglobal/gcc/ifglobal.expected b/src/test/correct/ifglobal/gcc/ifglobal.expected
index 858159134..ef4f35400 100644
--- a/src/test/correct/ifglobal/gcc/ifglobal.expected
+++ b/src/test/correct/ifglobal/gcc/ifglobal.expected
@@ -14,7 +14,7 @@ var {:extern} ZF: bv1;
 var {:extern} mem: [bv64]bv8;
 const {:extern} $x_addr: bv64;
 axiom ($x_addr == 69652bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
   (if (index == $x_addr) then true else false)
 }
 
@@ -41,10 +41,6 @@ function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv6
   (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
-}
-
 function {:extern} memory_store32_le(memory: [bv64]bv8, index: bv64, value: bv32) returns ([bv64]bv8) {
   memory[index := value[8:0]][bvadd64(index, 1bv64) := value[16:8]][bvadd64(index, 2bv64) := value[24:16]][bvadd64(index, 3bv64) := value[32:24]]
 }
@@ -54,12 +50,9 @@ function {:extern} {:bvbuiltin "zero_extend 1"} zero_extend1_32(bv32) returns (b
 function {:extern} {:bvbuiltin "zero_extend 32"} zero_extend32_32(bv32) returns (bv64);
 procedure {:extern} rely();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
-  free ensures (memory_load8_le(mem, 1876bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1877bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1878bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1879bv64) == 0bv8);
+  ensures (mem == old(mem));
+  free ensures (memory_load32_le(mem, 1876bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69016bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69024bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69616bv64) == 1812bv64);
@@ -67,8 +60,8 @@ procedure {:extern} rely();
 
 procedure {:extern} rely_transitive();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
+  ensures (mem == old(mem));
 
 implementation {:extern} rely_transitive()
 {
@@ -85,18 +78,12 @@ procedure main();
   modifies CF, Gamma_CF, Gamma_NF, Gamma_R0, Gamma_R1, Gamma_VF, Gamma_ZF, Gamma_mem, NF, R0, R1, VF, ZF, mem;
   free requires (memory_load64_le(mem, 69632bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free requires (memory_load8_le(mem, 1876bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1877bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1878bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1879bv64) == 0bv8);
+  free requires (memory_load32_le(mem, 1876bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69016bv64) == 1808bv64);
   free requires (memory_load64_le(mem, 69024bv64) == 1728bv64);
   free requires (memory_load64_le(mem, 69616bv64) == 1812bv64);
   free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free ensures (memory_load8_le(mem, 1876bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1877bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1878bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1879bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1876bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69016bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69024bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69616bv64) == 1812bv64);
diff --git a/src/test/correct/ifglobal/gcc/ifglobal_gtirb.expected b/src/test/correct/ifglobal/gcc/ifglobal_gtirb.expected
index 87745aec2..0b7d7767d 100644
--- a/src/test/correct/ifglobal/gcc/ifglobal_gtirb.expected
+++ b/src/test/correct/ifglobal/gcc/ifglobal_gtirb.expected
@@ -14,7 +14,7 @@ var {:extern} ZF: bv1;
 var {:extern} mem: [bv64]bv8;
 const {:extern} $x_addr: bv64;
 axiom ($x_addr == 69652bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
   (if (index == $x_addr) then true else false)
 }
 
@@ -40,10 +40,6 @@ function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv6
   (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
-}
-
 function {:extern} memory_store32_le(memory: [bv64]bv8, index: bv64, value: bv32) returns ([bv64]bv8) {
   memory[index := value[8:0]][bvadd64(index, 1bv64) := value[16:8]][bvadd64(index, 2bv64) := value[24:16]][bvadd64(index, 3bv64) := value[32:24]]
 }
@@ -52,12 +48,9 @@ function {:extern} {:bvbuiltin "zero_extend 1"} zero_extend1_32(bv32) returns (b
 function {:extern} {:bvbuiltin "zero_extend 32"} zero_extend32_32(bv32) returns (bv64);
 procedure {:extern} rely();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
-  free ensures (memory_load8_le(mem, 1876bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1877bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1878bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1879bv64) == 0bv8);
+  ensures (mem == old(mem));
+  free ensures (memory_load32_le(mem, 1876bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69016bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69024bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69616bv64) == 1812bv64);
@@ -65,8 +58,8 @@ procedure {:extern} rely();
 
 procedure {:extern} rely_transitive();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
+  ensures (mem == old(mem));
 
 implementation {:extern} rely_transitive()
 {
@@ -83,18 +76,12 @@ procedure main();
   modifies CF, Gamma_CF, Gamma_NF, Gamma_R0, Gamma_R1, Gamma_VF, Gamma_ZF, Gamma_mem, NF, R0, R1, VF, ZF, mem;
   free requires (memory_load64_le(mem, 69632bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free requires (memory_load8_le(mem, 1876bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1877bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1878bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1879bv64) == 0bv8);
+  free requires (memory_load32_le(mem, 1876bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69016bv64) == 1808bv64);
   free requires (memory_load64_le(mem, 69024bv64) == 1728bv64);
   free requires (memory_load64_le(mem, 69616bv64) == 1812bv64);
   free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free ensures (memory_load8_le(mem, 1876bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1877bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1878bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1879bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1876bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69016bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69024bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69616bv64) == 1812bv64);
diff --git a/src/test/correct/ifglobal/gcc_O2/ifglobal.expected b/src/test/correct/ifglobal/gcc_O2/ifglobal.expected
index 93f8cf349..1e0ea5e01 100644
--- a/src/test/correct/ifglobal/gcc_O2/ifglobal.expected
+++ b/src/test/correct/ifglobal/gcc_O2/ifglobal.expected
@@ -6,7 +6,7 @@ var {:extern} R1: bv64;
 var {:extern} mem: [bv64]bv8;
 const {:extern} $x_addr: bv64;
 axiom ($x_addr == 69652bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
   (if (index == $x_addr) then true else false)
 }
 
@@ -29,10 +29,6 @@ function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv6
   (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
-}
-
 function {:extern} memory_store32_le(memory: [bv64]bv8, index: bv64, value: bv32) returns ([bv64]bv8) {
   memory[index := value[8:0]][bvadd64(index, 1bv64) := value[16:8]][bvadd64(index, 2bv64) := value[24:16]][bvadd64(index, 3bv64) := value[32:24]]
 }
@@ -40,12 +36,9 @@ function {:extern} memory_store32_le(memory: [bv64]bv8, index: bv64, value: bv32
 function {:extern} {:bvbuiltin "zero_extend 32"} zero_extend32_32(bv32) returns (bv64);
 procedure {:extern} rely();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
-  free ensures (memory_load8_le(mem, 1896bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1897bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1898bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1899bv64) == 0bv8);
+  ensures (mem == old(mem));
+  free ensures (memory_load32_le(mem, 1896bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69016bv64) == 1872bv64);
   free ensures (memory_load64_le(mem, 69024bv64) == 1792bv64);
   free ensures (memory_load64_le(mem, 69616bv64) == 1536bv64);
@@ -53,8 +46,8 @@ procedure {:extern} rely();
 
 procedure {:extern} rely_transitive();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
+  ensures (mem == old(mem));
 
 implementation {:extern} rely_transitive()
 {
@@ -71,18 +64,12 @@ procedure main();
   modifies Gamma_R0, Gamma_R1, Gamma_mem, R0, R1, mem;
   free requires (memory_load64_le(mem, 69632bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free requires (memory_load8_le(mem, 1896bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1897bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1898bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1899bv64) == 0bv8);
+  free requires (memory_load32_le(mem, 1896bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69016bv64) == 1872bv64);
   free requires (memory_load64_le(mem, 69024bv64) == 1792bv64);
   free requires (memory_load64_le(mem, 69616bv64) == 1536bv64);
   free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free ensures (memory_load8_le(mem, 1896bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1897bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1898bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1899bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1896bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69016bv64) == 1872bv64);
   free ensures (memory_load64_le(mem, 69024bv64) == 1792bv64);
   free ensures (memory_load64_le(mem, 69616bv64) == 1536bv64);
diff --git a/src/test/correct/ifglobal/gcc_O2/ifglobal_gtirb.expected b/src/test/correct/ifglobal/gcc_O2/ifglobal_gtirb.expected
index f7ef66d68..0b576dc6c 100644
--- a/src/test/correct/ifglobal/gcc_O2/ifglobal_gtirb.expected
+++ b/src/test/correct/ifglobal/gcc_O2/ifglobal_gtirb.expected
@@ -6,7 +6,7 @@ var {:extern} R1: bv64;
 var {:extern} mem: [bv64]bv8;
 const {:extern} $x_addr: bv64;
 axiom ($x_addr == 69652bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
   (if (index == $x_addr) then true else false)
 }
 
@@ -27,10 +27,6 @@ function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv6
   (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
-}
-
 function {:extern} memory_store32_le(memory: [bv64]bv8, index: bv64, value: bv32) returns ([bv64]bv8) {
   memory[index := value[8:0]][bvadd64(index, 1bv64) := value[16:8]][bvadd64(index, 2bv64) := value[24:16]][bvadd64(index, 3bv64) := value[32:24]]
 }
@@ -38,12 +34,9 @@ function {:extern} memory_store32_le(memory: [bv64]bv8, index: bv64, value: bv32
 function {:extern} {:bvbuiltin "zero_extend 32"} zero_extend32_32(bv32) returns (bv64);
 procedure {:extern} rely();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
-  free ensures (memory_load8_le(mem, 1896bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1897bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1898bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1899bv64) == 0bv8);
+  ensures (mem == old(mem));
+  free ensures (memory_load32_le(mem, 1896bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69016bv64) == 1872bv64);
   free ensures (memory_load64_le(mem, 69024bv64) == 1792bv64);
   free ensures (memory_load64_le(mem, 69616bv64) == 1536bv64);
@@ -51,8 +44,8 @@ procedure {:extern} rely();
 
 procedure {:extern} rely_transitive();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
+  ensures (mem == old(mem));
 
 implementation {:extern} rely_transitive()
 {
@@ -69,18 +62,12 @@ procedure main();
   modifies Gamma_R0, Gamma_R1, Gamma_mem, R0, R1, mem;
   free requires (memory_load64_le(mem, 69632bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free requires (memory_load8_le(mem, 1896bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1897bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1898bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1899bv64) == 0bv8);
+  free requires (memory_load32_le(mem, 1896bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69016bv64) == 1872bv64);
   free requires (memory_load64_le(mem, 69024bv64) == 1792bv64);
   free requires (memory_load64_le(mem, 69616bv64) == 1536bv64);
   free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free ensures (memory_load8_le(mem, 1896bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1897bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1898bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1899bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1896bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69016bv64) == 1872bv64);
   free ensures (memory_load64_le(mem, 69024bv64) == 1792bv64);
   free ensures (memory_load64_le(mem, 69616bv64) == 1536bv64);
diff --git a/src/test/correct/ifglobal/gcc_pic/ifglobal.expected b/src/test/correct/ifglobal/gcc_pic/ifglobal.expected
index 03fc8c3d9..99d76739e 100644
--- a/src/test/correct/ifglobal/gcc_pic/ifglobal.expected
+++ b/src/test/correct/ifglobal/gcc_pic/ifglobal.expected
@@ -14,7 +14,7 @@ var {:extern} ZF: bv1;
 var {:extern} mem: [bv64]bv8;
 const {:extern} $x_addr: bv64;
 axiom ($x_addr == 69652bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
   (if (index == $x_addr) then true else false)
 }
 
@@ -45,10 +45,6 @@ function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv6
   (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
-}
-
 function {:extern} memory_store32_le(memory: [bv64]bv8, index: bv64, value: bv32) returns ([bv64]bv8) {
   memory[index := value[8:0]][bvadd64(index, 1bv64) := value[16:8]][bvadd64(index, 2bv64) := value[24:16]][bvadd64(index, 3bv64) := value[32:24]]
 }
@@ -58,22 +54,19 @@ function {:extern} {:bvbuiltin "zero_extend 1"} zero_extend1_32(bv32) returns (b
 function {:extern} {:bvbuiltin "zero_extend 32"} zero_extend32_32(bv32) returns (bv64);
 procedure {:extern} rely();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
-  free ensures (memory_load8_le(mem, 1940bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1941bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1942bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1943bv64) == 0bv8);
-  free ensures (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free ensures (memory_load64_le(mem, 69616bv64) == 1876bv64);
+  ensures (mem == old(mem));
+  free ensures (memory_load32_le(mem, 1940bv64) == 131073bv32);
+  free ensures (memory_load64_le(mem, 69008bv64) == 1872bv64);
   free ensures (memory_load64_le(mem, 69016bv64) == 1792bv64);
   free ensures (memory_load64_le(mem, 69600bv64) == 69652bv64);
-  free ensures (memory_load64_le(mem, 69008bv64) == 1872bv64);
+  free ensures (memory_load64_le(mem, 69616bv64) == 1876bv64);
+  free ensures (memory_load64_le(mem, 69640bv64) == 69640bv64);
 
 procedure {:extern} rely_transitive();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
+  ensures (mem == old(mem));
 
 implementation {:extern} rely_transitive()
 {
@@ -90,24 +83,18 @@ procedure main();
   modifies CF, Gamma_CF, Gamma_NF, Gamma_R0, Gamma_R1, Gamma_VF, Gamma_ZF, Gamma_mem, NF, R0, R1, VF, ZF, mem;
   free requires (memory_load64_le(mem, 69632bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free requires (memory_load8_le(mem, 1940bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1941bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1942bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1943bv64) == 0bv8);
-  free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free requires (memory_load64_le(mem, 69616bv64) == 1876bv64);
+  free requires (memory_load32_le(mem, 1940bv64) == 131073bv32);
+  free requires (memory_load64_le(mem, 69008bv64) == 1872bv64);
   free requires (memory_load64_le(mem, 69016bv64) == 1792bv64);
   free requires (memory_load64_le(mem, 69600bv64) == 69652bv64);
-  free requires (memory_load64_le(mem, 69008bv64) == 1872bv64);
-  free ensures (memory_load8_le(mem, 1940bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1941bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1942bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1943bv64) == 0bv8);
-  free ensures (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free ensures (memory_load64_le(mem, 69616bv64) == 1876bv64);
+  free requires (memory_load64_le(mem, 69616bv64) == 1876bv64);
+  free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
+  free ensures (memory_load32_le(mem, 1940bv64) == 131073bv32);
+  free ensures (memory_load64_le(mem, 69008bv64) == 1872bv64);
   free ensures (memory_load64_le(mem, 69016bv64) == 1792bv64);
   free ensures (memory_load64_le(mem, 69600bv64) == 69652bv64);
-  free ensures (memory_load64_le(mem, 69008bv64) == 1872bv64);
+  free ensures (memory_load64_le(mem, 69616bv64) == 1876bv64);
+  free ensures (memory_load64_le(mem, 69640bv64) == 69640bv64);
 
 implementation main()
 {
diff --git a/src/test/correct/ifglobal/gcc_pic/ifglobal_gtirb.expected b/src/test/correct/ifglobal/gcc_pic/ifglobal_gtirb.expected
index d5ed782bd..599a59bca 100644
--- a/src/test/correct/ifglobal/gcc_pic/ifglobal_gtirb.expected
+++ b/src/test/correct/ifglobal/gcc_pic/ifglobal_gtirb.expected
@@ -14,7 +14,7 @@ var {:extern} ZF: bv1;
 var {:extern} mem: [bv64]bv8;
 const {:extern} $x_addr: bv64;
 axiom ($x_addr == 69652bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
   (if (index == $x_addr) then true else false)
 }
 
@@ -44,10 +44,6 @@ function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv6
   (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
-}
-
 function {:extern} memory_store32_le(memory: [bv64]bv8, index: bv64, value: bv32) returns ([bv64]bv8) {
   memory[index := value[8:0]][bvadd64(index, 1bv64) := value[16:8]][bvadd64(index, 2bv64) := value[24:16]][bvadd64(index, 3bv64) := value[32:24]]
 }
@@ -56,22 +52,19 @@ function {:extern} {:bvbuiltin "zero_extend 1"} zero_extend1_32(bv32) returns (b
 function {:extern} {:bvbuiltin "zero_extend 32"} zero_extend32_32(bv32) returns (bv64);
 procedure {:extern} rely();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
-  free ensures (memory_load8_le(mem, 1940bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1941bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1942bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1943bv64) == 0bv8);
-  free ensures (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free ensures (memory_load64_le(mem, 69616bv64) == 1876bv64);
+  ensures (mem == old(mem));
+  free ensures (memory_load32_le(mem, 1940bv64) == 131073bv32);
+  free ensures (memory_load64_le(mem, 69008bv64) == 1872bv64);
   free ensures (memory_load64_le(mem, 69016bv64) == 1792bv64);
   free ensures (memory_load64_le(mem, 69600bv64) == 69652bv64);
-  free ensures (memory_load64_le(mem, 69008bv64) == 1872bv64);
+  free ensures (memory_load64_le(mem, 69616bv64) == 1876bv64);
+  free ensures (memory_load64_le(mem, 69640bv64) == 69640bv64);
 
 procedure {:extern} rely_transitive();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
+  ensures (mem == old(mem));
 
 implementation {:extern} rely_transitive()
 {
@@ -88,24 +81,18 @@ procedure main();
   modifies CF, Gamma_CF, Gamma_NF, Gamma_R0, Gamma_R1, Gamma_VF, Gamma_ZF, Gamma_mem, NF, R0, R1, VF, ZF, mem;
   free requires (memory_load64_le(mem, 69632bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free requires (memory_load8_le(mem, 1940bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1941bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1942bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1943bv64) == 0bv8);
-  free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free requires (memory_load64_le(mem, 69616bv64) == 1876bv64);
+  free requires (memory_load32_le(mem, 1940bv64) == 131073bv32);
+  free requires (memory_load64_le(mem, 69008bv64) == 1872bv64);
   free requires (memory_load64_le(mem, 69016bv64) == 1792bv64);
   free requires (memory_load64_le(mem, 69600bv64) == 69652bv64);
-  free requires (memory_load64_le(mem, 69008bv64) == 1872bv64);
-  free ensures (memory_load8_le(mem, 1940bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1941bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1942bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1943bv64) == 0bv8);
-  free ensures (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free ensures (memory_load64_le(mem, 69616bv64) == 1876bv64);
+  free requires (memory_load64_le(mem, 69616bv64) == 1876bv64);
+  free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
+  free ensures (memory_load32_le(mem, 1940bv64) == 131073bv32);
+  free ensures (memory_load64_le(mem, 69008bv64) == 1872bv64);
   free ensures (memory_load64_le(mem, 69016bv64) == 1792bv64);
   free ensures (memory_load64_le(mem, 69600bv64) == 69652bv64);
-  free ensures (memory_load64_le(mem, 69008bv64) == 1872bv64);
+  free ensures (memory_load64_le(mem, 69616bv64) == 1876bv64);
+  free ensures (memory_load64_le(mem, 69640bv64) == 69640bv64);
 
 implementation main()
 {
diff --git a/src/test/correct/indirect_call/clang/indirect_call_gtirb.expected b/src/test/correct/indirect_call/clang/indirect_call_gtirb.expected
index 9824811ab..2afb32f54 100644
--- a/src/test/correct/indirect_call/clang/indirect_call_gtirb.expected
+++ b/src/test/correct/indirect_call/clang/indirect_call_gtirb.expected
@@ -18,7 +18,7 @@ var {:extern} mem: [bv64]bv8;
 var {:extern} stack: [bv64]bv8;
 const {:extern} $_IO_stdin_used_addr: bv64;
 axiom ($_IO_stdin_used_addr == 1996bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
   false
 }
 
@@ -62,8 +62,8 @@ function {:extern} memory_store64_le(memory: [bv64]bv8, index: bv64, value: bv64
 function {:extern} {:bvbuiltin "zero_extend 32"} zero_extend32_32(bv32) returns (bv64);
 procedure {:extern} rely();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
+  ensures (mem == old(mem));
   free ensures (memory_load8_le(mem, 1996bv64) == 1bv8);
   free ensures (memory_load8_le(mem, 1997bv64) == 0bv8);
   free ensures (memory_load8_le(mem, 1998bv64) == 2bv8);
@@ -84,8 +84,8 @@ procedure {:extern} rely();
 
 procedure {:extern} rely_transitive();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
+  ensures (mem == old(mem));
 
 implementation {:extern} rely_transitive()
 {
diff --git a/src/test/correct/indirect_call/clang_pic/indirect_call_gtirb.expected b/src/test/correct/indirect_call/clang_pic/indirect_call_gtirb.expected
index cd39145d7..85aa00a9a 100644
--- a/src/test/correct/indirect_call/clang_pic/indirect_call_gtirb.expected
+++ b/src/test/correct/indirect_call/clang_pic/indirect_call_gtirb.expected
@@ -18,7 +18,7 @@ var {:extern} mem: [bv64]bv8;
 var {:extern} stack: [bv64]bv8;
 const {:extern} $_IO_stdin_used_addr: bv64;
 axiom ($_IO_stdin_used_addr == 2060bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
   false
 }
 
@@ -62,8 +62,8 @@ function {:extern} memory_store64_le(memory: [bv64]bv8, index: bv64, value: bv64
 function {:extern} {:bvbuiltin "zero_extend 32"} zero_extend32_32(bv32) returns (bv64);
 procedure {:extern} rely();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
+  ensures (mem == old(mem));
   free ensures (memory_load8_le(mem, 2060bv64) == 1bv8);
   free ensures (memory_load8_le(mem, 2061bv64) == 0bv8);
   free ensures (memory_load8_le(mem, 2062bv64) == 2bv8);
@@ -77,16 +77,16 @@ procedure {:extern} rely();
   free ensures (memory_load8_le(mem, 2105bv64) == 58bv8);
   free ensures (memory_load8_le(mem, 2106bv64) == 10bv8);
   free ensures (memory_load8_le(mem, 2107bv64) == 0bv8);
-  free ensures (memory_load64_le(mem, 69576bv64) == 1940bv64);
-  free ensures (memory_load64_le(mem, 69680bv64) == 69680bv64);
   free ensures (memory_load64_le(mem, 69056bv64) == 1936bv64);
   free ensures (memory_load64_le(mem, 69064bv64) == 1856bv64);
+  free ensures (memory_load64_le(mem, 69576bv64) == 1940bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1968bv64);
+  free ensures (memory_load64_le(mem, 69680bv64) == 69680bv64);
 
 procedure {:extern} rely_transitive();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
+  ensures (mem == old(mem));
 
 implementation {:extern} rely_transitive()
 {
@@ -116,11 +116,11 @@ procedure main();
   free requires (memory_load8_le(mem, 2105bv64) == 58bv8);
   free requires (memory_load8_le(mem, 2106bv64) == 10bv8);
   free requires (memory_load8_le(mem, 2107bv64) == 0bv8);
-  free requires (memory_load64_le(mem, 69576bv64) == 1940bv64);
-  free requires (memory_load64_le(mem, 69680bv64) == 69680bv64);
   free requires (memory_load64_le(mem, 69056bv64) == 1936bv64);
   free requires (memory_load64_le(mem, 69064bv64) == 1856bv64);
+  free requires (memory_load64_le(mem, 69576bv64) == 1940bv64);
   free requires (memory_load64_le(mem, 69592bv64) == 1968bv64);
+  free requires (memory_load64_le(mem, 69680bv64) == 69680bv64);
   free ensures (Gamma_R29 == old(Gamma_R29));
   free ensures (Gamma_R31 == old(Gamma_R31));
   free ensures (R29 == old(R29));
@@ -138,11 +138,11 @@ procedure main();
   free ensures (memory_load8_le(mem, 2105bv64) == 58bv8);
   free ensures (memory_load8_le(mem, 2106bv64) == 10bv8);
   free ensures (memory_load8_le(mem, 2107bv64) == 0bv8);
-  free ensures (memory_load64_le(mem, 69576bv64) == 1940bv64);
-  free ensures (memory_load64_le(mem, 69680bv64) == 69680bv64);
   free ensures (memory_load64_le(mem, 69056bv64) == 1936bv64);
   free ensures (memory_load64_le(mem, 69064bv64) == 1856bv64);
+  free ensures (memory_load64_le(mem, 69576bv64) == 1940bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1968bv64);
+  free ensures (memory_load64_le(mem, 69680bv64) == 69680bv64);
 
 implementation main()
 {
@@ -208,11 +208,11 @@ procedure FUN_650();
   free requires (memory_load8_le(mem, 2105bv64) == 58bv8);
   free requires (memory_load8_le(mem, 2106bv64) == 10bv8);
   free requires (memory_load8_le(mem, 2107bv64) == 0bv8);
-  free requires (memory_load64_le(mem, 69576bv64) == 1940bv64);
-  free requires (memory_load64_le(mem, 69680bv64) == 69680bv64);
   free requires (memory_load64_le(mem, 69056bv64) == 1936bv64);
   free requires (memory_load64_le(mem, 69064bv64) == 1856bv64);
+  free requires (memory_load64_le(mem, 69576bv64) == 1940bv64);
   free requires (memory_load64_le(mem, 69592bv64) == 1968bv64);
+  free requires (memory_load64_le(mem, 69680bv64) == 69680bv64);
   free ensures (memory_load8_le(mem, 2060bv64) == 1bv8);
   free ensures (memory_load8_le(mem, 2061bv64) == 0bv8);
   free ensures (memory_load8_le(mem, 2062bv64) == 2bv8);
@@ -226,11 +226,11 @@ procedure FUN_650();
   free ensures (memory_load8_le(mem, 2105bv64) == 58bv8);
   free ensures (memory_load8_le(mem, 2106bv64) == 10bv8);
   free ensures (memory_load8_le(mem, 2107bv64) == 0bv8);
-  free ensures (memory_load64_le(mem, 69576bv64) == 1940bv64);
-  free ensures (memory_load64_le(mem, 69680bv64) == 69680bv64);
   free ensures (memory_load64_le(mem, 69056bv64) == 1936bv64);
   free ensures (memory_load64_le(mem, 69064bv64) == 1856bv64);
+  free ensures (memory_load64_le(mem, 69576bv64) == 1940bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1968bv64);
+  free ensures (memory_load64_le(mem, 69680bv64) == 69680bv64);
 
 implementation FUN_650()
 {
@@ -259,11 +259,11 @@ procedure greet();
   free requires (memory_load8_le(mem, 2105bv64) == 58bv8);
   free requires (memory_load8_le(mem, 2106bv64) == 10bv8);
   free requires (memory_load8_le(mem, 2107bv64) == 0bv8);
-  free requires (memory_load64_le(mem, 69576bv64) == 1940bv64);
-  free requires (memory_load64_le(mem, 69680bv64) == 69680bv64);
   free requires (memory_load64_le(mem, 69056bv64) == 1936bv64);
   free requires (memory_load64_le(mem, 69064bv64) == 1856bv64);
+  free requires (memory_load64_le(mem, 69576bv64) == 1940bv64);
   free requires (memory_load64_le(mem, 69592bv64) == 1968bv64);
+  free requires (memory_load64_le(mem, 69680bv64) == 69680bv64);
   free ensures (Gamma_R29 == old(Gamma_R29));
   free ensures (Gamma_R31 == old(Gamma_R31));
   free ensures (R29 == old(R29));
@@ -281,11 +281,11 @@ procedure greet();
   free ensures (memory_load8_le(mem, 2105bv64) == 58bv8);
   free ensures (memory_load8_le(mem, 2106bv64) == 10bv8);
   free ensures (memory_load8_le(mem, 2107bv64) == 0bv8);
-  free ensures (memory_load64_le(mem, 69576bv64) == 1940bv64);
-  free ensures (memory_load64_le(mem, 69680bv64) == 69680bv64);
   free ensures (memory_load64_le(mem, 69056bv64) == 1936bv64);
   free ensures (memory_load64_le(mem, 69064bv64) == 1856bv64);
+  free ensures (memory_load64_le(mem, 69576bv64) == 1940bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1968bv64);
+  free ensures (memory_load64_le(mem, 69680bv64) == 69680bv64);
 
 implementation greet()
 {
@@ -330,11 +330,11 @@ procedure printf();
   free requires (memory_load8_le(mem, 2105bv64) == 58bv8);
   free requires (memory_load8_le(mem, 2106bv64) == 10bv8);
   free requires (memory_load8_le(mem, 2107bv64) == 0bv8);
-  free requires (memory_load64_le(mem, 69576bv64) == 1940bv64);
-  free requires (memory_load64_le(mem, 69680bv64) == 69680bv64);
   free requires (memory_load64_le(mem, 69056bv64) == 1936bv64);
   free requires (memory_load64_le(mem, 69064bv64) == 1856bv64);
+  free requires (memory_load64_le(mem, 69576bv64) == 1940bv64);
   free requires (memory_load64_le(mem, 69592bv64) == 1968bv64);
+  free requires (memory_load64_le(mem, 69680bv64) == 69680bv64);
   free ensures (memory_load8_le(mem, 2060bv64) == 1bv8);
   free ensures (memory_load8_le(mem, 2061bv64) == 0bv8);
   free ensures (memory_load8_le(mem, 2062bv64) == 2bv8);
@@ -348,9 +348,9 @@ procedure printf();
   free ensures (memory_load8_le(mem, 2105bv64) == 58bv8);
   free ensures (memory_load8_le(mem, 2106bv64) == 10bv8);
   free ensures (memory_load8_le(mem, 2107bv64) == 0bv8);
-  free ensures (memory_load64_le(mem, 69576bv64) == 1940bv64);
-  free ensures (memory_load64_le(mem, 69680bv64) == 69680bv64);
   free ensures (memory_load64_le(mem, 69056bv64) == 1936bv64);
   free ensures (memory_load64_le(mem, 69064bv64) == 1856bv64);
+  free ensures (memory_load64_le(mem, 69576bv64) == 1940bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1968bv64);
+  free ensures (memory_load64_le(mem, 69680bv64) == 69680bv64);
 
diff --git a/src/test/correct/indirect_call/gcc/indirect_call_gtirb.expected b/src/test/correct/indirect_call/gcc/indirect_call_gtirb.expected
index 1587a7a14..1b2be3e60 100644
--- a/src/test/correct/indirect_call/gcc/indirect_call_gtirb.expected
+++ b/src/test/correct/indirect_call/gcc/indirect_call_gtirb.expected
@@ -16,7 +16,7 @@ var {:extern} mem: [bv64]bv8;
 var {:extern} stack: [bv64]bv8;
 const {:extern} $_IO_stdin_used_addr: bv64;
 axiom ($_IO_stdin_used_addr == 1984bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
   false
 }
 
@@ -43,8 +43,8 @@ function {:extern} memory_store64_le(memory: [bv64]bv8, index: bv64, value: bv64
 
 procedure {:extern} rely();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
+  ensures (mem == old(mem));
   free ensures (memory_load64_le(mem, 1984bv64) == 131073bv64);
   free ensures (memory_load64_le(mem, 1992bv64) == 8583909746840200520bv64);
   free ensures (memory_load64_le(mem, 2000bv64) == 143418749551bv64);
@@ -62,8 +62,8 @@ procedure {:extern} rely();
 
 procedure {:extern} rely_transitive();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
+  ensures (mem == old(mem));
 
 implementation {:extern} rely_transitive()
 {
diff --git a/src/test/correct/indirect_call/gcc_pic/indirect_call_gtirb.expected b/src/test/correct/indirect_call/gcc_pic/indirect_call_gtirb.expected
index 6fae6b6ba..01dd235a3 100644
--- a/src/test/correct/indirect_call/gcc_pic/indirect_call_gtirb.expected
+++ b/src/test/correct/indirect_call/gcc_pic/indirect_call_gtirb.expected
@@ -16,7 +16,7 @@ var {:extern} mem: [bv64]bv8;
 var {:extern} stack: [bv64]bv8;
 const {:extern} $_IO_stdin_used_addr: bv64;
 axiom ($_IO_stdin_used_addr == 2048bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
   false
 }
 
@@ -43,8 +43,8 @@ function {:extern} memory_store64_le(memory: [bv64]bv8, index: bv64, value: bv64
 
 procedure {:extern} rely();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
+  ensures (mem == old(mem));
   free ensures (memory_load64_le(mem, 2048bv64) == 131073bv64);
   free ensures (memory_load64_le(mem, 2056bv64) == 8583909746840200520bv64);
   free ensures (memory_load64_le(mem, 2064bv64) == 143418749551bv64);
@@ -55,16 +55,16 @@ procedure {:extern} rely();
   free ensures (memory_load8_le(mem, 2097bv64) == 121bv8);
   free ensures (memory_load8_le(mem, 2098bv64) == 58bv8);
   free ensures (memory_load8_le(mem, 2099bv64) == 0bv8);
-  free ensures (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free ensures (memory_load64_le(mem, 69616bv64) == 1972bv64);
-  free ensures (memory_load64_le(mem, 69600bv64) == 1940bv64);
-  free ensures (memory_load64_le(mem, 69008bv64) == 1856bv64);
   free ensures (memory_load64_le(mem, 69000bv64) == 1936bv64);
+  free ensures (memory_load64_le(mem, 69008bv64) == 1856bv64);
+  free ensures (memory_load64_le(mem, 69600bv64) == 1940bv64);
+  free ensures (memory_load64_le(mem, 69616bv64) == 1972bv64);
+  free ensures (memory_load64_le(mem, 69640bv64) == 69640bv64);
 
 procedure {:extern} rely_transitive();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
+  ensures (mem == old(mem));
 
 implementation {:extern} rely_transitive()
 {
@@ -89,11 +89,11 @@ procedure greet();
   free requires (memory_load8_le(mem, 2097bv64) == 121bv8);
   free requires (memory_load8_le(mem, 2098bv64) == 58bv8);
   free requires (memory_load8_le(mem, 2099bv64) == 0bv8);
-  free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free requires (memory_load64_le(mem, 69616bv64) == 1972bv64);
-  free requires (memory_load64_le(mem, 69600bv64) == 1940bv64);
-  free requires (memory_load64_le(mem, 69008bv64) == 1856bv64);
   free requires (memory_load64_le(mem, 69000bv64) == 1936bv64);
+  free requires (memory_load64_le(mem, 69008bv64) == 1856bv64);
+  free requires (memory_load64_le(mem, 69600bv64) == 1940bv64);
+  free requires (memory_load64_le(mem, 69616bv64) == 1972bv64);
+  free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
   free ensures (Gamma_R29 == old(Gamma_R29));
   free ensures (Gamma_R31 == old(Gamma_R31));
   free ensures (R29 == old(R29));
@@ -108,11 +108,11 @@ procedure greet();
   free ensures (memory_load8_le(mem, 2097bv64) == 121bv8);
   free ensures (memory_load8_le(mem, 2098bv64) == 58bv8);
   free ensures (memory_load8_le(mem, 2099bv64) == 0bv8);
-  free ensures (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free ensures (memory_load64_le(mem, 69616bv64) == 1972bv64);
-  free ensures (memory_load64_le(mem, 69600bv64) == 1940bv64);
-  free ensures (memory_load64_le(mem, 69008bv64) == 1856bv64);
   free ensures (memory_load64_le(mem, 69000bv64) == 1936bv64);
+  free ensures (memory_load64_le(mem, 69008bv64) == 1856bv64);
+  free ensures (memory_load64_le(mem, 69600bv64) == 1940bv64);
+  free ensures (memory_load64_le(mem, 69616bv64) == 1972bv64);
+  free ensures (memory_load64_le(mem, 69640bv64) == 69640bv64);
 
 implementation greet()
 {
@@ -155,11 +155,11 @@ procedure FUN_650();
   free requires (memory_load8_le(mem, 2097bv64) == 121bv8);
   free requires (memory_load8_le(mem, 2098bv64) == 58bv8);
   free requires (memory_load8_le(mem, 2099bv64) == 0bv8);
-  free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free requires (memory_load64_le(mem, 69616bv64) == 1972bv64);
-  free requires (memory_load64_le(mem, 69600bv64) == 1940bv64);
-  free requires (memory_load64_le(mem, 69008bv64) == 1856bv64);
   free requires (memory_load64_le(mem, 69000bv64) == 1936bv64);
+  free requires (memory_load64_le(mem, 69008bv64) == 1856bv64);
+  free requires (memory_load64_le(mem, 69600bv64) == 1940bv64);
+  free requires (memory_load64_le(mem, 69616bv64) == 1972bv64);
+  free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
   free ensures (memory_load64_le(mem, 2048bv64) == 131073bv64);
   free ensures (memory_load64_le(mem, 2056bv64) == 8583909746840200520bv64);
   free ensures (memory_load64_le(mem, 2064bv64) == 143418749551bv64);
@@ -170,11 +170,11 @@ procedure FUN_650();
   free ensures (memory_load8_le(mem, 2097bv64) == 121bv8);
   free ensures (memory_load8_le(mem, 2098bv64) == 58bv8);
   free ensures (memory_load8_le(mem, 2099bv64) == 0bv8);
-  free ensures (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free ensures (memory_load64_le(mem, 69616bv64) == 1972bv64);
-  free ensures (memory_load64_le(mem, 69600bv64) == 1940bv64);
-  free ensures (memory_load64_le(mem, 69008bv64) == 1856bv64);
   free ensures (memory_load64_le(mem, 69000bv64) == 1936bv64);
+  free ensures (memory_load64_le(mem, 69008bv64) == 1856bv64);
+  free ensures (memory_load64_le(mem, 69600bv64) == 1940bv64);
+  free ensures (memory_load64_le(mem, 69616bv64) == 1972bv64);
+  free ensures (memory_load64_le(mem, 69640bv64) == 69640bv64);
 
 implementation FUN_650()
 {
@@ -202,11 +202,11 @@ procedure main();
   free requires (memory_load8_le(mem, 2097bv64) == 121bv8);
   free requires (memory_load8_le(mem, 2098bv64) == 58bv8);
   free requires (memory_load8_le(mem, 2099bv64) == 0bv8);
-  free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free requires (memory_load64_le(mem, 69616bv64) == 1972bv64);
-  free requires (memory_load64_le(mem, 69600bv64) == 1940bv64);
-  free requires (memory_load64_le(mem, 69008bv64) == 1856bv64);
   free requires (memory_load64_le(mem, 69000bv64) == 1936bv64);
+  free requires (memory_load64_le(mem, 69008bv64) == 1856bv64);
+  free requires (memory_load64_le(mem, 69600bv64) == 1940bv64);
+  free requires (memory_load64_le(mem, 69616bv64) == 1972bv64);
+  free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
   free ensures (Gamma_R29 == old(Gamma_R29));
   free ensures (Gamma_R31 == old(Gamma_R31));
   free ensures (R29 == old(R29));
@@ -221,11 +221,11 @@ procedure main();
   free ensures (memory_load8_le(mem, 2097bv64) == 121bv8);
   free ensures (memory_load8_le(mem, 2098bv64) == 58bv8);
   free ensures (memory_load8_le(mem, 2099bv64) == 0bv8);
-  free ensures (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free ensures (memory_load64_le(mem, 69616bv64) == 1972bv64);
-  free ensures (memory_load64_le(mem, 69600bv64) == 1940bv64);
-  free ensures (memory_load64_le(mem, 69008bv64) == 1856bv64);
   free ensures (memory_load64_le(mem, 69000bv64) == 1936bv64);
+  free ensures (memory_load64_le(mem, 69008bv64) == 1856bv64);
+  free ensures (memory_load64_le(mem, 69600bv64) == 1940bv64);
+  free ensures (memory_load64_le(mem, 69616bv64) == 1972bv64);
+  free ensures (memory_load64_le(mem, 69640bv64) == 69640bv64);
 
 implementation main()
 {
@@ -279,11 +279,11 @@ procedure puts();
   free requires (memory_load8_le(mem, 2097bv64) == 121bv8);
   free requires (memory_load8_le(mem, 2098bv64) == 58bv8);
   free requires (memory_load8_le(mem, 2099bv64) == 0bv8);
-  free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free requires (memory_load64_le(mem, 69616bv64) == 1972bv64);
-  free requires (memory_load64_le(mem, 69600bv64) == 1940bv64);
-  free requires (memory_load64_le(mem, 69008bv64) == 1856bv64);
   free requires (memory_load64_le(mem, 69000bv64) == 1936bv64);
+  free requires (memory_load64_le(mem, 69008bv64) == 1856bv64);
+  free requires (memory_load64_le(mem, 69600bv64) == 1940bv64);
+  free requires (memory_load64_le(mem, 69616bv64) == 1972bv64);
+  free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
   free ensures (memory_load64_le(mem, 2048bv64) == 131073bv64);
   free ensures (memory_load64_le(mem, 2056bv64) == 8583909746840200520bv64);
   free ensures (memory_load64_le(mem, 2064bv64) == 143418749551bv64);
@@ -294,9 +294,9 @@ procedure puts();
   free ensures (memory_load8_le(mem, 2097bv64) == 121bv8);
   free ensures (memory_load8_le(mem, 2098bv64) == 58bv8);
   free ensures (memory_load8_le(mem, 2099bv64) == 0bv8);
-  free ensures (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free ensures (memory_load64_le(mem, 69616bv64) == 1972bv64);
-  free ensures (memory_load64_le(mem, 69600bv64) == 1940bv64);
-  free ensures (memory_load64_le(mem, 69008bv64) == 1856bv64);
   free ensures (memory_load64_le(mem, 69000bv64) == 1936bv64);
+  free ensures (memory_load64_le(mem, 69008bv64) == 1856bv64);
+  free ensures (memory_load64_le(mem, 69600bv64) == 1940bv64);
+  free ensures (memory_load64_le(mem, 69616bv64) == 1972bv64);
+  free ensures (memory_load64_le(mem, 69640bv64) == 69640bv64);
 
diff --git a/src/test/correct/initialisation/clang/initialisation.expected b/src/test/correct/initialisation/clang/initialisation.expected
index 0af0f30d2..b6d670468 100644
--- a/src/test/correct/initialisation/clang/initialisation.expected
+++ b/src/test/correct/initialisation/clang/initialisation.expected
@@ -26,7 +26,7 @@ const {:extern} $y_addr: bv64;
 axiom ($y_addr == 69684bv64);
 const {:extern} $z_addr: bv64;
 axiom ($z_addr == 69688bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
   false
 }
 
@@ -90,12 +90,9 @@ function {:extern} {:bvbuiltin "zero_extend 32"} zero_extend32_32(bv32) returns
 function {:extern} {:bvbuiltin "zero_extend 56"} zero_extend56_8(bv8) returns (bv64);
 procedure {:extern} rely();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
-  free ensures (memory_load8_le(mem, 1912bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1913bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1914bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1915bv64) == 0bv8);
+  ensures (mem == old(mem));
+  free ensures (memory_load32_le(mem, 1912bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1812bv64);
@@ -103,8 +100,8 @@ procedure {:extern} rely();
 
 procedure {:extern} rely_transitive();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
+  ensures (mem == old(mem));
 
 implementation {:extern} rely_transitive()
 {
@@ -124,10 +121,7 @@ procedure main();
   free requires (memory_load64_le(mem, 69680bv64) == 416611827717bv64);
   free requires (memory_load64_le(mem, 69688bv64) == 68719476735bv64);
   free requires (memory_load64_le(mem, 69696bv64) == 8589934593bv64);
-  free requires (memory_load8_le(mem, 1912bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1913bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1914bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1915bv64) == 0bv8);
+  free requires (memory_load32_le(mem, 1912bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free requires (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free requires (memory_load64_le(mem, 69592bv64) == 1812bv64);
@@ -135,10 +129,7 @@ procedure main();
   ensures (memory_load32_le(mem, $x_addr) == 6bv32);
   ensures (memory_load32_le(mem, bvadd64($a_addr, 4bv64)) == 4bv32);
   ensures (memory_load32_le(mem, bvadd64($a_addr, 0bv64)) == 1bv32);
-  free ensures (memory_load8_le(mem, 1912bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1913bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1914bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1915bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1912bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1812bv64);
diff --git a/src/test/correct/initialisation/clang/initialisation_gtirb.expected b/src/test/correct/initialisation/clang/initialisation_gtirb.expected
index 3f5fbc23c..d27251515 100644
--- a/src/test/correct/initialisation/clang/initialisation_gtirb.expected
+++ b/src/test/correct/initialisation/clang/initialisation_gtirb.expected
@@ -26,7 +26,7 @@ const {:extern} $y_addr: bv64;
 axiom ($y_addr == 69684bv64);
 const {:extern} $z_addr: bv64;
 axiom ($z_addr == 69688bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
   false
 }
 
@@ -90,12 +90,9 @@ function {:extern} {:bvbuiltin "zero_extend 24"} zero_extend24_8(bv8) returns (b
 function {:extern} {:bvbuiltin "zero_extend 32"} zero_extend32_32(bv32) returns (bv64);
 procedure {:extern} rely();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
-  free ensures (memory_load8_le(mem, 1912bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1913bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1914bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1915bv64) == 0bv8);
+  ensures (mem == old(mem));
+  free ensures (memory_load32_le(mem, 1912bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1812bv64);
@@ -103,8 +100,8 @@ procedure {:extern} rely();
 
 procedure {:extern} rely_transitive();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
+  ensures (mem == old(mem));
 
 implementation {:extern} rely_transitive()
 {
@@ -124,10 +121,7 @@ procedure main();
   free requires (memory_load64_le(mem, 69680bv64) == 416611827717bv64);
   free requires (memory_load64_le(mem, 69688bv64) == 68719476735bv64);
   free requires (memory_load64_le(mem, 69696bv64) == 8589934593bv64);
-  free requires (memory_load8_le(mem, 1912bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1913bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1914bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1915bv64) == 0bv8);
+  free requires (memory_load32_le(mem, 1912bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free requires (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free requires (memory_load64_le(mem, 69592bv64) == 1812bv64);
@@ -135,10 +129,7 @@ procedure main();
   ensures (memory_load32_le(mem, $x_addr) == 6bv32);
   ensures (memory_load32_le(mem, bvadd64($a_addr, 4bv64)) == 4bv32);
   ensures (memory_load32_le(mem, bvadd64($a_addr, 0bv64)) == 1bv32);
-  free ensures (memory_load8_le(mem, 1912bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1913bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1914bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1915bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1912bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1812bv64);
diff --git a/src/test/correct/initialisation/clang_O2/initialisation.expected b/src/test/correct/initialisation/clang_O2/initialisation.expected
index 13d304de8..3562cf315 100644
--- a/src/test/correct/initialisation/clang_O2/initialisation.expected
+++ b/src/test/correct/initialisation/clang_O2/initialisation.expected
@@ -26,7 +26,7 @@ const {:extern} $y_addr: bv64;
 axiom ($y_addr == 69684bv64);
 const {:extern} $z_addr: bv64;
 axiom ($z_addr == 69688bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
   false
 }
 
@@ -84,12 +84,9 @@ function {:extern} {:bvbuiltin "zero_extend 32"} zero_extend32_32(bv32) returns
 function {:extern} {:bvbuiltin "zero_extend 56"} zero_extend56_8(bv8) returns (bv64);
 procedure {:extern} rely();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
-  free ensures (memory_load8_le(mem, 1908bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1909bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1910bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1911bv64) == 0bv8);
+  ensures (mem == old(mem));
+  free ensures (memory_load32_le(mem, 1908bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1812bv64);
@@ -97,8 +94,8 @@ procedure {:extern} rely();
 
 procedure {:extern} rely_transitive();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
+  ensures (mem == old(mem));
 
 implementation {:extern} rely_transitive()
 {
@@ -118,10 +115,7 @@ procedure main();
   free requires (memory_load64_le(mem, 69680bv64) == 416611827717bv64);
   free requires (memory_load64_le(mem, 69688bv64) == 68719476735bv64);
   free requires (memory_load64_le(mem, 69696bv64) == 8589934593bv64);
-  free requires (memory_load8_le(mem, 1908bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1909bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1910bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1911bv64) == 0bv8);
+  free requires (memory_load32_le(mem, 1908bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free requires (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free requires (memory_load64_le(mem, 69592bv64) == 1812bv64);
@@ -129,10 +123,7 @@ procedure main();
   ensures (memory_load32_le(mem, $x_addr) == 6bv32);
   ensures (memory_load32_le(mem, bvadd64($a_addr, 4bv64)) == 4bv32);
   ensures (memory_load32_le(mem, bvadd64($a_addr, 0bv64)) == 1bv32);
-  free ensures (memory_load8_le(mem, 1908bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1909bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1910bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1911bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1908bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1812bv64);
diff --git a/src/test/correct/initialisation/clang_O2/initialisation_gtirb.expected b/src/test/correct/initialisation/clang_O2/initialisation_gtirb.expected
index a9e116b67..3297b068d 100644
--- a/src/test/correct/initialisation/clang_O2/initialisation_gtirb.expected
+++ b/src/test/correct/initialisation/clang_O2/initialisation_gtirb.expected
@@ -26,7 +26,7 @@ const {:extern} $y_addr: bv64;
 axiom ($y_addr == 69684bv64);
 const {:extern} $z_addr: bv64;
 axiom ($z_addr == 69688bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
   false
 }
 
@@ -84,12 +84,9 @@ function {:extern} {:bvbuiltin "zero_extend 24"} zero_extend24_8(bv8) returns (b
 function {:extern} {:bvbuiltin "zero_extend 32"} zero_extend32_32(bv32) returns (bv64);
 procedure {:extern} rely();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
-  free ensures (memory_load8_le(mem, 1908bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1909bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1910bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1911bv64) == 0bv8);
+  ensures (mem == old(mem));
+  free ensures (memory_load32_le(mem, 1908bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1812bv64);
@@ -97,8 +94,8 @@ procedure {:extern} rely();
 
 procedure {:extern} rely_transitive();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
+  ensures (mem == old(mem));
 
 implementation {:extern} rely_transitive()
 {
@@ -118,10 +115,7 @@ procedure main();
   free requires (memory_load64_le(mem, 69680bv64) == 416611827717bv64);
   free requires (memory_load64_le(mem, 69688bv64) == 68719476735bv64);
   free requires (memory_load64_le(mem, 69696bv64) == 8589934593bv64);
-  free requires (memory_load8_le(mem, 1908bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1909bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1910bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1911bv64) == 0bv8);
+  free requires (memory_load32_le(mem, 1908bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free requires (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free requires (memory_load64_le(mem, 69592bv64) == 1812bv64);
@@ -129,10 +123,7 @@ procedure main();
   ensures (memory_load32_le(mem, $x_addr) == 6bv32);
   ensures (memory_load32_le(mem, bvadd64($a_addr, 4bv64)) == 4bv32);
   ensures (memory_load32_le(mem, bvadd64($a_addr, 0bv64)) == 1bv32);
-  free ensures (memory_load8_le(mem, 1908bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1909bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1910bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1911bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1908bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1812bv64);
diff --git a/src/test/correct/initialisation/clang_pic/initialisation.expected b/src/test/correct/initialisation/clang_pic/initialisation.expected
index dadd6b3d7..d38e9a7ca 100644
--- a/src/test/correct/initialisation/clang_pic/initialisation.expected
+++ b/src/test/correct/initialisation/clang_pic/initialisation.expected
@@ -24,7 +24,7 @@ const {:extern} $y_addr: bv64;
 axiom ($y_addr == 69684bv64);
 const {:extern} $z_addr: bv64;
 axiom ($z_addr == 69688bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
   false
 }
 
@@ -88,25 +88,22 @@ function {:extern} {:bvbuiltin "zero_extend 32"} zero_extend32_32(bv32) returns
 function {:extern} {:bvbuiltin "zero_extend 56"} zero_extend56_8(bv8) returns (bv64);
 procedure {:extern} rely();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
-  free ensures (memory_load8_le(mem, 2048bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 2049bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 2050bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 2051bv64) == 0bv8);
+  ensures (mem == old(mem));
+  free ensures (memory_load32_le(mem, 2048bv64) == 131073bv32);
+  free ensures (memory_load64_le(mem, 69032bv64) == 1936bv64);
+  free ensures (memory_load64_le(mem, 69040bv64) == 1856bv64);
+  free ensures (memory_load64_le(mem, 69552bv64) == 69688bv64);
+  free ensures (memory_load64_le(mem, 69560bv64) == 69680bv64);
   free ensures (memory_load64_le(mem, 69576bv64) == 69696bv64);
-  free ensures (memory_load64_le(mem, 69672bv64) == 69672bv64);
   free ensures (memory_load64_le(mem, 69584bv64) == 69684bv64);
-  free ensures (memory_load64_le(mem, 69552bv64) == 69688bv64);
-  free ensures (memory_load64_le(mem, 69040bv64) == 1856bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1940bv64);
-  free ensures (memory_load64_le(mem, 69032bv64) == 1936bv64);
-  free ensures (memory_load64_le(mem, 69560bv64) == 69680bv64);
+  free ensures (memory_load64_le(mem, 69672bv64) == 69672bv64);
 
 procedure {:extern} rely_transitive();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
+  ensures (mem == old(mem));
 
 implementation {:extern} rely_transitive()
 {
@@ -126,33 +123,27 @@ procedure main();
   free requires (memory_load64_le(mem, 69680bv64) == 416611827717bv64);
   free requires (memory_load64_le(mem, 69688bv64) == 68719476735bv64);
   free requires (memory_load64_le(mem, 69696bv64) == 8589934593bv64);
-  free requires (memory_load8_le(mem, 2048bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 2049bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 2050bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 2051bv64) == 0bv8);
+  free requires (memory_load32_le(mem, 2048bv64) == 131073bv32);
+  free requires (memory_load64_le(mem, 69032bv64) == 1936bv64);
+  free requires (memory_load64_le(mem, 69040bv64) == 1856bv64);
+  free requires (memory_load64_le(mem, 69552bv64) == 69688bv64);
+  free requires (memory_load64_le(mem, 69560bv64) == 69680bv64);
   free requires (memory_load64_le(mem, 69576bv64) == 69696bv64);
-  free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
   free requires (memory_load64_le(mem, 69584bv64) == 69684bv64);
-  free requires (memory_load64_le(mem, 69552bv64) == 69688bv64);
-  free requires (memory_load64_le(mem, 69040bv64) == 1856bv64);
   free requires (memory_load64_le(mem, 69592bv64) == 1940bv64);
-  free requires (memory_load64_le(mem, 69032bv64) == 1936bv64);
-  free requires (memory_load64_le(mem, 69560bv64) == 69680bv64);
+  free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
   ensures (memory_load32_le(mem, $x_addr) == 6bv32);
   ensures (memory_load32_le(mem, bvadd64($a_addr, 4bv64)) == 4bv32);
   ensures (memory_load32_le(mem, bvadd64($a_addr, 0bv64)) == 1bv32);
-  free ensures (memory_load8_le(mem, 2048bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 2049bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 2050bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 2051bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 2048bv64) == 131073bv32);
+  free ensures (memory_load64_le(mem, 69032bv64) == 1936bv64);
+  free ensures (memory_load64_le(mem, 69040bv64) == 1856bv64);
+  free ensures (memory_load64_le(mem, 69552bv64) == 69688bv64);
+  free ensures (memory_load64_le(mem, 69560bv64) == 69680bv64);
   free ensures (memory_load64_le(mem, 69576bv64) == 69696bv64);
-  free ensures (memory_load64_le(mem, 69672bv64) == 69672bv64);
   free ensures (memory_load64_le(mem, 69584bv64) == 69684bv64);
-  free ensures (memory_load64_le(mem, 69552bv64) == 69688bv64);
-  free ensures (memory_load64_le(mem, 69040bv64) == 1856bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1940bv64);
-  free ensures (memory_load64_le(mem, 69032bv64) == 1936bv64);
-  free ensures (memory_load64_le(mem, 69560bv64) == 69680bv64);
+  free ensures (memory_load64_le(mem, 69672bv64) == 69672bv64);
 
 implementation main()
 {
diff --git a/src/test/correct/initialisation/clang_pic/initialisation_gtirb.expected b/src/test/correct/initialisation/clang_pic/initialisation_gtirb.expected
index b27c8c0fc..874733c01 100644
--- a/src/test/correct/initialisation/clang_pic/initialisation_gtirb.expected
+++ b/src/test/correct/initialisation/clang_pic/initialisation_gtirb.expected
@@ -24,7 +24,7 @@ const {:extern} $y_addr: bv64;
 axiom ($y_addr == 69684bv64);
 const {:extern} $z_addr: bv64;
 axiom ($z_addr == 69688bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
   false
 }
 
@@ -88,25 +88,22 @@ function {:extern} {:bvbuiltin "zero_extend 24"} zero_extend24_8(bv8) returns (b
 function {:extern} {:bvbuiltin "zero_extend 32"} zero_extend32_32(bv32) returns (bv64);
 procedure {:extern} rely();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
-  free ensures (memory_load8_le(mem, 2048bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 2049bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 2050bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 2051bv64) == 0bv8);
+  ensures (mem == old(mem));
+  free ensures (memory_load32_le(mem, 2048bv64) == 131073bv32);
+  free ensures (memory_load64_le(mem, 69032bv64) == 1936bv64);
+  free ensures (memory_load64_le(mem, 69040bv64) == 1856bv64);
+  free ensures (memory_load64_le(mem, 69552bv64) == 69688bv64);
+  free ensures (memory_load64_le(mem, 69560bv64) == 69680bv64);
   free ensures (memory_load64_le(mem, 69576bv64) == 69696bv64);
-  free ensures (memory_load64_le(mem, 69672bv64) == 69672bv64);
   free ensures (memory_load64_le(mem, 69584bv64) == 69684bv64);
-  free ensures (memory_load64_le(mem, 69552bv64) == 69688bv64);
-  free ensures (memory_load64_le(mem, 69040bv64) == 1856bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1940bv64);
-  free ensures (memory_load64_le(mem, 69032bv64) == 1936bv64);
-  free ensures (memory_load64_le(mem, 69560bv64) == 69680bv64);
+  free ensures (memory_load64_le(mem, 69672bv64) == 69672bv64);
 
 procedure {:extern} rely_transitive();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
+  ensures (mem == old(mem));
 
 implementation {:extern} rely_transitive()
 {
@@ -126,33 +123,27 @@ procedure main();
   free requires (memory_load64_le(mem, 69680bv64) == 416611827717bv64);
   free requires (memory_load64_le(mem, 69688bv64) == 68719476735bv64);
   free requires (memory_load64_le(mem, 69696bv64) == 8589934593bv64);
-  free requires (memory_load8_le(mem, 2048bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 2049bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 2050bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 2051bv64) == 0bv8);
+  free requires (memory_load32_le(mem, 2048bv64) == 131073bv32);
+  free requires (memory_load64_le(mem, 69032bv64) == 1936bv64);
+  free requires (memory_load64_le(mem, 69040bv64) == 1856bv64);
+  free requires (memory_load64_le(mem, 69552bv64) == 69688bv64);
+  free requires (memory_load64_le(mem, 69560bv64) == 69680bv64);
   free requires (memory_load64_le(mem, 69576bv64) == 69696bv64);
-  free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
   free requires (memory_load64_le(mem, 69584bv64) == 69684bv64);
-  free requires (memory_load64_le(mem, 69552bv64) == 69688bv64);
-  free requires (memory_load64_le(mem, 69040bv64) == 1856bv64);
   free requires (memory_load64_le(mem, 69592bv64) == 1940bv64);
-  free requires (memory_load64_le(mem, 69032bv64) == 1936bv64);
-  free requires (memory_load64_le(mem, 69560bv64) == 69680bv64);
+  free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
   ensures (memory_load32_le(mem, $x_addr) == 6bv32);
   ensures (memory_load32_le(mem, bvadd64($a_addr, 4bv64)) == 4bv32);
   ensures (memory_load32_le(mem, bvadd64($a_addr, 0bv64)) == 1bv32);
-  free ensures (memory_load8_le(mem, 2048bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 2049bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 2050bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 2051bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 2048bv64) == 131073bv32);
+  free ensures (memory_load64_le(mem, 69032bv64) == 1936bv64);
+  free ensures (memory_load64_le(mem, 69040bv64) == 1856bv64);
+  free ensures (memory_load64_le(mem, 69552bv64) == 69688bv64);
+  free ensures (memory_load64_le(mem, 69560bv64) == 69680bv64);
   free ensures (memory_load64_le(mem, 69576bv64) == 69696bv64);
-  free ensures (memory_load64_le(mem, 69672bv64) == 69672bv64);
   free ensures (memory_load64_le(mem, 69584bv64) == 69684bv64);
-  free ensures (memory_load64_le(mem, 69552bv64) == 69688bv64);
-  free ensures (memory_load64_le(mem, 69040bv64) == 1856bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1940bv64);
-  free ensures (memory_load64_le(mem, 69032bv64) == 1936bv64);
-  free ensures (memory_load64_le(mem, 69560bv64) == 69680bv64);
+  free ensures (memory_load64_le(mem, 69672bv64) == 69672bv64);
 
 implementation main()
 {
diff --git a/src/test/correct/initialisation/gcc/initialisation.expected b/src/test/correct/initialisation/gcc/initialisation.expected
index cec7d3cbd..c1e20ad01 100644
--- a/src/test/correct/initialisation/gcc/initialisation.expected
+++ b/src/test/correct/initialisation/gcc/initialisation.expected
@@ -12,7 +12,7 @@ const {:extern} $y_addr: bv64;
 axiom ($y_addr == 69652bv64);
 const {:extern} $z_addr: bv64;
 axiom ($z_addr == 69656bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
   false
 }
 
@@ -70,12 +70,9 @@ function {:extern} {:bvbuiltin "zero_extend 32"} zero_extend32_32(bv32) returns
 function {:extern} {:bvbuiltin "zero_extend 56"} zero_extend56_8(bv8) returns (bv64);
 procedure {:extern} rely();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
-  free ensures (memory_load8_le(mem, 1956bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1957bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1958bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1959bv64) == 0bv8);
+  ensures (mem == old(mem));
+  free ensures (memory_load32_le(mem, 1956bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69016bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69024bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69616bv64) == 1812bv64);
@@ -83,8 +80,8 @@ procedure {:extern} rely();
 
 procedure {:extern} rely_transitive();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
+  ensures (mem == old(mem));
 
 implementation {:extern} rely_transitive()
 {
@@ -104,10 +101,7 @@ procedure main();
   free requires (memory_load64_le(mem, 69648bv64) == 416611827717bv64);
   free requires (memory_load64_le(mem, 69656bv64) == 68719476735bv64);
   free requires (memory_load64_le(mem, 69664bv64) == 8589934593bv64);
-  free requires (memory_load8_le(mem, 1956bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1957bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1958bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1959bv64) == 0bv8);
+  free requires (memory_load32_le(mem, 1956bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69016bv64) == 1808bv64);
   free requires (memory_load64_le(mem, 69024bv64) == 1728bv64);
   free requires (memory_load64_le(mem, 69616bv64) == 1812bv64);
@@ -115,10 +109,7 @@ procedure main();
   ensures (memory_load32_le(mem, $x_addr) == 6bv32);
   ensures (memory_load32_le(mem, bvadd64($a_addr, 4bv64)) == 4bv32);
   ensures (memory_load32_le(mem, bvadd64($a_addr, 0bv64)) == 1bv32);
-  free ensures (memory_load8_le(mem, 1956bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1957bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1958bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1959bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1956bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69016bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69024bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69616bv64) == 1812bv64);
diff --git a/src/test/correct/initialisation/gcc/initialisation_gtirb.expected b/src/test/correct/initialisation/gcc/initialisation_gtirb.expected
index 45006ee53..d23427f1b 100644
--- a/src/test/correct/initialisation/gcc/initialisation_gtirb.expected
+++ b/src/test/correct/initialisation/gcc/initialisation_gtirb.expected
@@ -12,7 +12,7 @@ const {:extern} $y_addr: bv64;
 axiom ($y_addr == 69652bv64);
 const {:extern} $z_addr: bv64;
 axiom ($z_addr == 69656bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
   false
 }
 
@@ -70,12 +70,9 @@ function {:extern} {:bvbuiltin "zero_extend 24"} zero_extend24_8(bv8) returns (b
 function {:extern} {:bvbuiltin "zero_extend 32"} zero_extend32_32(bv32) returns (bv64);
 procedure {:extern} rely();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
-  free ensures (memory_load8_le(mem, 1956bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1957bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1958bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1959bv64) == 0bv8);
+  ensures (mem == old(mem));
+  free ensures (memory_load32_le(mem, 1956bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69016bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69024bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69616bv64) == 1812bv64);
@@ -83,8 +80,8 @@ procedure {:extern} rely();
 
 procedure {:extern} rely_transitive();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
+  ensures (mem == old(mem));
 
 implementation {:extern} rely_transitive()
 {
@@ -104,10 +101,7 @@ procedure main();
   free requires (memory_load64_le(mem, 69648bv64) == 416611827717bv64);
   free requires (memory_load64_le(mem, 69656bv64) == 68719476735bv64);
   free requires (memory_load64_le(mem, 69664bv64) == 8589934593bv64);
-  free requires (memory_load8_le(mem, 1956bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1957bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1958bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1959bv64) == 0bv8);
+  free requires (memory_load32_le(mem, 1956bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69016bv64) == 1808bv64);
   free requires (memory_load64_le(mem, 69024bv64) == 1728bv64);
   free requires (memory_load64_le(mem, 69616bv64) == 1812bv64);
@@ -115,10 +109,7 @@ procedure main();
   ensures (memory_load32_le(mem, $x_addr) == 6bv32);
   ensures (memory_load32_le(mem, bvadd64($a_addr, 4bv64)) == 4bv32);
   ensures (memory_load32_le(mem, bvadd64($a_addr, 0bv64)) == 1bv32);
-  free ensures (memory_load8_le(mem, 1956bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1957bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1958bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1959bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1956bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69016bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69024bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69616bv64) == 1812bv64);
diff --git a/src/test/correct/initialisation/gcc_O2/initialisation.expected b/src/test/correct/initialisation/gcc_O2/initialisation.expected
index efb62f192..c9f0e32be 100644
--- a/src/test/correct/initialisation/gcc_O2/initialisation.expected
+++ b/src/test/correct/initialisation/gcc_O2/initialisation.expected
@@ -22,7 +22,7 @@ const {:extern} $y_addr: bv64;
 axiom ($y_addr == 69672bv64);
 const {:extern} $z_addr: bv64;
 axiom ($z_addr == 69656bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
   false
 }
 
@@ -80,12 +80,9 @@ function {:extern} {:bvbuiltin "zero_extend 32"} zero_extend32_32(bv32) returns
 function {:extern} {:bvbuiltin "zero_extend 56"} zero_extend56_8(bv8) returns (bv64);
 procedure {:extern} rely();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
-  free ensures (memory_load8_le(mem, 1896bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1897bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1898bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1899bv64) == 0bv8);
+  ensures (mem == old(mem));
+  free ensures (memory_load32_le(mem, 1896bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69016bv64) == 1872bv64);
   free ensures (memory_load64_le(mem, 69024bv64) == 1792bv64);
   free ensures (memory_load64_le(mem, 69616bv64) == 1536bv64);
@@ -93,8 +90,8 @@ procedure {:extern} rely();
 
 procedure {:extern} rely_transitive();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
+  ensures (mem == old(mem));
 
 implementation {:extern} rely_transitive()
 {
@@ -115,10 +112,7 @@ procedure main();
   free requires (memory_load64_le(mem, 69656bv64) == 68719476735bv64);
   free requires (memory_load64_le(mem, 69664bv64) == 8589934593bv64);
   free requires (memory_load8_le(mem, 69672bv64) == 97bv8);
-  free requires (memory_load8_le(mem, 1896bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1897bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1898bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1899bv64) == 0bv8);
+  free requires (memory_load32_le(mem, 1896bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69016bv64) == 1872bv64);
   free requires (memory_load64_le(mem, 69024bv64) == 1792bv64);
   free requires (memory_load64_le(mem, 69616bv64) == 1536bv64);
@@ -126,10 +120,7 @@ procedure main();
   ensures (memory_load32_le(mem, $x_addr) == 6bv32);
   ensures (memory_load32_le(mem, bvadd64($a_addr, 4bv64)) == 4bv32);
   ensures (memory_load32_le(mem, bvadd64($a_addr, 0bv64)) == 1bv32);
-  free ensures (memory_load8_le(mem, 1896bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1897bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1898bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1899bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1896bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69016bv64) == 1872bv64);
   free ensures (memory_load64_le(mem, 69024bv64) == 1792bv64);
   free ensures (memory_load64_le(mem, 69616bv64) == 1536bv64);
diff --git a/src/test/correct/initialisation/gcc_O2/initialisation_gtirb.expected b/src/test/correct/initialisation/gcc_O2/initialisation_gtirb.expected
index cc20e1b32..aed04a776 100644
--- a/src/test/correct/initialisation/gcc_O2/initialisation_gtirb.expected
+++ b/src/test/correct/initialisation/gcc_O2/initialisation_gtirb.expected
@@ -22,7 +22,7 @@ const {:extern} $y_addr: bv64;
 axiom ($y_addr == 69672bv64);
 const {:extern} $z_addr: bv64;
 axiom ($z_addr == 69656bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
   false
 }
 
@@ -80,12 +80,9 @@ function {:extern} {:bvbuiltin "zero_extend 24"} zero_extend24_8(bv8) returns (b
 function {:extern} {:bvbuiltin "zero_extend 32"} zero_extend32_32(bv32) returns (bv64);
 procedure {:extern} rely();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
-  free ensures (memory_load8_le(mem, 1896bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1897bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1898bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1899bv64) == 0bv8);
+  ensures (mem == old(mem));
+  free ensures (memory_load32_le(mem, 1896bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69016bv64) == 1872bv64);
   free ensures (memory_load64_le(mem, 69024bv64) == 1792bv64);
   free ensures (memory_load64_le(mem, 69616bv64) == 1536bv64);
@@ -93,8 +90,8 @@ procedure {:extern} rely();
 
 procedure {:extern} rely_transitive();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
+  ensures (mem == old(mem));
 
 implementation {:extern} rely_transitive()
 {
@@ -115,10 +112,7 @@ procedure main();
   free requires (memory_load64_le(mem, 69656bv64) == 68719476735bv64);
   free requires (memory_load64_le(mem, 69664bv64) == 8589934593bv64);
   free requires (memory_load8_le(mem, 69672bv64) == 97bv8);
-  free requires (memory_load8_le(mem, 1896bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1897bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1898bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1899bv64) == 0bv8);
+  free requires (memory_load32_le(mem, 1896bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69016bv64) == 1872bv64);
   free requires (memory_load64_le(mem, 69024bv64) == 1792bv64);
   free requires (memory_load64_le(mem, 69616bv64) == 1536bv64);
@@ -126,10 +120,7 @@ procedure main();
   ensures (memory_load32_le(mem, $x_addr) == 6bv32);
   ensures (memory_load32_le(mem, bvadd64($a_addr, 4bv64)) == 4bv32);
   ensures (memory_load32_le(mem, bvadd64($a_addr, 0bv64)) == 1bv32);
-  free ensures (memory_load8_le(mem, 1896bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1897bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1898bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1899bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1896bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69016bv64) == 1872bv64);
   free ensures (memory_load64_le(mem, 69024bv64) == 1792bv64);
   free ensures (memory_load64_le(mem, 69616bv64) == 1536bv64);
diff --git a/src/test/correct/initialisation/gcc_pic/initialisation.expected b/src/test/correct/initialisation/gcc_pic/initialisation.expected
index ef5a7eb85..5a5a277e7 100644
--- a/src/test/correct/initialisation/gcc_pic/initialisation.expected
+++ b/src/test/correct/initialisation/gcc_pic/initialisation.expected
@@ -12,7 +12,7 @@ const {:extern} $y_addr: bv64;
 axiom ($y_addr == 69652bv64);
 const {:extern} $z_addr: bv64;
 axiom ($z_addr == 69656bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
   false
 }
 
@@ -70,25 +70,22 @@ function {:extern} {:bvbuiltin "zero_extend 32"} zero_extend32_32(bv32) returns
 function {:extern} {:bvbuiltin "zero_extend 56"} zero_extend56_8(bv8) returns (bv64);
 procedure {:extern} rely();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
-  free ensures (memory_load8_le(mem, 2084bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 2085bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 2086bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 2087bv64) == 0bv8);
-  free ensures (memory_load64_le(mem, 69608bv64) == 69652bv64);
+  ensures (mem == old(mem));
+  free ensures (memory_load32_le(mem, 2084bv64) == 131073bv32);
+  free ensures (memory_load64_le(mem, 68984bv64) == 1936bv64);
+  free ensures (memory_load64_le(mem, 68992bv64) == 1856bv64);
   free ensures (memory_load64_le(mem, 69576bv64) == 69656bv64);
-  free ensures (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free ensures (memory_load64_le(mem, 69616bv64) == 1940bv64);
   free ensures (memory_load64_le(mem, 69584bv64) == 69648bv64);
   free ensures (memory_load64_le(mem, 69600bv64) == 69664bv64);
-  free ensures (memory_load64_le(mem, 68984bv64) == 1936bv64);
-  free ensures (memory_load64_le(mem, 68992bv64) == 1856bv64);
+  free ensures (memory_load64_le(mem, 69608bv64) == 69652bv64);
+  free ensures (memory_load64_le(mem, 69616bv64) == 1940bv64);
+  free ensures (memory_load64_le(mem, 69640bv64) == 69640bv64);
 
 procedure {:extern} rely_transitive();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
+  ensures (mem == old(mem));
 
 implementation {:extern} rely_transitive()
 {
@@ -108,33 +105,27 @@ procedure main();
   free requires (memory_load64_le(mem, 69648bv64) == 416611827717bv64);
   free requires (memory_load64_le(mem, 69656bv64) == 68719476735bv64);
   free requires (memory_load64_le(mem, 69664bv64) == 8589934593bv64);
-  free requires (memory_load8_le(mem, 2084bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 2085bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 2086bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 2087bv64) == 0bv8);
-  free requires (memory_load64_le(mem, 69608bv64) == 69652bv64);
+  free requires (memory_load32_le(mem, 2084bv64) == 131073bv32);
+  free requires (memory_load64_le(mem, 68984bv64) == 1936bv64);
+  free requires (memory_load64_le(mem, 68992bv64) == 1856bv64);
   free requires (memory_load64_le(mem, 69576bv64) == 69656bv64);
-  free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free requires (memory_load64_le(mem, 69616bv64) == 1940bv64);
   free requires (memory_load64_le(mem, 69584bv64) == 69648bv64);
   free requires (memory_load64_le(mem, 69600bv64) == 69664bv64);
-  free requires (memory_load64_le(mem, 68984bv64) == 1936bv64);
-  free requires (memory_load64_le(mem, 68992bv64) == 1856bv64);
+  free requires (memory_load64_le(mem, 69608bv64) == 69652bv64);
+  free requires (memory_load64_le(mem, 69616bv64) == 1940bv64);
+  free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
   ensures (memory_load32_le(mem, $x_addr) == 6bv32);
   ensures (memory_load32_le(mem, bvadd64($a_addr, 4bv64)) == 4bv32);
   ensures (memory_load32_le(mem, bvadd64($a_addr, 0bv64)) == 1bv32);
-  free ensures (memory_load8_le(mem, 2084bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 2085bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 2086bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 2087bv64) == 0bv8);
-  free ensures (memory_load64_le(mem, 69608bv64) == 69652bv64);
+  free ensures (memory_load32_le(mem, 2084bv64) == 131073bv32);
+  free ensures (memory_load64_le(mem, 68984bv64) == 1936bv64);
+  free ensures (memory_load64_le(mem, 68992bv64) == 1856bv64);
   free ensures (memory_load64_le(mem, 69576bv64) == 69656bv64);
-  free ensures (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free ensures (memory_load64_le(mem, 69616bv64) == 1940bv64);
   free ensures (memory_load64_le(mem, 69584bv64) == 69648bv64);
   free ensures (memory_load64_le(mem, 69600bv64) == 69664bv64);
-  free ensures (memory_load64_le(mem, 68984bv64) == 1936bv64);
-  free ensures (memory_load64_le(mem, 68992bv64) == 1856bv64);
+  free ensures (memory_load64_le(mem, 69608bv64) == 69652bv64);
+  free ensures (memory_load64_le(mem, 69616bv64) == 1940bv64);
+  free ensures (memory_load64_le(mem, 69640bv64) == 69640bv64);
 
 implementation main()
 {
diff --git a/src/test/correct/initialisation/gcc_pic/initialisation_gtirb.expected b/src/test/correct/initialisation/gcc_pic/initialisation_gtirb.expected
index 0de8f82bf..bc4fb819f 100644
--- a/src/test/correct/initialisation/gcc_pic/initialisation_gtirb.expected
+++ b/src/test/correct/initialisation/gcc_pic/initialisation_gtirb.expected
@@ -12,7 +12,7 @@ const {:extern} $y_addr: bv64;
 axiom ($y_addr == 69652bv64);
 const {:extern} $z_addr: bv64;
 axiom ($z_addr == 69656bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
   false
 }
 
@@ -70,25 +70,22 @@ function {:extern} {:bvbuiltin "zero_extend 24"} zero_extend24_8(bv8) returns (b
 function {:extern} {:bvbuiltin "zero_extend 32"} zero_extend32_32(bv32) returns (bv64);
 procedure {:extern} rely();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
-  free ensures (memory_load8_le(mem, 2084bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 2085bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 2086bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 2087bv64) == 0bv8);
-  free ensures (memory_load64_le(mem, 69608bv64) == 69652bv64);
+  ensures (mem == old(mem));
+  free ensures (memory_load32_le(mem, 2084bv64) == 131073bv32);
+  free ensures (memory_load64_le(mem, 68984bv64) == 1936bv64);
+  free ensures (memory_load64_le(mem, 68992bv64) == 1856bv64);
   free ensures (memory_load64_le(mem, 69576bv64) == 69656bv64);
-  free ensures (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free ensures (memory_load64_le(mem, 69616bv64) == 1940bv64);
   free ensures (memory_load64_le(mem, 69584bv64) == 69648bv64);
   free ensures (memory_load64_le(mem, 69600bv64) == 69664bv64);
-  free ensures (memory_load64_le(mem, 68984bv64) == 1936bv64);
-  free ensures (memory_load64_le(mem, 68992bv64) == 1856bv64);
+  free ensures (memory_load64_le(mem, 69608bv64) == 69652bv64);
+  free ensures (memory_load64_le(mem, 69616bv64) == 1940bv64);
+  free ensures (memory_load64_le(mem, 69640bv64) == 69640bv64);
 
 procedure {:extern} rely_transitive();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
+  ensures (mem == old(mem));
 
 implementation {:extern} rely_transitive()
 {
@@ -108,33 +105,27 @@ procedure main();
   free requires (memory_load64_le(mem, 69648bv64) == 416611827717bv64);
   free requires (memory_load64_le(mem, 69656bv64) == 68719476735bv64);
   free requires (memory_load64_le(mem, 69664bv64) == 8589934593bv64);
-  free requires (memory_load8_le(mem, 2084bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 2085bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 2086bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 2087bv64) == 0bv8);
-  free requires (memory_load64_le(mem, 69608bv64) == 69652bv64);
+  free requires (memory_load32_le(mem, 2084bv64) == 131073bv32);
+  free requires (memory_load64_le(mem, 68984bv64) == 1936bv64);
+  free requires (memory_load64_le(mem, 68992bv64) == 1856bv64);
   free requires (memory_load64_le(mem, 69576bv64) == 69656bv64);
-  free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free requires (memory_load64_le(mem, 69616bv64) == 1940bv64);
   free requires (memory_load64_le(mem, 69584bv64) == 69648bv64);
   free requires (memory_load64_le(mem, 69600bv64) == 69664bv64);
-  free requires (memory_load64_le(mem, 68984bv64) == 1936bv64);
-  free requires (memory_load64_le(mem, 68992bv64) == 1856bv64);
+  free requires (memory_load64_le(mem, 69608bv64) == 69652bv64);
+  free requires (memory_load64_le(mem, 69616bv64) == 1940bv64);
+  free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
   ensures (memory_load32_le(mem, $x_addr) == 6bv32);
   ensures (memory_load32_le(mem, bvadd64($a_addr, 4bv64)) == 4bv32);
   ensures (memory_load32_le(mem, bvadd64($a_addr, 0bv64)) == 1bv32);
-  free ensures (memory_load8_le(mem, 2084bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 2085bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 2086bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 2087bv64) == 0bv8);
-  free ensures (memory_load64_le(mem, 69608bv64) == 69652bv64);
+  free ensures (memory_load32_le(mem, 2084bv64) == 131073bv32);
+  free ensures (memory_load64_le(mem, 68984bv64) == 1936bv64);
+  free ensures (memory_load64_le(mem, 68992bv64) == 1856bv64);
   free ensures (memory_load64_le(mem, 69576bv64) == 69656bv64);
-  free ensures (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free ensures (memory_load64_le(mem, 69616bv64) == 1940bv64);
   free ensures (memory_load64_le(mem, 69584bv64) == 69648bv64);
   free ensures (memory_load64_le(mem, 69600bv64) == 69664bv64);
-  free ensures (memory_load64_le(mem, 68984bv64) == 1936bv64);
-  free ensures (memory_load64_le(mem, 68992bv64) == 1856bv64);
+  free ensures (memory_load64_le(mem, 69608bv64) == 69652bv64);
+  free ensures (memory_load64_le(mem, 69616bv64) == 1940bv64);
+  free ensures (memory_load64_le(mem, 69640bv64) == 69640bv64);
 
 implementation main()
 {
diff --git a/src/test/correct/jumptable2/clang/jumptable2_gtirb.expected b/src/test/correct/jumptable2/clang/jumptable2_gtirb.expected
index 0ca38869d..aedfd59b2 100644
--- a/src/test/correct/jumptable2/clang/jumptable2_gtirb.expected
+++ b/src/test/correct/jumptable2/clang/jumptable2_gtirb.expected
@@ -30,7 +30,7 @@ const {:extern} $jump_table_addr: bv64;
 axiom ($jump_table_addr == 69688bv64);
 const {:extern} $x_addr: bv64;
 axiom ($x_addr == 69680bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
   false
 }
 
@@ -64,10 +64,6 @@ function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv6
   (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
-}
-
 function {:extern} memory_store32_le(memory: [bv64]bv8, index: bv64, value: bv32) returns ([bv64]bv8) {
   memory[index := value[8:0]][bvadd64(index, 1bv64) := value[16:8]][bvadd64(index, 2bv64) := value[24:16]][bvadd64(index, 3bv64) := value[32:24]]
 }
@@ -81,24 +77,21 @@ function {:extern} {:bvbuiltin "zero_extend 1"} zero_extend1_32(bv32) returns (b
 function {:extern} {:bvbuiltin "zero_extend 32"} zero_extend32_32(bv32) returns (bv64);
 procedure {:extern} rely();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
-  free ensures (memory_load8_le(mem, 2052bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 2053bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 2054bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 2055bv64) == 0bv8);
-  free ensures (memory_load64_le(mem, 69688bv64) == 1876bv64);
-  free ensures (memory_load64_le(mem, 69672bv64) == 69672bv64);
-  free ensures (memory_load64_le(mem, 69704bv64) == 1916bv64);
-  free ensures (memory_load64_le(mem, 69696bv64) == 1896bv64);
-  free ensures (memory_load64_le(mem, 69072bv64) == 1792bv64);
+  ensures (mem == old(mem));
+  free ensures (memory_load32_le(mem, 2052bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69064bv64) == 1872bv64);
+  free ensures (memory_load64_le(mem, 69072bv64) == 1792bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1936bv64);
+  free ensures (memory_load64_le(mem, 69672bv64) == 69672bv64);
+  free ensures (memory_load64_le(mem, 69688bv64) == 1876bv64);
+  free ensures (memory_load64_le(mem, 69696bv64) == 1896bv64);
+  free ensures (memory_load64_le(mem, 69704bv64) == 1916bv64);
 
 procedure {:extern} rely_transitive();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
+  ensures (mem == old(mem));
 
 implementation {:extern} rely_transitive()
 {
@@ -113,28 +106,22 @@ procedure {:extern} guarantee_reflexive();
 
 procedure add_two();
   modifies Gamma_R8, Gamma_R9, Gamma_mem, R8, R9, mem;
-  free requires (memory_load8_le(mem, 2052bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 2053bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 2054bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 2055bv64) == 0bv8);
-  free requires (memory_load64_le(mem, 69688bv64) == 1876bv64);
-  free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
-  free requires (memory_load64_le(mem, 69704bv64) == 1916bv64);
-  free requires (memory_load64_le(mem, 69696bv64) == 1896bv64);
-  free requires (memory_load64_le(mem, 69072bv64) == 1792bv64);
+  free requires (memory_load32_le(mem, 2052bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69064bv64) == 1872bv64);
+  free requires (memory_load64_le(mem, 69072bv64) == 1792bv64);
   free requires (memory_load64_le(mem, 69592bv64) == 1936bv64);
-  free ensures (memory_load8_le(mem, 2052bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 2053bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 2054bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 2055bv64) == 0bv8);
-  free ensures (memory_load64_le(mem, 69688bv64) == 1876bv64);
-  free ensures (memory_load64_le(mem, 69672bv64) == 69672bv64);
-  free ensures (memory_load64_le(mem, 69704bv64) == 1916bv64);
-  free ensures (memory_load64_le(mem, 69696bv64) == 1896bv64);
-  free ensures (memory_load64_le(mem, 69072bv64) == 1792bv64);
+  free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
+  free requires (memory_load64_le(mem, 69688bv64) == 1876bv64);
+  free requires (memory_load64_le(mem, 69696bv64) == 1896bv64);
+  free requires (memory_load64_le(mem, 69704bv64) == 1916bv64);
+  free ensures (memory_load32_le(mem, 2052bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69064bv64) == 1872bv64);
+  free ensures (memory_load64_le(mem, 69072bv64) == 1792bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1936bv64);
+  free ensures (memory_load64_le(mem, 69672bv64) == 69672bv64);
+  free ensures (memory_load64_le(mem, 69688bv64) == 1876bv64);
+  free ensures (memory_load64_le(mem, 69696bv64) == 1896bv64);
+  free ensures (memory_load64_le(mem, 69704bv64) == 1916bv64);
 
 implementation add_two()
 {
@@ -156,28 +143,22 @@ implementation add_two()
 
 procedure sub_seven();
   modifies CF, Gamma_CF, Gamma_NF, Gamma_R8, Gamma_R9, Gamma_VF, Gamma_ZF, Gamma_mem, NF, R8, R9, VF, ZF, mem;
-  free requires (memory_load8_le(mem, 2052bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 2053bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 2054bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 2055bv64) == 0bv8);
-  free requires (memory_load64_le(mem, 69688bv64) == 1876bv64);
-  free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
-  free requires (memory_load64_le(mem, 69704bv64) == 1916bv64);
-  free requires (memory_load64_le(mem, 69696bv64) == 1896bv64);
-  free requires (memory_load64_le(mem, 69072bv64) == 1792bv64);
+  free requires (memory_load32_le(mem, 2052bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69064bv64) == 1872bv64);
+  free requires (memory_load64_le(mem, 69072bv64) == 1792bv64);
   free requires (memory_load64_le(mem, 69592bv64) == 1936bv64);
-  free ensures (memory_load8_le(mem, 2052bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 2053bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 2054bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 2055bv64) == 0bv8);
-  free ensures (memory_load64_le(mem, 69688bv64) == 1876bv64);
-  free ensures (memory_load64_le(mem, 69672bv64) == 69672bv64);
-  free ensures (memory_load64_le(mem, 69704bv64) == 1916bv64);
-  free ensures (memory_load64_le(mem, 69696bv64) == 1896bv64);
-  free ensures (memory_load64_le(mem, 69072bv64) == 1792bv64);
+  free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
+  free requires (memory_load64_le(mem, 69688bv64) == 1876bv64);
+  free requires (memory_load64_le(mem, 69696bv64) == 1896bv64);
+  free requires (memory_load64_le(mem, 69704bv64) == 1916bv64);
+  free ensures (memory_load32_le(mem, 2052bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69064bv64) == 1872bv64);
+  free ensures (memory_load64_le(mem, 69072bv64) == 1792bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1936bv64);
+  free ensures (memory_load64_le(mem, 69672bv64) == 69672bv64);
+  free ensures (memory_load64_le(mem, 69688bv64) == 1876bv64);
+  free ensures (memory_load64_le(mem, 69696bv64) == 1896bv64);
+  free ensures (memory_load64_le(mem, 69704bv64) == 1916bv64);
 
 implementation sub_seven()
 {
@@ -206,28 +187,22 @@ implementation sub_seven()
 
 procedure add_six();
   modifies Gamma_R8, Gamma_R9, Gamma_mem, R8, R9, mem;
-  free requires (memory_load8_le(mem, 2052bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 2053bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 2054bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 2055bv64) == 0bv8);
-  free requires (memory_load64_le(mem, 69688bv64) == 1876bv64);
-  free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
-  free requires (memory_load64_le(mem, 69704bv64) == 1916bv64);
-  free requires (memory_load64_le(mem, 69696bv64) == 1896bv64);
-  free requires (memory_load64_le(mem, 69072bv64) == 1792bv64);
+  free requires (memory_load32_le(mem, 2052bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69064bv64) == 1872bv64);
+  free requires (memory_load64_le(mem, 69072bv64) == 1792bv64);
   free requires (memory_load64_le(mem, 69592bv64) == 1936bv64);
-  free ensures (memory_load8_le(mem, 2052bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 2053bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 2054bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 2055bv64) == 0bv8);
-  free ensures (memory_load64_le(mem, 69688bv64) == 1876bv64);
-  free ensures (memory_load64_le(mem, 69672bv64) == 69672bv64);
-  free ensures (memory_load64_le(mem, 69704bv64) == 1916bv64);
-  free ensures (memory_load64_le(mem, 69696bv64) == 1896bv64);
-  free ensures (memory_load64_le(mem, 69072bv64) == 1792bv64);
+  free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
+  free requires (memory_load64_le(mem, 69688bv64) == 1876bv64);
+  free requires (memory_load64_le(mem, 69696bv64) == 1896bv64);
+  free requires (memory_load64_le(mem, 69704bv64) == 1916bv64);
+  free ensures (memory_load32_le(mem, 2052bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69064bv64) == 1872bv64);
+  free ensures (memory_load64_le(mem, 69072bv64) == 1792bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1936bv64);
+  free ensures (memory_load64_le(mem, 69672bv64) == 69672bv64);
+  free ensures (memory_load64_le(mem, 69688bv64) == 1876bv64);
+  free ensures (memory_load64_le(mem, 69696bv64) == 1896bv64);
+  free ensures (memory_load64_le(mem, 69704bv64) == 1916bv64);
 
 implementation add_six()
 {
@@ -255,32 +230,26 @@ procedure main();
   free requires (memory_load64_le(mem, 69688bv64) == 1876bv64);
   free requires (memory_load64_le(mem, 69696bv64) == 1896bv64);
   free requires (memory_load64_le(mem, 69704bv64) == 1916bv64);
-  free requires (memory_load8_le(mem, 2052bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 2053bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 2054bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 2055bv64) == 0bv8);
-  free requires (memory_load64_le(mem, 69688bv64) == 1876bv64);
-  free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
-  free requires (memory_load64_le(mem, 69704bv64) == 1916bv64);
-  free requires (memory_load64_le(mem, 69696bv64) == 1896bv64);
-  free requires (memory_load64_le(mem, 69072bv64) == 1792bv64);
+  free requires (memory_load32_le(mem, 2052bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69064bv64) == 1872bv64);
+  free requires (memory_load64_le(mem, 69072bv64) == 1792bv64);
   free requires (memory_load64_le(mem, 69592bv64) == 1936bv64);
+  free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
+  free requires (memory_load64_le(mem, 69688bv64) == 1876bv64);
+  free requires (memory_load64_le(mem, 69696bv64) == 1896bv64);
+  free requires (memory_load64_le(mem, 69704bv64) == 1916bv64);
   free ensures (Gamma_R29 == old(Gamma_R29));
   free ensures (Gamma_R31 == old(Gamma_R31));
   free ensures (R29 == old(R29));
   free ensures (R31 == old(R31));
-  free ensures (memory_load8_le(mem, 2052bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 2053bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 2054bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 2055bv64) == 0bv8);
-  free ensures (memory_load64_le(mem, 69688bv64) == 1876bv64);
-  free ensures (memory_load64_le(mem, 69672bv64) == 69672bv64);
-  free ensures (memory_load64_le(mem, 69704bv64) == 1916bv64);
-  free ensures (memory_load64_le(mem, 69696bv64) == 1896bv64);
-  free ensures (memory_load64_le(mem, 69072bv64) == 1792bv64);
+  free ensures (memory_load32_le(mem, 2052bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69064bv64) == 1872bv64);
+  free ensures (memory_load64_le(mem, 69072bv64) == 1792bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1936bv64);
+  free ensures (memory_load64_le(mem, 69672bv64) == 69672bv64);
+  free ensures (memory_load64_le(mem, 69688bv64) == 1876bv64);
+  free ensures (memory_load64_le(mem, 69696bv64) == 1896bv64);
+  free ensures (memory_load64_le(mem, 69704bv64) == 1916bv64);
 
 implementation main()
 {
diff --git a/src/test/correct/jumptable2/clang_O2/jumptable2_gtirb.expected b/src/test/correct/jumptable2/clang_O2/jumptable2_gtirb.expected
index dc88e8297..37536bc1f 100644
--- a/src/test/correct/jumptable2/clang_O2/jumptable2_gtirb.expected
+++ b/src/test/correct/jumptable2/clang_O2/jumptable2_gtirb.expected
@@ -22,7 +22,7 @@ const {:extern} $jump_table_addr: bv64;
 axiom ($jump_table_addr == 69688bv64);
 const {:extern} $x_addr: bv64;
 axiom ($x_addr == 69680bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
   false
 }
 
@@ -52,10 +52,6 @@ function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv6
   (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
-}
-
 function {:extern} memory_store32_le(memory: [bv64]bv8, index: bv64, value: bv32) returns ([bv64]bv8) {
   memory[index := value[8:0]][bvadd64(index, 1bv64) := value[16:8]][bvadd64(index, 2bv64) := value[24:16]][bvadd64(index, 3bv64) := value[32:24]]
 }
@@ -67,24 +63,21 @@ function {:extern} memory_store64_le(memory: [bv64]bv8, index: bv64, value: bv64
 function {:extern} {:bvbuiltin "zero_extend 32"} zero_extend32_32(bv32) returns (bv64);
 procedure {:extern} rely();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
-  free ensures (memory_load8_le(mem, 2016bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 2017bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 2018bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 2019bv64) == 0bv8);
-  free ensures (memory_load64_le(mem, 69688bv64) == 1876bv64);
-  free ensures (memory_load64_le(mem, 69672bv64) == 69672bv64);
-  free ensures (memory_load64_le(mem, 69704bv64) == 1916bv64);
-  free ensures (memory_load64_le(mem, 69696bv64) == 1896bv64);
-  free ensures (memory_load64_le(mem, 69072bv64) == 1792bv64);
+  ensures (mem == old(mem));
+  free ensures (memory_load32_le(mem, 2016bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69064bv64) == 1872bv64);
+  free ensures (memory_load64_le(mem, 69072bv64) == 1792bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1936bv64);
+  free ensures (memory_load64_le(mem, 69672bv64) == 69672bv64);
+  free ensures (memory_load64_le(mem, 69688bv64) == 1876bv64);
+  free ensures (memory_load64_le(mem, 69696bv64) == 1896bv64);
+  free ensures (memory_load64_le(mem, 69704bv64) == 1916bv64);
 
 procedure {:extern} rely_transitive();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
+  ensures (mem == old(mem));
 
 implementation {:extern} rely_transitive()
 {
@@ -105,34 +98,28 @@ procedure main();
   free requires (memory_load64_le(mem, 69688bv64) == 1876bv64);
   free requires (memory_load64_le(mem, 69696bv64) == 1896bv64);
   free requires (memory_load64_le(mem, 69704bv64) == 1916bv64);
-  free requires (memory_load8_le(mem, 2016bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 2017bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 2018bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 2019bv64) == 0bv8);
-  free requires (memory_load64_le(mem, 69688bv64) == 1876bv64);
-  free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
-  free requires (memory_load64_le(mem, 69704bv64) == 1916bv64);
-  free requires (memory_load64_le(mem, 69696bv64) == 1896bv64);
-  free requires (memory_load64_le(mem, 69072bv64) == 1792bv64);
+  free requires (memory_load32_le(mem, 2016bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69064bv64) == 1872bv64);
+  free requires (memory_load64_le(mem, 69072bv64) == 1792bv64);
   free requires (memory_load64_le(mem, 69592bv64) == 1936bv64);
+  free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
+  free requires (memory_load64_le(mem, 69688bv64) == 1876bv64);
+  free requires (memory_load64_le(mem, 69696bv64) == 1896bv64);
+  free requires (memory_load64_le(mem, 69704bv64) == 1916bv64);
   free ensures (Gamma_R19 == old(Gamma_R19));
   free ensures (Gamma_R29 == old(Gamma_R29));
   free ensures (Gamma_R31 == old(Gamma_R31));
   free ensures (R19 == old(R19));
   free ensures (R29 == old(R29));
   free ensures (R31 == old(R31));
-  free ensures (memory_load8_le(mem, 2016bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 2017bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 2018bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 2019bv64) == 0bv8);
-  free ensures (memory_load64_le(mem, 69688bv64) == 1876bv64);
-  free ensures (memory_load64_le(mem, 69672bv64) == 69672bv64);
-  free ensures (memory_load64_le(mem, 69704bv64) == 1916bv64);
-  free ensures (memory_load64_le(mem, 69696bv64) == 1896bv64);
-  free ensures (memory_load64_le(mem, 69072bv64) == 1792bv64);
+  free ensures (memory_load32_le(mem, 2016bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69064bv64) == 1872bv64);
+  free ensures (memory_load64_le(mem, 69072bv64) == 1792bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1936bv64);
+  free ensures (memory_load64_le(mem, 69672bv64) == 69672bv64);
+  free ensures (memory_load64_le(mem, 69688bv64) == 1876bv64);
+  free ensures (memory_load64_le(mem, 69696bv64) == 1896bv64);
+  free ensures (memory_load64_le(mem, 69704bv64) == 1916bv64);
 
 implementation main()
 {
@@ -185,28 +172,22 @@ implementation main()
 
 procedure sub_seven();
   modifies Gamma_R8, Gamma_R9, Gamma_mem, R8, R9, mem;
-  free requires (memory_load8_le(mem, 2016bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 2017bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 2018bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 2019bv64) == 0bv8);
-  free requires (memory_load64_le(mem, 69688bv64) == 1876bv64);
-  free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
-  free requires (memory_load64_le(mem, 69704bv64) == 1916bv64);
-  free requires (memory_load64_le(mem, 69696bv64) == 1896bv64);
-  free requires (memory_load64_le(mem, 69072bv64) == 1792bv64);
+  free requires (memory_load32_le(mem, 2016bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69064bv64) == 1872bv64);
+  free requires (memory_load64_le(mem, 69072bv64) == 1792bv64);
   free requires (memory_load64_le(mem, 69592bv64) == 1936bv64);
-  free ensures (memory_load8_le(mem, 2016bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 2017bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 2018bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 2019bv64) == 0bv8);
-  free ensures (memory_load64_le(mem, 69688bv64) == 1876bv64);
-  free ensures (memory_load64_le(mem, 69672bv64) == 69672bv64);
-  free ensures (memory_load64_le(mem, 69704bv64) == 1916bv64);
-  free ensures (memory_load64_le(mem, 69696bv64) == 1896bv64);
-  free ensures (memory_load64_le(mem, 69072bv64) == 1792bv64);
+  free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
+  free requires (memory_load64_le(mem, 69688bv64) == 1876bv64);
+  free requires (memory_load64_le(mem, 69696bv64) == 1896bv64);
+  free requires (memory_load64_le(mem, 69704bv64) == 1916bv64);
+  free ensures (memory_load32_le(mem, 2016bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69064bv64) == 1872bv64);
+  free ensures (memory_load64_le(mem, 69072bv64) == 1792bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1936bv64);
+  free ensures (memory_load64_le(mem, 69672bv64) == 69672bv64);
+  free ensures (memory_load64_le(mem, 69688bv64) == 1876bv64);
+  free ensures (memory_load64_le(mem, 69696bv64) == 1896bv64);
+  free ensures (memory_load64_le(mem, 69704bv64) == 1916bv64);
 
 implementation sub_seven()
 {
@@ -228,28 +209,22 @@ implementation sub_seven()
 
 procedure add_two();
   modifies Gamma_R8, Gamma_R9, Gamma_mem, R8, R9, mem;
-  free requires (memory_load8_le(mem, 2016bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 2017bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 2018bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 2019bv64) == 0bv8);
-  free requires (memory_load64_le(mem, 69688bv64) == 1876bv64);
-  free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
-  free requires (memory_load64_le(mem, 69704bv64) == 1916bv64);
-  free requires (memory_load64_le(mem, 69696bv64) == 1896bv64);
-  free requires (memory_load64_le(mem, 69072bv64) == 1792bv64);
+  free requires (memory_load32_le(mem, 2016bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69064bv64) == 1872bv64);
+  free requires (memory_load64_le(mem, 69072bv64) == 1792bv64);
   free requires (memory_load64_le(mem, 69592bv64) == 1936bv64);
-  free ensures (memory_load8_le(mem, 2016bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 2017bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 2018bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 2019bv64) == 0bv8);
-  free ensures (memory_load64_le(mem, 69688bv64) == 1876bv64);
-  free ensures (memory_load64_le(mem, 69672bv64) == 69672bv64);
-  free ensures (memory_load64_le(mem, 69704bv64) == 1916bv64);
-  free ensures (memory_load64_le(mem, 69696bv64) == 1896bv64);
-  free ensures (memory_load64_le(mem, 69072bv64) == 1792bv64);
+  free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
+  free requires (memory_load64_le(mem, 69688bv64) == 1876bv64);
+  free requires (memory_load64_le(mem, 69696bv64) == 1896bv64);
+  free requires (memory_load64_le(mem, 69704bv64) == 1916bv64);
+  free ensures (memory_load32_le(mem, 2016bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69064bv64) == 1872bv64);
+  free ensures (memory_load64_le(mem, 69072bv64) == 1792bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1936bv64);
+  free ensures (memory_load64_le(mem, 69672bv64) == 69672bv64);
+  free ensures (memory_load64_le(mem, 69688bv64) == 1876bv64);
+  free ensures (memory_load64_le(mem, 69696bv64) == 1896bv64);
+  free ensures (memory_load64_le(mem, 69704bv64) == 1916bv64);
 
 implementation add_two()
 {
@@ -271,28 +246,22 @@ implementation add_two()
 
 procedure add_six();
   modifies Gamma_R8, Gamma_R9, Gamma_mem, R8, R9, mem;
-  free requires (memory_load8_le(mem, 2016bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 2017bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 2018bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 2019bv64) == 0bv8);
-  free requires (memory_load64_le(mem, 69688bv64) == 1876bv64);
-  free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
-  free requires (memory_load64_le(mem, 69704bv64) == 1916bv64);
-  free requires (memory_load64_le(mem, 69696bv64) == 1896bv64);
-  free requires (memory_load64_le(mem, 69072bv64) == 1792bv64);
+  free requires (memory_load32_le(mem, 2016bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69064bv64) == 1872bv64);
+  free requires (memory_load64_le(mem, 69072bv64) == 1792bv64);
   free requires (memory_load64_le(mem, 69592bv64) == 1936bv64);
-  free ensures (memory_load8_le(mem, 2016bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 2017bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 2018bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 2019bv64) == 0bv8);
-  free ensures (memory_load64_le(mem, 69688bv64) == 1876bv64);
-  free ensures (memory_load64_le(mem, 69672bv64) == 69672bv64);
-  free ensures (memory_load64_le(mem, 69704bv64) == 1916bv64);
-  free ensures (memory_load64_le(mem, 69696bv64) == 1896bv64);
-  free ensures (memory_load64_le(mem, 69072bv64) == 1792bv64);
+  free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
+  free requires (memory_load64_le(mem, 69688bv64) == 1876bv64);
+  free requires (memory_load64_le(mem, 69696bv64) == 1896bv64);
+  free requires (memory_load64_le(mem, 69704bv64) == 1916bv64);
+  free ensures (memory_load32_le(mem, 2016bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69064bv64) == 1872bv64);
+  free ensures (memory_load64_le(mem, 69072bv64) == 1792bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1936bv64);
+  free ensures (memory_load64_le(mem, 69672bv64) == 69672bv64);
+  free ensures (memory_load64_le(mem, 69688bv64) == 1876bv64);
+  free ensures (memory_load64_le(mem, 69696bv64) == 1896bv64);
+  free ensures (memory_load64_le(mem, 69704bv64) == 1916bv64);
 
 implementation add_six()
 {
diff --git a/src/test/correct/jumptable2/clang_pic/jumptable2_gtirb.expected b/src/test/correct/jumptable2/clang_pic/jumptable2_gtirb.expected
index 1cebf2f2d..829cdbe50 100644
--- a/src/test/correct/jumptable2/clang_pic/jumptable2_gtirb.expected
+++ b/src/test/correct/jumptable2/clang_pic/jumptable2_gtirb.expected
@@ -30,7 +30,7 @@ const {:extern} $jump_table_addr: bv64;
 axiom ($jump_table_addr == 69688bv64);
 const {:extern} $x_addr: bv64;
 axiom ($x_addr == 69680bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
   false
 }
 
@@ -64,10 +64,6 @@ function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv6
   (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
-}
-
 function {:extern} memory_store32_le(memory: [bv64]bv8, index: bv64, value: bv32) returns ([bv64]bv8) {
   memory[index := value[8:0]][bvadd64(index, 1bv64) := value[16:8]][bvadd64(index, 2bv64) := value[24:16]][bvadd64(index, 3bv64) := value[32:24]]
 }
@@ -81,26 +77,23 @@ function {:extern} {:bvbuiltin "zero_extend 1"} zero_extend1_32(bv32) returns (b
 function {:extern} {:bvbuiltin "zero_extend 32"} zero_extend32_32(bv32) returns (bv64);
 procedure {:extern} rely();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
-  free ensures (memory_load8_le(mem, 2124bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 2125bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 2126bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 2127bv64) == 0bv8);
-  free ensures (memory_load64_le(mem, 69584bv64) == 2012bv64);
-  free ensures (memory_load64_le(mem, 69688bv64) == 1940bv64);
+  ensures (mem == old(mem));
+  free ensures (memory_load32_le(mem, 2124bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69048bv64) == 1936bv64);
-  free ensures (memory_load64_le(mem, 69568bv64) == 69680bv64);
   free ensures (memory_load64_le(mem, 69056bv64) == 1856bv64);
+  free ensures (memory_load64_le(mem, 69568bv64) == 69680bv64);
+  free ensures (memory_load64_le(mem, 69584bv64) == 2012bv64);
+  free ensures (memory_load64_le(mem, 69600bv64) == 69688bv64);
   free ensures (memory_load64_le(mem, 69672bv64) == 69672bv64);
-  free ensures (memory_load64_le(mem, 69704bv64) == 1988bv64);
+  free ensures (memory_load64_le(mem, 69688bv64) == 1940bv64);
   free ensures (memory_load64_le(mem, 69696bv64) == 1964bv64);
-  free ensures (memory_load64_le(mem, 69600bv64) == 69688bv64);
+  free ensures (memory_load64_le(mem, 69704bv64) == 1988bv64);
 
 procedure {:extern} rely_transitive();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
+  ensures (mem == old(mem));
 
 implementation {:extern} rely_transitive()
 {
@@ -115,32 +108,26 @@ procedure {:extern} guarantee_reflexive();
 
 procedure add_two();
   modifies Gamma_R8, Gamma_R9, Gamma_mem, R8, R9, mem;
-  free requires (memory_load8_le(mem, 2124bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 2125bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 2126bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 2127bv64) == 0bv8);
-  free requires (memory_load64_le(mem, 69584bv64) == 2012bv64);
-  free requires (memory_load64_le(mem, 69688bv64) == 1940bv64);
+  free requires (memory_load32_le(mem, 2124bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69048bv64) == 1936bv64);
-  free requires (memory_load64_le(mem, 69568bv64) == 69680bv64);
   free requires (memory_load64_le(mem, 69056bv64) == 1856bv64);
+  free requires (memory_load64_le(mem, 69568bv64) == 69680bv64);
+  free requires (memory_load64_le(mem, 69584bv64) == 2012bv64);
+  free requires (memory_load64_le(mem, 69600bv64) == 69688bv64);
   free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
-  free requires (memory_load64_le(mem, 69704bv64) == 1988bv64);
+  free requires (memory_load64_le(mem, 69688bv64) == 1940bv64);
   free requires (memory_load64_le(mem, 69696bv64) == 1964bv64);
-  free requires (memory_load64_le(mem, 69600bv64) == 69688bv64);
-  free ensures (memory_load8_le(mem, 2124bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 2125bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 2126bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 2127bv64) == 0bv8);
-  free ensures (memory_load64_le(mem, 69584bv64) == 2012bv64);
-  free ensures (memory_load64_le(mem, 69688bv64) == 1940bv64);
+  free requires (memory_load64_le(mem, 69704bv64) == 1988bv64);
+  free ensures (memory_load32_le(mem, 2124bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69048bv64) == 1936bv64);
-  free ensures (memory_load64_le(mem, 69568bv64) == 69680bv64);
   free ensures (memory_load64_le(mem, 69056bv64) == 1856bv64);
+  free ensures (memory_load64_le(mem, 69568bv64) == 69680bv64);
+  free ensures (memory_load64_le(mem, 69584bv64) == 2012bv64);
+  free ensures (memory_load64_le(mem, 69600bv64) == 69688bv64);
   free ensures (memory_load64_le(mem, 69672bv64) == 69672bv64);
-  free ensures (memory_load64_le(mem, 69704bv64) == 1988bv64);
+  free ensures (memory_load64_le(mem, 69688bv64) == 1940bv64);
   free ensures (memory_load64_le(mem, 69696bv64) == 1964bv64);
-  free ensures (memory_load64_le(mem, 69600bv64) == 69688bv64);
+  free ensures (memory_load64_le(mem, 69704bv64) == 1988bv64);
 
 implementation add_two()
 {
@@ -164,32 +151,26 @@ implementation add_two()
 
 procedure add_six();
   modifies Gamma_R8, Gamma_R9, Gamma_mem, R8, R9, mem;
-  free requires (memory_load8_le(mem, 2124bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 2125bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 2126bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 2127bv64) == 0bv8);
-  free requires (memory_load64_le(mem, 69584bv64) == 2012bv64);
-  free requires (memory_load64_le(mem, 69688bv64) == 1940bv64);
+  free requires (memory_load32_le(mem, 2124bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69048bv64) == 1936bv64);
-  free requires (memory_load64_le(mem, 69568bv64) == 69680bv64);
   free requires (memory_load64_le(mem, 69056bv64) == 1856bv64);
+  free requires (memory_load64_le(mem, 69568bv64) == 69680bv64);
+  free requires (memory_load64_le(mem, 69584bv64) == 2012bv64);
+  free requires (memory_load64_le(mem, 69600bv64) == 69688bv64);
   free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
-  free requires (memory_load64_le(mem, 69704bv64) == 1988bv64);
+  free requires (memory_load64_le(mem, 69688bv64) == 1940bv64);
   free requires (memory_load64_le(mem, 69696bv64) == 1964bv64);
-  free requires (memory_load64_le(mem, 69600bv64) == 69688bv64);
-  free ensures (memory_load8_le(mem, 2124bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 2125bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 2126bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 2127bv64) == 0bv8);
-  free ensures (memory_load64_le(mem, 69584bv64) == 2012bv64);
-  free ensures (memory_load64_le(mem, 69688bv64) == 1940bv64);
+  free requires (memory_load64_le(mem, 69704bv64) == 1988bv64);
+  free ensures (memory_load32_le(mem, 2124bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69048bv64) == 1936bv64);
-  free ensures (memory_load64_le(mem, 69568bv64) == 69680bv64);
   free ensures (memory_load64_le(mem, 69056bv64) == 1856bv64);
+  free ensures (memory_load64_le(mem, 69568bv64) == 69680bv64);
+  free ensures (memory_load64_le(mem, 69584bv64) == 2012bv64);
+  free ensures (memory_load64_le(mem, 69600bv64) == 69688bv64);
   free ensures (memory_load64_le(mem, 69672bv64) == 69672bv64);
-  free ensures (memory_load64_le(mem, 69704bv64) == 1988bv64);
+  free ensures (memory_load64_le(mem, 69688bv64) == 1940bv64);
   free ensures (memory_load64_le(mem, 69696bv64) == 1964bv64);
-  free ensures (memory_load64_le(mem, 69600bv64) == 69688bv64);
+  free ensures (memory_load64_le(mem, 69704bv64) == 1988bv64);
 
 implementation add_six()
 {
@@ -219,36 +200,30 @@ procedure main();
   free requires (memory_load64_le(mem, 69688bv64) == 1940bv64);
   free requires (memory_load64_le(mem, 69696bv64) == 1964bv64);
   free requires (memory_load64_le(mem, 69704bv64) == 1988bv64);
-  free requires (memory_load8_le(mem, 2124bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 2125bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 2126bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 2127bv64) == 0bv8);
-  free requires (memory_load64_le(mem, 69584bv64) == 2012bv64);
-  free requires (memory_load64_le(mem, 69688bv64) == 1940bv64);
+  free requires (memory_load32_le(mem, 2124bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69048bv64) == 1936bv64);
-  free requires (memory_load64_le(mem, 69568bv64) == 69680bv64);
   free requires (memory_load64_le(mem, 69056bv64) == 1856bv64);
+  free requires (memory_load64_le(mem, 69568bv64) == 69680bv64);
+  free requires (memory_load64_le(mem, 69584bv64) == 2012bv64);
+  free requires (memory_load64_le(mem, 69600bv64) == 69688bv64);
   free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
-  free requires (memory_load64_le(mem, 69704bv64) == 1988bv64);
+  free requires (memory_load64_le(mem, 69688bv64) == 1940bv64);
   free requires (memory_load64_le(mem, 69696bv64) == 1964bv64);
-  free requires (memory_load64_le(mem, 69600bv64) == 69688bv64);
+  free requires (memory_load64_le(mem, 69704bv64) == 1988bv64);
   free ensures (Gamma_R29 == old(Gamma_R29));
   free ensures (Gamma_R31 == old(Gamma_R31));
   free ensures (R29 == old(R29));
   free ensures (R31 == old(R31));
-  free ensures (memory_load8_le(mem, 2124bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 2125bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 2126bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 2127bv64) == 0bv8);
-  free ensures (memory_load64_le(mem, 69584bv64) == 2012bv64);
-  free ensures (memory_load64_le(mem, 69688bv64) == 1940bv64);
+  free ensures (memory_load32_le(mem, 2124bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69048bv64) == 1936bv64);
-  free ensures (memory_load64_le(mem, 69568bv64) == 69680bv64);
   free ensures (memory_load64_le(mem, 69056bv64) == 1856bv64);
+  free ensures (memory_load64_le(mem, 69568bv64) == 69680bv64);
+  free ensures (memory_load64_le(mem, 69584bv64) == 2012bv64);
+  free ensures (memory_load64_le(mem, 69600bv64) == 69688bv64);
   free ensures (memory_load64_le(mem, 69672bv64) == 69672bv64);
-  free ensures (memory_load64_le(mem, 69704bv64) == 1988bv64);
+  free ensures (memory_load64_le(mem, 69688bv64) == 1940bv64);
   free ensures (memory_load64_le(mem, 69696bv64) == 1964bv64);
-  free ensures (memory_load64_le(mem, 69600bv64) == 69688bv64);
+  free ensures (memory_load64_le(mem, 69704bv64) == 1988bv64);
 
 implementation main()
 {
@@ -315,32 +290,26 @@ implementation main()
 
 procedure sub_seven();
   modifies CF, Gamma_CF, Gamma_NF, Gamma_R8, Gamma_R9, Gamma_VF, Gamma_ZF, Gamma_mem, NF, R8, R9, VF, ZF, mem;
-  free requires (memory_load8_le(mem, 2124bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 2125bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 2126bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 2127bv64) == 0bv8);
-  free requires (memory_load64_le(mem, 69584bv64) == 2012bv64);
-  free requires (memory_load64_le(mem, 69688bv64) == 1940bv64);
+  free requires (memory_load32_le(mem, 2124bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69048bv64) == 1936bv64);
-  free requires (memory_load64_le(mem, 69568bv64) == 69680bv64);
   free requires (memory_load64_le(mem, 69056bv64) == 1856bv64);
+  free requires (memory_load64_le(mem, 69568bv64) == 69680bv64);
+  free requires (memory_load64_le(mem, 69584bv64) == 2012bv64);
+  free requires (memory_load64_le(mem, 69600bv64) == 69688bv64);
   free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
-  free requires (memory_load64_le(mem, 69704bv64) == 1988bv64);
+  free requires (memory_load64_le(mem, 69688bv64) == 1940bv64);
   free requires (memory_load64_le(mem, 69696bv64) == 1964bv64);
-  free requires (memory_load64_le(mem, 69600bv64) == 69688bv64);
-  free ensures (memory_load8_le(mem, 2124bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 2125bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 2126bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 2127bv64) == 0bv8);
-  free ensures (memory_load64_le(mem, 69584bv64) == 2012bv64);
-  free ensures (memory_load64_le(mem, 69688bv64) == 1940bv64);
+  free requires (memory_load64_le(mem, 69704bv64) == 1988bv64);
+  free ensures (memory_load32_le(mem, 2124bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69048bv64) == 1936bv64);
-  free ensures (memory_load64_le(mem, 69568bv64) == 69680bv64);
   free ensures (memory_load64_le(mem, 69056bv64) == 1856bv64);
+  free ensures (memory_load64_le(mem, 69568bv64) == 69680bv64);
+  free ensures (memory_load64_le(mem, 69584bv64) == 2012bv64);
+  free ensures (memory_load64_le(mem, 69600bv64) == 69688bv64);
   free ensures (memory_load64_le(mem, 69672bv64) == 69672bv64);
-  free ensures (memory_load64_le(mem, 69704bv64) == 1988bv64);
+  free ensures (memory_load64_le(mem, 69688bv64) == 1940bv64);
   free ensures (memory_load64_le(mem, 69696bv64) == 1964bv64);
-  free ensures (memory_load64_le(mem, 69600bv64) == 69688bv64);
+  free ensures (memory_load64_le(mem, 69704bv64) == 1988bv64);
 
 implementation sub_seven()
 {
diff --git a/src/test/correct/jumptable2/gcc/jumptable2_gtirb.expected b/src/test/correct/jumptable2/gcc/jumptable2_gtirb.expected
index 37f9a52df..9c87ecd7c 100644
--- a/src/test/correct/jumptable2/gcc/jumptable2_gtirb.expected
+++ b/src/test/correct/jumptable2/gcc/jumptable2_gtirb.expected
@@ -18,7 +18,7 @@ const {:extern} $jump_table_addr: bv64;
 axiom ($jump_table_addr == 69656bv64);
 const {:extern} $x_addr: bv64;
 axiom ($x_addr == 69648bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
   false
 }
 
@@ -48,10 +48,6 @@ function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv6
   (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
-}
-
 function {:extern} memory_store32_le(memory: [bv64]bv8, index: bv64, value: bv32) returns ([bv64]bv8) {
   memory[index := value[8:0]][bvadd64(index, 1bv64) := value[16:8]][bvadd64(index, 2bv64) := value[24:16]][bvadd64(index, 3bv64) := value[32:24]]
 }
@@ -63,24 +59,21 @@ function {:extern} memory_store64_le(memory: [bv64]bv8, index: bv64, value: bv64
 function {:extern} {:bvbuiltin "zero_extend 32"} zero_extend32_32(bv32) returns (bv64);
 procedure {:extern} rely();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
-  free ensures (memory_load8_le(mem, 2080bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 2081bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 2082bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 2083bv64) == 0bv8);
+  ensures (mem == old(mem));
+  free ensures (memory_load32_le(mem, 2080bv64) == 131073bv32);
+  free ensures (memory_load64_le(mem, 69016bv64) == 1872bv64);
+  free ensures (memory_load64_le(mem, 69024bv64) == 1792bv64);
   free ensures (memory_load64_le(mem, 69616bv64) == 1984bv64);
+  free ensures (memory_load64_le(mem, 69640bv64) == 69640bv64);
   free ensures (memory_load64_le(mem, 69656bv64) == 1876bv64);
-  free ensures (memory_load64_le(mem, 69016bv64) == 1872bv64);
   free ensures (memory_load64_le(mem, 69664bv64) == 1912bv64);
-  free ensures (memory_load64_le(mem, 69024bv64) == 1792bv64);
   free ensures (memory_load64_le(mem, 69672bv64) == 1948bv64);
-  free ensures (memory_load64_le(mem, 69640bv64) == 69640bv64);
 
 procedure {:extern} rely_transitive();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
+  ensures (mem == old(mem));
 
 implementation {:extern} rely_transitive()
 {
@@ -95,28 +88,22 @@ procedure {:extern} guarantee_reflexive();
 
 procedure add_two();
   modifies Gamma_R0, Gamma_R1, Gamma_mem, R0, R1, mem;
-  free requires (memory_load8_le(mem, 2080bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 2081bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 2082bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 2083bv64) == 0bv8);
+  free requires (memory_load32_le(mem, 2080bv64) == 131073bv32);
+  free requires (memory_load64_le(mem, 69016bv64) == 1872bv64);
+  free requires (memory_load64_le(mem, 69024bv64) == 1792bv64);
   free requires (memory_load64_le(mem, 69616bv64) == 1984bv64);
+  free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
   free requires (memory_load64_le(mem, 69656bv64) == 1876bv64);
-  free requires (memory_load64_le(mem, 69016bv64) == 1872bv64);
   free requires (memory_load64_le(mem, 69664bv64) == 1912bv64);
-  free requires (memory_load64_le(mem, 69024bv64) == 1792bv64);
   free requires (memory_load64_le(mem, 69672bv64) == 1948bv64);
-  free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free ensures (memory_load8_le(mem, 2080bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 2081bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 2082bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 2083bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 2080bv64) == 131073bv32);
+  free ensures (memory_load64_le(mem, 69016bv64) == 1872bv64);
+  free ensures (memory_load64_le(mem, 69024bv64) == 1792bv64);
   free ensures (memory_load64_le(mem, 69616bv64) == 1984bv64);
+  free ensures (memory_load64_le(mem, 69640bv64) == 69640bv64);
   free ensures (memory_load64_le(mem, 69656bv64) == 1876bv64);
-  free ensures (memory_load64_le(mem, 69016bv64) == 1872bv64);
   free ensures (memory_load64_le(mem, 69664bv64) == 1912bv64);
-  free ensures (memory_load64_le(mem, 69024bv64) == 1792bv64);
   free ensures (memory_load64_le(mem, 69672bv64) == 1948bv64);
-  free ensures (memory_load64_le(mem, 69640bv64) == 69640bv64);
 
 implementation add_two()
 {
@@ -141,28 +128,22 @@ implementation add_two()
 
 procedure sub_seven();
   modifies Gamma_R0, Gamma_R1, Gamma_mem, R0, R1, mem;
-  free requires (memory_load8_le(mem, 2080bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 2081bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 2082bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 2083bv64) == 0bv8);
+  free requires (memory_load32_le(mem, 2080bv64) == 131073bv32);
+  free requires (memory_load64_le(mem, 69016bv64) == 1872bv64);
+  free requires (memory_load64_le(mem, 69024bv64) == 1792bv64);
   free requires (memory_load64_le(mem, 69616bv64) == 1984bv64);
+  free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
   free requires (memory_load64_le(mem, 69656bv64) == 1876bv64);
-  free requires (memory_load64_le(mem, 69016bv64) == 1872bv64);
   free requires (memory_load64_le(mem, 69664bv64) == 1912bv64);
-  free requires (memory_load64_le(mem, 69024bv64) == 1792bv64);
   free requires (memory_load64_le(mem, 69672bv64) == 1948bv64);
-  free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free ensures (memory_load8_le(mem, 2080bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 2081bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 2082bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 2083bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 2080bv64) == 131073bv32);
+  free ensures (memory_load64_le(mem, 69016bv64) == 1872bv64);
+  free ensures (memory_load64_le(mem, 69024bv64) == 1792bv64);
   free ensures (memory_load64_le(mem, 69616bv64) == 1984bv64);
+  free ensures (memory_load64_le(mem, 69640bv64) == 69640bv64);
   free ensures (memory_load64_le(mem, 69656bv64) == 1876bv64);
-  free ensures (memory_load64_le(mem, 69016bv64) == 1872bv64);
   free ensures (memory_load64_le(mem, 69664bv64) == 1912bv64);
-  free ensures (memory_load64_le(mem, 69024bv64) == 1792bv64);
   free ensures (memory_load64_le(mem, 69672bv64) == 1948bv64);
-  free ensures (memory_load64_le(mem, 69640bv64) == 69640bv64);
 
 implementation sub_seven()
 {
@@ -187,28 +168,22 @@ implementation sub_seven()
 
 procedure add_six();
   modifies Gamma_R0, Gamma_R1, Gamma_mem, R0, R1, mem;
-  free requires (memory_load8_le(mem, 2080bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 2081bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 2082bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 2083bv64) == 0bv8);
+  free requires (memory_load32_le(mem, 2080bv64) == 131073bv32);
+  free requires (memory_load64_le(mem, 69016bv64) == 1872bv64);
+  free requires (memory_load64_le(mem, 69024bv64) == 1792bv64);
   free requires (memory_load64_le(mem, 69616bv64) == 1984bv64);
+  free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
   free requires (memory_load64_le(mem, 69656bv64) == 1876bv64);
-  free requires (memory_load64_le(mem, 69016bv64) == 1872bv64);
   free requires (memory_load64_le(mem, 69664bv64) == 1912bv64);
-  free requires (memory_load64_le(mem, 69024bv64) == 1792bv64);
   free requires (memory_load64_le(mem, 69672bv64) == 1948bv64);
-  free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free ensures (memory_load8_le(mem, 2080bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 2081bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 2082bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 2083bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 2080bv64) == 131073bv32);
+  free ensures (memory_load64_le(mem, 69016bv64) == 1872bv64);
+  free ensures (memory_load64_le(mem, 69024bv64) == 1792bv64);
   free ensures (memory_load64_le(mem, 69616bv64) == 1984bv64);
+  free ensures (memory_load64_le(mem, 69640bv64) == 69640bv64);
   free ensures (memory_load64_le(mem, 69656bv64) == 1876bv64);
-  free ensures (memory_load64_le(mem, 69016bv64) == 1872bv64);
   free ensures (memory_load64_le(mem, 69664bv64) == 1912bv64);
-  free ensures (memory_load64_le(mem, 69024bv64) == 1792bv64);
   free ensures (memory_load64_le(mem, 69672bv64) == 1948bv64);
-  free ensures (memory_load64_le(mem, 69640bv64) == 69640bv64);
 
 implementation add_six()
 {
@@ -239,32 +214,26 @@ procedure main();
   free requires (memory_load64_le(mem, 69656bv64) == 1876bv64);
   free requires (memory_load64_le(mem, 69664bv64) == 1912bv64);
   free requires (memory_load64_le(mem, 69672bv64) == 1948bv64);
-  free requires (memory_load8_le(mem, 2080bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 2081bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 2082bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 2083bv64) == 0bv8);
+  free requires (memory_load32_le(mem, 2080bv64) == 131073bv32);
+  free requires (memory_load64_le(mem, 69016bv64) == 1872bv64);
+  free requires (memory_load64_le(mem, 69024bv64) == 1792bv64);
   free requires (memory_load64_le(mem, 69616bv64) == 1984bv64);
+  free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
   free requires (memory_load64_le(mem, 69656bv64) == 1876bv64);
-  free requires (memory_load64_le(mem, 69016bv64) == 1872bv64);
   free requires (memory_load64_le(mem, 69664bv64) == 1912bv64);
-  free requires (memory_load64_le(mem, 69024bv64) == 1792bv64);
   free requires (memory_load64_le(mem, 69672bv64) == 1948bv64);
-  free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
   free ensures (Gamma_R29 == old(Gamma_R29));
   free ensures (Gamma_R31 == old(Gamma_R31));
   free ensures (R29 == old(R29));
   free ensures (R31 == old(R31));
-  free ensures (memory_load8_le(mem, 2080bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 2081bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 2082bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 2083bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 2080bv64) == 131073bv32);
+  free ensures (memory_load64_le(mem, 69016bv64) == 1872bv64);
+  free ensures (memory_load64_le(mem, 69024bv64) == 1792bv64);
   free ensures (memory_load64_le(mem, 69616bv64) == 1984bv64);
+  free ensures (memory_load64_le(mem, 69640bv64) == 69640bv64);
   free ensures (memory_load64_le(mem, 69656bv64) == 1876bv64);
-  free ensures (memory_load64_le(mem, 69016bv64) == 1872bv64);
   free ensures (memory_load64_le(mem, 69664bv64) == 1912bv64);
-  free ensures (memory_load64_le(mem, 69024bv64) == 1792bv64);
   free ensures (memory_load64_le(mem, 69672bv64) == 1948bv64);
-  free ensures (memory_load64_le(mem, 69640bv64) == 69640bv64);
 
 implementation main()
 {
diff --git a/src/test/correct/jumptable2/gcc_O2/jumptable2_gtirb.expected b/src/test/correct/jumptable2/gcc_O2/jumptable2_gtirb.expected
index 5c232874f..f0ab465db 100644
--- a/src/test/correct/jumptable2/gcc_O2/jumptable2_gtirb.expected
+++ b/src/test/correct/jumptable2/gcc_O2/jumptable2_gtirb.expected
@@ -20,7 +20,7 @@ const {:extern} $jump_table_addr: bv64;
 axiom ($jump_table_addr == 69656bv64);
 const {:extern} $x_addr: bv64;
 axiom ($x_addr == 69648bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
   false
 }
 
@@ -50,10 +50,6 @@ function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv6
   (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
-}
-
 function {:extern} memory_store32_le(memory: [bv64]bv8, index: bv64, value: bv32) returns ([bv64]bv8) {
   memory[index := value[8:0]][bvadd64(index, 1bv64) := value[16:8]][bvadd64(index, 2bv64) := value[24:16]][bvadd64(index, 3bv64) := value[32:24]]
 }
@@ -65,24 +61,21 @@ function {:extern} memory_store64_le(memory: [bv64]bv8, index: bv64, value: bv64
 function {:extern} {:bvbuiltin "zero_extend 32"} zero_extend32_32(bv32) returns (bv64);
 procedure {:extern} rely();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
-  free ensures (memory_load8_le(mem, 2040bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 2041bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 2042bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 2043bv64) == 0bv8);
+  ensures (mem == old(mem));
+  free ensures (memory_load32_le(mem, 2040bv64) == 131073bv32);
+  free ensures (memory_load64_le(mem, 69016bv64) == 1936bv64);
+  free ensures (memory_load64_le(mem, 69024bv64) == 1856bv64);
   free ensures (memory_load64_le(mem, 69616bv64) == 1600bv64);
+  free ensures (memory_load64_le(mem, 69640bv64) == 69640bv64);
   free ensures (memory_load64_le(mem, 69656bv64) == 1952bv64);
-  free ensures (memory_load64_le(mem, 69016bv64) == 1936bv64);
   free ensures (memory_load64_le(mem, 69664bv64) == 1972bv64);
-  free ensures (memory_load64_le(mem, 69024bv64) == 1856bv64);
   free ensures (memory_load64_le(mem, 69672bv64) == 2000bv64);
-  free ensures (memory_load64_le(mem, 69640bv64) == 69640bv64);
 
 procedure {:extern} rely_transitive();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
+  ensures (mem == old(mem));
 
 implementation {:extern} rely_transitive()
 {
@@ -97,28 +90,22 @@ procedure {:extern} guarantee_reflexive();
 
 procedure add_two();
   modifies Gamma_R0, Gamma_R1, Gamma_mem, R0, R1, mem;
-  free requires (memory_load8_le(mem, 2040bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 2041bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 2042bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 2043bv64) == 0bv8);
+  free requires (memory_load32_le(mem, 2040bv64) == 131073bv32);
+  free requires (memory_load64_le(mem, 69016bv64) == 1936bv64);
+  free requires (memory_load64_le(mem, 69024bv64) == 1856bv64);
   free requires (memory_load64_le(mem, 69616bv64) == 1600bv64);
+  free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
   free requires (memory_load64_le(mem, 69656bv64) == 1952bv64);
-  free requires (memory_load64_le(mem, 69016bv64) == 1936bv64);
   free requires (memory_load64_le(mem, 69664bv64) == 1972bv64);
-  free requires (memory_load64_le(mem, 69024bv64) == 1856bv64);
   free requires (memory_load64_le(mem, 69672bv64) == 2000bv64);
-  free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free ensures (memory_load8_le(mem, 2040bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 2041bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 2042bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 2043bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 2040bv64) == 131073bv32);
+  free ensures (memory_load64_le(mem, 69016bv64) == 1936bv64);
+  free ensures (memory_load64_le(mem, 69024bv64) == 1856bv64);
   free ensures (memory_load64_le(mem, 69616bv64) == 1600bv64);
+  free ensures (memory_load64_le(mem, 69640bv64) == 69640bv64);
   free ensures (memory_load64_le(mem, 69656bv64) == 1952bv64);
-  free ensures (memory_load64_le(mem, 69016bv64) == 1936bv64);
   free ensures (memory_load64_le(mem, 69664bv64) == 1972bv64);
-  free ensures (memory_load64_le(mem, 69024bv64) == 1856bv64);
   free ensures (memory_load64_le(mem, 69672bv64) == 2000bv64);
-  free ensures (memory_load64_le(mem, 69640bv64) == 69640bv64);
 
 implementation add_two()
 {
@@ -146,34 +133,28 @@ procedure main();
   free requires (memory_load64_le(mem, 69656bv64) == 1952bv64);
   free requires (memory_load64_le(mem, 69664bv64) == 1972bv64);
   free requires (memory_load64_le(mem, 69672bv64) == 2000bv64);
-  free requires (memory_load8_le(mem, 2040bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 2041bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 2042bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 2043bv64) == 0bv8);
+  free requires (memory_load32_le(mem, 2040bv64) == 131073bv32);
+  free requires (memory_load64_le(mem, 69016bv64) == 1936bv64);
+  free requires (memory_load64_le(mem, 69024bv64) == 1856bv64);
   free requires (memory_load64_le(mem, 69616bv64) == 1600bv64);
+  free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
   free requires (memory_load64_le(mem, 69656bv64) == 1952bv64);
-  free requires (memory_load64_le(mem, 69016bv64) == 1936bv64);
   free requires (memory_load64_le(mem, 69664bv64) == 1972bv64);
-  free requires (memory_load64_le(mem, 69024bv64) == 1856bv64);
   free requires (memory_load64_le(mem, 69672bv64) == 2000bv64);
-  free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
   free ensures (Gamma_R19 == old(Gamma_R19));
   free ensures (Gamma_R29 == old(Gamma_R29));
   free ensures (Gamma_R31 == old(Gamma_R31));
   free ensures (R19 == old(R19));
   free ensures (R29 == old(R29));
   free ensures (R31 == old(R31));
-  free ensures (memory_load8_le(mem, 2040bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 2041bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 2042bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 2043bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 2040bv64) == 131073bv32);
+  free ensures (memory_load64_le(mem, 69016bv64) == 1936bv64);
+  free ensures (memory_load64_le(mem, 69024bv64) == 1856bv64);
   free ensures (memory_load64_le(mem, 69616bv64) == 1600bv64);
+  free ensures (memory_load64_le(mem, 69640bv64) == 69640bv64);
   free ensures (memory_load64_le(mem, 69656bv64) == 1952bv64);
-  free ensures (memory_load64_le(mem, 69016bv64) == 1936bv64);
   free ensures (memory_load64_le(mem, 69664bv64) == 1972bv64);
-  free ensures (memory_load64_le(mem, 69024bv64) == 1856bv64);
   free ensures (memory_load64_le(mem, 69672bv64) == 2000bv64);
-  free ensures (memory_load64_le(mem, 69640bv64) == 69640bv64);
 
 implementation main()
 {
@@ -226,28 +207,22 @@ implementation main()
 
 procedure sub_seven();
   modifies Gamma_R0, Gamma_R1, Gamma_mem, R0, R1, mem;
-  free requires (memory_load8_le(mem, 2040bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 2041bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 2042bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 2043bv64) == 0bv8);
+  free requires (memory_load32_le(mem, 2040bv64) == 131073bv32);
+  free requires (memory_load64_le(mem, 69016bv64) == 1936bv64);
+  free requires (memory_load64_le(mem, 69024bv64) == 1856bv64);
   free requires (memory_load64_le(mem, 69616bv64) == 1600bv64);
+  free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
   free requires (memory_load64_le(mem, 69656bv64) == 1952bv64);
-  free requires (memory_load64_le(mem, 69016bv64) == 1936bv64);
   free requires (memory_load64_le(mem, 69664bv64) == 1972bv64);
-  free requires (memory_load64_le(mem, 69024bv64) == 1856bv64);
   free requires (memory_load64_le(mem, 69672bv64) == 2000bv64);
-  free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free ensures (memory_load8_le(mem, 2040bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 2041bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 2042bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 2043bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 2040bv64) == 131073bv32);
+  free ensures (memory_load64_le(mem, 69016bv64) == 1936bv64);
+  free ensures (memory_load64_le(mem, 69024bv64) == 1856bv64);
   free ensures (memory_load64_le(mem, 69616bv64) == 1600bv64);
+  free ensures (memory_load64_le(mem, 69640bv64) == 69640bv64);
   free ensures (memory_load64_le(mem, 69656bv64) == 1952bv64);
-  free ensures (memory_load64_le(mem, 69016bv64) == 1936bv64);
   free ensures (memory_load64_le(mem, 69664bv64) == 1972bv64);
-  free ensures (memory_load64_le(mem, 69024bv64) == 1856bv64);
   free ensures (memory_load64_le(mem, 69672bv64) == 2000bv64);
-  free ensures (memory_load64_le(mem, 69640bv64) == 69640bv64);
 
 implementation sub_seven()
 {
@@ -269,28 +244,22 @@ implementation sub_seven()
 
 procedure add_six();
   modifies Gamma_R0, Gamma_R1, Gamma_mem, R0, R1, mem;
-  free requires (memory_load8_le(mem, 2040bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 2041bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 2042bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 2043bv64) == 0bv8);
+  free requires (memory_load32_le(mem, 2040bv64) == 131073bv32);
+  free requires (memory_load64_le(mem, 69016bv64) == 1936bv64);
+  free requires (memory_load64_le(mem, 69024bv64) == 1856bv64);
   free requires (memory_load64_le(mem, 69616bv64) == 1600bv64);
+  free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
   free requires (memory_load64_le(mem, 69656bv64) == 1952bv64);
-  free requires (memory_load64_le(mem, 69016bv64) == 1936bv64);
   free requires (memory_load64_le(mem, 69664bv64) == 1972bv64);
-  free requires (memory_load64_le(mem, 69024bv64) == 1856bv64);
   free requires (memory_load64_le(mem, 69672bv64) == 2000bv64);
-  free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free ensures (memory_load8_le(mem, 2040bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 2041bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 2042bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 2043bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 2040bv64) == 131073bv32);
+  free ensures (memory_load64_le(mem, 69016bv64) == 1936bv64);
+  free ensures (memory_load64_le(mem, 69024bv64) == 1856bv64);
   free ensures (memory_load64_le(mem, 69616bv64) == 1600bv64);
+  free ensures (memory_load64_le(mem, 69640bv64) == 69640bv64);
   free ensures (memory_load64_le(mem, 69656bv64) == 1952bv64);
-  free ensures (memory_load64_le(mem, 69016bv64) == 1936bv64);
   free ensures (memory_load64_le(mem, 69664bv64) == 1972bv64);
-  free ensures (memory_load64_le(mem, 69024bv64) == 1856bv64);
   free ensures (memory_load64_le(mem, 69672bv64) == 2000bv64);
-  free ensures (memory_load64_le(mem, 69640bv64) == 69640bv64);
 
 implementation add_six()
 {
diff --git a/src/test/correct/jumptable2/gcc_pic/jumptable2_gtirb.expected b/src/test/correct/jumptable2/gcc_pic/jumptable2_gtirb.expected
index 9ff9781fc..b5833af5e 100644
--- a/src/test/correct/jumptable2/gcc_pic/jumptable2_gtirb.expected
+++ b/src/test/correct/jumptable2/gcc_pic/jumptable2_gtirb.expected
@@ -18,7 +18,7 @@ const {:extern} $jump_table_addr: bv64;
 axiom ($jump_table_addr == 69656bv64);
 const {:extern} $x_addr: bv64;
 axiom ($x_addr == 69648bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
   false
 }
 
@@ -48,10 +48,6 @@ function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv6
   (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
-}
-
 function {:extern} memory_store32_le(memory: [bv64]bv8, index: bv64, value: bv32) returns ([bv64]bv8) {
   memory[index := value[8:0]][bvadd64(index, 1bv64) := value[16:8]][bvadd64(index, 2bv64) := value[24:16]][bvadd64(index, 3bv64) := value[32:24]]
 }
@@ -63,26 +59,23 @@ function {:extern} memory_store64_le(memory: [bv64]bv8, index: bv64, value: bv64
 function {:extern} {:bvbuiltin "zero_extend 32"} zero_extend32_32(bv32) returns (bv64);
 procedure {:extern} rely();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
-  free ensures (memory_load8_le(mem, 2144bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 2145bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 2146bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 2147bv64) == 0bv8);
+  ensures (mem == old(mem));
+  free ensures (memory_load32_le(mem, 2144bv64) == 131073bv32);
+  free ensures (memory_load64_le(mem, 69000bv64) == 1936bv64);
+  free ensures (memory_load64_le(mem, 69008bv64) == 1856bv64);
+  free ensures (memory_load64_le(mem, 69592bv64) == 69648bv64);
   free ensures (memory_load64_le(mem, 69608bv64) == 2048bv64);
+  free ensures (memory_load64_le(mem, 69624bv64) == 69656bv64);
+  free ensures (memory_load64_le(mem, 69640bv64) == 69640bv64);
   free ensures (memory_load64_le(mem, 69656bv64) == 1940bv64);
   free ensures (memory_load64_le(mem, 69664bv64) == 1976bv64);
-  free ensures (memory_load64_le(mem, 69008bv64) == 1856bv64);
-  free ensures (memory_load64_le(mem, 69624bv64) == 69656bv64);
-  free ensures (memory_load64_le(mem, 69592bv64) == 69648bv64);
-  free ensures (memory_load64_le(mem, 69000bv64) == 1936bv64);
   free ensures (memory_load64_le(mem, 69672bv64) == 2012bv64);
-  free ensures (memory_load64_le(mem, 69640bv64) == 69640bv64);
 
 procedure {:extern} rely_transitive();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
+  ensures (mem == old(mem));
 
 implementation {:extern} rely_transitive()
 {
@@ -97,32 +90,26 @@ procedure {:extern} guarantee_reflexive();
 
 procedure add_two();
   modifies Gamma_R0, Gamma_R1, Gamma_mem, R0, R1, mem;
-  free requires (memory_load8_le(mem, 2144bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 2145bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 2146bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 2147bv64) == 0bv8);
+  free requires (memory_load32_le(mem, 2144bv64) == 131073bv32);
+  free requires (memory_load64_le(mem, 69000bv64) == 1936bv64);
+  free requires (memory_load64_le(mem, 69008bv64) == 1856bv64);
+  free requires (memory_load64_le(mem, 69592bv64) == 69648bv64);
   free requires (memory_load64_le(mem, 69608bv64) == 2048bv64);
+  free requires (memory_load64_le(mem, 69624bv64) == 69656bv64);
+  free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
   free requires (memory_load64_le(mem, 69656bv64) == 1940bv64);
   free requires (memory_load64_le(mem, 69664bv64) == 1976bv64);
-  free requires (memory_load64_le(mem, 69008bv64) == 1856bv64);
-  free requires (memory_load64_le(mem, 69624bv64) == 69656bv64);
-  free requires (memory_load64_le(mem, 69592bv64) == 69648bv64);
-  free requires (memory_load64_le(mem, 69000bv64) == 1936bv64);
   free requires (memory_load64_le(mem, 69672bv64) == 2012bv64);
-  free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free ensures (memory_load8_le(mem, 2144bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 2145bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 2146bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 2147bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 2144bv64) == 131073bv32);
+  free ensures (memory_load64_le(mem, 69000bv64) == 1936bv64);
+  free ensures (memory_load64_le(mem, 69008bv64) == 1856bv64);
+  free ensures (memory_load64_le(mem, 69592bv64) == 69648bv64);
   free ensures (memory_load64_le(mem, 69608bv64) == 2048bv64);
+  free ensures (memory_load64_le(mem, 69624bv64) == 69656bv64);
+  free ensures (memory_load64_le(mem, 69640bv64) == 69640bv64);
   free ensures (memory_load64_le(mem, 69656bv64) == 1940bv64);
   free ensures (memory_load64_le(mem, 69664bv64) == 1976bv64);
-  free ensures (memory_load64_le(mem, 69008bv64) == 1856bv64);
-  free ensures (memory_load64_le(mem, 69624bv64) == 69656bv64);
-  free ensures (memory_load64_le(mem, 69592bv64) == 69648bv64);
-  free ensures (memory_load64_le(mem, 69000bv64) == 1936bv64);
   free ensures (memory_load64_le(mem, 69672bv64) == 2012bv64);
-  free ensures (memory_load64_le(mem, 69640bv64) == 69640bv64);
 
 implementation add_two()
 {
@@ -149,32 +136,26 @@ implementation add_two()
 
 procedure sub_seven();
   modifies Gamma_R0, Gamma_R1, Gamma_mem, R0, R1, mem;
-  free requires (memory_load8_le(mem, 2144bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 2145bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 2146bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 2147bv64) == 0bv8);
+  free requires (memory_load32_le(mem, 2144bv64) == 131073bv32);
+  free requires (memory_load64_le(mem, 69000bv64) == 1936bv64);
+  free requires (memory_load64_le(mem, 69008bv64) == 1856bv64);
+  free requires (memory_load64_le(mem, 69592bv64) == 69648bv64);
   free requires (memory_load64_le(mem, 69608bv64) == 2048bv64);
+  free requires (memory_load64_le(mem, 69624bv64) == 69656bv64);
+  free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
   free requires (memory_load64_le(mem, 69656bv64) == 1940bv64);
   free requires (memory_load64_le(mem, 69664bv64) == 1976bv64);
-  free requires (memory_load64_le(mem, 69008bv64) == 1856bv64);
-  free requires (memory_load64_le(mem, 69624bv64) == 69656bv64);
-  free requires (memory_load64_le(mem, 69592bv64) == 69648bv64);
-  free requires (memory_load64_le(mem, 69000bv64) == 1936bv64);
   free requires (memory_load64_le(mem, 69672bv64) == 2012bv64);
-  free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free ensures (memory_load8_le(mem, 2144bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 2145bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 2146bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 2147bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 2144bv64) == 131073bv32);
+  free ensures (memory_load64_le(mem, 69000bv64) == 1936bv64);
+  free ensures (memory_load64_le(mem, 69008bv64) == 1856bv64);
+  free ensures (memory_load64_le(mem, 69592bv64) == 69648bv64);
   free ensures (memory_load64_le(mem, 69608bv64) == 2048bv64);
+  free ensures (memory_load64_le(mem, 69624bv64) == 69656bv64);
+  free ensures (memory_load64_le(mem, 69640bv64) == 69640bv64);
   free ensures (memory_load64_le(mem, 69656bv64) == 1940bv64);
   free ensures (memory_load64_le(mem, 69664bv64) == 1976bv64);
-  free ensures (memory_load64_le(mem, 69008bv64) == 1856bv64);
-  free ensures (memory_load64_le(mem, 69624bv64) == 69656bv64);
-  free ensures (memory_load64_le(mem, 69592bv64) == 69648bv64);
-  free ensures (memory_load64_le(mem, 69000bv64) == 1936bv64);
   free ensures (memory_load64_le(mem, 69672bv64) == 2012bv64);
-  free ensures (memory_load64_le(mem, 69640bv64) == 69640bv64);
 
 implementation sub_seven()
 {
@@ -207,36 +188,30 @@ procedure main();
   free requires (memory_load64_le(mem, 69656bv64) == 1940bv64);
   free requires (memory_load64_le(mem, 69664bv64) == 1976bv64);
   free requires (memory_load64_le(mem, 69672bv64) == 2012bv64);
-  free requires (memory_load8_le(mem, 2144bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 2145bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 2146bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 2147bv64) == 0bv8);
+  free requires (memory_load32_le(mem, 2144bv64) == 131073bv32);
+  free requires (memory_load64_le(mem, 69000bv64) == 1936bv64);
+  free requires (memory_load64_le(mem, 69008bv64) == 1856bv64);
+  free requires (memory_load64_le(mem, 69592bv64) == 69648bv64);
   free requires (memory_load64_le(mem, 69608bv64) == 2048bv64);
+  free requires (memory_load64_le(mem, 69624bv64) == 69656bv64);
+  free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
   free requires (memory_load64_le(mem, 69656bv64) == 1940bv64);
   free requires (memory_load64_le(mem, 69664bv64) == 1976bv64);
-  free requires (memory_load64_le(mem, 69008bv64) == 1856bv64);
-  free requires (memory_load64_le(mem, 69624bv64) == 69656bv64);
-  free requires (memory_load64_le(mem, 69592bv64) == 69648bv64);
-  free requires (memory_load64_le(mem, 69000bv64) == 1936bv64);
   free requires (memory_load64_le(mem, 69672bv64) == 2012bv64);
-  free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
   free ensures (Gamma_R29 == old(Gamma_R29));
   free ensures (Gamma_R31 == old(Gamma_R31));
   free ensures (R29 == old(R29));
   free ensures (R31 == old(R31));
-  free ensures (memory_load8_le(mem, 2144bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 2145bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 2146bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 2147bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 2144bv64) == 131073bv32);
+  free ensures (memory_load64_le(mem, 69000bv64) == 1936bv64);
+  free ensures (memory_load64_le(mem, 69008bv64) == 1856bv64);
+  free ensures (memory_load64_le(mem, 69592bv64) == 69648bv64);
   free ensures (memory_load64_le(mem, 69608bv64) == 2048bv64);
+  free ensures (memory_load64_le(mem, 69624bv64) == 69656bv64);
+  free ensures (memory_load64_le(mem, 69640bv64) == 69640bv64);
   free ensures (memory_load64_le(mem, 69656bv64) == 1940bv64);
   free ensures (memory_load64_le(mem, 69664bv64) == 1976bv64);
-  free ensures (memory_load64_le(mem, 69008bv64) == 1856bv64);
-  free ensures (memory_load64_le(mem, 69624bv64) == 69656bv64);
-  free ensures (memory_load64_le(mem, 69592bv64) == 69648bv64);
-  free ensures (memory_load64_le(mem, 69000bv64) == 1936bv64);
   free ensures (memory_load64_le(mem, 69672bv64) == 2012bv64);
-  free ensures (memory_load64_le(mem, 69640bv64) == 69640bv64);
 
 implementation main()
 {
@@ -297,32 +272,26 @@ implementation main()
 
 procedure add_six();
   modifies Gamma_R0, Gamma_R1, Gamma_mem, R0, R1, mem;
-  free requires (memory_load8_le(mem, 2144bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 2145bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 2146bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 2147bv64) == 0bv8);
+  free requires (memory_load32_le(mem, 2144bv64) == 131073bv32);
+  free requires (memory_load64_le(mem, 69000bv64) == 1936bv64);
+  free requires (memory_load64_le(mem, 69008bv64) == 1856bv64);
+  free requires (memory_load64_le(mem, 69592bv64) == 69648bv64);
   free requires (memory_load64_le(mem, 69608bv64) == 2048bv64);
+  free requires (memory_load64_le(mem, 69624bv64) == 69656bv64);
+  free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
   free requires (memory_load64_le(mem, 69656bv64) == 1940bv64);
   free requires (memory_load64_le(mem, 69664bv64) == 1976bv64);
-  free requires (memory_load64_le(mem, 69008bv64) == 1856bv64);
-  free requires (memory_load64_le(mem, 69624bv64) == 69656bv64);
-  free requires (memory_load64_le(mem, 69592bv64) == 69648bv64);
-  free requires (memory_load64_le(mem, 69000bv64) == 1936bv64);
   free requires (memory_load64_le(mem, 69672bv64) == 2012bv64);
-  free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free ensures (memory_load8_le(mem, 2144bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 2145bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 2146bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 2147bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 2144bv64) == 131073bv32);
+  free ensures (memory_load64_le(mem, 69000bv64) == 1936bv64);
+  free ensures (memory_load64_le(mem, 69008bv64) == 1856bv64);
+  free ensures (memory_load64_le(mem, 69592bv64) == 69648bv64);
   free ensures (memory_load64_le(mem, 69608bv64) == 2048bv64);
+  free ensures (memory_load64_le(mem, 69624bv64) == 69656bv64);
+  free ensures (memory_load64_le(mem, 69640bv64) == 69640bv64);
   free ensures (memory_load64_le(mem, 69656bv64) == 1940bv64);
   free ensures (memory_load64_le(mem, 69664bv64) == 1976bv64);
-  free ensures (memory_load64_le(mem, 69008bv64) == 1856bv64);
-  free ensures (memory_load64_le(mem, 69624bv64) == 69656bv64);
-  free ensures (memory_load64_le(mem, 69592bv64) == 69648bv64);
-  free ensures (memory_load64_le(mem, 69000bv64) == 1936bv64);
   free ensures (memory_load64_le(mem, 69672bv64) == 2012bv64);
-  free ensures (memory_load64_le(mem, 69640bv64) == 69640bv64);
 
 implementation add_six()
 {
diff --git a/src/test/correct/malloc_with_local/clang/malloc_with_local.expected b/src/test/correct/malloc_with_local/clang/malloc_with_local.expected
index d744c417a..d54c96082 100644
--- a/src/test/correct/malloc_with_local/clang/malloc_with_local.expected
+++ b/src/test/correct/malloc_with_local/clang/malloc_with_local.expected
@@ -22,7 +22,7 @@ var {:extern} mem: [bv64]bv8;
 var {:extern} stack: [bv64]bv8;
 const {:extern} $_IO_stdin_used_addr: bv64;
 axiom ($_IO_stdin_used_addr == 2256bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
   false
 }
 
@@ -79,8 +79,8 @@ function {:extern} {:bvbuiltin "zero_extend 32"} zero_extend32_32(bv32) returns
 function {:extern} {:bvbuiltin "zero_extend 56"} zero_extend56_8(bv8) returns (bv64);
 procedure {:extern} rely();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
+  ensures (mem == old(mem));
   free ensures (memory_load64_le(mem, 2256bv64) == 2334386691848142849bv64);
   free ensures (memory_load64_le(mem, 2264bv64) == 4211825664600402019bv64);
   free ensures (memory_load64_le(mem, 2272bv64) == 7307182754559632672bv64);
@@ -96,8 +96,8 @@ procedure {:extern} rely();
 
 procedure {:extern} rely_transitive();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
+  ensures (mem == old(mem));
 
 implementation {:extern} rely_transitive()
 {
diff --git a/src/test/correct/malloc_with_local/clang/malloc_with_local_gtirb.expected b/src/test/correct/malloc_with_local/clang/malloc_with_local_gtirb.expected
index 35a8659c0..6793f6257 100644
--- a/src/test/correct/malloc_with_local/clang/malloc_with_local_gtirb.expected
+++ b/src/test/correct/malloc_with_local/clang/malloc_with_local_gtirb.expected
@@ -22,7 +22,7 @@ var {:extern} mem: [bv64]bv8;
 var {:extern} stack: [bv64]bv8;
 const {:extern} $_IO_stdin_used_addr: bv64;
 axiom ($_IO_stdin_used_addr == 2256bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
   false
 }
 
@@ -79,8 +79,8 @@ function {:extern} {:bvbuiltin "zero_extend 24"} zero_extend24_8(bv8) returns (b
 function {:extern} {:bvbuiltin "zero_extend 32"} zero_extend32_32(bv32) returns (bv64);
 procedure {:extern} rely();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
+  ensures (mem == old(mem));
   free ensures (memory_load64_le(mem, 2256bv64) == 2334386691848142849bv64);
   free ensures (memory_load64_le(mem, 2264bv64) == 4211825664600402019bv64);
   free ensures (memory_load64_le(mem, 2272bv64) == 7307182754559632672bv64);
@@ -96,8 +96,8 @@ procedure {:extern} rely();
 
 procedure {:extern} rely_transitive();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
+  ensures (mem == old(mem));
 
 implementation {:extern} rely_transitive()
 {
diff --git a/src/test/correct/malloc_with_local/clang_O2/malloc_with_local.expected b/src/test/correct/malloc_with_local/clang_O2/malloc_with_local.expected
index e967cbe24..ac16f7d10 100644
--- a/src/test/correct/malloc_with_local/clang_O2/malloc_with_local.expected
+++ b/src/test/correct/malloc_with_local/clang_O2/malloc_with_local.expected
@@ -41,8 +41,8 @@ function {:extern} memory_store64_le(memory: [bv64]bv8, index: bv64, value: bv64
 
 procedure {:extern} rely();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
+  ensures (mem == old(mem));
   free ensures (memory_load8_le(mem, 1964bv64) == 1bv8);
   free ensures (memory_load8_le(mem, 1965bv64) == 0bv8);
   free ensures (memory_load8_le(mem, 1966bv64) == 2bv8);
@@ -65,8 +65,8 @@ procedure {:extern} rely();
 
 procedure {:extern} rely_transitive();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
+  ensures (mem == old(mem));
 
 implementation {:extern} rely_transitive()
 {
diff --git a/src/test/correct/malloc_with_local/clang_O2/malloc_with_local_gtirb.expected b/src/test/correct/malloc_with_local/clang_O2/malloc_with_local_gtirb.expected
index 69e194091..1f4ef0422 100644
--- a/src/test/correct/malloc_with_local/clang_O2/malloc_with_local_gtirb.expected
+++ b/src/test/correct/malloc_with_local/clang_O2/malloc_with_local_gtirb.expected
@@ -18,7 +18,7 @@ var {:extern} mem: [bv64]bv8;
 var {:extern} stack: [bv64]bv8;
 const {:extern} $_IO_stdin_used_addr: bv64;
 axiom ($_IO_stdin_used_addr == 1964bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
   false
 }
 
@@ -45,8 +45,8 @@ function {:extern} memory_store64_le(memory: [bv64]bv8, index: bv64, value: bv64
 
 procedure {:extern} rely();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
+  ensures (mem == old(mem));
   free ensures (memory_load8_le(mem, 1964bv64) == 1bv8);
   free ensures (memory_load8_le(mem, 1965bv64) == 0bv8);
   free ensures (memory_load8_le(mem, 1966bv64) == 2bv8);
@@ -69,8 +69,8 @@ procedure {:extern} rely();
 
 procedure {:extern} rely_transitive();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
+  ensures (mem == old(mem));
 
 implementation {:extern} rely_transitive()
 {
diff --git a/src/test/correct/malloc_with_local/gcc/malloc_with_local.expected b/src/test/correct/malloc_with_local/gcc/malloc_with_local.expected
index 86442b2ef..a85bcc599 100644
--- a/src/test/correct/malloc_with_local/gcc/malloc_with_local.expected
+++ b/src/test/correct/malloc_with_local/gcc/malloc_with_local.expected
@@ -18,7 +18,7 @@ var {:extern} mem: [bv64]bv8;
 var {:extern} stack: [bv64]bv8;
 const {:extern} $_IO_stdin_used_addr: bv64;
 axiom ($_IO_stdin_used_addr == 2248bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
   false
 }
 
@@ -75,8 +75,8 @@ function {:extern} {:bvbuiltin "zero_extend 32"} zero_extend32_32(bv32) returns
 function {:extern} {:bvbuiltin "zero_extend 56"} zero_extend56_8(bv8) returns (bv64);
 procedure {:extern} rely();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
+  ensures (mem == old(mem));
   free ensures (memory_load64_le(mem, 2248bv64) == 131073bv64);
   free ensures (memory_load64_le(mem, 2256bv64) == 8241983568019286100bv64);
   free ensures (memory_load64_le(mem, 2264bv64) == 748482783423457568bv64);
@@ -96,8 +96,8 @@ procedure {:extern} rely();
 
 procedure {:extern} rely_transitive();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
+  ensures (mem == old(mem));
 
 implementation {:extern} rely_transitive()
 {
diff --git a/src/test/correct/malloc_with_local/gcc/malloc_with_local_gtirb.expected b/src/test/correct/malloc_with_local/gcc/malloc_with_local_gtirb.expected
index 9c82490bb..b0dce8dca 100644
--- a/src/test/correct/malloc_with_local/gcc/malloc_with_local_gtirb.expected
+++ b/src/test/correct/malloc_with_local/gcc/malloc_with_local_gtirb.expected
@@ -18,7 +18,7 @@ var {:extern} mem: [bv64]bv8;
 var {:extern} stack: [bv64]bv8;
 const {:extern} $_IO_stdin_used_addr: bv64;
 axiom ($_IO_stdin_used_addr == 2248bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
   false
 }
 
@@ -75,8 +75,8 @@ function {:extern} {:bvbuiltin "zero_extend 24"} zero_extend24_8(bv8) returns (b
 function {:extern} {:bvbuiltin "zero_extend 32"} zero_extend32_32(bv32) returns (bv64);
 procedure {:extern} rely();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
+  ensures (mem == old(mem));
   free ensures (memory_load64_le(mem, 2248bv64) == 131073bv64);
   free ensures (memory_load64_le(mem, 2256bv64) == 8241983568019286100bv64);
   free ensures (memory_load64_le(mem, 2264bv64) == 748482783423457568bv64);
@@ -96,8 +96,8 @@ procedure {:extern} rely();
 
 procedure {:extern} rely_transitive();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
+  ensures (mem == old(mem));
 
 implementation {:extern} rely_transitive()
 {
diff --git a/src/test/correct/malloc_with_local/gcc_O2/malloc_with_local.expected b/src/test/correct/malloc_with_local/gcc_O2/malloc_with_local.expected
index 2b6826c22..715409413 100644
--- a/src/test/correct/malloc_with_local/gcc_O2/malloc_with_local.expected
+++ b/src/test/correct/malloc_with_local/gcc_O2/malloc_with_local.expected
@@ -43,8 +43,8 @@ function {:extern} memory_store64_le(memory: [bv64]bv8, index: bv64, value: bv64
 
 procedure {:extern} rely();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
+  ensures (mem == old(mem));
   free ensures (memory_load64_le(mem, 2088bv64) == 131073bv64);
   free ensures (memory_load64_le(mem, 2096bv64) == 8241983568019286100bv64);
   free ensures (memory_load64_le(mem, 2104bv64) == 748482783423457568bv64);
@@ -64,8 +64,8 @@ procedure {:extern} rely();
 
 procedure {:extern} rely_transitive();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
+  ensures (mem == old(mem));
 
 implementation {:extern} rely_transitive()
 {
diff --git a/src/test/correct/malloc_with_local/gcc_O2/malloc_with_local_gtirb.expected b/src/test/correct/malloc_with_local/gcc_O2/malloc_with_local_gtirb.expected
index 026f5518e..3b14ada56 100644
--- a/src/test/correct/malloc_with_local/gcc_O2/malloc_with_local_gtirb.expected
+++ b/src/test/correct/malloc_with_local/gcc_O2/malloc_with_local_gtirb.expected
@@ -20,7 +20,7 @@ var {:extern} mem: [bv64]bv8;
 var {:extern} stack: [bv64]bv8;
 const {:extern} $_IO_stdin_used_addr: bv64;
 axiom ($_IO_stdin_used_addr == 2088bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
   false
 }
 
@@ -47,8 +47,8 @@ function {:extern} memory_store64_le(memory: [bv64]bv8, index: bv64, value: bv64
 
 procedure {:extern} rely();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
+  ensures (mem == old(mem));
   free ensures (memory_load64_le(mem, 2088bv64) == 131073bv64);
   free ensures (memory_load64_le(mem, 2096bv64) == 8241983568019286100bv64);
   free ensures (memory_load64_le(mem, 2104bv64) == 748482783423457568bv64);
@@ -68,8 +68,8 @@ procedure {:extern} rely();
 
 procedure {:extern} rely_transitive();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
+  ensures (mem == old(mem));
 
 implementation {:extern} rely_transitive()
 {
diff --git a/src/test/correct/malloc_with_local2/clang/malloc_with_local2.expected b/src/test/correct/malloc_with_local2/clang/malloc_with_local2.expected
index 9503872ed..b2883ffa9 100644
--- a/src/test/correct/malloc_with_local2/clang/malloc_with_local2.expected
+++ b/src/test/correct/malloc_with_local2/clang/malloc_with_local2.expected
@@ -22,7 +22,7 @@ var {:extern} mem: [bv64]bv8;
 var {:extern} stack: [bv64]bv8;
 const {:extern} $_IO_stdin_used_addr: bv64;
 axiom ($_IO_stdin_used_addr == 2292bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
   false
 }
 
@@ -79,8 +79,8 @@ function {:extern} {:bvbuiltin "zero_extend 32"} zero_extend32_32(bv32) returns
 function {:extern} {:bvbuiltin "zero_extend 56"} zero_extend56_8(bv8) returns (bv64);
 procedure {:extern} rely();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
+  ensures (mem == old(mem));
   free ensures (memory_load8_le(mem, 2292bv64) == 1bv8);
   free ensures (memory_load8_le(mem, 2293bv64) == 0bv8);
   free ensures (memory_load8_le(mem, 2294bv64) == 2bv8);
@@ -103,8 +103,8 @@ procedure {:extern} rely();
 
 procedure {:extern} rely_transitive();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
+  ensures (mem == old(mem));
 
 implementation {:extern} rely_transitive()
 {
diff --git a/src/test/correct/malloc_with_local2/clang/malloc_with_local2_gtirb.expected b/src/test/correct/malloc_with_local2/clang/malloc_with_local2_gtirb.expected
index 22e7f1347..076949b82 100644
--- a/src/test/correct/malloc_with_local2/clang/malloc_with_local2_gtirb.expected
+++ b/src/test/correct/malloc_with_local2/clang/malloc_with_local2_gtirb.expected
@@ -22,7 +22,7 @@ var {:extern} mem: [bv64]bv8;
 var {:extern} stack: [bv64]bv8;
 const {:extern} $_IO_stdin_used_addr: bv64;
 axiom ($_IO_stdin_used_addr == 2292bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
   false
 }
 
@@ -79,8 +79,8 @@ function {:extern} {:bvbuiltin "zero_extend 24"} zero_extend24_8(bv8) returns (b
 function {:extern} {:bvbuiltin "zero_extend 32"} zero_extend32_32(bv32) returns (bv64);
 procedure {:extern} rely();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
+  ensures (mem == old(mem));
   free ensures (memory_load8_le(mem, 2292bv64) == 1bv8);
   free ensures (memory_load8_le(mem, 2293bv64) == 0bv8);
   free ensures (memory_load8_le(mem, 2294bv64) == 2bv8);
@@ -103,8 +103,8 @@ procedure {:extern} rely();
 
 procedure {:extern} rely_transitive();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
+  ensures (mem == old(mem));
 
 implementation {:extern} rely_transitive()
 {
diff --git a/src/test/correct/malloc_with_local2/gcc/malloc_with_local2.expected b/src/test/correct/malloc_with_local2/gcc/malloc_with_local2.expected
index ba606abce..553af7a9e 100644
--- a/src/test/correct/malloc_with_local2/gcc/malloc_with_local2.expected
+++ b/src/test/correct/malloc_with_local2/gcc/malloc_with_local2.expected
@@ -18,7 +18,7 @@ var {:extern} mem: [bv64]bv8;
 var {:extern} stack: [bv64]bv8;
 const {:extern} $_IO_stdin_used_addr: bv64;
 axiom ($_IO_stdin_used_addr == 2272bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
   false
 }
 
@@ -75,8 +75,8 @@ function {:extern} {:bvbuiltin "zero_extend 32"} zero_extend32_32(bv32) returns
 function {:extern} {:bvbuiltin "zero_extend 56"} zero_extend56_8(bv8) returns (bv64);
 procedure {:extern} rely();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
+  ensures (mem == old(mem));
   free ensures (memory_load64_le(mem, 2272bv64) == 131073bv64);
   free ensures (memory_load64_le(mem, 2280bv64) == 8241983568019286100bv64);
   free ensures (memory_load64_le(mem, 2288bv64) == 748482783423457568bv64);
@@ -96,8 +96,8 @@ procedure {:extern} rely();
 
 procedure {:extern} rely_transitive();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
+  ensures (mem == old(mem));
 
 implementation {:extern} rely_transitive()
 {
diff --git a/src/test/correct/malloc_with_local2/gcc/malloc_with_local2_gtirb.expected b/src/test/correct/malloc_with_local2/gcc/malloc_with_local2_gtirb.expected
index 034a6ffd3..782535552 100644
--- a/src/test/correct/malloc_with_local2/gcc/malloc_with_local2_gtirb.expected
+++ b/src/test/correct/malloc_with_local2/gcc/malloc_with_local2_gtirb.expected
@@ -18,7 +18,7 @@ var {:extern} mem: [bv64]bv8;
 var {:extern} stack: [bv64]bv8;
 const {:extern} $_IO_stdin_used_addr: bv64;
 axiom ($_IO_stdin_used_addr == 2272bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
   false
 }
 
@@ -75,8 +75,8 @@ function {:extern} {:bvbuiltin "zero_extend 24"} zero_extend24_8(bv8) returns (b
 function {:extern} {:bvbuiltin "zero_extend 32"} zero_extend32_32(bv32) returns (bv64);
 procedure {:extern} rely();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
+  ensures (mem == old(mem));
   free ensures (memory_load64_le(mem, 2272bv64) == 131073bv64);
   free ensures (memory_load64_le(mem, 2280bv64) == 8241983568019286100bv64);
   free ensures (memory_load64_le(mem, 2288bv64) == 748482783423457568bv64);
@@ -96,8 +96,8 @@ procedure {:extern} rely();
 
 procedure {:extern} rely_transitive();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
+  ensures (mem == old(mem));
 
 implementation {:extern} rely_transitive()
 {
diff --git a/src/test/correct/malloc_with_local3/clang/malloc_with_local3.expected b/src/test/correct/malloc_with_local3/clang/malloc_with_local3.expected
index f8b3fd019..e26d62293 100644
--- a/src/test/correct/malloc_with_local3/clang/malloc_with_local3.expected
+++ b/src/test/correct/malloc_with_local3/clang/malloc_with_local3.expected
@@ -22,7 +22,7 @@ var {:extern} mem: [bv64]bv8;
 var {:extern} stack: [bv64]bv8;
 const {:extern} $_IO_stdin_used_addr: bv64;
 axiom ($_IO_stdin_used_addr == 2344bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
   false
 }
 
@@ -80,8 +80,8 @@ function {:extern} {:bvbuiltin "zero_extend 32"} zero_extend32_32(bv32) returns
 function {:extern} {:bvbuiltin "zero_extend 56"} zero_extend56_8(bv8) returns (bv64);
 procedure {:extern} rely();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
+  ensures (mem == old(mem));
   free ensures (memory_load64_le(mem, 2344bv64) == 2334386691848142849bv64);
   free ensures (memory_load64_le(mem, 2352bv64) == 2322295453216173673bv64);
   free ensures (memory_load64_le(mem, 2360bv64) == 2334386691848692773bv64);
@@ -103,8 +103,8 @@ procedure {:extern} rely();
 
 procedure {:extern} rely_transitive();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
+  ensures (mem == old(mem));
 
 implementation {:extern} rely_transitive()
 {
diff --git a/src/test/correct/malloc_with_local3/clang/malloc_with_local3_gtirb.expected b/src/test/correct/malloc_with_local3/clang/malloc_with_local3_gtirb.expected
index 508af9ec4..4cfaf99f2 100644
--- a/src/test/correct/malloc_with_local3/clang/malloc_with_local3_gtirb.expected
+++ b/src/test/correct/malloc_with_local3/clang/malloc_with_local3_gtirb.expected
@@ -22,7 +22,7 @@ var {:extern} mem: [bv64]bv8;
 var {:extern} stack: [bv64]bv8;
 const {:extern} $_IO_stdin_used_addr: bv64;
 axiom ($_IO_stdin_used_addr == 2344bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
   false
 }
 
@@ -80,8 +80,8 @@ function {:extern} {:bvbuiltin "zero_extend 24"} zero_extend24_8(bv8) returns (b
 function {:extern} {:bvbuiltin "zero_extend 32"} zero_extend32_32(bv32) returns (bv64);
 procedure {:extern} rely();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
+  ensures (mem == old(mem));
   free ensures (memory_load64_le(mem, 2344bv64) == 2334386691848142849bv64);
   free ensures (memory_load64_le(mem, 2352bv64) == 2322295453216173673bv64);
   free ensures (memory_load64_le(mem, 2360bv64) == 2334386691848692773bv64);
@@ -103,8 +103,8 @@ procedure {:extern} rely();
 
 procedure {:extern} rely_transitive();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
+  ensures (mem == old(mem));
 
 implementation {:extern} rely_transitive()
 {
diff --git a/src/test/correct/malloc_with_local3/gcc/malloc_with_local3.expected b/src/test/correct/malloc_with_local3/gcc/malloc_with_local3.expected
index b090008a9..24cfa9582 100644
--- a/src/test/correct/malloc_with_local3/gcc/malloc_with_local3.expected
+++ b/src/test/correct/malloc_with_local3/gcc/malloc_with_local3.expected
@@ -18,7 +18,7 @@ var {:extern} mem: [bv64]bv8;
 var {:extern} stack: [bv64]bv8;
 const {:extern} $_IO_stdin_used_addr: bv64;
 axiom ($_IO_stdin_used_addr == 2328bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
   false
 }
 
@@ -76,8 +76,8 @@ function {:extern} {:bvbuiltin "zero_extend 32"} zero_extend32_32(bv32) returns
 function {:extern} {:bvbuiltin "zero_extend 56"} zero_extend56_8(bv8) returns (bv64);
 procedure {:extern} rely();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
+  ensures (mem == old(mem));
   free ensures (memory_load64_le(mem, 2328bv64) == 131073bv64);
   free ensures (memory_load64_le(mem, 2336bv64) == 2338615504306268244bv64);
   free ensures (memory_load64_le(mem, 2344bv64) == 2924860384375657bv64);
@@ -101,8 +101,8 @@ procedure {:extern} rely();
 
 procedure {:extern} rely_transitive();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
+  ensures (mem == old(mem));
 
 implementation {:extern} rely_transitive()
 {
diff --git a/src/test/correct/malloc_with_local3/gcc/malloc_with_local3_gtirb.expected b/src/test/correct/malloc_with_local3/gcc/malloc_with_local3_gtirb.expected
index dfaf0a7b1..6206c7d40 100644
--- a/src/test/correct/malloc_with_local3/gcc/malloc_with_local3_gtirb.expected
+++ b/src/test/correct/malloc_with_local3/gcc/malloc_with_local3_gtirb.expected
@@ -18,7 +18,7 @@ var {:extern} mem: [bv64]bv8;
 var {:extern} stack: [bv64]bv8;
 const {:extern} $_IO_stdin_used_addr: bv64;
 axiom ($_IO_stdin_used_addr == 2328bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
   false
 }
 
@@ -76,8 +76,8 @@ function {:extern} {:bvbuiltin "zero_extend 24"} zero_extend24_8(bv8) returns (b
 function {:extern} {:bvbuiltin "zero_extend 32"} zero_extend32_32(bv32) returns (bv64);
 procedure {:extern} rely();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
+  ensures (mem == old(mem));
   free ensures (memory_load64_le(mem, 2328bv64) == 131073bv64);
   free ensures (memory_load64_le(mem, 2336bv64) == 2338615504306268244bv64);
   free ensures (memory_load64_le(mem, 2344bv64) == 2924860384375657bv64);
@@ -101,8 +101,8 @@ procedure {:extern} rely();
 
 procedure {:extern} rely_transitive();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
+  ensures (mem == old(mem));
 
 implementation {:extern} rely_transitive()
 {
diff --git a/src/test/correct/malloc_with_local3/gcc_O2/malloc_with_local3.expected b/src/test/correct/malloc_with_local3/gcc_O2/malloc_with_local3.expected
index 7b2e9ba3f..6121cf2f2 100644
--- a/src/test/correct/malloc_with_local3/gcc_O2/malloc_with_local3.expected
+++ b/src/test/correct/malloc_with_local3/gcc_O2/malloc_with_local3.expected
@@ -24,7 +24,7 @@ var {:extern} mem: [bv64]bv8;
 var {:extern} stack: [bv64]bv8;
 const {:extern} $_IO_stdin_used_addr: bv64;
 axiom ($_IO_stdin_used_addr == 2264bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
   false
 }
 
@@ -66,8 +66,8 @@ function {:extern} {:bvbuiltin "zero_extend 32"} zero_extend32_32(bv32) returns
 function {:extern} {:bvbuiltin "zero_extend 56"} zero_extend56_8(bv8) returns (bv64);
 procedure {:extern} rely();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
+  ensures (mem == old(mem));
   free ensures (memory_load64_le(mem, 2264bv64) == 131073bv64);
   free ensures (memory_load64_le(mem, 2272bv64) == 8241983568019286100bv64);
   free ensures (memory_load64_le(mem, 2280bv64) == 7575166128241079840bv64);
@@ -87,8 +87,8 @@ procedure {:extern} rely();
 
 procedure {:extern} rely_transitive();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
+  ensures (mem == old(mem));
 
 implementation {:extern} rely_transitive()
 {
@@ -368,6 +368,6 @@ implementation printCharValue()
     mem, Gamma_mem := memory_store8_le(mem, R3, R2[8:0]), gamma_store8(Gamma_mem, R3, Gamma_R2);
     assume {:captureState "%00000293"} true;
     call __printf_chk();
-    assume false; //no return target
+    assume false;
 }
 
diff --git a/src/test/correct/malloc_with_local3/gcc_O2/malloc_with_local3_gtirb.expected b/src/test/correct/malloc_with_local3/gcc_O2/malloc_with_local3_gtirb.expected
index b26def393..86a87c185 100644
--- a/src/test/correct/malloc_with_local3/gcc_O2/malloc_with_local3_gtirb.expected
+++ b/src/test/correct/malloc_with_local3/gcc_O2/malloc_with_local3_gtirb.expected
@@ -24,7 +24,7 @@ var {:extern} mem: [bv64]bv8;
 var {:extern} stack: [bv64]bv8;
 const {:extern} $_IO_stdin_used_addr: bv64;
 axiom ($_IO_stdin_used_addr == 2264bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
   false
 }
 
@@ -66,8 +66,8 @@ function {:extern} {:bvbuiltin "zero_extend 24"} zero_extend24_8(bv8) returns (b
 function {:extern} {:bvbuiltin "zero_extend 32"} zero_extend32_32(bv32) returns (bv64);
 procedure {:extern} rely();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
+  ensures (mem == old(mem));
   free ensures (memory_load64_le(mem, 2264bv64) == 131073bv64);
   free ensures (memory_load64_le(mem, 2272bv64) == 8241983568019286100bv64);
   free ensures (memory_load64_le(mem, 2280bv64) == 7575166128241079840bv64);
@@ -87,8 +87,8 @@ procedure {:extern} rely();
 
 procedure {:extern} rely_transitive();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
+  ensures (mem == old(mem));
 
 implementation {:extern} rely_transitive()
 {
diff --git a/src/test/correct/multi_malloc/clang/multi_malloc.expected b/src/test/correct/multi_malloc/clang/multi_malloc.expected
index c9b7066c9..8d34e535f 100644
--- a/src/test/correct/multi_malloc/clang/multi_malloc.expected
+++ b/src/test/correct/multi_malloc/clang/multi_malloc.expected
@@ -22,7 +22,7 @@ var {:extern} mem: [bv64]bv8;
 var {:extern} stack: [bv64]bv8;
 const {:extern} $_IO_stdin_used_addr: bv64;
 axiom ($_IO_stdin_used_addr == 2232bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
   false
 }
 
@@ -79,8 +79,8 @@ function {:extern} {:bvbuiltin "zero_extend 32"} zero_extend32_32(bv32) returns
 function {:extern} {:bvbuiltin "zero_extend 56"} zero_extend56_8(bv8) returns (bv64);
 procedure {:extern} rely();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
+  ensures (mem == old(mem));
   free ensures (memory_load64_le(mem, 2232bv64) == 2334386691848142849bv64);
   free ensures (memory_load64_le(mem, 2240bv64) == 4211825664600402019bv64);
   free ensures (memory_load64_le(mem, 2248bv64) == 7307182754559632672bv64);
@@ -97,8 +97,8 @@ procedure {:extern} rely();
 
 procedure {:extern} rely_transitive();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
+  ensures (mem == old(mem));
 
 implementation {:extern} rely_transitive()
 {
diff --git a/src/test/correct/multi_malloc/clang/multi_malloc_gtirb.expected b/src/test/correct/multi_malloc/clang/multi_malloc_gtirb.expected
index 4cb699d0b..7481729ca 100644
--- a/src/test/correct/multi_malloc/clang/multi_malloc_gtirb.expected
+++ b/src/test/correct/multi_malloc/clang/multi_malloc_gtirb.expected
@@ -22,7 +22,7 @@ var {:extern} mem: [bv64]bv8;
 var {:extern} stack: [bv64]bv8;
 const {:extern} $_IO_stdin_used_addr: bv64;
 axiom ($_IO_stdin_used_addr == 2232bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
   false
 }
 
@@ -79,8 +79,8 @@ function {:extern} {:bvbuiltin "zero_extend 24"} zero_extend24_8(bv8) returns (b
 function {:extern} {:bvbuiltin "zero_extend 32"} zero_extend32_32(bv32) returns (bv64);
 procedure {:extern} rely();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
+  ensures (mem == old(mem));
   free ensures (memory_load64_le(mem, 2232bv64) == 2334386691848142849bv64);
   free ensures (memory_load64_le(mem, 2240bv64) == 4211825664600402019bv64);
   free ensures (memory_load64_le(mem, 2248bv64) == 7307182754559632672bv64);
@@ -97,8 +97,8 @@ procedure {:extern} rely();
 
 procedure {:extern} rely_transitive();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
+  ensures (mem == old(mem));
 
 implementation {:extern} rely_transitive()
 {
diff --git a/src/test/correct/multi_malloc/gcc/multi_malloc.expected b/src/test/correct/multi_malloc/gcc/multi_malloc.expected
index f81950ff7..509eb4da3 100644
--- a/src/test/correct/multi_malloc/gcc/multi_malloc.expected
+++ b/src/test/correct/multi_malloc/gcc/multi_malloc.expected
@@ -18,7 +18,7 @@ var {:extern} mem: [bv64]bv8;
 var {:extern} stack: [bv64]bv8;
 const {:extern} $_IO_stdin_used_addr: bv64;
 axiom ($_IO_stdin_used_addr == 2224bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
   false
 }
 
@@ -75,8 +75,8 @@ function {:extern} {:bvbuiltin "zero_extend 32"} zero_extend32_32(bv32) returns
 function {:extern} {:bvbuiltin "zero_extend 56"} zero_extend56_8(bv8) returns (bv64);
 procedure {:extern} rely();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
+  ensures (mem == old(mem));
   free ensures (memory_load64_le(mem, 2224bv64) == 131073bv64);
   free ensures (memory_load64_le(mem, 2232bv64) == 8241983568019286100bv64);
   free ensures (memory_load64_le(mem, 2240bv64) == 748482783423457568bv64);
@@ -90,8 +90,8 @@ procedure {:extern} rely();
 
 procedure {:extern} rely_transitive();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
+  ensures (mem == old(mem));
 
 implementation {:extern} rely_transitive()
 {
diff --git a/src/test/correct/multi_malloc/gcc/multi_malloc_gtirb.expected b/src/test/correct/multi_malloc/gcc/multi_malloc_gtirb.expected
index bddf81deb..72a908f31 100644
--- a/src/test/correct/multi_malloc/gcc/multi_malloc_gtirb.expected
+++ b/src/test/correct/multi_malloc/gcc/multi_malloc_gtirb.expected
@@ -18,7 +18,7 @@ var {:extern} mem: [bv64]bv8;
 var {:extern} stack: [bv64]bv8;
 const {:extern} $_IO_stdin_used_addr: bv64;
 axiom ($_IO_stdin_used_addr == 2224bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
   false
 }
 
@@ -75,8 +75,8 @@ function {:extern} {:bvbuiltin "zero_extend 24"} zero_extend24_8(bv8) returns (b
 function {:extern} {:bvbuiltin "zero_extend 32"} zero_extend32_32(bv32) returns (bv64);
 procedure {:extern} rely();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
+  ensures (mem == old(mem));
   free ensures (memory_load64_le(mem, 2224bv64) == 131073bv64);
   free ensures (memory_load64_le(mem, 2232bv64) == 8241983568019286100bv64);
   free ensures (memory_load64_le(mem, 2240bv64) == 748482783423457568bv64);
@@ -90,8 +90,8 @@ procedure {:extern} rely();
 
 procedure {:extern} rely_transitive();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
+  ensures (mem == old(mem));
 
 implementation {:extern} rely_transitive()
 {
diff --git a/src/test/correct/no_interference_update_x/clang/no_interference_update_x.expected b/src/test/correct/no_interference_update_x/clang/no_interference_update_x.expected
index 8824e2170..489874491 100644
--- a/src/test/correct/no_interference_update_x/clang/no_interference_update_x.expected
+++ b/src/test/correct/no_interference_update_x/clang/no_interference_update_x.expected
@@ -10,7 +10,7 @@ const {:extern} $x_addr: bv64;
 axiom ($x_addr == 69684bv64);
 const {:extern} $y_addr: bv64;
 axiom ($y_addr == 69688bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
   (if (index == $y_addr) then true else (if (index == $x_addr) then true else false))
 }
 
@@ -27,10 +27,6 @@ function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv6
   (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
-}
-
 function {:extern} memory_store32_le(memory: [bv64]bv8, index: bv64, value: bv32) returns ([bv64]bv8) {
   memory[index := value[8:0]][bvadd64(index, 1bv64) := value[16:8]][bvadd64(index, 2bv64) := value[24:16]][bvadd64(index, 3bv64) := value[32:24]]
 }
@@ -39,10 +35,7 @@ procedure {:extern} rely();
   modifies Gamma_mem, mem;
   ensures (forall i: bv64 :: (((mem[i] == old(mem[i])) ==> (Gamma_mem[i] == old(Gamma_mem[i])))));
   ensures (memory_load32_le(mem, $x_addr) == old(memory_load32_le(mem, $x_addr)));
-  free ensures (memory_load8_le(mem, 1852bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1853bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1854bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1855bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1852bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1812bv64);
@@ -77,19 +70,13 @@ procedure main();
   modifies Gamma_R0, Gamma_R8, Gamma_R9, Gamma_mem, R0, R8, R9, mem;
   free requires (memory_load64_le(mem, 69664bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
-  free requires (memory_load8_le(mem, 1852bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1853bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1854bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1855bv64) == 0bv8);
+  free requires (memory_load32_le(mem, 1852bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free requires (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free requires (memory_load64_le(mem, 69592bv64) == 1812bv64);
   free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
   ensures (memory_load32_le(mem, $x_addr) == 1bv32);
-  free ensures (memory_load8_le(mem, 1852bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1853bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1854bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1855bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1852bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1812bv64);
diff --git a/src/test/correct/no_interference_update_x/clang/no_interference_update_x_gtirb.expected b/src/test/correct/no_interference_update_x/clang/no_interference_update_x_gtirb.expected
index a0daae130..cae7dacd2 100644
--- a/src/test/correct/no_interference_update_x/clang/no_interference_update_x_gtirb.expected
+++ b/src/test/correct/no_interference_update_x/clang/no_interference_update_x_gtirb.expected
@@ -10,7 +10,7 @@ const {:extern} $x_addr: bv64;
 axiom ($x_addr == 69684bv64);
 const {:extern} $y_addr: bv64;
 axiom ($y_addr == 69688bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
   (if (index == $y_addr) then true else (if (index == $x_addr) then true else false))
 }
 
@@ -27,10 +27,6 @@ function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv6
   (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
-}
-
 function {:extern} memory_store32_le(memory: [bv64]bv8, index: bv64, value: bv32) returns ([bv64]bv8) {
   memory[index := value[8:0]][bvadd64(index, 1bv64) := value[16:8]][bvadd64(index, 2bv64) := value[24:16]][bvadd64(index, 3bv64) := value[32:24]]
 }
@@ -39,10 +35,7 @@ procedure {:extern} rely();
   modifies Gamma_mem, mem;
   ensures (forall i: bv64 :: (((mem[i] == old(mem[i])) ==> (Gamma_mem[i] == old(Gamma_mem[i])))));
   ensures (memory_load32_le(mem, $x_addr) == old(memory_load32_le(mem, $x_addr)));
-  free ensures (memory_load8_le(mem, 1852bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1853bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1854bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1855bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1852bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1812bv64);
@@ -77,19 +70,13 @@ procedure main();
   modifies Gamma_R0, Gamma_R8, Gamma_R9, Gamma_mem, R0, R8, R9, mem;
   free requires (memory_load64_le(mem, 69664bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
-  free requires (memory_load8_le(mem, 1852bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1853bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1854bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1855bv64) == 0bv8);
+  free requires (memory_load32_le(mem, 1852bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free requires (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free requires (memory_load64_le(mem, 69592bv64) == 1812bv64);
   free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
   ensures (memory_load32_le(mem, $x_addr) == 1bv32);
-  free ensures (memory_load8_le(mem, 1852bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1853bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1854bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1855bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1852bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1812bv64);
diff --git a/src/test/correct/no_interference_update_x/clang_pic/no_interference_update_x.expected b/src/test/correct/no_interference_update_x/clang_pic/no_interference_update_x.expected
index 0ba50c6e8..39c2b88dd 100644
--- a/src/test/correct/no_interference_update_x/clang_pic/no_interference_update_x.expected
+++ b/src/test/correct/no_interference_update_x/clang_pic/no_interference_update_x.expected
@@ -10,7 +10,7 @@ const {:extern} $x_addr: bv64;
 axiom ($x_addr == 69684bv64);
 const {:extern} $y_addr: bv64;
 axiom ($y_addr == 69688bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
   (if (index == $y_addr) then true else (if (index == $x_addr) then true else false))
 }
 
@@ -31,10 +31,6 @@ function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv6
   (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
-}
-
 function {:extern} memory_store32_le(memory: [bv64]bv8, index: bv64, value: bv32) returns ([bv64]bv8) {
   memory[index := value[8:0]][bvadd64(index, 1bv64) := value[16:8]][bvadd64(index, 2bv64) := value[24:16]][bvadd64(index, 3bv64) := value[32:24]]
 }
@@ -43,15 +39,12 @@ procedure {:extern} rely();
   modifies Gamma_mem, mem;
   ensures (forall i: bv64 :: (((mem[i] == old(mem[i])) ==> (Gamma_mem[i] == old(Gamma_mem[i])))));
   ensures (memory_load32_le(mem, $x_addr) == old(memory_load32_le(mem, $x_addr)));
-  free ensures (memory_load8_le(mem, 1920bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1921bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1922bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1923bv64) == 0bv8);
-  free ensures (memory_load64_le(mem, 69576bv64) == 69684bv64);
-  free ensures (memory_load64_le(mem, 69672bv64) == 69672bv64);
+  free ensures (memory_load32_le(mem, 1920bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69056bv64) == 1872bv64);
   free ensures (memory_load64_le(mem, 69064bv64) == 1792bv64);
+  free ensures (memory_load64_le(mem, 69576bv64) == 69684bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1876bv64);
+  free ensures (memory_load64_le(mem, 69672bv64) == 69672bv64);
 
 procedure {:extern} rely_transitive();
   modifies Gamma_mem, mem;
@@ -82,25 +75,19 @@ procedure main();
   modifies Gamma_R0, Gamma_R8, Gamma_R9, Gamma_mem, R0, R8, R9, mem;
   free requires (memory_load64_le(mem, 69664bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
-  free requires (memory_load8_le(mem, 1920bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1921bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1922bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1923bv64) == 0bv8);
-  free requires (memory_load64_le(mem, 69576bv64) == 69684bv64);
-  free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
+  free requires (memory_load32_le(mem, 1920bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69056bv64) == 1872bv64);
   free requires (memory_load64_le(mem, 69064bv64) == 1792bv64);
+  free requires (memory_load64_le(mem, 69576bv64) == 69684bv64);
   free requires (memory_load64_le(mem, 69592bv64) == 1876bv64);
+  free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
   ensures (memory_load32_le(mem, $x_addr) == 1bv32);
-  free ensures (memory_load8_le(mem, 1920bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1921bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1922bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1923bv64) == 0bv8);
-  free ensures (memory_load64_le(mem, 69576bv64) == 69684bv64);
-  free ensures (memory_load64_le(mem, 69672bv64) == 69672bv64);
+  free ensures (memory_load32_le(mem, 1920bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69056bv64) == 1872bv64);
   free ensures (memory_load64_le(mem, 69064bv64) == 1792bv64);
+  free ensures (memory_load64_le(mem, 69576bv64) == 69684bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1876bv64);
+  free ensures (memory_load64_le(mem, 69672bv64) == 69672bv64);
 
 implementation main()
 {
diff --git a/src/test/correct/no_interference_update_x/clang_pic/no_interference_update_x_gtirb.expected b/src/test/correct/no_interference_update_x/clang_pic/no_interference_update_x_gtirb.expected
index 51d3fd212..937fa0e13 100644
--- a/src/test/correct/no_interference_update_x/clang_pic/no_interference_update_x_gtirb.expected
+++ b/src/test/correct/no_interference_update_x/clang_pic/no_interference_update_x_gtirb.expected
@@ -10,7 +10,7 @@ const {:extern} $x_addr: bv64;
 axiom ($x_addr == 69684bv64);
 const {:extern} $y_addr: bv64;
 axiom ($y_addr == 69688bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
   (if (index == $y_addr) then true else (if (index == $x_addr) then true else false))
 }
 
@@ -31,10 +31,6 @@ function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv6
   (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
-}
-
 function {:extern} memory_store32_le(memory: [bv64]bv8, index: bv64, value: bv32) returns ([bv64]bv8) {
   memory[index := value[8:0]][bvadd64(index, 1bv64) := value[16:8]][bvadd64(index, 2bv64) := value[24:16]][bvadd64(index, 3bv64) := value[32:24]]
 }
@@ -43,15 +39,12 @@ procedure {:extern} rely();
   modifies Gamma_mem, mem;
   ensures (forall i: bv64 :: (((mem[i] == old(mem[i])) ==> (Gamma_mem[i] == old(Gamma_mem[i])))));
   ensures (memory_load32_le(mem, $x_addr) == old(memory_load32_le(mem, $x_addr)));
-  free ensures (memory_load8_le(mem, 1920bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1921bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1922bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1923bv64) == 0bv8);
-  free ensures (memory_load64_le(mem, 69576bv64) == 69684bv64);
-  free ensures (memory_load64_le(mem, 69672bv64) == 69672bv64);
+  free ensures (memory_load32_le(mem, 1920bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69056bv64) == 1872bv64);
   free ensures (memory_load64_le(mem, 69064bv64) == 1792bv64);
+  free ensures (memory_load64_le(mem, 69576bv64) == 69684bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1876bv64);
+  free ensures (memory_load64_le(mem, 69672bv64) == 69672bv64);
 
 procedure {:extern} rely_transitive();
   modifies Gamma_mem, mem;
@@ -82,25 +75,19 @@ procedure main();
   modifies Gamma_R0, Gamma_R8, Gamma_R9, Gamma_mem, R0, R8, R9, mem;
   free requires (memory_load64_le(mem, 69664bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
-  free requires (memory_load8_le(mem, 1920bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1921bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1922bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1923bv64) == 0bv8);
-  free requires (memory_load64_le(mem, 69576bv64) == 69684bv64);
-  free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
+  free requires (memory_load32_le(mem, 1920bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69056bv64) == 1872bv64);
   free requires (memory_load64_le(mem, 69064bv64) == 1792bv64);
+  free requires (memory_load64_le(mem, 69576bv64) == 69684bv64);
   free requires (memory_load64_le(mem, 69592bv64) == 1876bv64);
+  free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
   ensures (memory_load32_le(mem, $x_addr) == 1bv32);
-  free ensures (memory_load8_le(mem, 1920bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1921bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1922bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1923bv64) == 0bv8);
-  free ensures (memory_load64_le(mem, 69576bv64) == 69684bv64);
-  free ensures (memory_load64_le(mem, 69672bv64) == 69672bv64);
+  free ensures (memory_load32_le(mem, 1920bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69056bv64) == 1872bv64);
   free ensures (memory_load64_le(mem, 69064bv64) == 1792bv64);
+  free ensures (memory_load64_le(mem, 69576bv64) == 69684bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1876bv64);
+  free ensures (memory_load64_le(mem, 69672bv64) == 69672bv64);
 
 implementation main()
 {
diff --git a/src/test/correct/no_interference_update_x/gcc/no_interference_update_x.expected b/src/test/correct/no_interference_update_x/gcc/no_interference_update_x.expected
index 39715fe78..e88a5a93e 100644
--- a/src/test/correct/no_interference_update_x/gcc/no_interference_update_x.expected
+++ b/src/test/correct/no_interference_update_x/gcc/no_interference_update_x.expected
@@ -8,7 +8,7 @@ const {:extern} $x_addr: bv64;
 axiom ($x_addr == 69652bv64);
 const {:extern} $y_addr: bv64;
 axiom ($y_addr == 69656bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
   (if (index == $y_addr) then true else (if (index == $x_addr) then true else false))
 }
 
@@ -25,10 +25,6 @@ function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv6
   (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
-}
-
 function {:extern} memory_store32_le(memory: [bv64]bv8, index: bv64, value: bv32) returns ([bv64]bv8) {
   memory[index := value[8:0]][bvadd64(index, 1bv64) := value[16:8]][bvadd64(index, 2bv64) := value[24:16]][bvadd64(index, 3bv64) := value[32:24]]
 }
@@ -37,10 +33,7 @@ procedure {:extern} rely();
   modifies Gamma_mem, mem;
   ensures (forall i: bv64 :: (((mem[i] == old(mem[i])) ==> (Gamma_mem[i] == old(Gamma_mem[i])))));
   ensures (memory_load32_le(mem, $x_addr) == old(memory_load32_le(mem, $x_addr)));
-  free ensures (memory_load8_le(mem, 1856bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1857bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1858bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1859bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1856bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69016bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69024bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69616bv64) == 1812bv64);
@@ -75,19 +68,13 @@ procedure main();
   modifies Gamma_R0, Gamma_R1, Gamma_mem, R0, R1, mem;
   free requires (memory_load64_le(mem, 69632bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free requires (memory_load8_le(mem, 1856bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1857bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1858bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1859bv64) == 0bv8);
+  free requires (memory_load32_le(mem, 1856bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69016bv64) == 1808bv64);
   free requires (memory_load64_le(mem, 69024bv64) == 1728bv64);
   free requires (memory_load64_le(mem, 69616bv64) == 1812bv64);
   free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
   ensures (memory_load32_le(mem, $x_addr) == 1bv32);
-  free ensures (memory_load8_le(mem, 1856bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1857bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1858bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1859bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1856bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69016bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69024bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69616bv64) == 1812bv64);
diff --git a/src/test/correct/no_interference_update_x/gcc/no_interference_update_x_gtirb.expected b/src/test/correct/no_interference_update_x/gcc/no_interference_update_x_gtirb.expected
index a7e28fd8a..a0f5daea6 100644
--- a/src/test/correct/no_interference_update_x/gcc/no_interference_update_x_gtirb.expected
+++ b/src/test/correct/no_interference_update_x/gcc/no_interference_update_x_gtirb.expected
@@ -8,7 +8,7 @@ const {:extern} $x_addr: bv64;
 axiom ($x_addr == 69652bv64);
 const {:extern} $y_addr: bv64;
 axiom ($y_addr == 69656bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
   (if (index == $y_addr) then true else (if (index == $x_addr) then true else false))
 }
 
@@ -25,10 +25,6 @@ function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv6
   (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
-}
-
 function {:extern} memory_store32_le(memory: [bv64]bv8, index: bv64, value: bv32) returns ([bv64]bv8) {
   memory[index := value[8:0]][bvadd64(index, 1bv64) := value[16:8]][bvadd64(index, 2bv64) := value[24:16]][bvadd64(index, 3bv64) := value[32:24]]
 }
@@ -37,10 +33,7 @@ procedure {:extern} rely();
   modifies Gamma_mem, mem;
   ensures (forall i: bv64 :: (((mem[i] == old(mem[i])) ==> (Gamma_mem[i] == old(Gamma_mem[i])))));
   ensures (memory_load32_le(mem, $x_addr) == old(memory_load32_le(mem, $x_addr)));
-  free ensures (memory_load8_le(mem, 1856bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1857bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1858bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1859bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1856bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69016bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69024bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69616bv64) == 1812bv64);
@@ -75,19 +68,13 @@ procedure main();
   modifies Gamma_R0, Gamma_R1, Gamma_mem, R0, R1, mem;
   free requires (memory_load64_le(mem, 69632bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free requires (memory_load8_le(mem, 1856bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1857bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1858bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1859bv64) == 0bv8);
+  free requires (memory_load32_le(mem, 1856bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69016bv64) == 1808bv64);
   free requires (memory_load64_le(mem, 69024bv64) == 1728bv64);
   free requires (memory_load64_le(mem, 69616bv64) == 1812bv64);
   free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
   ensures (memory_load32_le(mem, $x_addr) == 1bv32);
-  free ensures (memory_load8_le(mem, 1856bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1857bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1858bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1859bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1856bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69016bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69024bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69616bv64) == 1812bv64);
diff --git a/src/test/correct/no_interference_update_x/gcc_O2/no_interference_update_x.expected b/src/test/correct/no_interference_update_x/gcc_O2/no_interference_update_x.expected
index 812b72308..4979c392b 100644
--- a/src/test/correct/no_interference_update_x/gcc_O2/no_interference_update_x.expected
+++ b/src/test/correct/no_interference_update_x/gcc_O2/no_interference_update_x.expected
@@ -10,7 +10,7 @@ const {:extern} $x_addr: bv64;
 axiom ($x_addr == 69652bv64);
 const {:extern} $y_addr: bv64;
 axiom ($y_addr == 69656bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
   (if (index == $y_addr) then true else (if (index == $x_addr) then true else false))
 }
 
@@ -27,10 +27,6 @@ function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv6
   (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
-}
-
 function {:extern} memory_store32_le(memory: [bv64]bv8, index: bv64, value: bv32) returns ([bv64]bv8) {
   memory[index := value[8:0]][bvadd64(index, 1bv64) := value[16:8]][bvadd64(index, 2bv64) := value[24:16]][bvadd64(index, 3bv64) := value[32:24]]
 }
@@ -39,10 +35,7 @@ procedure {:extern} rely();
   modifies Gamma_mem, mem;
   ensures (forall i: bv64 :: (((mem[i] == old(mem[i])) ==> (Gamma_mem[i] == old(Gamma_mem[i])))));
   ensures (memory_load32_le(mem, $x_addr) == old(memory_load32_le(mem, $x_addr)));
-  free ensures (memory_load8_le(mem, 1896bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1897bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1898bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1899bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1896bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69016bv64) == 1872bv64);
   free ensures (memory_load64_le(mem, 69024bv64) == 1792bv64);
   free ensures (memory_load64_le(mem, 69616bv64) == 1536bv64);
@@ -77,19 +70,13 @@ procedure main();
   modifies Gamma_R0, Gamma_R1, Gamma_R2, Gamma_mem, R0, R1, R2, mem;
   free requires (memory_load64_le(mem, 69632bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free requires (memory_load8_le(mem, 1896bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1897bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1898bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1899bv64) == 0bv8);
+  free requires (memory_load32_le(mem, 1896bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69016bv64) == 1872bv64);
   free requires (memory_load64_le(mem, 69024bv64) == 1792bv64);
   free requires (memory_load64_le(mem, 69616bv64) == 1536bv64);
   free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
   ensures (memory_load32_le(mem, $x_addr) == 1bv32);
-  free ensures (memory_load8_le(mem, 1896bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1897bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1898bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1899bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1896bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69016bv64) == 1872bv64);
   free ensures (memory_load64_le(mem, 69024bv64) == 1792bv64);
   free ensures (memory_load64_le(mem, 69616bv64) == 1536bv64);
diff --git a/src/test/correct/no_interference_update_x/gcc_O2/no_interference_update_x_gtirb.expected b/src/test/correct/no_interference_update_x/gcc_O2/no_interference_update_x_gtirb.expected
index 5addc892a..e53c49059 100644
--- a/src/test/correct/no_interference_update_x/gcc_O2/no_interference_update_x_gtirb.expected
+++ b/src/test/correct/no_interference_update_x/gcc_O2/no_interference_update_x_gtirb.expected
@@ -10,7 +10,7 @@ const {:extern} $x_addr: bv64;
 axiom ($x_addr == 69652bv64);
 const {:extern} $y_addr: bv64;
 axiom ($y_addr == 69656bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
   (if (index == $y_addr) then true else (if (index == $x_addr) then true else false))
 }
 
@@ -27,10 +27,6 @@ function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv6
   (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
-}
-
 function {:extern} memory_store32_le(memory: [bv64]bv8, index: bv64, value: bv32) returns ([bv64]bv8) {
   memory[index := value[8:0]][bvadd64(index, 1bv64) := value[16:8]][bvadd64(index, 2bv64) := value[24:16]][bvadd64(index, 3bv64) := value[32:24]]
 }
@@ -39,10 +35,7 @@ procedure {:extern} rely();
   modifies Gamma_mem, mem;
   ensures (forall i: bv64 :: (((mem[i] == old(mem[i])) ==> (Gamma_mem[i] == old(Gamma_mem[i])))));
   ensures (memory_load32_le(mem, $x_addr) == old(memory_load32_le(mem, $x_addr)));
-  free ensures (memory_load8_le(mem, 1896bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1897bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1898bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1899bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1896bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69016bv64) == 1872bv64);
   free ensures (memory_load64_le(mem, 69024bv64) == 1792bv64);
   free ensures (memory_load64_le(mem, 69616bv64) == 1536bv64);
@@ -77,19 +70,13 @@ procedure main();
   modifies Gamma_R0, Gamma_R1, Gamma_R2, Gamma_mem, R0, R1, R2, mem;
   free requires (memory_load64_le(mem, 69632bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free requires (memory_load8_le(mem, 1896bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1897bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1898bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1899bv64) == 0bv8);
+  free requires (memory_load32_le(mem, 1896bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69016bv64) == 1872bv64);
   free requires (memory_load64_le(mem, 69024bv64) == 1792bv64);
   free requires (memory_load64_le(mem, 69616bv64) == 1536bv64);
   free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
   ensures (memory_load32_le(mem, $x_addr) == 1bv32);
-  free ensures (memory_load8_le(mem, 1896bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1897bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1898bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1899bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1896bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69016bv64) == 1872bv64);
   free ensures (memory_load64_le(mem, 69024bv64) == 1792bv64);
   free ensures (memory_load64_le(mem, 69616bv64) == 1536bv64);
diff --git a/src/test/correct/no_interference_update_x/gcc_pic/no_interference_update_x.expected b/src/test/correct/no_interference_update_x/gcc_pic/no_interference_update_x.expected
index b3dff2519..fbd858afc 100644
--- a/src/test/correct/no_interference_update_x/gcc_pic/no_interference_update_x.expected
+++ b/src/test/correct/no_interference_update_x/gcc_pic/no_interference_update_x.expected
@@ -8,7 +8,7 @@ const {:extern} $x_addr: bv64;
 axiom ($x_addr == 69652bv64);
 const {:extern} $y_addr: bv64;
 axiom ($y_addr == 69656bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
   (if (index == $y_addr) then true else (if (index == $x_addr) then true else false))
 }
 
@@ -29,10 +29,6 @@ function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv6
   (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
-}
-
 function {:extern} memory_store32_le(memory: [bv64]bv8, index: bv64, value: bv32) returns ([bv64]bv8) {
   memory[index := value[8:0]][bvadd64(index, 1bv64) := value[16:8]][bvadd64(index, 2bv64) := value[24:16]][bvadd64(index, 3bv64) := value[32:24]]
 }
@@ -41,15 +37,12 @@ procedure {:extern} rely();
   modifies Gamma_mem, mem;
   ensures (forall i: bv64 :: (((mem[i] == old(mem[i])) ==> (Gamma_mem[i] == old(Gamma_mem[i])))));
   ensures (memory_load32_le(mem, $x_addr) == old(memory_load32_le(mem, $x_addr)));
-  free ensures (memory_load8_le(mem, 1920bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1921bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1922bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1923bv64) == 0bv8);
-  free ensures (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free ensures (memory_load64_le(mem, 69616bv64) == 1876bv64);
+  free ensures (memory_load32_le(mem, 1920bv64) == 131073bv32);
+  free ensures (memory_load64_le(mem, 69008bv64) == 1872bv64);
   free ensures (memory_load64_le(mem, 69016bv64) == 1792bv64);
   free ensures (memory_load64_le(mem, 69600bv64) == 69652bv64);
-  free ensures (memory_load64_le(mem, 69008bv64) == 1872bv64);
+  free ensures (memory_load64_le(mem, 69616bv64) == 1876bv64);
+  free ensures (memory_load64_le(mem, 69640bv64) == 69640bv64);
 
 procedure {:extern} rely_transitive();
   modifies Gamma_mem, mem;
@@ -80,25 +73,19 @@ procedure main();
   modifies Gamma_R0, Gamma_R1, Gamma_mem, R0, R1, mem;
   free requires (memory_load64_le(mem, 69632bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free requires (memory_load8_le(mem, 1920bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1921bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1922bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1923bv64) == 0bv8);
-  free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free requires (memory_load64_le(mem, 69616bv64) == 1876bv64);
+  free requires (memory_load32_le(mem, 1920bv64) == 131073bv32);
+  free requires (memory_load64_le(mem, 69008bv64) == 1872bv64);
   free requires (memory_load64_le(mem, 69016bv64) == 1792bv64);
   free requires (memory_load64_le(mem, 69600bv64) == 69652bv64);
-  free requires (memory_load64_le(mem, 69008bv64) == 1872bv64);
+  free requires (memory_load64_le(mem, 69616bv64) == 1876bv64);
+  free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
   ensures (memory_load32_le(mem, $x_addr) == 1bv32);
-  free ensures (memory_load8_le(mem, 1920bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1921bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1922bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1923bv64) == 0bv8);
-  free ensures (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free ensures (memory_load64_le(mem, 69616bv64) == 1876bv64);
+  free ensures (memory_load32_le(mem, 1920bv64) == 131073bv32);
+  free ensures (memory_load64_le(mem, 69008bv64) == 1872bv64);
   free ensures (memory_load64_le(mem, 69016bv64) == 1792bv64);
   free ensures (memory_load64_le(mem, 69600bv64) == 69652bv64);
-  free ensures (memory_load64_le(mem, 69008bv64) == 1872bv64);
+  free ensures (memory_load64_le(mem, 69616bv64) == 1876bv64);
+  free ensures (memory_load64_le(mem, 69640bv64) == 69640bv64);
 
 implementation main()
 {
diff --git a/src/test/correct/no_interference_update_x/gcc_pic/no_interference_update_x_gtirb.expected b/src/test/correct/no_interference_update_x/gcc_pic/no_interference_update_x_gtirb.expected
index 5714ee446..49ac0244c 100644
--- a/src/test/correct/no_interference_update_x/gcc_pic/no_interference_update_x_gtirb.expected
+++ b/src/test/correct/no_interference_update_x/gcc_pic/no_interference_update_x_gtirb.expected
@@ -8,7 +8,7 @@ const {:extern} $x_addr: bv64;
 axiom ($x_addr == 69652bv64);
 const {:extern} $y_addr: bv64;
 axiom ($y_addr == 69656bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
   (if (index == $y_addr) then true else (if (index == $x_addr) then true else false))
 }
 
@@ -29,10 +29,6 @@ function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv6
   (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
-}
-
 function {:extern} memory_store32_le(memory: [bv64]bv8, index: bv64, value: bv32) returns ([bv64]bv8) {
   memory[index := value[8:0]][bvadd64(index, 1bv64) := value[16:8]][bvadd64(index, 2bv64) := value[24:16]][bvadd64(index, 3bv64) := value[32:24]]
 }
@@ -41,15 +37,12 @@ procedure {:extern} rely();
   modifies Gamma_mem, mem;
   ensures (forall i: bv64 :: (((mem[i] == old(mem[i])) ==> (Gamma_mem[i] == old(Gamma_mem[i])))));
   ensures (memory_load32_le(mem, $x_addr) == old(memory_load32_le(mem, $x_addr)));
-  free ensures (memory_load8_le(mem, 1920bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1921bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1922bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1923bv64) == 0bv8);
-  free ensures (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free ensures (memory_load64_le(mem, 69616bv64) == 1876bv64);
+  free ensures (memory_load32_le(mem, 1920bv64) == 131073bv32);
+  free ensures (memory_load64_le(mem, 69008bv64) == 1872bv64);
   free ensures (memory_load64_le(mem, 69016bv64) == 1792bv64);
   free ensures (memory_load64_le(mem, 69600bv64) == 69652bv64);
-  free ensures (memory_load64_le(mem, 69008bv64) == 1872bv64);
+  free ensures (memory_load64_le(mem, 69616bv64) == 1876bv64);
+  free ensures (memory_load64_le(mem, 69640bv64) == 69640bv64);
 
 procedure {:extern} rely_transitive();
   modifies Gamma_mem, mem;
@@ -80,25 +73,19 @@ procedure main();
   modifies Gamma_R0, Gamma_R1, Gamma_mem, R0, R1, mem;
   free requires (memory_load64_le(mem, 69632bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free requires (memory_load8_le(mem, 1920bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1921bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1922bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1923bv64) == 0bv8);
-  free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free requires (memory_load64_le(mem, 69616bv64) == 1876bv64);
+  free requires (memory_load32_le(mem, 1920bv64) == 131073bv32);
+  free requires (memory_load64_le(mem, 69008bv64) == 1872bv64);
   free requires (memory_load64_le(mem, 69016bv64) == 1792bv64);
   free requires (memory_load64_le(mem, 69600bv64) == 69652bv64);
-  free requires (memory_load64_le(mem, 69008bv64) == 1872bv64);
+  free requires (memory_load64_le(mem, 69616bv64) == 1876bv64);
+  free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
   ensures (memory_load32_le(mem, $x_addr) == 1bv32);
-  free ensures (memory_load8_le(mem, 1920bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1921bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1922bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1923bv64) == 0bv8);
-  free ensures (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free ensures (memory_load64_le(mem, 69616bv64) == 1876bv64);
+  free ensures (memory_load32_le(mem, 1920bv64) == 131073bv32);
+  free ensures (memory_load64_le(mem, 69008bv64) == 1872bv64);
   free ensures (memory_load64_le(mem, 69016bv64) == 1792bv64);
   free ensures (memory_load64_le(mem, 69600bv64) == 69652bv64);
-  free ensures (memory_load64_le(mem, 69008bv64) == 1872bv64);
+  free ensures (memory_load64_le(mem, 69616bv64) == 1876bv64);
+  free ensures (memory_load64_le(mem, 69640bv64) == 69640bv64);
 
 implementation main()
 {
diff --git a/src/test/correct/no_interference_update_y/clang/no_interference_update_y.expected b/src/test/correct/no_interference_update_y/clang/no_interference_update_y.expected
index 47005edc5..c730fada4 100644
--- a/src/test/correct/no_interference_update_y/clang/no_interference_update_y.expected
+++ b/src/test/correct/no_interference_update_y/clang/no_interference_update_y.expected
@@ -10,7 +10,7 @@ const {:extern} $x_addr: bv64;
 axiom ($x_addr == 69688bv64);
 const {:extern} $y_addr: bv64;
 axiom ($y_addr == 69684bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
   (if (index == $y_addr) then true else (if (index == $x_addr) then true else false))
 }
 
@@ -27,10 +27,6 @@ function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv6
   (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
-}
-
 function {:extern} memory_store32_le(memory: [bv64]bv8, index: bv64, value: bv32) returns ([bv64]bv8) {
   memory[index := value[8:0]][bvadd64(index, 1bv64) := value[16:8]][bvadd64(index, 2bv64) := value[24:16]][bvadd64(index, 3bv64) := value[32:24]]
 }
@@ -39,10 +35,7 @@ procedure {:extern} rely();
   modifies Gamma_mem, mem;
   ensures (forall i: bv64 :: (((mem[i] == old(mem[i])) ==> (Gamma_mem[i] == old(Gamma_mem[i])))));
   ensures (memory_load32_le(mem, $y_addr) == old(memory_load32_le(mem, $y_addr)));
-  free ensures (memory_load8_le(mem, 1852bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1853bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1854bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1855bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1852bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1812bv64);
@@ -77,19 +70,13 @@ procedure main();
   modifies Gamma_R0, Gamma_R8, Gamma_R9, Gamma_mem, R0, R8, R9, mem;
   free requires (memory_load64_le(mem, 69664bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
-  free requires (memory_load8_le(mem, 1852bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1853bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1854bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1855bv64) == 0bv8);
+  free requires (memory_load32_le(mem, 1852bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free requires (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free requires (memory_load64_le(mem, 69592bv64) == 1812bv64);
   free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
   ensures (memory_load32_le(mem, $y_addr) == 1bv32);
-  free ensures (memory_load8_le(mem, 1852bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1853bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1854bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1855bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1852bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1812bv64);
diff --git a/src/test/correct/no_interference_update_y/clang/no_interference_update_y_gtirb.expected b/src/test/correct/no_interference_update_y/clang/no_interference_update_y_gtirb.expected
index 9d04098e1..8bf937d63 100644
--- a/src/test/correct/no_interference_update_y/clang/no_interference_update_y_gtirb.expected
+++ b/src/test/correct/no_interference_update_y/clang/no_interference_update_y_gtirb.expected
@@ -10,7 +10,7 @@ const {:extern} $x_addr: bv64;
 axiom ($x_addr == 69688bv64);
 const {:extern} $y_addr: bv64;
 axiom ($y_addr == 69684bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
   (if (index == $y_addr) then true else (if (index == $x_addr) then true else false))
 }
 
@@ -27,10 +27,6 @@ function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv6
   (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
-}
-
 function {:extern} memory_store32_le(memory: [bv64]bv8, index: bv64, value: bv32) returns ([bv64]bv8) {
   memory[index := value[8:0]][bvadd64(index, 1bv64) := value[16:8]][bvadd64(index, 2bv64) := value[24:16]][bvadd64(index, 3bv64) := value[32:24]]
 }
@@ -39,10 +35,7 @@ procedure {:extern} rely();
   modifies Gamma_mem, mem;
   ensures (forall i: bv64 :: (((mem[i] == old(mem[i])) ==> (Gamma_mem[i] == old(Gamma_mem[i])))));
   ensures (memory_load32_le(mem, $y_addr) == old(memory_load32_le(mem, $y_addr)));
-  free ensures (memory_load8_le(mem, 1852bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1853bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1854bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1855bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1852bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1812bv64);
@@ -77,19 +70,13 @@ procedure main();
   modifies Gamma_R0, Gamma_R8, Gamma_R9, Gamma_mem, R0, R8, R9, mem;
   free requires (memory_load64_le(mem, 69664bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
-  free requires (memory_load8_le(mem, 1852bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1853bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1854bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1855bv64) == 0bv8);
+  free requires (memory_load32_le(mem, 1852bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free requires (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free requires (memory_load64_le(mem, 69592bv64) == 1812bv64);
   free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
   ensures (memory_load32_le(mem, $y_addr) == 1bv32);
-  free ensures (memory_load8_le(mem, 1852bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1853bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1854bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1855bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1852bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1812bv64);
diff --git a/src/test/correct/no_interference_update_y/clang_pic/no_interference_update_y.expected b/src/test/correct/no_interference_update_y/clang_pic/no_interference_update_y.expected
index 99d2305ec..01bd7a9e8 100644
--- a/src/test/correct/no_interference_update_y/clang_pic/no_interference_update_y.expected
+++ b/src/test/correct/no_interference_update_y/clang_pic/no_interference_update_y.expected
@@ -10,7 +10,7 @@ const {:extern} $x_addr: bv64;
 axiom ($x_addr == 69688bv64);
 const {:extern} $y_addr: bv64;
 axiom ($y_addr == 69684bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
   (if (index == $y_addr) then true else (if (index == $x_addr) then true else false))
 }
 
@@ -31,10 +31,6 @@ function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv6
   (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
-}
-
 function {:extern} memory_store32_le(memory: [bv64]bv8, index: bv64, value: bv32) returns ([bv64]bv8) {
   memory[index := value[8:0]][bvadd64(index, 1bv64) := value[16:8]][bvadd64(index, 2bv64) := value[24:16]][bvadd64(index, 3bv64) := value[32:24]]
 }
@@ -43,15 +39,12 @@ procedure {:extern} rely();
   modifies Gamma_mem, mem;
   ensures (forall i: bv64 :: (((mem[i] == old(mem[i])) ==> (Gamma_mem[i] == old(Gamma_mem[i])))));
   ensures (memory_load32_le(mem, $y_addr) == old(memory_load32_le(mem, $y_addr)));
-  free ensures (memory_load8_le(mem, 1920bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1921bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1922bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1923bv64) == 0bv8);
-  free ensures (memory_load64_le(mem, 69672bv64) == 69672bv64);
-  free ensures (memory_load64_le(mem, 69584bv64) == 69684bv64);
+  free ensures (memory_load32_le(mem, 1920bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69056bv64) == 1872bv64);
   free ensures (memory_load64_le(mem, 69064bv64) == 1792bv64);
+  free ensures (memory_load64_le(mem, 69584bv64) == 69684bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1876bv64);
+  free ensures (memory_load64_le(mem, 69672bv64) == 69672bv64);
 
 procedure {:extern} rely_transitive();
   modifies Gamma_mem, mem;
@@ -82,25 +75,19 @@ procedure main();
   modifies Gamma_R0, Gamma_R8, Gamma_R9, Gamma_mem, R0, R8, R9, mem;
   free requires (memory_load64_le(mem, 69664bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
-  free requires (memory_load8_le(mem, 1920bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1921bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1922bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1923bv64) == 0bv8);
-  free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
-  free requires (memory_load64_le(mem, 69584bv64) == 69684bv64);
+  free requires (memory_load32_le(mem, 1920bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69056bv64) == 1872bv64);
   free requires (memory_load64_le(mem, 69064bv64) == 1792bv64);
+  free requires (memory_load64_le(mem, 69584bv64) == 69684bv64);
   free requires (memory_load64_le(mem, 69592bv64) == 1876bv64);
+  free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
   ensures (memory_load32_le(mem, $y_addr) == 1bv32);
-  free ensures (memory_load8_le(mem, 1920bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1921bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1922bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1923bv64) == 0bv8);
-  free ensures (memory_load64_le(mem, 69672bv64) == 69672bv64);
-  free ensures (memory_load64_le(mem, 69584bv64) == 69684bv64);
+  free ensures (memory_load32_le(mem, 1920bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69056bv64) == 1872bv64);
   free ensures (memory_load64_le(mem, 69064bv64) == 1792bv64);
+  free ensures (memory_load64_le(mem, 69584bv64) == 69684bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1876bv64);
+  free ensures (memory_load64_le(mem, 69672bv64) == 69672bv64);
 
 implementation main()
 {
diff --git a/src/test/correct/no_interference_update_y/clang_pic/no_interference_update_y_gtirb.expected b/src/test/correct/no_interference_update_y/clang_pic/no_interference_update_y_gtirb.expected
index ce221cf8e..9d3394cc3 100644
--- a/src/test/correct/no_interference_update_y/clang_pic/no_interference_update_y_gtirb.expected
+++ b/src/test/correct/no_interference_update_y/clang_pic/no_interference_update_y_gtirb.expected
@@ -10,7 +10,7 @@ const {:extern} $x_addr: bv64;
 axiom ($x_addr == 69688bv64);
 const {:extern} $y_addr: bv64;
 axiom ($y_addr == 69684bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
   (if (index == $y_addr) then true else (if (index == $x_addr) then true else false))
 }
 
@@ -31,10 +31,6 @@ function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv6
   (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
-}
-
 function {:extern} memory_store32_le(memory: [bv64]bv8, index: bv64, value: bv32) returns ([bv64]bv8) {
   memory[index := value[8:0]][bvadd64(index, 1bv64) := value[16:8]][bvadd64(index, 2bv64) := value[24:16]][bvadd64(index, 3bv64) := value[32:24]]
 }
@@ -43,15 +39,12 @@ procedure {:extern} rely();
   modifies Gamma_mem, mem;
   ensures (forall i: bv64 :: (((mem[i] == old(mem[i])) ==> (Gamma_mem[i] == old(Gamma_mem[i])))));
   ensures (memory_load32_le(mem, $y_addr) == old(memory_load32_le(mem, $y_addr)));
-  free ensures (memory_load8_le(mem, 1920bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1921bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1922bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1923bv64) == 0bv8);
-  free ensures (memory_load64_le(mem, 69672bv64) == 69672bv64);
-  free ensures (memory_load64_le(mem, 69584bv64) == 69684bv64);
+  free ensures (memory_load32_le(mem, 1920bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69056bv64) == 1872bv64);
   free ensures (memory_load64_le(mem, 69064bv64) == 1792bv64);
+  free ensures (memory_load64_le(mem, 69584bv64) == 69684bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1876bv64);
+  free ensures (memory_load64_le(mem, 69672bv64) == 69672bv64);
 
 procedure {:extern} rely_transitive();
   modifies Gamma_mem, mem;
@@ -82,25 +75,19 @@ procedure main();
   modifies Gamma_R0, Gamma_R8, Gamma_R9, Gamma_mem, R0, R8, R9, mem;
   free requires (memory_load64_le(mem, 69664bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
-  free requires (memory_load8_le(mem, 1920bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1921bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1922bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1923bv64) == 0bv8);
-  free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
-  free requires (memory_load64_le(mem, 69584bv64) == 69684bv64);
+  free requires (memory_load32_le(mem, 1920bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69056bv64) == 1872bv64);
   free requires (memory_load64_le(mem, 69064bv64) == 1792bv64);
+  free requires (memory_load64_le(mem, 69584bv64) == 69684bv64);
   free requires (memory_load64_le(mem, 69592bv64) == 1876bv64);
+  free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
   ensures (memory_load32_le(mem, $y_addr) == 1bv32);
-  free ensures (memory_load8_le(mem, 1920bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1921bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1922bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1923bv64) == 0bv8);
-  free ensures (memory_load64_le(mem, 69672bv64) == 69672bv64);
-  free ensures (memory_load64_le(mem, 69584bv64) == 69684bv64);
+  free ensures (memory_load32_le(mem, 1920bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69056bv64) == 1872bv64);
   free ensures (memory_load64_le(mem, 69064bv64) == 1792bv64);
+  free ensures (memory_load64_le(mem, 69584bv64) == 69684bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1876bv64);
+  free ensures (memory_load64_le(mem, 69672bv64) == 69672bv64);
 
 implementation main()
 {
diff --git a/src/test/correct/no_interference_update_y/gcc/no_interference_update_y.expected b/src/test/correct/no_interference_update_y/gcc/no_interference_update_y.expected
index 4e0b74c0f..707922203 100644
--- a/src/test/correct/no_interference_update_y/gcc/no_interference_update_y.expected
+++ b/src/test/correct/no_interference_update_y/gcc/no_interference_update_y.expected
@@ -8,7 +8,7 @@ const {:extern} $x_addr: bv64;
 axiom ($x_addr == 69652bv64);
 const {:extern} $y_addr: bv64;
 axiom ($y_addr == 69656bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
   (if (index == $y_addr) then true else (if (index == $x_addr) then true else false))
 }
 
@@ -25,10 +25,6 @@ function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv6
   (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
-}
-
 function {:extern} memory_store32_le(memory: [bv64]bv8, index: bv64, value: bv32) returns ([bv64]bv8) {
   memory[index := value[8:0]][bvadd64(index, 1bv64) := value[16:8]][bvadd64(index, 2bv64) := value[24:16]][bvadd64(index, 3bv64) := value[32:24]]
 }
@@ -37,10 +33,7 @@ procedure {:extern} rely();
   modifies Gamma_mem, mem;
   ensures (forall i: bv64 :: (((mem[i] == old(mem[i])) ==> (Gamma_mem[i] == old(Gamma_mem[i])))));
   ensures (memory_load32_le(mem, $y_addr) == old(memory_load32_le(mem, $y_addr)));
-  free ensures (memory_load8_le(mem, 1856bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1857bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1858bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1859bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1856bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69016bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69024bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69616bv64) == 1812bv64);
@@ -75,19 +68,13 @@ procedure main();
   modifies Gamma_R0, Gamma_R1, Gamma_mem, R0, R1, mem;
   free requires (memory_load64_le(mem, 69632bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free requires (memory_load8_le(mem, 1856bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1857bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1858bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1859bv64) == 0bv8);
+  free requires (memory_load32_le(mem, 1856bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69016bv64) == 1808bv64);
   free requires (memory_load64_le(mem, 69024bv64) == 1728bv64);
   free requires (memory_load64_le(mem, 69616bv64) == 1812bv64);
   free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
   ensures (memory_load32_le(mem, $y_addr) == 1bv32);
-  free ensures (memory_load8_le(mem, 1856bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1857bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1858bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1859bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1856bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69016bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69024bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69616bv64) == 1812bv64);
diff --git a/src/test/correct/no_interference_update_y/gcc/no_interference_update_y_gtirb.expected b/src/test/correct/no_interference_update_y/gcc/no_interference_update_y_gtirb.expected
index 524df54f5..046da73bd 100644
--- a/src/test/correct/no_interference_update_y/gcc/no_interference_update_y_gtirb.expected
+++ b/src/test/correct/no_interference_update_y/gcc/no_interference_update_y_gtirb.expected
@@ -8,7 +8,7 @@ const {:extern} $x_addr: bv64;
 axiom ($x_addr == 69652bv64);
 const {:extern} $y_addr: bv64;
 axiom ($y_addr == 69656bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
   (if (index == $y_addr) then true else (if (index == $x_addr) then true else false))
 }
 
@@ -25,10 +25,6 @@ function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv6
   (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
-}
-
 function {:extern} memory_store32_le(memory: [bv64]bv8, index: bv64, value: bv32) returns ([bv64]bv8) {
   memory[index := value[8:0]][bvadd64(index, 1bv64) := value[16:8]][bvadd64(index, 2bv64) := value[24:16]][bvadd64(index, 3bv64) := value[32:24]]
 }
@@ -37,10 +33,7 @@ procedure {:extern} rely();
   modifies Gamma_mem, mem;
   ensures (forall i: bv64 :: (((mem[i] == old(mem[i])) ==> (Gamma_mem[i] == old(Gamma_mem[i])))));
   ensures (memory_load32_le(mem, $y_addr) == old(memory_load32_le(mem, $y_addr)));
-  free ensures (memory_load8_le(mem, 1856bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1857bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1858bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1859bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1856bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69016bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69024bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69616bv64) == 1812bv64);
@@ -75,19 +68,13 @@ procedure main();
   modifies Gamma_R0, Gamma_R1, Gamma_mem, R0, R1, mem;
   free requires (memory_load64_le(mem, 69632bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free requires (memory_load8_le(mem, 1856bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1857bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1858bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1859bv64) == 0bv8);
+  free requires (memory_load32_le(mem, 1856bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69016bv64) == 1808bv64);
   free requires (memory_load64_le(mem, 69024bv64) == 1728bv64);
   free requires (memory_load64_le(mem, 69616bv64) == 1812bv64);
   free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
   ensures (memory_load32_le(mem, $y_addr) == 1bv32);
-  free ensures (memory_load8_le(mem, 1856bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1857bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1858bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1859bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1856bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69016bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69024bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69616bv64) == 1812bv64);
diff --git a/src/test/correct/no_interference_update_y/gcc_O2/no_interference_update_y.expected b/src/test/correct/no_interference_update_y/gcc_O2/no_interference_update_y.expected
index a45d9640a..2985f6029 100644
--- a/src/test/correct/no_interference_update_y/gcc_O2/no_interference_update_y.expected
+++ b/src/test/correct/no_interference_update_y/gcc_O2/no_interference_update_y.expected
@@ -10,7 +10,7 @@ const {:extern} $x_addr: bv64;
 axiom ($x_addr == 69656bv64);
 const {:extern} $y_addr: bv64;
 axiom ($y_addr == 69652bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
   (if (index == $y_addr) then true else (if (index == $x_addr) then true else false))
 }
 
@@ -27,10 +27,6 @@ function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv6
   (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
-}
-
 function {:extern} memory_store32_le(memory: [bv64]bv8, index: bv64, value: bv32) returns ([bv64]bv8) {
   memory[index := value[8:0]][bvadd64(index, 1bv64) := value[16:8]][bvadd64(index, 2bv64) := value[24:16]][bvadd64(index, 3bv64) := value[32:24]]
 }
@@ -39,10 +35,7 @@ procedure {:extern} rely();
   modifies Gamma_mem, mem;
   ensures (forall i: bv64 :: (((mem[i] == old(mem[i])) ==> (Gamma_mem[i] == old(Gamma_mem[i])))));
   ensures (memory_load32_le(mem, $y_addr) == old(memory_load32_le(mem, $y_addr)));
-  free ensures (memory_load8_le(mem, 1896bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1897bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1898bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1899bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1896bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69016bv64) == 1872bv64);
   free ensures (memory_load64_le(mem, 69024bv64) == 1792bv64);
   free ensures (memory_load64_le(mem, 69616bv64) == 1536bv64);
@@ -77,19 +70,13 @@ procedure main();
   modifies Gamma_R0, Gamma_R1, Gamma_R2, Gamma_mem, R0, R1, R2, mem;
   free requires (memory_load64_le(mem, 69632bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free requires (memory_load8_le(mem, 1896bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1897bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1898bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1899bv64) == 0bv8);
+  free requires (memory_load32_le(mem, 1896bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69016bv64) == 1872bv64);
   free requires (memory_load64_le(mem, 69024bv64) == 1792bv64);
   free requires (memory_load64_le(mem, 69616bv64) == 1536bv64);
   free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
   ensures (memory_load32_le(mem, $y_addr) == 1bv32);
-  free ensures (memory_load8_le(mem, 1896bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1897bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1898bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1899bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1896bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69016bv64) == 1872bv64);
   free ensures (memory_load64_le(mem, 69024bv64) == 1792bv64);
   free ensures (memory_load64_le(mem, 69616bv64) == 1536bv64);
diff --git a/src/test/correct/no_interference_update_y/gcc_O2/no_interference_update_y_gtirb.expected b/src/test/correct/no_interference_update_y/gcc_O2/no_interference_update_y_gtirb.expected
index 873279301..1b0e1ce61 100644
--- a/src/test/correct/no_interference_update_y/gcc_O2/no_interference_update_y_gtirb.expected
+++ b/src/test/correct/no_interference_update_y/gcc_O2/no_interference_update_y_gtirb.expected
@@ -10,7 +10,7 @@ const {:extern} $x_addr: bv64;
 axiom ($x_addr == 69656bv64);
 const {:extern} $y_addr: bv64;
 axiom ($y_addr == 69652bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
   (if (index == $y_addr) then true else (if (index == $x_addr) then true else false))
 }
 
@@ -27,10 +27,6 @@ function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv6
   (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
-}
-
 function {:extern} memory_store32_le(memory: [bv64]bv8, index: bv64, value: bv32) returns ([bv64]bv8) {
   memory[index := value[8:0]][bvadd64(index, 1bv64) := value[16:8]][bvadd64(index, 2bv64) := value[24:16]][bvadd64(index, 3bv64) := value[32:24]]
 }
@@ -39,10 +35,7 @@ procedure {:extern} rely();
   modifies Gamma_mem, mem;
   ensures (forall i: bv64 :: (((mem[i] == old(mem[i])) ==> (Gamma_mem[i] == old(Gamma_mem[i])))));
   ensures (memory_load32_le(mem, $y_addr) == old(memory_load32_le(mem, $y_addr)));
-  free ensures (memory_load8_le(mem, 1896bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1897bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1898bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1899bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1896bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69016bv64) == 1872bv64);
   free ensures (memory_load64_le(mem, 69024bv64) == 1792bv64);
   free ensures (memory_load64_le(mem, 69616bv64) == 1536bv64);
@@ -77,19 +70,13 @@ procedure main();
   modifies Gamma_R0, Gamma_R1, Gamma_R2, Gamma_mem, R0, R1, R2, mem;
   free requires (memory_load64_le(mem, 69632bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free requires (memory_load8_le(mem, 1896bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1897bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1898bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1899bv64) == 0bv8);
+  free requires (memory_load32_le(mem, 1896bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69016bv64) == 1872bv64);
   free requires (memory_load64_le(mem, 69024bv64) == 1792bv64);
   free requires (memory_load64_le(mem, 69616bv64) == 1536bv64);
   free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
   ensures (memory_load32_le(mem, $y_addr) == 1bv32);
-  free ensures (memory_load8_le(mem, 1896bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1897bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1898bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1899bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1896bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69016bv64) == 1872bv64);
   free ensures (memory_load64_le(mem, 69024bv64) == 1792bv64);
   free ensures (memory_load64_le(mem, 69616bv64) == 1536bv64);
diff --git a/src/test/correct/no_interference_update_y/gcc_pic/no_interference_update_y.expected b/src/test/correct/no_interference_update_y/gcc_pic/no_interference_update_y.expected
index 8d57819eb..72fb704a7 100644
--- a/src/test/correct/no_interference_update_y/gcc_pic/no_interference_update_y.expected
+++ b/src/test/correct/no_interference_update_y/gcc_pic/no_interference_update_y.expected
@@ -8,7 +8,7 @@ const {:extern} $x_addr: bv64;
 axiom ($x_addr == 69652bv64);
 const {:extern} $y_addr: bv64;
 axiom ($y_addr == 69656bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
   (if (index == $y_addr) then true else (if (index == $x_addr) then true else false))
 }
 
@@ -29,10 +29,6 @@ function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv6
   (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
-}
-
 function {:extern} memory_store32_le(memory: [bv64]bv8, index: bv64, value: bv32) returns ([bv64]bv8) {
   memory[index := value[8:0]][bvadd64(index, 1bv64) := value[16:8]][bvadd64(index, 2bv64) := value[24:16]][bvadd64(index, 3bv64) := value[32:24]]
 }
@@ -41,15 +37,12 @@ procedure {:extern} rely();
   modifies Gamma_mem, mem;
   ensures (forall i: bv64 :: (((mem[i] == old(mem[i])) ==> (Gamma_mem[i] == old(Gamma_mem[i])))));
   ensures (memory_load32_le(mem, $y_addr) == old(memory_load32_le(mem, $y_addr)));
-  free ensures (memory_load8_le(mem, 1920bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1921bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1922bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1923bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1920bv64) == 131073bv32);
+  free ensures (memory_load64_le(mem, 69008bv64) == 1872bv64);
+  free ensures (memory_load64_le(mem, 69016bv64) == 1792bv64);
   free ensures (memory_load64_le(mem, 69608bv64) == 69656bv64);
-  free ensures (memory_load64_le(mem, 69640bv64) == 69640bv64);
   free ensures (memory_load64_le(mem, 69616bv64) == 1876bv64);
-  free ensures (memory_load64_le(mem, 69016bv64) == 1792bv64);
-  free ensures (memory_load64_le(mem, 69008bv64) == 1872bv64);
+  free ensures (memory_load64_le(mem, 69640bv64) == 69640bv64);
 
 procedure {:extern} rely_transitive();
   modifies Gamma_mem, mem;
@@ -80,25 +73,19 @@ procedure main();
   modifies Gamma_R0, Gamma_R1, Gamma_mem, R0, R1, mem;
   free requires (memory_load64_le(mem, 69632bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free requires (memory_load8_le(mem, 1920bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1921bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1922bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1923bv64) == 0bv8);
+  free requires (memory_load32_le(mem, 1920bv64) == 131073bv32);
+  free requires (memory_load64_le(mem, 69008bv64) == 1872bv64);
+  free requires (memory_load64_le(mem, 69016bv64) == 1792bv64);
   free requires (memory_load64_le(mem, 69608bv64) == 69656bv64);
-  free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
   free requires (memory_load64_le(mem, 69616bv64) == 1876bv64);
-  free requires (memory_load64_le(mem, 69016bv64) == 1792bv64);
-  free requires (memory_load64_le(mem, 69008bv64) == 1872bv64);
+  free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
   ensures (memory_load32_le(mem, $y_addr) == 1bv32);
-  free ensures (memory_load8_le(mem, 1920bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1921bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1922bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1923bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1920bv64) == 131073bv32);
+  free ensures (memory_load64_le(mem, 69008bv64) == 1872bv64);
+  free ensures (memory_load64_le(mem, 69016bv64) == 1792bv64);
   free ensures (memory_load64_le(mem, 69608bv64) == 69656bv64);
-  free ensures (memory_load64_le(mem, 69640bv64) == 69640bv64);
   free ensures (memory_load64_le(mem, 69616bv64) == 1876bv64);
-  free ensures (memory_load64_le(mem, 69016bv64) == 1792bv64);
-  free ensures (memory_load64_le(mem, 69008bv64) == 1872bv64);
+  free ensures (memory_load64_le(mem, 69640bv64) == 69640bv64);
 
 implementation main()
 {
diff --git a/src/test/correct/no_interference_update_y/gcc_pic/no_interference_update_y_gtirb.expected b/src/test/correct/no_interference_update_y/gcc_pic/no_interference_update_y_gtirb.expected
index b9ffef1ce..2dc3bd3bb 100644
--- a/src/test/correct/no_interference_update_y/gcc_pic/no_interference_update_y_gtirb.expected
+++ b/src/test/correct/no_interference_update_y/gcc_pic/no_interference_update_y_gtirb.expected
@@ -8,7 +8,7 @@ const {:extern} $x_addr: bv64;
 axiom ($x_addr == 69652bv64);
 const {:extern} $y_addr: bv64;
 axiom ($y_addr == 69656bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
   (if (index == $y_addr) then true else (if (index == $x_addr) then true else false))
 }
 
@@ -29,10 +29,6 @@ function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv6
   (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
-}
-
 function {:extern} memory_store32_le(memory: [bv64]bv8, index: bv64, value: bv32) returns ([bv64]bv8) {
   memory[index := value[8:0]][bvadd64(index, 1bv64) := value[16:8]][bvadd64(index, 2bv64) := value[24:16]][bvadd64(index, 3bv64) := value[32:24]]
 }
@@ -41,15 +37,12 @@ procedure {:extern} rely();
   modifies Gamma_mem, mem;
   ensures (forall i: bv64 :: (((mem[i] == old(mem[i])) ==> (Gamma_mem[i] == old(Gamma_mem[i])))));
   ensures (memory_load32_le(mem, $y_addr) == old(memory_load32_le(mem, $y_addr)));
-  free ensures (memory_load8_le(mem, 1920bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1921bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1922bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1923bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1920bv64) == 131073bv32);
+  free ensures (memory_load64_le(mem, 69008bv64) == 1872bv64);
+  free ensures (memory_load64_le(mem, 69016bv64) == 1792bv64);
   free ensures (memory_load64_le(mem, 69608bv64) == 69656bv64);
-  free ensures (memory_load64_le(mem, 69640bv64) == 69640bv64);
   free ensures (memory_load64_le(mem, 69616bv64) == 1876bv64);
-  free ensures (memory_load64_le(mem, 69016bv64) == 1792bv64);
-  free ensures (memory_load64_le(mem, 69008bv64) == 1872bv64);
+  free ensures (memory_load64_le(mem, 69640bv64) == 69640bv64);
 
 procedure {:extern} rely_transitive();
   modifies Gamma_mem, mem;
@@ -80,25 +73,19 @@ procedure main();
   modifies Gamma_R0, Gamma_R1, Gamma_mem, R0, R1, mem;
   free requires (memory_load64_le(mem, 69632bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free requires (memory_load8_le(mem, 1920bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1921bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1922bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1923bv64) == 0bv8);
+  free requires (memory_load32_le(mem, 1920bv64) == 131073bv32);
+  free requires (memory_load64_le(mem, 69008bv64) == 1872bv64);
+  free requires (memory_load64_le(mem, 69016bv64) == 1792bv64);
   free requires (memory_load64_le(mem, 69608bv64) == 69656bv64);
-  free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
   free requires (memory_load64_le(mem, 69616bv64) == 1876bv64);
-  free requires (memory_load64_le(mem, 69016bv64) == 1792bv64);
-  free requires (memory_load64_le(mem, 69008bv64) == 1872bv64);
+  free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
   ensures (memory_load32_le(mem, $y_addr) == 1bv32);
-  free ensures (memory_load8_le(mem, 1920bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1921bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1922bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1923bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1920bv64) == 131073bv32);
+  free ensures (memory_load64_le(mem, 69008bv64) == 1872bv64);
+  free ensures (memory_load64_le(mem, 69016bv64) == 1792bv64);
   free ensures (memory_load64_le(mem, 69608bv64) == 69656bv64);
-  free ensures (memory_load64_le(mem, 69640bv64) == 69640bv64);
   free ensures (memory_load64_le(mem, 69616bv64) == 1876bv64);
-  free ensures (memory_load64_le(mem, 69016bv64) == 1792bv64);
-  free ensures (memory_load64_le(mem, 69008bv64) == 1872bv64);
+  free ensures (memory_load64_le(mem, 69640bv64) == 69640bv64);
 
 implementation main()
 {
diff --git a/src/test/correct/secret_write/clang/secret_write.expected b/src/test/correct/secret_write/clang/secret_write.expected
index 9fd104c05..ff731a250 100644
--- a/src/test/correct/secret_write/clang/secret_write.expected
+++ b/src/test/correct/secret_write/clang/secret_write.expected
@@ -14,8 +14,8 @@ const {:extern} $x_addr: bv64;
 axiom ($x_addr == 69692bv64);
 const {:extern} $z_addr: bv64;
 axiom ($z_addr == 69684bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
-  (if (index == $secret_addr) then false else (if (index == $x_addr) then (bvsmod32(memory_load32_le(memory, $z_addr), 2bv32) == 0bv32) else (if (index == $z_addr) then true else false)))
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
+  (if (index == $secret_addr) then false else (if (index == $x_addr) then (bvsmod32(memory_load32_le(mem$in, $z_addr), 2bv32) == 0bv32) else (if (index == $z_addr) then true else false)))
 }
 
 function {:extern} {:bvbuiltin "bvadd"} bvadd32(bv32, bv32) returns (bv32);
@@ -38,10 +38,6 @@ function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv6
   (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
-}
-
 function {:extern} memory_store32_le(memory: [bv64]bv8, index: bv64, value: bv32) returns ([bv64]bv8) {
   memory[index := value[8:0]][bvadd64(index, 1bv64) := value[16:8]][bvadd64(index, 2bv64) := value[24:16]][bvadd64(index, 3bv64) := value[32:24]]
 }
@@ -52,10 +48,7 @@ procedure {:extern} rely();
   ensures (forall i: bv64 :: (((mem[i] == old(mem[i])) ==> (Gamma_mem[i] == old(Gamma_mem[i])))));
   ensures (memory_load32_le(mem, $z_addr) == old(memory_load32_le(mem, $z_addr)));
   ensures (old(gamma_load32(Gamma_mem, $x_addr)) ==> gamma_load32(Gamma_mem, $x_addr));
-  free ensures (memory_load8_le(mem, 1892bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1893bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1894bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1895bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1892bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1812bv64);
@@ -96,18 +89,12 @@ procedure main();
   requires (memory_load32_le(mem, $z_addr) == 0bv32);
   free requires (memory_load64_le(mem, 69664bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
-  free requires (memory_load8_le(mem, 1892bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1893bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1894bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1895bv64) == 0bv8);
+  free requires (memory_load32_le(mem, 1892bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free requires (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free requires (memory_load64_le(mem, 69592bv64) == 1812bv64);
   free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
-  free ensures (memory_load8_le(mem, 1892bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1893bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1894bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1895bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1892bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1812bv64);
diff --git a/src/test/correct/secret_write/clang/secret_write_gtirb.expected b/src/test/correct/secret_write/clang/secret_write_gtirb.expected
index 6c22b7f34..e9d02dcdd 100644
--- a/src/test/correct/secret_write/clang/secret_write_gtirb.expected
+++ b/src/test/correct/secret_write/clang/secret_write_gtirb.expected
@@ -14,8 +14,8 @@ const {:extern} $x_addr: bv64;
 axiom ($x_addr == 69692bv64);
 const {:extern} $z_addr: bv64;
 axiom ($z_addr == 69684bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
-  (if (index == $secret_addr) then false else (if (index == $x_addr) then (bvsmod32(memory_load32_le(memory, $z_addr), 2bv32) == 0bv32) else (if (index == $z_addr) then true else false)))
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
+  (if (index == $secret_addr) then false else (if (index == $x_addr) then (bvsmod32(memory_load32_le(mem$in, $z_addr), 2bv32) == 0bv32) else (if (index == $z_addr) then true else false)))
 }
 
 function {:extern} {:bvbuiltin "bvadd"} bvadd32(bv32, bv32) returns (bv32);
@@ -38,10 +38,6 @@ function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv6
   (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
-}
-
 function {:extern} memory_store32_le(memory: [bv64]bv8, index: bv64, value: bv32) returns ([bv64]bv8) {
   memory[index := value[8:0]][bvadd64(index, 1bv64) := value[16:8]][bvadd64(index, 2bv64) := value[24:16]][bvadd64(index, 3bv64) := value[32:24]]
 }
@@ -52,10 +48,7 @@ procedure {:extern} rely();
   ensures (forall i: bv64 :: (((mem[i] == old(mem[i])) ==> (Gamma_mem[i] == old(Gamma_mem[i])))));
   ensures (memory_load32_le(mem, $z_addr) == old(memory_load32_le(mem, $z_addr)));
   ensures (old(gamma_load32(Gamma_mem, $x_addr)) ==> gamma_load32(Gamma_mem, $x_addr));
-  free ensures (memory_load8_le(mem, 1892bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1893bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1894bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1895bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1892bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1812bv64);
@@ -96,18 +89,12 @@ procedure main();
   requires (memory_load32_le(mem, $z_addr) == 0bv32);
   free requires (memory_load64_le(mem, 69664bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
-  free requires (memory_load8_le(mem, 1892bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1893bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1894bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1895bv64) == 0bv8);
+  free requires (memory_load32_le(mem, 1892bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free requires (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free requires (memory_load64_le(mem, 69592bv64) == 1812bv64);
   free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
-  free ensures (memory_load8_le(mem, 1892bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1893bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1894bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1895bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1892bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1812bv64);
diff --git a/src/test/correct/secret_write/clang_O2/secret_write.expected b/src/test/correct/secret_write/clang_O2/secret_write.expected
index a9048843f..48a428eaa 100644
--- a/src/test/correct/secret_write/clang_O2/secret_write.expected
+++ b/src/test/correct/secret_write/clang_O2/secret_write.expected
@@ -14,8 +14,8 @@ const {:extern} $x_addr: bv64;
 axiom ($x_addr == 69692bv64);
 const {:extern} $z_addr: bv64;
 axiom ($z_addr == 69684bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
-  (if (index == $secret_addr) then false else (if (index == $x_addr) then (bvsmod32(memory_load32_le(memory, $z_addr), 2bv32) == 0bv32) else (if (index == $z_addr) then true else false)))
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
+  (if (index == $secret_addr) then false else (if (index == $x_addr) then (bvsmod32(memory_load32_le(mem$in, $z_addr), 2bv32) == 0bv32) else (if (index == $z_addr) then true else false)))
 }
 
 function {:extern} {:bvbuiltin "bvadd"} bvadd64(bv64, bv64) returns (bv64);
@@ -37,10 +37,6 @@ function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv6
   (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
-}
-
 function {:extern} memory_store32_le(memory: [bv64]bv8, index: bv64, value: bv32) returns ([bv64]bv8) {
   memory[index := value[8:0]][bvadd64(index, 1bv64) := value[16:8]][bvadd64(index, 2bv64) := value[24:16]][bvadd64(index, 3bv64) := value[32:24]]
 }
@@ -50,10 +46,7 @@ procedure {:extern} rely();
   ensures (forall i: bv64 :: (((mem[i] == old(mem[i])) ==> (Gamma_mem[i] == old(Gamma_mem[i])))));
   ensures (memory_load32_le(mem, $z_addr) == old(memory_load32_le(mem, $z_addr)));
   ensures (old(gamma_load32(Gamma_mem, $x_addr)) ==> gamma_load32(Gamma_mem, $x_addr));
-  free ensures (memory_load8_le(mem, 1860bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1861bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1862bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1863bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1860bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1812bv64);
@@ -94,18 +87,12 @@ procedure main();
   requires (memory_load32_le(mem, $z_addr) == 0bv32);
   free requires (memory_load64_le(mem, 69664bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
-  free requires (memory_load8_le(mem, 1860bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1861bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1862bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1863bv64) == 0bv8);
+  free requires (memory_load32_le(mem, 1860bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free requires (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free requires (memory_load64_le(mem, 69592bv64) == 1812bv64);
   free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
-  free ensures (memory_load8_le(mem, 1860bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1861bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1862bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1863bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1860bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1812bv64);
diff --git a/src/test/correct/secret_write/clang_O2/secret_write_gtirb.expected b/src/test/correct/secret_write/clang_O2/secret_write_gtirb.expected
index 8e15ef31b..289dadb93 100644
--- a/src/test/correct/secret_write/clang_O2/secret_write_gtirb.expected
+++ b/src/test/correct/secret_write/clang_O2/secret_write_gtirb.expected
@@ -14,8 +14,8 @@ const {:extern} $x_addr: bv64;
 axiom ($x_addr == 69692bv64);
 const {:extern} $z_addr: bv64;
 axiom ($z_addr == 69684bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
-  (if (index == $secret_addr) then false else (if (index == $x_addr) then (bvsmod32(memory_load32_le(memory, $z_addr), 2bv32) == 0bv32) else (if (index == $z_addr) then true else false)))
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
+  (if (index == $secret_addr) then false else (if (index == $x_addr) then (bvsmod32(memory_load32_le(mem$in, $z_addr), 2bv32) == 0bv32) else (if (index == $z_addr) then true else false)))
 }
 
 function {:extern} {:bvbuiltin "bvadd"} bvadd64(bv64, bv64) returns (bv64);
@@ -37,10 +37,6 @@ function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv6
   (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
-}
-
 function {:extern} memory_store32_le(memory: [bv64]bv8, index: bv64, value: bv32) returns ([bv64]bv8) {
   memory[index := value[8:0]][bvadd64(index, 1bv64) := value[16:8]][bvadd64(index, 2bv64) := value[24:16]][bvadd64(index, 3bv64) := value[32:24]]
 }
@@ -50,10 +46,7 @@ procedure {:extern} rely();
   ensures (forall i: bv64 :: (((mem[i] == old(mem[i])) ==> (Gamma_mem[i] == old(Gamma_mem[i])))));
   ensures (memory_load32_le(mem, $z_addr) == old(memory_load32_le(mem, $z_addr)));
   ensures (old(gamma_load32(Gamma_mem, $x_addr)) ==> gamma_load32(Gamma_mem, $x_addr));
-  free ensures (memory_load8_le(mem, 1860bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1861bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1862bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1863bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1860bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1812bv64);
@@ -94,18 +87,12 @@ procedure main();
   requires (memory_load32_le(mem, $z_addr) == 0bv32);
   free requires (memory_load64_le(mem, 69664bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
-  free requires (memory_load8_le(mem, 1860bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1861bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1862bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1863bv64) == 0bv8);
+  free requires (memory_load32_le(mem, 1860bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free requires (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free requires (memory_load64_le(mem, 69592bv64) == 1812bv64);
   free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
-  free ensures (memory_load8_le(mem, 1860bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1861bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1862bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1863bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1860bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1812bv64);
diff --git a/src/test/correct/secret_write/clang_pic/secret_write.expected b/src/test/correct/secret_write/clang_pic/secret_write.expected
index ec9017dde..c6a6d5878 100644
--- a/src/test/correct/secret_write/clang_pic/secret_write.expected
+++ b/src/test/correct/secret_write/clang_pic/secret_write.expected
@@ -14,8 +14,8 @@ const {:extern} $x_addr: bv64;
 axiom ($x_addr == 69692bv64);
 const {:extern} $z_addr: bv64;
 axiom ($z_addr == 69684bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
-  (if (index == $secret_addr) then false else (if (index == $x_addr) then (bvsmod32(memory_load32_le(memory, $z_addr), 2bv32) == 0bv32) else (if (index == $z_addr) then true else false)))
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
+  (if (index == $secret_addr) then false else (if (index == $x_addr) then (bvsmod32(memory_load32_le(mem$in, $z_addr), 2bv32) == 0bv32) else (if (index == $z_addr) then true else false)))
 }
 
 function {:extern} {:bvbuiltin "bvadd"} bvadd32(bv32, bv32) returns (bv32);
@@ -42,10 +42,6 @@ function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv6
   (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
-}
-
 function {:extern} memory_store32_le(memory: [bv64]bv8, index: bv64, value: bv32) returns ([bv64]bv8) {
   memory[index := value[8:0]][bvadd64(index, 1bv64) := value[16:8]][bvadd64(index, 2bv64) := value[24:16]][bvadd64(index, 3bv64) := value[32:24]]
 }
@@ -56,17 +52,14 @@ procedure {:extern} rely();
   ensures (forall i: bv64 :: (((mem[i] == old(mem[i])) ==> (Gamma_mem[i] == old(Gamma_mem[i])))));
   ensures (memory_load32_le(mem, $z_addr) == old(memory_load32_le(mem, $z_addr)));
   ensures (old(gamma_load32(Gamma_mem, $x_addr)) ==> gamma_load32(Gamma_mem, $x_addr));
-  free ensures (memory_load8_le(mem, 1968bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1969bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1970bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1971bv64) == 0bv8);
-  free ensures (memory_load64_le(mem, 69672bv64) == 69672bv64);
-  free ensures (memory_load64_le(mem, 69584bv64) == 69688bv64);
-  free ensures (memory_load64_le(mem, 69048bv64) == 1792bv64);
+  free ensures (memory_load32_le(mem, 1968bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69040bv64) == 1872bv64);
+  free ensures (memory_load64_le(mem, 69048bv64) == 1792bv64);
+  free ensures (memory_load64_le(mem, 69560bv64) == 69684bv64);
   free ensures (memory_load64_le(mem, 69568bv64) == 69692bv64);
+  free ensures (memory_load64_le(mem, 69584bv64) == 69688bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1876bv64);
-  free ensures (memory_load64_le(mem, 69560bv64) == 69684bv64);
+  free ensures (memory_load64_le(mem, 69672bv64) == 69672bv64);
 
 procedure {:extern} rely_transitive();
   modifies Gamma_mem, mem;
@@ -103,28 +96,22 @@ procedure main();
   requires (memory_load32_le(mem, $z_addr) == 0bv32);
   free requires (memory_load64_le(mem, 69664bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
-  free requires (memory_load8_le(mem, 1968bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1969bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1970bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1971bv64) == 0bv8);
-  free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
-  free requires (memory_load64_le(mem, 69584bv64) == 69688bv64);
-  free requires (memory_load64_le(mem, 69048bv64) == 1792bv64);
+  free requires (memory_load32_le(mem, 1968bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69040bv64) == 1872bv64);
+  free requires (memory_load64_le(mem, 69048bv64) == 1792bv64);
+  free requires (memory_load64_le(mem, 69560bv64) == 69684bv64);
   free requires (memory_load64_le(mem, 69568bv64) == 69692bv64);
+  free requires (memory_load64_le(mem, 69584bv64) == 69688bv64);
   free requires (memory_load64_le(mem, 69592bv64) == 1876bv64);
-  free requires (memory_load64_le(mem, 69560bv64) == 69684bv64);
-  free ensures (memory_load8_le(mem, 1968bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1969bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1970bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1971bv64) == 0bv8);
-  free ensures (memory_load64_le(mem, 69672bv64) == 69672bv64);
-  free ensures (memory_load64_le(mem, 69584bv64) == 69688bv64);
-  free ensures (memory_load64_le(mem, 69048bv64) == 1792bv64);
+  free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
+  free ensures (memory_load32_le(mem, 1968bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69040bv64) == 1872bv64);
+  free ensures (memory_load64_le(mem, 69048bv64) == 1792bv64);
+  free ensures (memory_load64_le(mem, 69560bv64) == 69684bv64);
   free ensures (memory_load64_le(mem, 69568bv64) == 69692bv64);
+  free ensures (memory_load64_le(mem, 69584bv64) == 69688bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1876bv64);
-  free ensures (memory_load64_le(mem, 69560bv64) == 69684bv64);
+  free ensures (memory_load64_le(mem, 69672bv64) == 69672bv64);
 
 implementation main()
 {
diff --git a/src/test/correct/secret_write/clang_pic/secret_write_gtirb.expected b/src/test/correct/secret_write/clang_pic/secret_write_gtirb.expected
index 848e9040c..5d1c612d0 100644
--- a/src/test/correct/secret_write/clang_pic/secret_write_gtirb.expected
+++ b/src/test/correct/secret_write/clang_pic/secret_write_gtirb.expected
@@ -14,8 +14,8 @@ const {:extern} $x_addr: bv64;
 axiom ($x_addr == 69692bv64);
 const {:extern} $z_addr: bv64;
 axiom ($z_addr == 69684bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
-  (if (index == $secret_addr) then false else (if (index == $x_addr) then (bvsmod32(memory_load32_le(memory, $z_addr), 2bv32) == 0bv32) else (if (index == $z_addr) then true else false)))
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
+  (if (index == $secret_addr) then false else (if (index == $x_addr) then (bvsmod32(memory_load32_le(mem$in, $z_addr), 2bv32) == 0bv32) else (if (index == $z_addr) then true else false)))
 }
 
 function {:extern} {:bvbuiltin "bvadd"} bvadd32(bv32, bv32) returns (bv32);
@@ -42,10 +42,6 @@ function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv6
   (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
-}
-
 function {:extern} memory_store32_le(memory: [bv64]bv8, index: bv64, value: bv32) returns ([bv64]bv8) {
   memory[index := value[8:0]][bvadd64(index, 1bv64) := value[16:8]][bvadd64(index, 2bv64) := value[24:16]][bvadd64(index, 3bv64) := value[32:24]]
 }
@@ -56,17 +52,14 @@ procedure {:extern} rely();
   ensures (forall i: bv64 :: (((mem[i] == old(mem[i])) ==> (Gamma_mem[i] == old(Gamma_mem[i])))));
   ensures (memory_load32_le(mem, $z_addr) == old(memory_load32_le(mem, $z_addr)));
   ensures (old(gamma_load32(Gamma_mem, $x_addr)) ==> gamma_load32(Gamma_mem, $x_addr));
-  free ensures (memory_load8_le(mem, 1968bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1969bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1970bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1971bv64) == 0bv8);
-  free ensures (memory_load64_le(mem, 69672bv64) == 69672bv64);
-  free ensures (memory_load64_le(mem, 69584bv64) == 69688bv64);
-  free ensures (memory_load64_le(mem, 69048bv64) == 1792bv64);
+  free ensures (memory_load32_le(mem, 1968bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69040bv64) == 1872bv64);
+  free ensures (memory_load64_le(mem, 69048bv64) == 1792bv64);
+  free ensures (memory_load64_le(mem, 69560bv64) == 69684bv64);
   free ensures (memory_load64_le(mem, 69568bv64) == 69692bv64);
+  free ensures (memory_load64_le(mem, 69584bv64) == 69688bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1876bv64);
-  free ensures (memory_load64_le(mem, 69560bv64) == 69684bv64);
+  free ensures (memory_load64_le(mem, 69672bv64) == 69672bv64);
 
 procedure {:extern} rely_transitive();
   modifies Gamma_mem, mem;
@@ -103,28 +96,22 @@ procedure main();
   requires (memory_load32_le(mem, $z_addr) == 0bv32);
   free requires (memory_load64_le(mem, 69664bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
-  free requires (memory_load8_le(mem, 1968bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1969bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1970bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1971bv64) == 0bv8);
-  free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
-  free requires (memory_load64_le(mem, 69584bv64) == 69688bv64);
-  free requires (memory_load64_le(mem, 69048bv64) == 1792bv64);
+  free requires (memory_load32_le(mem, 1968bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69040bv64) == 1872bv64);
+  free requires (memory_load64_le(mem, 69048bv64) == 1792bv64);
+  free requires (memory_load64_le(mem, 69560bv64) == 69684bv64);
   free requires (memory_load64_le(mem, 69568bv64) == 69692bv64);
+  free requires (memory_load64_le(mem, 69584bv64) == 69688bv64);
   free requires (memory_load64_le(mem, 69592bv64) == 1876bv64);
-  free requires (memory_load64_le(mem, 69560bv64) == 69684bv64);
-  free ensures (memory_load8_le(mem, 1968bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1969bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1970bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1971bv64) == 0bv8);
-  free ensures (memory_load64_le(mem, 69672bv64) == 69672bv64);
-  free ensures (memory_load64_le(mem, 69584bv64) == 69688bv64);
-  free ensures (memory_load64_le(mem, 69048bv64) == 1792bv64);
+  free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
+  free ensures (memory_load32_le(mem, 1968bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69040bv64) == 1872bv64);
+  free ensures (memory_load64_le(mem, 69048bv64) == 1792bv64);
+  free ensures (memory_load64_le(mem, 69560bv64) == 69684bv64);
   free ensures (memory_load64_le(mem, 69568bv64) == 69692bv64);
+  free ensures (memory_load64_le(mem, 69584bv64) == 69688bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1876bv64);
-  free ensures (memory_load64_le(mem, 69560bv64) == 69684bv64);
+  free ensures (memory_load64_le(mem, 69672bv64) == 69672bv64);
 
 implementation main()
 {
diff --git a/src/test/correct/secret_write/gcc/secret_write.expected b/src/test/correct/secret_write/gcc/secret_write.expected
index c0e03ae6f..af58dd477 100644
--- a/src/test/correct/secret_write/gcc/secret_write.expected
+++ b/src/test/correct/secret_write/gcc/secret_write.expected
@@ -10,8 +10,8 @@ const {:extern} $x_addr: bv64;
 axiom ($x_addr == 69656bv64);
 const {:extern} $z_addr: bv64;
 axiom ($z_addr == 69652bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
-  (if (index == $secret_addr) then false else (if (index == $x_addr) then (bvsmod32(memory_load32_le(memory, $z_addr), 2bv32) == 0bv32) else (if (index == $z_addr) then true else false)))
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
+  (if (index == $secret_addr) then false else (if (index == $x_addr) then (bvsmod32(memory_load32_le(mem$in, $z_addr), 2bv32) == 0bv32) else (if (index == $z_addr) then true else false)))
 }
 
 function {:extern} {:bvbuiltin "bvadd"} bvadd32(bv32, bv32) returns (bv32);
@@ -34,10 +34,6 @@ function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv6
   (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
-}
-
 function {:extern} memory_store32_le(memory: [bv64]bv8, index: bv64, value: bv32) returns ([bv64]bv8) {
   memory[index := value[8:0]][bvadd64(index, 1bv64) := value[16:8]][bvadd64(index, 2bv64) := value[24:16]][bvadd64(index, 3bv64) := value[32:24]]
 }
@@ -48,10 +44,7 @@ procedure {:extern} rely();
   ensures (forall i: bv64 :: (((mem[i] == old(mem[i])) ==> (Gamma_mem[i] == old(Gamma_mem[i])))));
   ensures (memory_load32_le(mem, $z_addr) == old(memory_load32_le(mem, $z_addr)));
   ensures (old(gamma_load32(Gamma_mem, $x_addr)) ==> gamma_load32(Gamma_mem, $x_addr));
-  free ensures (memory_load8_le(mem, 1944bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1945bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1946bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1947bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1944bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69016bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69024bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69616bv64) == 1812bv64);
@@ -92,18 +85,12 @@ procedure main();
   requires (memory_load32_le(mem, $z_addr) == 0bv32);
   free requires (memory_load64_le(mem, 69632bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free requires (memory_load8_le(mem, 1944bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1945bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1946bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1947bv64) == 0bv8);
+  free requires (memory_load32_le(mem, 1944bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69016bv64) == 1808bv64);
   free requires (memory_load64_le(mem, 69024bv64) == 1728bv64);
   free requires (memory_load64_le(mem, 69616bv64) == 1812bv64);
   free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free ensures (memory_load8_le(mem, 1944bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1945bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1946bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1947bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1944bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69016bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69024bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69616bv64) == 1812bv64);
diff --git a/src/test/correct/secret_write/gcc/secret_write_gtirb.expected b/src/test/correct/secret_write/gcc/secret_write_gtirb.expected
index 38bbdd467..29dca0c16 100644
--- a/src/test/correct/secret_write/gcc/secret_write_gtirb.expected
+++ b/src/test/correct/secret_write/gcc/secret_write_gtirb.expected
@@ -10,8 +10,8 @@ const {:extern} $x_addr: bv64;
 axiom ($x_addr == 69656bv64);
 const {:extern} $z_addr: bv64;
 axiom ($z_addr == 69652bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
-  (if (index == $secret_addr) then false else (if (index == $x_addr) then (bvsmod32(memory_load32_le(memory, $z_addr), 2bv32) == 0bv32) else (if (index == $z_addr) then true else false)))
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
+  (if (index == $secret_addr) then false else (if (index == $x_addr) then (bvsmod32(memory_load32_le(mem$in, $z_addr), 2bv32) == 0bv32) else (if (index == $z_addr) then true else false)))
 }
 
 function {:extern} {:bvbuiltin "bvadd"} bvadd32(bv32, bv32) returns (bv32);
@@ -34,10 +34,6 @@ function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv6
   (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
-}
-
 function {:extern} memory_store32_le(memory: [bv64]bv8, index: bv64, value: bv32) returns ([bv64]bv8) {
   memory[index := value[8:0]][bvadd64(index, 1bv64) := value[16:8]][bvadd64(index, 2bv64) := value[24:16]][bvadd64(index, 3bv64) := value[32:24]]
 }
@@ -48,10 +44,7 @@ procedure {:extern} rely();
   ensures (forall i: bv64 :: (((mem[i] == old(mem[i])) ==> (Gamma_mem[i] == old(Gamma_mem[i])))));
   ensures (memory_load32_le(mem, $z_addr) == old(memory_load32_le(mem, $z_addr)));
   ensures (old(gamma_load32(Gamma_mem, $x_addr)) ==> gamma_load32(Gamma_mem, $x_addr));
-  free ensures (memory_load8_le(mem, 1944bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1945bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1946bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1947bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1944bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69016bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69024bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69616bv64) == 1812bv64);
@@ -92,18 +85,12 @@ procedure main();
   requires (memory_load32_le(mem, $z_addr) == 0bv32);
   free requires (memory_load64_le(mem, 69632bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free requires (memory_load8_le(mem, 1944bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1945bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1946bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1947bv64) == 0bv8);
+  free requires (memory_load32_le(mem, 1944bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69016bv64) == 1808bv64);
   free requires (memory_load64_le(mem, 69024bv64) == 1728bv64);
   free requires (memory_load64_le(mem, 69616bv64) == 1812bv64);
   free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free ensures (memory_load8_le(mem, 1944bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1945bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1946bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1947bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1944bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69016bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69024bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69616bv64) == 1812bv64);
diff --git a/src/test/correct/secret_write/gcc_O2/secret_write.expected b/src/test/correct/secret_write/gcc_O2/secret_write.expected
index 0f26390fb..543cf34f9 100644
--- a/src/test/correct/secret_write/gcc_O2/secret_write.expected
+++ b/src/test/correct/secret_write/gcc_O2/secret_write.expected
@@ -14,8 +14,8 @@ const {:extern} $x_addr: bv64;
 axiom ($x_addr == 69652bv64);
 const {:extern} $z_addr: bv64;
 axiom ($z_addr == 69656bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
-  (if (index == $secret_addr) then false else (if (index == $x_addr) then (bvsmod32(memory_load32_le(memory, $z_addr), 2bv32) == 0bv32) else (if (index == $z_addr) then true else false)))
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
+  (if (index == $secret_addr) then false else (if (index == $x_addr) then (bvsmod32(memory_load32_le(mem$in, $z_addr), 2bv32) == 0bv32) else (if (index == $z_addr) then true else false)))
 }
 
 function {:extern} {:bvbuiltin "bvadd"} bvadd64(bv64, bv64) returns (bv64);
@@ -37,10 +37,6 @@ function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv6
   (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
-}
-
 function {:extern} memory_store32_le(memory: [bv64]bv8, index: bv64, value: bv32) returns ([bv64]bv8) {
   memory[index := value[8:0]][bvadd64(index, 1bv64) := value[16:8]][bvadd64(index, 2bv64) := value[24:16]][bvadd64(index, 3bv64) := value[32:24]]
 }
@@ -50,10 +46,7 @@ procedure {:extern} rely();
   ensures (forall i: bv64 :: (((mem[i] == old(mem[i])) ==> (Gamma_mem[i] == old(Gamma_mem[i])))));
   ensures (memory_load32_le(mem, $z_addr) == old(memory_load32_le(mem, $z_addr)));
   ensures (old(gamma_load32(Gamma_mem, $x_addr)) ==> gamma_load32(Gamma_mem, $x_addr));
-  free ensures (memory_load8_le(mem, 1896bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1897bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1898bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1899bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1896bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69016bv64) == 1872bv64);
   free ensures (memory_load64_le(mem, 69024bv64) == 1792bv64);
   free ensures (memory_load64_le(mem, 69616bv64) == 1536bv64);
@@ -94,18 +87,12 @@ procedure main();
   requires (memory_load32_le(mem, $z_addr) == 0bv32);
   free requires (memory_load64_le(mem, 69632bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free requires (memory_load8_le(mem, 1896bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1897bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1898bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1899bv64) == 0bv8);
+  free requires (memory_load32_le(mem, 1896bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69016bv64) == 1872bv64);
   free requires (memory_load64_le(mem, 69024bv64) == 1792bv64);
   free requires (memory_load64_le(mem, 69616bv64) == 1536bv64);
   free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free ensures (memory_load8_le(mem, 1896bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1897bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1898bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1899bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1896bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69016bv64) == 1872bv64);
   free ensures (memory_load64_le(mem, 69024bv64) == 1792bv64);
   free ensures (memory_load64_le(mem, 69616bv64) == 1536bv64);
diff --git a/src/test/correct/secret_write/gcc_O2/secret_write_gtirb.expected b/src/test/correct/secret_write/gcc_O2/secret_write_gtirb.expected
index 7af63a49b..84db56744 100644
--- a/src/test/correct/secret_write/gcc_O2/secret_write_gtirb.expected
+++ b/src/test/correct/secret_write/gcc_O2/secret_write_gtirb.expected
@@ -14,8 +14,8 @@ const {:extern} $x_addr: bv64;
 axiom ($x_addr == 69652bv64);
 const {:extern} $z_addr: bv64;
 axiom ($z_addr == 69656bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
-  (if (index == $secret_addr) then false else (if (index == $x_addr) then (bvsmod32(memory_load32_le(memory, $z_addr), 2bv32) == 0bv32) else (if (index == $z_addr) then true else false)))
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
+  (if (index == $secret_addr) then false else (if (index == $x_addr) then (bvsmod32(memory_load32_le(mem$in, $z_addr), 2bv32) == 0bv32) else (if (index == $z_addr) then true else false)))
 }
 
 function {:extern} {:bvbuiltin "bvadd"} bvadd64(bv64, bv64) returns (bv64);
@@ -37,10 +37,6 @@ function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv6
   (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
-}
-
 function {:extern} memory_store32_le(memory: [bv64]bv8, index: bv64, value: bv32) returns ([bv64]bv8) {
   memory[index := value[8:0]][bvadd64(index, 1bv64) := value[16:8]][bvadd64(index, 2bv64) := value[24:16]][bvadd64(index, 3bv64) := value[32:24]]
 }
@@ -50,10 +46,7 @@ procedure {:extern} rely();
   ensures (forall i: bv64 :: (((mem[i] == old(mem[i])) ==> (Gamma_mem[i] == old(Gamma_mem[i])))));
   ensures (memory_load32_le(mem, $z_addr) == old(memory_load32_le(mem, $z_addr)));
   ensures (old(gamma_load32(Gamma_mem, $x_addr)) ==> gamma_load32(Gamma_mem, $x_addr));
-  free ensures (memory_load8_le(mem, 1896bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1897bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1898bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1899bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1896bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69016bv64) == 1872bv64);
   free ensures (memory_load64_le(mem, 69024bv64) == 1792bv64);
   free ensures (memory_load64_le(mem, 69616bv64) == 1536bv64);
@@ -94,18 +87,12 @@ procedure main();
   requires (memory_load32_le(mem, $z_addr) == 0bv32);
   free requires (memory_load64_le(mem, 69632bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free requires (memory_load8_le(mem, 1896bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1897bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1898bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1899bv64) == 0bv8);
+  free requires (memory_load32_le(mem, 1896bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69016bv64) == 1872bv64);
   free requires (memory_load64_le(mem, 69024bv64) == 1792bv64);
   free requires (memory_load64_le(mem, 69616bv64) == 1536bv64);
   free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free ensures (memory_load8_le(mem, 1896bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1897bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1898bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1899bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1896bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69016bv64) == 1872bv64);
   free ensures (memory_load64_le(mem, 69024bv64) == 1792bv64);
   free ensures (memory_load64_le(mem, 69616bv64) == 1536bv64);
diff --git a/src/test/correct/secret_write/gcc_pic/secret_write.expected b/src/test/correct/secret_write/gcc_pic/secret_write.expected
index 64d5aff6b..1b1aa27ca 100644
--- a/src/test/correct/secret_write/gcc_pic/secret_write.expected
+++ b/src/test/correct/secret_write/gcc_pic/secret_write.expected
@@ -10,8 +10,8 @@ const {:extern} $x_addr: bv64;
 axiom ($x_addr == 69656bv64);
 const {:extern} $z_addr: bv64;
 axiom ($z_addr == 69652bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
-  (if (index == $secret_addr) then false else (if (index == $x_addr) then (bvsmod32(memory_load32_le(memory, $z_addr), 2bv32) == 0bv32) else (if (index == $z_addr) then true else false)))
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
+  (if (index == $secret_addr) then false else (if (index == $x_addr) then (bvsmod32(memory_load32_le(mem$in, $z_addr), 2bv32) == 0bv32) else (if (index == $z_addr) then true else false)))
 }
 
 function {:extern} {:bvbuiltin "bvadd"} bvadd32(bv32, bv32) returns (bv32);
@@ -38,10 +38,6 @@ function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv6
   (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
-}
-
 function {:extern} memory_store32_le(memory: [bv64]bv8, index: bv64, value: bv32) returns ([bv64]bv8) {
   memory[index := value[8:0]][bvadd64(index, 1bv64) := value[16:8]][bvadd64(index, 2bv64) := value[24:16]][bvadd64(index, 3bv64) := value[32:24]]
 }
@@ -52,17 +48,14 @@ procedure {:extern} rely();
   ensures (forall i: bv64 :: (((mem[i] == old(mem[i])) ==> (Gamma_mem[i] == old(Gamma_mem[i])))));
   ensures (memory_load32_le(mem, $z_addr) == old(memory_load32_le(mem, $z_addr)));
   ensures (old(gamma_load32(Gamma_mem, $x_addr)) ==> gamma_load32(Gamma_mem, $x_addr));
-  free ensures (memory_load8_le(mem, 2008bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 2009bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 2010bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 2011bv64) == 0bv8);
-  free ensures (memory_load64_le(mem, 69608bv64) == 69660bv64);
-  free ensures (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free ensures (memory_load64_le(mem, 69616bv64) == 1876bv64);
+  free ensures (memory_load32_le(mem, 2008bv64) == 131073bv32);
+  free ensures (memory_load64_le(mem, 68992bv64) == 1872bv64);
+  free ensures (memory_load64_le(mem, 69000bv64) == 1792bv64);
   free ensures (memory_load64_le(mem, 69584bv64) == 69652bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 69656bv64);
-  free ensures (memory_load64_le(mem, 69000bv64) == 1792bv64);
-  free ensures (memory_load64_le(mem, 68992bv64) == 1872bv64);
+  free ensures (memory_load64_le(mem, 69608bv64) == 69660bv64);
+  free ensures (memory_load64_le(mem, 69616bv64) == 1876bv64);
+  free ensures (memory_load64_le(mem, 69640bv64) == 69640bv64);
 
 procedure {:extern} rely_transitive();
   modifies Gamma_mem, mem;
@@ -99,28 +92,22 @@ procedure main();
   requires (memory_load32_le(mem, $z_addr) == 0bv32);
   free requires (memory_load64_le(mem, 69632bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free requires (memory_load8_le(mem, 2008bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 2009bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 2010bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 2011bv64) == 0bv8);
-  free requires (memory_load64_le(mem, 69608bv64) == 69660bv64);
-  free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free requires (memory_load64_le(mem, 69616bv64) == 1876bv64);
+  free requires (memory_load32_le(mem, 2008bv64) == 131073bv32);
+  free requires (memory_load64_le(mem, 68992bv64) == 1872bv64);
+  free requires (memory_load64_le(mem, 69000bv64) == 1792bv64);
   free requires (memory_load64_le(mem, 69584bv64) == 69652bv64);
   free requires (memory_load64_le(mem, 69592bv64) == 69656bv64);
-  free requires (memory_load64_le(mem, 69000bv64) == 1792bv64);
-  free requires (memory_load64_le(mem, 68992bv64) == 1872bv64);
-  free ensures (memory_load8_le(mem, 2008bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 2009bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 2010bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 2011bv64) == 0bv8);
-  free ensures (memory_load64_le(mem, 69608bv64) == 69660bv64);
-  free ensures (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free ensures (memory_load64_le(mem, 69616bv64) == 1876bv64);
+  free requires (memory_load64_le(mem, 69608bv64) == 69660bv64);
+  free requires (memory_load64_le(mem, 69616bv64) == 1876bv64);
+  free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
+  free ensures (memory_load32_le(mem, 2008bv64) == 131073bv32);
+  free ensures (memory_load64_le(mem, 68992bv64) == 1872bv64);
+  free ensures (memory_load64_le(mem, 69000bv64) == 1792bv64);
   free ensures (memory_load64_le(mem, 69584bv64) == 69652bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 69656bv64);
-  free ensures (memory_load64_le(mem, 69000bv64) == 1792bv64);
-  free ensures (memory_load64_le(mem, 68992bv64) == 1872bv64);
+  free ensures (memory_load64_le(mem, 69608bv64) == 69660bv64);
+  free ensures (memory_load64_le(mem, 69616bv64) == 1876bv64);
+  free ensures (memory_load64_le(mem, 69640bv64) == 69640bv64);
 
 implementation main()
 {
diff --git a/src/test/correct/secret_write/gcc_pic/secret_write_gtirb.expected b/src/test/correct/secret_write/gcc_pic/secret_write_gtirb.expected
index e7f9eb3a1..9ad582f9c 100644
--- a/src/test/correct/secret_write/gcc_pic/secret_write_gtirb.expected
+++ b/src/test/correct/secret_write/gcc_pic/secret_write_gtirb.expected
@@ -10,8 +10,8 @@ const {:extern} $x_addr: bv64;
 axiom ($x_addr == 69656bv64);
 const {:extern} $z_addr: bv64;
 axiom ($z_addr == 69652bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
-  (if (index == $secret_addr) then false else (if (index == $x_addr) then (bvsmod32(memory_load32_le(memory, $z_addr), 2bv32) == 0bv32) else (if (index == $z_addr) then true else false)))
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
+  (if (index == $secret_addr) then false else (if (index == $x_addr) then (bvsmod32(memory_load32_le(mem$in, $z_addr), 2bv32) == 0bv32) else (if (index == $z_addr) then true else false)))
 }
 
 function {:extern} {:bvbuiltin "bvadd"} bvadd32(bv32, bv32) returns (bv32);
@@ -38,10 +38,6 @@ function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv6
   (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
-}
-
 function {:extern} memory_store32_le(memory: [bv64]bv8, index: bv64, value: bv32) returns ([bv64]bv8) {
   memory[index := value[8:0]][bvadd64(index, 1bv64) := value[16:8]][bvadd64(index, 2bv64) := value[24:16]][bvadd64(index, 3bv64) := value[32:24]]
 }
@@ -52,17 +48,14 @@ procedure {:extern} rely();
   ensures (forall i: bv64 :: (((mem[i] == old(mem[i])) ==> (Gamma_mem[i] == old(Gamma_mem[i])))));
   ensures (memory_load32_le(mem, $z_addr) == old(memory_load32_le(mem, $z_addr)));
   ensures (old(gamma_load32(Gamma_mem, $x_addr)) ==> gamma_load32(Gamma_mem, $x_addr));
-  free ensures (memory_load8_le(mem, 2008bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 2009bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 2010bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 2011bv64) == 0bv8);
-  free ensures (memory_load64_le(mem, 69608bv64) == 69660bv64);
-  free ensures (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free ensures (memory_load64_le(mem, 69616bv64) == 1876bv64);
+  free ensures (memory_load32_le(mem, 2008bv64) == 131073bv32);
+  free ensures (memory_load64_le(mem, 68992bv64) == 1872bv64);
+  free ensures (memory_load64_le(mem, 69000bv64) == 1792bv64);
   free ensures (memory_load64_le(mem, 69584bv64) == 69652bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 69656bv64);
-  free ensures (memory_load64_le(mem, 69000bv64) == 1792bv64);
-  free ensures (memory_load64_le(mem, 68992bv64) == 1872bv64);
+  free ensures (memory_load64_le(mem, 69608bv64) == 69660bv64);
+  free ensures (memory_load64_le(mem, 69616bv64) == 1876bv64);
+  free ensures (memory_load64_le(mem, 69640bv64) == 69640bv64);
 
 procedure {:extern} rely_transitive();
   modifies Gamma_mem, mem;
@@ -99,28 +92,22 @@ procedure main();
   requires (memory_load32_le(mem, $z_addr) == 0bv32);
   free requires (memory_load64_le(mem, 69632bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free requires (memory_load8_le(mem, 2008bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 2009bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 2010bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 2011bv64) == 0bv8);
-  free requires (memory_load64_le(mem, 69608bv64) == 69660bv64);
-  free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free requires (memory_load64_le(mem, 69616bv64) == 1876bv64);
+  free requires (memory_load32_le(mem, 2008bv64) == 131073bv32);
+  free requires (memory_load64_le(mem, 68992bv64) == 1872bv64);
+  free requires (memory_load64_le(mem, 69000bv64) == 1792bv64);
   free requires (memory_load64_le(mem, 69584bv64) == 69652bv64);
   free requires (memory_load64_le(mem, 69592bv64) == 69656bv64);
-  free requires (memory_load64_le(mem, 69000bv64) == 1792bv64);
-  free requires (memory_load64_le(mem, 68992bv64) == 1872bv64);
-  free ensures (memory_load8_le(mem, 2008bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 2009bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 2010bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 2011bv64) == 0bv8);
-  free ensures (memory_load64_le(mem, 69608bv64) == 69660bv64);
-  free ensures (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free ensures (memory_load64_le(mem, 69616bv64) == 1876bv64);
+  free requires (memory_load64_le(mem, 69608bv64) == 69660bv64);
+  free requires (memory_load64_le(mem, 69616bv64) == 1876bv64);
+  free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
+  free ensures (memory_load32_le(mem, 2008bv64) == 131073bv32);
+  free ensures (memory_load64_le(mem, 68992bv64) == 1872bv64);
+  free ensures (memory_load64_le(mem, 69000bv64) == 1792bv64);
   free ensures (memory_load64_le(mem, 69584bv64) == 69652bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 69656bv64);
-  free ensures (memory_load64_le(mem, 69000bv64) == 1792bv64);
-  free ensures (memory_load64_le(mem, 68992bv64) == 1872bv64);
+  free ensures (memory_load64_le(mem, 69608bv64) == 69660bv64);
+  free ensures (memory_load64_le(mem, 69616bv64) == 1876bv64);
+  free ensures (memory_load64_le(mem, 69640bv64) == 69640bv64);
 
 implementation main()
 {
diff --git a/src/test/correct/switch/clang/switch.expected b/src/test/correct/switch/clang/switch.expected
index f6a079d18..71ad0b07a 100644
--- a/src/test/correct/switch/clang/switch.expected
+++ b/src/test/correct/switch/clang/switch.expected
@@ -39,10 +39,6 @@ function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv6
   (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
-}
-
 function {:extern} memory_store32_le(memory: [bv64]bv8, index: bv64, value: bv32) returns ([bv64]bv8) {
   memory[index := value[8:0]][bvadd64(index, 1bv64) := value[16:8]][bvadd64(index, 2bv64) := value[24:16]][bvadd64(index, 3bv64) := value[32:24]]
 }
@@ -52,12 +48,9 @@ function {:extern} {:bvbuiltin "zero_extend 1"} zero_extend1_32(bv32) returns (b
 function {:extern} {:bvbuiltin "zero_extend 32"} zero_extend32_32(bv32) returns (bv64);
 procedure {:extern} rely();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
-  free ensures (memory_load8_le(mem, 1936bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1937bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1938bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1939bv64) == 0bv8);
+  ensures (mem == old(mem));
+  free ensures (memory_load32_le(mem, 1936bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1812bv64);
@@ -65,8 +58,8 @@ procedure {:extern} rely();
 
 procedure {:extern} rely_transitive();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
+  ensures (mem == old(mem));
 
 implementation {:extern} rely_transitive()
 {
@@ -83,20 +76,14 @@ procedure main();
   modifies CF, Gamma_CF, Gamma_NF, Gamma_R31, Gamma_R8, Gamma_VF, Gamma_ZF, Gamma_stack, NF, R31, R8, VF, ZF, stack;
   free requires (memory_load64_le(mem, 69664bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
-  free requires (memory_load8_le(mem, 1936bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1937bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1938bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1939bv64) == 0bv8);
+  free requires (memory_load32_le(mem, 1936bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free requires (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free requires (memory_load64_le(mem, 69592bv64) == 1812bv64);
   free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
   free ensures (Gamma_R31 == old(Gamma_R31));
   free ensures (R31 == old(R31));
-  free ensures (memory_load8_le(mem, 1936bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1937bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1938bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1939bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1936bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1812bv64);
diff --git a/src/test/correct/switch/clang/switch_gtirb.expected b/src/test/correct/switch/clang/switch_gtirb.expected
index bbfae8da5..9a0c4ad46 100644
--- a/src/test/correct/switch/clang/switch_gtirb.expected
+++ b/src/test/correct/switch/clang/switch_gtirb.expected
@@ -38,10 +38,6 @@ function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv6
   (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
-}
-
 function {:extern} memory_store32_le(memory: [bv64]bv8, index: bv64, value: bv32) returns ([bv64]bv8) {
   memory[index := value[8:0]][bvadd64(index, 1bv64) := value[16:8]][bvadd64(index, 2bv64) := value[24:16]][bvadd64(index, 3bv64) := value[32:24]]
 }
@@ -51,12 +47,9 @@ function {:extern} {:bvbuiltin "zero_extend 1"} zero_extend1_32(bv32) returns (b
 function {:extern} {:bvbuiltin "zero_extend 32"} zero_extend32_32(bv32) returns (bv64);
 procedure {:extern} rely();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
-  free ensures (memory_load8_le(mem, 1936bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1937bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1938bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1939bv64) == 0bv8);
+  ensures (mem == old(mem));
+  free ensures (memory_load32_le(mem, 1936bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1812bv64);
@@ -64,8 +57,8 @@ procedure {:extern} rely();
 
 procedure {:extern} rely_transitive();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
+  ensures (mem == old(mem));
 
 implementation {:extern} rely_transitive()
 {
@@ -82,20 +75,14 @@ procedure main();
   modifies CF, Gamma_CF, Gamma_NF, Gamma_R31, Gamma_R8, Gamma_VF, Gamma_ZF, Gamma_stack, NF, R31, R8, VF, ZF, stack;
   free requires (memory_load64_le(mem, 69664bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
-  free requires (memory_load8_le(mem, 1936bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1937bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1938bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1939bv64) == 0bv8);
+  free requires (memory_load32_le(mem, 1936bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free requires (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free requires (memory_load64_le(mem, 69592bv64) == 1812bv64);
   free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
   free ensures (Gamma_R31 == old(Gamma_R31));
   free ensures (R31 == old(R31));
-  free ensures (memory_load8_le(mem, 1936bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1937bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1938bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1939bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1936bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1812bv64);
diff --git a/src/test/correct/switch/clang_O2/switch.expected b/src/test/correct/switch/clang_O2/switch.expected
index 074ebb121..63ab24607 100644
--- a/src/test/correct/switch/clang_O2/switch.expected
+++ b/src/test/correct/switch/clang_O2/switch.expected
@@ -3,22 +3,19 @@ var {:extern} mem: [bv64]bv8;
 const {:extern} $_IO_stdin_used_addr: bv64;
 axiom ($_IO_stdin_used_addr == 1836bv64);
 function {:extern} {:bvbuiltin "bvadd"} bvadd64(bv64, bv64) returns (bv64);
-function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv64) {
-  (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
+function {:extern} memory_load32_le(memory: [bv64]bv8, index: bv64) returns (bv32) {
+  (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
+function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv64) {
+  (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
 procedure {:extern} rely();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
-  free ensures (memory_load8_le(mem, 1836bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1837bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1838bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1839bv64) == 0bv8);
+  ensures (mem == old(mem));
+  free ensures (memory_load32_le(mem, 1836bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1812bv64);
@@ -26,8 +23,8 @@ procedure {:extern} rely();
 
 procedure {:extern} rely_transitive();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
+  ensures (mem == old(mem));
 
 implementation {:extern} rely_transitive()
 {
@@ -43,18 +40,12 @@ procedure {:extern} guarantee_reflexive();
 procedure main();
   free requires (memory_load64_le(mem, 69664bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
-  free requires (memory_load8_le(mem, 1836bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1837bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1838bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1839bv64) == 0bv8);
+  free requires (memory_load32_le(mem, 1836bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free requires (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free requires (memory_load64_le(mem, 69592bv64) == 1812bv64);
   free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
-  free ensures (memory_load8_le(mem, 1836bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1837bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1838bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1839bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1836bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1812bv64);
diff --git a/src/test/correct/switch/clang_O2/switch_gtirb.expected b/src/test/correct/switch/clang_O2/switch_gtirb.expected
index 1f07e5df7..6197b5d11 100644
--- a/src/test/correct/switch/clang_O2/switch_gtirb.expected
+++ b/src/test/correct/switch/clang_O2/switch_gtirb.expected
@@ -3,22 +3,19 @@ var {:extern} mem: [bv64]bv8;
 const {:extern} $_IO_stdin_used_addr: bv64;
 axiom ($_IO_stdin_used_addr == 1836bv64);
 function {:extern} {:bvbuiltin "bvadd"} bvadd64(bv64, bv64) returns (bv64);
-function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv64) {
-  (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
+function {:extern} memory_load32_le(memory: [bv64]bv8, index: bv64) returns (bv32) {
+  (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
+function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv64) {
+  (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
 procedure {:extern} rely();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
-  free ensures (memory_load8_le(mem, 1836bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1837bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1838bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1839bv64) == 0bv8);
+  ensures (mem == old(mem));
+  free ensures (memory_load32_le(mem, 1836bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1812bv64);
@@ -26,8 +23,8 @@ procedure {:extern} rely();
 
 procedure {:extern} rely_transitive();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
+  ensures (mem == old(mem));
 
 implementation {:extern} rely_transitive()
 {
@@ -43,18 +40,12 @@ procedure {:extern} guarantee_reflexive();
 procedure main();
   free requires (memory_load64_le(mem, 69664bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
-  free requires (memory_load8_le(mem, 1836bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1837bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1838bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1839bv64) == 0bv8);
+  free requires (memory_load32_le(mem, 1836bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free requires (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free requires (memory_load64_le(mem, 69592bv64) == 1812bv64);
   free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
-  free ensures (memory_load8_le(mem, 1836bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1837bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1838bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1839bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1836bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1812bv64);
diff --git a/src/test/correct/switch/gcc/switch.expected b/src/test/correct/switch/gcc/switch.expected
index af33e269d..b13f88a63 100644
--- a/src/test/correct/switch/gcc/switch.expected
+++ b/src/test/correct/switch/gcc/switch.expected
@@ -39,10 +39,6 @@ function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv6
   (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
-}
-
 function {:extern} memory_store32_le(memory: [bv64]bv8, index: bv64, value: bv32) returns ([bv64]bv8) {
   memory[index := value[8:0]][bvadd64(index, 1bv64) := value[16:8]][bvadd64(index, 2bv64) := value[24:16]][bvadd64(index, 3bv64) := value[32:24]]
 }
@@ -52,12 +48,9 @@ function {:extern} {:bvbuiltin "zero_extend 1"} zero_extend1_32(bv32) returns (b
 function {:extern} {:bvbuiltin "zero_extend 32"} zero_extend32_32(bv32) returns (bv64);
 procedure {:extern} rely();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
-  free ensures (memory_load8_le(mem, 1916bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1917bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1918bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1919bv64) == 0bv8);
+  ensures (mem == old(mem));
+  free ensures (memory_load32_le(mem, 1916bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69016bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69024bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69616bv64) == 1812bv64);
@@ -65,8 +58,8 @@ procedure {:extern} rely();
 
 procedure {:extern} rely_transitive();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
+  ensures (mem == old(mem));
 
 implementation {:extern} rely_transitive()
 {
@@ -83,20 +76,14 @@ procedure main();
   modifies CF, Gamma_CF, Gamma_NF, Gamma_R0, Gamma_R31, Gamma_VF, Gamma_ZF, Gamma_stack, NF, R0, R31, VF, ZF, stack;
   free requires (memory_load64_le(mem, 69632bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free requires (memory_load8_le(mem, 1916bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1917bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1918bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1919bv64) == 0bv8);
+  free requires (memory_load32_le(mem, 1916bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69016bv64) == 1808bv64);
   free requires (memory_load64_le(mem, 69024bv64) == 1728bv64);
   free requires (memory_load64_le(mem, 69616bv64) == 1812bv64);
   free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
   free ensures (Gamma_R31 == old(Gamma_R31));
   free ensures (R31 == old(R31));
-  free ensures (memory_load8_le(mem, 1916bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1917bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1918bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1919bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1916bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69016bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69024bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69616bv64) == 1812bv64);
diff --git a/src/test/correct/switch/gcc/switch_gtirb.expected b/src/test/correct/switch/gcc/switch_gtirb.expected
index 36195f0ef..2d439a7c9 100644
--- a/src/test/correct/switch/gcc/switch_gtirb.expected
+++ b/src/test/correct/switch/gcc/switch_gtirb.expected
@@ -38,10 +38,6 @@ function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv6
   (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
-}
-
 function {:extern} memory_store32_le(memory: [bv64]bv8, index: bv64, value: bv32) returns ([bv64]bv8) {
   memory[index := value[8:0]][bvadd64(index, 1bv64) := value[16:8]][bvadd64(index, 2bv64) := value[24:16]][bvadd64(index, 3bv64) := value[32:24]]
 }
@@ -51,12 +47,9 @@ function {:extern} {:bvbuiltin "zero_extend 1"} zero_extend1_32(bv32) returns (b
 function {:extern} {:bvbuiltin "zero_extend 32"} zero_extend32_32(bv32) returns (bv64);
 procedure {:extern} rely();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
-  free ensures (memory_load8_le(mem, 1916bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1917bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1918bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1919bv64) == 0bv8);
+  ensures (mem == old(mem));
+  free ensures (memory_load32_le(mem, 1916bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69016bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69024bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69616bv64) == 1812bv64);
@@ -64,8 +57,8 @@ procedure {:extern} rely();
 
 procedure {:extern} rely_transitive();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
+  ensures (mem == old(mem));
 
 implementation {:extern} rely_transitive()
 {
@@ -82,20 +75,14 @@ procedure main();
   modifies CF, Gamma_CF, Gamma_NF, Gamma_R0, Gamma_R31, Gamma_VF, Gamma_ZF, Gamma_stack, NF, R0, R31, VF, ZF, stack;
   free requires (memory_load64_le(mem, 69632bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free requires (memory_load8_le(mem, 1916bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1917bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1918bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1919bv64) == 0bv8);
+  free requires (memory_load32_le(mem, 1916bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69016bv64) == 1808bv64);
   free requires (memory_load64_le(mem, 69024bv64) == 1728bv64);
   free requires (memory_load64_le(mem, 69616bv64) == 1812bv64);
   free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
   free ensures (Gamma_R31 == old(Gamma_R31));
   free ensures (R31 == old(R31));
-  free ensures (memory_load8_le(mem, 1916bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1917bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1918bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1919bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1916bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69016bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69024bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69616bv64) == 1812bv64);
diff --git a/src/test/correct/switch/gcc_O2/switch.expected b/src/test/correct/switch/gcc_O2/switch.expected
index f5fe2a468..a1aa0c66c 100644
--- a/src/test/correct/switch/gcc_O2/switch.expected
+++ b/src/test/correct/switch/gcc_O2/switch.expected
@@ -3,22 +3,19 @@ var {:extern} mem: [bv64]bv8;
 const {:extern} $_IO_stdin_used_addr: bv64;
 axiom ($_IO_stdin_used_addr == 1896bv64);
 function {:extern} {:bvbuiltin "bvadd"} bvadd64(bv64, bv64) returns (bv64);
-function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv64) {
-  (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
+function {:extern} memory_load32_le(memory: [bv64]bv8, index: bv64) returns (bv32) {
+  (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
+function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv64) {
+  (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
 procedure {:extern} rely();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
-  free ensures (memory_load8_le(mem, 1896bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1897bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1898bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1899bv64) == 0bv8);
+  ensures (mem == old(mem));
+  free ensures (memory_load32_le(mem, 1896bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69016bv64) == 1872bv64);
   free ensures (memory_load64_le(mem, 69024bv64) == 1792bv64);
   free ensures (memory_load64_le(mem, 69616bv64) == 1536bv64);
@@ -26,8 +23,8 @@ procedure {:extern} rely();
 
 procedure {:extern} rely_transitive();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
+  ensures (mem == old(mem));
 
 implementation {:extern} rely_transitive()
 {
@@ -43,18 +40,12 @@ procedure {:extern} guarantee_reflexive();
 procedure main();
   free requires (memory_load64_le(mem, 69632bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free requires (memory_load8_le(mem, 1896bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1897bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1898bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1899bv64) == 0bv8);
+  free requires (memory_load32_le(mem, 1896bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69016bv64) == 1872bv64);
   free requires (memory_load64_le(mem, 69024bv64) == 1792bv64);
   free requires (memory_load64_le(mem, 69616bv64) == 1536bv64);
   free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free ensures (memory_load8_le(mem, 1896bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1897bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1898bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1899bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1896bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69016bv64) == 1872bv64);
   free ensures (memory_load64_le(mem, 69024bv64) == 1792bv64);
   free ensures (memory_load64_le(mem, 69616bv64) == 1536bv64);
diff --git a/src/test/correct/switch/gcc_O2/switch_gtirb.expected b/src/test/correct/switch/gcc_O2/switch_gtirb.expected
index a87f9b510..aca746161 100644
--- a/src/test/correct/switch/gcc_O2/switch_gtirb.expected
+++ b/src/test/correct/switch/gcc_O2/switch_gtirb.expected
@@ -3,22 +3,19 @@ var {:extern} mem: [bv64]bv8;
 const {:extern} $_IO_stdin_used_addr: bv64;
 axiom ($_IO_stdin_used_addr == 1896bv64);
 function {:extern} {:bvbuiltin "bvadd"} bvadd64(bv64, bv64) returns (bv64);
-function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv64) {
-  (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
+function {:extern} memory_load32_le(memory: [bv64]bv8, index: bv64) returns (bv32) {
+  (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
+function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv64) {
+  (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
 procedure {:extern} rely();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
-  free ensures (memory_load8_le(mem, 1896bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1897bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1898bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1899bv64) == 0bv8);
+  ensures (mem == old(mem));
+  free ensures (memory_load32_le(mem, 1896bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69016bv64) == 1872bv64);
   free ensures (memory_load64_le(mem, 69024bv64) == 1792bv64);
   free ensures (memory_load64_le(mem, 69616bv64) == 1536bv64);
@@ -26,8 +23,8 @@ procedure {:extern} rely();
 
 procedure {:extern} rely_transitive();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
+  ensures (mem == old(mem));
 
 implementation {:extern} rely_transitive()
 {
@@ -43,18 +40,12 @@ procedure {:extern} guarantee_reflexive();
 procedure main();
   free requires (memory_load64_le(mem, 69632bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free requires (memory_load8_le(mem, 1896bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1897bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1898bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1899bv64) == 0bv8);
+  free requires (memory_load32_le(mem, 1896bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69016bv64) == 1872bv64);
   free requires (memory_load64_le(mem, 69024bv64) == 1792bv64);
   free requires (memory_load64_le(mem, 69616bv64) == 1536bv64);
   free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free ensures (memory_load8_le(mem, 1896bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1897bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1898bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1899bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1896bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69016bv64) == 1872bv64);
   free ensures (memory_load64_le(mem, 69024bv64) == 1792bv64);
   free ensures (memory_load64_le(mem, 69616bv64) == 1536bv64);
diff --git a/src/test/correct/syscall/clang/syscall.expected b/src/test/correct/syscall/clang/syscall.expected
index 54a9d6eea..d7e0403c0 100644
--- a/src/test/correct/syscall/clang/syscall.expected
+++ b/src/test/correct/syscall/clang/syscall.expected
@@ -43,10 +43,6 @@ function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv6
   (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
-}
-
 function {:extern} memory_store32_le(memory: [bv64]bv8, index: bv64, value: bv32) returns ([bv64]bv8) {
   memory[index := value[8:0]][bvadd64(index, 1bv64) := value[16:8]][bvadd64(index, 2bv64) := value[24:16]][bvadd64(index, 3bv64) := value[32:24]]
 }
@@ -58,12 +54,9 @@ function {:extern} memory_store64_le(memory: [bv64]bv8, index: bv64, value: bv64
 function {:extern} {:bvbuiltin "zero_extend 32"} zero_extend32_32(bv32) returns (bv64);
 procedure {:extern} rely();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
-  free ensures (memory_load8_le(mem, 1944bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1945bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1946bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1947bv64) == 0bv8);
+  ensures (mem == old(mem));
+  free ensures (memory_load32_le(mem, 1944bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69064bv64) == 1872bv64);
   free ensures (memory_load64_le(mem, 69072bv64) == 1792bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1876bv64);
@@ -71,8 +64,8 @@ procedure {:extern} rely();
 
 procedure {:extern} rely_transitive();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
+  ensures (mem == old(mem));
 
 implementation {:extern} rely_transitive()
 {
@@ -87,18 +80,12 @@ procedure {:extern} guarantee_reflexive();
 
 procedure fork();
   modifies Gamma_R16, Gamma_R17, R16, R17;
-  free requires (memory_load8_le(mem, 1944bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1945bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1946bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1947bv64) == 0bv8);
+  free requires (memory_load32_le(mem, 1944bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69064bv64) == 1872bv64);
   free requires (memory_load64_le(mem, 69072bv64) == 1792bv64);
   free requires (memory_load64_le(mem, 69592bv64) == 1876bv64);
   free requires (memory_load64_le(mem, 69680bv64) == 69680bv64);
-  free ensures (memory_load8_le(mem, 1944bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1945bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1946bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1947bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1944bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69064bv64) == 1872bv64);
   free ensures (memory_load64_le(mem, 69072bv64) == 1792bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1876bv64);
@@ -108,10 +95,7 @@ procedure main();
   modifies Gamma_R0, Gamma_R16, Gamma_R17, Gamma_R29, Gamma_R30, Gamma_R31, Gamma_stack, R0, R16, R17, R29, R30, R31, stack;
   free requires (memory_load64_le(mem, 69672bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69680bv64) == 69680bv64);
-  free requires (memory_load8_le(mem, 1944bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1945bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1946bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1947bv64) == 0bv8);
+  free requires (memory_load32_le(mem, 1944bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69064bv64) == 1872bv64);
   free requires (memory_load64_le(mem, 69072bv64) == 1792bv64);
   free requires (memory_load64_le(mem, 69592bv64) == 1876bv64);
@@ -120,10 +104,7 @@ procedure main();
   free ensures (Gamma_R31 == old(Gamma_R31));
   free ensures (R29 == old(R29));
   free ensures (R31 == old(R31));
-  free ensures (memory_load8_le(mem, 1944bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1945bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1946bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1947bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1944bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69064bv64) == 1872bv64);
   free ensures (memory_load64_le(mem, 69072bv64) == 1792bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1876bv64);
diff --git a/src/test/correct/syscall/clang/syscall_gtirb.expected b/src/test/correct/syscall/clang/syscall_gtirb.expected
index 1b662d317..40bab66af 100644
--- a/src/test/correct/syscall/clang/syscall_gtirb.expected
+++ b/src/test/correct/syscall/clang/syscall_gtirb.expected
@@ -18,7 +18,7 @@ var {:extern} mem: [bv64]bv8;
 var {:extern} stack: [bv64]bv8;
 const {:extern} $_IO_stdin_used_addr: bv64;
 axiom ($_IO_stdin_used_addr == 1944bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
   false
 }
 
@@ -47,10 +47,6 @@ function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv6
   (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
-}
-
 function {:extern} memory_store32_le(memory: [bv64]bv8, index: bv64, value: bv32) returns ([bv64]bv8) {
   memory[index := value[8:0]][bvadd64(index, 1bv64) := value[16:8]][bvadd64(index, 2bv64) := value[24:16]][bvadd64(index, 3bv64) := value[32:24]]
 }
@@ -62,12 +58,9 @@ function {:extern} memory_store64_le(memory: [bv64]bv8, index: bv64, value: bv64
 function {:extern} {:bvbuiltin "zero_extend 32"} zero_extend32_32(bv32) returns (bv64);
 procedure {:extern} rely();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
-  free ensures (memory_load8_le(mem, 1944bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1945bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1946bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1947bv64) == 0bv8);
+  ensures (mem == old(mem));
+  free ensures (memory_load32_le(mem, 1944bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69064bv64) == 1872bv64);
   free ensures (memory_load64_le(mem, 69072bv64) == 1792bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1876bv64);
@@ -75,8 +68,8 @@ procedure {:extern} rely();
 
 procedure {:extern} rely_transitive();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
+  ensures (mem == old(mem));
 
 implementation {:extern} rely_transitive()
 {
@@ -93,10 +86,7 @@ procedure main();
   modifies Gamma_R0, Gamma_R16, Gamma_R17, Gamma_R29, Gamma_R30, Gamma_R31, Gamma_mem, Gamma_stack, R0, R16, R17, R29, R30, R31, mem, stack;
   free requires (memory_load64_le(mem, 69672bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69680bv64) == 69680bv64);
-  free requires (memory_load8_le(mem, 1944bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1945bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1946bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1947bv64) == 0bv8);
+  free requires (memory_load32_le(mem, 1944bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69064bv64) == 1872bv64);
   free requires (memory_load64_le(mem, 69072bv64) == 1792bv64);
   free requires (memory_load64_le(mem, 69592bv64) == 1876bv64);
@@ -105,10 +95,7 @@ procedure main();
   free ensures (Gamma_R31 == old(Gamma_R31));
   free ensures (R29 == old(R29));
   free ensures (R31 == old(R31));
-  free ensures (memory_load8_le(mem, 1944bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1945bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1946bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1947bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1944bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69064bv64) == 1872bv64);
   free ensures (memory_load64_le(mem, 69072bv64) == 1792bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1876bv64);
@@ -155,18 +142,12 @@ implementation main()
 
 procedure FUN_610();
   modifies Gamma_R16, Gamma_R17, Gamma_mem, R16, R17, mem;
-  free requires (memory_load8_le(mem, 1944bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1945bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1946bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1947bv64) == 0bv8);
+  free requires (memory_load32_le(mem, 1944bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69064bv64) == 1872bv64);
   free requires (memory_load64_le(mem, 69072bv64) == 1792bv64);
   free requires (memory_load64_le(mem, 69592bv64) == 1876bv64);
   free requires (memory_load64_le(mem, 69680bv64) == 69680bv64);
-  free ensures (memory_load8_le(mem, 1944bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1945bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1946bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1947bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1944bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69064bv64) == 1872bv64);
   free ensures (memory_load64_le(mem, 69072bv64) == 1792bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1876bv64);
@@ -185,18 +166,12 @@ implementation FUN_610()
 }
 
 procedure fork();
-  free requires (memory_load8_le(mem, 1944bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1945bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1946bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1947bv64) == 0bv8);
+  free requires (memory_load32_le(mem, 1944bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69064bv64) == 1872bv64);
   free requires (memory_load64_le(mem, 69072bv64) == 1792bv64);
   free requires (memory_load64_le(mem, 69592bv64) == 1876bv64);
   free requires (memory_load64_le(mem, 69680bv64) == 69680bv64);
-  free ensures (memory_load8_le(mem, 1944bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1945bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1946bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1947bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1944bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69064bv64) == 1872bv64);
   free ensures (memory_load64_le(mem, 69072bv64) == 1792bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1876bv64);
diff --git a/src/test/correct/syscall/clang_O2/syscall_gtirb.expected b/src/test/correct/syscall/clang_O2/syscall_gtirb.expected
index 0c9d7d48d..4ce3e54e5 100644
--- a/src/test/correct/syscall/clang_O2/syscall_gtirb.expected
+++ b/src/test/correct/syscall/clang_O2/syscall_gtirb.expected
@@ -6,7 +6,7 @@ var {:extern} R17: bv64;
 var {:extern} mem: [bv64]bv8;
 const {:extern} $_IO_stdin_used_addr: bv64;
 axiom ($_IO_stdin_used_addr == 1900bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
   false
 }
 
@@ -15,22 +15,19 @@ function {:extern} gamma_load64(gammaMap: [bv64]bool, index: bv64) returns (bool
   (gammaMap[bvadd64(index, 7bv64)] && (gammaMap[bvadd64(index, 6bv64)] && (gammaMap[bvadd64(index, 5bv64)] && (gammaMap[bvadd64(index, 4bv64)] && (gammaMap[bvadd64(index, 3bv64)] && (gammaMap[bvadd64(index, 2bv64)] && (gammaMap[bvadd64(index, 1bv64)] && gammaMap[index])))))))
 }
 
-function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv64) {
-  (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
+function {:extern} memory_load32_le(memory: [bv64]bv8, index: bv64) returns (bv32) {
+  (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
+function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv64) {
+  (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
 procedure {:extern} rely();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
-  free ensures (memory_load8_le(mem, 1900bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1901bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1902bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1903bv64) == 0bv8);
+  ensures (mem == old(mem));
+  free ensures (memory_load32_le(mem, 1900bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69064bv64) == 1872bv64);
   free ensures (memory_load64_le(mem, 69072bv64) == 1792bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1876bv64);
@@ -38,8 +35,8 @@ procedure {:extern} rely();
 
 procedure {:extern} rely_transitive();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
+  ensures (mem == old(mem));
 
 implementation {:extern} rely_transitive()
 {
@@ -56,18 +53,12 @@ procedure main();
   modifies Gamma_R16, Gamma_R17, Gamma_mem, R16, R17, mem;
   free requires (memory_load64_le(mem, 69672bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69680bv64) == 69680bv64);
-  free requires (memory_load8_le(mem, 1900bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1901bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1902bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1903bv64) == 0bv8);
+  free requires (memory_load32_le(mem, 1900bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69064bv64) == 1872bv64);
   free requires (memory_load64_le(mem, 69072bv64) == 1792bv64);
   free requires (memory_load64_le(mem, 69592bv64) == 1876bv64);
   free requires (memory_load64_le(mem, 69680bv64) == 69680bv64);
-  free ensures (memory_load8_le(mem, 1900bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1901bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1902bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1903bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1900bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69064bv64) == 1872bv64);
   free ensures (memory_load64_le(mem, 69072bv64) == 1792bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1876bv64);
@@ -83,18 +74,12 @@ implementation main()
 
 procedure .L_610();
   modifies Gamma_R16, Gamma_R17, Gamma_mem, R16, R17, mem;
-  free requires (memory_load8_le(mem, 1900bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1901bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1902bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1903bv64) == 0bv8);
+  free requires (memory_load32_le(mem, 1900bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69064bv64) == 1872bv64);
   free requires (memory_load64_le(mem, 69072bv64) == 1792bv64);
   free requires (memory_load64_le(mem, 69592bv64) == 1876bv64);
   free requires (memory_load64_le(mem, 69680bv64) == 69680bv64);
-  free ensures (memory_load8_le(mem, 1900bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1901bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1902bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1903bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1900bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69064bv64) == 1872bv64);
   free ensures (memory_load64_le(mem, 69072bv64) == 1792bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1876bv64);
@@ -113,18 +98,12 @@ implementation .L_610()
 }
 
 procedure fork();
-  free requires (memory_load8_le(mem, 1900bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1901bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1902bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1903bv64) == 0bv8);
+  free requires (memory_load32_le(mem, 1900bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69064bv64) == 1872bv64);
   free requires (memory_load64_le(mem, 69072bv64) == 1792bv64);
   free requires (memory_load64_le(mem, 69592bv64) == 1876bv64);
   free requires (memory_load64_le(mem, 69680bv64) == 69680bv64);
-  free ensures (memory_load8_le(mem, 1900bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1901bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1902bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1903bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1900bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69064bv64) == 1872bv64);
   free ensures (memory_load64_le(mem, 69072bv64) == 1792bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1876bv64);
diff --git a/src/test/correct/syscall/gcc/syscall.expected b/src/test/correct/syscall/gcc/syscall.expected
index eee352c79..9b5a6bfb5 100644
--- a/src/test/correct/syscall/gcc/syscall.expected
+++ b/src/test/correct/syscall/gcc/syscall.expected
@@ -43,10 +43,6 @@ function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv6
   (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
-}
-
 function {:extern} memory_store32_le(memory: [bv64]bv8, index: bv64, value: bv32) returns ([bv64]bv8) {
   memory[index := value[8:0]][bvadd64(index, 1bv64) := value[16:8]][bvadd64(index, 2bv64) := value[24:16]][bvadd64(index, 3bv64) := value[32:24]]
 }
@@ -58,12 +54,9 @@ function {:extern} memory_store64_le(memory: [bv64]bv8, index: bv64, value: bv64
 function {:extern} {:bvbuiltin "zero_extend 32"} zero_extend32_32(bv32) returns (bv64);
 procedure {:extern} rely();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
-  free ensures (memory_load8_le(mem, 1932bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1933bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1934bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1935bv64) == 0bv8);
+  ensures (mem == old(mem));
+  free ensures (memory_load32_le(mem, 1932bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69008bv64) == 1872bv64);
   free ensures (memory_load64_le(mem, 69016bv64) == 1792bv64);
   free ensures (memory_load64_le(mem, 69616bv64) == 1876bv64);
@@ -71,8 +64,8 @@ procedure {:extern} rely();
 
 procedure {:extern} rely_transitive();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
+  ensures (mem == old(mem));
 
 implementation {:extern} rely_transitive()
 {
@@ -87,18 +80,12 @@ procedure {:extern} guarantee_reflexive();
 
 procedure fork();
   modifies Gamma_R16, Gamma_R17, R16, R17;
-  free requires (memory_load8_le(mem, 1932bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1933bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1934bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1935bv64) == 0bv8);
+  free requires (memory_load32_le(mem, 1932bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69008bv64) == 1872bv64);
   free requires (memory_load64_le(mem, 69016bv64) == 1792bv64);
   free requires (memory_load64_le(mem, 69616bv64) == 1876bv64);
   free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free ensures (memory_load8_le(mem, 1932bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1933bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1934bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1935bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1932bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69008bv64) == 1872bv64);
   free ensures (memory_load64_le(mem, 69016bv64) == 1792bv64);
   free ensures (memory_load64_le(mem, 69616bv64) == 1876bv64);
@@ -108,10 +95,7 @@ procedure main();
   modifies Gamma_R0, Gamma_R16, Gamma_R17, Gamma_R29, Gamma_R30, Gamma_R31, Gamma_stack, R0, R16, R17, R29, R30, R31, stack;
   free requires (memory_load64_le(mem, 69632bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free requires (memory_load8_le(mem, 1932bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1933bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1934bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1935bv64) == 0bv8);
+  free requires (memory_load32_le(mem, 1932bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69008bv64) == 1872bv64);
   free requires (memory_load64_le(mem, 69016bv64) == 1792bv64);
   free requires (memory_load64_le(mem, 69616bv64) == 1876bv64);
@@ -120,10 +104,7 @@ procedure main();
   free ensures (Gamma_R31 == old(Gamma_R31));
   free ensures (R29 == old(R29));
   free ensures (R31 == old(R31));
-  free ensures (memory_load8_le(mem, 1932bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1933bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1934bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1935bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1932bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69008bv64) == 1872bv64);
   free ensures (memory_load64_le(mem, 69016bv64) == 1792bv64);
   free ensures (memory_load64_le(mem, 69616bv64) == 1876bv64);
diff --git a/src/test/correct/syscall/gcc/syscall_gtirb.expected b/src/test/correct/syscall/gcc/syscall_gtirb.expected
index bff162b41..56a484a3f 100644
--- a/src/test/correct/syscall/gcc/syscall_gtirb.expected
+++ b/src/test/correct/syscall/gcc/syscall_gtirb.expected
@@ -18,7 +18,7 @@ var {:extern} mem: [bv64]bv8;
 var {:extern} stack: [bv64]bv8;
 const {:extern} $_IO_stdin_used_addr: bv64;
 axiom ($_IO_stdin_used_addr == 1932bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
   false
 }
 
@@ -47,10 +47,6 @@ function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv6
   (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
-}
-
 function {:extern} memory_store32_le(memory: [bv64]bv8, index: bv64, value: bv32) returns ([bv64]bv8) {
   memory[index := value[8:0]][bvadd64(index, 1bv64) := value[16:8]][bvadd64(index, 2bv64) := value[24:16]][bvadd64(index, 3bv64) := value[32:24]]
 }
@@ -62,12 +58,9 @@ function {:extern} memory_store64_le(memory: [bv64]bv8, index: bv64, value: bv64
 function {:extern} {:bvbuiltin "zero_extend 32"} zero_extend32_32(bv32) returns (bv64);
 procedure {:extern} rely();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
-  free ensures (memory_load8_le(mem, 1932bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1933bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1934bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1935bv64) == 0bv8);
+  ensures (mem == old(mem));
+  free ensures (memory_load32_le(mem, 1932bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69008bv64) == 1872bv64);
   free ensures (memory_load64_le(mem, 69016bv64) == 1792bv64);
   free ensures (memory_load64_le(mem, 69616bv64) == 1876bv64);
@@ -75,8 +68,8 @@ procedure {:extern} rely();
 
 procedure {:extern} rely_transitive();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
+  ensures (mem == old(mem));
 
 implementation {:extern} rely_transitive()
 {
@@ -91,18 +84,12 @@ procedure {:extern} guarantee_reflexive();
 
 procedure FUN_610();
   modifies Gamma_R16, Gamma_R17, Gamma_mem, R16, R17, mem;
-  free requires (memory_load8_le(mem, 1932bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1933bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1934bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1935bv64) == 0bv8);
+  free requires (memory_load32_le(mem, 1932bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69008bv64) == 1872bv64);
   free requires (memory_load64_le(mem, 69016bv64) == 1792bv64);
   free requires (memory_load64_le(mem, 69616bv64) == 1876bv64);
   free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free ensures (memory_load8_le(mem, 1932bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1933bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1934bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1935bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1932bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69008bv64) == 1872bv64);
   free ensures (memory_load64_le(mem, 69016bv64) == 1792bv64);
   free ensures (memory_load64_le(mem, 69616bv64) == 1876bv64);
@@ -124,10 +111,7 @@ procedure main();
   modifies Gamma_R0, Gamma_R16, Gamma_R17, Gamma_R29, Gamma_R30, Gamma_R31, Gamma_mem, Gamma_stack, R0, R16, R17, R29, R30, R31, mem, stack;
   free requires (memory_load64_le(mem, 69632bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free requires (memory_load8_le(mem, 1932bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1933bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1934bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1935bv64) == 0bv8);
+  free requires (memory_load32_le(mem, 1932bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69008bv64) == 1872bv64);
   free requires (memory_load64_le(mem, 69016bv64) == 1792bv64);
   free requires (memory_load64_le(mem, 69616bv64) == 1876bv64);
@@ -136,10 +120,7 @@ procedure main();
   free ensures (Gamma_R31 == old(Gamma_R31));
   free ensures (R29 == old(R29));
   free ensures (R31 == old(R31));
-  free ensures (memory_load8_le(mem, 1932bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1933bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1934bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1935bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1932bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69008bv64) == 1872bv64);
   free ensures (memory_load64_le(mem, 69016bv64) == 1792bv64);
   free ensures (memory_load64_le(mem, 69616bv64) == 1876bv64);
@@ -180,18 +161,12 @@ implementation main()
 }
 
 procedure fork();
-  free requires (memory_load8_le(mem, 1932bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1933bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1934bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1935bv64) == 0bv8);
+  free requires (memory_load32_le(mem, 1932bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69008bv64) == 1872bv64);
   free requires (memory_load64_le(mem, 69016bv64) == 1792bv64);
   free requires (memory_load64_le(mem, 69616bv64) == 1876bv64);
   free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free ensures (memory_load8_le(mem, 1932bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1933bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1934bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1935bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1932bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69008bv64) == 1872bv64);
   free ensures (memory_load64_le(mem, 69016bv64) == 1792bv64);
   free ensures (memory_load64_le(mem, 69616bv64) == 1876bv64);
diff --git a/src/test/correct/syscall/gcc_O2/syscall.expected b/src/test/correct/syscall/gcc_O2/syscall.expected
index fcb66403d..fef381e05 100644
--- a/src/test/correct/syscall/gcc_O2/syscall.expected
+++ b/src/test/correct/syscall/gcc_O2/syscall.expected
@@ -7,22 +7,19 @@ var {:extern} mem: [bv64]bv8;
 const {:extern} $_IO_stdin_used_addr: bv64;
 axiom ($_IO_stdin_used_addr == 1960bv64);
 function {:extern} {:bvbuiltin "bvadd"} bvadd64(bv64, bv64) returns (bv64);
-function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv64) {
-  (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
+function {:extern} memory_load32_le(memory: [bv64]bv8, index: bv64) returns (bv32) {
+  (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
+function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv64) {
+  (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
 procedure {:extern} rely();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
-  free ensures (memory_load8_le(mem, 1960bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1961bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1962bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1963bv64) == 0bv8);
+  ensures (mem == old(mem));
+  free ensures (memory_load32_le(mem, 1960bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69008bv64) == 1936bv64);
   free ensures (memory_load64_le(mem, 69016bv64) == 1856bv64);
   free ensures (memory_load64_le(mem, 69616bv64) == 1600bv64);
@@ -30,8 +27,8 @@ procedure {:extern} rely();
 
 procedure {:extern} rely_transitive();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
+  ensures (mem == old(mem));
 
 implementation {:extern} rely_transitive()
 {
@@ -48,18 +45,12 @@ procedure fork();
   modifies Gamma_R16, Gamma_R17, R16, R17;
   free requires (memory_load64_le(mem, 69632bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free requires (memory_load8_le(mem, 1960bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1961bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1962bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1963bv64) == 0bv8);
+  free requires (memory_load32_le(mem, 1960bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69008bv64) == 1936bv64);
   free requires (memory_load64_le(mem, 69016bv64) == 1856bv64);
   free requires (memory_load64_le(mem, 69616bv64) == 1600bv64);
   free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free ensures (memory_load8_le(mem, 1960bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1961bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1962bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1963bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1960bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69008bv64) == 1936bv64);
   free ensures (memory_load64_le(mem, 69016bv64) == 1856bv64);
   free ensures (memory_load64_le(mem, 69616bv64) == 1600bv64);
diff --git a/src/test/correct/syscall/gcc_O2/syscall_gtirb.expected b/src/test/correct/syscall/gcc_O2/syscall_gtirb.expected
index ef48faa8c..c8f72f876 100644
--- a/src/test/correct/syscall/gcc_O2/syscall_gtirb.expected
+++ b/src/test/correct/syscall/gcc_O2/syscall_gtirb.expected
@@ -6,7 +6,7 @@ var {:extern} R17: bv64;
 var {:extern} mem: [bv64]bv8;
 const {:extern} $_IO_stdin_used_addr: bv64;
 axiom ($_IO_stdin_used_addr == 1960bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
   false
 }
 
@@ -15,22 +15,19 @@ function {:extern} gamma_load64(gammaMap: [bv64]bool, index: bv64) returns (bool
   (gammaMap[bvadd64(index, 7bv64)] && (gammaMap[bvadd64(index, 6bv64)] && (gammaMap[bvadd64(index, 5bv64)] && (gammaMap[bvadd64(index, 4bv64)] && (gammaMap[bvadd64(index, 3bv64)] && (gammaMap[bvadd64(index, 2bv64)] && (gammaMap[bvadd64(index, 1bv64)] && gammaMap[index])))))))
 }
 
-function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv64) {
-  (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
+function {:extern} memory_load32_le(memory: [bv64]bv8, index: bv64) returns (bv32) {
+  (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
+function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv64) {
+  (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
 procedure {:extern} rely();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
-  free ensures (memory_load8_le(mem, 1960bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1961bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1962bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1963bv64) == 0bv8);
+  ensures (mem == old(mem));
+  free ensures (memory_load32_le(mem, 1960bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69008bv64) == 1936bv64);
   free ensures (memory_load64_le(mem, 69016bv64) == 1856bv64);
   free ensures (memory_load64_le(mem, 69616bv64) == 1600bv64);
@@ -38,8 +35,8 @@ procedure {:extern} rely();
 
 procedure {:extern} rely_transitive();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
+  ensures (mem == old(mem));
 
 implementation {:extern} rely_transitive()
 {
@@ -56,18 +53,12 @@ procedure main();
   modifies Gamma_R16, Gamma_R17, Gamma_mem, R16, R17, mem;
   free requires (memory_load64_le(mem, 69632bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free requires (memory_load8_le(mem, 1960bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1961bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1962bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1963bv64) == 0bv8);
+  free requires (memory_load32_le(mem, 1960bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69008bv64) == 1936bv64);
   free requires (memory_load64_le(mem, 69016bv64) == 1856bv64);
   free requires (memory_load64_le(mem, 69616bv64) == 1600bv64);
   free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free ensures (memory_load8_le(mem, 1960bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1961bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1962bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1963bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1960bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69008bv64) == 1936bv64);
   free ensures (memory_load64_le(mem, 69016bv64) == 1856bv64);
   free ensures (memory_load64_le(mem, 69616bv64) == 1600bv64);
@@ -83,18 +74,12 @@ implementation main()
 
 procedure .L_610();
   modifies Gamma_R16, Gamma_R17, Gamma_mem, R16, R17, mem;
-  free requires (memory_load8_le(mem, 1960bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1961bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1962bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1963bv64) == 0bv8);
+  free requires (memory_load32_le(mem, 1960bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69008bv64) == 1936bv64);
   free requires (memory_load64_le(mem, 69016bv64) == 1856bv64);
   free requires (memory_load64_le(mem, 69616bv64) == 1600bv64);
   free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free ensures (memory_load8_le(mem, 1960bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1961bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1962bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1963bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1960bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69008bv64) == 1936bv64);
   free ensures (memory_load64_le(mem, 69016bv64) == 1856bv64);
   free ensures (memory_load64_le(mem, 69616bv64) == 1600bv64);
@@ -113,18 +98,12 @@ implementation .L_610()
 }
 
 procedure fork();
-  free requires (memory_load8_le(mem, 1960bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1961bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1962bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1963bv64) == 0bv8);
+  free requires (memory_load32_le(mem, 1960bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69008bv64) == 1936bv64);
   free requires (memory_load64_le(mem, 69016bv64) == 1856bv64);
   free requires (memory_load64_le(mem, 69616bv64) == 1600bv64);
   free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free ensures (memory_load8_le(mem, 1960bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1961bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1962bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1963bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1960bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69008bv64) == 1936bv64);
   free ensures (memory_load64_le(mem, 69016bv64) == 1856bv64);
   free ensures (memory_load64_le(mem, 69616bv64) == 1600bv64);
diff --git a/src/test/correct/using_gamma_conditional/clang/using_gamma_conditional.expected b/src/test/correct/using_gamma_conditional/clang/using_gamma_conditional.expected
index 5531435ab..f85384bef 100644
--- a/src/test/correct/using_gamma_conditional/clang/using_gamma_conditional.expected
+++ b/src/test/correct/using_gamma_conditional/clang/using_gamma_conditional.expected
@@ -20,8 +20,8 @@ const {:extern} $x_addr: bv64;
 axiom ($x_addr == 69684bv64);
 const {:extern} $z_addr: bv64;
 axiom ($z_addr == 69688bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
-  (if (index == $z_addr) then true else (if (index == $x_addr) then (memory_load32_le(memory, $z_addr) == 0bv32) else false))
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
+  (if (index == $z_addr) then true else (if (index == $x_addr) then (memory_load32_le(mem$in, $z_addr) == 0bv32) else false))
 }
 
 function {:extern} {:bvbuiltin "bvadd"} bvadd32(bv32, bv32) returns (bv32);
@@ -47,10 +47,6 @@ function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv6
   (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
-}
-
 function {:extern} memory_store32_le(memory: [bv64]bv8, index: bv64, value: bv32) returns ([bv64]bv8) {
   memory[index := value[8:0]][bvadd64(index, 1bv64) := value[16:8]][bvadd64(index, 2bv64) := value[24:16]][bvadd64(index, 3bv64) := value[32:24]]
 }
@@ -62,10 +58,7 @@ procedure {:extern} rely();
   modifies Gamma_mem, mem;
   ensures (forall i: bv64 :: (((mem[i] == old(mem[i])) ==> (Gamma_mem[i] == old(Gamma_mem[i])))));
   ensures (old(gamma_load32(Gamma_mem, $x_addr)) ==> gamma_load32(Gamma_mem, $x_addr));
-  free ensures (memory_load8_le(mem, 1896bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1897bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1898bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1899bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1896bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1812bv64);
@@ -101,20 +94,14 @@ procedure main();
   requires (gamma_load32(Gamma_mem, $x_addr) == true);
   free requires (memory_load64_le(mem, 69664bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
-  free requires (memory_load8_le(mem, 1896bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1897bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1898bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1899bv64) == 0bv8);
+  free requires (memory_load32_le(mem, 1896bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free requires (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free requires (memory_load64_le(mem, 69592bv64) == 1812bv64);
   free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
   free ensures (Gamma_R31 == old(Gamma_R31));
   free ensures (R31 == old(R31));
-  free ensures (memory_load8_le(mem, 1896bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1897bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1898bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1899bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1896bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1812bv64);
diff --git a/src/test/correct/using_gamma_conditional/clang/using_gamma_conditional_gtirb.expected b/src/test/correct/using_gamma_conditional/clang/using_gamma_conditional_gtirb.expected
index c1eb2bbc9..f5400493a 100644
--- a/src/test/correct/using_gamma_conditional/clang/using_gamma_conditional_gtirb.expected
+++ b/src/test/correct/using_gamma_conditional/clang/using_gamma_conditional_gtirb.expected
@@ -20,8 +20,8 @@ const {:extern} $x_addr: bv64;
 axiom ($x_addr == 69684bv64);
 const {:extern} $z_addr: bv64;
 axiom ($z_addr == 69688bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
-  (if (index == $z_addr) then true else (if (index == $x_addr) then (memory_load32_le(memory, $z_addr) == 0bv32) else false))
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
+  (if (index == $z_addr) then true else (if (index == $x_addr) then (memory_load32_le(mem$in, $z_addr) == 0bv32) else false))
 }
 
 function {:extern} {:bvbuiltin "bvadd"} bvadd32(bv32, bv32) returns (bv32);
@@ -46,10 +46,6 @@ function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv6
   (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
-}
-
 function {:extern} memory_store32_le(memory: [bv64]bv8, index: bv64, value: bv32) returns ([bv64]bv8) {
   memory[index := value[8:0]][bvadd64(index, 1bv64) := value[16:8]][bvadd64(index, 2bv64) := value[24:16]][bvadd64(index, 3bv64) := value[32:24]]
 }
@@ -60,10 +56,7 @@ procedure {:extern} rely();
   modifies Gamma_mem, mem;
   ensures (forall i: bv64 :: (((mem[i] == old(mem[i])) ==> (Gamma_mem[i] == old(Gamma_mem[i])))));
   ensures (old(gamma_load32(Gamma_mem, $x_addr)) ==> gamma_load32(Gamma_mem, $x_addr));
-  free ensures (memory_load8_le(mem, 1896bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1897bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1898bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1899bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1896bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1812bv64);
@@ -99,20 +92,14 @@ procedure main();
   requires (gamma_load32(Gamma_mem, $x_addr) == true);
   free requires (memory_load64_le(mem, 69664bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
-  free requires (memory_load8_le(mem, 1896bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1897bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1898bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1899bv64) == 0bv8);
+  free requires (memory_load32_le(mem, 1896bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free requires (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free requires (memory_load64_le(mem, 69592bv64) == 1812bv64);
   free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
   free ensures (Gamma_R31 == old(Gamma_R31));
   free ensures (R31 == old(R31));
-  free ensures (memory_load8_le(mem, 1896bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1897bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1898bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1899bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1896bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1812bv64);
diff --git a/src/test/correct/using_gamma_conditional/clang_O2/using_gamma_conditional.expected b/src/test/correct/using_gamma_conditional/clang_O2/using_gamma_conditional.expected
index 3df066045..5bbfbd38f 100644
--- a/src/test/correct/using_gamma_conditional/clang_O2/using_gamma_conditional.expected
+++ b/src/test/correct/using_gamma_conditional/clang_O2/using_gamma_conditional.expected
@@ -16,8 +16,8 @@ const {:extern} $x_addr: bv64;
 axiom ($x_addr == 69684bv64);
 const {:extern} $z_addr: bv64;
 axiom ($z_addr == 69688bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
-  (if (index == $z_addr) then true else (if (index == $x_addr) then (memory_load32_le(memory, $z_addr) == 0bv32) else false))
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
+  (if (index == $z_addr) then true else (if (index == $x_addr) then (memory_load32_le(mem$in, $z_addr) == 0bv32) else false))
 }
 
 function {:extern} {:bvbuiltin "bvadd"} bvadd32(bv32, bv32) returns (bv32);
@@ -39,10 +39,6 @@ function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv6
   (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
-}
-
 function {:extern} {:bvbuiltin "sign_extend 1"} sign_extend1_32(bv32) returns (bv33);
 function {:extern} {:bvbuiltin "zero_extend 1"} zero_extend1_32(bv32) returns (bv33);
 function {:extern} {:bvbuiltin "zero_extend 32"} zero_extend32_32(bv32) returns (bv64);
@@ -50,10 +46,7 @@ procedure {:extern} rely();
   modifies Gamma_mem, mem;
   ensures (forall i: bv64 :: (((mem[i] == old(mem[i])) ==> (Gamma_mem[i] == old(Gamma_mem[i])))));
   ensures (old(gamma_load32(Gamma_mem, $x_addr)) ==> gamma_load32(Gamma_mem, $x_addr));
-  free ensures (memory_load8_le(mem, 1852bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1853bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1854bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1855bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1852bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1812bv64);
@@ -89,18 +82,12 @@ procedure main();
   requires (gamma_load32(Gamma_mem, $x_addr) == true);
   free requires (memory_load64_le(mem, 69664bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
-  free requires (memory_load8_le(mem, 1852bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1853bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1854bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1855bv64) == 0bv8);
+  free requires (memory_load32_le(mem, 1852bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free requires (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free requires (memory_load64_le(mem, 69592bv64) == 1812bv64);
   free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
-  free ensures (memory_load8_le(mem, 1852bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1853bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1854bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1855bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1852bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1812bv64);
diff --git a/src/test/correct/using_gamma_conditional/clang_O2/using_gamma_conditional_gtirb.expected b/src/test/correct/using_gamma_conditional/clang_O2/using_gamma_conditional_gtirb.expected
index 5480a19ca..739f58556 100644
--- a/src/test/correct/using_gamma_conditional/clang_O2/using_gamma_conditional_gtirb.expected
+++ b/src/test/correct/using_gamma_conditional/clang_O2/using_gamma_conditional_gtirb.expected
@@ -16,8 +16,8 @@ const {:extern} $x_addr: bv64;
 axiom ($x_addr == 69684bv64);
 const {:extern} $z_addr: bv64;
 axiom ($z_addr == 69688bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
-  (if (index == $z_addr) then true else (if (index == $x_addr) then (memory_load32_le(memory, $z_addr) == 0bv32) else false))
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
+  (if (index == $z_addr) then true else (if (index == $x_addr) then (memory_load32_le(mem$in, $z_addr) == 0bv32) else false))
 }
 
 function {:extern} {:bvbuiltin "bvadd"} bvadd32(bv32, bv32) returns (bv32);
@@ -38,20 +38,13 @@ function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv6
   (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
-}
-
 function {:extern} {:bvbuiltin "zero_extend 1"} zero_extend1_32(bv32) returns (bv33);
 function {:extern} {:bvbuiltin "zero_extend 32"} zero_extend32_32(bv32) returns (bv64);
 procedure {:extern} rely();
   modifies Gamma_mem, mem;
   ensures (forall i: bv64 :: (((mem[i] == old(mem[i])) ==> (Gamma_mem[i] == old(Gamma_mem[i])))));
   ensures (old(gamma_load32(Gamma_mem, $x_addr)) ==> gamma_load32(Gamma_mem, $x_addr));
-  free ensures (memory_load8_le(mem, 1852bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1853bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1854bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1855bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1852bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1812bv64);
@@ -87,18 +80,12 @@ procedure main();
   requires (gamma_load32(Gamma_mem, $x_addr) == true);
   free requires (memory_load64_le(mem, 69664bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
-  free requires (memory_load8_le(mem, 1852bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1853bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1854bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1855bv64) == 0bv8);
+  free requires (memory_load32_le(mem, 1852bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free requires (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free requires (memory_load64_le(mem, 69592bv64) == 1812bv64);
   free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
-  free ensures (memory_load8_le(mem, 1852bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1853bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1854bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1855bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1852bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1812bv64);
diff --git a/src/test/correct/using_gamma_conditional/clang_pic/using_gamma_conditional.expected b/src/test/correct/using_gamma_conditional/clang_pic/using_gamma_conditional.expected
index ca1acc493..6c064e72e 100644
--- a/src/test/correct/using_gamma_conditional/clang_pic/using_gamma_conditional.expected
+++ b/src/test/correct/using_gamma_conditional/clang_pic/using_gamma_conditional.expected
@@ -20,8 +20,8 @@ const {:extern} $x_addr: bv64;
 axiom ($x_addr == 69684bv64);
 const {:extern} $z_addr: bv64;
 axiom ($z_addr == 69688bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
-  (if (index == $z_addr) then true else (if (index == $x_addr) then (memory_load32_le(memory, $z_addr) == 0bv32) else false))
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
+  (if (index == $z_addr) then true else (if (index == $x_addr) then (memory_load32_le(mem$in, $z_addr) == 0bv32) else false))
 }
 
 function {:extern} {:bvbuiltin "bvadd"} bvadd32(bv32, bv32) returns (bv32);
@@ -51,10 +51,6 @@ function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv6
   (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
-}
-
 function {:extern} memory_store32_le(memory: [bv64]bv8, index: bv64, value: bv32) returns ([bv64]bv8) {
   memory[index := value[8:0]][bvadd64(index, 1bv64) := value[16:8]][bvadd64(index, 2bv64) := value[24:16]][bvadd64(index, 3bv64) := value[32:24]]
 }
@@ -66,15 +62,12 @@ procedure {:extern} rely();
   modifies Gamma_mem, mem;
   ensures (forall i: bv64 :: (((mem[i] == old(mem[i])) ==> (Gamma_mem[i] == old(Gamma_mem[i])))));
   ensures (old(gamma_load32(Gamma_mem, $x_addr)) ==> gamma_load32(Gamma_mem, $x_addr));
-  free ensures (memory_load8_le(mem, 1964bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1965bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1966bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1967bv64) == 0bv8);
-  free ensures (memory_load64_le(mem, 69576bv64) == 69684bv64);
-  free ensures (memory_load64_le(mem, 69672bv64) == 69672bv64);
+  free ensures (memory_load32_le(mem, 1964bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69056bv64) == 1872bv64);
   free ensures (memory_load64_le(mem, 69064bv64) == 1792bv64);
+  free ensures (memory_load64_le(mem, 69576bv64) == 69684bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1876bv64);
+  free ensures (memory_load64_le(mem, 69672bv64) == 69672bv64);
 
 procedure {:extern} rely_transitive();
   modifies Gamma_mem, mem;
@@ -106,26 +99,20 @@ procedure main();
   requires (gamma_load32(Gamma_mem, $x_addr) == true);
   free requires (memory_load64_le(mem, 69664bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
-  free requires (memory_load8_le(mem, 1964bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1965bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1966bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1967bv64) == 0bv8);
-  free requires (memory_load64_le(mem, 69576bv64) == 69684bv64);
-  free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
+  free requires (memory_load32_le(mem, 1964bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69056bv64) == 1872bv64);
   free requires (memory_load64_le(mem, 69064bv64) == 1792bv64);
+  free requires (memory_load64_le(mem, 69576bv64) == 69684bv64);
   free requires (memory_load64_le(mem, 69592bv64) == 1876bv64);
+  free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
   free ensures (Gamma_R31 == old(Gamma_R31));
   free ensures (R31 == old(R31));
-  free ensures (memory_load8_le(mem, 1964bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1965bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1966bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1967bv64) == 0bv8);
-  free ensures (memory_load64_le(mem, 69576bv64) == 69684bv64);
-  free ensures (memory_load64_le(mem, 69672bv64) == 69672bv64);
+  free ensures (memory_load32_le(mem, 1964bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69056bv64) == 1872bv64);
   free ensures (memory_load64_le(mem, 69064bv64) == 1792bv64);
+  free ensures (memory_load64_le(mem, 69576bv64) == 69684bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1876bv64);
+  free ensures (memory_load64_le(mem, 69672bv64) == 69672bv64);
 
 implementation main()
 {
diff --git a/src/test/correct/using_gamma_conditional/clang_pic/using_gamma_conditional_gtirb.expected b/src/test/correct/using_gamma_conditional/clang_pic/using_gamma_conditional_gtirb.expected
index 988281be0..bab1430f0 100644
--- a/src/test/correct/using_gamma_conditional/clang_pic/using_gamma_conditional_gtirb.expected
+++ b/src/test/correct/using_gamma_conditional/clang_pic/using_gamma_conditional_gtirb.expected
@@ -20,8 +20,8 @@ const {:extern} $x_addr: bv64;
 axiom ($x_addr == 69684bv64);
 const {:extern} $z_addr: bv64;
 axiom ($z_addr == 69688bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
-  (if (index == $z_addr) then true else (if (index == $x_addr) then (memory_load32_le(memory, $z_addr) == 0bv32) else false))
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
+  (if (index == $z_addr) then true else (if (index == $x_addr) then (memory_load32_le(mem$in, $z_addr) == 0bv32) else false))
 }
 
 function {:extern} {:bvbuiltin "bvadd"} bvadd32(bv32, bv32) returns (bv32);
@@ -50,10 +50,6 @@ function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv6
   (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
-}
-
 function {:extern} memory_store32_le(memory: [bv64]bv8, index: bv64, value: bv32) returns ([bv64]bv8) {
   memory[index := value[8:0]][bvadd64(index, 1bv64) := value[16:8]][bvadd64(index, 2bv64) := value[24:16]][bvadd64(index, 3bv64) := value[32:24]]
 }
@@ -64,15 +60,12 @@ procedure {:extern} rely();
   modifies Gamma_mem, mem;
   ensures (forall i: bv64 :: (((mem[i] == old(mem[i])) ==> (Gamma_mem[i] == old(Gamma_mem[i])))));
   ensures (old(gamma_load32(Gamma_mem, $x_addr)) ==> gamma_load32(Gamma_mem, $x_addr));
-  free ensures (memory_load8_le(mem, 1964bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1965bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1966bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1967bv64) == 0bv8);
-  free ensures (memory_load64_le(mem, 69576bv64) == 69684bv64);
-  free ensures (memory_load64_le(mem, 69672bv64) == 69672bv64);
+  free ensures (memory_load32_le(mem, 1964bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69056bv64) == 1872bv64);
   free ensures (memory_load64_le(mem, 69064bv64) == 1792bv64);
+  free ensures (memory_load64_le(mem, 69576bv64) == 69684bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1876bv64);
+  free ensures (memory_load64_le(mem, 69672bv64) == 69672bv64);
 
 procedure {:extern} rely_transitive();
   modifies Gamma_mem, mem;
@@ -104,26 +97,20 @@ procedure main();
   requires (gamma_load32(Gamma_mem, $x_addr) == true);
   free requires (memory_load64_le(mem, 69664bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
-  free requires (memory_load8_le(mem, 1964bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1965bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1966bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1967bv64) == 0bv8);
-  free requires (memory_load64_le(mem, 69576bv64) == 69684bv64);
-  free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
+  free requires (memory_load32_le(mem, 1964bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69056bv64) == 1872bv64);
   free requires (memory_load64_le(mem, 69064bv64) == 1792bv64);
+  free requires (memory_load64_le(mem, 69576bv64) == 69684bv64);
   free requires (memory_load64_le(mem, 69592bv64) == 1876bv64);
+  free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
   free ensures (Gamma_R31 == old(Gamma_R31));
   free ensures (R31 == old(R31));
-  free ensures (memory_load8_le(mem, 1964bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1965bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1966bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1967bv64) == 0bv8);
-  free ensures (memory_load64_le(mem, 69576bv64) == 69684bv64);
-  free ensures (memory_load64_le(mem, 69672bv64) == 69672bv64);
+  free ensures (memory_load32_le(mem, 1964bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69056bv64) == 1872bv64);
   free ensures (memory_load64_le(mem, 69064bv64) == 1792bv64);
+  free ensures (memory_load64_le(mem, 69576bv64) == 69684bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1876bv64);
+  free ensures (memory_load64_le(mem, 69672bv64) == 69672bv64);
 
 implementation main()
 {
diff --git a/src/test/correct/using_gamma_conditional/gcc/using_gamma_conditional.expected b/src/test/correct/using_gamma_conditional/gcc/using_gamma_conditional.expected
index ca310ac5a..d15546bc6 100644
--- a/src/test/correct/using_gamma_conditional/gcc/using_gamma_conditional.expected
+++ b/src/test/correct/using_gamma_conditional/gcc/using_gamma_conditional.expected
@@ -14,8 +14,8 @@ const {:extern} $x_addr: bv64;
 axiom ($x_addr == 69652bv64);
 const {:extern} $z_addr: bv64;
 axiom ($z_addr == 69656bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
-  (if (index == $z_addr) then true else (if (index == $x_addr) then (memory_load32_le(memory, $z_addr) == 0bv32) else false))
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
+  (if (index == $z_addr) then true else (if (index == $x_addr) then (memory_load32_le(mem$in, $z_addr) == 0bv32) else false))
 }
 
 function {:extern} {:bvbuiltin "bvadd"} bvadd32(bv32, bv32) returns (bv32);
@@ -37,10 +37,6 @@ function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv6
   (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
-}
-
 function {:extern} {:bvbuiltin "sign_extend 1"} sign_extend1_32(bv32) returns (bv33);
 function {:extern} {:bvbuiltin "zero_extend 1"} zero_extend1_32(bv32) returns (bv33);
 function {:extern} {:bvbuiltin "zero_extend 32"} zero_extend32_32(bv32) returns (bv64);
@@ -48,10 +44,7 @@ procedure {:extern} rely();
   modifies Gamma_mem, mem;
   ensures (forall i: bv64 :: (((mem[i] == old(mem[i])) ==> (Gamma_mem[i] == old(Gamma_mem[i])))));
   ensures (old(gamma_load32(Gamma_mem, $x_addr)) ==> gamma_load32(Gamma_mem, $x_addr));
-  free ensures (memory_load8_le(mem, 1868bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1869bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1870bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1871bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1868bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69016bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69024bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69616bv64) == 1812bv64);
@@ -87,18 +80,12 @@ procedure main();
   requires (gamma_load32(Gamma_mem, $x_addr) == true);
   free requires (memory_load64_le(mem, 69632bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free requires (memory_load8_le(mem, 1868bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1869bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1870bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1871bv64) == 0bv8);
+  free requires (memory_load32_le(mem, 1868bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69016bv64) == 1808bv64);
   free requires (memory_load64_le(mem, 69024bv64) == 1728bv64);
   free requires (memory_load64_le(mem, 69616bv64) == 1812bv64);
   free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free ensures (memory_load8_le(mem, 1868bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1869bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1870bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1871bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1868bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69016bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69024bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69616bv64) == 1812bv64);
diff --git a/src/test/correct/using_gamma_conditional/gcc/using_gamma_conditional_gtirb.expected b/src/test/correct/using_gamma_conditional/gcc/using_gamma_conditional_gtirb.expected
index 65aa5243e..092d40222 100644
--- a/src/test/correct/using_gamma_conditional/gcc/using_gamma_conditional_gtirb.expected
+++ b/src/test/correct/using_gamma_conditional/gcc/using_gamma_conditional_gtirb.expected
@@ -14,8 +14,8 @@ const {:extern} $x_addr: bv64;
 axiom ($x_addr == 69652bv64);
 const {:extern} $z_addr: bv64;
 axiom ($z_addr == 69656bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
-  (if (index == $z_addr) then true else (if (index == $x_addr) then (memory_load32_le(memory, $z_addr) == 0bv32) else false))
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
+  (if (index == $z_addr) then true else (if (index == $x_addr) then (memory_load32_le(mem$in, $z_addr) == 0bv32) else false))
 }
 
 function {:extern} {:bvbuiltin "bvadd"} bvadd32(bv32, bv32) returns (bv32);
@@ -36,20 +36,13 @@ function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv6
   (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
-}
-
 function {:extern} {:bvbuiltin "zero_extend 1"} zero_extend1_32(bv32) returns (bv33);
 function {:extern} {:bvbuiltin "zero_extend 32"} zero_extend32_32(bv32) returns (bv64);
 procedure {:extern} rely();
   modifies Gamma_mem, mem;
   ensures (forall i: bv64 :: (((mem[i] == old(mem[i])) ==> (Gamma_mem[i] == old(Gamma_mem[i])))));
   ensures (old(gamma_load32(Gamma_mem, $x_addr)) ==> gamma_load32(Gamma_mem, $x_addr));
-  free ensures (memory_load8_le(mem, 1868bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1869bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1870bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1871bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1868bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69016bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69024bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69616bv64) == 1812bv64);
@@ -85,18 +78,12 @@ procedure main();
   requires (gamma_load32(Gamma_mem, $x_addr) == true);
   free requires (memory_load64_le(mem, 69632bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free requires (memory_load8_le(mem, 1868bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1869bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1870bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1871bv64) == 0bv8);
+  free requires (memory_load32_le(mem, 1868bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69016bv64) == 1808bv64);
   free requires (memory_load64_le(mem, 69024bv64) == 1728bv64);
   free requires (memory_load64_le(mem, 69616bv64) == 1812bv64);
   free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free ensures (memory_load8_le(mem, 1868bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1869bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1870bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1871bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1868bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69016bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69024bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69616bv64) == 1812bv64);
diff --git a/src/test/correct/using_gamma_conditional/gcc_pic/using_gamma_conditional.expected b/src/test/correct/using_gamma_conditional/gcc_pic/using_gamma_conditional.expected
index c8746d547..e36ae841a 100644
--- a/src/test/correct/using_gamma_conditional/gcc_pic/using_gamma_conditional.expected
+++ b/src/test/correct/using_gamma_conditional/gcc_pic/using_gamma_conditional.expected
@@ -14,8 +14,8 @@ const {:extern} $x_addr: bv64;
 axiom ($x_addr == 69652bv64);
 const {:extern} $z_addr: bv64;
 axiom ($z_addr == 69656bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
-  (if (index == $z_addr) then true else (if (index == $x_addr) then (memory_load32_le(memory, $z_addr) == 0bv32) else false))
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
+  (if (index == $z_addr) then true else (if (index == $x_addr) then (memory_load32_le(mem$in, $z_addr) == 0bv32) else false))
 }
 
 function {:extern} {:bvbuiltin "bvadd"} bvadd32(bv32, bv32) returns (bv32);
@@ -41,10 +41,6 @@ function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv6
   (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
-}
-
 function {:extern} {:bvbuiltin "sign_extend 1"} sign_extend1_32(bv32) returns (bv33);
 function {:extern} {:bvbuiltin "zero_extend 1"} zero_extend1_32(bv32) returns (bv33);
 function {:extern} {:bvbuiltin "zero_extend 32"} zero_extend32_32(bv32) returns (bv64);
@@ -52,15 +48,12 @@ procedure {:extern} rely();
   modifies Gamma_mem, mem;
   ensures (forall i: bv64 :: (((mem[i] == old(mem[i])) ==> (Gamma_mem[i] == old(Gamma_mem[i])))));
   ensures (old(gamma_load32(Gamma_mem, $x_addr)) ==> gamma_load32(Gamma_mem, $x_addr));
-  free ensures (memory_load8_le(mem, 1932bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1933bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1934bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1935bv64) == 0bv8);
-  free ensures (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free ensures (memory_load64_le(mem, 69616bv64) == 1876bv64);
+  free ensures (memory_load32_le(mem, 1932bv64) == 131073bv32);
+  free ensures (memory_load64_le(mem, 69008bv64) == 1872bv64);
   free ensures (memory_load64_le(mem, 69016bv64) == 1792bv64);
   free ensures (memory_load64_le(mem, 69600bv64) == 69652bv64);
-  free ensures (memory_load64_le(mem, 69008bv64) == 1872bv64);
+  free ensures (memory_load64_le(mem, 69616bv64) == 1876bv64);
+  free ensures (memory_load64_le(mem, 69640bv64) == 69640bv64);
 
 procedure {:extern} rely_transitive();
   modifies Gamma_mem, mem;
@@ -92,24 +85,18 @@ procedure main();
   requires (gamma_load32(Gamma_mem, $x_addr) == true);
   free requires (memory_load64_le(mem, 69632bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free requires (memory_load8_le(mem, 1932bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1933bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1934bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1935bv64) == 0bv8);
-  free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free requires (memory_load64_le(mem, 69616bv64) == 1876bv64);
+  free requires (memory_load32_le(mem, 1932bv64) == 131073bv32);
+  free requires (memory_load64_le(mem, 69008bv64) == 1872bv64);
   free requires (memory_load64_le(mem, 69016bv64) == 1792bv64);
   free requires (memory_load64_le(mem, 69600bv64) == 69652bv64);
-  free requires (memory_load64_le(mem, 69008bv64) == 1872bv64);
-  free ensures (memory_load8_le(mem, 1932bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1933bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1934bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1935bv64) == 0bv8);
-  free ensures (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free ensures (memory_load64_le(mem, 69616bv64) == 1876bv64);
+  free requires (memory_load64_le(mem, 69616bv64) == 1876bv64);
+  free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
+  free ensures (memory_load32_le(mem, 1932bv64) == 131073bv32);
+  free ensures (memory_load64_le(mem, 69008bv64) == 1872bv64);
   free ensures (memory_load64_le(mem, 69016bv64) == 1792bv64);
   free ensures (memory_load64_le(mem, 69600bv64) == 69652bv64);
-  free ensures (memory_load64_le(mem, 69008bv64) == 1872bv64);
+  free ensures (memory_load64_le(mem, 69616bv64) == 1876bv64);
+  free ensures (memory_load64_le(mem, 69640bv64) == 69640bv64);
 
 implementation main()
 {
diff --git a/src/test/correct/using_gamma_conditional/gcc_pic/using_gamma_conditional_gtirb.expected b/src/test/correct/using_gamma_conditional/gcc_pic/using_gamma_conditional_gtirb.expected
index 3fc47285f..b1b14067c 100644
--- a/src/test/correct/using_gamma_conditional/gcc_pic/using_gamma_conditional_gtirb.expected
+++ b/src/test/correct/using_gamma_conditional/gcc_pic/using_gamma_conditional_gtirb.expected
@@ -14,8 +14,8 @@ const {:extern} $x_addr: bv64;
 axiom ($x_addr == 69652bv64);
 const {:extern} $z_addr: bv64;
 axiom ($z_addr == 69656bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
-  (if (index == $z_addr) then true else (if (index == $x_addr) then (memory_load32_le(memory, $z_addr) == 0bv32) else false))
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
+  (if (index == $z_addr) then true else (if (index == $x_addr) then (memory_load32_le(mem$in, $z_addr) == 0bv32) else false))
 }
 
 function {:extern} {:bvbuiltin "bvadd"} bvadd32(bv32, bv32) returns (bv32);
@@ -40,25 +40,18 @@ function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv6
   (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
-}
-
 function {:extern} {:bvbuiltin "zero_extend 1"} zero_extend1_32(bv32) returns (bv33);
 function {:extern} {:bvbuiltin "zero_extend 32"} zero_extend32_32(bv32) returns (bv64);
 procedure {:extern} rely();
   modifies Gamma_mem, mem;
   ensures (forall i: bv64 :: (((mem[i] == old(mem[i])) ==> (Gamma_mem[i] == old(Gamma_mem[i])))));
   ensures (old(gamma_load32(Gamma_mem, $x_addr)) ==> gamma_load32(Gamma_mem, $x_addr));
-  free ensures (memory_load8_le(mem, 1932bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1933bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1934bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1935bv64) == 0bv8);
-  free ensures (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free ensures (memory_load64_le(mem, 69616bv64) == 1876bv64);
+  free ensures (memory_load32_le(mem, 1932bv64) == 131073bv32);
+  free ensures (memory_load64_le(mem, 69008bv64) == 1872bv64);
   free ensures (memory_load64_le(mem, 69016bv64) == 1792bv64);
   free ensures (memory_load64_le(mem, 69600bv64) == 69652bv64);
-  free ensures (memory_load64_le(mem, 69008bv64) == 1872bv64);
+  free ensures (memory_load64_le(mem, 69616bv64) == 1876bv64);
+  free ensures (memory_load64_le(mem, 69640bv64) == 69640bv64);
 
 procedure {:extern} rely_transitive();
   modifies Gamma_mem, mem;
@@ -90,24 +83,18 @@ procedure main();
   requires (gamma_load32(Gamma_mem, $x_addr) == true);
   free requires (memory_load64_le(mem, 69632bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free requires (memory_load8_le(mem, 1932bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1933bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1934bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1935bv64) == 0bv8);
-  free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free requires (memory_load64_le(mem, 69616bv64) == 1876bv64);
+  free requires (memory_load32_le(mem, 1932bv64) == 131073bv32);
+  free requires (memory_load64_le(mem, 69008bv64) == 1872bv64);
   free requires (memory_load64_le(mem, 69016bv64) == 1792bv64);
   free requires (memory_load64_le(mem, 69600bv64) == 69652bv64);
-  free requires (memory_load64_le(mem, 69008bv64) == 1872bv64);
-  free ensures (memory_load8_le(mem, 1932bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1933bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1934bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1935bv64) == 0bv8);
-  free ensures (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free ensures (memory_load64_le(mem, 69616bv64) == 1876bv64);
+  free requires (memory_load64_le(mem, 69616bv64) == 1876bv64);
+  free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
+  free ensures (memory_load32_le(mem, 1932bv64) == 131073bv32);
+  free ensures (memory_load64_le(mem, 69008bv64) == 1872bv64);
   free ensures (memory_load64_le(mem, 69016bv64) == 1792bv64);
   free ensures (memory_load64_le(mem, 69600bv64) == 69652bv64);
-  free ensures (memory_load64_le(mem, 69008bv64) == 1872bv64);
+  free ensures (memory_load64_le(mem, 69616bv64) == 1876bv64);
+  free ensures (memory_load64_le(mem, 69640bv64) == 69640bv64);
 
 implementation main()
 {
diff --git a/src/test/correct/using_gamma_write_z/clang/using_gamma_write_z.expected b/src/test/correct/using_gamma_write_z/clang/using_gamma_write_z.expected
index 880ccabaf..9d59e8152 100644
--- a/src/test/correct/using_gamma_write_z/clang/using_gamma_write_z.expected
+++ b/src/test/correct/using_gamma_write_z/clang/using_gamma_write_z.expected
@@ -10,8 +10,8 @@ const {:extern} $x_addr: bv64;
 axiom ($x_addr == 69688bv64);
 const {:extern} $z_addr: bv64;
 axiom ($z_addr == 69684bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
-  (if (index == $z_addr) then true else (if (index == $x_addr) then (memory_load32_le(memory, $z_addr) == 0bv32) else false))
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
+  (if (index == $z_addr) then true else (if (index == $x_addr) then (memory_load32_le(mem$in, $z_addr) == 0bv32) else false))
 }
 
 function {:extern} {:bvbuiltin "bvadd"} bvadd64(bv64, bv64) returns (bv64);
@@ -31,10 +31,6 @@ function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv6
   (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
-}
-
 function {:extern} memory_store32_le(memory: [bv64]bv8, index: bv64, value: bv32) returns ([bv64]bv8) {
   memory[index := value[8:0]][bvadd64(index, 1bv64) := value[16:8]][bvadd64(index, 2bv64) := value[24:16]][bvadd64(index, 3bv64) := value[32:24]]
 }
@@ -43,10 +39,7 @@ procedure {:extern} rely();
   modifies Gamma_mem, mem;
   ensures (forall i: bv64 :: (((mem[i] == old(mem[i])) ==> (Gamma_mem[i] == old(Gamma_mem[i])))));
   ensures ((old(memory_load32_le(mem, $x_addr)) == memory_load32_le(mem, $x_addr)) && (old(memory_load32_le(mem, $z_addr)) == memory_load32_le(mem, $z_addr)));
-  free ensures (memory_load8_le(mem, 1852bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1853bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1854bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1855bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1852bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1812bv64);
@@ -82,18 +75,12 @@ procedure main();
   requires ((memory_load32_le(mem, $z_addr) == 0bv32) ==> gamma_load32(Gamma_mem, $x_addr));
   free requires (memory_load64_le(mem, 69664bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
-  free requires (memory_load8_le(mem, 1852bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1853bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1854bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1855bv64) == 0bv8);
+  free requires (memory_load32_le(mem, 1852bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free requires (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free requires (memory_load64_le(mem, 69592bv64) == 1812bv64);
   free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
-  free ensures (memory_load8_le(mem, 1852bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1853bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1854bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1855bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1852bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1812bv64);
@@ -111,7 +98,6 @@ implementation main()
     Gamma_x_old := (gamma_load32(Gamma_mem, $x_addr) || L(mem, $x_addr));
     mem, Gamma_mem := memory_store32_le(mem, bvadd64(R9, 52bv64), R8[32:0]), gamma_store32(Gamma_mem, bvadd64(R9, 52bv64), Gamma_R8);
     assert ((bvadd64(R9, 52bv64) == $z_addr) ==> (L(mem, $x_addr) ==> Gamma_x_old));
-    assert (Gamma_x_old ==> gamma_load32(Gamma_mem, $x_addr));
     assume {:captureState "%000002ce"} true;
     R0, Gamma_R0 := 0bv64, true;
     goto main_basil_return;
diff --git a/src/test/correct/using_gamma_write_z/clang/using_gamma_write_z_gtirb.expected b/src/test/correct/using_gamma_write_z/clang/using_gamma_write_z_gtirb.expected
index 91ed7e5d7..740065fd5 100644
--- a/src/test/correct/using_gamma_write_z/clang/using_gamma_write_z_gtirb.expected
+++ b/src/test/correct/using_gamma_write_z/clang/using_gamma_write_z_gtirb.expected
@@ -10,8 +10,8 @@ const {:extern} $x_addr: bv64;
 axiom ($x_addr == 69688bv64);
 const {:extern} $z_addr: bv64;
 axiom ($z_addr == 69684bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
-  (if (index == $z_addr) then true else (if (index == $x_addr) then (memory_load32_le(memory, $z_addr) == 0bv32) else false))
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
+  (if (index == $z_addr) then true else (if (index == $x_addr) then (memory_load32_le(mem$in, $z_addr) == 0bv32) else false))
 }
 
 function {:extern} {:bvbuiltin "bvadd"} bvadd64(bv64, bv64) returns (bv64);
@@ -31,10 +31,6 @@ function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv6
   (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
-}
-
 function {:extern} memory_store32_le(memory: [bv64]bv8, index: bv64, value: bv32) returns ([bv64]bv8) {
   memory[index := value[8:0]][bvadd64(index, 1bv64) := value[16:8]][bvadd64(index, 2bv64) := value[24:16]][bvadd64(index, 3bv64) := value[32:24]]
 }
@@ -43,10 +39,7 @@ procedure {:extern} rely();
   modifies Gamma_mem, mem;
   ensures (forall i: bv64 :: (((mem[i] == old(mem[i])) ==> (Gamma_mem[i] == old(Gamma_mem[i])))));
   ensures ((old(memory_load32_le(mem, $x_addr)) == memory_load32_le(mem, $x_addr)) && (old(memory_load32_le(mem, $z_addr)) == memory_load32_le(mem, $z_addr)));
-  free ensures (memory_load8_le(mem, 1852bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1853bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1854bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1855bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1852bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1812bv64);
@@ -82,18 +75,12 @@ procedure main();
   requires ((memory_load32_le(mem, $z_addr) == 0bv32) ==> gamma_load32(Gamma_mem, $x_addr));
   free requires (memory_load64_le(mem, 69664bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
-  free requires (memory_load8_le(mem, 1852bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1853bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1854bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1855bv64) == 0bv8);
+  free requires (memory_load32_le(mem, 1852bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free requires (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free requires (memory_load64_le(mem, 69592bv64) == 1812bv64);
   free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
-  free ensures (memory_load8_le(mem, 1852bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1853bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1854bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1855bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1852bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1812bv64);
@@ -111,7 +98,6 @@ implementation main()
     Gamma_x_old := (gamma_load32(Gamma_mem, $x_addr) || L(mem, $x_addr));
     mem, Gamma_mem := memory_store32_le(mem, bvadd64(R9, 52bv64), R8[32:0]), gamma_store32(Gamma_mem, bvadd64(R9, 52bv64), Gamma_R8);
     assert ((bvadd64(R9, 52bv64) == $z_addr) ==> (L(mem, $x_addr) ==> Gamma_x_old));
-    assert (Gamma_x_old ==> gamma_load32(Gamma_mem, $x_addr));
     assume {:captureState "1820$0"} true;
     R0, Gamma_R0 := 0bv64, true;
     goto main_basil_return;
diff --git a/src/test/correct/using_gamma_write_z/clang_pic/using_gamma_write_z.expected b/src/test/correct/using_gamma_write_z/clang_pic/using_gamma_write_z.expected
index 8787d7ffc..8525eea2b 100644
--- a/src/test/correct/using_gamma_write_z/clang_pic/using_gamma_write_z.expected
+++ b/src/test/correct/using_gamma_write_z/clang_pic/using_gamma_write_z.expected
@@ -10,8 +10,8 @@ const {:extern} $x_addr: bv64;
 axiom ($x_addr == 69688bv64);
 const {:extern} $z_addr: bv64;
 axiom ($z_addr == 69684bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
-  (if (index == $z_addr) then true else (if (index == $x_addr) then (memory_load32_le(memory, $z_addr) == 0bv32) else false))
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
+  (if (index == $z_addr) then true else (if (index == $x_addr) then (memory_load32_le(mem$in, $z_addr) == 0bv32) else false))
 }
 
 function {:extern} {:bvbuiltin "bvadd"} bvadd64(bv64, bv64) returns (bv64);
@@ -35,10 +35,6 @@ function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv6
   (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
-}
-
 function {:extern} memory_store32_le(memory: [bv64]bv8, index: bv64, value: bv32) returns ([bv64]bv8) {
   memory[index := value[8:0]][bvadd64(index, 1bv64) := value[16:8]][bvadd64(index, 2bv64) := value[24:16]][bvadd64(index, 3bv64) := value[32:24]]
 }
@@ -47,15 +43,12 @@ procedure {:extern} rely();
   modifies Gamma_mem, mem;
   ensures (forall i: bv64 :: (((mem[i] == old(mem[i])) ==> (Gamma_mem[i] == old(Gamma_mem[i])))));
   ensures ((old(memory_load32_le(mem, $x_addr)) == memory_load32_le(mem, $x_addr)) && (old(memory_load32_le(mem, $z_addr)) == memory_load32_le(mem, $z_addr)));
-  free ensures (memory_load8_le(mem, 1920bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1921bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1922bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1923bv64) == 0bv8);
-  free ensures (memory_load64_le(mem, 69576bv64) == 69684bv64);
-  free ensures (memory_load64_le(mem, 69672bv64) == 69672bv64);
+  free ensures (memory_load32_le(mem, 1920bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69056bv64) == 1872bv64);
   free ensures (memory_load64_le(mem, 69064bv64) == 1792bv64);
+  free ensures (memory_load64_le(mem, 69576bv64) == 69684bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1876bv64);
+  free ensures (memory_load64_le(mem, 69672bv64) == 69672bv64);
 
 procedure {:extern} rely_transitive();
   modifies Gamma_mem, mem;
@@ -87,24 +80,18 @@ procedure main();
   requires ((memory_load32_le(mem, $z_addr) == 0bv32) ==> gamma_load32(Gamma_mem, $x_addr));
   free requires (memory_load64_le(mem, 69664bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
-  free requires (memory_load8_le(mem, 1920bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1921bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1922bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1923bv64) == 0bv8);
-  free requires (memory_load64_le(mem, 69576bv64) == 69684bv64);
-  free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
+  free requires (memory_load32_le(mem, 1920bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69056bv64) == 1872bv64);
   free requires (memory_load64_le(mem, 69064bv64) == 1792bv64);
+  free requires (memory_load64_le(mem, 69576bv64) == 69684bv64);
   free requires (memory_load64_le(mem, 69592bv64) == 1876bv64);
-  free ensures (memory_load8_le(mem, 1920bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1921bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1922bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1923bv64) == 0bv8);
-  free ensures (memory_load64_le(mem, 69576bv64) == 69684bv64);
-  free ensures (memory_load64_le(mem, 69672bv64) == 69672bv64);
+  free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
+  free ensures (memory_load32_le(mem, 1920bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69056bv64) == 1872bv64);
   free ensures (memory_load64_le(mem, 69064bv64) == 1792bv64);
+  free ensures (memory_load64_le(mem, 69576bv64) == 69684bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1876bv64);
+  free ensures (memory_load64_le(mem, 69672bv64) == 69672bv64);
 
 implementation main()
 {
@@ -120,7 +107,6 @@ implementation main()
     Gamma_x_old := (gamma_load32(Gamma_mem, $x_addr) || L(mem, $x_addr));
     mem, Gamma_mem := memory_store32_le(mem, R9, R8[32:0]), gamma_store32(Gamma_mem, R9, Gamma_R8);
     assert ((R9 == $z_addr) ==> (L(mem, $x_addr) ==> Gamma_x_old));
-    assert (Gamma_x_old ==> gamma_load32(Gamma_mem, $x_addr));
     assume {:captureState "%000002d9"} true;
     R0, Gamma_R0 := 0bv64, true;
     goto main_basil_return;
diff --git a/src/test/correct/using_gamma_write_z/clang_pic/using_gamma_write_z_gtirb.expected b/src/test/correct/using_gamma_write_z/clang_pic/using_gamma_write_z_gtirb.expected
index 797dd348e..8062aae34 100644
--- a/src/test/correct/using_gamma_write_z/clang_pic/using_gamma_write_z_gtirb.expected
+++ b/src/test/correct/using_gamma_write_z/clang_pic/using_gamma_write_z_gtirb.expected
@@ -10,8 +10,8 @@ const {:extern} $x_addr: bv64;
 axiom ($x_addr == 69688bv64);
 const {:extern} $z_addr: bv64;
 axiom ($z_addr == 69684bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
-  (if (index == $z_addr) then true else (if (index == $x_addr) then (memory_load32_le(memory, $z_addr) == 0bv32) else false))
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
+  (if (index == $z_addr) then true else (if (index == $x_addr) then (memory_load32_le(mem$in, $z_addr) == 0bv32) else false))
 }
 
 function {:extern} {:bvbuiltin "bvadd"} bvadd64(bv64, bv64) returns (bv64);
@@ -35,10 +35,6 @@ function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv6
   (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
-}
-
 function {:extern} memory_store32_le(memory: [bv64]bv8, index: bv64, value: bv32) returns ([bv64]bv8) {
   memory[index := value[8:0]][bvadd64(index, 1bv64) := value[16:8]][bvadd64(index, 2bv64) := value[24:16]][bvadd64(index, 3bv64) := value[32:24]]
 }
@@ -47,15 +43,12 @@ procedure {:extern} rely();
   modifies Gamma_mem, mem;
   ensures (forall i: bv64 :: (((mem[i] == old(mem[i])) ==> (Gamma_mem[i] == old(Gamma_mem[i])))));
   ensures ((old(memory_load32_le(mem, $x_addr)) == memory_load32_le(mem, $x_addr)) && (old(memory_load32_le(mem, $z_addr)) == memory_load32_le(mem, $z_addr)));
-  free ensures (memory_load8_le(mem, 1920bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1921bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1922bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1923bv64) == 0bv8);
-  free ensures (memory_load64_le(mem, 69576bv64) == 69684bv64);
-  free ensures (memory_load64_le(mem, 69672bv64) == 69672bv64);
+  free ensures (memory_load32_le(mem, 1920bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69056bv64) == 1872bv64);
   free ensures (memory_load64_le(mem, 69064bv64) == 1792bv64);
+  free ensures (memory_load64_le(mem, 69576bv64) == 69684bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1876bv64);
+  free ensures (memory_load64_le(mem, 69672bv64) == 69672bv64);
 
 procedure {:extern} rely_transitive();
   modifies Gamma_mem, mem;
@@ -87,24 +80,18 @@ procedure main();
   requires ((memory_load32_le(mem, $z_addr) == 0bv32) ==> gamma_load32(Gamma_mem, $x_addr));
   free requires (memory_load64_le(mem, 69664bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
-  free requires (memory_load8_le(mem, 1920bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1921bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1922bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1923bv64) == 0bv8);
-  free requires (memory_load64_le(mem, 69576bv64) == 69684bv64);
-  free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
+  free requires (memory_load32_le(mem, 1920bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69056bv64) == 1872bv64);
   free requires (memory_load64_le(mem, 69064bv64) == 1792bv64);
+  free requires (memory_load64_le(mem, 69576bv64) == 69684bv64);
   free requires (memory_load64_le(mem, 69592bv64) == 1876bv64);
-  free ensures (memory_load8_le(mem, 1920bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1921bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1922bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1923bv64) == 0bv8);
-  free ensures (memory_load64_le(mem, 69576bv64) == 69684bv64);
-  free ensures (memory_load64_le(mem, 69672bv64) == 69672bv64);
+  free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
+  free ensures (memory_load32_le(mem, 1920bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69056bv64) == 1872bv64);
   free ensures (memory_load64_le(mem, 69064bv64) == 1792bv64);
+  free ensures (memory_load64_le(mem, 69576bv64) == 69684bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1876bv64);
+  free ensures (memory_load64_le(mem, 69672bv64) == 69672bv64);
 
 implementation main()
 {
@@ -120,7 +107,6 @@ implementation main()
     Gamma_x_old := (gamma_load32(Gamma_mem, $x_addr) || L(mem, $x_addr));
     mem, Gamma_mem := memory_store32_le(mem, R9, R8[32:0]), gamma_store32(Gamma_mem, R9, Gamma_R8);
     assert ((R9 == $z_addr) ==> (L(mem, $x_addr) ==> Gamma_x_old));
-    assert (Gamma_x_old ==> gamma_load32(Gamma_mem, $x_addr));
     assume {:captureState "1888$0"} true;
     R0, Gamma_R0 := 0bv64, true;
     goto main_basil_return;
diff --git a/src/test/correct/using_gamma_write_z/gcc/using_gamma_write_z.expected b/src/test/correct/using_gamma_write_z/gcc/using_gamma_write_z.expected
index 7ce4c193c..2fe980180 100644
--- a/src/test/correct/using_gamma_write_z/gcc/using_gamma_write_z.expected
+++ b/src/test/correct/using_gamma_write_z/gcc/using_gamma_write_z.expected
@@ -8,8 +8,8 @@ const {:extern} $x_addr: bv64;
 axiom ($x_addr == 69652bv64);
 const {:extern} $z_addr: bv64;
 axiom ($z_addr == 69656bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
-  (if (index == $z_addr) then true else (if (index == $x_addr) then (memory_load32_le(memory, $z_addr) == 0bv32) else false))
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
+  (if (index == $z_addr) then true else (if (index == $x_addr) then (memory_load32_le(mem$in, $z_addr) == 0bv32) else false))
 }
 
 function {:extern} {:bvbuiltin "bvadd"} bvadd64(bv64, bv64) returns (bv64);
@@ -29,10 +29,6 @@ function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv6
   (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
-}
-
 function {:extern} memory_store32_le(memory: [bv64]bv8, index: bv64, value: bv32) returns ([bv64]bv8) {
   memory[index := value[8:0]][bvadd64(index, 1bv64) := value[16:8]][bvadd64(index, 2bv64) := value[24:16]][bvadd64(index, 3bv64) := value[32:24]]
 }
@@ -41,10 +37,7 @@ procedure {:extern} rely();
   modifies Gamma_mem, mem;
   ensures (forall i: bv64 :: (((mem[i] == old(mem[i])) ==> (Gamma_mem[i] == old(Gamma_mem[i])))));
   ensures ((old(memory_load32_le(mem, $x_addr)) == memory_load32_le(mem, $x_addr)) && (old(memory_load32_le(mem, $z_addr)) == memory_load32_le(mem, $z_addr)));
-  free ensures (memory_load8_le(mem, 1856bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1857bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1858bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1859bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1856bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69016bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69024bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69616bv64) == 1812bv64);
@@ -80,18 +73,12 @@ procedure main();
   requires ((memory_load32_le(mem, $z_addr) == 0bv32) ==> gamma_load32(Gamma_mem, $x_addr));
   free requires (memory_load64_le(mem, 69632bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free requires (memory_load8_le(mem, 1856bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1857bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1858bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1859bv64) == 0bv8);
+  free requires (memory_load32_le(mem, 1856bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69016bv64) == 1808bv64);
   free requires (memory_load64_le(mem, 69024bv64) == 1728bv64);
   free requires (memory_load64_le(mem, 69616bv64) == 1812bv64);
   free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free ensures (memory_load8_le(mem, 1856bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1857bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1858bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1859bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1856bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69016bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69024bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69616bv64) == 1812bv64);
@@ -110,7 +97,6 @@ implementation main()
     Gamma_x_old := (gamma_load32(Gamma_mem, $x_addr) || L(mem, $x_addr));
     mem, Gamma_mem := memory_store32_le(mem, R0, R1[32:0]), gamma_store32(Gamma_mem, R0, Gamma_R1);
     assert ((R0 == $z_addr) ==> (L(mem, $x_addr) ==> Gamma_x_old));
-    assert (Gamma_x_old ==> gamma_load32(Gamma_mem, $x_addr));
     assume {:captureState "%000002d8"} true;
     R0, Gamma_R0 := 0bv64, true;
     goto main_basil_return;
diff --git a/src/test/correct/using_gamma_write_z/gcc/using_gamma_write_z_gtirb.expected b/src/test/correct/using_gamma_write_z/gcc/using_gamma_write_z_gtirb.expected
index e3fef2e26..da53252e5 100644
--- a/src/test/correct/using_gamma_write_z/gcc/using_gamma_write_z_gtirb.expected
+++ b/src/test/correct/using_gamma_write_z/gcc/using_gamma_write_z_gtirb.expected
@@ -8,8 +8,8 @@ const {:extern} $x_addr: bv64;
 axiom ($x_addr == 69652bv64);
 const {:extern} $z_addr: bv64;
 axiom ($z_addr == 69656bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
-  (if (index == $z_addr) then true else (if (index == $x_addr) then (memory_load32_le(memory, $z_addr) == 0bv32) else false))
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
+  (if (index == $z_addr) then true else (if (index == $x_addr) then (memory_load32_le(mem$in, $z_addr) == 0bv32) else false))
 }
 
 function {:extern} {:bvbuiltin "bvadd"} bvadd64(bv64, bv64) returns (bv64);
@@ -29,10 +29,6 @@ function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv6
   (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
-}
-
 function {:extern} memory_store32_le(memory: [bv64]bv8, index: bv64, value: bv32) returns ([bv64]bv8) {
   memory[index := value[8:0]][bvadd64(index, 1bv64) := value[16:8]][bvadd64(index, 2bv64) := value[24:16]][bvadd64(index, 3bv64) := value[32:24]]
 }
@@ -41,10 +37,7 @@ procedure {:extern} rely();
   modifies Gamma_mem, mem;
   ensures (forall i: bv64 :: (((mem[i] == old(mem[i])) ==> (Gamma_mem[i] == old(Gamma_mem[i])))));
   ensures ((old(memory_load32_le(mem, $x_addr)) == memory_load32_le(mem, $x_addr)) && (old(memory_load32_le(mem, $z_addr)) == memory_load32_le(mem, $z_addr)));
-  free ensures (memory_load8_le(mem, 1856bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1857bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1858bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1859bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1856bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69016bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69024bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69616bv64) == 1812bv64);
@@ -80,18 +73,12 @@ procedure main();
   requires ((memory_load32_le(mem, $z_addr) == 0bv32) ==> gamma_load32(Gamma_mem, $x_addr));
   free requires (memory_load64_le(mem, 69632bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free requires (memory_load8_le(mem, 1856bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1857bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1858bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1859bv64) == 0bv8);
+  free requires (memory_load32_le(mem, 1856bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69016bv64) == 1808bv64);
   free requires (memory_load64_le(mem, 69024bv64) == 1728bv64);
   free requires (memory_load64_le(mem, 69616bv64) == 1812bv64);
   free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free ensures (memory_load8_le(mem, 1856bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1857bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1858bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1859bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1856bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69016bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69024bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69616bv64) == 1812bv64);
@@ -110,7 +97,6 @@ implementation main()
     Gamma_x_old := (gamma_load32(Gamma_mem, $x_addr) || L(mem, $x_addr));
     mem, Gamma_mem := memory_store32_le(mem, R0, R1[32:0]), gamma_store32(Gamma_mem, R0, Gamma_R1);
     assert ((R0 == $z_addr) ==> (L(mem, $x_addr) ==> Gamma_x_old));
-    assert (Gamma_x_old ==> gamma_load32(Gamma_mem, $x_addr));
     assume {:captureState "1824$0"} true;
     R0, Gamma_R0 := 0bv64, true;
     goto main_basil_return;
diff --git a/src/test/correct/using_gamma_write_z/gcc_O2/using_gamma_write_z.expected b/src/test/correct/using_gamma_write_z/gcc_O2/using_gamma_write_z.expected
index a5be3e625..d253f2a2e 100644
--- a/src/test/correct/using_gamma_write_z/gcc_O2/using_gamma_write_z.expected
+++ b/src/test/correct/using_gamma_write_z/gcc_O2/using_gamma_write_z.expected
@@ -10,8 +10,8 @@ const {:extern} $x_addr: bv64;
 axiom ($x_addr == 69656bv64);
 const {:extern} $z_addr: bv64;
 axiom ($z_addr == 69652bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
-  (if (index == $z_addr) then true else (if (index == $x_addr) then (memory_load32_le(memory, $z_addr) == 0bv32) else false))
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
+  (if (index == $z_addr) then true else (if (index == $x_addr) then (memory_load32_le(mem$in, $z_addr) == 0bv32) else false))
 }
 
 function {:extern} {:bvbuiltin "bvadd"} bvadd64(bv64, bv64) returns (bv64);
@@ -31,10 +31,6 @@ function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv6
   (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
-}
-
 function {:extern} memory_store32_le(memory: [bv64]bv8, index: bv64, value: bv32) returns ([bv64]bv8) {
   memory[index := value[8:0]][bvadd64(index, 1bv64) := value[16:8]][bvadd64(index, 2bv64) := value[24:16]][bvadd64(index, 3bv64) := value[32:24]]
 }
@@ -43,10 +39,7 @@ procedure {:extern} rely();
   modifies Gamma_mem, mem;
   ensures (forall i: bv64 :: (((mem[i] == old(mem[i])) ==> (Gamma_mem[i] == old(Gamma_mem[i])))));
   ensures ((old(memory_load32_le(mem, $x_addr)) == memory_load32_le(mem, $x_addr)) && (old(memory_load32_le(mem, $z_addr)) == memory_load32_le(mem, $z_addr)));
-  free ensures (memory_load8_le(mem, 1896bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1897bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1898bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1899bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1896bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69016bv64) == 1872bv64);
   free ensures (memory_load64_le(mem, 69024bv64) == 1792bv64);
   free ensures (memory_load64_le(mem, 69616bv64) == 1536bv64);
@@ -82,18 +75,12 @@ procedure main();
   requires ((memory_load32_le(mem, $z_addr) == 0bv32) ==> gamma_load32(Gamma_mem, $x_addr));
   free requires (memory_load64_le(mem, 69632bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free requires (memory_load8_le(mem, 1896bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1897bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1898bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1899bv64) == 0bv8);
+  free requires (memory_load32_le(mem, 1896bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69016bv64) == 1872bv64);
   free requires (memory_load64_le(mem, 69024bv64) == 1792bv64);
   free requires (memory_load64_le(mem, 69616bv64) == 1536bv64);
   free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free ensures (memory_load8_le(mem, 1896bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1897bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1898bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1899bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1896bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69016bv64) == 1872bv64);
   free ensures (memory_load64_le(mem, 69024bv64) == 1792bv64);
   free ensures (memory_load64_le(mem, 69616bv64) == 1536bv64);
@@ -112,7 +99,6 @@ implementation main()
     Gamma_x_old := (gamma_load32(Gamma_mem, $x_addr) || L(mem, $x_addr));
     mem, Gamma_mem := memory_store32_le(mem, bvadd64(R1, 20bv64), R2[32:0]), gamma_store32(Gamma_mem, bvadd64(R1, 20bv64), Gamma_R2);
     assert ((bvadd64(R1, 20bv64) == $z_addr) ==> (L(mem, $x_addr) ==> Gamma_x_old));
-    assert (Gamma_x_old ==> gamma_load32(Gamma_mem, $x_addr));
     assume {:captureState "%000001bd"} true;
     goto main_basil_return;
   main_basil_return:
diff --git a/src/test/correct/using_gamma_write_z/gcc_O2/using_gamma_write_z_gtirb.expected b/src/test/correct/using_gamma_write_z/gcc_O2/using_gamma_write_z_gtirb.expected
index 6ae6f75eb..0f13da53f 100644
--- a/src/test/correct/using_gamma_write_z/gcc_O2/using_gamma_write_z_gtirb.expected
+++ b/src/test/correct/using_gamma_write_z/gcc_O2/using_gamma_write_z_gtirb.expected
@@ -10,8 +10,8 @@ const {:extern} $x_addr: bv64;
 axiom ($x_addr == 69656bv64);
 const {:extern} $z_addr: bv64;
 axiom ($z_addr == 69652bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
-  (if (index == $z_addr) then true else (if (index == $x_addr) then (memory_load32_le(memory, $z_addr) == 0bv32) else false))
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
+  (if (index == $z_addr) then true else (if (index == $x_addr) then (memory_load32_le(mem$in, $z_addr) == 0bv32) else false))
 }
 
 function {:extern} {:bvbuiltin "bvadd"} bvadd64(bv64, bv64) returns (bv64);
@@ -31,10 +31,6 @@ function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv6
   (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
-}
-
 function {:extern} memory_store32_le(memory: [bv64]bv8, index: bv64, value: bv32) returns ([bv64]bv8) {
   memory[index := value[8:0]][bvadd64(index, 1bv64) := value[16:8]][bvadd64(index, 2bv64) := value[24:16]][bvadd64(index, 3bv64) := value[32:24]]
 }
@@ -43,10 +39,7 @@ procedure {:extern} rely();
   modifies Gamma_mem, mem;
   ensures (forall i: bv64 :: (((mem[i] == old(mem[i])) ==> (Gamma_mem[i] == old(Gamma_mem[i])))));
   ensures ((old(memory_load32_le(mem, $x_addr)) == memory_load32_le(mem, $x_addr)) && (old(memory_load32_le(mem, $z_addr)) == memory_load32_le(mem, $z_addr)));
-  free ensures (memory_load8_le(mem, 1896bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1897bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1898bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1899bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1896bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69016bv64) == 1872bv64);
   free ensures (memory_load64_le(mem, 69024bv64) == 1792bv64);
   free ensures (memory_load64_le(mem, 69616bv64) == 1536bv64);
@@ -82,18 +75,12 @@ procedure main();
   requires ((memory_load32_le(mem, $z_addr) == 0bv32) ==> gamma_load32(Gamma_mem, $x_addr));
   free requires (memory_load64_le(mem, 69632bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free requires (memory_load8_le(mem, 1896bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1897bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1898bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1899bv64) == 0bv8);
+  free requires (memory_load32_le(mem, 1896bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69016bv64) == 1872bv64);
   free requires (memory_load64_le(mem, 69024bv64) == 1792bv64);
   free requires (memory_load64_le(mem, 69616bv64) == 1536bv64);
   free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free ensures (memory_load8_le(mem, 1896bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1897bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1898bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1899bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1896bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69016bv64) == 1872bv64);
   free ensures (memory_load64_le(mem, 69024bv64) == 1792bv64);
   free ensures (memory_load64_le(mem, 69616bv64) == 1536bv64);
@@ -112,7 +99,6 @@ implementation main()
     Gamma_x_old := (gamma_load32(Gamma_mem, $x_addr) || L(mem, $x_addr));
     mem, Gamma_mem := memory_store32_le(mem, bvadd64(R1, 20bv64), R2[32:0]), gamma_store32(Gamma_mem, bvadd64(R1, 20bv64), Gamma_R2);
     assert ((bvadd64(R1, 20bv64) == $z_addr) ==> (L(mem, $x_addr) ==> Gamma_x_old));
-    assert (Gamma_x_old ==> gamma_load32(Gamma_mem, $x_addr));
     assume {:captureState "1548$0"} true;
     goto main_basil_return;
   main_basil_return:
diff --git a/src/test/correct/using_gamma_write_z/gcc_pic/using_gamma_write_z.expected b/src/test/correct/using_gamma_write_z/gcc_pic/using_gamma_write_z.expected
index addc3d272..23cde8fa0 100644
--- a/src/test/correct/using_gamma_write_z/gcc_pic/using_gamma_write_z.expected
+++ b/src/test/correct/using_gamma_write_z/gcc_pic/using_gamma_write_z.expected
@@ -8,8 +8,8 @@ const {:extern} $x_addr: bv64;
 axiom ($x_addr == 69652bv64);
 const {:extern} $z_addr: bv64;
 axiom ($z_addr == 69656bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
-  (if (index == $z_addr) then true else (if (index == $x_addr) then (memory_load32_le(memory, $z_addr) == 0bv32) else false))
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
+  (if (index == $z_addr) then true else (if (index == $x_addr) then (memory_load32_le(mem$in, $z_addr) == 0bv32) else false))
 }
 
 function {:extern} {:bvbuiltin "bvadd"} bvadd64(bv64, bv64) returns (bv64);
@@ -33,10 +33,6 @@ function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv6
   (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
-}
-
 function {:extern} memory_store32_le(memory: [bv64]bv8, index: bv64, value: bv32) returns ([bv64]bv8) {
   memory[index := value[8:0]][bvadd64(index, 1bv64) := value[16:8]][bvadd64(index, 2bv64) := value[24:16]][bvadd64(index, 3bv64) := value[32:24]]
 }
@@ -45,15 +41,12 @@ procedure {:extern} rely();
   modifies Gamma_mem, mem;
   ensures (forall i: bv64 :: (((mem[i] == old(mem[i])) ==> (Gamma_mem[i] == old(Gamma_mem[i])))));
   ensures ((old(memory_load32_le(mem, $x_addr)) == memory_load32_le(mem, $x_addr)) && (old(memory_load32_le(mem, $z_addr)) == memory_load32_le(mem, $z_addr)));
-  free ensures (memory_load8_le(mem, 1920bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1921bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1922bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1923bv64) == 0bv8);
-  free ensures (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free ensures (memory_load64_le(mem, 69616bv64) == 1876bv64);
+  free ensures (memory_load32_le(mem, 1920bv64) == 131073bv32);
+  free ensures (memory_load64_le(mem, 69008bv64) == 1872bv64);
   free ensures (memory_load64_le(mem, 69016bv64) == 1792bv64);
   free ensures (memory_load64_le(mem, 69600bv64) == 69656bv64);
-  free ensures (memory_load64_le(mem, 69008bv64) == 1872bv64);
+  free ensures (memory_load64_le(mem, 69616bv64) == 1876bv64);
+  free ensures (memory_load64_le(mem, 69640bv64) == 69640bv64);
 
 procedure {:extern} rely_transitive();
   modifies Gamma_mem, mem;
@@ -85,24 +78,18 @@ procedure main();
   requires ((memory_load32_le(mem, $z_addr) == 0bv32) ==> gamma_load32(Gamma_mem, $x_addr));
   free requires (memory_load64_le(mem, 69632bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free requires (memory_load8_le(mem, 1920bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1921bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1922bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1923bv64) == 0bv8);
-  free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free requires (memory_load64_le(mem, 69616bv64) == 1876bv64);
+  free requires (memory_load32_le(mem, 1920bv64) == 131073bv32);
+  free requires (memory_load64_le(mem, 69008bv64) == 1872bv64);
   free requires (memory_load64_le(mem, 69016bv64) == 1792bv64);
   free requires (memory_load64_le(mem, 69600bv64) == 69656bv64);
-  free requires (memory_load64_le(mem, 69008bv64) == 1872bv64);
-  free ensures (memory_load8_le(mem, 1920bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1921bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1922bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1923bv64) == 0bv8);
-  free ensures (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free ensures (memory_load64_le(mem, 69616bv64) == 1876bv64);
+  free requires (memory_load64_le(mem, 69616bv64) == 1876bv64);
+  free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
+  free ensures (memory_load32_le(mem, 1920bv64) == 131073bv32);
+  free ensures (memory_load64_le(mem, 69008bv64) == 1872bv64);
   free ensures (memory_load64_le(mem, 69016bv64) == 1792bv64);
   free ensures (memory_load64_le(mem, 69600bv64) == 69656bv64);
-  free ensures (memory_load64_le(mem, 69008bv64) == 1872bv64);
+  free ensures (memory_load64_le(mem, 69616bv64) == 1876bv64);
+  free ensures (memory_load64_le(mem, 69640bv64) == 69640bv64);
 
 implementation main()
 {
@@ -118,7 +105,6 @@ implementation main()
     Gamma_x_old := (gamma_load32(Gamma_mem, $x_addr) || L(mem, $x_addr));
     mem, Gamma_mem := memory_store32_le(mem, R0, R1[32:0]), gamma_store32(Gamma_mem, R0, Gamma_R1);
     assert ((R0 == $z_addr) ==> (L(mem, $x_addr) ==> Gamma_x_old));
-    assert (Gamma_x_old ==> gamma_load32(Gamma_mem, $x_addr));
     assume {:captureState "%000002d9"} true;
     R0, Gamma_R0 := 0bv64, true;
     goto main_basil_return;
diff --git a/src/test/correct/using_gamma_write_z/gcc_pic/using_gamma_write_z_gtirb.expected b/src/test/correct/using_gamma_write_z/gcc_pic/using_gamma_write_z_gtirb.expected
index fda018aa5..e70802918 100644
--- a/src/test/correct/using_gamma_write_z/gcc_pic/using_gamma_write_z_gtirb.expected
+++ b/src/test/correct/using_gamma_write_z/gcc_pic/using_gamma_write_z_gtirb.expected
@@ -8,8 +8,8 @@ const {:extern} $x_addr: bv64;
 axiom ($x_addr == 69652bv64);
 const {:extern} $z_addr: bv64;
 axiom ($z_addr == 69656bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
-  (if (index == $z_addr) then true else (if (index == $x_addr) then (memory_load32_le(memory, $z_addr) == 0bv32) else false))
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
+  (if (index == $z_addr) then true else (if (index == $x_addr) then (memory_load32_le(mem$in, $z_addr) == 0bv32) else false))
 }
 
 function {:extern} {:bvbuiltin "bvadd"} bvadd64(bv64, bv64) returns (bv64);
@@ -33,10 +33,6 @@ function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv6
   (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
-}
-
 function {:extern} memory_store32_le(memory: [bv64]bv8, index: bv64, value: bv32) returns ([bv64]bv8) {
   memory[index := value[8:0]][bvadd64(index, 1bv64) := value[16:8]][bvadd64(index, 2bv64) := value[24:16]][bvadd64(index, 3bv64) := value[32:24]]
 }
@@ -45,15 +41,12 @@ procedure {:extern} rely();
   modifies Gamma_mem, mem;
   ensures (forall i: bv64 :: (((mem[i] == old(mem[i])) ==> (Gamma_mem[i] == old(Gamma_mem[i])))));
   ensures ((old(memory_load32_le(mem, $x_addr)) == memory_load32_le(mem, $x_addr)) && (old(memory_load32_le(mem, $z_addr)) == memory_load32_le(mem, $z_addr)));
-  free ensures (memory_load8_le(mem, 1920bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1921bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1922bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1923bv64) == 0bv8);
-  free ensures (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free ensures (memory_load64_le(mem, 69616bv64) == 1876bv64);
+  free ensures (memory_load32_le(mem, 1920bv64) == 131073bv32);
+  free ensures (memory_load64_le(mem, 69008bv64) == 1872bv64);
   free ensures (memory_load64_le(mem, 69016bv64) == 1792bv64);
   free ensures (memory_load64_le(mem, 69600bv64) == 69656bv64);
-  free ensures (memory_load64_le(mem, 69008bv64) == 1872bv64);
+  free ensures (memory_load64_le(mem, 69616bv64) == 1876bv64);
+  free ensures (memory_load64_le(mem, 69640bv64) == 69640bv64);
 
 procedure {:extern} rely_transitive();
   modifies Gamma_mem, mem;
@@ -85,24 +78,18 @@ procedure main();
   requires ((memory_load32_le(mem, $z_addr) == 0bv32) ==> gamma_load32(Gamma_mem, $x_addr));
   free requires (memory_load64_le(mem, 69632bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free requires (memory_load8_le(mem, 1920bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1921bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1922bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1923bv64) == 0bv8);
-  free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free requires (memory_load64_le(mem, 69616bv64) == 1876bv64);
+  free requires (memory_load32_le(mem, 1920bv64) == 131073bv32);
+  free requires (memory_load64_le(mem, 69008bv64) == 1872bv64);
   free requires (memory_load64_le(mem, 69016bv64) == 1792bv64);
   free requires (memory_load64_le(mem, 69600bv64) == 69656bv64);
-  free requires (memory_load64_le(mem, 69008bv64) == 1872bv64);
-  free ensures (memory_load8_le(mem, 1920bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1921bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1922bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1923bv64) == 0bv8);
-  free ensures (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free ensures (memory_load64_le(mem, 69616bv64) == 1876bv64);
+  free requires (memory_load64_le(mem, 69616bv64) == 1876bv64);
+  free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
+  free ensures (memory_load32_le(mem, 1920bv64) == 131073bv32);
+  free ensures (memory_load64_le(mem, 69008bv64) == 1872bv64);
   free ensures (memory_load64_le(mem, 69016bv64) == 1792bv64);
   free ensures (memory_load64_le(mem, 69600bv64) == 69656bv64);
-  free ensures (memory_load64_le(mem, 69008bv64) == 1872bv64);
+  free ensures (memory_load64_le(mem, 69616bv64) == 1876bv64);
+  free ensures (memory_load64_le(mem, 69640bv64) == 69640bv64);
 
 implementation main()
 {
@@ -118,7 +105,6 @@ implementation main()
     Gamma_x_old := (gamma_load32(Gamma_mem, $x_addr) || L(mem, $x_addr));
     mem, Gamma_mem := memory_store32_le(mem, R0, R1[32:0]), gamma_store32(Gamma_mem, R0, Gamma_R1);
     assert ((R0 == $z_addr) ==> (L(mem, $x_addr) ==> Gamma_x_old));
-    assert (Gamma_x_old ==> gamma_load32(Gamma_mem, $x_addr));
     assume {:captureState "1888$0"} true;
     R0, Gamma_R0 := 0bv64, true;
     goto main_basil_return;
diff --git a/src/test/dsa/interproc_pointer_arithmetic/interproc_pointer_arithmetic.adt b/src/test/dsa/interproc_pointer_arithmetic/interproc_pointer_arithmetic.adt
new file mode 100755
index 000000000..b3975b7b4
--- /dev/null
+++ b/src/test/dsa/interproc_pointer_arithmetic/interproc_pointer_arithmetic.adt
@@ -0,0 +1,609 @@
+Project(Attrs([Attr("filename","interproc_pointer_arithmetic.out"),
+Attr("image-specification","(declare abi (name str))\n(declare arch (name str))\n(declare base-address (addr int))\n(declare bias (off int))\n(declare bits (size int))\n(declare code-region (addr int) (size int) (off int))\n(declare code-start (addr int))\n(declare entry-point (addr int))\n(declare external-reference (addr int) (name str))\n(declare format (name str))\n(declare is-executable (flag bool))\n(declare is-little-endian (flag bool))\n(declare llvm:base-address (addr int))\n(declare llvm:code-entry (name str) (off int) (size int))\n(declare llvm:coff-import-library (name str))\n(declare llvm:coff-virtual-section-header (name str) (addr int) (size int))\n(declare llvm:elf-program-header (name str) (off int) (size int))\n(declare llvm:elf-program-header-flags (name str) (ld bool) (r bool) \n (w bool) (x bool))\n(declare llvm:elf-virtual-program-header (name str) (addr int) (size int))\n(declare llvm:entry-point (addr int))\n(declare llvm:macho-symbol (name str) (value int))\n(declare llvm:name-reference (at int) (name str))\n(declare llvm:relocation (at int) (addr int))\n(declare llvm:section-entry (name str) (addr int) (size int) (off int))\n(declare llvm:section-flags (name str) (r bool) (w bool) (x bool))\n(declare llvm:segment-command (name str) (off int) (size int))\n(declare llvm:segment-command-flags (name str) (r bool) (w bool) (x bool))\n(declare llvm:symbol-entry (name str) (addr int) (size int) (off int)\n (value int))\n(declare llvm:virtual-segment-command (name str) (addr int) (size int))\n(declare mapped (addr int) (size int) (off int))\n(declare named-region (addr int) (size int) (name str))\n(declare named-symbol (addr int) (name str))\n(declare require (name str))\n(declare section (addr int) (size int))\n(declare segment (addr int) (size int) (r bool) (w bool) (x bool))\n(declare subarch (name str))\n(declare symbol-chunk (addr int) (size int) (root int))\n(declare symbol-value (addr int) (value int))\n(declare system (name str))\n(declare vendor (name str))\n\n(abi unknown)\n(arch aarch64)\n(base-address 0)\n(bias 0)\n(bits 64)\n(code-region 2000 20 2000)\n(code-region 1600 400 1600)\n(code-region 1488 112 1488)\n(code-region 1464 24 1464)\n(code-start 1652)\n(code-start 1600)\n(code-start 1908)\n(code-start 1876)\n(entry-point 1600)\n(external-reference 131032 _ITM_deregisterTMCloneTable)\n(external-reference 131040 __cxa_finalize)\n(external-reference 131048 __gmon_start__)\n(external-reference 131064 _ITM_registerTMCloneTable)\n(external-reference 130984 __libc_start_main)\n(external-reference 130992 __cxa_finalize)\n(external-reference 131000 malloc)\n(external-reference 131008 __gmon_start__)\n(external-reference 131016 abort)\n(format elf)\n(is-executable true)\n(is-little-endian true)\n(llvm:base-address 0)\n(llvm:code-entry abort 0 0)\n(llvm:code-entry malloc 0 0)\n(llvm:code-entry __cxa_finalize 0 0)\n(llvm:code-entry __libc_start_main 0 0)\n(llvm:code-entry _init 1464 0)\n(llvm:code-entry callee 1876 32)\n(llvm:code-entry main 1908 92)\n(llvm:code-entry _start 1600 52)\n(llvm:code-entry abort@GLIBC_2.17 0 0)\n(llvm:code-entry malloc@GLIBC_2.17 0 0)\n(llvm:code-entry _fini 2000 0)\n(llvm:code-entry __cxa_finalize@GLIBC_2.17 0 0)\n(llvm:code-entry __libc_start_main@GLIBC_2.34 0 0)\n(llvm:code-entry frame_dummy 1872 0)\n(llvm:code-entry __do_global_dtors_aux 1792 0)\n(llvm:code-entry register_tm_clones 1728 0)\n(llvm:code-entry deregister_tm_clones 1680 0)\n(llvm:code-entry call_weak_fn 1652 20)\n(llvm:code-entry .fini 2000 20)\n(llvm:code-entry .text 1600 400)\n(llvm:code-entry .plt 1488 112)\n(llvm:code-entry .init 1464 24)\n(llvm:elf-program-header 08 64912 624)\n(llvm:elf-program-header 07 0 0)\n(llvm:elf-program-header 06 2024 68)\n(llvm:elf-program-header 05 596 68)\n(llvm:elf-program-header 04 64928 496)\n(llvm:elf-program-header 03 64912 640)\n(llvm:elf-program-header 02 0 2292)\n(llvm:elf-program-header 01 568 27)\n(llvm:elf-program-header 00 64 504)\n(llvm:elf-program-header-flags 08 false true false false)\n(llvm:elf-program-header-flags 07 false true true false)\n(llvm:elf-program-header-flags 06 false true false false)\n(llvm:elf-program-header-flags 05 false true false false)\n(llvm:elf-program-header-flags 04 false true true false)\n(llvm:elf-program-header-flags 03 true true true false)\n(llvm:elf-program-header-flags 02 true true false true)\n(llvm:elf-program-header-flags 01 false true false false)\n(llvm:elf-program-header-flags 00 false true false false)\n(llvm:elf-virtual-program-header 08 130448 624)\n(llvm:elf-virtual-program-header 07 0 0)\n(llvm:elf-virtual-program-header 06 2024 68)\n(llvm:elf-virtual-program-header 05 596 68)\n(llvm:elf-virtual-program-header 04 130464 496)\n(llvm:elf-virtual-program-header 03 130448 648)\n(llvm:elf-virtual-program-header 02 0 2292)\n(llvm:elf-virtual-program-header 01 568 27)\n(llvm:elf-virtual-program-header 00 64 504)\n(llvm:entry-point 1600)\n(llvm:name-reference 131016 abort)\n(llvm:name-reference 131008 __gmon_start__)\n(llvm:name-reference 131000 malloc)\n(llvm:name-reference 130992 __cxa_finalize)\n(llvm:name-reference 130984 __libc_start_main)\n(llvm:name-reference 131064 _ITM_registerTMCloneTable)\n(llvm:name-reference 131048 __gmon_start__)\n(llvm:name-reference 131040 __cxa_finalize)\n(llvm:name-reference 131032 _ITM_deregisterTMCloneTable)\n(llvm:section-entry .shstrtab 0 250 68301)\n(llvm:section-entry .strtab 0 589 67712)\n(llvm:section-entry .symtab 0 2112 65600)\n(llvm:section-entry .comment 0 43 65552)\n(llvm:section-entry .bss 131088 8 65552)\n(llvm:section-entry .data 131072 16 65536)\n(llvm:section-entry .got 130960 112 65424)\n(llvm:section-entry .dynamic 130464 496 64928)\n(llvm:section-entry .fini_array 130456 8 64920)\n(llvm:section-entry .init_array 130448 8 64912)\n(llvm:section-entry .eh_frame 2096 196 2096)\n(llvm:section-entry .eh_frame_hdr 2024 68 2024)\n(llvm:section-entry .rodata 2020 4 2020)\n(llvm:section-entry .fini 2000 20 2000)\n(llvm:section-entry .text 1600 400 1600)\n(llvm:section-entry .plt 1488 112 1488)\n(llvm:section-entry .init 1464 24 1464)\n(llvm:section-entry .rela.plt 1344 120 1344)\n(llvm:section-entry .rela.dyn 1152 192 1152)\n(llvm:section-entry .gnu.version_r 1104 48 1104)\n(llvm:section-entry .gnu.version 1084 20 1084)\n(llvm:section-entry .dynstr 936 148 936)\n(llvm:section-entry .dynsym 696 240 696)\n(llvm:section-entry .gnu.hash 664 28 664)\n(llvm:section-entry .note.ABI-tag 632 32 632)\n(llvm:section-entry .note.gnu.build-id 596 36 596)\n(llvm:section-entry .interp 568 27 568)\n(llvm:section-flags .shstrtab true false false)\n(llvm:section-flags .strtab true false false)\n(llvm:section-flags .symtab true false false)\n(llvm:section-flags .comment true false false)\n(llvm:section-flags .bss true true false)\n(llvm:section-flags .data true true false)\n(llvm:section-flags .got true true false)\n(llvm:section-flags .dynamic true true false)\n(llvm:section-flags .fini_array true true false)\n(llvm:section-flags .init_array true true false)\n(llvm:section-flags .eh_frame true false false)\n(llvm:section-flags .eh_frame_hdr true false false)\n(llvm:section-flags .rodata true false false)\n(llvm:section-flags .fini true false true)\n(llvm:section-flags .text true false true)\n(llvm:section-flags .plt true false true)\n(llvm:section-flags .init true false true)\n(llvm:section-flags .rela.plt true false false)\n(llvm:section-flags .rela.dyn true false false)\n(llvm:section-flags .gnu.version_r true false false)\n(llvm:section-flags .gnu.version true false false)\n(llvm:section-flags .dynstr true false false)\n(llvm:section-flags .dynsym true false false)\n(llvm:section-flags .gnu.hash true false false)\n(llvm:section-flags .note.ABI-tag true false false)\n(llvm:section-flags .note.gnu.build-id true false false)\n(llvm:section-flags .interp true false false)\n(llvm:symbol-entry abort 0 0 0 0)\n(llvm:symbol-entry malloc 0 0 0 0)\n(llvm:symbol-entry __cxa_finalize 0 0 0 0)\n(llvm:symbol-entry __libc_start_main 0 0 0 0)\n(llvm:symbol-entry _init 1464 0 1464 1464)\n(llvm:symbol-entry callee 1876 32 1876 1876)\n(llvm:symbol-entry main 1908 92 1908 1908)\n(llvm:symbol-entry _start 1600 52 1600 1600)\n(llvm:symbol-entry abort@GLIBC_2.17 0 0 0 0)\n(llvm:symbol-entry malloc@GLIBC_2.17 0 0 0 0)\n(llvm:symbol-entry _fini 2000 0 2000 2000)\n(llvm:symbol-entry __cxa_finalize@GLIBC_2.17 0 0 0 0)\n(llvm:symbol-entry __libc_start_main@GLIBC_2.34 0 0 0 0)\n(llvm:symbol-entry frame_dummy 1872 0 1872 1872)\n(llvm:symbol-entry __do_global_dtors_aux 1792 0 1792 1792)\n(llvm:symbol-entry register_tm_clones 1728 0 1728 1728)\n(llvm:symbol-entry deregister_tm_clones 1680 0 1680 1680)\n(llvm:symbol-entry call_weak_fn 1652 20 1652 1652)\n(mapped 0 2292 0)\n(mapped 130448 640 64912)\n(named-region 0 2292 02)\n(named-region 130448 648 03)\n(named-region 568 27 .interp)\n(named-region 596 36 .note.gnu.build-id)\n(named-region 632 32 .note.ABI-tag)\n(named-region 664 28 .gnu.hash)\n(named-region 696 240 .dynsym)\n(named-region 936 148 .dynstr)\n(named-region 1084 20 .gnu.version)\n(named-region 1104 48 .gnu.version_r)\n(named-region 1152 192 .rela.dyn)\n(named-region 1344 120 .rela.plt)\n(named-region 1464 24 .init)\n(named-region 1488 112 .plt)\n(named-region 1600 400 .text)\n(named-region 2000 20 .fini)\n(named-region 2020 4 .rodata)\n(named-region 2024 68 .eh_frame_hdr)\n(named-region 2096 196 .eh_frame)\n(named-region 130448 8 .init_array)\n(named-region 130456 8 .fini_array)\n(named-region 130464 496 .dynamic)\n(named-region 130960 112 .got)\n(named-region 131072 16 .data)\n(named-region 131088 8 .bss)\n(named-region 0 43 .comment)\n(named-region 0 2112 .symtab)\n(named-region 0 589 .strtab)\n(named-region 0 250 .shstrtab)\n(named-symbol 1652 call_weak_fn)\n(named-symbol 1680 deregister_tm_clones)\n(named-symbol 1728 register_tm_clones)\n(named-symbol 1792 __do_global_dtors_aux)\n(named-symbol 1872 frame_dummy)\n(named-symbol 0 __libc_start_main@GLIBC_2.34)\n(named-symbol 0 __cxa_finalize@GLIBC_2.17)\n(named-symbol 2000 _fini)\n(named-symbol 0 malloc@GLIBC_2.17)\n(named-symbol 0 abort@GLIBC_2.17)\n(named-symbol 1600 _start)\n(named-symbol 1908 main)\n(named-symbol 1876 callee)\n(named-symbol 1464 _init)\n(named-symbol 0 __libc_start_main)\n(named-symbol 0 __cxa_finalize)\n(named-symbol 0 malloc)\n(named-symbol 0 abort)\n(require libc.so.6)\n(section 568 27)\n(section 596 36)\n(section 632 32)\n(section 664 28)\n(section 696 240)\n(section 936 148)\n(section 1084 20)\n(section 1104 48)\n(section 1152 192)\n(section 1344 120)\n(section 1464 24)\n(section 1488 112)\n(section 1600 400)\n(section 2000 20)\n(section 2020 4)\n(section 2024 68)\n(section 2096 196)\n(section 130448 8)\n(section 130456 8)\n(section 130464 496)\n(section 130960 112)\n(section 131072 16)\n(section 131088 8)\n(section 0 43)\n(section 0 2112)\n(section 0 589)\n(section 0 250)\n(segment 0 2292 true false true)\n(segment 130448 648 true true false)\n(subarch v8)\n(symbol-chunk 1652 20 1652)\n(symbol-chunk 1600 52 1600)\n(symbol-chunk 1908 92 1908)\n(symbol-chunk 1876 32 1876)\n(symbol-value 1652 1652)\n(symbol-value 1680 1680)\n(symbol-value 1728 1728)\n(symbol-value 1792 1792)\n(symbol-value 1872 1872)\n(symbol-value 2000 2000)\n(symbol-value 1600 1600)\n(symbol-value 1908 1908)\n(symbol-value 1876 1876)\n(symbol-value 1464 1464)\n(symbol-value 0 0)\n(system \"\")\n(vendor \"\")\n"),
+Attr("abi-name","aarch64-linux-gnu-elf")]),
+Sections([Section(".shstrtab", 0x0, "\x7f\x45\x4c\x46\x02\x01\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x03\x00\xb7\x00\x01\x00\x00\x00\x40\x06\x00\x00\x00\x00\x00\x00\x40\x00\x00\x00\x00\x00\x00\x00\xc8\x0b\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x40\x00\x38\x00\x09\x00\x40\x00\x1c\x00\x1b\x00\x06\x00\x00\x00\x04\x00\x00\x00\x40\x00\x00\x00\x00\x00\x00\x00\x40\x00\x00\x00\x00\x00\x00\x00\x40\x00\x00\x00\x00\x00\x00\x00\xf8\x01\x00\x00\x00\x00\x00\x00\xf8\x01\x00\x00\x00\x00\x00\x00\x08\x00\x00\x00\x00\x00\x00\x00\x03\x00\x00\x00\x04\x00\x00\x00\x38\x02\x00\x00\x00\x00\x00\x00\x38\x02\x00\x00\x00\x00\x00\x00\x38\x02\x00\x00\x00\x00\x00\x00\x1b\x00\x00\x00\x00\x00\x00\x00\x1b\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x05\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xf4\x08\x00\x00\x00\x00\x00\x00\xf4\x08\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x00\x00\x01\x00\x00\x00\x06\x00\x00\x00\x90\xfd\x00\x00\x00\x00\x00\x00\x90\xfd"),
+Section(".strtab", 0x0, "\x7f\x45\x4c\x46\x02\x01\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x03\x00\xb7\x00\x01\x00\x00\x00\x40\x06\x00\x00\x00\x00\x00\x00\x40\x00\x00\x00\x00\x00\x00\x00\xc8\x0b\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x40\x00\x38\x00\x09\x00\x40\x00\x1c\x00\x1b\x00\x06\x00\x00\x00\x04\x00\x00\x00\x40\x00\x00\x00\x00\x00\x00\x00\x40\x00\x00\x00\x00\x00\x00\x00\x40\x00\x00\x00\x00\x00\x00\x00\xf8\x01\x00\x00\x00\x00\x00\x00\xf8\x01\x00\x00\x00\x00\x00\x00\x08\x00\x00\x00\x00\x00\x00\x00\x03\x00\x00\x00\x04\x00\x00\x00\x38\x02\x00\x00\x00\x00\x00\x00\x38\x02\x00\x00\x00\x00\x00\x00\x38\x02\x00\x00\x00\x00\x00\x00\x1b\x00\x00\x00\x00\x00\x00\x00\x1b\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x05\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xf4\x08\x00\x00\x00\x00\x00\x00\xf4\x08\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x00\x00\x01\x00\x00\x00\x06\x00\x00\x00\x90\xfd\x00\x00\x00\x00\x00\x00\x90\xfd\x01\x00\x00\x00\x00\x00\x90\xfd\x01\x00\x00\x00\x00\x00\x80\x02\x00\x00\x00\x00\x00\x00\x88\x02\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x00\x00\x02\x00\x00\x00\x06\x00\x00\x00\xa0\xfd\x00\x00\x00\x00\x00\x00\xa0\xfd\x01\x00\x00\x00\x00\x00\xa0\xfd\x01\x00\x00\x00\x00\x00\xf0\x01\x00\x00\x00\x00\x00\x00\xf0\x01\x00\x00\x00\x00\x00\x00\x08\x00\x00\x00\x00\x00\x00\x00\x04\x00\x00\x00\x04\x00\x00\x00\x54\x02\x00\x00\x00\x00\x00\x00\x54\x02\x00\x00\x00\x00\x00\x00\x54\x02\x00\x00\x00\x00\x00\x00\x44\x00\x00\x00\x00\x00\x00\x00\x44\x00\x00\x00\x00\x00\x00\x00\x04\x00\x00\x00\x00\x00\x00\x00\x50\xe5\x74\x64\x04\x00\x00\x00\xe8\x07\x00\x00\x00\x00\x00\x00\xe8\x07\x00\x00\x00\x00\x00\x00\xe8\x07\x00\x00\x00\x00\x00\x00\x44\x00\x00\x00\x00\x00\x00\x00\x44\x00\x00\x00\x00\x00\x00\x00\x04\x00\x00\x00\x00\x00\x00\x00\x51\xe5\x74\x64\x06\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x10\x00\x00\x00\x00\x00\x00\x00\x52\xe5\x74\x64\x04\x00\x00\x00\x90\xfd\x00\x00\x00\x00\x00\x00\x90\xfd\x01\x00\x00\x00\x00\x00\x90\xfd\x01\x00\x00\x00\x00\x00\x70\x02\x00\x00\x00\x00\x00\x00\x70\x02\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00\x2f\x6c\x69\x62\x2f\x6c\x64\x2d\x6c\x69\x6e\x75\x78\x2d\x61\x61\x72\x63\x68\x36\x34"),
+Section(".symtab", 0x0, "\x7f\x45\x4c\x46\x02\x01\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x03\x00\xb7\x00\x01\x00\x00\x00\x40\x06\x00\x00\x00\x00\x00\x00\x40\x00\x00\x00\x00\x00\x00\x00\xc8\x0b\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x40\x00\x38\x00\x09\x00\x40\x00\x1c\x00\x1b\x00\x06\x00\x00\x00\x04\x00\x00\x00\x40\x00\x00\x00\x00\x00\x00\x00\x40\x00\x00\x00\x00\x00\x00\x00\x40\x00\x00\x00\x00\x00\x00\x00\xf8\x01\x00\x00\x00\x00\x00\x00\xf8\x01\x00\x00\x00\x00\x00\x00\x08\x00\x00\x00\x00\x00\x00\x00\x03\x00\x00\x00\x04\x00\x00\x00\x38\x02\x00\x00\x00\x00\x00\x00\x38\x02\x00\x00\x00\x00\x00\x00\x38\x02\x00\x00\x00\x00\x00\x00\x1b\x00\x00\x00\x00\x00\x00\x00\x1b\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x05\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xf4\x08\x00\x00\x00\x00\x00\x00\xf4\x08\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x00\x00\x01\x00\x00\x00\x06\x00\x00\x00\x90\xfd\x00\x00\x00\x00\x00\x00\x90\xfd\x01\x00\x00\x00\x00\x00\x90\xfd\x01\x00\x00\x00\x00\x00\x80\x02\x00\x00\x00\x00\x00\x00\x88\x02\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x00\x00\x02\x00\x00\x00\x06\x00\x00\x00\xa0\xfd\x00\x00\x00\x00\x00\x00\xa0\xfd\x01\x00\x00\x00\x00\x00\xa0\xfd\x01\x00\x00\x00\x00\x00\xf0\x01\x00\x00\x00\x00\x00\x00\xf0\x01\x00\x00\x00\x00\x00\x00\x08\x00\x00\x00\x00\x00\x00\x00\x04\x00\x00\x00\x04\x00\x00\x00\x54\x02\x00\x00\x00\x00\x00\x00\x54\x02\x00\x00\x00\x00\x00\x00\x54\x02\x00\x00\x00\x00\x00\x00\x44\x00\x00\x00\x00\x00\x00\x00\x44\x00\x00\x00\x00\x00\x00\x00\x04\x00\x00\x00\x00\x00\x00\x00\x50\xe5\x74\x64\x04\x00\x00\x00\xe8\x07\x00\x00\x00\x00\x00\x00\xe8\x07\x00\x00\x00\x00\x00\x00\xe8\x07\x00\x00\x00\x00\x00\x00\x44\x00\x00\x00\x00\x00\x00\x00\x44\x00\x00\x00\x00\x00\x00\x00\x04\x00\x00\x00\x00\x00\x00\x00\x51\xe5\x74\x64\x06\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x10\x00\x00\x00\x00\x00\x00\x00\x52\xe5\x74\x64\x04\x00\x00\x00\x90\xfd\x00\x00\x00\x00\x00\x00\x90\xfd\x01\x00\x00\x00\x00\x00\x90\xfd\x01\x00\x00\x00\x00\x00\x70\x02\x00\x00\x00\x00\x00\x00\x70\x02\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00\x2f\x6c\x69\x62\x2f\x6c\x64\x2d\x6c\x69\x6e\x75\x78\x2d\x61\x61\x72\x63\x68\x36\x34\x2e\x73\x6f\x2e\x31\x00\x00\x04\x00\x00\x00\x14\x00\x00\x00\x03\x00\x00\x00\x47\x4e\x55\x00\x56\x39\x03\xc2\xe1\x5e\x80\x94\xce\xd1\x56\x3a\x67\x2f\x13\x1f\x3c\x67\x44\x5e\x04\x00\x00\x00\x10\x00\x00\x00\x01\x00\x00\x00\x47\x4e\x55\x00\x00\x00\x00\x00\x03\x00\x00\x00\x07\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x03\x00\x0b\x00\xb8\x05\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x03\x00\x16\x00\x00\x00\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x08\x00\x00\x00\x12\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4f\x00\x00\x00\x20\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1a\x00\x00\x00\x22\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x12\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6b\x00\x00\x00\x20\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x29\x00\x00\x00\x12\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x7a\x00\x00\x00\x20\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6d\x61\x6c\x6c\x6f\x63\x00\x5f\x5f\x6c\x69\x62\x63\x5f\x73\x74\x61\x72\x74\x5f\x6d\x61\x69\x6e\x00\x5f\x5f\x63\x78\x61\x5f\x66\x69\x6e\x61\x6c\x69\x7a\x65\x00\x61\x62\x6f\x72\x74\x00\x6c\x69\x62\x63\x2e\x73\x6f\x2e\x36\x00\x47\x4c\x49\x42\x43\x5f\x32\x2e\x31\x37\x00\x47\x4c\x49\x42\x43\x5f\x32\x2e\x33\x34\x00\x5f\x49\x54\x4d\x5f\x64\x65\x72\x65\x67\x69\x73\x74\x65\x72\x54\x4d\x43\x6c\x6f\x6e\x65\x54\x61\x62\x6c\x65\x00\x5f\x5f\x67\x6d\x6f\x6e\x5f\x73\x74\x61\x72\x74\x5f\x5f\x00\x5f\x49\x54\x4d\x5f\x72\x65\x67\x69\x73\x74\x65\x72\x54\x4d\x43\x6c\x6f\x6e\x65\x54\x61\x62\x6c\x65\x00\x00\x00\x00\x00\x00\x00\x02\x00\x01\x00\x03\x00\x03\x00\x01\x00\x03\x00\x01\x00\x01\x00\x02\x00\x2f\x00\x00\x00\x10\x00\x00\x00\x00\x00\x00\x00\x97\x91\x96\x06\x00\x00\x03\x00\x39\x00\x00\x00\x10\x00\x00\x00\xb4\x91\x96\x06\x00\x00\x02\x00\x44\x00\x00\x00\x00\x00\x00\x00\x90\xfd\x01\x00\x00\x00\x00\x00\x03\x04\x00\x00\x00\x00\x00\x00\x50\x07\x00\x00\x00\x00\x00\x00\x98\xfd\x01\x00\x00\x00\x00\x00\x03\x04\x00\x00\x00\x00\x00\x00\x00\x07\x00\x00\x00\x00\x00\x00\xf0\xff\x01\x00\x00\x00\x00\x00\x03\x04\x00\x00\x00\x00\x00\x00\x74\x07\x00\x00\x00\x00\x00\x00\x08\x00\x02\x00\x00\x00\x00\x00\x03\x04\x00\x00\x00\x00\x00\x00\x08\x00\x02\x00\x00\x00\x00\x00\xd8\xff\x01\x00\x00\x00\x00\x00\x01\x04\x00\x00\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe0\xff\x01\x00\x00\x00\x00\x00\x01\x04\x00\x00\x05\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe8\xff\x01\x00\x00\x00\x00\x00\x01\x04\x00\x00\x07\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xf8\xff\x01\x00\x00\x00\x00\x00\x01\x04\x00\x00\x09\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa8\xff\x01\x00\x00\x00\x00\x00\x02\x04\x00\x00\x03\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb0\xff\x01\x00\x00\x00\x00\x00\x02\x04\x00\x00\x05\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb8\xff\x01\x00\x00\x00\x00\x00\x02\x04\x00\x00\x06\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc0\xff\x01\x00\x00\x00\x00\x00\x02\x04\x00\x00\x07\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc8\xff\x01\x00\x00\x00\x00\x00\x02\x04\x00\x00\x08\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1f\x20\x03\xd5\xfd\x7b\xbf\xa9\xfd\x03\x00\x91\x2c\x00\x00\x94\xfd\x7b\xc1\xa8\xc0\x03\x5f\xd6\xf0\x7b\xbf\xa9\xf0\x00\x00\xf0\x11\xd2\x47\xf9\x10\x82\x3e\x91\x20\x02\x1f\xd6\x1f\x20\x03\xd5\x1f\x20\x03\xd5\x1f\x20\x03\xd5\xf0\x00\x00\xf0\x11\xd6\x47\xf9\x10\xa2\x3e\x91\x20\x02\x1f\xd6\xf0\x00\x00\xf0\x11\xda\x47\xf9\x10\xc2\x3e\x91\x20\x02\x1f\xd6\xf0\x00\x00\xf0\x11\xde\x47\xf9\x10\xe2\x3e\x91\x20\x02\x1f\xd6\xf0\x00\x00\xf0\x11\xe2\x47\xf9\x10\x02\x3f\x91\x20\x02\x1f\xd6\xf0\x00\x00\xf0\x11\xe6\x47\xf9\x10\x22\x3f\x91\x20\x02\x1f\xd6\x1f\x20\x03\xd5\x1d\x00\x80\xd2\x1e\x00\x80\xd2\xe5\x03\x00\xaa\xe1\x03\x40\xf9\xe2\x23\x00\x91\xe6\x03\x00\x91\xe0\x00\x00\xf0\x00\xf8\x47\xf9\x03\x00\x80\xd2\x04\x00\x80\xd2\xe1\xff\xff\x97\xf0\xff\xff\x97\xe0\x00\x00\xf0\x00\xf4\x47\xf9\x40\x00\x00\xb4\xe8\xff\xff\x17\xc0\x03\x5f\xd6\x1f\x20\x03\xd5\x1f\x20\x03\xd5\x00\x01\x00\x90\x00\x40\x00\x91\x01\x01\x00\x90\x21\x40\x00\x91\x3f\x00\x00\xeb\xc0\x00\x00\x54\xe1\x00\x00\xf0\x21\xec\x47\xf9\x61\x00\x00\xb4\xf0\x03\x01\xaa\x00\x02\x1f\xd6\xc0\x03\x5f\xd6\x00\x01\x00\x90\x00\x40\x00\x91\x01\x01\x00\x90\x21\x40\x00\x91\x21\x00\x00\xcb\x22\xfc\x7f\xd3\x41\x0c\x81\x8b\x21\xfc\x41\x93\xc1\x00\x00\xb4\xe2\x00\x00\xf0\x42\xfc\x47\xf9\x62\x00\x00\xb4\xf0\x03\x02\xaa\x00\x02\x1f\xd6\xc0\x03\x5f\xd6\x1f\x20\x03\xd5\xfd\x7b\xbe\xa9\xfd\x03\x00\x91\xf3\x0b\x00\xf9\x13\x01\x00\x90\x60\x42\x40\x39\x40\x01\x00\x35\xe0\x00\x00\xf0\x00\xf0\x47\xf9\x80\x00\x00\xb4\x00\x01\x00\x90\x00\x04\x40\xf9\xb5\xff\xff\x97\xd8\xff\xff\x97\x20\x00\x80\x52\x60\x42\x00\x39\xf3\x0b\x40\xf9\xfd\x7b\xc2\xa8\xc0\x03\x5f\xd6\x1f\x20\x03\xd5\x1f\x20\x03\xd5\xdc\xff\xff\x17\xff\x83\x00\xd1\xe0\x07\x00\xf9\xe0\x07\x40\xf9\x00\x40\x00\x91\xe0\x0f\x00\xf9\xe0\x0f\x40\xf9\xff\x83\x00\x91\xc0\x03\x5f\xd6\xfd\x7b\xbd\xa9\xfd\x03\x00\x91\x80\x02\x80\xd2\xa4\xff\xff\x97\xe0\x0f\x00\xf9\xe0\x0f\x40\xf9\x81\x01\x80\x52\x01\x00\x00\xb9\xe0\x0f\x40\xf9\x00\x40\x00\x91\xe0\x13\x00\xf9\xe0\x13\x40\xf9\xa1\x01\x80\x52\x01\x00\x00\xb9\xe0\x13\x40\xf9\xe9\xff\xff\x97\xe0\x17\x00\xf9\xe0\x17\x40\xf9\xc1\x01\x80\x52\x01\x00\x00\xb9\x00\x00\x80\x52\xfd\x7b\xc3\xa8\xc0\x03\x5f\xd6\x1f\x20\x03\xd5\xfd\x7b\xbf\xa9\xfd\x03\x00\x91\xfd\x7b\xc1\xa8\xc0\x03\x5f\xd6\x01\x00\x02\x00\x01\x1b\x03\x3b\x44\x00\x00\x00\x07\x00\x00\x00\x58\xfe\xff\xff\x5c\x00\x00\x00\xa8\xfe\xff\xff\x70\x00\x00\x00\xd8\xfe\xff\xff\x84\x00\x00\x00\x18\xff\xff\xff\x98\x00\x00\x00\x68\xff\xff\xff\xbc\x00\x00\x00\x6c\xff\xff\xff\xd0\x00\x00\x00\x8c\xff\xff\xff\xe8\x00\x00\x00\x00\x00\x00\x00\x10\x00\x00\x00\x00\x00\x00\x00\x01\x7a\x52\x00\x04\x78\x1e\x01"),
+Section(".comment", 0x0, "\x7f\x45\x4c\x46\x02\x01\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x03\x00\xb7\x00\x01\x00\x00\x00\x40\x06\x00\x00\x00\x00\x00\x00\x40\x00\x00\x00\x00\x00\x00\x00\xc8\x0b\x01"),
+Section(".interp", 0x238, "\x2f\x6c\x69\x62\x2f\x6c\x64\x2d\x6c\x69\x6e\x75\x78\x2d\x61\x61\x72\x63\x68\x36\x34\x2e\x73\x6f\x2e\x31\x00"),
+Section(".note.gnu.build-id", 0x254, "\x04\x00\x00\x00\x14\x00\x00\x00\x03\x00\x00\x00\x47\x4e\x55\x00\x56\x39\x03\xc2\xe1\x5e\x80\x94\xce\xd1\x56\x3a\x67\x2f\x13\x1f\x3c\x67\x44\x5e"),
+Section(".note.ABI-tag", 0x278, "\x04\x00\x00\x00\x10\x00\x00\x00\x01\x00\x00\x00\x47\x4e\x55\x00\x00\x00\x00\x00\x03\x00\x00\x00\x07\x00\x00\x00\x00\x00\x00\x00"),
+Section(".gnu.hash", 0x298, "\x01\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"),
+Section(".dynsym", 0x2B8, "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x03\x00\x0b\x00\xb8\x05\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x03\x00\x16\x00\x00\x00\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x08\x00\x00\x00\x12\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4f\x00\x00\x00\x20\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1a\x00\x00\x00\x22\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x12\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6b\x00\x00\x00\x20\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x29\x00\x00\x00\x12\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x7a\x00\x00\x00\x20\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"),
+Section(".dynstr", 0x3A8, "\x00\x6d\x61\x6c\x6c\x6f\x63\x00\x5f\x5f\x6c\x69\x62\x63\x5f\x73\x74\x61\x72\x74\x5f\x6d\x61\x69\x6e\x00\x5f\x5f\x63\x78\x61\x5f\x66\x69\x6e\x61\x6c\x69\x7a\x65\x00\x61\x62\x6f\x72\x74\x00\x6c\x69\x62\x63\x2e\x73\x6f\x2e\x36\x00\x47\x4c\x49\x42\x43\x5f\x32\x2e\x31\x37\x00\x47\x4c\x49\x42\x43\x5f\x32\x2e\x33\x34\x00\x5f\x49\x54\x4d\x5f\x64\x65\x72\x65\x67\x69\x73\x74\x65\x72\x54\x4d\x43\x6c\x6f\x6e\x65\x54\x61\x62\x6c\x65\x00\x5f\x5f\x67\x6d\x6f\x6e\x5f\x73\x74\x61\x72\x74\x5f\x5f\x00\x5f\x49\x54\x4d\x5f\x72\x65\x67\x69\x73\x74\x65\x72\x54\x4d\x43\x6c\x6f\x6e\x65\x54\x61\x62\x6c\x65\x00"),
+Section(".gnu.version", 0x43C, "\x00\x00\x00\x00\x00\x00\x02\x00\x01\x00\x03\x00\x03\x00\x01\x00\x03\x00\x01\x00"),
+Section(".gnu.version_r", 0x450, "\x01\x00\x02\x00\x2f\x00\x00\x00\x10\x00\x00\x00\x00\x00\x00\x00\x97\x91\x96\x06\x00\x00\x03\x00\x39\x00\x00\x00\x10\x00\x00\x00\xb4\x91\x96\x06\x00\x00\x02\x00\x44\x00\x00\x00\x00\x00\x00\x00"),
+Section(".rela.dyn", 0x480, "\x90\xfd\x01\x00\x00\x00\x00\x00\x03\x04\x00\x00\x00\x00\x00\x00\x50\x07\x00\x00\x00\x00\x00\x00\x98\xfd\x01\x00\x00\x00\x00\x00\x03\x04\x00\x00\x00\x00\x00\x00\x00\x07\x00\x00\x00\x00\x00\x00\xf0\xff\x01\x00\x00\x00\x00\x00\x03\x04\x00\x00\x00\x00\x00\x00\x74\x07\x00\x00\x00\x00\x00\x00\x08\x00\x02\x00\x00\x00\x00\x00\x03\x04\x00\x00\x00\x00\x00\x00\x08\x00\x02\x00\x00\x00\x00\x00\xd8\xff\x01\x00\x00\x00\x00\x00\x01\x04\x00\x00\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe0\xff\x01\x00\x00\x00\x00\x00\x01\x04\x00\x00\x05\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe8\xff\x01\x00\x00\x00\x00\x00\x01\x04\x00\x00\x07\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xf8\xff\x01\x00\x00\x00\x00\x00\x01\x04\x00\x00\x09\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"),
+Section(".rela.plt", 0x540, "\xa8\xff\x01\x00\x00\x00\x00\x00\x02\x04\x00\x00\x03\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb0\xff\x01\x00\x00\x00\x00\x00\x02\x04\x00\x00\x05\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb8\xff\x01\x00\x00\x00\x00\x00\x02\x04\x00\x00\x06\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc0\xff\x01\x00\x00\x00\x00\x00\x02\x04\x00\x00\x07\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc8\xff\x01\x00\x00\x00\x00\x00\x02\x04\x00\x00\x08\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"),
+Section(".init", 0x5B8, "\x1f\x20\x03\xd5\xfd\x7b\xbf\xa9\xfd\x03\x00\x91\x2c\x00\x00\x94\xfd\x7b\xc1\xa8\xc0\x03\x5f\xd6"),
+Section(".plt", 0x5D0, "\xf0\x7b\xbf\xa9\xf0\x00\x00\xf0\x11\xd2\x47\xf9\x10\x82\x3e\x91\x20\x02\x1f\xd6\x1f\x20\x03\xd5\x1f\x20\x03\xd5\x1f\x20\x03\xd5\xf0\x00\x00\xf0\x11\xd6\x47\xf9\x10\xa2\x3e\x91\x20\x02\x1f\xd6\xf0\x00\x00\xf0\x11\xda\x47\xf9\x10\xc2\x3e\x91\x20\x02\x1f\xd6\xf0\x00\x00\xf0\x11\xde\x47\xf9\x10\xe2\x3e\x91\x20\x02\x1f\xd6\xf0\x00\x00\xf0\x11\xe2\x47\xf9\x10\x02\x3f\x91\x20\x02\x1f\xd6\xf0\x00\x00\xf0\x11\xe6\x47\xf9\x10\x22\x3f\x91\x20\x02\x1f\xd6"),
+Section(".text", 0x640, "\x1f\x20\x03\xd5\x1d\x00\x80\xd2\x1e\x00\x80\xd2\xe5\x03\x00\xaa\xe1\x03\x40\xf9\xe2\x23\x00\x91\xe6\x03\x00\x91\xe0\x00\x00\xf0\x00\xf8\x47\xf9\x03\x00\x80\xd2\x04\x00\x80\xd2\xe1\xff\xff\x97\xf0\xff\xff\x97\xe0\x00\x00\xf0\x00\xf4\x47\xf9\x40\x00\x00\xb4\xe8\xff\xff\x17\xc0\x03\x5f\xd6\x1f\x20\x03\xd5\x1f\x20\x03\xd5\x00\x01\x00\x90\x00\x40\x00\x91\x01\x01\x00\x90\x21\x40\x00\x91\x3f\x00\x00\xeb\xc0\x00\x00\x54\xe1\x00\x00\xf0\x21\xec\x47\xf9\x61\x00\x00\xb4\xf0\x03\x01\xaa\x00\x02\x1f\xd6\xc0\x03\x5f\xd6\x00\x01\x00\x90\x00\x40\x00\x91\x01\x01\x00\x90\x21\x40\x00\x91\x21\x00\x00\xcb\x22\xfc\x7f\xd3\x41\x0c\x81\x8b\x21\xfc\x41\x93\xc1\x00\x00\xb4\xe2\x00\x00\xf0\x42\xfc\x47\xf9\x62\x00\x00\xb4\xf0\x03\x02\xaa\x00\x02\x1f\xd6\xc0\x03\x5f\xd6\x1f\x20\x03\xd5\xfd\x7b\xbe\xa9\xfd\x03\x00\x91\xf3\x0b\x00\xf9\x13\x01\x00\x90\x60\x42\x40\x39\x40\x01\x00\x35\xe0\x00\x00\xf0\x00\xf0\x47\xf9\x80\x00\x00\xb4\x00\x01\x00\x90\x00\x04\x40\xf9\xb5\xff\xff\x97\xd8\xff\xff\x97\x20\x00\x80\x52\x60\x42\x00\x39\xf3\x0b\x40\xf9\xfd\x7b\xc2\xa8\xc0\x03\x5f\xd6\x1f\x20\x03\xd5\x1f\x20\x03\xd5\xdc\xff\xff\x17\xff\x83\x00\xd1\xe0\x07\x00\xf9\xe0\x07\x40\xf9\x00\x40\x00\x91\xe0\x0f\x00\xf9\xe0\x0f\x40\xf9\xff\x83\x00\x91\xc0\x03\x5f\xd6\xfd\x7b\xbd\xa9\xfd\x03\x00\x91\x80\x02\x80\xd2\xa4\xff\xff\x97\xe0\x0f\x00\xf9\xe0\x0f\x40\xf9\x81\x01\x80\x52\x01\x00\x00\xb9\xe0\x0f\x40\xf9\x00\x40\x00\x91\xe0\x13\x00\xf9\xe0\x13\x40\xf9\xa1\x01\x80\x52\x01\x00\x00\xb9\xe0\x13\x40\xf9\xe9\xff\xff\x97\xe0\x17\x00\xf9\xe0\x17\x40\xf9\xc1\x01\x80\x52\x01\x00\x00\xb9\x00\x00\x80\x52\xfd\x7b\xc3\xa8\xc0\x03\x5f\xd6"),
+Section(".fini", 0x7D0, "\x1f\x20\x03\xd5\xfd\x7b\xbf\xa9\xfd\x03\x00\x91\xfd\x7b\xc1\xa8\xc0\x03\x5f\xd6"),
+Section(".rodata", 0x7E4, "\x01\x00\x02\x00"),
+Section(".eh_frame_hdr", 0x7E8, "\x01\x1b\x03\x3b\x44\x00\x00\x00\x07\x00\x00\x00\x58\xfe\xff\xff\x5c\x00\x00\x00\xa8\xfe\xff\xff\x70\x00\x00\x00\xd8\xfe\xff\xff\x84\x00\x00\x00\x18\xff\xff\xff\x98\x00\x00\x00\x68\xff\xff\xff\xbc\x00\x00\x00\x6c\xff\xff\xff\xd0\x00\x00\x00\x8c\xff\xff\xff\xe8\x00\x00\x00"),
+Section(".eh_frame", 0x830, "\x10\x00\x00\x00\x00\x00\x00\x00\x01\x7a\x52\x00\x04\x78\x1e\x01\x1b\x0c\x1f\x00\x10\x00\x00\x00\x18\x00\x00\x00\xf4\xfd\xff\xff\x34\x00\x00\x00\x00\x41\x07\x1e\x10\x00\x00\x00\x2c\x00\x00\x00\x30\xfe\xff\xff\x30\x00\x00\x00\x00\x00\x00\x00\x10\x00\x00\x00\x40\x00\x00\x00\x4c\xfe\xff\xff\x3c\x00\x00\x00\x00\x00\x00\x00\x20\x00\x00\x00\x54\x00\x00\x00\x78\xfe\xff\xff\x48\x00\x00\x00\x00\x41\x0e\x20\x9d\x04\x9e\x03\x42\x93\x02\x4e\xde\xdd\xd3\x0e\x00\x00\x00\x00\x10\x00\x00\x00\x78\x00\x00\x00\xa4\xfe\xff\xff\x04\x00\x00\x00\x00\x00\x00\x00\x14\x00\x00\x00\x8c\x00\x00\x00\x94\xfe\xff\xff\x20\x00\x00\x00\x00\x41\x0e\x20\x46\x0e\x00\x00\x1c\x00\x00\x00\xa4\x00\x00\x00\x9c\xfe\xff\xff\x5c\x00\x00\x00\x00\x41\x0e\x30\x9d\x06\x9e\x05\x55\xde\xdd\x0e\x00\x00\x00\x00\x00\x00\x00\x00"),
+Section(".fini_array", 0x1FD98, "\x00\x07\x00\x00\x00\x00\x00\x00"),
+Section(".dynamic", 0x1FDA0, "\x01\x00\x00\x00\x00\x00\x00\x00\x2f\x00\x00\x00\x00\x00\x00\x00\x0c\x00\x00\x00\x00\x00\x00\x00\xb8\x05\x00\x00\x00\x00\x00\x00\x0d\x00\x00\x00\x00\x00\x00\x00\xd0\x07\x00\x00\x00\x00\x00\x00\x19\x00\x00\x00\x00\x00\x00\x00\x90\xfd\x01\x00\x00\x00\x00\x00\x1b\x00\x00\x00\x00\x00\x00\x00\x08\x00\x00\x00\x00\x00\x00\x00\x1a\x00\x00\x00\x00\x00\x00\x00\x98\xfd\x01\x00\x00\x00\x00\x00\x1c\x00\x00\x00\x00\x00\x00\x00\x08\x00\x00\x00\x00\x00\x00\x00\xf5\xfe\xff\x6f\x00\x00\x00\x00\x98\x02\x00\x00\x00\x00\x00\x00\x05\x00\x00\x00\x00\x00\x00\x00\xa8\x03\x00\x00\x00\x00\x00\x00\x06\x00\x00\x00\x00\x00\x00\x00\xb8\x02\x00\x00\x00\x00\x00\x00\x0a\x00\x00\x00\x00\x00\x00\x00\x94\x00\x00\x00\x00\x00\x00\x00\x0b\x00\x00\x00\x00\x00\x00\x00\x18\x00\x00\x00\x00\x00\x00\x00\x15\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x03\x00\x00\x00\x00\x00\x00\x00\x90\xff\x01\x00\x00\x00\x00\x00\x02\x00\x00\x00\x00\x00\x00\x00\x78\x00\x00\x00\x00\x00\x00\x00\x14\x00\x00\x00\x00\x00\x00\x00\x07\x00\x00\x00\x00\x00\x00\x00\x17\x00\x00\x00\x00\x00\x00\x00\x40\x05\x00\x00\x00\x00\x00\x00\x07\x00\x00\x00\x00\x00\x00\x00\x80\x04\x00\x00\x00\x00\x00\x00\x08\x00\x00\x00\x00\x00\x00\x00\xc0\x00\x00\x00\x00\x00\x00\x00\x09\x00\x00\x00\x00\x00\x00\x00\x18\x00\x00\x00\x00\x00\x00\x00\x1e\x00\x00\x00\x00\x00\x00\x00\x08\x00\x00\x00\x00\x00\x00\x00\xfb\xff\xff\x6f\x00\x00\x00\x00\x01\x00\x00\x08\x00\x00\x00\x00\xfe\xff\xff\x6f\x00\x00\x00\x00\x50\x04\x00\x00\x00\x00\x00\x00\xff\xff\xff\x6f\x00\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00\xf0\xff\xff\x6f\x00\x00\x00\x00\x3c\x04\x00\x00\x00\x00\x00\x00\xf9\xff\xff\x6f\x00\x00\x00\x00\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"),
+Section(".got", 0x1FF90, "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd0\x05\x00\x00\x00\x00\x00\x00\xd0\x05\x00\x00\x00\x00\x00\x00\xd0\x05\x00\x00\x00\x00\x00\x00\xd0\x05\x00\x00\x00\x00\x00\x00\xd0\x05\x00\x00\x00\x00\x00\x00\xa0\xfd\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x74\x07\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"),
+Section(".data", 0x20000, "\x00\x00\x00\x00\x00\x00\x00\x00\x08\x00\x02\x00\x00\x00\x00\x00"),
+Section(".init_array", 0x1FD90, "\x50\x07\x00\x00\x00\x00\x00\x00")]),
+Memmap([Annotation(Region(0x0,0x8F3), Attr("segment","02 0 2292")),
+Annotation(Region(0x640,0x673), Attr("symbol","_start")),
+Annotation(Region(0x0,0xF9), Attr("section",".shstrtab")),
+Annotation(Region(0x0,0x24C), Attr("section",".strtab")),
+Annotation(Region(0x0,0x83F), Attr("section",".symtab")),
+Annotation(Region(0x0,0x2A), Attr("section",".comment")),
+Annotation(Region(0x238,0x252), Attr("section",".interp")),
+Annotation(Region(0x254,0x277), Attr("section",".note.gnu.build-id")),
+Annotation(Region(0x278,0x297), Attr("section",".note.ABI-tag")),
+Annotation(Region(0x298,0x2B3), Attr("section",".gnu.hash")),
+Annotation(Region(0x2B8,0x3A7), Attr("section",".dynsym")),
+Annotation(Region(0x3A8,0x43B), Attr("section",".dynstr")),
+Annotation(Region(0x43C,0x44F), Attr("section",".gnu.version")),
+Annotation(Region(0x450,0x47F), Attr("section",".gnu.version_r")),
+Annotation(Region(0x480,0x53F), Attr("section",".rela.dyn")),
+Annotation(Region(0x540,0x5B7), Attr("section",".rela.plt")),
+Annotation(Region(0x5B8,0x5CF), Attr("section",".init")),
+Annotation(Region(0x5D0,0x63F), Attr("section",".plt")),
+Annotation(Region(0x5B8,0x5CF), Attr("code-region","()")),
+Annotation(Region(0x5D0,0x63F), Attr("code-region","()")),
+Annotation(Region(0x640,0x673), Attr("symbol-info","_start 0x640 52")),
+Annotation(Region(0x674,0x687), Attr("symbol","call_weak_fn")),
+Annotation(Region(0x674,0x687), Attr("symbol-info","call_weak_fn 0x674 20")),
+Annotation(Region(0x754,0x773), Attr("symbol","callee")),
+Annotation(Region(0x640,0x7CF), Attr("section",".text")),
+Annotation(Region(0x640,0x7CF), Attr("code-region","()")),
+Annotation(Region(0x754,0x773), Attr("symbol-info","callee 0x754 32")),
+Annotation(Region(0x774,0x7CF), Attr("symbol","main")),
+Annotation(Region(0x774,0x7CF), Attr("symbol-info","main 0x774 92")),
+Annotation(Region(0x7D0,0x7E3), Attr("section",".fini")),
+Annotation(Region(0x7D0,0x7E3), Attr("code-region","()")),
+Annotation(Region(0x7E4,0x7E7), Attr("section",".rodata")),
+Annotation(Region(0x7E8,0x82B), Attr("section",".eh_frame_hdr")),
+Annotation(Region(0x830,0x8F3), Attr("section",".eh_frame")),
+Annotation(Region(0x1FD90,0x2000F), Attr("segment","03 0x1FD90 648")),
+Annotation(Region(0x1FD98,0x1FD9F), Attr("section",".fini_array")),
+Annotation(Region(0x1FDA0,0x1FF8F), Attr("section",".dynamic")),
+Annotation(Region(0x1FF90,0x1FFFF), Attr("section",".got")),
+Annotation(Region(0x20000,0x2000F), Attr("section",".data")),
+Annotation(Region(0x1FD90,0x1FD97), Attr("section",".init_array"))]),
+Program(Tid(1_844, "%00000734"), Attrs([]),
+ Subs([Sub(Tid(1_789, "@__cxa_finalize"), Attrs([Attr("address","0x600"),
+Attr("stub","()"), Attr("c.proto","signed (*)(void)")]), "__cxa_finalize",
+ Args([Arg(Tid(1_845, "%00000735"), Attrs([Attr("c.data","Top:u32"),
+Attr("c.layout","[signed : 32]"), Attr("c.type","signed")]),
+ Var("__cxa_finalize_result",Imm(32)), LOW(32,Var("R0",Imm(64))), Out())]),
+Blks([Blk(Tid(1_113, "@__cxa_finalize"), Attrs([Attr("address","0x600")]),
+ Phis([]), Defs([Def(Tid(1_377, "%00000561"), Attrs([Attr("address","0x600"),
+Attr("insn","adrp x16, #126976")]), Var("R16",Imm(64)), Int(126976,64)),
+Def(Tid(1_384, "%00000568"), Attrs([Attr("address","0x604"),
+Attr("insn","ldr x17, [x16, #0xfb0]")]), Var("R17",Imm(64)),
+Load(Var("mem",Mem(64,8)),PLUS(Var("R16",Imm(64)),Int(4016,64)),LittleEndian(),64)),
+Def(Tid(1_390, "%0000056e"), Attrs([Attr("address","0x608"),
+Attr("insn","add x16, x16, #0xfb0")]), Var("R16",Imm(64)),
+PLUS(Var("R16",Imm(64)),Int(4016,64)))]), Jmps([Call(Tid(1_395, "%00000573"),
+ Attrs([Attr("address","0x60C"), Attr("insn","br x17")]), Int(1,1),
+(Indirect(Var("R17",Imm(64))),))]))])),
+Sub(Tid(1_790, "@__do_global_dtors_aux"), Attrs([Attr("address","0x700"),
+Attr("c.proto","signed (*)(void)")]), "__do_global_dtors_aux",
+ Args([Arg(Tid(1_846, "%00000736"), Attrs([Attr("c.data","Top:u32"),
+Attr("c.layout","[signed : 32]"), Attr("c.type","signed")]),
+ Var("__do_global_dtors_aux_result",Imm(32)), LOW(32,Var("R0",Imm(64))),
+Out())]), Blks([Blk(Tid(735, "@__do_global_dtors_aux"),
+ Attrs([Attr("address","0x700")]), Phis([]), Defs([Def(Tid(739, "%000002e3"),
+ Attrs([Attr("address","0x700"),
+Attr("insn","stp x29, x30, [sp, #-0x20]!")]), Var("#3",Imm(64)),
+PLUS(Var("R31",Imm(64)),Int(18446744073709551584,64))),
+Def(Tid(745, "%000002e9"), Attrs([Attr("address","0x700"),
+Attr("insn","stp x29, x30, [sp, #-0x20]!")]), Var("mem",Mem(64,8)),
+Store(Var("mem",Mem(64,8)),Var("#3",Imm(64)),Var("R29",Imm(64)),LittleEndian(),64)),
+Def(Tid(751, "%000002ef"), Attrs([Attr("address","0x700"),
+Attr("insn","stp x29, x30, [sp, #-0x20]!")]), Var("mem",Mem(64,8)),
+Store(Var("mem",Mem(64,8)),PLUS(Var("#3",Imm(64)),Int(8,64)),Var("R30",Imm(64)),LittleEndian(),64)),
+Def(Tid(755, "%000002f3"), Attrs([Attr("address","0x700"),
+Attr("insn","stp x29, x30, [sp, #-0x20]!")]), Var("R31",Imm(64)),
+Var("#3",Imm(64))), Def(Tid(761, "%000002f9"),
+ Attrs([Attr("address","0x704"), Attr("insn","mov x29, sp")]),
+ Var("R29",Imm(64)), Var("R31",Imm(64))), Def(Tid(769, "%00000301"),
+ Attrs([Attr("address","0x708"), Attr("insn","str x19, [sp, #0x10]")]),
+ Var("mem",Mem(64,8)),
+Store(Var("mem",Mem(64,8)),PLUS(Var("R31",Imm(64)),Int(16,64)),Var("R19",Imm(64)),LittleEndian(),64)),
+Def(Tid(774, "%00000306"), Attrs([Attr("address","0x70C"),
+Attr("insn","adrp x19, #131072")]), Var("R19",Imm(64)), Int(131072,64)),
+Def(Tid(781, "%0000030d"), Attrs([Attr("address","0x710"),
+Attr("insn","ldrb w0, [x19, #0x10]")]), Var("R0",Imm(64)),
+UNSIGNED(64,Load(Var("mem",Mem(64,8)),PLUS(Var("R19",Imm(64)),Int(16,64)),LittleEndian(),8)))]),
+Jmps([Goto(Tid(788, "%00000314"), Attrs([Attr("address","0x714"),
+Attr("insn","cbnz w0, #0x28")]),
+ NEQ(Extract(31,0,Var("R0",Imm(64))),Int(0,32)),
+Direct(Tid(786, "%00000312"))), Goto(Tid(1_834, "%0000072a"), Attrs([]),
+ Int(1,1), Direct(Tid(1_058, "%00000422")))])), Blk(Tid(1_058, "%00000422"),
+ Attrs([Attr("address","0x718")]), Phis([]),
+Defs([Def(Tid(1_061, "%00000425"), Attrs([Attr("address","0x718"),
+Attr("insn","adrp x0, #126976")]), Var("R0",Imm(64)), Int(126976,64)),
+Def(Tid(1_068, "%0000042c"), Attrs([Attr("address","0x71C"),
+Attr("insn","ldr x0, [x0, #0xfe0]")]), Var("R0",Imm(64)),
+Load(Var("mem",Mem(64,8)),PLUS(Var("R0",Imm(64)),Int(4064,64)),LittleEndian(),64))]),
+Jmps([Goto(Tid(1_074, "%00000432"), Attrs([Attr("address","0x720"),
+Attr("insn","cbz x0, #0x10")]), EQ(Var("R0",Imm(64)),Int(0,64)),
+Direct(Tid(1_072, "%00000430"))), Goto(Tid(1_835, "%0000072b"), Attrs([]),
+ Int(1,1), Direct(Tid(1_097, "%00000449")))])), Blk(Tid(1_097, "%00000449"),
+ Attrs([Attr("address","0x724")]), Phis([]),
+Defs([Def(Tid(1_100, "%0000044c"), Attrs([Attr("address","0x724"),
+Attr("insn","adrp x0, #131072")]), Var("R0",Imm(64)), Int(131072,64)),
+Def(Tid(1_107, "%00000453"), Attrs([Attr("address","0x728"),
+Attr("insn","ldr x0, [x0, #0x8]")]), Var("R0",Imm(64)),
+Load(Var("mem",Mem(64,8)),PLUS(Var("R0",Imm(64)),Int(8,64)),LittleEndian(),64)),
+Def(Tid(1_112, "%00000458"), Attrs([Attr("address","0x72C"),
+Attr("insn","bl #-0x12c")]), Var("R30",Imm(64)), Int(1840,64))]),
+Jmps([Call(Tid(1_115, "%0000045b"), Attrs([Attr("address","0x72C"),
+Attr("insn","bl #-0x12c")]), Int(1,1),
+(Direct(Tid(1_789, "@__cxa_finalize")),Direct(Tid(1_072, "%00000430"))))])),
+Blk(Tid(1_072, "%00000430"), Attrs([Attr("address","0x730")]), Phis([]),
+Defs([Def(Tid(1_080, "%00000438"), Attrs([Attr("address","0x730"),
+Attr("insn","bl #-0xa0")]), Var("R30",Imm(64)), Int(1844,64))]),
+Jmps([Call(Tid(1_082, "%0000043a"), Attrs([Attr("address","0x730"),
+Attr("insn","bl #-0xa0")]), Int(1,1),
+(Direct(Tid(1_804, "@deregister_tm_clones")),Direct(Tid(1_084, "%0000043c"))))])),
+Blk(Tid(1_084, "%0000043c"), Attrs([Attr("address","0x734")]), Phis([]),
+Defs([Def(Tid(1_087, "%0000043f"), Attrs([Attr("address","0x734"),
+Attr("insn","mov w0, #0x1")]), Var("R0",Imm(64)), Int(1,64)),
+Def(Tid(1_095, "%00000447"), Attrs([Attr("address","0x738"),
+Attr("insn","strb w0, [x19, #0x10]")]), Var("mem",Mem(64,8)),
+Store(Var("mem",Mem(64,8)),PLUS(Var("R19",Imm(64)),Int(16,64)),Extract(7,0,Var("R0",Imm(64))),LittleEndian(),8))]),
+Jmps([Goto(Tid(1_836, "%0000072c"), Attrs([]), Int(1,1),
+Direct(Tid(786, "%00000312")))])), Blk(Tid(786, "%00000312"),
+ Attrs([Attr("address","0x73C")]), Phis([]), Defs([Def(Tid(796, "%0000031c"),
+ Attrs([Attr("address","0x73C"), Attr("insn","ldr x19, [sp, #0x10]")]),
+ Var("R19",Imm(64)),
+Load(Var("mem",Mem(64,8)),PLUS(Var("R31",Imm(64)),Int(16,64)),LittleEndian(),64)),
+Def(Tid(803, "%00000323"), Attrs([Attr("address","0x740"),
+Attr("insn","ldp x29, x30, [sp], #0x20")]), Var("R29",Imm(64)),
+Load(Var("mem",Mem(64,8)),Var("R31",Imm(64)),LittleEndian(),64)),
+Def(Tid(808, "%00000328"), Attrs([Attr("address","0x740"),
+Attr("insn","ldp x29, x30, [sp], #0x20")]), Var("R30",Imm(64)),
+Load(Var("mem",Mem(64,8)),PLUS(Var("R31",Imm(64)),Int(8,64)),LittleEndian(),64)),
+Def(Tid(812, "%0000032c"), Attrs([Attr("address","0x740"),
+Attr("insn","ldp x29, x30, [sp], #0x20")]), Var("R31",Imm(64)),
+PLUS(Var("R31",Imm(64)),Int(32,64)))]), Jmps([Call(Tid(817, "%00000331"),
+ Attrs([Attr("address","0x744"), Attr("insn","ret")]), Int(1,1),
+(Indirect(Var("R30",Imm(64))),))]))])), Sub(Tid(1_794, "@__libc_start_main"),
+ Attrs([Attr("address","0x5F0"), Attr("stub","()"),
+Attr("c.proto","signed (*)(signed (*)(signed , char** , char** );* main, signed , char** , \nvoid* auxv)")]),
+ "__libc_start_main", Args([Arg(Tid(1_847, "%00000737"),
+ Attrs([Attr("c.data","Top:u64 ptr ptr"),
+Attr("c.layout","**[<undef> : 64]"),
+Attr("c.type","signed (*)(signed , char** , char** );*")]),
+ Var("__libc_start_main_main",Imm(64)), Var("R0",Imm(64)), In()),
+Arg(Tid(1_848, "%00000738"), Attrs([Attr("c.data","Top:u32"),
+Attr("c.layout","[signed : 32]"), Attr("c.type","signed")]),
+ Var("__libc_start_main_arg2",Imm(32)), LOW(32,Var("R1",Imm(64))), In()),
+Arg(Tid(1_849, "%00000739"), Attrs([Attr("c.data","Top:u8 ptr ptr"),
+Attr("c.layout","**[char : 8]"), Attr("c.type","char**")]),
+ Var("__libc_start_main_arg3",Imm(64)), Var("R2",Imm(64)), Both()),
+Arg(Tid(1_850, "%0000073a"), Attrs([Attr("c.data","{} ptr"),
+Attr("c.layout","*[<undef> : 8]"), Attr("c.type","void*")]),
+ Var("__libc_start_main_auxv",Imm(64)), Var("R3",Imm(64)), Both()),
+Arg(Tid(1_851, "%0000073b"), Attrs([Attr("c.data","Top:u32"),
+Attr("c.layout","[signed : 32]"), Attr("c.type","signed")]),
+ Var("__libc_start_main_result",Imm(32)), LOW(32,Var("R0",Imm(64))),
+Out())]), Blks([Blk(Tid(568, "@__libc_start_main"),
+ Attrs([Attr("address","0x5F0")]), Phis([]),
+Defs([Def(Tid(1_355, "%0000054b"), Attrs([Attr("address","0x5F0"),
+Attr("insn","adrp x16, #126976")]), Var("R16",Imm(64)), Int(126976,64)),
+Def(Tid(1_362, "%00000552"), Attrs([Attr("address","0x5F4"),
+Attr("insn","ldr x17, [x16, #0xfa8]")]), Var("R17",Imm(64)),
+Load(Var("mem",Mem(64,8)),PLUS(Var("R16",Imm(64)),Int(4008,64)),LittleEndian(),64)),
+Def(Tid(1_368, "%00000558"), Attrs([Attr("address","0x5F8"),
+Attr("insn","add x16, x16, #0xfa8")]), Var("R16",Imm(64)),
+PLUS(Var("R16",Imm(64)),Int(4008,64)))]), Jmps([Call(Tid(1_373, "%0000055d"),
+ Attrs([Attr("address","0x5FC"), Attr("insn","br x17")]), Int(1,1),
+(Indirect(Var("R17",Imm(64))),))]))])), Sub(Tid(1_795, "@_fini"),
+ Attrs([Attr("address","0x7D0"), Attr("c.proto","signed (*)(void)")]),
+ "_fini", Args([Arg(Tid(1_852, "%0000073c"), Attrs([Attr("c.data","Top:u32"),
+Attr("c.layout","[signed : 32]"), Attr("c.type","signed")]),
+ Var("_fini_result",Imm(32)), LOW(32,Var("R0",Imm(64))), Out())]),
+Blks([Blk(Tid(52, "@_fini"), Attrs([Attr("address","0x7D0")]), Phis([]),
+Defs([Def(Tid(58, "%0000003a"), Attrs([Attr("address","0x7D4"),
+Attr("insn","stp x29, x30, [sp, #-0x10]!")]), Var("#0",Imm(64)),
+PLUS(Var("R31",Imm(64)),Int(18446744073709551600,64))),
+Def(Tid(64, "%00000040"), Attrs([Attr("address","0x7D4"),
+Attr("insn","stp x29, x30, [sp, #-0x10]!")]), Var("mem",Mem(64,8)),
+Store(Var("mem",Mem(64,8)),Var("#0",Imm(64)),Var("R29",Imm(64)),LittleEndian(),64)),
+Def(Tid(70, "%00000046"), Attrs([Attr("address","0x7D4"),
+Attr("insn","stp x29, x30, [sp, #-0x10]!")]), Var("mem",Mem(64,8)),
+Store(Var("mem",Mem(64,8)),PLUS(Var("#0",Imm(64)),Int(8,64)),Var("R30",Imm(64)),LittleEndian(),64)),
+Def(Tid(74, "%0000004a"), Attrs([Attr("address","0x7D4"),
+Attr("insn","stp x29, x30, [sp, #-0x10]!")]), Var("R31",Imm(64)),
+Var("#0",Imm(64))), Def(Tid(80, "%00000050"), Attrs([Attr("address","0x7D8"),
+Attr("insn","mov x29, sp")]), Var("R29",Imm(64)), Var("R31",Imm(64))),
+Def(Tid(87, "%00000057"), Attrs([Attr("address","0x7DC"),
+Attr("insn","ldp x29, x30, [sp], #0x10")]), Var("R29",Imm(64)),
+Load(Var("mem",Mem(64,8)),Var("R31",Imm(64)),LittleEndian(),64)),
+Def(Tid(92, "%0000005c"), Attrs([Attr("address","0x7DC"),
+Attr("insn","ldp x29, x30, [sp], #0x10")]), Var("R30",Imm(64)),
+Load(Var("mem",Mem(64,8)),PLUS(Var("R31",Imm(64)),Int(8,64)),LittleEndian(),64)),
+Def(Tid(96, "%00000060"), Attrs([Attr("address","0x7DC"),
+Attr("insn","ldp x29, x30, [sp], #0x10")]), Var("R31",Imm(64)),
+PLUS(Var("R31",Imm(64)),Int(16,64)))]), Jmps([Call(Tid(101, "%00000065"),
+ Attrs([Attr("address","0x7E0"), Attr("insn","ret")]), Int(1,1),
+(Indirect(Var("R30",Imm(64))),))]))])), Sub(Tid(1_796, "@_init"),
+ Attrs([Attr("address","0x5B8"), Attr("c.proto","signed (*)(void)")]),
+ "_init", Args([Arg(Tid(1_853, "%0000073d"), Attrs([Attr("c.data","Top:u32"),
+Attr("c.layout","[signed : 32]"), Attr("c.type","signed")]),
+ Var("_init_result",Imm(32)), LOW(32,Var("R0",Imm(64))), Out())]),
+Blks([Blk(Tid(1_596, "@_init"), Attrs([Attr("address","0x5B8")]), Phis([]),
+Defs([Def(Tid(1_602, "%00000642"), Attrs([Attr("address","0x5BC"),
+Attr("insn","stp x29, x30, [sp, #-0x10]!")]), Var("#6",Imm(64)),
+PLUS(Var("R31",Imm(64)),Int(18446744073709551600,64))),
+Def(Tid(1_608, "%00000648"), Attrs([Attr("address","0x5BC"),
+Attr("insn","stp x29, x30, [sp, #-0x10]!")]), Var("mem",Mem(64,8)),
+Store(Var("mem",Mem(64,8)),Var("#6",Imm(64)),Var("R29",Imm(64)),LittleEndian(),64)),
+Def(Tid(1_614, "%0000064e"), Attrs([Attr("address","0x5BC"),
+Attr("insn","stp x29, x30, [sp, #-0x10]!")]), Var("mem",Mem(64,8)),
+Store(Var("mem",Mem(64,8)),PLUS(Var("#6",Imm(64)),Int(8,64)),Var("R30",Imm(64)),LittleEndian(),64)),
+Def(Tid(1_618, "%00000652"), Attrs([Attr("address","0x5BC"),
+Attr("insn","stp x29, x30, [sp, #-0x10]!")]), Var("R31",Imm(64)),
+Var("#6",Imm(64))), Def(Tid(1_624, "%00000658"),
+ Attrs([Attr("address","0x5C0"), Attr("insn","mov x29, sp")]),
+ Var("R29",Imm(64)), Var("R31",Imm(64))), Def(Tid(1_629, "%0000065d"),
+ Attrs([Attr("address","0x5C4"), Attr("insn","bl #0xb0")]),
+ Var("R30",Imm(64)), Int(1480,64))]), Jmps([Call(Tid(1_631, "%0000065f"),
+ Attrs([Attr("address","0x5C4"), Attr("insn","bl #0xb0")]), Int(1,1),
+(Direct(Tid(1_801, "@call_weak_fn")),Direct(Tid(1_633, "%00000661"))))])),
+Blk(Tid(1_633, "%00000661"), Attrs([Attr("address","0x5C8")]), Phis([]),
+Defs([Def(Tid(1_638, "%00000666"), Attrs([Attr("address","0x5C8"),
+Attr("insn","ldp x29, x30, [sp], #0x10")]), Var("R29",Imm(64)),
+Load(Var("mem",Mem(64,8)),Var("R31",Imm(64)),LittleEndian(),64)),
+Def(Tid(1_643, "%0000066b"), Attrs([Attr("address","0x5C8"),
+Attr("insn","ldp x29, x30, [sp], #0x10")]), Var("R30",Imm(64)),
+Load(Var("mem",Mem(64,8)),PLUS(Var("R31",Imm(64)),Int(8,64)),LittleEndian(),64)),
+Def(Tid(1_647, "%0000066f"), Attrs([Attr("address","0x5C8"),
+Attr("insn","ldp x29, x30, [sp], #0x10")]), Var("R31",Imm(64)),
+PLUS(Var("R31",Imm(64)),Int(16,64)))]), Jmps([Call(Tid(1_652, "%00000674"),
+ Attrs([Attr("address","0x5CC"), Attr("insn","ret")]), Int(1,1),
+(Indirect(Var("R30",Imm(64))),))]))])), Sub(Tid(1_797, "@_start"),
+ Attrs([Attr("address","0x640"), Attr("stub","()"), Attr("entry-point","()"),
+Attr("c.proto","signed (*)(void)")]), "_start",
+ Args([Arg(Tid(1_854, "%0000073e"), Attrs([Attr("c.data","Top:u32"),
+Attr("c.layout","[signed : 32]"), Attr("c.type","signed")]),
+ Var("_start_result",Imm(32)), LOW(32,Var("R0",Imm(64))), Out())]),
+Blks([Blk(Tid(505, "@_start"), Attrs([Attr("address","0x640")]), Phis([]),
+Defs([Def(Tid(510, "%000001fe"), Attrs([Attr("address","0x644"),
+Attr("insn","mov x29, #0x0")]), Var("R29",Imm(64)), Int(0,64)),
+Def(Tid(515, "%00000203"), Attrs([Attr("address","0x648"),
+Attr("insn","mov x30, #0x0")]), Var("R30",Imm(64)), Int(0,64)),
+Def(Tid(521, "%00000209"), Attrs([Attr("address","0x64C"),
+Attr("insn","mov x5, x0")]), Var("R5",Imm(64)), Var("R0",Imm(64))),
+Def(Tid(528, "%00000210"), Attrs([Attr("address","0x650"),
+Attr("insn","ldr x1, [sp]")]), Var("R1",Imm(64)),
+Load(Var("mem",Mem(64,8)),Var("R31",Imm(64)),LittleEndian(),64)),
+Def(Tid(534, "%00000216"), Attrs([Attr("address","0x654"),
+Attr("insn","add x2, sp, #0x8")]), Var("R2",Imm(64)),
+PLUS(Var("R31",Imm(64)),Int(8,64))), Def(Tid(540, "%0000021c"),
+ Attrs([Attr("address","0x658"), Attr("insn","mov x6, sp")]),
+ Var("R6",Imm(64)), Var("R31",Imm(64))), Def(Tid(545, "%00000221"),
+ Attrs([Attr("address","0x65C"), Attr("insn","adrp x0, #126976")]),
+ Var("R0",Imm(64)), Int(126976,64)), Def(Tid(552, "%00000228"),
+ Attrs([Attr("address","0x660"), Attr("insn","ldr x0, [x0, #0xff0]")]),
+ Var("R0",Imm(64)),
+Load(Var("mem",Mem(64,8)),PLUS(Var("R0",Imm(64)),Int(4080,64)),LittleEndian(),64)),
+Def(Tid(557, "%0000022d"), Attrs([Attr("address","0x664"),
+Attr("insn","mov x3, #0x0")]), Var("R3",Imm(64)), Int(0,64)),
+Def(Tid(562, "%00000232"), Attrs([Attr("address","0x668"),
+Attr("insn","mov x4, #0x0")]), Var("R4",Imm(64)), Int(0,64)),
+Def(Tid(567, "%00000237"), Attrs([Attr("address","0x66C"),
+Attr("insn","bl #-0x7c")]), Var("R30",Imm(64)), Int(1648,64))]),
+Jmps([Call(Tid(570, "%0000023a"), Attrs([Attr("address","0x66C"),
+Attr("insn","bl #-0x7c")]), Int(1,1),
+(Direct(Tid(1_794, "@__libc_start_main")),Direct(Tid(572, "%0000023c"))))])),
+Blk(Tid(572, "%0000023c"), Attrs([Attr("address","0x670")]), Phis([]),
+Defs([Def(Tid(575, "%0000023f"), Attrs([Attr("address","0x670"),
+Attr("insn","bl #-0x40")]), Var("R30",Imm(64)), Int(1652,64))]),
+Jmps([Call(Tid(578, "%00000242"), Attrs([Attr("address","0x670"),
+Attr("insn","bl #-0x40")]), Int(1,1),
+(Direct(Tid(1_800, "@abort")),Direct(Tid(1_837, "%0000072d"))))])),
+Blk(Tid(1_837, "%0000072d"), Attrs([]), Phis([]), Defs([]),
+Jmps([Call(Tid(1_838, "%0000072e"), Attrs([]), Int(1,1),
+(Direct(Tid(1_801, "@call_weak_fn")),))]))])), Sub(Tid(1_800, "@abort"),
+ Attrs([Attr("address","0x630"), Attr("stub","()"), Attr("noreturn","()"),
+Attr("c.proto","void (*)(void)")]), "abort", Args([]),
+Blks([Blk(Tid(576, "@abort"), Attrs([Attr("address","0x630")]), Phis([]),
+Defs([Def(Tid(1_443, "%000005a3"), Attrs([Attr("address","0x630"),
+Attr("insn","adrp x16, #126976")]), Var("R16",Imm(64)), Int(126976,64)),
+Def(Tid(1_450, "%000005aa"), Attrs([Attr("address","0x634"),
+Attr("insn","ldr x17, [x16, #0xfc8]")]), Var("R17",Imm(64)),
+Load(Var("mem",Mem(64,8)),PLUS(Var("R16",Imm(64)),Int(4040,64)),LittleEndian(),64)),
+Def(Tid(1_456, "%000005b0"), Attrs([Attr("address","0x638"),
+Attr("insn","add x16, x16, #0xfc8")]), Var("R16",Imm(64)),
+PLUS(Var("R16",Imm(64)),Int(4040,64)))]), Jmps([Call(Tid(1_461, "%000005b5"),
+ Attrs([Attr("address","0x63C"), Attr("insn","br x17")]), Int(1,1),
+(Indirect(Var("R17",Imm(64))),))]))])), Sub(Tid(1_801, "@call_weak_fn"),
+ Attrs([Attr("address","0x674"), Attr("c.proto","signed (*)(void)")]),
+ "call_weak_fn", Args([Arg(Tid(1_855, "%0000073f"),
+ Attrs([Attr("c.data","Top:u32"), Attr("c.layout","[signed : 32]"),
+Attr("c.type","signed")]), Var("call_weak_fn_result",Imm(32)),
+LOW(32,Var("R0",Imm(64))), Out())]), Blks([Blk(Tid(580, "@call_weak_fn"),
+ Attrs([Attr("address","0x674")]), Phis([]), Defs([Def(Tid(583, "%00000247"),
+ Attrs([Attr("address","0x674"), Attr("insn","adrp x0, #126976")]),
+ Var("R0",Imm(64)), Int(126976,64)), Def(Tid(590, "%0000024e"),
+ Attrs([Attr("address","0x678"), Attr("insn","ldr x0, [x0, #0xfe8]")]),
+ Var("R0",Imm(64)),
+Load(Var("mem",Mem(64,8)),PLUS(Var("R0",Imm(64)),Int(4072,64)),LittleEndian(),64))]),
+Jmps([Goto(Tid(596, "%00000254"), Attrs([Attr("address","0x67C"),
+Attr("insn","cbz x0, #0x8")]), EQ(Var("R0",Imm(64)),Int(0,64)),
+Direct(Tid(594, "%00000252"))), Goto(Tid(1_839, "%0000072f"), Attrs([]),
+ Int(1,1), Direct(Tid(1_177, "%00000499")))])), Blk(Tid(594, "%00000252"),
+ Attrs([Attr("address","0x684")]), Phis([]), Defs([]),
+Jmps([Call(Tid(602, "%0000025a"), Attrs([Attr("address","0x684"),
+Attr("insn","ret")]), Int(1,1), (Indirect(Var("R30",Imm(64))),))])),
+Blk(Tid(1_177, "%00000499"), Attrs([Attr("address","0x680")]), Phis([]),
+Defs([]), Jmps([Goto(Tid(1_180, "%0000049c"), Attrs([Attr("address","0x680"),
+Attr("insn","b #-0x60")]), Int(1,1),
+Direct(Tid(1_178, "@__gmon_start__")))])), Blk(Tid(1_178, "@__gmon_start__"),
+ Attrs([Attr("address","0x620")]), Phis([]),
+Defs([Def(Tid(1_421, "%0000058d"), Attrs([Attr("address","0x620"),
+Attr("insn","adrp x16, #126976")]), Var("R16",Imm(64)), Int(126976,64)),
+Def(Tid(1_428, "%00000594"), Attrs([Attr("address","0x624"),
+Attr("insn","ldr x17, [x16, #0xfc0]")]), Var("R17",Imm(64)),
+Load(Var("mem",Mem(64,8)),PLUS(Var("R16",Imm(64)),Int(4032,64)),LittleEndian(),64)),
+Def(Tid(1_434, "%0000059a"), Attrs([Attr("address","0x628"),
+Attr("insn","add x16, x16, #0xfc0")]), Var("R16",Imm(64)),
+PLUS(Var("R16",Imm(64)),Int(4032,64)))]), Jmps([Call(Tid(1_439, "%0000059f"),
+ Attrs([Attr("address","0x62C"), Attr("insn","br x17")]), Int(1,1),
+(Indirect(Var("R17",Imm(64))),))]))])), Sub(Tid(1_803, "@callee"),
+ Attrs([Attr("address","0x754"), Attr("c.proto","signed (*)(void)")]),
+ "callee", Args([Arg(Tid(1_856, "%00000740"),
+ Attrs([Attr("c.data","Top:u32"), Attr("c.layout","[signed : 32]"),
+Attr("c.type","signed")]), Var("callee_result",Imm(32)),
+LOW(32,Var("R0",Imm(64))), Out())]), Blks([Blk(Tid(827, "@callee"),
+ Attrs([Attr("address","0x754")]), Phis([]), Defs([Def(Tid(831, "%0000033f"),
+ Attrs([Attr("address","0x754"), Attr("insn","sub sp, sp, #0x20")]),
+ Var("R31",Imm(64)), PLUS(Var("R31",Imm(64)),Int(18446744073709551584,64))),
+Def(Tid(839, "%00000347"), Attrs([Attr("address","0x758"),
+Attr("insn","str x0, [sp, #0x8]")]), Var("mem",Mem(64,8)),
+Store(Var("mem",Mem(64,8)),PLUS(Var("R31",Imm(64)),Int(8,64)),Var("R0",Imm(64)),LittleEndian(),64)),
+Def(Tid(846, "%0000034e"), Attrs([Attr("address","0x75C"),
+Attr("insn","ldr x0, [sp, #0x8]")]), Var("R0",Imm(64)),
+Load(Var("mem",Mem(64,8)),PLUS(Var("R31",Imm(64)),Int(8,64)),LittleEndian(),64)),
+Def(Tid(852, "%00000354"), Attrs([Attr("address","0x760"),
+Attr("insn","add x0, x0, #0x10")]), Var("R0",Imm(64)),
+PLUS(Var("R0",Imm(64)),Int(16,64))), Def(Tid(860, "%0000035c"),
+ Attrs([Attr("address","0x764"), Attr("insn","str x0, [sp, #0x18]")]),
+ Var("mem",Mem(64,8)),
+Store(Var("mem",Mem(64,8)),PLUS(Var("R31",Imm(64)),Int(24,64)),Var("R0",Imm(64)),LittleEndian(),64)),
+Def(Tid(867, "%00000363"), Attrs([Attr("address","0x768"),
+Attr("insn","ldr x0, [sp, #0x18]")]), Var("R0",Imm(64)),
+Load(Var("mem",Mem(64,8)),PLUS(Var("R31",Imm(64)),Int(24,64)),LittleEndian(),64)),
+Def(Tid(873, "%00000369"), Attrs([Attr("address","0x76C"),
+Attr("insn","add sp, sp, #0x20")]), Var("R31",Imm(64)),
+PLUS(Var("R31",Imm(64)),Int(32,64)))]), Jmps([Call(Tid(878, "%0000036e"),
+ Attrs([Attr("address","0x770"), Attr("insn","ret")]), Int(1,1),
+(Indirect(Var("R30",Imm(64))),))]))])),
+Sub(Tid(1_804, "@deregister_tm_clones"), Attrs([Attr("address","0x690"),
+Attr("c.proto","signed (*)(void)")]), "deregister_tm_clones",
+ Args([Arg(Tid(1_857, "%00000741"), Attrs([Attr("c.data","Top:u32"),
+Attr("c.layout","[signed : 32]"), Attr("c.type","signed")]),
+ Var("deregister_tm_clones_result",Imm(32)), LOW(32,Var("R0",Imm(64))),
+Out())]), Blks([Blk(Tid(608, "@deregister_tm_clones"),
+ Attrs([Attr("address","0x690")]), Phis([]), Defs([Def(Tid(611, "%00000263"),
+ Attrs([Attr("address","0x690"), Attr("insn","adrp x0, #131072")]),
+ Var("R0",Imm(64)), Int(131072,64)), Def(Tid(617, "%00000269"),
+ Attrs([Attr("address","0x694"), Attr("insn","add x0, x0, #0x10")]),
+ Var("R0",Imm(64)), PLUS(Var("R0",Imm(64)),Int(16,64))),
+Def(Tid(622, "%0000026e"), Attrs([Attr("address","0x698"),
+Attr("insn","adrp x1, #131072")]), Var("R1",Imm(64)), Int(131072,64)),
+Def(Tid(628, "%00000274"), Attrs([Attr("address","0x69C"),
+Attr("insn","add x1, x1, #0x10")]), Var("R1",Imm(64)),
+PLUS(Var("R1",Imm(64)),Int(16,64))), Def(Tid(634, "%0000027a"),
+ Attrs([Attr("address","0x6A0"), Attr("insn","cmp x1, x0")]),
+ Var("#1",Imm(64)), NOT(Var("R0",Imm(64)))), Def(Tid(639, "%0000027f"),
+ Attrs([Attr("address","0x6A0"), Attr("insn","cmp x1, x0")]),
+ Var("#2",Imm(64)), PLUS(Var("R1",Imm(64)),NOT(Var("R0",Imm(64))))),
+Def(Tid(645, "%00000285"), Attrs([Attr("address","0x6A0"),
+Attr("insn","cmp x1, x0")]), Var("VF",Imm(1)),
+NEQ(SIGNED(65,PLUS(Var("#2",Imm(64)),Int(1,64))),PLUS(PLUS(SIGNED(65,Var("R1",Imm(64))),SIGNED(65,Var("#1",Imm(64)))),Int(1,65)))),
+Def(Tid(651, "%0000028b"), Attrs([Attr("address","0x6A0"),
+Attr("insn","cmp x1, x0")]), Var("CF",Imm(1)),
+NEQ(UNSIGNED(65,PLUS(Var("#2",Imm(64)),Int(1,64))),PLUS(PLUS(UNSIGNED(65,Var("R1",Imm(64))),UNSIGNED(65,Var("#1",Imm(64)))),Int(1,65)))),
+Def(Tid(655, "%0000028f"), Attrs([Attr("address","0x6A0"),
+Attr("insn","cmp x1, x0")]), Var("ZF",Imm(1)),
+EQ(PLUS(Var("#2",Imm(64)),Int(1,64)),Int(0,64))), Def(Tid(659, "%00000293"),
+ Attrs([Attr("address","0x6A0"), Attr("insn","cmp x1, x0")]),
+ Var("NF",Imm(1)), Extract(63,63,PLUS(Var("#2",Imm(64)),Int(1,64))))]),
+Jmps([Goto(Tid(665, "%00000299"), Attrs([Attr("address","0x6A4"),
+Attr("insn","b.eq #0x18")]), EQ(Var("ZF",Imm(1)),Int(1,1)),
+Direct(Tid(663, "%00000297"))), Goto(Tid(1_840, "%00000730"), Attrs([]),
+ Int(1,1), Direct(Tid(1_147, "%0000047b")))])), Blk(Tid(1_147, "%0000047b"),
+ Attrs([Attr("address","0x6A8")]), Phis([]),
+Defs([Def(Tid(1_150, "%0000047e"), Attrs([Attr("address","0x6A8"),
+Attr("insn","adrp x1, #126976")]), Var("R1",Imm(64)), Int(126976,64)),
+Def(Tid(1_157, "%00000485"), Attrs([Attr("address","0x6AC"),
+Attr("insn","ldr x1, [x1, #0xfd8]")]), Var("R1",Imm(64)),
+Load(Var("mem",Mem(64,8)),PLUS(Var("R1",Imm(64)),Int(4056,64)),LittleEndian(),64))]),
+Jmps([Goto(Tid(1_162, "%0000048a"), Attrs([Attr("address","0x6B0"),
+Attr("insn","cbz x1, #0xc")]), EQ(Var("R1",Imm(64)),Int(0,64)),
+Direct(Tid(663, "%00000297"))), Goto(Tid(1_841, "%00000731"), Attrs([]),
+ Int(1,1), Direct(Tid(1_166, "%0000048e")))])), Blk(Tid(663, "%00000297"),
+ Attrs([Attr("address","0x6BC")]), Phis([]), Defs([]),
+Jmps([Call(Tid(671, "%0000029f"), Attrs([Attr("address","0x6BC"),
+Attr("insn","ret")]), Int(1,1), (Indirect(Var("R30",Imm(64))),))])),
+Blk(Tid(1_166, "%0000048e"), Attrs([Attr("address","0x6B4")]), Phis([]),
+Defs([Def(Tid(1_170, "%00000492"), Attrs([Attr("address","0x6B4"),
+Attr("insn","mov x16, x1")]), Var("R16",Imm(64)), Var("R1",Imm(64)))]),
+Jmps([Call(Tid(1_175, "%00000497"), Attrs([Attr("address","0x6B8"),
+Attr("insn","br x16")]), Int(1,1), (Indirect(Var("R16",Imm(64))),))]))])),
+Sub(Tid(1_807, "@frame_dummy"), Attrs([Attr("address","0x750"),
+Attr("c.proto","signed (*)(void)")]), "frame_dummy",
+ Args([Arg(Tid(1_858, "%00000742"), Attrs([Attr("c.data","Top:u32"),
+Attr("c.layout","[signed : 32]"), Attr("c.type","signed")]),
+ Var("frame_dummy_result",Imm(32)), LOW(32,Var("R0",Imm(64))), Out())]),
+Blks([Blk(Tid(823, "@frame_dummy"), Attrs([Attr("address","0x750")]),
+ Phis([]), Defs([]), Jmps([Call(Tid(825, "%00000339"),
+ Attrs([Attr("address","0x750"), Attr("insn","b #-0x90")]), Int(1,1),
+(Direct(Tid(1_810, "@register_tm_clones")),))]))])), Sub(Tid(1_808, "@main"),
+ Attrs([Attr("address","0x774"),
+Attr("c.proto","signed (*)(signed argc,  const char** argv)")]), "main",
+ Args([Arg(Tid(1_859, "%00000743"), Attrs([Attr("c.data","Top:u32"),
+Attr("c.layout","[signed : 32]"), Attr("c.type","signed")]),
+ Var("main_argc",Imm(32)), LOW(32,Var("R0",Imm(64))), In()),
+Arg(Tid(1_860, "%00000744"), Attrs([Attr("c.data","Top:u8 ptr ptr"),
+Attr("c.layout","**[char : 8]"), Attr("c.type"," const char**")]),
+ Var("main_argv",Imm(64)), Var("R1",Imm(64)), Both()),
+Arg(Tid(1_861, "%00000745"), Attrs([Attr("c.data","Top:u32"),
+Attr("c.layout","[signed : 32]"), Attr("c.type","signed")]),
+ Var("main_result",Imm(32)), LOW(32,Var("R0",Imm(64))), Out())]),
+Blks([Blk(Tid(880, "@main"), Attrs([Attr("address","0x774")]), Phis([]),
+Defs([Def(Tid(884, "%00000374"), Attrs([Attr("address","0x774"),
+Attr("insn","stp x29, x30, [sp, #-0x30]!")]), Var("#4",Imm(64)),
+PLUS(Var("R31",Imm(64)),Int(18446744073709551568,64))),
+Def(Tid(890, "%0000037a"), Attrs([Attr("address","0x774"),
+Attr("insn","stp x29, x30, [sp, #-0x30]!")]), Var("mem",Mem(64,8)),
+Store(Var("mem",Mem(64,8)),Var("#4",Imm(64)),Var("R29",Imm(64)),LittleEndian(),64)),
+Def(Tid(896, "%00000380"), Attrs([Attr("address","0x774"),
+Attr("insn","stp x29, x30, [sp, #-0x30]!")]), Var("mem",Mem(64,8)),
+Store(Var("mem",Mem(64,8)),PLUS(Var("#4",Imm(64)),Int(8,64)),Var("R30",Imm(64)),LittleEndian(),64)),
+Def(Tid(900, "%00000384"), Attrs([Attr("address","0x774"),
+Attr("insn","stp x29, x30, [sp, #-0x30]!")]), Var("R31",Imm(64)),
+Var("#4",Imm(64))), Def(Tid(906, "%0000038a"),
+ Attrs([Attr("address","0x778"), Attr("insn","mov x29, sp")]),
+ Var("R29",Imm(64)), Var("R31",Imm(64))), Def(Tid(911, "%0000038f"),
+ Attrs([Attr("address","0x77C"), Attr("insn","mov x0, #0x14")]),
+ Var("R0",Imm(64)), Int(20,64)), Def(Tid(916, "%00000394"),
+ Attrs([Attr("address","0x780"), Attr("insn","bl #-0x170")]),
+ Var("R30",Imm(64)), Int(1924,64))]), Jmps([Call(Tid(919, "%00000397"),
+ Attrs([Attr("address","0x780"), Attr("insn","bl #-0x170")]), Int(1,1),
+(Direct(Tid(1_809, "@malloc")),Direct(Tid(921, "%00000399"))))])),
+Blk(Tid(921, "%00000399"), Attrs([Attr("address","0x784")]), Phis([]),
+Defs([Def(Tid(927, "%0000039f"), Attrs([Attr("address","0x784"),
+Attr("insn","str x0, [sp, #0x18]")]), Var("mem",Mem(64,8)),
+Store(Var("mem",Mem(64,8)),PLUS(Var("R31",Imm(64)),Int(24,64)),Var("R0",Imm(64)),LittleEndian(),64)),
+Def(Tid(934, "%000003a6"), Attrs([Attr("address","0x788"),
+Attr("insn","ldr x0, [sp, #0x18]")]), Var("R0",Imm(64)),
+Load(Var("mem",Mem(64,8)),PLUS(Var("R31",Imm(64)),Int(24,64)),LittleEndian(),64)),
+Def(Tid(939, "%000003ab"), Attrs([Attr("address","0x78C"),
+Attr("insn","mov w1, #0xc")]), Var("R1",Imm(64)), Int(12,64)),
+Def(Tid(947, "%000003b3"), Attrs([Attr("address","0x790"),
+Attr("insn","str w1, [x0]")]), Var("mem",Mem(64,8)),
+Store(Var("mem",Mem(64,8)),Var("R0",Imm(64)),Extract(31,0,Var("R1",Imm(64))),LittleEndian(),32)),
+Def(Tid(954, "%000003ba"), Attrs([Attr("address","0x794"),
+Attr("insn","ldr x0, [sp, #0x18]")]), Var("R0",Imm(64)),
+Load(Var("mem",Mem(64,8)),PLUS(Var("R31",Imm(64)),Int(24,64)),LittleEndian(),64)),
+Def(Tid(960, "%000003c0"), Attrs([Attr("address","0x798"),
+Attr("insn","add x0, x0, #0x10")]), Var("R0",Imm(64)),
+PLUS(Var("R0",Imm(64)),Int(16,64))), Def(Tid(968, "%000003c8"),
+ Attrs([Attr("address","0x79C"), Attr("insn","str x0, [sp, #0x20]")]),
+ Var("mem",Mem(64,8)),
+Store(Var("mem",Mem(64,8)),PLUS(Var("R31",Imm(64)),Int(32,64)),Var("R0",Imm(64)),LittleEndian(),64)),
+Def(Tid(975, "%000003cf"), Attrs([Attr("address","0x7A0"),
+Attr("insn","ldr x0, [sp, #0x20]")]), Var("R0",Imm(64)),
+Load(Var("mem",Mem(64,8)),PLUS(Var("R31",Imm(64)),Int(32,64)),LittleEndian(),64)),
+Def(Tid(980, "%000003d4"), Attrs([Attr("address","0x7A4"),
+Attr("insn","mov w1, #0xd")]), Var("R1",Imm(64)), Int(13,64)),
+Def(Tid(988, "%000003dc"), Attrs([Attr("address","0x7A8"),
+Attr("insn","str w1, [x0]")]), Var("mem",Mem(64,8)),
+Store(Var("mem",Mem(64,8)),Var("R0",Imm(64)),Extract(31,0,Var("R1",Imm(64))),LittleEndian(),32)),
+Def(Tid(995, "%000003e3"), Attrs([Attr("address","0x7AC"),
+Attr("insn","ldr x0, [sp, #0x20]")]), Var("R0",Imm(64)),
+Load(Var("mem",Mem(64,8)),PLUS(Var("R31",Imm(64)),Int(32,64)),LittleEndian(),64)),
+Def(Tid(1_000, "%000003e8"), Attrs([Attr("address","0x7B0"),
+Attr("insn","bl #-0x5c")]), Var("R30",Imm(64)), Int(1972,64))]),
+Jmps([Call(Tid(1_002, "%000003ea"), Attrs([Attr("address","0x7B0"),
+Attr("insn","bl #-0x5c")]), Int(1,1),
+(Direct(Tid(1_803, "@callee")),Direct(Tid(1_004, "%000003ec"))))])),
+Blk(Tid(1_004, "%000003ec"), Attrs([Attr("address","0x7B4")]), Phis([]),
+Defs([Def(Tid(1_010, "%000003f2"), Attrs([Attr("address","0x7B4"),
+Attr("insn","str x0, [sp, #0x28]")]), Var("mem",Mem(64,8)),
+Store(Var("mem",Mem(64,8)),PLUS(Var("R31",Imm(64)),Int(40,64)),Var("R0",Imm(64)),LittleEndian(),64)),
+Def(Tid(1_017, "%000003f9"), Attrs([Attr("address","0x7B8"),
+Attr("insn","ldr x0, [sp, #0x28]")]), Var("R0",Imm(64)),
+Load(Var("mem",Mem(64,8)),PLUS(Var("R31",Imm(64)),Int(40,64)),LittleEndian(),64)),
+Def(Tid(1_022, "%000003fe"), Attrs([Attr("address","0x7BC"),
+Attr("insn","mov w1, #0xe")]), Var("R1",Imm(64)), Int(14,64)),
+Def(Tid(1_030, "%00000406"), Attrs([Attr("address","0x7C0"),
+Attr("insn","str w1, [x0]")]), Var("mem",Mem(64,8)),
+Store(Var("mem",Mem(64,8)),Var("R0",Imm(64)),Extract(31,0,Var("R1",Imm(64))),LittleEndian(),32)),
+Def(Tid(1_035, "%0000040b"), Attrs([Attr("address","0x7C4"),
+Attr("insn","mov w0, #0x0")]), Var("R0",Imm(64)), Int(0,64)),
+Def(Tid(1_042, "%00000412"), Attrs([Attr("address","0x7C8"),
+Attr("insn","ldp x29, x30, [sp], #0x30")]), Var("R29",Imm(64)),
+Load(Var("mem",Mem(64,8)),Var("R31",Imm(64)),LittleEndian(),64)),
+Def(Tid(1_047, "%00000417"), Attrs([Attr("address","0x7C8"),
+Attr("insn","ldp x29, x30, [sp], #0x30")]), Var("R30",Imm(64)),
+Load(Var("mem",Mem(64,8)),PLUS(Var("R31",Imm(64)),Int(8,64)),LittleEndian(),64)),
+Def(Tid(1_051, "%0000041b"), Attrs([Attr("address","0x7C8"),
+Attr("insn","ldp x29, x30, [sp], #0x30")]), Var("R31",Imm(64)),
+PLUS(Var("R31",Imm(64)),Int(48,64)))]), Jmps([Call(Tid(1_056, "%00000420"),
+ Attrs([Attr("address","0x7CC"), Attr("insn","ret")]), Int(1,1),
+(Indirect(Var("R30",Imm(64))),))]))])), Sub(Tid(1_809, "@malloc"),
+ Attrs([Attr("address","0x610"), Attr("stub","()"), Attr("malloc","()"),
+Attr("c.proto","void* (*)(unsigned long size)")]), "malloc",
+ Args([Arg(Tid(1_862, "%00000746"), Attrs([Attr("alloc-size","()"),
+Attr("c.data","Top:u64"), Attr("c.layout","[unsigned long : 64]"),
+Attr("c.type","unsigned long")]), Var("malloc_size",Imm(64)),
+Var("R0",Imm(64)), In()), Arg(Tid(1_863, "%00000747"),
+ Attrs([Attr("warn-unused","()"), Attr("c.data","{} ptr"),
+Attr("c.layout","*[<undef> : 8]"), Attr("c.type","void*")]),
+ Var("malloc_result",Imm(64)), Var("R0",Imm(64)), Out())]),
+Blks([Blk(Tid(917, "@malloc"), Attrs([Attr("address","0x610")]), Phis([]),
+Defs([Def(Tid(1_399, "%00000577"), Attrs([Attr("address","0x610"),
+Attr("insn","adrp x16, #126976")]), Var("R16",Imm(64)), Int(126976,64)),
+Def(Tid(1_406, "%0000057e"), Attrs([Attr("address","0x614"),
+Attr("insn","ldr x17, [x16, #0xfb8]")]), Var("R17",Imm(64)),
+Load(Var("mem",Mem(64,8)),PLUS(Var("R16",Imm(64)),Int(4024,64)),LittleEndian(),64)),
+Def(Tid(1_412, "%00000584"), Attrs([Attr("address","0x618"),
+Attr("insn","add x16, x16, #0xfb8")]), Var("R16",Imm(64)),
+PLUS(Var("R16",Imm(64)),Int(4024,64)))]), Jmps([Call(Tid(1_417, "%00000589"),
+ Attrs([Attr("address","0x61C"), Attr("insn","br x17")]), Int(1,1),
+(Indirect(Var("R17",Imm(64))),))]))])),
+Sub(Tid(1_810, "@register_tm_clones"), Attrs([Attr("address","0x6C0"),
+Attr("c.proto","signed (*)(void)")]), "register_tm_clones",
+ Args([Arg(Tid(1_864, "%00000748"), Attrs([Attr("c.data","Top:u32"),
+Attr("c.layout","[signed : 32]"), Attr("c.type","signed")]),
+ Var("register_tm_clones_result",Imm(32)), LOW(32,Var("R0",Imm(64))),
+Out())]), Blks([Blk(Tid(673, "@register_tm_clones"),
+ Attrs([Attr("address","0x6C0")]), Phis([]), Defs([Def(Tid(676, "%000002a4"),
+ Attrs([Attr("address","0x6C0"), Attr("insn","adrp x0, #131072")]),
+ Var("R0",Imm(64)), Int(131072,64)), Def(Tid(682, "%000002aa"),
+ Attrs([Attr("address","0x6C4"), Attr("insn","add x0, x0, #0x10")]),
+ Var("R0",Imm(64)), PLUS(Var("R0",Imm(64)),Int(16,64))),
+Def(Tid(687, "%000002af"), Attrs([Attr("address","0x6C8"),
+Attr("insn","adrp x1, #131072")]), Var("R1",Imm(64)), Int(131072,64)),
+Def(Tid(693, "%000002b5"), Attrs([Attr("address","0x6CC"),
+Attr("insn","add x1, x1, #0x10")]), Var("R1",Imm(64)),
+PLUS(Var("R1",Imm(64)),Int(16,64))), Def(Tid(700, "%000002bc"),
+ Attrs([Attr("address","0x6D0"), Attr("insn","sub x1, x1, x0")]),
+ Var("R1",Imm(64)),
+PLUS(PLUS(Var("R1",Imm(64)),NOT(Var("R0",Imm(64)))),Int(1,64))),
+Def(Tid(706, "%000002c2"), Attrs([Attr("address","0x6D4"),
+Attr("insn","lsr x2, x1, #63")]), Var("R2",Imm(64)),
+Concat(Int(0,63),Extract(63,63,Var("R1",Imm(64))))),
+Def(Tid(713, "%000002c9"), Attrs([Attr("address","0x6D8"),
+Attr("insn","add x1, x2, x1, asr #3")]), Var("R1",Imm(64)),
+PLUS(Var("R2",Imm(64)),ARSHIFT(Var("R1",Imm(64)),Int(3,3)))),
+Def(Tid(719, "%000002cf"), Attrs([Attr("address","0x6DC"),
+Attr("insn","asr x1, x1, #1")]), Var("R1",Imm(64)),
+SIGNED(64,Extract(63,1,Var("R1",Imm(64)))))]),
+Jmps([Goto(Tid(725, "%000002d5"), Attrs([Attr("address","0x6E0"),
+Attr("insn","cbz x1, #0x18")]), EQ(Var("R1",Imm(64)),Int(0,64)),
+Direct(Tid(723, "%000002d3"))), Goto(Tid(1_842, "%00000732"), Attrs([]),
+ Int(1,1), Direct(Tid(1_117, "%0000045d")))])), Blk(Tid(1_117, "%0000045d"),
+ Attrs([Attr("address","0x6E4")]), Phis([]),
+Defs([Def(Tid(1_120, "%00000460"), Attrs([Attr("address","0x6E4"),
+Attr("insn","adrp x2, #126976")]), Var("R2",Imm(64)), Int(126976,64)),
+Def(Tid(1_127, "%00000467"), Attrs([Attr("address","0x6E8"),
+Attr("insn","ldr x2, [x2, #0xff8]")]), Var("R2",Imm(64)),
+Load(Var("mem",Mem(64,8)),PLUS(Var("R2",Imm(64)),Int(4088,64)),LittleEndian(),64))]),
+Jmps([Goto(Tid(1_132, "%0000046c"), Attrs([Attr("address","0x6EC"),
+Attr("insn","cbz x2, #0xc")]), EQ(Var("R2",Imm(64)),Int(0,64)),
+Direct(Tid(723, "%000002d3"))), Goto(Tid(1_843, "%00000733"), Attrs([]),
+ Int(1,1), Direct(Tid(1_136, "%00000470")))])), Blk(Tid(723, "%000002d3"),
+ Attrs([Attr("address","0x6F8")]), Phis([]), Defs([]),
+Jmps([Call(Tid(731, "%000002db"), Attrs([Attr("address","0x6F8"),
+Attr("insn","ret")]), Int(1,1), (Indirect(Var("R30",Imm(64))),))])),
+Blk(Tid(1_136, "%00000470"), Attrs([Attr("address","0x6F0")]), Phis([]),
+Defs([Def(Tid(1_140, "%00000474"), Attrs([Attr("address","0x6F0"),
+Attr("insn","mov x16, x2")]), Var("R16",Imm(64)), Var("R2",Imm(64)))]),
+Jmps([Call(Tid(1_145, "%00000479"), Attrs([Attr("address","0x6F4"),
+Attr("insn","br x16")]), Int(1,1),
+(Indirect(Var("R16",Imm(64))),))]))]))])))
\ No newline at end of file
diff --git a/src/test/dsa/interproc_pointer_arithmetic/interproc_pointer_arithmetic.bir b/src/test/dsa/interproc_pointer_arithmetic/interproc_pointer_arithmetic.bir
new file mode 100755
index 000000000..4329d89ad
--- /dev/null
+++ b/src/test/dsa/interproc_pointer_arithmetic/interproc_pointer_arithmetic.bir
@@ -0,0 +1,279 @@
+00000715: program
+000006fd: sub __cxa_finalize(__cxa_finalize_result)
+00000716: __cxa_finalize_result :: out u32 = low:32[R0]
+
+00000459:
+00000561: R16 := 0x1F000
+00000568: R17 := mem[R16 + 0xFB0, el]:u64
+0000056e: R16 := R16 + 0xFB0
+00000573: call R17 with noreturn
+
+000006fe: sub __do_global_dtors_aux(__do_global_dtors_aux_result)
+00000717: __do_global_dtors_aux_result :: out u32 = low:32[R0]
+
+000002df:
+000002e3: #3 := R31 - 0x20
+000002e9: mem := mem with [#3, el]:u64 <- R29
+000002ef: mem := mem with [#3 + 8, el]:u64 <- R30
+000002f3: R31 := #3
+000002f9: R29 := R31
+00000301: mem := mem with [R31 + 0x10, el]:u64 <- R19
+00000306: R19 := 0x20000
+0000030d: R0 := pad:64[mem[R19 + 0x10]]
+00000314: when 31:0[R0] <> 0 goto %00000312
+000006ff: goto %00000422
+
+00000422:
+00000425: R0 := 0x1F000
+0000042c: R0 := mem[R0 + 0xFE0, el]:u64
+00000432: when R0 = 0 goto %00000430
+00000700: goto %00000449
+
+00000449:
+0000044c: R0 := 0x20000
+00000453: R0 := mem[R0 + 8, el]:u64
+00000458: R30 := 0x730
+0000045b: call @__cxa_finalize with return %00000430
+
+00000430:
+00000438: R30 := 0x734
+0000043a: call @deregister_tm_clones with return %0000043c
+
+0000043c:
+0000043f: R0 := 1
+00000447: mem := mem with [R19 + 0x10] <- 7:0[R0]
+00000701: goto %00000312
+
+00000312:
+0000031c: R19 := mem[R31 + 0x10, el]:u64
+00000323: R29 := mem[R31, el]:u64
+00000328: R30 := mem[R31 + 8, el]:u64
+0000032c: R31 := R31 + 0x20
+00000331: call R30 with noreturn
+
+00000702: sub __libc_start_main(__libc_start_main_main, __libc_start_main_arg2, __libc_start_main_arg3, __libc_start_main_auxv, __libc_start_main_result)
+00000718: __libc_start_main_main :: in u64 = R0
+00000719: __libc_start_main_arg2 :: in u32 = low:32[R1]
+0000071a: __libc_start_main_arg3 :: in out u64 = R2
+0000071b: __libc_start_main_auxv :: in out u64 = R3
+0000071c: __libc_start_main_result :: out u32 = low:32[R0]
+
+00000238:
+0000054b: R16 := 0x1F000
+00000552: R17 := mem[R16 + 0xFA8, el]:u64
+00000558: R16 := R16 + 0xFA8
+0000055d: call R17 with noreturn
+
+00000703: sub _fini(_fini_result)
+0000071d: _fini_result :: out u32 = low:32[R0]
+
+00000034:
+0000003a: #0 := R31 - 0x10
+00000040: mem := mem with [#0, el]:u64 <- R29
+00000046: mem := mem with [#0 + 8, el]:u64 <- R30
+0000004a: R31 := #0
+00000050: R29 := R31
+00000057: R29 := mem[R31, el]:u64
+0000005c: R30 := mem[R31 + 8, el]:u64
+00000060: R31 := R31 + 0x10
+00000065: call R30 with noreturn
+
+00000704: sub _init(_init_result)
+0000071e: _init_result :: out u32 = low:32[R0]
+
+0000063c:
+00000642: #6 := R31 - 0x10
+00000648: mem := mem with [#6, el]:u64 <- R29
+0000064e: mem := mem with [#6 + 8, el]:u64 <- R30
+00000652: R31 := #6
+00000658: R29 := R31
+0000065d: R30 := 0x5C8
+0000065f: call @call_weak_fn with return %00000661
+
+00000661:
+00000666: R29 := mem[R31, el]:u64
+0000066b: R30 := mem[R31 + 8, el]:u64
+0000066f: R31 := R31 + 0x10
+00000674: call R30 with noreturn
+
+00000705: sub _start(_start_result)
+0000071f: _start_result :: out u32 = low:32[R0]
+
+000001f9:
+000001fe: R29 := 0
+00000203: R30 := 0
+00000209: R5 := R0
+00000210: R1 := mem[R31, el]:u64
+00000216: R2 := R31 + 8
+0000021c: R6 := R31
+00000221: R0 := 0x1F000
+00000228: R0 := mem[R0 + 0xFF0, el]:u64
+0000022d: R3 := 0
+00000232: R4 := 0
+00000237: R30 := 0x670
+0000023a: call @__libc_start_main with return %0000023c
+
+0000023c:
+0000023f: R30 := 0x674
+00000242: call @abort with return %00000706
+
+00000706:
+00000707: call @call_weak_fn with noreturn
+
+00000708: sub abort()
+
+
+00000240:
+000005a3: R16 := 0x1F000
+000005aa: R17 := mem[R16 + 0xFC8, el]:u64
+000005b0: R16 := R16 + 0xFC8
+000005b5: call R17 with noreturn
+
+00000709: sub call_weak_fn(call_weak_fn_result)
+00000720: call_weak_fn_result :: out u32 = low:32[R0]
+
+00000244:
+00000247: R0 := 0x1F000
+0000024e: R0 := mem[R0 + 0xFE8, el]:u64
+00000254: when R0 = 0 goto %00000252
+0000070a: goto %00000499
+
+00000252:
+0000025a: call R30 with noreturn
+
+00000499:
+0000049c: goto @__gmon_start__
+
+0000049a:
+0000058d: R16 := 0x1F000
+00000594: R17 := mem[R16 + 0xFC0, el]:u64
+0000059a: R16 := R16 + 0xFC0
+0000059f: call R17 with noreturn
+
+0000070b: sub callee(callee_result)
+00000721: callee_result :: out u32 = low:32[R0]
+
+0000033b:
+0000033f: R31 := R31 - 0x20
+00000347: mem := mem with [R31 + 8, el]:u64 <- R0
+0000034e: R0 := mem[R31 + 8, el]:u64
+00000354: R0 := R0 + 0x10
+0000035c: mem := mem with [R31 + 0x18, el]:u64 <- R0
+00000363: R0 := mem[R31 + 0x18, el]:u64
+00000369: R31 := R31 + 0x20
+0000036e: call R30 with noreturn
+
+0000070c: sub deregister_tm_clones(deregister_tm_clones_result)
+00000722: deregister_tm_clones_result :: out u32 = low:32[R0]
+
+00000260:
+00000263: R0 := 0x20000
+00000269: R0 := R0 + 0x10
+0000026e: R1 := 0x20000
+00000274: R1 := R1 + 0x10
+0000027a: #1 := ~R0
+0000027f: #2 := R1 + ~R0
+00000285: VF := extend:65[#2 + 1] <> extend:65[R1] + extend:65[#1] + 1
+0000028b: CF := pad:65[#2 + 1] <> pad:65[R1] + pad:65[#1] + 1
+0000028f: ZF := #2 + 1 = 0
+00000293: NF := 63:63[#2 + 1]
+00000299: when ZF goto %00000297
+0000070d: goto %0000047b
+
+0000047b:
+0000047e: R1 := 0x1F000
+00000485: R1 := mem[R1 + 0xFD8, el]:u64
+0000048a: when R1 = 0 goto %00000297
+0000070e: goto %0000048e
+
+00000297:
+0000029f: call R30 with noreturn
+
+0000048e:
+00000492: R16 := R1
+00000497: call R16 with noreturn
+
+0000070f: sub frame_dummy(frame_dummy_result)
+00000723: frame_dummy_result :: out u32 = low:32[R0]
+
+00000337:
+00000339: call @register_tm_clones with noreturn
+
+00000710: sub main(main_argc, main_argv, main_result)
+00000724: main_argc :: in u32 = low:32[R0]
+00000725: main_argv :: in out u64 = R1
+00000726: main_result :: out u32 = low:32[R0]
+
+00000370:
+00000374: #4 := R31 - 0x30
+0000037a: mem := mem with [#4, el]:u64 <- R29
+00000380: mem := mem with [#4 + 8, el]:u64 <- R30
+00000384: R31 := #4
+0000038a: R29 := R31
+0000038f: R0 := 0x14
+00000394: R30 := 0x784
+00000397: call @malloc with return %00000399
+
+00000399:
+0000039f: mem := mem with [R31 + 0x18, el]:u64 <- R0
+000003a6: R0 := mem[R31 + 0x18, el]:u64
+000003ab: R1 := 0xC
+000003b3: mem := mem with [R0, el]:u32 <- 31:0[R1]
+000003ba: R0 := mem[R31 + 0x18, el]:u64
+000003c0: R0 := R0 + 0x10
+000003c8: mem := mem with [R31 + 0x20, el]:u64 <- R0
+000003cf: R0 := mem[R31 + 0x20, el]:u64
+000003d4: R1 := 0xD
+000003dc: mem := mem with [R0, el]:u32 <- 31:0[R1]
+000003e3: R0 := mem[R31 + 0x20, el]:u64
+000003e8: R30 := 0x7B4
+000003ea: call @callee with return %000003ec
+
+000003ec:
+000003f2: mem := mem with [R31 + 0x28, el]:u64 <- R0
+000003f9: R0 := mem[R31 + 0x28, el]:u64
+000003fe: R1 := 0xE
+00000406: mem := mem with [R0, el]:u32 <- 31:0[R1]
+0000040b: R0 := 0
+00000412: R29 := mem[R31, el]:u64
+00000417: R30 := mem[R31 + 8, el]:u64
+0000041b: R31 := R31 + 0x30
+00000420: call R30 with noreturn
+
+00000711: sub malloc(malloc_size, malloc_result)
+00000727: malloc_size :: in u64 = R0
+00000728: malloc_result :: out u64 = R0
+
+00000395:
+00000577: R16 := 0x1F000
+0000057e: R17 := mem[R16 + 0xFB8, el]:u64
+00000584: R16 := R16 + 0xFB8
+00000589: call R17 with noreturn
+
+00000712: sub register_tm_clones(register_tm_clones_result)
+00000729: register_tm_clones_result :: out u32 = low:32[R0]
+
+000002a1:
+000002a4: R0 := 0x20000
+000002aa: R0 := R0 + 0x10
+000002af: R1 := 0x20000
+000002b5: R1 := R1 + 0x10
+000002bc: R1 := R1 + ~R0 + 1
+000002c2: R2 := 0.63:63[R1]
+000002c9: R1 := R2 + (R1 ~>> 3)
+000002cf: R1 := extend:64[63:1[R1]]
+000002d5: when R1 = 0 goto %000002d3
+00000713: goto %0000045d
+
+0000045d:
+00000460: R2 := 0x1F000
+00000467: R2 := mem[R2 + 0xFF8, el]:u64
+0000046c: when R2 = 0 goto %000002d3
+00000714: goto %00000470
+
+000002d3:
+000002db: call R30 with noreturn
+
+00000470:
+00000474: R16 := R2
+00000479: call R16 with noreturn
diff --git a/src/test/dsa/interproc_pointer_arithmetic/interproc_pointer_arithmetic.c b/src/test/dsa/interproc_pointer_arithmetic/interproc_pointer_arithmetic.c
new file mode 100644
index 000000000..1d02bae06
--- /dev/null
+++ b/src/test/dsa/interproc_pointer_arithmetic/interproc_pointer_arithmetic.c
@@ -0,0 +1,14 @@
+#include <stdlib.h>
+int* callee(int* arg) {
+    int* ret = arg + sizeof(int); // this is wrong
+    return ret;
+}
+
+int main() {
+    int *bar = malloc(5 * sizeof(int));
+    *bar = 12;
+    int* foo = bar + sizeof(int);
+    *foo = 13;
+    int* bat = callee(foo);
+    *bat = 14;
+}
diff --git a/src/test/dsa/interproc_pointer_arithmetic/interproc_pointer_arithmetic.relf b/src/test/dsa/interproc_pointer_arithmetic/interproc_pointer_arithmetic.relf
new file mode 100755
index 000000000..3fb1fea4c
--- /dev/null
+++ b/src/test/dsa/interproc_pointer_arithmetic/interproc_pointer_arithmetic.relf
@@ -0,0 +1,123 @@
+
+Relocation section '.rela.dyn' at offset 0x480 contains 8 entries:
+    Offset             Info             Type               Symbol's Value  Symbol's Name + Addend
+000000000001fd90  0000000000000403 R_AARCH64_RELATIVE                        750
+000000000001fd98  0000000000000403 R_AARCH64_RELATIVE                        700
+000000000001fff0  0000000000000403 R_AARCH64_RELATIVE                        774
+0000000000020008  0000000000000403 R_AARCH64_RELATIVE                        20008
+000000000001ffd8  0000000400000401 R_AARCH64_GLOB_DAT     0000000000000000 _ITM_deregisterTMCloneTable + 0
+000000000001ffe0  0000000500000401 R_AARCH64_GLOB_DAT     0000000000000000 __cxa_finalize@GLIBC_2.17 + 0
+000000000001ffe8  0000000700000401 R_AARCH64_GLOB_DAT     0000000000000000 __gmon_start__ + 0
+000000000001fff8  0000000900000401 R_AARCH64_GLOB_DAT     0000000000000000 _ITM_registerTMCloneTable + 0
+
+Relocation section '.rela.plt' at offset 0x540 contains 5 entries:
+    Offset             Info             Type               Symbol's Value  Symbol's Name + Addend
+000000000001ffa8  0000000300000402 R_AARCH64_JUMP_SLOT    0000000000000000 __libc_start_main@GLIBC_2.34 + 0
+000000000001ffb0  0000000500000402 R_AARCH64_JUMP_SLOT    0000000000000000 __cxa_finalize@GLIBC_2.17 + 0
+000000000001ffb8  0000000600000402 R_AARCH64_JUMP_SLOT    0000000000000000 malloc@GLIBC_2.17 + 0
+000000000001ffc0  0000000700000402 R_AARCH64_JUMP_SLOT    0000000000000000 __gmon_start__ + 0
+000000000001ffc8  0000000800000402 R_AARCH64_JUMP_SLOT    0000000000000000 abort@GLIBC_2.17 + 0
+
+Symbol table '.dynsym' contains 10 entries:
+   Num:    Value          Size Type    Bind   Vis      Ndx Name
+     0: 0000000000000000     0 NOTYPE  LOCAL  DEFAULT  UND 
+     1: 00000000000005b8     0 SECTION LOCAL  DEFAULT   11 .init
+     2: 0000000000020000     0 SECTION LOCAL  DEFAULT   22 .data
+     3: 0000000000000000     0 FUNC    GLOBAL DEFAULT  UND __libc_start_main@GLIBC_2.34 (2)
+     4: 0000000000000000     0 NOTYPE  WEAK   DEFAULT  UND _ITM_deregisterTMCloneTable
+     5: 0000000000000000     0 FUNC    WEAK   DEFAULT  UND __cxa_finalize@GLIBC_2.17 (3)
+     6: 0000000000000000     0 FUNC    GLOBAL DEFAULT  UND malloc@GLIBC_2.17 (3)
+     7: 0000000000000000     0 NOTYPE  WEAK   DEFAULT  UND __gmon_start__
+     8: 0000000000000000     0 FUNC    GLOBAL DEFAULT  UND abort@GLIBC_2.17 (3)
+     9: 0000000000000000     0 NOTYPE  WEAK   DEFAULT  UND _ITM_registerTMCloneTable
+
+Symbol table '.symtab' contains 88 entries:
+   Num:    Value          Size Type    Bind   Vis      Ndx Name
+     0: 0000000000000000     0 NOTYPE  LOCAL  DEFAULT  UND 
+     1: 0000000000000238     0 SECTION LOCAL  DEFAULT    1 .interp
+     2: 0000000000000254     0 SECTION LOCAL  DEFAULT    2 .note.gnu.build-id
+     3: 0000000000000278     0 SECTION LOCAL  DEFAULT    3 .note.ABI-tag
+     4: 0000000000000298     0 SECTION LOCAL  DEFAULT    4 .gnu.hash
+     5: 00000000000002b8     0 SECTION LOCAL  DEFAULT    5 .dynsym
+     6: 00000000000003a8     0 SECTION LOCAL  DEFAULT    6 .dynstr
+     7: 000000000000043c     0 SECTION LOCAL  DEFAULT    7 .gnu.version
+     8: 0000000000000450     0 SECTION LOCAL  DEFAULT    8 .gnu.version_r
+     9: 0000000000000480     0 SECTION LOCAL  DEFAULT    9 .rela.dyn
+    10: 0000000000000540     0 SECTION LOCAL  DEFAULT   10 .rela.plt
+    11: 00000000000005b8     0 SECTION LOCAL  DEFAULT   11 .init
+    12: 00000000000005d0     0 SECTION LOCAL  DEFAULT   12 .plt
+    13: 0000000000000640     0 SECTION LOCAL  DEFAULT   13 .text
+    14: 00000000000007d0     0 SECTION LOCAL  DEFAULT   14 .fini
+    15: 00000000000007e4     0 SECTION LOCAL  DEFAULT   15 .rodata
+    16: 00000000000007e8     0 SECTION LOCAL  DEFAULT   16 .eh_frame_hdr
+    17: 0000000000000830     0 SECTION LOCAL  DEFAULT   17 .eh_frame
+    18: 000000000001fd90     0 SECTION LOCAL  DEFAULT   18 .init_array
+    19: 000000000001fd98     0 SECTION LOCAL  DEFAULT   19 .fini_array
+    20: 000000000001fda0     0 SECTION LOCAL  DEFAULT   20 .dynamic
+    21: 000000000001ff90     0 SECTION LOCAL  DEFAULT   21 .got
+    22: 0000000000020000     0 SECTION LOCAL  DEFAULT   22 .data
+    23: 0000000000020010     0 SECTION LOCAL  DEFAULT   23 .bss
+    24: 0000000000000000     0 SECTION LOCAL  DEFAULT   24 .comment
+    25: 0000000000000000     0 FILE    LOCAL  DEFAULT  ABS Scrt1.o
+    26: 0000000000000278     0 NOTYPE  LOCAL  DEFAULT    3 $d
+    27: 0000000000000278    32 OBJECT  LOCAL  DEFAULT    3 __abi_tag
+    28: 0000000000000640     0 NOTYPE  LOCAL  DEFAULT   13 $x
+    29: 0000000000000844     0 NOTYPE  LOCAL  DEFAULT   17 $d
+    30: 00000000000007e4     0 NOTYPE  LOCAL  DEFAULT   15 $d
+    31: 0000000000000000     0 FILE    LOCAL  DEFAULT  ABS crti.o
+    32: 0000000000000674     0 NOTYPE  LOCAL  DEFAULT   13 $x
+    33: 0000000000000674    20 FUNC    LOCAL  DEFAULT   13 call_weak_fn
+    34: 00000000000005b8     0 NOTYPE  LOCAL  DEFAULT   11 $x
+    35: 00000000000007d0     0 NOTYPE  LOCAL  DEFAULT   14 $x
+    36: 0000000000000000     0 FILE    LOCAL  DEFAULT  ABS crtn.o
+    37: 00000000000005c8     0 NOTYPE  LOCAL  DEFAULT   11 $x
+    38: 00000000000007dc     0 NOTYPE  LOCAL  DEFAULT   14 $x
+    39: 0000000000000000     0 FILE    LOCAL  DEFAULT  ABS crtstuff.c
+    40: 0000000000000690     0 NOTYPE  LOCAL  DEFAULT   13 $x
+    41: 0000000000000690     0 FUNC    LOCAL  DEFAULT   13 deregister_tm_clones
+    42: 00000000000006c0     0 FUNC    LOCAL  DEFAULT   13 register_tm_clones
+    43: 0000000000020008     0 NOTYPE  LOCAL  DEFAULT   22 $d
+    44: 0000000000000700     0 FUNC    LOCAL  DEFAULT   13 __do_global_dtors_aux
+    45: 0000000000020010     1 OBJECT  LOCAL  DEFAULT   23 completed.0
+    46: 000000000001fd98     0 NOTYPE  LOCAL  DEFAULT   19 $d
+    47: 000000000001fd98     0 OBJECT  LOCAL  DEFAULT   19 __do_global_dtors_aux_fini_array_entry
+    48: 0000000000000750     0 FUNC    LOCAL  DEFAULT   13 frame_dummy
+    49: 000000000001fd90     0 NOTYPE  LOCAL  DEFAULT   18 $d
+    50: 000000000001fd90     0 OBJECT  LOCAL  DEFAULT   18 __frame_dummy_init_array_entry
+    51: 0000000000000858     0 NOTYPE  LOCAL  DEFAULT   17 $d
+    52: 0000000000020010     0 NOTYPE  LOCAL  DEFAULT   23 $d
+    53: 0000000000000000     0 FILE    LOCAL  DEFAULT  ABS interproc_pointer_arithmetic.c
+    54: 0000000000000754     0 NOTYPE  LOCAL  DEFAULT   13 $x
+    55: 00000000000008b8     0 NOTYPE  LOCAL  DEFAULT   17 $d
+    56: 0000000000000000     0 FILE    LOCAL  DEFAULT  ABS crtstuff.c
+    57: 00000000000008f0     0 NOTYPE  LOCAL  DEFAULT   17 $d
+    58: 00000000000008f0     0 OBJECT  LOCAL  DEFAULT   17 __FRAME_END__
+    59: 0000000000000000     0 FILE    LOCAL  DEFAULT  ABS 
+    60: 000000000001fda0     0 OBJECT  LOCAL  DEFAULT  ABS _DYNAMIC
+    61: 00000000000007e8     0 NOTYPE  LOCAL  DEFAULT   16 __GNU_EH_FRAME_HDR
+    62: 000000000001ffd0     0 OBJECT  LOCAL  DEFAULT  ABS _GLOBAL_OFFSET_TABLE_
+    63: 00000000000005d0     0 NOTYPE  LOCAL  DEFAULT   12 $x
+    64: 0000000000000000     0 FUNC    GLOBAL DEFAULT  UND __libc_start_main@GLIBC_2.34
+    65: 0000000000000000     0 NOTYPE  WEAK   DEFAULT  UND _ITM_deregisterTMCloneTable
+    66: 0000000000020000     0 NOTYPE  WEAK   DEFAULT   22 data_start
+    67: 0000000000020010     0 NOTYPE  GLOBAL DEFAULT   23 __bss_start__
+    68: 0000000000000000     0 FUNC    WEAK   DEFAULT  UND __cxa_finalize@GLIBC_2.17
+    69: 0000000000020018     0 NOTYPE  GLOBAL DEFAULT   23 _bss_end__
+    70: 0000000000020010     0 NOTYPE  GLOBAL DEFAULT   22 _edata
+    71: 00000000000007d0     0 FUNC    GLOBAL HIDDEN    14 _fini
+    72: 0000000000020018     0 NOTYPE  GLOBAL DEFAULT   23 __bss_end__
+    73: 0000000000000000     0 FUNC    GLOBAL DEFAULT  UND malloc@GLIBC_2.17
+    74: 0000000000020000     0 NOTYPE  GLOBAL DEFAULT   22 __data_start
+    75: 0000000000000000     0 NOTYPE  WEAK   DEFAULT  UND __gmon_start__
+    76: 0000000000020008     0 OBJECT  GLOBAL HIDDEN    22 __dso_handle
+    77: 0000000000000000     0 FUNC    GLOBAL DEFAULT  UND abort@GLIBC_2.17
+    78: 00000000000007e4     4 OBJECT  GLOBAL DEFAULT   15 _IO_stdin_used
+    79: 0000000000020018     0 NOTYPE  GLOBAL DEFAULT   23 _end
+    80: 0000000000000640    52 FUNC    GLOBAL DEFAULT   13 _start
+    81: 0000000000020018     0 NOTYPE  GLOBAL DEFAULT   23 __end__
+    82: 0000000000020010     0 NOTYPE  GLOBAL DEFAULT   23 __bss_start
+    83: 0000000000000774    92 FUNC    GLOBAL DEFAULT   13 main
+    84: 0000000000000754    32 FUNC    GLOBAL DEFAULT   13 callee
+    85: 0000000000020010     0 OBJECT  GLOBAL HIDDEN    22 __TMC_END__
+    86: 0000000000000000     0 NOTYPE  WEAK   DEFAULT  UND _ITM_registerTMCloneTable
+    87: 00000000000005b8     0 FUNC    GLOBAL HIDDEN    11 _init
diff --git a/src/test/dsa/unsafe_pointer_arithmetic/unsafe_pointer_arithmetic.adt b/src/test/dsa/unsafe_pointer_arithmetic/unsafe_pointer_arithmetic.adt
new file mode 100644
index 000000000..b112faabc
--- /dev/null
+++ b/src/test/dsa/unsafe_pointer_arithmetic/unsafe_pointer_arithmetic.adt
@@ -0,0 +1,586 @@
+Project(Attrs([Attr("filename","unsafe_pointer_arithmetic.out"),
+Attr("image-specification","(declare abi (name str))\n(declare arch (name str))\n(declare base-address (addr int))\n(declare bias (off int))\n(declare bits (size int))\n(declare code-region (addr int) (size int) (off int))\n(declare code-start (addr int))\n(declare entry-point (addr int))\n(declare external-reference (addr int) (name str))\n(declare format (name str))\n(declare is-executable (flag bool))\n(declare is-little-endian (flag bool))\n(declare llvm:base-address (addr int))\n(declare llvm:code-entry (name str) (off int) (size int))\n(declare llvm:coff-import-library (name str))\n(declare llvm:coff-virtual-section-header (name str) (addr int) (size int))\n(declare llvm:elf-program-header (name str) (off int) (size int))\n(declare llvm:elf-program-header-flags (name str) (ld bool) (r bool) \n (w bool) (x bool))\n(declare llvm:elf-virtual-program-header (name str) (addr int) (size int))\n(declare llvm:entry-point (addr int))\n(declare llvm:macho-symbol (name str) (value int))\n(declare llvm:name-reference (at int) (name str))\n(declare llvm:relocation (at int) (addr int))\n(declare llvm:section-entry (name str) (addr int) (size int) (off int))\n(declare llvm:section-flags (name str) (r bool) (w bool) (x bool))\n(declare llvm:segment-command (name str) (off int) (size int))\n(declare llvm:segment-command-flags (name str) (r bool) (w bool) (x bool))\n(declare llvm:symbol-entry (name str) (addr int) (size int) (off int)\n (value int))\n(declare llvm:virtual-segment-command (name str) (addr int) (size int))\n(declare mapped (addr int) (size int) (off int))\n(declare named-region (addr int) (size int) (name str))\n(declare named-symbol (addr int) (name str))\n(declare require (name str))\n(declare section (addr int) (size int))\n(declare segment (addr int) (size int) (r bool) (w bool) (x bool))\n(declare subarch (name str))\n(declare symbol-chunk (addr int) (size int) (root int))\n(declare symbol-value (addr int) (value int))\n(declare system (name str))\n(declare vendor (name str))\n\n(abi unknown)\n(arch aarch64)\n(base-address 0)\n(bias 0)\n(bits 64)\n(code-region 1976 20 1976)\n(code-region 1600 376 1600)\n(code-region 1488 112 1488)\n(code-region 1464 24 1464)\n(code-start 1652)\n(code-start 1600)\n(code-start 1876)\n(entry-point 1600)\n(external-reference 131032 _ITM_deregisterTMCloneTable)\n(external-reference 131040 __cxa_finalize)\n(external-reference 131048 __gmon_start__)\n(external-reference 131064 _ITM_registerTMCloneTable)\n(external-reference 130984 __libc_start_main)\n(external-reference 130992 __cxa_finalize)\n(external-reference 131000 malloc)\n(external-reference 131008 __gmon_start__)\n(external-reference 131016 abort)\n(format elf)\n(is-executable true)\n(is-little-endian true)\n(llvm:base-address 0)\n(llvm:code-entry abort 0 0)\n(llvm:code-entry malloc 0 0)\n(llvm:code-entry __cxa_finalize 0 0)\n(llvm:code-entry __libc_start_main 0 0)\n(llvm:code-entry _init 1464 0)\n(llvm:code-entry main 1876 100)\n(llvm:code-entry _start 1600 52)\n(llvm:code-entry abort@GLIBC_2.17 0 0)\n(llvm:code-entry malloc@GLIBC_2.17 0 0)\n(llvm:code-entry _fini 1976 0)\n(llvm:code-entry __cxa_finalize@GLIBC_2.17 0 0)\n(llvm:code-entry __libc_start_main@GLIBC_2.34 0 0)\n(llvm:code-entry frame_dummy 1872 0)\n(llvm:code-entry __do_global_dtors_aux 1792 0)\n(llvm:code-entry register_tm_clones 1728 0)\n(llvm:code-entry deregister_tm_clones 1680 0)\n(llvm:code-entry call_weak_fn 1652 20)\n(llvm:code-entry .fini 1976 20)\n(llvm:code-entry .text 1600 376)\n(llvm:code-entry .plt 1488 112)\n(llvm:code-entry .init 1464 24)\n(llvm:elf-program-header 08 64912 624)\n(llvm:elf-program-header 07 0 0)\n(llvm:elf-program-header 06 2000 60)\n(llvm:elf-program-header 05 596 68)\n(llvm:elf-program-header 04 64928 496)\n(llvm:elf-program-header 03 64912 640)\n(llvm:elf-program-header 02 0 2236)\n(llvm:elf-program-header 01 568 27)\n(llvm:elf-program-header 00 64 504)\n(llvm:elf-program-header-flags 08 false true false false)\n(llvm:elf-program-header-flags 07 false true true false)\n(llvm:elf-program-header-flags 06 false true false false)\n(llvm:elf-program-header-flags 05 false true false false)\n(llvm:elf-program-header-flags 04 false true true false)\n(llvm:elf-program-header-flags 03 true true true false)\n(llvm:elf-program-header-flags 02 true true false true)\n(llvm:elf-program-header-flags 01 false true false false)\n(llvm:elf-program-header-flags 00 false true false false)\n(llvm:elf-virtual-program-header 08 130448 624)\n(llvm:elf-virtual-program-header 07 0 0)\n(llvm:elf-virtual-program-header 06 2000 60)\n(llvm:elf-virtual-program-header 05 596 68)\n(llvm:elf-virtual-program-header 04 130464 496)\n(llvm:elf-virtual-program-header 03 130448 648)\n(llvm:elf-virtual-program-header 02 0 2236)\n(llvm:elf-virtual-program-header 01 568 27)\n(llvm:elf-virtual-program-header 00 64 504)\n(llvm:entry-point 1600)\n(llvm:name-reference 131016 abort)\n(llvm:name-reference 131008 __gmon_start__)\n(llvm:name-reference 131000 malloc)\n(llvm:name-reference 130992 __cxa_finalize)\n(llvm:name-reference 130984 __libc_start_main)\n(llvm:name-reference 131064 _ITM_registerTMCloneTable)\n(llvm:name-reference 131048 __gmon_start__)\n(llvm:name-reference 131040 __cxa_finalize)\n(llvm:name-reference 131032 _ITM_deregisterTMCloneTable)\n(llvm:section-entry .shstrtab 0 250 68267)\n(llvm:section-entry .strtab 0 579 67688)\n(llvm:section-entry .symtab 0 2088 65600)\n(llvm:section-entry .comment 0 43 65552)\n(llvm:section-entry .bss 131088 8 65552)\n(llvm:section-entry .data 131072 16 65536)\n(llvm:section-entry .got 130960 112 65424)\n(llvm:section-entry .dynamic 130464 496 64928)\n(llvm:section-entry .fini_array 130456 8 64920)\n(llvm:section-entry .init_array 130448 8 64912)\n(llvm:section-entry .eh_frame 2064 172 2064)\n(llvm:section-entry .eh_frame_hdr 2000 60 2000)\n(llvm:section-entry .rodata 1996 4 1996)\n(llvm:section-entry .fini 1976 20 1976)\n(llvm:section-entry .text 1600 376 1600)\n(llvm:section-entry .plt 1488 112 1488)\n(llvm:section-entry .init 1464 24 1464)\n(llvm:section-entry .rela.plt 1344 120 1344)\n(llvm:section-entry .rela.dyn 1152 192 1152)\n(llvm:section-entry .gnu.version_r 1104 48 1104)\n(llvm:section-entry .gnu.version 1084 20 1084)\n(llvm:section-entry .dynstr 936 148 936)\n(llvm:section-entry .dynsym 696 240 696)\n(llvm:section-entry .gnu.hash 664 28 664)\n(llvm:section-entry .note.ABI-tag 632 32 632)\n(llvm:section-entry .note.gnu.build-id 596 36 596)\n(llvm:section-entry .interp 568 27 568)\n(llvm:section-flags .shstrtab true false false)\n(llvm:section-flags .strtab true false false)\n(llvm:section-flags .symtab true false false)\n(llvm:section-flags .comment true false false)\n(llvm:section-flags .bss true true false)\n(llvm:section-flags .data true true false)\n(llvm:section-flags .got true true false)\n(llvm:section-flags .dynamic true true false)\n(llvm:section-flags .fini_array true true false)\n(llvm:section-flags .init_array true true false)\n(llvm:section-flags .eh_frame true false false)\n(llvm:section-flags .eh_frame_hdr true false false)\n(llvm:section-flags .rodata true false false)\n(llvm:section-flags .fini true false true)\n(llvm:section-flags .text true false true)\n(llvm:section-flags .plt true false true)\n(llvm:section-flags .init true false true)\n(llvm:section-flags .rela.plt true false false)\n(llvm:section-flags .rela.dyn true false false)\n(llvm:section-flags .gnu.version_r true false false)\n(llvm:section-flags .gnu.version true false false)\n(llvm:section-flags .dynstr true false false)\n(llvm:section-flags .dynsym true false false)\n(llvm:section-flags .gnu.hash true false false)\n(llvm:section-flags .note.ABI-tag true false false)\n(llvm:section-flags .note.gnu.build-id true false false)\n(llvm:section-flags .interp true false false)\n(llvm:symbol-entry abort 0 0 0 0)\n(llvm:symbol-entry malloc 0 0 0 0)\n(llvm:symbol-entry __cxa_finalize 0 0 0 0)\n(llvm:symbol-entry __libc_start_main 0 0 0 0)\n(llvm:symbol-entry _init 1464 0 1464 1464)\n(llvm:symbol-entry main 1876 100 1876 1876)\n(llvm:symbol-entry _start 1600 52 1600 1600)\n(llvm:symbol-entry abort@GLIBC_2.17 0 0 0 0)\n(llvm:symbol-entry malloc@GLIBC_2.17 0 0 0 0)\n(llvm:symbol-entry _fini 1976 0 1976 1976)\n(llvm:symbol-entry __cxa_finalize@GLIBC_2.17 0 0 0 0)\n(llvm:symbol-entry __libc_start_main@GLIBC_2.34 0 0 0 0)\n(llvm:symbol-entry frame_dummy 1872 0 1872 1872)\n(llvm:symbol-entry __do_global_dtors_aux 1792 0 1792 1792)\n(llvm:symbol-entry register_tm_clones 1728 0 1728 1728)\n(llvm:symbol-entry deregister_tm_clones 1680 0 1680 1680)\n(llvm:symbol-entry call_weak_fn 1652 20 1652 1652)\n(mapped 0 2236 0)\n(mapped 130448 640 64912)\n(named-region 0 2236 02)\n(named-region 130448 648 03)\n(named-region 568 27 .interp)\n(named-region 596 36 .note.gnu.build-id)\n(named-region 632 32 .note.ABI-tag)\n(named-region 664 28 .gnu.hash)\n(named-region 696 240 .dynsym)\n(named-region 936 148 .dynstr)\n(named-region 1084 20 .gnu.version)\n(named-region 1104 48 .gnu.version_r)\n(named-region 1152 192 .rela.dyn)\n(named-region 1344 120 .rela.plt)\n(named-region 1464 24 .init)\n(named-region 1488 112 .plt)\n(named-region 1600 376 .text)\n(named-region 1976 20 .fini)\n(named-region 1996 4 .rodata)\n(named-region 2000 60 .eh_frame_hdr)\n(named-region 2064 172 .eh_frame)\n(named-region 130448 8 .init_array)\n(named-region 130456 8 .fini_array)\n(named-region 130464 496 .dynamic)\n(named-region 130960 112 .got)\n(named-region 131072 16 .data)\n(named-region 131088 8 .bss)\n(named-region 0 43 .comment)\n(named-region 0 2088 .symtab)\n(named-region 0 579 .strtab)\n(named-region 0 250 .shstrtab)\n(named-symbol 1652 call_weak_fn)\n(named-symbol 1680 deregister_tm_clones)\n(named-symbol 1728 register_tm_clones)\n(named-symbol 1792 __do_global_dtors_aux)\n(named-symbol 1872 frame_dummy)\n(named-symbol 0 __libc_start_main@GLIBC_2.34)\n(named-symbol 0 __cxa_finalize@GLIBC_2.17)\n(named-symbol 1976 _fini)\n(named-symbol 0 malloc@GLIBC_2.17)\n(named-symbol 0 abort@GLIBC_2.17)\n(named-symbol 1600 _start)\n(named-symbol 1876 main)\n(named-symbol 1464 _init)\n(named-symbol 0 __libc_start_main)\n(named-symbol 0 __cxa_finalize)\n(named-symbol 0 malloc)\n(named-symbol 0 abort)\n(require libc.so.6)\n(section 568 27)\n(section 596 36)\n(section 632 32)\n(section 664 28)\n(section 696 240)\n(section 936 148)\n(section 1084 20)\n(section 1104 48)\n(section 1152 192)\n(section 1344 120)\n(section 1464 24)\n(section 1488 112)\n(section 1600 376)\n(section 1976 20)\n(section 1996 4)\n(section 2000 60)\n(section 2064 172)\n(section 130448 8)\n(section 130456 8)\n(section 130464 496)\n(section 130960 112)\n(section 131072 16)\n(section 131088 8)\n(section 0 43)\n(section 0 2088)\n(section 0 579)\n(section 0 250)\n(segment 0 2236 true false true)\n(segment 130448 648 true true false)\n(subarch v8)\n(symbol-chunk 1652 20 1652)\n(symbol-chunk 1600 52 1600)\n(symbol-chunk 1876 100 1876)\n(symbol-value 1652 1652)\n(symbol-value 1680 1680)\n(symbol-value 1728 1728)\n(symbol-value 1792 1792)\n(symbol-value 1872 1872)\n(symbol-value 1976 1976)\n(symbol-value 1600 1600)\n(symbol-value 1876 1876)\n(symbol-value 1464 1464)\n(symbol-value 0 0)\n(system \"\")\n(vendor \"\")\n"),
+Attr("abi-name","aarch64-linux-gnu-elf")]),
+Sections([Section(".shstrtab", 0x0, "\x7f\x45\x4c\x46\x02\x01\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x03\x00\xb7\x00\x01\x00\x00\x00\x40\x06\x00\x00\x00\x00\x00\x00\x40\x00\x00\x00\x00\x00\x00\x00\xa8\x0b\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x40\x00\x38\x00\x09\x00\x40\x00\x1c\x00\x1b\x00\x06\x00\x00\x00\x04\x00\x00\x00\x40\x00\x00\x00\x00\x00\x00\x00\x40\x00\x00\x00\x00\x00\x00\x00\x40\x00\x00\x00\x00\x00\x00\x00\xf8\x01\x00\x00\x00\x00\x00\x00\xf8\x01\x00\x00\x00\x00\x00\x00\x08\x00\x00\x00\x00\x00\x00\x00\x03\x00\x00\x00\x04\x00\x00\x00\x38\x02\x00\x00\x00\x00\x00\x00\x38\x02\x00\x00\x00\x00\x00\x00\x38\x02\x00\x00\x00\x00\x00\x00\x1b\x00\x00\x00\x00\x00\x00\x00\x1b\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x05\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xbc\x08\x00\x00\x00\x00\x00\x00\xbc\x08\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x00\x00\x01\x00\x00\x00\x06\x00\x00\x00\x90\xfd\x00\x00\x00\x00\x00\x00\x90\xfd"),
+Section(".strtab", 0x0, "\x7f\x45\x4c\x46\x02\x01\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x03\x00\xb7\x00\x01\x00\x00\x00\x40\x06\x00\x00\x00\x00\x00\x00\x40\x00\x00\x00\x00\x00\x00\x00\xa8\x0b\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x40\x00\x38\x00\x09\x00\x40\x00\x1c\x00\x1b\x00\x06\x00\x00\x00\x04\x00\x00\x00\x40\x00\x00\x00\x00\x00\x00\x00\x40\x00\x00\x00\x00\x00\x00\x00\x40\x00\x00\x00\x00\x00\x00\x00\xf8\x01\x00\x00\x00\x00\x00\x00\xf8\x01\x00\x00\x00\x00\x00\x00\x08\x00\x00\x00\x00\x00\x00\x00\x03\x00\x00\x00\x04\x00\x00\x00\x38\x02\x00\x00\x00\x00\x00\x00\x38\x02\x00\x00\x00\x00\x00\x00\x38\x02\x00\x00\x00\x00\x00\x00\x1b\x00\x00\x00\x00\x00\x00\x00\x1b\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x05\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xbc\x08\x00\x00\x00\x00\x00\x00\xbc\x08\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x00\x00\x01\x00\x00\x00\x06\x00\x00\x00\x90\xfd\x00\x00\x00\x00\x00\x00\x90\xfd\x01\x00\x00\x00\x00\x00\x90\xfd\x01\x00\x00\x00\x00\x00\x80\x02\x00\x00\x00\x00\x00\x00\x88\x02\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x00\x00\x02\x00\x00\x00\x06\x00\x00\x00\xa0\xfd\x00\x00\x00\x00\x00\x00\xa0\xfd\x01\x00\x00\x00\x00\x00\xa0\xfd\x01\x00\x00\x00\x00\x00\xf0\x01\x00\x00\x00\x00\x00\x00\xf0\x01\x00\x00\x00\x00\x00\x00\x08\x00\x00\x00\x00\x00\x00\x00\x04\x00\x00\x00\x04\x00\x00\x00\x54\x02\x00\x00\x00\x00\x00\x00\x54\x02\x00\x00\x00\x00\x00\x00\x54\x02\x00\x00\x00\x00\x00\x00\x44\x00\x00\x00\x00\x00\x00\x00\x44\x00\x00\x00\x00\x00\x00\x00\x04\x00\x00\x00\x00\x00\x00\x00\x50\xe5\x74\x64\x04\x00\x00\x00\xd0\x07\x00\x00\x00\x00\x00\x00\xd0\x07\x00\x00\x00\x00\x00\x00\xd0\x07\x00\x00\x00\x00\x00\x00\x3c\x00\x00\x00\x00\x00\x00\x00\x3c\x00\x00\x00\x00\x00\x00\x00\x04\x00\x00\x00\x00\x00\x00\x00\x51\xe5\x74\x64\x06\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x10\x00\x00\x00\x00\x00\x00\x00\x52\xe5\x74\x64\x04\x00\x00\x00\x90\xfd\x00\x00\x00\x00\x00\x00\x90\xfd\x01\x00\x00\x00\x00\x00\x90\xfd\x01\x00\x00\x00\x00\x00\x70\x02\x00\x00\x00\x00\x00\x00\x70\x02\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00\x2f\x6c\x69\x62\x2f\x6c\x64\x2d\x6c\x69\x6e"),
+Section(".symtab", 0x0, "\x7f\x45\x4c\x46\x02\x01\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x03\x00\xb7\x00\x01\x00\x00\x00\x40\x06\x00\x00\x00\x00\x00\x00\x40\x00\x00\x00\x00\x00\x00\x00\xa8\x0b\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x40\x00\x38\x00\x09\x00\x40\x00\x1c\x00\x1b\x00\x06\x00\x00\x00\x04\x00\x00\x00\x40\x00\x00\x00\x00\x00\x00\x00\x40\x00\x00\x00\x00\x00\x00\x00\x40\x00\x00\x00\x00\x00\x00\x00\xf8\x01\x00\x00\x00\x00\x00\x00\xf8\x01\x00\x00\x00\x00\x00\x00\x08\x00\x00\x00\x00\x00\x00\x00\x03\x00\x00\x00\x04\x00\x00\x00\x38\x02\x00\x00\x00\x00\x00\x00\x38\x02\x00\x00\x00\x00\x00\x00\x38\x02\x00\x00\x00\x00\x00\x00\x1b\x00\x00\x00\x00\x00\x00\x00\x1b\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x05\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xbc\x08\x00\x00\x00\x00\x00\x00\xbc\x08\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x00\x00\x01\x00\x00\x00\x06\x00\x00\x00\x90\xfd\x00\x00\x00\x00\x00\x00\x90\xfd\x01\x00\x00\x00\x00\x00\x90\xfd\x01\x00\x00\x00\x00\x00\x80\x02\x00\x00\x00\x00\x00\x00\x88\x02\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x00\x00\x02\x00\x00\x00\x06\x00\x00\x00\xa0\xfd\x00\x00\x00\x00\x00\x00\xa0\xfd\x01\x00\x00\x00\x00\x00\xa0\xfd\x01\x00\x00\x00\x00\x00\xf0\x01\x00\x00\x00\x00\x00\x00\xf0\x01\x00\x00\x00\x00\x00\x00\x08\x00\x00\x00\x00\x00\x00\x00\x04\x00\x00\x00\x04\x00\x00\x00\x54\x02\x00\x00\x00\x00\x00\x00\x54\x02\x00\x00\x00\x00\x00\x00\x54\x02\x00\x00\x00\x00\x00\x00\x44\x00\x00\x00\x00\x00\x00\x00\x44\x00\x00\x00\x00\x00\x00\x00\x04\x00\x00\x00\x00\x00\x00\x00\x50\xe5\x74\x64\x04\x00\x00\x00\xd0\x07\x00\x00\x00\x00\x00\x00\xd0\x07\x00\x00\x00\x00\x00\x00\xd0\x07\x00\x00\x00\x00\x00\x00\x3c\x00\x00\x00\x00\x00\x00\x00\x3c\x00\x00\x00\x00\x00\x00\x00\x04\x00\x00\x00\x00\x00\x00\x00\x51\xe5\x74\x64\x06\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x10\x00\x00\x00\x00\x00\x00\x00\x52\xe5\x74\x64\x04\x00\x00\x00\x90\xfd\x00\x00\x00\x00\x00\x00\x90\xfd\x01\x00\x00\x00\x00\x00\x90\xfd\x01\x00\x00\x00\x00\x00\x70\x02\x00\x00\x00\x00\x00\x00\x70\x02\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00\x2f\x6c\x69\x62\x2f\x6c\x64\x2d\x6c\x69\x6e\x75\x78\x2d\x61\x61\x72\x63\x68\x36\x34\x2e\x73\x6f\x2e\x31\x00\x00\x04\x00\x00\x00\x14\x00\x00\x00\x03\x00\x00\x00\x47\x4e\x55\x00\xe7\x83\xd0\x0b\x65\xff\x69\x99\x15\x9f\x13\x77\x3c\xa9\xc0\x82\xdf\x41\xac\xfa\x04\x00\x00\x00\x10\x00\x00\x00\x01\x00\x00\x00\x47\x4e\x55\x00\x00\x00\x00\x00\x03\x00\x00\x00\x07\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x03\x00\x0b\x00\xb8\x05\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x03\x00\x16\x00\x00\x00\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x08\x00\x00\x00\x12\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4f\x00\x00\x00\x20\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1a\x00\x00\x00\x22\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x12\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6b\x00\x00\x00\x20\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x29\x00\x00\x00\x12\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x7a\x00\x00\x00\x20\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6d\x61\x6c\x6c\x6f\x63\x00\x5f\x5f\x6c\x69\x62\x63\x5f\x73\x74\x61\x72\x74\x5f\x6d\x61\x69\x6e\x00\x5f\x5f\x63\x78\x61\x5f\x66\x69\x6e\x61\x6c\x69\x7a\x65\x00\x61\x62\x6f\x72\x74\x00\x6c\x69\x62\x63\x2e\x73\x6f\x2e\x36\x00\x47\x4c\x49\x42\x43\x5f\x32\x2e\x31\x37\x00\x47\x4c\x49\x42\x43\x5f\x32\x2e\x33\x34\x00\x5f\x49\x54\x4d\x5f\x64\x65\x72\x65\x67\x69\x73\x74\x65\x72\x54\x4d\x43\x6c\x6f\x6e\x65\x54\x61\x62\x6c\x65\x00\x5f\x5f\x67\x6d\x6f\x6e\x5f\x73\x74\x61\x72\x74\x5f\x5f\x00\x5f\x49\x54\x4d\x5f\x72\x65\x67\x69\x73\x74\x65\x72\x54\x4d\x43\x6c\x6f\x6e\x65\x54\x61\x62\x6c\x65\x00\x00\x00\x00\x00\x00\x00\x02\x00\x01\x00\x03\x00\x03\x00\x01\x00\x03\x00\x01\x00\x01\x00\x02\x00\x2f\x00\x00\x00\x10\x00\x00\x00\x00\x00\x00\x00\x97\x91\x96\x06\x00\x00\x03\x00\x39\x00\x00\x00\x10\x00\x00\x00\xb4\x91\x96\x06\x00\x00\x02\x00\x44\x00\x00\x00\x00\x00\x00\x00\x90\xfd\x01\x00\x00\x00\x00\x00\x03\x04\x00\x00\x00\x00\x00\x00\x50\x07\x00\x00\x00\x00\x00\x00\x98\xfd\x01\x00\x00\x00\x00\x00\x03\x04\x00\x00\x00\x00\x00\x00\x00\x07\x00\x00\x00\x00\x00\x00\xf0\xff\x01\x00\x00\x00\x00\x00\x03\x04\x00\x00\x00\x00\x00\x00\x54\x07\x00\x00\x00\x00\x00\x00\x08\x00\x02\x00\x00\x00\x00\x00\x03\x04\x00\x00\x00\x00\x00\x00\x08\x00\x02\x00\x00\x00\x00\x00\xd8\xff\x01\x00\x00\x00\x00\x00\x01\x04\x00\x00\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe0\xff\x01\x00\x00\x00\x00\x00\x01\x04\x00\x00\x05\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe8\xff\x01\x00\x00\x00\x00\x00\x01\x04\x00\x00\x07\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xf8\xff\x01\x00\x00\x00\x00\x00\x01\x04\x00\x00\x09\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa8\xff\x01\x00\x00\x00\x00\x00\x02\x04\x00\x00\x03\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb0\xff\x01\x00\x00\x00\x00\x00\x02\x04\x00\x00\x05\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb8\xff\x01\x00\x00\x00\x00\x00\x02\x04\x00\x00\x06\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc0\xff\x01\x00\x00\x00\x00\x00\x02\x04\x00\x00\x07\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc8\xff\x01\x00\x00\x00\x00\x00\x02\x04\x00\x00\x08\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1f\x20\x03\xd5\xfd\x7b\xbf\xa9\xfd\x03\x00\x91\x2c\x00\x00\x94\xfd\x7b\xc1\xa8\xc0\x03\x5f\xd6\xf0\x7b\xbf\xa9\xf0\x00\x00\xf0\x11\xd2\x47\xf9\x10\x82\x3e\x91\x20\x02\x1f\xd6\x1f\x20\x03\xd5\x1f\x20\x03\xd5\x1f\x20\x03\xd5\xf0\x00\x00\xf0\x11\xd6\x47\xf9\x10\xa2\x3e\x91\x20\x02\x1f\xd6\xf0\x00\x00\xf0\x11\xda\x47\xf9\x10\xc2\x3e\x91\x20\x02\x1f\xd6\xf0\x00\x00\xf0\x11\xde\x47\xf9\x10\xe2\x3e\x91\x20\x02\x1f\xd6\xf0\x00\x00\xf0\x11\xe2\x47\xf9\x10\x02\x3f\x91\x20\x02\x1f\xd6\xf0\x00\x00\xf0\x11\xe6\x47\xf9\x10\x22\x3f\x91\x20\x02\x1f\xd6\x1f\x20\x03\xd5\x1d\x00\x80\xd2\x1e\x00\x80\xd2\xe5\x03\x00\xaa\xe1\x03\x40\xf9\xe2\x23\x00\x91\xe6\x03\x00\x91\xe0\x00\x00\xf0\x00\xf8\x47\xf9\x03\x00\x80\xd2\x04\x00\x80\xd2\xe1\xff\xff\x97\xf0\xff\xff\x97\xe0\x00\x00\xf0\x00\xf4\x47\xf9\x40\x00\x00\xb4\xe8\xff\xff\x17\xc0\x03\x5f\xd6\x1f\x20\x03\xd5\x1f\x20\x03\xd5\x00\x01\x00\x90\x00\x40\x00\x91\x01\x01\x00\x90\x21\x40\x00\x91\x3f\x00\x00\xeb\xc0\x00\x00\x54\xe1\x00\x00\xf0\x21\xec\x47\xf9\x61\x00\x00\xb4\xf0\x03\x01\xaa\x00\x02\x1f\xd6\xc0\x03\x5f\xd6\x00\x01\x00\x90\x00\x40\x00\x91\x01\x01\x00\x90\x21\x40\x00\x91\x21\x00\x00\xcb\x22\xfc\x7f\xd3\x41\x0c\x81\x8b\x21\xfc\x41\x93\xc1\x00\x00\xb4\xe2\x00\x00\xf0\x42\xfc\x47\xf9\x62\x00\x00\xb4\xf0\x03\x02\xaa\x00\x02\x1f\xd6\xc0\x03\x5f\xd6\x1f\x20\x03\xd5\xfd\x7b\xbe\xa9\xfd\x03\x00\x91\xf3\x0b\x00\xf9\x13\x01\x00\x90\x60\x42\x40\x39\x40\x01\x00\x35\xe0\x00\x00\xf0\x00\xf0\x47\xf9\x80\x00\x00\xb4\x00\x01\x00\x90\x00\x04\x40\xf9\xb5\xff\xff\x97\xd8\xff\xff\x97\x20\x00\x80\x52\x60\x42\x00\x39\xf3\x0b\x40\xf9\xfd\x7b\xc2\xa8\xc0\x03\x5f\xd6\x1f\x20\x03\xd5\x1f\x20\x03\xd5\xdc\xff\xff\x17\xfd\x7b\xbc\xa9\xfd\x03\x00\x91\x80\x02\x80\xd2\xac\xff\xff\x97\xe0\x0f\x00\xf9\xe0\x0f\x40\xf9\x81\x01\x80\x52\x01\x00\x00\xb9\xe0\x0f\x40\xf9\xe0\x13\x00\xf9\xe0\x13\x40\xf9\x00\x04\x00\x91\xe0\x17\x00\xf9\x00\x01\x80\xd2\xa1\xff\xff\x97\xe0\x1b\x00\xf9\xe0\x1b\x40\xf9\xe1\x17\x40\xf9\x01\x00\x00\xf9\xe0\x1b\x40\xf9\x00\x00\x40\xf9\xe0\x1f\x00\xf9\x00\x00\x80\x52\xfd\x7b\xc4\xa8\xc0\x03\x5f\xd6\x1f\x20\x03\xd5\xfd\x7b\xbf\xa9\xfd\x03\x00\x91\xfd\x7b\xc1\xa8\xc0\x03\x5f\xd6\x01\x00\x02\x00\x01\x1b\x03\x3b\x3c\x00\x00\x00\x06\x00\x00\x00\x70\xfe\xff\xff\x54\x00\x00\x00\xc0\xfe\xff\xff\x68\x00\x00\x00\xf0\xfe\xff\xff\x7c\x00\x00\x00\x30\xff\xff\xff\x90\x00\x00\x00\x80\xff\xff\xff\xb4\x00\x00\x00\x84\xff\xff\xff\xc8\x00\x00\x00\x00\x00\x00\x00\x10\x00\x00\x00\x00\x00\x00\x00\x01\x7a\x52\x00\x04\x78\x1e\x01\x1b\x0c\x1f\x00\x10\x00\x00\x00"),
+Section(".comment", 0x0, "\x7f\x45\x4c\x46\x02\x01\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x03\x00\xb7\x00\x01\x00\x00\x00\x40\x06\x00\x00\x00\x00\x00\x00\x40\x00\x00\x00\x00\x00\x00\x00\xa8\x0b\x01"),
+Section(".interp", 0x238, "\x2f\x6c\x69\x62\x2f\x6c\x64\x2d\x6c\x69\x6e\x75\x78\x2d\x61\x61\x72\x63\x68\x36\x34\x2e\x73\x6f\x2e\x31\x00"),
+Section(".note.gnu.build-id", 0x254, "\x04\x00\x00\x00\x14\x00\x00\x00\x03\x00\x00\x00\x47\x4e\x55\x00\xe7\x83\xd0\x0b\x65\xff\x69\x99\x15\x9f\x13\x77\x3c\xa9\xc0\x82\xdf\x41\xac\xfa"),
+Section(".note.ABI-tag", 0x278, "\x04\x00\x00\x00\x10\x00\x00\x00\x01\x00\x00\x00\x47\x4e\x55\x00\x00\x00\x00\x00\x03\x00\x00\x00\x07\x00\x00\x00\x00\x00\x00\x00"),
+Section(".gnu.hash", 0x298, "\x01\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"),
+Section(".dynsym", 0x2B8, "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x03\x00\x0b\x00\xb8\x05\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x03\x00\x16\x00\x00\x00\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x08\x00\x00\x00\x12\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4f\x00\x00\x00\x20\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1a\x00\x00\x00\x22\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x12\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6b\x00\x00\x00\x20\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x29\x00\x00\x00\x12\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x7a\x00\x00\x00\x20\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"),
+Section(".dynstr", 0x3A8, "\x00\x6d\x61\x6c\x6c\x6f\x63\x00\x5f\x5f\x6c\x69\x62\x63\x5f\x73\x74\x61\x72\x74\x5f\x6d\x61\x69\x6e\x00\x5f\x5f\x63\x78\x61\x5f\x66\x69\x6e\x61\x6c\x69\x7a\x65\x00\x61\x62\x6f\x72\x74\x00\x6c\x69\x62\x63\x2e\x73\x6f\x2e\x36\x00\x47\x4c\x49\x42\x43\x5f\x32\x2e\x31\x37\x00\x47\x4c\x49\x42\x43\x5f\x32\x2e\x33\x34\x00\x5f\x49\x54\x4d\x5f\x64\x65\x72\x65\x67\x69\x73\x74\x65\x72\x54\x4d\x43\x6c\x6f\x6e\x65\x54\x61\x62\x6c\x65\x00\x5f\x5f\x67\x6d\x6f\x6e\x5f\x73\x74\x61\x72\x74\x5f\x5f\x00\x5f\x49\x54\x4d\x5f\x72\x65\x67\x69\x73\x74\x65\x72\x54\x4d\x43\x6c\x6f\x6e\x65\x54\x61\x62\x6c\x65\x00"),
+Section(".gnu.version", 0x43C, "\x00\x00\x00\x00\x00\x00\x02\x00\x01\x00\x03\x00\x03\x00\x01\x00\x03\x00\x01\x00"),
+Section(".gnu.version_r", 0x450, "\x01\x00\x02\x00\x2f\x00\x00\x00\x10\x00\x00\x00\x00\x00\x00\x00\x97\x91\x96\x06\x00\x00\x03\x00\x39\x00\x00\x00\x10\x00\x00\x00\xb4\x91\x96\x06\x00\x00\x02\x00\x44\x00\x00\x00\x00\x00\x00\x00"),
+Section(".rela.dyn", 0x480, "\x90\xfd\x01\x00\x00\x00\x00\x00\x03\x04\x00\x00\x00\x00\x00\x00\x50\x07\x00\x00\x00\x00\x00\x00\x98\xfd\x01\x00\x00\x00\x00\x00\x03\x04\x00\x00\x00\x00\x00\x00\x00\x07\x00\x00\x00\x00\x00\x00\xf0\xff\x01\x00\x00\x00\x00\x00\x03\x04\x00\x00\x00\x00\x00\x00\x54\x07\x00\x00\x00\x00\x00\x00\x08\x00\x02\x00\x00\x00\x00\x00\x03\x04\x00\x00\x00\x00\x00\x00\x08\x00\x02\x00\x00\x00\x00\x00\xd8\xff\x01\x00\x00\x00\x00\x00\x01\x04\x00\x00\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe0\xff\x01\x00\x00\x00\x00\x00\x01\x04\x00\x00\x05\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe8\xff\x01\x00\x00\x00\x00\x00\x01\x04\x00\x00\x07\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xf8\xff\x01\x00\x00\x00\x00\x00\x01\x04\x00\x00\x09\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"),
+Section(".rela.plt", 0x540, "\xa8\xff\x01\x00\x00\x00\x00\x00\x02\x04\x00\x00\x03\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb0\xff\x01\x00\x00\x00\x00\x00\x02\x04\x00\x00\x05\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb8\xff\x01\x00\x00\x00\x00\x00\x02\x04\x00\x00\x06\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc0\xff\x01\x00\x00\x00\x00\x00\x02\x04\x00\x00\x07\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc8\xff\x01\x00\x00\x00\x00\x00\x02\x04\x00\x00\x08\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"),
+Section(".init", 0x5B8, "\x1f\x20\x03\xd5\xfd\x7b\xbf\xa9\xfd\x03\x00\x91\x2c\x00\x00\x94\xfd\x7b\xc1\xa8\xc0\x03\x5f\xd6"),
+Section(".plt", 0x5D0, "\xf0\x7b\xbf\xa9\xf0\x00\x00\xf0\x11\xd2\x47\xf9\x10\x82\x3e\x91\x20\x02\x1f\xd6\x1f\x20\x03\xd5\x1f\x20\x03\xd5\x1f\x20\x03\xd5\xf0\x00\x00\xf0\x11\xd6\x47\xf9\x10\xa2\x3e\x91\x20\x02\x1f\xd6\xf0\x00\x00\xf0\x11\xda\x47\xf9\x10\xc2\x3e\x91\x20\x02\x1f\xd6\xf0\x00\x00\xf0\x11\xde\x47\xf9\x10\xe2\x3e\x91\x20\x02\x1f\xd6\xf0\x00\x00\xf0\x11\xe2\x47\xf9\x10\x02\x3f\x91\x20\x02\x1f\xd6\xf0\x00\x00\xf0\x11\xe6\x47\xf9\x10\x22\x3f\x91\x20\x02\x1f\xd6"),
+Section(".fini", 0x7B8, "\x1f\x20\x03\xd5\xfd\x7b\xbf\xa9\xfd\x03\x00\x91\xfd\x7b\xc1\xa8\xc0\x03\x5f\xd6"),
+Section(".rodata", 0x7CC, "\x01\x00\x02\x00"),
+Section(".eh_frame_hdr", 0x7D0, "\x01\x1b\x03\x3b\x3c\x00\x00\x00\x06\x00\x00\x00\x70\xfe\xff\xff\x54\x00\x00\x00\xc0\xfe\xff\xff\x68\x00\x00\x00\xf0\xfe\xff\xff\x7c\x00\x00\x00\x30\xff\xff\xff\x90\x00\x00\x00\x80\xff\xff\xff\xb4\x00\x00\x00\x84\xff\xff\xff\xc8\x00\x00\x00"),
+Section(".eh_frame", 0x810, "\x10\x00\x00\x00\x00\x00\x00\x00\x01\x7a\x52\x00\x04\x78\x1e\x01\x1b\x0c\x1f\x00\x10\x00\x00\x00\x18\x00\x00\x00\x14\xfe\xff\xff\x34\x00\x00\x00\x00\x41\x07\x1e\x10\x00\x00\x00\x2c\x00\x00\x00\x50\xfe\xff\xff\x30\x00\x00\x00\x00\x00\x00\x00\x10\x00\x00\x00\x40\x00\x00\x00\x6c\xfe\xff\xff\x3c\x00\x00\x00\x00\x00\x00\x00\x20\x00\x00\x00\x54\x00\x00\x00\x98\xfe\xff\xff\x48\x00\x00\x00\x00\x41\x0e\x20\x9d\x04\x9e\x03\x42\x93\x02\x4e\xde\xdd\xd3\x0e\x00\x00\x00\x00\x10\x00\x00\x00\x78\x00\x00\x00\xc4\xfe\xff\xff\x04\x00\x00\x00\x00\x00\x00\x00\x1c\x00\x00\x00\x8c\x00\x00\x00\xb4\xfe\xff\xff\x64\x00\x00\x00\x00\x41\x0e\x40\x9d\x08\x9e\x07\x57\xde\xdd\x0e\x00\x00\x00\x00\x00\x00\x00\x00"),
+Section(".fini_array", 0x1FD98, "\x00\x07\x00\x00\x00\x00\x00\x00"),
+Section(".dynamic", 0x1FDA0, "\x01\x00\x00\x00\x00\x00\x00\x00\x2f\x00\x00\x00\x00\x00\x00\x00\x0c\x00\x00\x00\x00\x00\x00\x00\xb8\x05\x00\x00\x00\x00\x00\x00\x0d\x00\x00\x00\x00\x00\x00\x00\xb8\x07\x00\x00\x00\x00\x00\x00\x19\x00\x00\x00\x00\x00\x00\x00\x90\xfd\x01\x00\x00\x00\x00\x00\x1b\x00\x00\x00\x00\x00\x00\x00\x08\x00\x00\x00\x00\x00\x00\x00\x1a\x00\x00\x00\x00\x00\x00\x00\x98\xfd\x01\x00\x00\x00\x00\x00\x1c\x00\x00\x00\x00\x00\x00\x00\x08\x00\x00\x00\x00\x00\x00\x00\xf5\xfe\xff\x6f\x00\x00\x00\x00\x98\x02\x00\x00\x00\x00\x00\x00\x05\x00\x00\x00\x00\x00\x00\x00\xa8\x03\x00\x00\x00\x00\x00\x00\x06\x00\x00\x00\x00\x00\x00\x00\xb8\x02\x00\x00\x00\x00\x00\x00\x0a\x00\x00\x00\x00\x00\x00\x00\x94\x00\x00\x00\x00\x00\x00\x00\x0b\x00\x00\x00\x00\x00\x00\x00\x18\x00\x00\x00\x00\x00\x00\x00\x15\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x03\x00\x00\x00\x00\x00\x00\x00\x90\xff\x01\x00\x00\x00\x00\x00\x02\x00\x00\x00\x00\x00\x00\x00\x78\x00\x00\x00\x00\x00\x00\x00\x14\x00\x00\x00\x00\x00\x00\x00\x07\x00\x00\x00\x00\x00\x00\x00\x17\x00\x00\x00\x00\x00\x00\x00\x40\x05\x00\x00\x00\x00\x00\x00\x07\x00\x00\x00\x00\x00\x00\x00\x80\x04\x00\x00\x00\x00\x00\x00\x08\x00\x00\x00\x00\x00\x00\x00\xc0\x00\x00\x00\x00\x00\x00\x00\x09\x00\x00\x00\x00\x00\x00\x00\x18\x00\x00\x00\x00\x00\x00\x00\x1e\x00\x00\x00\x00\x00\x00\x00\x08\x00\x00\x00\x00\x00\x00\x00\xfb\xff\xff\x6f\x00\x00\x00\x00\x01\x00\x00\x08\x00\x00\x00\x00\xfe\xff\xff\x6f\x00\x00\x00\x00\x50\x04\x00\x00\x00\x00\x00\x00\xff\xff\xff\x6f\x00\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00\xf0\xff\xff\x6f\x00\x00\x00\x00\x3c\x04\x00\x00\x00\x00\x00\x00\xf9\xff\xff\x6f\x00\x00\x00\x00\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"),
+Section(".got", 0x1FF90, "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd0\x05\x00\x00\x00\x00\x00\x00\xd0\x05\x00\x00\x00\x00\x00\x00\xd0\x05\x00\x00\x00\x00\x00\x00\xd0\x05\x00\x00\x00\x00\x00\x00\xd0\x05\x00\x00\x00\x00\x00\x00\xa0\xfd\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x54\x07\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"),
+Section(".data", 0x20000, "\x00\x00\x00\x00\x00\x00\x00\x00\x08\x00\x02\x00\x00\x00\x00\x00"),
+Section(".init_array", 0x1FD90, "\x50\x07\x00\x00\x00\x00\x00\x00"),
+Section(".text", 0x640, "\x1f\x20\x03\xd5\x1d\x00\x80\xd2\x1e\x00\x80\xd2\xe5\x03\x00\xaa\xe1\x03\x40\xf9\xe2\x23\x00\x91\xe6\x03\x00\x91\xe0\x00\x00\xf0\x00\xf8\x47\xf9\x03\x00\x80\xd2\x04\x00\x80\xd2\xe1\xff\xff\x97\xf0\xff\xff\x97\xe0\x00\x00\xf0\x00\xf4\x47\xf9\x40\x00\x00\xb4\xe8\xff\xff\x17\xc0\x03\x5f\xd6\x1f\x20\x03\xd5\x1f\x20\x03\xd5\x00\x01\x00\x90\x00\x40\x00\x91\x01\x01\x00\x90\x21\x40\x00\x91\x3f\x00\x00\xeb\xc0\x00\x00\x54\xe1\x00\x00\xf0\x21\xec\x47\xf9\x61\x00\x00\xb4\xf0\x03\x01\xaa\x00\x02\x1f\xd6\xc0\x03\x5f\xd6\x00\x01\x00\x90\x00\x40\x00\x91\x01\x01\x00\x90\x21\x40\x00\x91\x21\x00\x00\xcb\x22\xfc\x7f\xd3\x41\x0c\x81\x8b\x21\xfc\x41\x93\xc1\x00\x00\xb4\xe2\x00\x00\xf0\x42\xfc\x47\xf9\x62\x00\x00\xb4\xf0\x03\x02\xaa\x00\x02\x1f\xd6\xc0\x03\x5f\xd6\x1f\x20\x03\xd5\xfd\x7b\xbe\xa9\xfd\x03\x00\x91\xf3\x0b\x00\xf9\x13\x01\x00\x90\x60\x42\x40\x39\x40\x01\x00\x35\xe0\x00\x00\xf0\x00\xf0\x47\xf9\x80\x00\x00\xb4\x00\x01\x00\x90\x00\x04\x40\xf9\xb5\xff\xff\x97\xd8\xff\xff\x97\x20\x00\x80\x52\x60\x42\x00\x39\xf3\x0b\x40\xf9\xfd\x7b\xc2\xa8\xc0\x03\x5f\xd6\x1f\x20\x03\xd5\x1f\x20\x03\xd5\xdc\xff\xff\x17\xfd\x7b\xbc\xa9\xfd\x03\x00\x91\x80\x02\x80\xd2\xac\xff\xff\x97\xe0\x0f\x00\xf9\xe0\x0f\x40\xf9\x81\x01\x80\x52\x01\x00\x00\xb9\xe0\x0f\x40\xf9\xe0\x13\x00\xf9\xe0\x13\x40\xf9\x00\x04\x00\x91\xe0\x17\x00\xf9\x00\x01\x80\xd2\xa1\xff\xff\x97\xe0\x1b\x00\xf9\xe0\x1b\x40\xf9\xe1\x17\x40\xf9\x01\x00\x00\xf9\xe0\x1b\x40\xf9\x00\x00\x40\xf9\xe0\x1f\x00\xf9\x00\x00\x80\x52\xfd\x7b\xc4\xa8\xc0\x03\x5f\xd6")]),
+Memmap([Annotation(Region(0x0,0x8BB), Attr("segment","02 0 2236")),
+Annotation(Region(0x640,0x673), Attr("symbol","_start")),
+Annotation(Region(0x0,0xF9), Attr("section",".shstrtab")),
+Annotation(Region(0x0,0x242), Attr("section",".strtab")),
+Annotation(Region(0x0,0x827), Attr("section",".symtab")),
+Annotation(Region(0x0,0x2A), Attr("section",".comment")),
+Annotation(Region(0x238,0x252), Attr("section",".interp")),
+Annotation(Region(0x254,0x277), Attr("section",".note.gnu.build-id")),
+Annotation(Region(0x278,0x297), Attr("section",".note.ABI-tag")),
+Annotation(Region(0x298,0x2B3), Attr("section",".gnu.hash")),
+Annotation(Region(0x2B8,0x3A7), Attr("section",".dynsym")),
+Annotation(Region(0x3A8,0x43B), Attr("section",".dynstr")),
+Annotation(Region(0x43C,0x44F), Attr("section",".gnu.version")),
+Annotation(Region(0x450,0x47F), Attr("section",".gnu.version_r")),
+Annotation(Region(0x480,0x53F), Attr("section",".rela.dyn")),
+Annotation(Region(0x540,0x5B7), Attr("section",".rela.plt")),
+Annotation(Region(0x5B8,0x5CF), Attr("section",".init")),
+Annotation(Region(0x5D0,0x63F), Attr("section",".plt")),
+Annotation(Region(0x5B8,0x5CF), Attr("code-region","()")),
+Annotation(Region(0x5D0,0x63F), Attr("code-region","()")),
+Annotation(Region(0x640,0x673), Attr("symbol-info","_start 0x640 52")),
+Annotation(Region(0x674,0x687), Attr("symbol","call_weak_fn")),
+Annotation(Region(0x674,0x687), Attr("symbol-info","call_weak_fn 0x674 20")),
+Annotation(Region(0x754,0x7B7), Attr("symbol","main")),
+Annotation(Region(0x754,0x7B7), Attr("symbol-info","main 0x754 100")),
+Annotation(Region(0x7B8,0x7CB), Attr("section",".fini")),
+Annotation(Region(0x7CC,0x7CF), Attr("section",".rodata")),
+Annotation(Region(0x7D0,0x80B), Attr("section",".eh_frame_hdr")),
+Annotation(Region(0x810,0x8BB), Attr("section",".eh_frame")),
+Annotation(Region(0x1FD90,0x2000F), Attr("segment","03 0x1FD90 648")),
+Annotation(Region(0x1FD98,0x1FD9F), Attr("section",".fini_array")),
+Annotation(Region(0x1FDA0,0x1FF8F), Attr("section",".dynamic")),
+Annotation(Region(0x1FF90,0x1FFFF), Attr("section",".got")),
+Annotation(Region(0x20000,0x2000F), Attr("section",".data")),
+Annotation(Region(0x1FD90,0x1FD97), Attr("section",".init_array")),
+Annotation(Region(0x640,0x7B7), Attr("section",".text")),
+Annotation(Region(0x640,0x7B7), Attr("code-region","()")),
+Annotation(Region(0x7B8,0x7CB), Attr("code-region","()"))]),
+Program(Tid(1_768, "%000006e8"), Attrs([]),
+ Subs([Sub(Tid(1_715, "@__cxa_finalize"), Attrs([Attr("address","0x600"),
+Attr("stub","()"), Attr("c.proto","signed (*)(void)")]), "__cxa_finalize",
+ Args([Arg(Tid(1_769, "%000006e9"), Attrs([Attr("c.data","Top:u32"),
+Attr("c.layout","[signed : 32]"), Attr("c.type","signed")]),
+ Var("__cxa_finalize_result",Imm(32)), LOW(32,Var("R0",Imm(64))), Out())]),
+Blks([Blk(Tid(1_051, "@__cxa_finalize"), Attrs([Attr("address","0x600")]),
+ Phis([]), Defs([Def(Tid(1_315, "%00000523"), Attrs([Attr("address","0x600"),
+Attr("insn","adrp x16, #126976")]), Var("R16",Imm(64)), Int(126976,64)),
+Def(Tid(1_322, "%0000052a"), Attrs([Attr("address","0x604"),
+Attr("insn","ldr x17, [x16, #0xfb0]")]), Var("R17",Imm(64)),
+Load(Var("mem",Mem(64,8)),PLUS(Var("R16",Imm(64)),Int(4016,64)),LittleEndian(),64)),
+Def(Tid(1_328, "%00000530"), Attrs([Attr("address","0x608"),
+Attr("insn","add x16, x16, #0xfb0")]), Var("R16",Imm(64)),
+PLUS(Var("R16",Imm(64)),Int(4016,64)))]), Jmps([Call(Tid(1_333, "%00000535"),
+ Attrs([Attr("address","0x60C"), Attr("insn","br x17")]), Int(1,1),
+(Indirect(Var("R17",Imm(64))),))]))])),
+Sub(Tid(1_716, "@__do_global_dtors_aux"), Attrs([Attr("address","0x700"),
+Attr("c.proto","signed (*)(void)")]), "__do_global_dtors_aux",
+ Args([Arg(Tid(1_770, "%000006ea"), Attrs([Attr("c.data","Top:u32"),
+Attr("c.layout","[signed : 32]"), Attr("c.type","signed")]),
+ Var("__do_global_dtors_aux_result",Imm(32)), LOW(32,Var("R0",Imm(64))),
+Out())]), Blks([Blk(Tid(709, "@__do_global_dtors_aux"),
+ Attrs([Attr("address","0x700")]), Phis([]), Defs([Def(Tid(713, "%000002c9"),
+ Attrs([Attr("address","0x700"),
+Attr("insn","stp x29, x30, [sp, #-0x20]!")]), Var("#3",Imm(64)),
+PLUS(Var("R31",Imm(64)),Int(18446744073709551584,64))),
+Def(Tid(719, "%000002cf"), Attrs([Attr("address","0x700"),
+Attr("insn","stp x29, x30, [sp, #-0x20]!")]), Var("mem",Mem(64,8)),
+Store(Var("mem",Mem(64,8)),Var("#3",Imm(64)),Var("R29",Imm(64)),LittleEndian(),64)),
+Def(Tid(725, "%000002d5"), Attrs([Attr("address","0x700"),
+Attr("insn","stp x29, x30, [sp, #-0x20]!")]), Var("mem",Mem(64,8)),
+Store(Var("mem",Mem(64,8)),PLUS(Var("#3",Imm(64)),Int(8,64)),Var("R30",Imm(64)),LittleEndian(),64)),
+Def(Tid(729, "%000002d9"), Attrs([Attr("address","0x700"),
+Attr("insn","stp x29, x30, [sp, #-0x20]!")]), Var("R31",Imm(64)),
+Var("#3",Imm(64))), Def(Tid(735, "%000002df"),
+ Attrs([Attr("address","0x704"), Attr("insn","mov x29, sp")]),
+ Var("R29",Imm(64)), Var("R31",Imm(64))), Def(Tid(743, "%000002e7"),
+ Attrs([Attr("address","0x708"), Attr("insn","str x19, [sp, #0x10]")]),
+ Var("mem",Mem(64,8)),
+Store(Var("mem",Mem(64,8)),PLUS(Var("R31",Imm(64)),Int(16,64)),Var("R19",Imm(64)),LittleEndian(),64)),
+Def(Tid(748, "%000002ec"), Attrs([Attr("address","0x70C"),
+Attr("insn","adrp x19, #131072")]), Var("R19",Imm(64)), Int(131072,64)),
+Def(Tid(755, "%000002f3"), Attrs([Attr("address","0x710"),
+Attr("insn","ldrb w0, [x19, #0x10]")]), Var("R0",Imm(64)),
+UNSIGNED(64,Load(Var("mem",Mem(64,8)),PLUS(Var("R19",Imm(64)),Int(16,64)),LittleEndian(),8)))]),
+Jmps([Goto(Tid(762, "%000002fa"), Attrs([Attr("address","0x714"),
+Attr("insn","cbnz w0, #0x28")]),
+ NEQ(Extract(31,0,Var("R0",Imm(64))),Int(0,32)),
+Direct(Tid(760, "%000002f8"))), Goto(Tid(1_758, "%000006de"), Attrs([]),
+ Int(1,1), Direct(Tid(996, "%000003e4")))])), Blk(Tid(996, "%000003e4"),
+ Attrs([Attr("address","0x718")]), Phis([]), Defs([Def(Tid(999, "%000003e7"),
+ Attrs([Attr("address","0x718"), Attr("insn","adrp x0, #126976")]),
+ Var("R0",Imm(64)), Int(126976,64)), Def(Tid(1_006, "%000003ee"),
+ Attrs([Attr("address","0x71C"), Attr("insn","ldr x0, [x0, #0xfe0]")]),
+ Var("R0",Imm(64)),
+Load(Var("mem",Mem(64,8)),PLUS(Var("R0",Imm(64)),Int(4064,64)),LittleEndian(),64))]),
+Jmps([Goto(Tid(1_012, "%000003f4"), Attrs([Attr("address","0x720"),
+Attr("insn","cbz x0, #0x10")]), EQ(Var("R0",Imm(64)),Int(0,64)),
+Direct(Tid(1_010, "%000003f2"))), Goto(Tid(1_759, "%000006df"), Attrs([]),
+ Int(1,1), Direct(Tid(1_035, "%0000040b")))])), Blk(Tid(1_035, "%0000040b"),
+ Attrs([Attr("address","0x724")]), Phis([]),
+Defs([Def(Tid(1_038, "%0000040e"), Attrs([Attr("address","0x724"),
+Attr("insn","adrp x0, #131072")]), Var("R0",Imm(64)), Int(131072,64)),
+Def(Tid(1_045, "%00000415"), Attrs([Attr("address","0x728"),
+Attr("insn","ldr x0, [x0, #0x8]")]), Var("R0",Imm(64)),
+Load(Var("mem",Mem(64,8)),PLUS(Var("R0",Imm(64)),Int(8,64)),LittleEndian(),64)),
+Def(Tid(1_050, "%0000041a"), Attrs([Attr("address","0x72C"),
+Attr("insn","bl #-0x12c")]), Var("R30",Imm(64)), Int(1840,64))]),
+Jmps([Call(Tid(1_053, "%0000041d"), Attrs([Attr("address","0x72C"),
+Attr("insn","bl #-0x12c")]), Int(1,1),
+(Direct(Tid(1_715, "@__cxa_finalize")),Direct(Tid(1_010, "%000003f2"))))])),
+Blk(Tid(1_010, "%000003f2"), Attrs([Attr("address","0x730")]), Phis([]),
+Defs([Def(Tid(1_018, "%000003fa"), Attrs([Attr("address","0x730"),
+Attr("insn","bl #-0xa0")]), Var("R30",Imm(64)), Int(1844,64))]),
+Jmps([Call(Tid(1_020, "%000003fc"), Attrs([Attr("address","0x730"),
+Attr("insn","bl #-0xa0")]), Int(1,1),
+(Direct(Tid(1_729, "@deregister_tm_clones")),Direct(Tid(1_022, "%000003fe"))))])),
+Blk(Tid(1_022, "%000003fe"), Attrs([Attr("address","0x734")]), Phis([]),
+Defs([Def(Tid(1_025, "%00000401"), Attrs([Attr("address","0x734"),
+Attr("insn","mov w0, #0x1")]), Var("R0",Imm(64)), Int(1,64)),
+Def(Tid(1_033, "%00000409"), Attrs([Attr("address","0x738"),
+Attr("insn","strb w0, [x19, #0x10]")]), Var("mem",Mem(64,8)),
+Store(Var("mem",Mem(64,8)),PLUS(Var("R19",Imm(64)),Int(16,64)),Extract(7,0,Var("R0",Imm(64))),LittleEndian(),8))]),
+Jmps([Goto(Tid(1_760, "%000006e0"), Attrs([]), Int(1,1),
+Direct(Tid(760, "%000002f8")))])), Blk(Tid(760, "%000002f8"),
+ Attrs([Attr("address","0x73C")]), Phis([]), Defs([Def(Tid(770, "%00000302"),
+ Attrs([Attr("address","0x73C"), Attr("insn","ldr x19, [sp, #0x10]")]),
+ Var("R19",Imm(64)),
+Load(Var("mem",Mem(64,8)),PLUS(Var("R31",Imm(64)),Int(16,64)),LittleEndian(),64)),
+Def(Tid(777, "%00000309"), Attrs([Attr("address","0x740"),
+Attr("insn","ldp x29, x30, [sp], #0x20")]), Var("R29",Imm(64)),
+Load(Var("mem",Mem(64,8)),Var("R31",Imm(64)),LittleEndian(),64)),
+Def(Tid(782, "%0000030e"), Attrs([Attr("address","0x740"),
+Attr("insn","ldp x29, x30, [sp], #0x20")]), Var("R30",Imm(64)),
+Load(Var("mem",Mem(64,8)),PLUS(Var("R31",Imm(64)),Int(8,64)),LittleEndian(),64)),
+Def(Tid(786, "%00000312"), Attrs([Attr("address","0x740"),
+Attr("insn","ldp x29, x30, [sp], #0x20")]), Var("R31",Imm(64)),
+PLUS(Var("R31",Imm(64)),Int(32,64)))]), Jmps([Call(Tid(791, "%00000317"),
+ Attrs([Attr("address","0x744"), Attr("insn","ret")]), Int(1,1),
+(Indirect(Var("R30",Imm(64))),))]))])), Sub(Tid(1_720, "@__libc_start_main"),
+ Attrs([Attr("address","0x5F0"), Attr("stub","()"),
+Attr("c.proto","signed (*)(signed (*)(signed , char** , char** );* main, signed , char** , \nvoid* auxv)")]),
+ "__libc_start_main", Args([Arg(Tid(1_771, "%000006eb"),
+ Attrs([Attr("c.data","Top:u64 ptr ptr"),
+Attr("c.layout","**[<undef> : 64]"),
+Attr("c.type","signed (*)(signed , char** , char** );*")]),
+ Var("__libc_start_main_main",Imm(64)), Var("R0",Imm(64)), In()),
+Arg(Tid(1_772, "%000006ec"), Attrs([Attr("c.data","Top:u32"),
+Attr("c.layout","[signed : 32]"), Attr("c.type","signed")]),
+ Var("__libc_start_main_arg2",Imm(32)), LOW(32,Var("R1",Imm(64))), In()),
+Arg(Tid(1_773, "%000006ed"), Attrs([Attr("c.data","Top:u8 ptr ptr"),
+Attr("c.layout","**[char : 8]"), Attr("c.type","char**")]),
+ Var("__libc_start_main_arg3",Imm(64)), Var("R2",Imm(64)), Both()),
+Arg(Tid(1_774, "%000006ee"), Attrs([Attr("c.data","{} ptr"),
+Attr("c.layout","*[<undef> : 8]"), Attr("c.type","void*")]),
+ Var("__libc_start_main_auxv",Imm(64)), Var("R3",Imm(64)), Both()),
+Arg(Tid(1_775, "%000006ef"), Attrs([Attr("c.data","Top:u32"),
+Attr("c.layout","[signed : 32]"), Attr("c.type","signed")]),
+ Var("__libc_start_main_result",Imm(32)), LOW(32,Var("R0",Imm(64))),
+Out())]), Blks([Blk(Tid(542, "@__libc_start_main"),
+ Attrs([Attr("address","0x5F0")]), Phis([]),
+Defs([Def(Tid(1_293, "%0000050d"), Attrs([Attr("address","0x5F0"),
+Attr("insn","adrp x16, #126976")]), Var("R16",Imm(64)), Int(126976,64)),
+Def(Tid(1_300, "%00000514"), Attrs([Attr("address","0x5F4"),
+Attr("insn","ldr x17, [x16, #0xfa8]")]), Var("R17",Imm(64)),
+Load(Var("mem",Mem(64,8)),PLUS(Var("R16",Imm(64)),Int(4008,64)),LittleEndian(),64)),
+Def(Tid(1_306, "%0000051a"), Attrs([Attr("address","0x5F8"),
+Attr("insn","add x16, x16, #0xfa8")]), Var("R16",Imm(64)),
+PLUS(Var("R16",Imm(64)),Int(4008,64)))]), Jmps([Call(Tid(1_311, "%0000051f"),
+ Attrs([Attr("address","0x5FC"), Attr("insn","br x17")]), Int(1,1),
+(Indirect(Var("R17",Imm(64))),))]))])), Sub(Tid(1_721, "@_fini"),
+ Attrs([Attr("address","0x7B8"), Attr("c.proto","signed (*)(void)")]),
+ "_fini", Args([Arg(Tid(1_776, "%000006f0"), Attrs([Attr("c.data","Top:u32"),
+Attr("c.layout","[signed : 32]"), Attr("c.type","signed")]),
+ Var("_fini_result",Imm(32)), LOW(32,Var("R0",Imm(64))), Out())]),
+Blks([Blk(Tid(50, "@_fini"), Attrs([Attr("address","0x7B8")]), Phis([]),
+Defs([Def(Tid(56, "%00000038"), Attrs([Attr("address","0x7BC"),
+Attr("insn","stp x29, x30, [sp, #-0x10]!")]), Var("#0",Imm(64)),
+PLUS(Var("R31",Imm(64)),Int(18446744073709551600,64))),
+Def(Tid(62, "%0000003e"), Attrs([Attr("address","0x7BC"),
+Attr("insn","stp x29, x30, [sp, #-0x10]!")]), Var("mem",Mem(64,8)),
+Store(Var("mem",Mem(64,8)),Var("#0",Imm(64)),Var("R29",Imm(64)),LittleEndian(),64)),
+Def(Tid(68, "%00000044"), Attrs([Attr("address","0x7BC"),
+Attr("insn","stp x29, x30, [sp, #-0x10]!")]), Var("mem",Mem(64,8)),
+Store(Var("mem",Mem(64,8)),PLUS(Var("#0",Imm(64)),Int(8,64)),Var("R30",Imm(64)),LittleEndian(),64)),
+Def(Tid(72, "%00000048"), Attrs([Attr("address","0x7BC"),
+Attr("insn","stp x29, x30, [sp, #-0x10]!")]), Var("R31",Imm(64)),
+Var("#0",Imm(64))), Def(Tid(78, "%0000004e"), Attrs([Attr("address","0x7C0"),
+Attr("insn","mov x29, sp")]), Var("R29",Imm(64)), Var("R31",Imm(64))),
+Def(Tid(85, "%00000055"), Attrs([Attr("address","0x7C4"),
+Attr("insn","ldp x29, x30, [sp], #0x10")]), Var("R29",Imm(64)),
+Load(Var("mem",Mem(64,8)),Var("R31",Imm(64)),LittleEndian(),64)),
+Def(Tid(90, "%0000005a"), Attrs([Attr("address","0x7C4"),
+Attr("insn","ldp x29, x30, [sp], #0x10")]), Var("R30",Imm(64)),
+Load(Var("mem",Mem(64,8)),PLUS(Var("R31",Imm(64)),Int(8,64)),LittleEndian(),64)),
+Def(Tid(94, "%0000005e"), Attrs([Attr("address","0x7C4"),
+Attr("insn","ldp x29, x30, [sp], #0x10")]), Var("R31",Imm(64)),
+PLUS(Var("R31",Imm(64)),Int(16,64)))]), Jmps([Call(Tid(99, "%00000063"),
+ Attrs([Attr("address","0x7C8"), Attr("insn","ret")]), Int(1,1),
+(Indirect(Var("R30",Imm(64))),))]))])), Sub(Tid(1_722, "@_init"),
+ Attrs([Attr("address","0x5B8"), Attr("c.proto","signed (*)(void)")]),
+ "_init", Args([Arg(Tid(1_777, "%000006f1"), Attrs([Attr("c.data","Top:u32"),
+Attr("c.layout","[signed : 32]"), Attr("c.type","signed")]),
+ Var("_init_result",Imm(32)), LOW(32,Var("R0",Imm(64))), Out())]),
+Blks([Blk(Tid(1_528, "@_init"), Attrs([Attr("address","0x5B8")]), Phis([]),
+Defs([Def(Tid(1_534, "%000005fe"), Attrs([Attr("address","0x5BC"),
+Attr("insn","stp x29, x30, [sp, #-0x10]!")]), Var("#6",Imm(64)),
+PLUS(Var("R31",Imm(64)),Int(18446744073709551600,64))),
+Def(Tid(1_540, "%00000604"), Attrs([Attr("address","0x5BC"),
+Attr("insn","stp x29, x30, [sp, #-0x10]!")]), Var("mem",Mem(64,8)),
+Store(Var("mem",Mem(64,8)),Var("#6",Imm(64)),Var("R29",Imm(64)),LittleEndian(),64)),
+Def(Tid(1_546, "%0000060a"), Attrs([Attr("address","0x5BC"),
+Attr("insn","stp x29, x30, [sp, #-0x10]!")]), Var("mem",Mem(64,8)),
+Store(Var("mem",Mem(64,8)),PLUS(Var("#6",Imm(64)),Int(8,64)),Var("R30",Imm(64)),LittleEndian(),64)),
+Def(Tid(1_550, "%0000060e"), Attrs([Attr("address","0x5BC"),
+Attr("insn","stp x29, x30, [sp, #-0x10]!")]), Var("R31",Imm(64)),
+Var("#6",Imm(64))), Def(Tid(1_556, "%00000614"),
+ Attrs([Attr("address","0x5C0"), Attr("insn","mov x29, sp")]),
+ Var("R29",Imm(64)), Var("R31",Imm(64))), Def(Tid(1_561, "%00000619"),
+ Attrs([Attr("address","0x5C4"), Attr("insn","bl #0xb0")]),
+ Var("R30",Imm(64)), Int(1480,64))]), Jmps([Call(Tid(1_563, "%0000061b"),
+ Attrs([Attr("address","0x5C4"), Attr("insn","bl #0xb0")]), Int(1,1),
+(Direct(Tid(1_727, "@call_weak_fn")),Direct(Tid(1_565, "%0000061d"))))])),
+Blk(Tid(1_565, "%0000061d"), Attrs([Attr("address","0x5C8")]), Phis([]),
+Defs([Def(Tid(1_570, "%00000622"), Attrs([Attr("address","0x5C8"),
+Attr("insn","ldp x29, x30, [sp], #0x10")]), Var("R29",Imm(64)),
+Load(Var("mem",Mem(64,8)),Var("R31",Imm(64)),LittleEndian(),64)),
+Def(Tid(1_575, "%00000627"), Attrs([Attr("address","0x5C8"),
+Attr("insn","ldp x29, x30, [sp], #0x10")]), Var("R30",Imm(64)),
+Load(Var("mem",Mem(64,8)),PLUS(Var("R31",Imm(64)),Int(8,64)),LittleEndian(),64)),
+Def(Tid(1_579, "%0000062b"), Attrs([Attr("address","0x5C8"),
+Attr("insn","ldp x29, x30, [sp], #0x10")]), Var("R31",Imm(64)),
+PLUS(Var("R31",Imm(64)),Int(16,64)))]), Jmps([Call(Tid(1_584, "%00000630"),
+ Attrs([Attr("address","0x5CC"), Attr("insn","ret")]), Int(1,1),
+(Indirect(Var("R30",Imm(64))),))]))])), Sub(Tid(1_723, "@_start"),
+ Attrs([Attr("address","0x640"), Attr("stub","()"), Attr("entry-point","()"),
+Attr("c.proto","signed (*)(void)")]), "_start",
+ Args([Arg(Tid(1_778, "%000006f2"), Attrs([Attr("c.data","Top:u32"),
+Attr("c.layout","[signed : 32]"), Attr("c.type","signed")]),
+ Var("_start_result",Imm(32)), LOW(32,Var("R0",Imm(64))), Out())]),
+Blks([Blk(Tid(479, "@_start"), Attrs([Attr("address","0x640")]), Phis([]),
+Defs([Def(Tid(484, "%000001e4"), Attrs([Attr("address","0x644"),
+Attr("insn","mov x29, #0x0")]), Var("R29",Imm(64)), Int(0,64)),
+Def(Tid(489, "%000001e9"), Attrs([Attr("address","0x648"),
+Attr("insn","mov x30, #0x0")]), Var("R30",Imm(64)), Int(0,64)),
+Def(Tid(495, "%000001ef"), Attrs([Attr("address","0x64C"),
+Attr("insn","mov x5, x0")]), Var("R5",Imm(64)), Var("R0",Imm(64))),
+Def(Tid(502, "%000001f6"), Attrs([Attr("address","0x650"),
+Attr("insn","ldr x1, [sp]")]), Var("R1",Imm(64)),
+Load(Var("mem",Mem(64,8)),Var("R31",Imm(64)),LittleEndian(),64)),
+Def(Tid(508, "%000001fc"), Attrs([Attr("address","0x654"),
+Attr("insn","add x2, sp, #0x8")]), Var("R2",Imm(64)),
+PLUS(Var("R31",Imm(64)),Int(8,64))), Def(Tid(514, "%00000202"),
+ Attrs([Attr("address","0x658"), Attr("insn","mov x6, sp")]),
+ Var("R6",Imm(64)), Var("R31",Imm(64))), Def(Tid(519, "%00000207"),
+ Attrs([Attr("address","0x65C"), Attr("insn","adrp x0, #126976")]),
+ Var("R0",Imm(64)), Int(126976,64)), Def(Tid(526, "%0000020e"),
+ Attrs([Attr("address","0x660"), Attr("insn","ldr x0, [x0, #0xff0]")]),
+ Var("R0",Imm(64)),
+Load(Var("mem",Mem(64,8)),PLUS(Var("R0",Imm(64)),Int(4080,64)),LittleEndian(),64)),
+Def(Tid(531, "%00000213"), Attrs([Attr("address","0x664"),
+Attr("insn","mov x3, #0x0")]), Var("R3",Imm(64)), Int(0,64)),
+Def(Tid(536, "%00000218"), Attrs([Attr("address","0x668"),
+Attr("insn","mov x4, #0x0")]), Var("R4",Imm(64)), Int(0,64)),
+Def(Tid(541, "%0000021d"), Attrs([Attr("address","0x66C"),
+Attr("insn","bl #-0x7c")]), Var("R30",Imm(64)), Int(1648,64))]),
+Jmps([Call(Tid(544, "%00000220"), Attrs([Attr("address","0x66C"),
+Attr("insn","bl #-0x7c")]), Int(1,1),
+(Direct(Tid(1_720, "@__libc_start_main")),Direct(Tid(546, "%00000222"))))])),
+Blk(Tid(546, "%00000222"), Attrs([Attr("address","0x670")]), Phis([]),
+Defs([Def(Tid(549, "%00000225"), Attrs([Attr("address","0x670"),
+Attr("insn","bl #-0x40")]), Var("R30",Imm(64)), Int(1652,64))]),
+Jmps([Call(Tid(552, "%00000228"), Attrs([Attr("address","0x670"),
+Attr("insn","bl #-0x40")]), Int(1,1),
+(Direct(Tid(1_726, "@abort")),Direct(Tid(1_761, "%000006e1"))))])),
+Blk(Tid(1_761, "%000006e1"), Attrs([]), Phis([]), Defs([]),
+Jmps([Call(Tid(1_762, "%000006e2"), Attrs([]), Int(1,1),
+(Direct(Tid(1_727, "@call_weak_fn")),))]))])), Sub(Tid(1_726, "@abort"),
+ Attrs([Attr("address","0x630"), Attr("stub","()"), Attr("noreturn","()"),
+Attr("c.proto","void (*)(void)")]), "abort", Args([]),
+Blks([Blk(Tid(550, "@abort"), Attrs([Attr("address","0x630")]), Phis([]),
+Defs([Def(Tid(1_381, "%00000565"), Attrs([Attr("address","0x630"),
+Attr("insn","adrp x16, #126976")]), Var("R16",Imm(64)), Int(126976,64)),
+Def(Tid(1_388, "%0000056c"), Attrs([Attr("address","0x634"),
+Attr("insn","ldr x17, [x16, #0xfc8]")]), Var("R17",Imm(64)),
+Load(Var("mem",Mem(64,8)),PLUS(Var("R16",Imm(64)),Int(4040,64)),LittleEndian(),64)),
+Def(Tid(1_394, "%00000572"), Attrs([Attr("address","0x638"),
+Attr("insn","add x16, x16, #0xfc8")]), Var("R16",Imm(64)),
+PLUS(Var("R16",Imm(64)),Int(4040,64)))]), Jmps([Call(Tid(1_399, "%00000577"),
+ Attrs([Attr("address","0x63C"), Attr("insn","br x17")]), Int(1,1),
+(Indirect(Var("R17",Imm(64))),))]))])), Sub(Tid(1_727, "@call_weak_fn"),
+ Attrs([Attr("address","0x674"), Attr("c.proto","signed (*)(void)")]),
+ "call_weak_fn", Args([Arg(Tid(1_779, "%000006f3"),
+ Attrs([Attr("c.data","Top:u32"), Attr("c.layout","[signed : 32]"),
+Attr("c.type","signed")]), Var("call_weak_fn_result",Imm(32)),
+LOW(32,Var("R0",Imm(64))), Out())]), Blks([Blk(Tid(554, "@call_weak_fn"),
+ Attrs([Attr("address","0x674")]), Phis([]), Defs([Def(Tid(557, "%0000022d"),
+ Attrs([Attr("address","0x674"), Attr("insn","adrp x0, #126976")]),
+ Var("R0",Imm(64)), Int(126976,64)), Def(Tid(564, "%00000234"),
+ Attrs([Attr("address","0x678"), Attr("insn","ldr x0, [x0, #0xfe8]")]),
+ Var("R0",Imm(64)),
+Load(Var("mem",Mem(64,8)),PLUS(Var("R0",Imm(64)),Int(4072,64)),LittleEndian(),64))]),
+Jmps([Goto(Tid(570, "%0000023a"), Attrs([Attr("address","0x67C"),
+Attr("insn","cbz x0, #0x8")]), EQ(Var("R0",Imm(64)),Int(0,64)),
+Direct(Tid(568, "%00000238"))), Goto(Tid(1_763, "%000006e3"), Attrs([]),
+ Int(1,1), Direct(Tid(1_115, "%0000045b")))])), Blk(Tid(568, "%00000238"),
+ Attrs([Attr("address","0x684")]), Phis([]), Defs([]),
+Jmps([Call(Tid(576, "%00000240"), Attrs([Attr("address","0x684"),
+Attr("insn","ret")]), Int(1,1), (Indirect(Var("R30",Imm(64))),))])),
+Blk(Tid(1_115, "%0000045b"), Attrs([Attr("address","0x680")]), Phis([]),
+Defs([]), Jmps([Goto(Tid(1_118, "%0000045e"), Attrs([Attr("address","0x680"),
+Attr("insn","b #-0x60")]), Int(1,1),
+Direct(Tid(1_116, "@__gmon_start__")))])), Blk(Tid(1_116, "@__gmon_start__"),
+ Attrs([Attr("address","0x620")]), Phis([]),
+Defs([Def(Tid(1_359, "%0000054f"), Attrs([Attr("address","0x620"),
+Attr("insn","adrp x16, #126976")]), Var("R16",Imm(64)), Int(126976,64)),
+Def(Tid(1_366, "%00000556"), Attrs([Attr("address","0x624"),
+Attr("insn","ldr x17, [x16, #0xfc0]")]), Var("R17",Imm(64)),
+Load(Var("mem",Mem(64,8)),PLUS(Var("R16",Imm(64)),Int(4032,64)),LittleEndian(),64)),
+Def(Tid(1_372, "%0000055c"), Attrs([Attr("address","0x628"),
+Attr("insn","add x16, x16, #0xfc0")]), Var("R16",Imm(64)),
+PLUS(Var("R16",Imm(64)),Int(4032,64)))]), Jmps([Call(Tid(1_377, "%00000561"),
+ Attrs([Attr("address","0x62C"), Attr("insn","br x17")]), Int(1,1),
+(Indirect(Var("R17",Imm(64))),))]))])),
+Sub(Tid(1_729, "@deregister_tm_clones"), Attrs([Attr("address","0x690"),
+Attr("c.proto","signed (*)(void)")]), "deregister_tm_clones",
+ Args([Arg(Tid(1_780, "%000006f4"), Attrs([Attr("c.data","Top:u32"),
+Attr("c.layout","[signed : 32]"), Attr("c.type","signed")]),
+ Var("deregister_tm_clones_result",Imm(32)), LOW(32,Var("R0",Imm(64))),
+Out())]), Blks([Blk(Tid(582, "@deregister_tm_clones"),
+ Attrs([Attr("address","0x690")]), Phis([]), Defs([Def(Tid(585, "%00000249"),
+ Attrs([Attr("address","0x690"), Attr("insn","adrp x0, #131072")]),
+ Var("R0",Imm(64)), Int(131072,64)), Def(Tid(591, "%0000024f"),
+ Attrs([Attr("address","0x694"), Attr("insn","add x0, x0, #0x10")]),
+ Var("R0",Imm(64)), PLUS(Var("R0",Imm(64)),Int(16,64))),
+Def(Tid(596, "%00000254"), Attrs([Attr("address","0x698"),
+Attr("insn","adrp x1, #131072")]), Var("R1",Imm(64)), Int(131072,64)),
+Def(Tid(602, "%0000025a"), Attrs([Attr("address","0x69C"),
+Attr("insn","add x1, x1, #0x10")]), Var("R1",Imm(64)),
+PLUS(Var("R1",Imm(64)),Int(16,64))), Def(Tid(608, "%00000260"),
+ Attrs([Attr("address","0x6A0"), Attr("insn","cmp x1, x0")]),
+ Var("#1",Imm(64)), NOT(Var("R0",Imm(64)))), Def(Tid(613, "%00000265"),
+ Attrs([Attr("address","0x6A0"), Attr("insn","cmp x1, x0")]),
+ Var("#2",Imm(64)), PLUS(Var("R1",Imm(64)),NOT(Var("R0",Imm(64))))),
+Def(Tid(619, "%0000026b"), Attrs([Attr("address","0x6A0"),
+Attr("insn","cmp x1, x0")]), Var("VF",Imm(1)),
+NEQ(SIGNED(65,PLUS(Var("#2",Imm(64)),Int(1,64))),PLUS(PLUS(SIGNED(65,Var("R1",Imm(64))),SIGNED(65,Var("#1",Imm(64)))),Int(1,65)))),
+Def(Tid(625, "%00000271"), Attrs([Attr("address","0x6A0"),
+Attr("insn","cmp x1, x0")]), Var("CF",Imm(1)),
+NEQ(UNSIGNED(65,PLUS(Var("#2",Imm(64)),Int(1,64))),PLUS(PLUS(UNSIGNED(65,Var("R1",Imm(64))),UNSIGNED(65,Var("#1",Imm(64)))),Int(1,65)))),
+Def(Tid(629, "%00000275"), Attrs([Attr("address","0x6A0"),
+Attr("insn","cmp x1, x0")]), Var("ZF",Imm(1)),
+EQ(PLUS(Var("#2",Imm(64)),Int(1,64)),Int(0,64))), Def(Tid(633, "%00000279"),
+ Attrs([Attr("address","0x6A0"), Attr("insn","cmp x1, x0")]),
+ Var("NF",Imm(1)), Extract(63,63,PLUS(Var("#2",Imm(64)),Int(1,64))))]),
+Jmps([Goto(Tid(639, "%0000027f"), Attrs([Attr("address","0x6A4"),
+Attr("insn","b.eq #0x18")]), EQ(Var("ZF",Imm(1)),Int(1,1)),
+Direct(Tid(637, "%0000027d"))), Goto(Tid(1_764, "%000006e4"), Attrs([]),
+ Int(1,1), Direct(Tid(1_085, "%0000043d")))])), Blk(Tid(1_085, "%0000043d"),
+ Attrs([Attr("address","0x6A8")]), Phis([]),
+Defs([Def(Tid(1_088, "%00000440"), Attrs([Attr("address","0x6A8"),
+Attr("insn","adrp x1, #126976")]), Var("R1",Imm(64)), Int(126976,64)),
+Def(Tid(1_095, "%00000447"), Attrs([Attr("address","0x6AC"),
+Attr("insn","ldr x1, [x1, #0xfd8]")]), Var("R1",Imm(64)),
+Load(Var("mem",Mem(64,8)),PLUS(Var("R1",Imm(64)),Int(4056,64)),LittleEndian(),64))]),
+Jmps([Goto(Tid(1_100, "%0000044c"), Attrs([Attr("address","0x6B0"),
+Attr("insn","cbz x1, #0xc")]), EQ(Var("R1",Imm(64)),Int(0,64)),
+Direct(Tid(637, "%0000027d"))), Goto(Tid(1_765, "%000006e5"), Attrs([]),
+ Int(1,1), Direct(Tid(1_104, "%00000450")))])), Blk(Tid(637, "%0000027d"),
+ Attrs([Attr("address","0x6BC")]), Phis([]), Defs([]),
+Jmps([Call(Tid(645, "%00000285"), Attrs([Attr("address","0x6BC"),
+Attr("insn","ret")]), Int(1,1), (Indirect(Var("R30",Imm(64))),))])),
+Blk(Tid(1_104, "%00000450"), Attrs([Attr("address","0x6B4")]), Phis([]),
+Defs([Def(Tid(1_108, "%00000454"), Attrs([Attr("address","0x6B4"),
+Attr("insn","mov x16, x1")]), Var("R16",Imm(64)), Var("R1",Imm(64)))]),
+Jmps([Call(Tid(1_113, "%00000459"), Attrs([Attr("address","0x6B8"),
+Attr("insn","br x16")]), Int(1,1), (Indirect(Var("R16",Imm(64))),))]))])),
+Sub(Tid(1_732, "@frame_dummy"), Attrs([Attr("address","0x750"),
+Attr("c.proto","signed (*)(void)")]), "frame_dummy",
+ Args([Arg(Tid(1_781, "%000006f5"), Attrs([Attr("c.data","Top:u32"),
+Attr("c.layout","[signed : 32]"), Attr("c.type","signed")]),
+ Var("frame_dummy_result",Imm(32)), LOW(32,Var("R0",Imm(64))), Out())]),
+Blks([Blk(Tid(797, "@frame_dummy"), Attrs([Attr("address","0x750")]),
+ Phis([]), Defs([]), Jmps([Call(Tid(799, "%0000031f"),
+ Attrs([Attr("address","0x750"), Attr("insn","b #-0x90")]), Int(1,1),
+(Direct(Tid(1_735, "@register_tm_clones")),))]))])), Sub(Tid(1_733, "@main"),
+ Attrs([Attr("address","0x754"),
+Attr("c.proto","signed (*)(signed argc,  const char** argv)")]), "main",
+ Args([Arg(Tid(1_782, "%000006f6"), Attrs([Attr("c.data","Top:u32"),
+Attr("c.layout","[signed : 32]"), Attr("c.type","signed")]),
+ Var("main_argc",Imm(32)), LOW(32,Var("R0",Imm(64))), In()),
+Arg(Tid(1_783, "%000006f7"), Attrs([Attr("c.data","Top:u8 ptr ptr"),
+Attr("c.layout","**[char : 8]"), Attr("c.type"," const char**")]),
+ Var("main_argv",Imm(64)), Var("R1",Imm(64)), Both()),
+Arg(Tid(1_784, "%000006f8"), Attrs([Attr("c.data","Top:u32"),
+Attr("c.layout","[signed : 32]"), Attr("c.type","signed")]),
+ Var("main_result",Imm(32)), LOW(32,Var("R0",Imm(64))), Out())]),
+Blks([Blk(Tid(801, "@main"), Attrs([Attr("address","0x754")]), Phis([]),
+Defs([Def(Tid(805, "%00000325"), Attrs([Attr("address","0x754"),
+Attr("insn","stp x29, x30, [sp, #-0x40]!")]), Var("#4",Imm(64)),
+PLUS(Var("R31",Imm(64)),Int(18446744073709551552,64))),
+Def(Tid(811, "%0000032b"), Attrs([Attr("address","0x754"),
+Attr("insn","stp x29, x30, [sp, #-0x40]!")]), Var("mem",Mem(64,8)),
+Store(Var("mem",Mem(64,8)),Var("#4",Imm(64)),Var("R29",Imm(64)),LittleEndian(),64)),
+Def(Tid(817, "%00000331"), Attrs([Attr("address","0x754"),
+Attr("insn","stp x29, x30, [sp, #-0x40]!")]), Var("mem",Mem(64,8)),
+Store(Var("mem",Mem(64,8)),PLUS(Var("#4",Imm(64)),Int(8,64)),Var("R30",Imm(64)),LittleEndian(),64)),
+Def(Tid(821, "%00000335"), Attrs([Attr("address","0x754"),
+Attr("insn","stp x29, x30, [sp, #-0x40]!")]), Var("R31",Imm(64)),
+Var("#4",Imm(64))), Def(Tid(827, "%0000033b"),
+ Attrs([Attr("address","0x758"), Attr("insn","mov x29, sp")]),
+ Var("R29",Imm(64)), Var("R31",Imm(64))), Def(Tid(832, "%00000340"),
+ Attrs([Attr("address","0x75C"), Attr("insn","mov x0, #0x14")]),
+ Var("R0",Imm(64)), Int(20,64)), Def(Tid(837, "%00000345"),
+ Attrs([Attr("address","0x760"), Attr("insn","bl #-0x150")]),
+ Var("R30",Imm(64)), Int(1892,64))]), Jmps([Call(Tid(840, "%00000348"),
+ Attrs([Attr("address","0x760"), Attr("insn","bl #-0x150")]), Int(1,1),
+(Direct(Tid(1_734, "@malloc")),Direct(Tid(842, "%0000034a"))))])),
+Blk(Tid(842, "%0000034a"), Attrs([Attr("address","0x764")]), Phis([]),
+Defs([Def(Tid(848, "%00000350"), Attrs([Attr("address","0x764"),
+Attr("insn","str x0, [sp, #0x18]")]), Var("mem",Mem(64,8)),
+Store(Var("mem",Mem(64,8)),PLUS(Var("R31",Imm(64)),Int(24,64)),Var("R0",Imm(64)),LittleEndian(),64)),
+Def(Tid(855, "%00000357"), Attrs([Attr("address","0x768"),
+Attr("insn","ldr x0, [sp, #0x18]")]), Var("R0",Imm(64)),
+Load(Var("mem",Mem(64,8)),PLUS(Var("R31",Imm(64)),Int(24,64)),LittleEndian(),64)),
+Def(Tid(860, "%0000035c"), Attrs([Attr("address","0x76C"),
+Attr("insn","mov w1, #0xc")]), Var("R1",Imm(64)), Int(12,64)),
+Def(Tid(868, "%00000364"), Attrs([Attr("address","0x770"),
+Attr("insn","str w1, [x0]")]), Var("mem",Mem(64,8)),
+Store(Var("mem",Mem(64,8)),Var("R0",Imm(64)),Extract(31,0,Var("R1",Imm(64))),LittleEndian(),32)),
+Def(Tid(875, "%0000036b"), Attrs([Attr("address","0x774"),
+Attr("insn","ldr x0, [sp, #0x18]")]), Var("R0",Imm(64)),
+Load(Var("mem",Mem(64,8)),PLUS(Var("R31",Imm(64)),Int(24,64)),LittleEndian(),64)),
+Def(Tid(883, "%00000373"), Attrs([Attr("address","0x778"),
+Attr("insn","str x0, [sp, #0x20]")]), Var("mem",Mem(64,8)),
+Store(Var("mem",Mem(64,8)),PLUS(Var("R31",Imm(64)),Int(32,64)),Var("R0",Imm(64)),LittleEndian(),64)),
+Def(Tid(890, "%0000037a"), Attrs([Attr("address","0x77C"),
+Attr("insn","ldr x0, [sp, #0x20]")]), Var("R0",Imm(64)),
+Load(Var("mem",Mem(64,8)),PLUS(Var("R31",Imm(64)),Int(32,64)),LittleEndian(),64)),
+Def(Tid(896, "%00000380"), Attrs([Attr("address","0x780"),
+Attr("insn","add x0, x0, #0x1")]), Var("R0",Imm(64)),
+PLUS(Var("R0",Imm(64)),Int(1,64))), Def(Tid(904, "%00000388"),
+ Attrs([Attr("address","0x784"), Attr("insn","str x0, [sp, #0x28]")]),
+ Var("mem",Mem(64,8)),
+Store(Var("mem",Mem(64,8)),PLUS(Var("R31",Imm(64)),Int(40,64)),Var("R0",Imm(64)),LittleEndian(),64)),
+Def(Tid(909, "%0000038d"), Attrs([Attr("address","0x788"),
+Attr("insn","mov x0, #0x8")]), Var("R0",Imm(64)), Int(8,64)),
+Def(Tid(914, "%00000392"), Attrs([Attr("address","0x78C"),
+Attr("insn","bl #-0x17c")]), Var("R30",Imm(64)), Int(1936,64))]),
+Jmps([Call(Tid(916, "%00000394"), Attrs([Attr("address","0x78C"),
+Attr("insn","bl #-0x17c")]), Int(1,1),
+(Direct(Tid(1_734, "@malloc")),Direct(Tid(918, "%00000396"))))])),
+Blk(Tid(918, "%00000396"), Attrs([Attr("address","0x790")]), Phis([]),
+Defs([Def(Tid(924, "%0000039c"), Attrs([Attr("address","0x790"),
+Attr("insn","str x0, [sp, #0x30]")]), Var("mem",Mem(64,8)),
+Store(Var("mem",Mem(64,8)),PLUS(Var("R31",Imm(64)),Int(48,64)),Var("R0",Imm(64)),LittleEndian(),64)),
+Def(Tid(931, "%000003a3"), Attrs([Attr("address","0x794"),
+Attr("insn","ldr x0, [sp, #0x30]")]), Var("R0",Imm(64)),
+Load(Var("mem",Mem(64,8)),PLUS(Var("R31",Imm(64)),Int(48,64)),LittleEndian(),64)),
+Def(Tid(938, "%000003aa"), Attrs([Attr("address","0x798"),
+Attr("insn","ldr x1, [sp, #0x28]")]), Var("R1",Imm(64)),
+Load(Var("mem",Mem(64,8)),PLUS(Var("R31",Imm(64)),Int(40,64)),LittleEndian(),64)),
+Def(Tid(946, "%000003b2"), Attrs([Attr("address","0x79C"),
+Attr("insn","str x1, [x0]")]), Var("mem",Mem(64,8)),
+Store(Var("mem",Mem(64,8)),Var("R0",Imm(64)),Var("R1",Imm(64)),LittleEndian(),64)),
+Def(Tid(953, "%000003b9"), Attrs([Attr("address","0x7A0"),
+Attr("insn","ldr x0, [sp, #0x30]")]), Var("R0",Imm(64)),
+Load(Var("mem",Mem(64,8)),PLUS(Var("R31",Imm(64)),Int(48,64)),LittleEndian(),64)),
+Def(Tid(960, "%000003c0"), Attrs([Attr("address","0x7A4"),
+Attr("insn","ldr x0, [x0]")]), Var("R0",Imm(64)),
+Load(Var("mem",Mem(64,8)),Var("R0",Imm(64)),LittleEndian(),64)),
+Def(Tid(968, "%000003c8"), Attrs([Attr("address","0x7A8"),
+Attr("insn","str x0, [sp, #0x38]")]), Var("mem",Mem(64,8)),
+Store(Var("mem",Mem(64,8)),PLUS(Var("R31",Imm(64)),Int(56,64)),Var("R0",Imm(64)),LittleEndian(),64)),
+Def(Tid(973, "%000003cd"), Attrs([Attr("address","0x7AC"),
+Attr("insn","mov w0, #0x0")]), Var("R0",Imm(64)), Int(0,64)),
+Def(Tid(980, "%000003d4"), Attrs([Attr("address","0x7B0"),
+Attr("insn","ldp x29, x30, [sp], #0x40")]), Var("R29",Imm(64)),
+Load(Var("mem",Mem(64,8)),Var("R31",Imm(64)),LittleEndian(),64)),
+Def(Tid(985, "%000003d9"), Attrs([Attr("address","0x7B0"),
+Attr("insn","ldp x29, x30, [sp], #0x40")]), Var("R30",Imm(64)),
+Load(Var("mem",Mem(64,8)),PLUS(Var("R31",Imm(64)),Int(8,64)),LittleEndian(),64)),
+Def(Tid(989, "%000003dd"), Attrs([Attr("address","0x7B0"),
+Attr("insn","ldp x29, x30, [sp], #0x40")]), Var("R31",Imm(64)),
+PLUS(Var("R31",Imm(64)),Int(64,64)))]), Jmps([Call(Tid(994, "%000003e2"),
+ Attrs([Attr("address","0x7B4"), Attr("insn","ret")]), Int(1,1),
+(Indirect(Var("R30",Imm(64))),))]))])), Sub(Tid(1_734, "@malloc"),
+ Attrs([Attr("address","0x610"), Attr("stub","()"), Attr("malloc","()"),
+Attr("c.proto","void* (*)(unsigned long size)")]), "malloc",
+ Args([Arg(Tid(1_785, "%000006f9"), Attrs([Attr("alloc-size","()"),
+Attr("c.data","Top:u64"), Attr("c.layout","[unsigned long : 64]"),
+Attr("c.type","unsigned long")]), Var("malloc_size",Imm(64)),
+Var("R0",Imm(64)), In()), Arg(Tid(1_786, "%000006fa"),
+ Attrs([Attr("warn-unused","()"), Attr("c.data","{} ptr"),
+Attr("c.layout","*[<undef> : 8]"), Attr("c.type","void*")]),
+ Var("malloc_result",Imm(64)), Var("R0",Imm(64)), Out())]),
+Blks([Blk(Tid(838, "@malloc"), Attrs([Attr("address","0x610")]), Phis([]),
+Defs([Def(Tid(1_337, "%00000539"), Attrs([Attr("address","0x610"),
+Attr("insn","adrp x16, #126976")]), Var("R16",Imm(64)), Int(126976,64)),
+Def(Tid(1_344, "%00000540"), Attrs([Attr("address","0x614"),
+Attr("insn","ldr x17, [x16, #0xfb8]")]), Var("R17",Imm(64)),
+Load(Var("mem",Mem(64,8)),PLUS(Var("R16",Imm(64)),Int(4024,64)),LittleEndian(),64)),
+Def(Tid(1_350, "%00000546"), Attrs([Attr("address","0x618"),
+Attr("insn","add x16, x16, #0xfb8")]), Var("R16",Imm(64)),
+PLUS(Var("R16",Imm(64)),Int(4024,64)))]), Jmps([Call(Tid(1_355, "%0000054b"),
+ Attrs([Attr("address","0x61C"), Attr("insn","br x17")]), Int(1,1),
+(Indirect(Var("R17",Imm(64))),))]))])),
+Sub(Tid(1_735, "@register_tm_clones"), Attrs([Attr("address","0x6C0"),
+Attr("c.proto","signed (*)(void)")]), "register_tm_clones",
+ Args([Arg(Tid(1_787, "%000006fb"), Attrs([Attr("c.data","Top:u32"),
+Attr("c.layout","[signed : 32]"), Attr("c.type","signed")]),
+ Var("register_tm_clones_result",Imm(32)), LOW(32,Var("R0",Imm(64))),
+Out())]), Blks([Blk(Tid(647, "@register_tm_clones"),
+ Attrs([Attr("address","0x6C0")]), Phis([]), Defs([Def(Tid(650, "%0000028a"),
+ Attrs([Attr("address","0x6C0"), Attr("insn","adrp x0, #131072")]),
+ Var("R0",Imm(64)), Int(131072,64)), Def(Tid(656, "%00000290"),
+ Attrs([Attr("address","0x6C4"), Attr("insn","add x0, x0, #0x10")]),
+ Var("R0",Imm(64)), PLUS(Var("R0",Imm(64)),Int(16,64))),
+Def(Tid(661, "%00000295"), Attrs([Attr("address","0x6C8"),
+Attr("insn","adrp x1, #131072")]), Var("R1",Imm(64)), Int(131072,64)),
+Def(Tid(667, "%0000029b"), Attrs([Attr("address","0x6CC"),
+Attr("insn","add x1, x1, #0x10")]), Var("R1",Imm(64)),
+PLUS(Var("R1",Imm(64)),Int(16,64))), Def(Tid(674, "%000002a2"),
+ Attrs([Attr("address","0x6D0"), Attr("insn","sub x1, x1, x0")]),
+ Var("R1",Imm(64)),
+PLUS(PLUS(Var("R1",Imm(64)),NOT(Var("R0",Imm(64)))),Int(1,64))),
+Def(Tid(680, "%000002a8"), Attrs([Attr("address","0x6D4"),
+Attr("insn","lsr x2, x1, #63")]), Var("R2",Imm(64)),
+Concat(Int(0,63),Extract(63,63,Var("R1",Imm(64))))),
+Def(Tid(687, "%000002af"), Attrs([Attr("address","0x6D8"),
+Attr("insn","add x1, x2, x1, asr #3")]), Var("R1",Imm(64)),
+PLUS(Var("R2",Imm(64)),ARSHIFT(Var("R1",Imm(64)),Int(3,3)))),
+Def(Tid(693, "%000002b5"), Attrs([Attr("address","0x6DC"),
+Attr("insn","asr x1, x1, #1")]), Var("R1",Imm(64)),
+SIGNED(64,Extract(63,1,Var("R1",Imm(64)))))]),
+Jmps([Goto(Tid(699, "%000002bb"), Attrs([Attr("address","0x6E0"),
+Attr("insn","cbz x1, #0x18")]), EQ(Var("R1",Imm(64)),Int(0,64)),
+Direct(Tid(697, "%000002b9"))), Goto(Tid(1_766, "%000006e6"), Attrs([]),
+ Int(1,1), Direct(Tid(1_055, "%0000041f")))])), Blk(Tid(1_055, "%0000041f"),
+ Attrs([Attr("address","0x6E4")]), Phis([]),
+Defs([Def(Tid(1_058, "%00000422"), Attrs([Attr("address","0x6E4"),
+Attr("insn","adrp x2, #126976")]), Var("R2",Imm(64)), Int(126976,64)),
+Def(Tid(1_065, "%00000429"), Attrs([Attr("address","0x6E8"),
+Attr("insn","ldr x2, [x2, #0xff8]")]), Var("R2",Imm(64)),
+Load(Var("mem",Mem(64,8)),PLUS(Var("R2",Imm(64)),Int(4088,64)),LittleEndian(),64))]),
+Jmps([Goto(Tid(1_070, "%0000042e"), Attrs([Attr("address","0x6EC"),
+Attr("insn","cbz x2, #0xc")]), EQ(Var("R2",Imm(64)),Int(0,64)),
+Direct(Tid(697, "%000002b9"))), Goto(Tid(1_767, "%000006e7"), Attrs([]),
+ Int(1,1), Direct(Tid(1_074, "%00000432")))])), Blk(Tid(697, "%000002b9"),
+ Attrs([Attr("address","0x6F8")]), Phis([]), Defs([]),
+Jmps([Call(Tid(705, "%000002c1"), Attrs([Attr("address","0x6F8"),
+Attr("insn","ret")]), Int(1,1), (Indirect(Var("R30",Imm(64))),))])),
+Blk(Tid(1_074, "%00000432"), Attrs([Attr("address","0x6F0")]), Phis([]),
+Defs([Def(Tid(1_078, "%00000436"), Attrs([Attr("address","0x6F0"),
+Attr("insn","mov x16, x2")]), Var("R16",Imm(64)), Var("R2",Imm(64)))]),
+Jmps([Call(Tid(1_083, "%0000043b"), Attrs([Attr("address","0x6F4"),
+Attr("insn","br x16")]), Int(1,1),
+(Indirect(Var("R16",Imm(64))),))]))]))])))
\ No newline at end of file
diff --git a/src/test/dsa/unsafe_pointer_arithmetic/unsafe_pointer_arithmetic.bir b/src/test/dsa/unsafe_pointer_arithmetic/unsafe_pointer_arithmetic.bir
new file mode 100644
index 000000000..3b2746f07
--- /dev/null
+++ b/src/test/dsa/unsafe_pointer_arithmetic/unsafe_pointer_arithmetic.bir
@@ -0,0 +1,268 @@
+000006ca: program
+000006b3: sub __cxa_finalize(__cxa_finalize_result)
+000006cb: __cxa_finalize_result :: out u32 = low:32[R0]
+
+0000041b:
+00000523: R16 := 0x1F000
+0000052a: R17 := mem[R16 + 0xFB0, el]:u64
+00000530: R16 := R16 + 0xFB0
+00000535: call R17 with noreturn
+
+000006b4: sub __do_global_dtors_aux(__do_global_dtors_aux_result)
+000006cc: __do_global_dtors_aux_result :: out u32 = low:32[R0]
+
+000002c5:
+000002c9: #3 := R31 - 0x20
+000002cf: mem := mem with [#3, el]:u64 <- R29
+000002d5: mem := mem with [#3 + 8, el]:u64 <- R30
+000002d9: R31 := #3
+000002df: R29 := R31
+000002e7: mem := mem with [R31 + 0x10, el]:u64 <- R19
+000002ec: R19 := 0x20000
+000002f3: R0 := pad:64[mem[R19 + 0x10]]
+000002fa: when 31:0[R0] <> 0 goto %000002f8
+000006b5: goto %000003e4
+
+000003e4:
+000003e7: R0 := 0x1F000
+000003ee: R0 := mem[R0 + 0xFE0, el]:u64
+000003f4: when R0 = 0 goto %000003f2
+000006b6: goto %0000040b
+
+0000040b:
+0000040e: R0 := 0x20000
+00000415: R0 := mem[R0 + 8, el]:u64
+0000041a: R30 := 0x730
+0000041d: call @__cxa_finalize with return %000003f2
+
+000003f2:
+000003fa: R30 := 0x734
+000003fc: call @deregister_tm_clones with return %000003fe
+
+000003fe:
+00000401: R0 := 1
+00000409: mem := mem with [R19 + 0x10] <- 7:0[R0]
+000006b7: goto %000002f8
+
+000002f8:
+00000302: R19 := mem[R31 + 0x10, el]:u64
+00000309: R29 := mem[R31, el]:u64
+0000030e: R30 := mem[R31 + 8, el]:u64
+00000312: R31 := R31 + 0x20
+00000317: call R30 with noreturn
+
+000006b8: sub __libc_start_main(__libc_start_main_main, __libc_start_main_arg2, __libc_start_main_arg3, __libc_start_main_auxv, __libc_start_main_result)
+000006cd: __libc_start_main_main :: in u64 = R0
+000006ce: __libc_start_main_arg2 :: in u32 = low:32[R1]
+000006cf: __libc_start_main_arg3 :: in out u64 = R2
+000006d0: __libc_start_main_auxv :: in out u64 = R3
+000006d1: __libc_start_main_result :: out u32 = low:32[R0]
+
+0000021e:
+0000050d: R16 := 0x1F000
+00000514: R17 := mem[R16 + 0xFA8, el]:u64
+0000051a: R16 := R16 + 0xFA8
+0000051f: call R17 with noreturn
+
+000006b9: sub _fini(_fini_result)
+000006d2: _fini_result :: out u32 = low:32[R0]
+
+00000032:
+00000038: #0 := R31 - 0x10
+0000003e: mem := mem with [#0, el]:u64 <- R29
+00000044: mem := mem with [#0 + 8, el]:u64 <- R30
+00000048: R31 := #0
+0000004e: R29 := R31
+00000055: R29 := mem[R31, el]:u64
+0000005a: R30 := mem[R31 + 8, el]:u64
+0000005e: R31 := R31 + 0x10
+00000063: call R30 with noreturn
+
+000006ba: sub _init(_init_result)
+000006d3: _init_result :: out u32 = low:32[R0]
+
+000005f8:
+000005fe: #6 := R31 - 0x10
+00000604: mem := mem with [#6, el]:u64 <- R29
+0000060a: mem := mem with [#6 + 8, el]:u64 <- R30
+0000060e: R31 := #6
+00000614: R29 := R31
+00000619: R30 := 0x5C8
+0000061b: call @call_weak_fn with return %0000061d
+
+0000061d:
+00000622: R29 := mem[R31, el]:u64
+00000627: R30 := mem[R31 + 8, el]:u64
+0000062b: R31 := R31 + 0x10
+00000630: call R30 with noreturn
+
+000006bb: sub _start(_start_result)
+000006d4: _start_result :: out u32 = low:32[R0]
+
+000001df:
+000001e4: R29 := 0
+000001e9: R30 := 0
+000001ef: R5 := R0
+000001f6: R1 := mem[R31, el]:u64
+000001fc: R2 := R31 + 8
+00000202: R6 := R31
+00000207: R0 := 0x1F000
+0000020e: R0 := mem[R0 + 0xFF0, el]:u64
+00000213: R3 := 0
+00000218: R4 := 0
+0000021d: R30 := 0x670
+00000220: call @__libc_start_main with return %00000222
+
+00000222:
+00000225: R30 := 0x674
+00000228: call @abort with return %000006bc
+
+000006bc:
+000006bd: call @call_weak_fn with noreturn
+
+000006be: sub abort()
+
+
+00000226:
+00000565: R16 := 0x1F000
+0000056c: R17 := mem[R16 + 0xFC8, el]:u64
+00000572: R16 := R16 + 0xFC8
+00000577: call R17 with noreturn
+
+000006bf: sub call_weak_fn(call_weak_fn_result)
+000006d5: call_weak_fn_result :: out u32 = low:32[R0]
+
+0000022a:
+0000022d: R0 := 0x1F000
+00000234: R0 := mem[R0 + 0xFE8, el]:u64
+0000023a: when R0 = 0 goto %00000238
+000006c0: goto %0000045b
+
+00000238:
+00000240: call R30 with noreturn
+
+0000045b:
+0000045e: goto @__gmon_start__
+
+0000045c:
+0000054f: R16 := 0x1F000
+00000556: R17 := mem[R16 + 0xFC0, el]:u64
+0000055c: R16 := R16 + 0xFC0
+00000561: call R17 with noreturn
+
+000006c1: sub deregister_tm_clones(deregister_tm_clones_result)
+000006d6: deregister_tm_clones_result :: out u32 = low:32[R0]
+
+00000246:
+00000249: R0 := 0x20000
+0000024f: R0 := R0 + 0x10
+00000254: R1 := 0x20000
+0000025a: R1 := R1 + 0x10
+00000260: #1 := ~R0
+00000265: #2 := R1 + ~R0
+0000026b: VF := extend:65[#2 + 1] <> extend:65[R1] + extend:65[#1] + 1
+00000271: CF := pad:65[#2 + 1] <> pad:65[R1] + pad:65[#1] + 1
+00000275: ZF := #2 + 1 = 0
+00000279: NF := 63:63[#2 + 1]
+0000027f: when ZF goto %0000027d
+000006c2: goto %0000043d
+
+0000043d:
+00000440: R1 := 0x1F000
+00000447: R1 := mem[R1 + 0xFD8, el]:u64
+0000044c: when R1 = 0 goto %0000027d
+000006c3: goto %00000450
+
+0000027d:
+00000285: call R30 with noreturn
+
+00000450:
+00000454: R16 := R1
+00000459: call R16 with noreturn
+
+000006c4: sub frame_dummy(frame_dummy_result)
+000006d7: frame_dummy_result :: out u32 = low:32[R0]
+
+0000031d:
+0000031f: call @register_tm_clones with noreturn
+
+000006c5: sub main(main_argc, main_argv, main_result)
+000006d8: main_argc :: in u32 = low:32[R0]
+000006d9: main_argv :: in out u64 = R1
+000006da: main_result :: out u32 = low:32[R0]
+
+00000321:
+00000325: #4 := R31 - 0x40
+0000032b: mem := mem with [#4, el]:u64 <- R29
+00000331: mem := mem with [#4 + 8, el]:u64 <- R30
+00000335: R31 := #4
+0000033b: R29 := R31
+00000340: R0 := 0x14
+00000345: R30 := 0x764
+00000348: call @malloc with return %0000034a
+
+0000034a:
+00000350: mem := mem with [R31 + 0x18, el]:u64 <- R0
+00000357: R0 := mem[R31 + 0x18, el]:u64
+0000035c: R1 := 0xC
+00000364: mem := mem with [R0, el]:u32 <- 31:0[R1]
+0000036b: R0 := mem[R31 + 0x18, el]:u64
+00000373: mem := mem with [R31 + 0x20, el]:u64 <- R0
+0000037a: R0 := mem[R31 + 0x20, el]:u64
+00000380: R0 := R0 + 1
+00000388: mem := mem with [R31 + 0x28, el]:u64 <- R0
+0000038d: R0 := 8
+00000392: R30 := 0x790
+00000394: call @malloc with return %00000396
+
+00000396:
+0000039c: mem := mem with [R31 + 0x30, el]:u64 <- R0
+000003a3: R0 := mem[R31 + 0x30, el]:u64
+000003aa: R1 := mem[R31 + 0x28, el]:u64
+000003b2: mem := mem with [R0, el]:u64 <- R1
+000003b9: R0 := mem[R31 + 0x30, el]:u64
+000003c0: R0 := mem[R0, el]:u64
+000003c8: mem := mem with [R31 + 0x38, el]:u64 <- R0
+000003cd: R0 := 0
+000003d4: R29 := mem[R31, el]:u64
+000003d9: R30 := mem[R31 + 8, el]:u64
+000003dd: R31 := R31 + 0x40
+000003e2: call R30 with noreturn
+
+000006c6: sub malloc(malloc_size, malloc_result)
+000006db: malloc_size :: in u64 = R0
+000006dc: malloc_result :: out u64 = R0
+
+00000346:
+00000539: R16 := 0x1F000
+00000540: R17 := mem[R16 + 0xFB8, el]:u64
+00000546: R16 := R16 + 0xFB8
+0000054b: call R17 with noreturn
+
+000006c7: sub register_tm_clones(register_tm_clones_result)
+000006dd: register_tm_clones_result :: out u32 = low:32[R0]
+
+00000287:
+0000028a: R0 := 0x20000
+00000290: R0 := R0 + 0x10
+00000295: R1 := 0x20000
+0000029b: R1 := R1 + 0x10
+000002a2: R1 := R1 + ~R0 + 1
+000002a8: R2 := 0.63:63[R1]
+000002af: R1 := R2 + (R1 ~>> 3)
+000002b5: R1 := extend:64[63:1[R1]]
+000002bb: when R1 = 0 goto %000002b9
+000006c8: goto %0000041f
+
+0000041f:
+00000422: R2 := 0x1F000
+00000429: R2 := mem[R2 + 0xFF8, el]:u64
+0000042e: when R2 = 0 goto %000002b9
+000006c9: goto %00000432
+
+000002b9:
+000002c1: call R30 with noreturn
+
+00000432:
+00000436: R16 := R2
+0000043b: call R16 with noreturn
diff --git a/src/test/dsa/unsafe_pointer_arithmetic/unsafe_pointer_arithmetic.c b/src/test/dsa/unsafe_pointer_arithmetic/unsafe_pointer_arithmetic.c
new file mode 100644
index 000000000..d3c43c655
--- /dev/null
+++ b/src/test/dsa/unsafe_pointer_arithmetic/unsafe_pointer_arithmetic.c
@@ -0,0 +1,12 @@
+#include <stdlib.h>
+
+
+int main() {
+    int *bar = malloc(5 * sizeof(int));
+    *bar = 12;
+    void * car = (void*) bar;
+    int* foo = (int*) (car + 1);
+    int ** tar = malloc(sizeof(int*));
+    *tar = foo;
+    int *bat = *tar;
+}
diff --git a/src/test/dsa/unsafe_pointer_arithmetic/unsafe_pointer_arithmetic.relf b/src/test/dsa/unsafe_pointer_arithmetic/unsafe_pointer_arithmetic.relf
new file mode 100644
index 000000000..ee608ea91
--- /dev/null
+++ b/src/test/dsa/unsafe_pointer_arithmetic/unsafe_pointer_arithmetic.relf
@@ -0,0 +1,122 @@
+
+Relocation section '.rela.dyn' at offset 0x480 contains 8 entries:
+    Offset             Info             Type               Symbol's Value  Symbol's Name + Addend
+000000000001fd90  0000000000000403 R_AARCH64_RELATIVE                        750
+000000000001fd98  0000000000000403 R_AARCH64_RELATIVE                        700
+000000000001fff0  0000000000000403 R_AARCH64_RELATIVE                        754
+0000000000020008  0000000000000403 R_AARCH64_RELATIVE                        20008
+000000000001ffd8  0000000400000401 R_AARCH64_GLOB_DAT     0000000000000000 _ITM_deregisterTMCloneTable + 0
+000000000001ffe0  0000000500000401 R_AARCH64_GLOB_DAT     0000000000000000 __cxa_finalize@GLIBC_2.17 + 0
+000000000001ffe8  0000000700000401 R_AARCH64_GLOB_DAT     0000000000000000 __gmon_start__ + 0
+000000000001fff8  0000000900000401 R_AARCH64_GLOB_DAT     0000000000000000 _ITM_registerTMCloneTable + 0
+
+Relocation section '.rela.plt' at offset 0x540 contains 5 entries:
+    Offset             Info             Type               Symbol's Value  Symbol's Name + Addend
+000000000001ffa8  0000000300000402 R_AARCH64_JUMP_SLOT    0000000000000000 __libc_start_main@GLIBC_2.34 + 0
+000000000001ffb0  0000000500000402 R_AARCH64_JUMP_SLOT    0000000000000000 __cxa_finalize@GLIBC_2.17 + 0
+000000000001ffb8  0000000600000402 R_AARCH64_JUMP_SLOT    0000000000000000 malloc@GLIBC_2.17 + 0
+000000000001ffc0  0000000700000402 R_AARCH64_JUMP_SLOT    0000000000000000 __gmon_start__ + 0
+000000000001ffc8  0000000800000402 R_AARCH64_JUMP_SLOT    0000000000000000 abort@GLIBC_2.17 + 0
+
+Symbol table '.dynsym' contains 10 entries:
+   Num:    Value          Size Type    Bind   Vis      Ndx Name
+     0: 0000000000000000     0 NOTYPE  LOCAL  DEFAULT  UND 
+     1: 00000000000005b8     0 SECTION LOCAL  DEFAULT   11 .init
+     2: 0000000000020000     0 SECTION LOCAL  DEFAULT   22 .data
+     3: 0000000000000000     0 FUNC    GLOBAL DEFAULT  UND __libc_start_main@GLIBC_2.34 (2)
+     4: 0000000000000000     0 NOTYPE  WEAK   DEFAULT  UND _ITM_deregisterTMCloneTable
+     5: 0000000000000000     0 FUNC    WEAK   DEFAULT  UND __cxa_finalize@GLIBC_2.17 (3)
+     6: 0000000000000000     0 FUNC    GLOBAL DEFAULT  UND malloc@GLIBC_2.17 (3)
+     7: 0000000000000000     0 NOTYPE  WEAK   DEFAULT  UND __gmon_start__
+     8: 0000000000000000     0 FUNC    GLOBAL DEFAULT  UND abort@GLIBC_2.17 (3)
+     9: 0000000000000000     0 NOTYPE  WEAK   DEFAULT  UND _ITM_registerTMCloneTable
+
+Symbol table '.symtab' contains 87 entries:
+   Num:    Value          Size Type    Bind   Vis      Ndx Name
+     0: 0000000000000000     0 NOTYPE  LOCAL  DEFAULT  UND 
+     1: 0000000000000238     0 SECTION LOCAL  DEFAULT    1 .interp
+     2: 0000000000000254     0 SECTION LOCAL  DEFAULT    2 .note.gnu.build-id
+     3: 0000000000000278     0 SECTION LOCAL  DEFAULT    3 .note.ABI-tag
+     4: 0000000000000298     0 SECTION LOCAL  DEFAULT    4 .gnu.hash
+     5: 00000000000002b8     0 SECTION LOCAL  DEFAULT    5 .dynsym
+     6: 00000000000003a8     0 SECTION LOCAL  DEFAULT    6 .dynstr
+     7: 000000000000043c     0 SECTION LOCAL  DEFAULT    7 .gnu.version
+     8: 0000000000000450     0 SECTION LOCAL  DEFAULT    8 .gnu.version_r
+     9: 0000000000000480     0 SECTION LOCAL  DEFAULT    9 .rela.dyn
+    10: 0000000000000540     0 SECTION LOCAL  DEFAULT   10 .rela.plt
+    11: 00000000000005b8     0 SECTION LOCAL  DEFAULT   11 .init
+    12: 00000000000005d0     0 SECTION LOCAL  DEFAULT   12 .plt
+    13: 0000000000000640     0 SECTION LOCAL  DEFAULT   13 .text
+    14: 00000000000007b8     0 SECTION LOCAL  DEFAULT   14 .fini
+    15: 00000000000007cc     0 SECTION LOCAL  DEFAULT   15 .rodata
+    16: 00000000000007d0     0 SECTION LOCAL  DEFAULT   16 .eh_frame_hdr
+    17: 0000000000000810     0 SECTION LOCAL  DEFAULT   17 .eh_frame
+    18: 000000000001fd90     0 SECTION LOCAL  DEFAULT   18 .init_array
+    19: 000000000001fd98     0 SECTION LOCAL  DEFAULT   19 .fini_array
+    20: 000000000001fda0     0 SECTION LOCAL  DEFAULT   20 .dynamic
+    21: 000000000001ff90     0 SECTION LOCAL  DEFAULT   21 .got
+    22: 0000000000020000     0 SECTION LOCAL  DEFAULT   22 .data
+    23: 0000000000020010     0 SECTION LOCAL  DEFAULT   23 .bss
+    24: 0000000000000000     0 SECTION LOCAL  DEFAULT   24 .comment
+    25: 0000000000000000     0 FILE    LOCAL  DEFAULT  ABS Scrt1.o
+    26: 0000000000000278     0 NOTYPE  LOCAL  DEFAULT    3 $d
+    27: 0000000000000278    32 OBJECT  LOCAL  DEFAULT    3 __abi_tag
+    28: 0000000000000640     0 NOTYPE  LOCAL  DEFAULT   13 $x
+    29: 0000000000000824     0 NOTYPE  LOCAL  DEFAULT   17 $d
+    30: 00000000000007cc     0 NOTYPE  LOCAL  DEFAULT   15 $d
+    31: 0000000000000000     0 FILE    LOCAL  DEFAULT  ABS crti.o
+    32: 0000000000000674     0 NOTYPE  LOCAL  DEFAULT   13 $x
+    33: 0000000000000674    20 FUNC    LOCAL  DEFAULT   13 call_weak_fn
+    34: 00000000000005b8     0 NOTYPE  LOCAL  DEFAULT   11 $x
+    35: 00000000000007b8     0 NOTYPE  LOCAL  DEFAULT   14 $x
+    36: 0000000000000000     0 FILE    LOCAL  DEFAULT  ABS crtn.o
+    37: 00000000000005c8     0 NOTYPE  LOCAL  DEFAULT   11 $x
+    38: 00000000000007c4     0 NOTYPE  LOCAL  DEFAULT   14 $x
+    39: 0000000000000000     0 FILE    LOCAL  DEFAULT  ABS crtstuff.c
+    40: 0000000000000690     0 NOTYPE  LOCAL  DEFAULT   13 $x
+    41: 0000000000000690     0 FUNC    LOCAL  DEFAULT   13 deregister_tm_clones
+    42: 00000000000006c0     0 FUNC    LOCAL  DEFAULT   13 register_tm_clones
+    43: 0000000000020008     0 NOTYPE  LOCAL  DEFAULT   22 $d
+    44: 0000000000000700     0 FUNC    LOCAL  DEFAULT   13 __do_global_dtors_aux
+    45: 0000000000020010     1 OBJECT  LOCAL  DEFAULT   23 completed.0
+    46: 000000000001fd98     0 NOTYPE  LOCAL  DEFAULT   19 $d
+    47: 000000000001fd98     0 OBJECT  LOCAL  DEFAULT   19 __do_global_dtors_aux_fini_array_entry
+    48: 0000000000000750     0 FUNC    LOCAL  DEFAULT   13 frame_dummy
+    49: 000000000001fd90     0 NOTYPE  LOCAL  DEFAULT   18 $d
+    50: 000000000001fd90     0 OBJECT  LOCAL  DEFAULT   18 __frame_dummy_init_array_entry
+    51: 0000000000000838     0 NOTYPE  LOCAL  DEFAULT   17 $d
+    52: 0000000000020010     0 NOTYPE  LOCAL  DEFAULT   23 $d
+    53: 0000000000000000     0 FILE    LOCAL  DEFAULT  ABS unsafe_pointer_arithmetic.c
+    54: 0000000000000754     0 NOTYPE  LOCAL  DEFAULT   13 $x
+    55: 0000000000000898     0 NOTYPE  LOCAL  DEFAULT   17 $d
+    56: 0000000000000000     0 FILE    LOCAL  DEFAULT  ABS crtstuff.c
+    57: 00000000000008b8     0 NOTYPE  LOCAL  DEFAULT   17 $d
+    58: 00000000000008b8     0 OBJECT  LOCAL  DEFAULT   17 __FRAME_END__
+    59: 0000000000000000     0 FILE    LOCAL  DEFAULT  ABS 
+    60: 000000000001fda0     0 OBJECT  LOCAL  DEFAULT  ABS _DYNAMIC
+    61: 00000000000007d0     0 NOTYPE  LOCAL  DEFAULT   16 __GNU_EH_FRAME_HDR
+    62: 000000000001ffd0     0 OBJECT  LOCAL  DEFAULT  ABS _GLOBAL_OFFSET_TABLE_
+    63: 00000000000005d0     0 NOTYPE  LOCAL  DEFAULT   12 $x
+    64: 0000000000000000     0 FUNC    GLOBAL DEFAULT  UND __libc_start_main@GLIBC_2.34
+    65: 0000000000000000     0 NOTYPE  WEAK   DEFAULT  UND _ITM_deregisterTMCloneTable
+    66: 0000000000020000     0 NOTYPE  WEAK   DEFAULT   22 data_start
+    67: 0000000000020010     0 NOTYPE  GLOBAL DEFAULT   23 __bss_start__
+    68: 0000000000000000     0 FUNC    WEAK   DEFAULT  UND __cxa_finalize@GLIBC_2.17
+    69: 0000000000020018     0 NOTYPE  GLOBAL DEFAULT   23 _bss_end__
+    70: 0000000000020010     0 NOTYPE  GLOBAL DEFAULT   22 _edata
+    71: 00000000000007b8     0 FUNC    GLOBAL HIDDEN    14 _fini
+    72: 0000000000020018     0 NOTYPE  GLOBAL DEFAULT   23 __bss_end__
+    73: 0000000000000000     0 FUNC    GLOBAL DEFAULT  UND malloc@GLIBC_2.17
+    74: 0000000000020000     0 NOTYPE  GLOBAL DEFAULT   22 __data_start
+    75: 0000000000000000     0 NOTYPE  WEAK   DEFAULT  UND __gmon_start__
+    76: 0000000000020008     0 OBJECT  GLOBAL HIDDEN    22 __dso_handle
+    77: 0000000000000000     0 FUNC    GLOBAL DEFAULT  UND abort@GLIBC_2.17
+    78: 00000000000007cc     4 OBJECT  GLOBAL DEFAULT   15 _IO_stdin_used
+    79: 0000000000020018     0 NOTYPE  GLOBAL DEFAULT   23 _end
+    80: 0000000000000640    52 FUNC    GLOBAL DEFAULT   13 _start
+    81: 0000000000020018     0 NOTYPE  GLOBAL DEFAULT   23 __end__
+    82: 0000000000020010     0 NOTYPE  GLOBAL DEFAULT   23 __bss_start
+    83: 0000000000000754   100 FUNC    GLOBAL DEFAULT   13 main
+    84: 0000000000020010     0 OBJECT  GLOBAL HIDDEN    22 __TMC_END__
+    85: 0000000000000000     0 NOTYPE  WEAK   DEFAULT  UND _ITM_registerTMCloneTable
+    86: 00000000000005b8     0 FUNC    GLOBAL HIDDEN    11 _init
diff --git a/src/test/incorrect/basicassign/clang/basicassign.expected b/src/test/incorrect/basicassign/clang/basicassign.expected
index 60367a8c0..02b8d1f0e 100644
--- a/src/test/incorrect/basicassign/clang/basicassign.expected
+++ b/src/test/incorrect/basicassign/clang/basicassign.expected
@@ -16,7 +16,7 @@ const {:extern} $x_addr: bv64;
 axiom ($x_addr == 69688bv64);
 const {:extern} $z_addr: bv64;
 axiom ($z_addr == 69692bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
   (if (index == $z_addr) then true else (if (index == $secret_addr) then false else (if (index == $x_addr) then false else false)))
 }
 
@@ -37,10 +37,6 @@ function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv6
   (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
-}
-
 function {:extern} memory_store32_le(memory: [bv64]bv8, index: bv64, value: bv32) returns ([bv64]bv8) {
   memory[index := value[8:0]][bvadd64(index, 1bv64) := value[16:8]][bvadd64(index, 2bv64) := value[24:16]][bvadd64(index, 3bv64) := value[32:24]]
 }
@@ -50,10 +46,7 @@ procedure {:extern} rely();
   modifies Gamma_mem, mem;
   ensures (forall i: bv64 :: (((mem[i] == old(mem[i])) ==> (Gamma_mem[i] == old(Gamma_mem[i])))));
   ensures (memory_load32_le(mem, $x_addr) == old(memory_load32_le(mem, $x_addr)));
-  free ensures (memory_load8_le(mem, 1888bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1889bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1890bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1891bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1888bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1812bv64);
@@ -83,18 +76,12 @@ procedure main();
   modifies Gamma_R0, Gamma_R10, Gamma_R11, Gamma_R8, Gamma_R9, Gamma_mem, R0, R10, R11, R8, R9, mem;
   free requires (memory_load64_le(mem, 69664bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
-  free requires (memory_load8_le(mem, 1888bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1889bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1890bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1891bv64) == 0bv8);
+  free requires (memory_load32_le(mem, 1888bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free requires (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free requires (memory_load64_le(mem, 69592bv64) == 1812bv64);
   free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
-  free ensures (memory_load8_le(mem, 1888bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1889bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1890bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1891bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1888bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1812bv64);
diff --git a/src/test/incorrect/basicassign/clang/basicassign_gtirb.expected b/src/test/incorrect/basicassign/clang/basicassign_gtirb.expected
index 7338ab0ff..563cb3087 100644
--- a/src/test/incorrect/basicassign/clang/basicassign_gtirb.expected
+++ b/src/test/incorrect/basicassign/clang/basicassign_gtirb.expected
@@ -16,7 +16,7 @@ const {:extern} $x_addr: bv64;
 axiom ($x_addr == 69688bv64);
 const {:extern} $z_addr: bv64;
 axiom ($z_addr == 69692bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
   (if (index == $z_addr) then true else (if (index == $secret_addr) then false else (if (index == $x_addr) then false else false)))
 }
 
@@ -37,10 +37,6 @@ function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv6
   (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
-}
-
 function {:extern} memory_store32_le(memory: [bv64]bv8, index: bv64, value: bv32) returns ([bv64]bv8) {
   memory[index := value[8:0]][bvadd64(index, 1bv64) := value[16:8]][bvadd64(index, 2bv64) := value[24:16]][bvadd64(index, 3bv64) := value[32:24]]
 }
@@ -50,10 +46,7 @@ procedure {:extern} rely();
   modifies Gamma_mem, mem;
   ensures (forall i: bv64 :: (((mem[i] == old(mem[i])) ==> (Gamma_mem[i] == old(Gamma_mem[i])))));
   ensures (memory_load32_le(mem, $x_addr) == old(memory_load32_le(mem, $x_addr)));
-  free ensures (memory_load8_le(mem, 1888bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1889bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1890bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1891bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1888bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1812bv64);
@@ -83,18 +76,12 @@ procedure main();
   modifies Gamma_R0, Gamma_R10, Gamma_R11, Gamma_R8, Gamma_R9, Gamma_mem, R0, R10, R11, R8, R9, mem;
   free requires (memory_load64_le(mem, 69664bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
-  free requires (memory_load8_le(mem, 1888bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1889bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1890bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1891bv64) == 0bv8);
+  free requires (memory_load32_le(mem, 1888bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free requires (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free requires (memory_load64_le(mem, 69592bv64) == 1812bv64);
   free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
-  free ensures (memory_load8_le(mem, 1888bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1889bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1890bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1891bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1888bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1812bv64);
diff --git a/src/test/incorrect/basicassign/clang_O2/basicassign.expected b/src/test/incorrect/basicassign/clang_O2/basicassign.expected
index 3de01bcab..8b0e755c9 100644
--- a/src/test/incorrect/basicassign/clang_O2/basicassign.expected
+++ b/src/test/incorrect/basicassign/clang_O2/basicassign.expected
@@ -14,7 +14,7 @@ const {:extern} $x_addr: bv64;
 axiom ($x_addr == 69688bv64);
 const {:extern} $z_addr: bv64;
 axiom ($z_addr == 69692bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
   (if (index == $z_addr) then true else (if (index == $secret_addr) then false else (if (index == $x_addr) then false else false)))
 }
 
@@ -35,10 +35,6 @@ function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv6
   (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
-}
-
 function {:extern} memory_store32_le(memory: [bv64]bv8, index: bv64, value: bv32) returns ([bv64]bv8) {
   memory[index := value[8:0]][bvadd64(index, 1bv64) := value[16:8]][bvadd64(index, 2bv64) := value[24:16]][bvadd64(index, 3bv64) := value[32:24]]
 }
@@ -48,10 +44,7 @@ procedure {:extern} rely();
   modifies Gamma_mem, mem;
   ensures (forall i: bv64 :: (((mem[i] == old(mem[i])) ==> (Gamma_mem[i] == old(Gamma_mem[i])))));
   ensures (memory_load32_le(mem, $x_addr) == old(memory_load32_le(mem, $x_addr)));
-  free ensures (memory_load8_le(mem, 1864bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1865bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1866bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1867bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1864bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1812bv64);
@@ -81,18 +74,12 @@ procedure main();
   modifies Gamma_R0, Gamma_R10, Gamma_R8, Gamma_R9, Gamma_mem, R0, R10, R8, R9, mem;
   free requires (memory_load64_le(mem, 69664bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
-  free requires (memory_load8_le(mem, 1864bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1865bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1866bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1867bv64) == 0bv8);
+  free requires (memory_load32_le(mem, 1864bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free requires (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free requires (memory_load64_le(mem, 69592bv64) == 1812bv64);
   free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
-  free ensures (memory_load8_le(mem, 1864bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1865bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1866bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1867bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1864bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1812bv64);
diff --git a/src/test/incorrect/basicassign/clang_O2/basicassign_gtirb.expected b/src/test/incorrect/basicassign/clang_O2/basicassign_gtirb.expected
index ecdc0fe3d..abae7f906 100644
--- a/src/test/incorrect/basicassign/clang_O2/basicassign_gtirb.expected
+++ b/src/test/incorrect/basicassign/clang_O2/basicassign_gtirb.expected
@@ -14,7 +14,7 @@ const {:extern} $x_addr: bv64;
 axiom ($x_addr == 69688bv64);
 const {:extern} $z_addr: bv64;
 axiom ($z_addr == 69692bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
   (if (index == $z_addr) then true else (if (index == $secret_addr) then false else (if (index == $x_addr) then false else false)))
 }
 
@@ -35,10 +35,6 @@ function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv6
   (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
-}
-
 function {:extern} memory_store32_le(memory: [bv64]bv8, index: bv64, value: bv32) returns ([bv64]bv8) {
   memory[index := value[8:0]][bvadd64(index, 1bv64) := value[16:8]][bvadd64(index, 2bv64) := value[24:16]][bvadd64(index, 3bv64) := value[32:24]]
 }
@@ -48,10 +44,7 @@ procedure {:extern} rely();
   modifies Gamma_mem, mem;
   ensures (forall i: bv64 :: (((mem[i] == old(mem[i])) ==> (Gamma_mem[i] == old(Gamma_mem[i])))));
   ensures (memory_load32_le(mem, $x_addr) == old(memory_load32_le(mem, $x_addr)));
-  free ensures (memory_load8_le(mem, 1864bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1865bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1866bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1867bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1864bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1812bv64);
@@ -81,18 +74,12 @@ procedure main();
   modifies Gamma_R0, Gamma_R10, Gamma_R8, Gamma_R9, Gamma_mem, R0, R10, R8, R9, mem;
   free requires (memory_load64_le(mem, 69664bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
-  free requires (memory_load8_le(mem, 1864bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1865bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1866bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1867bv64) == 0bv8);
+  free requires (memory_load32_le(mem, 1864bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free requires (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free requires (memory_load64_le(mem, 69592bv64) == 1812bv64);
   free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
-  free ensures (memory_load8_le(mem, 1864bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1865bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1866bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1867bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1864bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1812bv64);
diff --git a/src/test/incorrect/basicassign/clang_pic/basicassign.expected b/src/test/incorrect/basicassign/clang_pic/basicassign.expected
index 2482ec834..df8da4c63 100644
--- a/src/test/incorrect/basicassign/clang_pic/basicassign.expected
+++ b/src/test/incorrect/basicassign/clang_pic/basicassign.expected
@@ -16,7 +16,7 @@ const {:extern} $x_addr: bv64;
 axiom ($x_addr == 69688bv64);
 const {:extern} $z_addr: bv64;
 axiom ($z_addr == 69692bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
   (if (index == $z_addr) then true else (if (index == $secret_addr) then false else (if (index == $x_addr) then false else false)))
 }
 
@@ -41,10 +41,6 @@ function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv6
   (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
-}
-
 function {:extern} memory_store32_le(memory: [bv64]bv8, index: bv64, value: bv32) returns ([bv64]bv8) {
   memory[index := value[8:0]][bvadd64(index, 1bv64) := value[16:8]][bvadd64(index, 2bv64) := value[24:16]][bvadd64(index, 3bv64) := value[32:24]]
 }
@@ -54,17 +50,14 @@ procedure {:extern} rely();
   modifies Gamma_mem, mem;
   ensures (forall i: bv64 :: (((mem[i] == old(mem[i])) ==> (Gamma_mem[i] == old(Gamma_mem[i])))));
   ensures (memory_load32_le(mem, $x_addr) == old(memory_load32_le(mem, $x_addr)));
-  free ensures (memory_load8_le(mem, 1964bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1965bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1966bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1967bv64) == 0bv8);
-  free ensures (memory_load64_le(mem, 69672bv64) == 69672bv64);
-  free ensures (memory_load64_le(mem, 69584bv64) == 69684bv64);
-  free ensures (memory_load64_le(mem, 69048bv64) == 1792bv64);
+  free ensures (memory_load32_le(mem, 1964bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69040bv64) == 1872bv64);
+  free ensures (memory_load64_le(mem, 69048bv64) == 1792bv64);
+  free ensures (memory_load64_le(mem, 69560bv64) == 69692bv64);
   free ensures (memory_load64_le(mem, 69568bv64) == 69688bv64);
+  free ensures (memory_load64_le(mem, 69584bv64) == 69684bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1876bv64);
-  free ensures (memory_load64_le(mem, 69560bv64) == 69692bv64);
+  free ensures (memory_load64_le(mem, 69672bv64) == 69672bv64);
 
 procedure {:extern} rely_transitive();
   modifies Gamma_mem, mem;
@@ -90,28 +83,22 @@ procedure main();
   modifies Gamma_R0, Gamma_R10, Gamma_R11, Gamma_R8, Gamma_R9, Gamma_mem, R0, R10, R11, R8, R9, mem;
   free requires (memory_load64_le(mem, 69664bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
-  free requires (memory_load8_le(mem, 1964bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1965bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1966bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1967bv64) == 0bv8);
-  free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
-  free requires (memory_load64_le(mem, 69584bv64) == 69684bv64);
-  free requires (memory_load64_le(mem, 69048bv64) == 1792bv64);
+  free requires (memory_load32_le(mem, 1964bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69040bv64) == 1872bv64);
+  free requires (memory_load64_le(mem, 69048bv64) == 1792bv64);
+  free requires (memory_load64_le(mem, 69560bv64) == 69692bv64);
   free requires (memory_load64_le(mem, 69568bv64) == 69688bv64);
+  free requires (memory_load64_le(mem, 69584bv64) == 69684bv64);
   free requires (memory_load64_le(mem, 69592bv64) == 1876bv64);
-  free requires (memory_load64_le(mem, 69560bv64) == 69692bv64);
-  free ensures (memory_load8_le(mem, 1964bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1965bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1966bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1967bv64) == 0bv8);
-  free ensures (memory_load64_le(mem, 69672bv64) == 69672bv64);
-  free ensures (memory_load64_le(mem, 69584bv64) == 69684bv64);
-  free ensures (memory_load64_le(mem, 69048bv64) == 1792bv64);
+  free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
+  free ensures (memory_load32_le(mem, 1964bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69040bv64) == 1872bv64);
+  free ensures (memory_load64_le(mem, 69048bv64) == 1792bv64);
+  free ensures (memory_load64_le(mem, 69560bv64) == 69692bv64);
   free ensures (memory_load64_le(mem, 69568bv64) == 69688bv64);
+  free ensures (memory_load64_le(mem, 69584bv64) == 69684bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1876bv64);
-  free ensures (memory_load64_le(mem, 69560bv64) == 69692bv64);
+  free ensures (memory_load64_le(mem, 69672bv64) == 69672bv64);
 
 implementation main()
 {
diff --git a/src/test/incorrect/basicassign/clang_pic/basicassign_gtirb.expected b/src/test/incorrect/basicassign/clang_pic/basicassign_gtirb.expected
index 5584a3882..60c48f7f5 100644
--- a/src/test/incorrect/basicassign/clang_pic/basicassign_gtirb.expected
+++ b/src/test/incorrect/basicassign/clang_pic/basicassign_gtirb.expected
@@ -16,7 +16,7 @@ const {:extern} $x_addr: bv64;
 axiom ($x_addr == 69688bv64);
 const {:extern} $z_addr: bv64;
 axiom ($z_addr == 69692bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
   (if (index == $z_addr) then true else (if (index == $secret_addr) then false else (if (index == $x_addr) then false else false)))
 }
 
@@ -41,10 +41,6 @@ function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv6
   (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
-}
-
 function {:extern} memory_store32_le(memory: [bv64]bv8, index: bv64, value: bv32) returns ([bv64]bv8) {
   memory[index := value[8:0]][bvadd64(index, 1bv64) := value[16:8]][bvadd64(index, 2bv64) := value[24:16]][bvadd64(index, 3bv64) := value[32:24]]
 }
@@ -54,17 +50,14 @@ procedure {:extern} rely();
   modifies Gamma_mem, mem;
   ensures (forall i: bv64 :: (((mem[i] == old(mem[i])) ==> (Gamma_mem[i] == old(Gamma_mem[i])))));
   ensures (memory_load32_le(mem, $x_addr) == old(memory_load32_le(mem, $x_addr)));
-  free ensures (memory_load8_le(mem, 1964bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1965bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1966bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1967bv64) == 0bv8);
-  free ensures (memory_load64_le(mem, 69672bv64) == 69672bv64);
-  free ensures (memory_load64_le(mem, 69584bv64) == 69684bv64);
-  free ensures (memory_load64_le(mem, 69048bv64) == 1792bv64);
+  free ensures (memory_load32_le(mem, 1964bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69040bv64) == 1872bv64);
+  free ensures (memory_load64_le(mem, 69048bv64) == 1792bv64);
+  free ensures (memory_load64_le(mem, 69560bv64) == 69692bv64);
   free ensures (memory_load64_le(mem, 69568bv64) == 69688bv64);
+  free ensures (memory_load64_le(mem, 69584bv64) == 69684bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1876bv64);
-  free ensures (memory_load64_le(mem, 69560bv64) == 69692bv64);
+  free ensures (memory_load64_le(mem, 69672bv64) == 69672bv64);
 
 procedure {:extern} rely_transitive();
   modifies Gamma_mem, mem;
@@ -90,28 +83,22 @@ procedure main();
   modifies Gamma_R0, Gamma_R10, Gamma_R11, Gamma_R8, Gamma_R9, Gamma_mem, R0, R10, R11, R8, R9, mem;
   free requires (memory_load64_le(mem, 69664bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
-  free requires (memory_load8_le(mem, 1964bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1965bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1966bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1967bv64) == 0bv8);
-  free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
-  free requires (memory_load64_le(mem, 69584bv64) == 69684bv64);
-  free requires (memory_load64_le(mem, 69048bv64) == 1792bv64);
+  free requires (memory_load32_le(mem, 1964bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69040bv64) == 1872bv64);
+  free requires (memory_load64_le(mem, 69048bv64) == 1792bv64);
+  free requires (memory_load64_le(mem, 69560bv64) == 69692bv64);
   free requires (memory_load64_le(mem, 69568bv64) == 69688bv64);
+  free requires (memory_load64_le(mem, 69584bv64) == 69684bv64);
   free requires (memory_load64_le(mem, 69592bv64) == 1876bv64);
-  free requires (memory_load64_le(mem, 69560bv64) == 69692bv64);
-  free ensures (memory_load8_le(mem, 1964bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1965bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1966bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1967bv64) == 0bv8);
-  free ensures (memory_load64_le(mem, 69672bv64) == 69672bv64);
-  free ensures (memory_load64_le(mem, 69584bv64) == 69684bv64);
-  free ensures (memory_load64_le(mem, 69048bv64) == 1792bv64);
+  free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
+  free ensures (memory_load32_le(mem, 1964bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69040bv64) == 1872bv64);
+  free ensures (memory_load64_le(mem, 69048bv64) == 1792bv64);
+  free ensures (memory_load64_le(mem, 69560bv64) == 69692bv64);
   free ensures (memory_load64_le(mem, 69568bv64) == 69688bv64);
+  free ensures (memory_load64_le(mem, 69584bv64) == 69684bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1876bv64);
-  free ensures (memory_load64_le(mem, 69560bv64) == 69692bv64);
+  free ensures (memory_load64_le(mem, 69672bv64) == 69672bv64);
 
 implementation main()
 {
diff --git a/src/test/incorrect/basicassign/gcc/basicassign.expected b/src/test/incorrect/basicassign/gcc/basicassign.expected
index 404564f37..94068d3c2 100644
--- a/src/test/incorrect/basicassign/gcc/basicassign.expected
+++ b/src/test/incorrect/basicassign/gcc/basicassign.expected
@@ -10,7 +10,7 @@ const {:extern} $x_addr: bv64;
 axiom ($x_addr == 69652bv64);
 const {:extern} $z_addr: bv64;
 axiom ($z_addr == 69656bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
   (if (index == $z_addr) then true else (if (index == $secret_addr) then false else (if (index == $x_addr) then false else false)))
 }
 
@@ -31,10 +31,6 @@ function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv6
   (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
-}
-
 function {:extern} memory_store32_le(memory: [bv64]bv8, index: bv64, value: bv32) returns ([bv64]bv8) {
   memory[index := value[8:0]][bvadd64(index, 1bv64) := value[16:8]][bvadd64(index, 2bv64) := value[24:16]][bvadd64(index, 3bv64) := value[32:24]]
 }
@@ -44,10 +40,7 @@ procedure {:extern} rely();
   modifies Gamma_mem, mem;
   ensures (forall i: bv64 :: (((mem[i] == old(mem[i])) ==> (Gamma_mem[i] == old(Gamma_mem[i])))));
   ensures (memory_load32_le(mem, $x_addr) == old(memory_load32_le(mem, $x_addr)));
-  free ensures (memory_load8_le(mem, 1948bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1949bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1950bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1951bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1948bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69016bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69024bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69616bv64) == 1812bv64);
@@ -77,18 +70,12 @@ procedure main();
   modifies Gamma_R0, Gamma_R1, Gamma_mem, R0, R1, mem;
   free requires (memory_load64_le(mem, 69632bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free requires (memory_load8_le(mem, 1948bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1949bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1950bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1951bv64) == 0bv8);
+  free requires (memory_load32_le(mem, 1948bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69016bv64) == 1808bv64);
   free requires (memory_load64_le(mem, 69024bv64) == 1728bv64);
   free requires (memory_load64_le(mem, 69616bv64) == 1812bv64);
   free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free ensures (memory_load8_le(mem, 1948bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1949bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1950bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1951bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1948bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69016bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69024bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69616bv64) == 1812bv64);
diff --git a/src/test/incorrect/basicassign/gcc/basicassign_gtirb.expected b/src/test/incorrect/basicassign/gcc/basicassign_gtirb.expected
index 095bf3adc..19dc9e4c2 100644
--- a/src/test/incorrect/basicassign/gcc/basicassign_gtirb.expected
+++ b/src/test/incorrect/basicassign/gcc/basicassign_gtirb.expected
@@ -10,7 +10,7 @@ const {:extern} $x_addr: bv64;
 axiom ($x_addr == 69652bv64);
 const {:extern} $z_addr: bv64;
 axiom ($z_addr == 69656bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
   (if (index == $z_addr) then true else (if (index == $secret_addr) then false else (if (index == $x_addr) then false else false)))
 }
 
@@ -31,10 +31,6 @@ function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv6
   (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
-}
-
 function {:extern} memory_store32_le(memory: [bv64]bv8, index: bv64, value: bv32) returns ([bv64]bv8) {
   memory[index := value[8:0]][bvadd64(index, 1bv64) := value[16:8]][bvadd64(index, 2bv64) := value[24:16]][bvadd64(index, 3bv64) := value[32:24]]
 }
@@ -44,10 +40,7 @@ procedure {:extern} rely();
   modifies Gamma_mem, mem;
   ensures (forall i: bv64 :: (((mem[i] == old(mem[i])) ==> (Gamma_mem[i] == old(Gamma_mem[i])))));
   ensures (memory_load32_le(mem, $x_addr) == old(memory_load32_le(mem, $x_addr)));
-  free ensures (memory_load8_le(mem, 1948bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1949bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1950bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1951bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1948bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69016bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69024bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69616bv64) == 1812bv64);
@@ -77,18 +70,12 @@ procedure main();
   modifies Gamma_R0, Gamma_R1, Gamma_mem, R0, R1, mem;
   free requires (memory_load64_le(mem, 69632bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free requires (memory_load8_le(mem, 1948bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1949bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1950bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1951bv64) == 0bv8);
+  free requires (memory_load32_le(mem, 1948bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69016bv64) == 1808bv64);
   free requires (memory_load64_le(mem, 69024bv64) == 1728bv64);
   free requires (memory_load64_le(mem, 69616bv64) == 1812bv64);
   free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free ensures (memory_load8_le(mem, 1948bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1949bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1950bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1951bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1948bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69016bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69024bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69616bv64) == 1812bv64);
diff --git a/src/test/incorrect/basicassign/gcc_O2/basicassign.expected b/src/test/incorrect/basicassign/gcc_O2/basicassign.expected
index 49c578a07..d330626d5 100644
--- a/src/test/incorrect/basicassign/gcc_O2/basicassign.expected
+++ b/src/test/incorrect/basicassign/gcc_O2/basicassign.expected
@@ -12,7 +12,7 @@ const {:extern} $x_addr: bv64;
 axiom ($x_addr == 69656bv64);
 const {:extern} $z_addr: bv64;
 axiom ($z_addr == 69660bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
   (if (index == $z_addr) then true else (if (index == $secret_addr) then false else (if (index == $x_addr) then false else false)))
 }
 
@@ -33,10 +33,6 @@ function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv6
   (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
-}
-
 function {:extern} memory_store32_le(memory: [bv64]bv8, index: bv64, value: bv32) returns ([bv64]bv8) {
   memory[index := value[8:0]][bvadd64(index, 1bv64) := value[16:8]][bvadd64(index, 2bv64) := value[24:16]][bvadd64(index, 3bv64) := value[32:24]]
 }
@@ -46,10 +42,7 @@ procedure {:extern} rely();
   modifies Gamma_mem, mem;
   ensures (forall i: bv64 :: (((mem[i] == old(mem[i])) ==> (Gamma_mem[i] == old(Gamma_mem[i])))));
   ensures (memory_load32_le(mem, $x_addr) == old(memory_load32_le(mem, $x_addr)));
-  free ensures (memory_load8_le(mem, 1896bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1897bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1898bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1899bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1896bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69016bv64) == 1872bv64);
   free ensures (memory_load64_le(mem, 69024bv64) == 1792bv64);
   free ensures (memory_load64_le(mem, 69616bv64) == 1536bv64);
@@ -79,18 +72,12 @@ procedure main();
   modifies Gamma_R0, Gamma_R1, Gamma_R2, Gamma_mem, R0, R1, R2, mem;
   free requires (memory_load64_le(mem, 69632bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free requires (memory_load8_le(mem, 1896bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1897bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1898bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1899bv64) == 0bv8);
+  free requires (memory_load32_le(mem, 1896bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69016bv64) == 1872bv64);
   free requires (memory_load64_le(mem, 69024bv64) == 1792bv64);
   free requires (memory_load64_le(mem, 69616bv64) == 1536bv64);
   free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free ensures (memory_load8_le(mem, 1896bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1897bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1898bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1899bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1896bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69016bv64) == 1872bv64);
   free ensures (memory_load64_le(mem, 69024bv64) == 1792bv64);
   free ensures (memory_load64_le(mem, 69616bv64) == 1536bv64);
diff --git a/src/test/incorrect/basicassign/gcc_O2/basicassign_gtirb.expected b/src/test/incorrect/basicassign/gcc_O2/basicassign_gtirb.expected
index 9669ae7ca..48dec0790 100644
--- a/src/test/incorrect/basicassign/gcc_O2/basicassign_gtirb.expected
+++ b/src/test/incorrect/basicassign/gcc_O2/basicassign_gtirb.expected
@@ -12,7 +12,7 @@ const {:extern} $x_addr: bv64;
 axiom ($x_addr == 69656bv64);
 const {:extern} $z_addr: bv64;
 axiom ($z_addr == 69660bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
   (if (index == $z_addr) then true else (if (index == $secret_addr) then false else (if (index == $x_addr) then false else false)))
 }
 
@@ -33,10 +33,6 @@ function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv6
   (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
-}
-
 function {:extern} memory_store32_le(memory: [bv64]bv8, index: bv64, value: bv32) returns ([bv64]bv8) {
   memory[index := value[8:0]][bvadd64(index, 1bv64) := value[16:8]][bvadd64(index, 2bv64) := value[24:16]][bvadd64(index, 3bv64) := value[32:24]]
 }
@@ -46,10 +42,7 @@ procedure {:extern} rely();
   modifies Gamma_mem, mem;
   ensures (forall i: bv64 :: (((mem[i] == old(mem[i])) ==> (Gamma_mem[i] == old(Gamma_mem[i])))));
   ensures (memory_load32_le(mem, $x_addr) == old(memory_load32_le(mem, $x_addr)));
-  free ensures (memory_load8_le(mem, 1896bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1897bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1898bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1899bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1896bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69016bv64) == 1872bv64);
   free ensures (memory_load64_le(mem, 69024bv64) == 1792bv64);
   free ensures (memory_load64_le(mem, 69616bv64) == 1536bv64);
@@ -79,18 +72,12 @@ procedure main();
   modifies Gamma_R0, Gamma_R1, Gamma_R2, Gamma_mem, R0, R1, R2, mem;
   free requires (memory_load64_le(mem, 69632bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free requires (memory_load8_le(mem, 1896bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1897bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1898bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1899bv64) == 0bv8);
+  free requires (memory_load32_le(mem, 1896bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69016bv64) == 1872bv64);
   free requires (memory_load64_le(mem, 69024bv64) == 1792bv64);
   free requires (memory_load64_le(mem, 69616bv64) == 1536bv64);
   free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free ensures (memory_load8_le(mem, 1896bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1897bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1898bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1899bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1896bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69016bv64) == 1872bv64);
   free ensures (memory_load64_le(mem, 69024bv64) == 1792bv64);
   free ensures (memory_load64_le(mem, 69616bv64) == 1536bv64);
diff --git a/src/test/incorrect/basicassign/gcc_pic/basicassign.expected b/src/test/incorrect/basicassign/gcc_pic/basicassign.expected
index f87155f7a..e58a0dbe9 100644
--- a/src/test/incorrect/basicassign/gcc_pic/basicassign.expected
+++ b/src/test/incorrect/basicassign/gcc_pic/basicassign.expected
@@ -10,7 +10,7 @@ const {:extern} $x_addr: bv64;
 axiom ($x_addr == 69652bv64);
 const {:extern} $z_addr: bv64;
 axiom ($z_addr == 69656bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
   (if (index == $z_addr) then true else (if (index == $secret_addr) then false else (if (index == $x_addr) then false else false)))
 }
 
@@ -35,10 +35,6 @@ function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv6
   (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
-}
-
 function {:extern} memory_store32_le(memory: [bv64]bv8, index: bv64, value: bv32) returns ([bv64]bv8) {
   memory[index := value[8:0]][bvadd64(index, 1bv64) := value[16:8]][bvadd64(index, 2bv64) := value[24:16]][bvadd64(index, 3bv64) := value[32:24]]
 }
@@ -48,17 +44,14 @@ procedure {:extern} rely();
   modifies Gamma_mem, mem;
   ensures (forall i: bv64 :: (((mem[i] == old(mem[i])) ==> (Gamma_mem[i] == old(Gamma_mem[i])))));
   ensures (memory_load32_le(mem, $x_addr) == old(memory_load32_le(mem, $x_addr)));
-  free ensures (memory_load8_le(mem, 2012bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 2013bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 2014bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 2015bv64) == 0bv8);
-  free ensures (memory_load64_le(mem, 69608bv64) == 69660bv64);
-  free ensures (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free ensures (memory_load64_le(mem, 69616bv64) == 1876bv64);
+  free ensures (memory_load32_le(mem, 2012bv64) == 131073bv32);
+  free ensures (memory_load64_le(mem, 68992bv64) == 1872bv64);
+  free ensures (memory_load64_le(mem, 69000bv64) == 1792bv64);
   free ensures (memory_load64_le(mem, 69584bv64) == 69656bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 69652bv64);
-  free ensures (memory_load64_le(mem, 69000bv64) == 1792bv64);
-  free ensures (memory_load64_le(mem, 68992bv64) == 1872bv64);
+  free ensures (memory_load64_le(mem, 69608bv64) == 69660bv64);
+  free ensures (memory_load64_le(mem, 69616bv64) == 1876bv64);
+  free ensures (memory_load64_le(mem, 69640bv64) == 69640bv64);
 
 procedure {:extern} rely_transitive();
   modifies Gamma_mem, mem;
@@ -84,28 +77,22 @@ procedure main();
   modifies Gamma_R0, Gamma_R1, Gamma_mem, R0, R1, mem;
   free requires (memory_load64_le(mem, 69632bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free requires (memory_load8_le(mem, 2012bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 2013bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 2014bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 2015bv64) == 0bv8);
-  free requires (memory_load64_le(mem, 69608bv64) == 69660bv64);
-  free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free requires (memory_load64_le(mem, 69616bv64) == 1876bv64);
+  free requires (memory_load32_le(mem, 2012bv64) == 131073bv32);
+  free requires (memory_load64_le(mem, 68992bv64) == 1872bv64);
+  free requires (memory_load64_le(mem, 69000bv64) == 1792bv64);
   free requires (memory_load64_le(mem, 69584bv64) == 69656bv64);
   free requires (memory_load64_le(mem, 69592bv64) == 69652bv64);
-  free requires (memory_load64_le(mem, 69000bv64) == 1792bv64);
-  free requires (memory_load64_le(mem, 68992bv64) == 1872bv64);
-  free ensures (memory_load8_le(mem, 2012bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 2013bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 2014bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 2015bv64) == 0bv8);
-  free ensures (memory_load64_le(mem, 69608bv64) == 69660bv64);
-  free ensures (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free ensures (memory_load64_le(mem, 69616bv64) == 1876bv64);
+  free requires (memory_load64_le(mem, 69608bv64) == 69660bv64);
+  free requires (memory_load64_le(mem, 69616bv64) == 1876bv64);
+  free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
+  free ensures (memory_load32_le(mem, 2012bv64) == 131073bv32);
+  free ensures (memory_load64_le(mem, 68992bv64) == 1872bv64);
+  free ensures (memory_load64_le(mem, 69000bv64) == 1792bv64);
   free ensures (memory_load64_le(mem, 69584bv64) == 69656bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 69652bv64);
-  free ensures (memory_load64_le(mem, 69000bv64) == 1792bv64);
-  free ensures (memory_load64_le(mem, 68992bv64) == 1872bv64);
+  free ensures (memory_load64_le(mem, 69608bv64) == 69660bv64);
+  free ensures (memory_load64_le(mem, 69616bv64) == 1876bv64);
+  free ensures (memory_load64_le(mem, 69640bv64) == 69640bv64);
 
 implementation main()
 {
diff --git a/src/test/incorrect/basicassign/gcc_pic/basicassign_gtirb.expected b/src/test/incorrect/basicassign/gcc_pic/basicassign_gtirb.expected
index 5d4ca47a0..79aaba0e7 100644
--- a/src/test/incorrect/basicassign/gcc_pic/basicassign_gtirb.expected
+++ b/src/test/incorrect/basicassign/gcc_pic/basicassign_gtirb.expected
@@ -10,7 +10,7 @@ const {:extern} $x_addr: bv64;
 axiom ($x_addr == 69652bv64);
 const {:extern} $z_addr: bv64;
 axiom ($z_addr == 69656bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
   (if (index == $z_addr) then true else (if (index == $secret_addr) then false else (if (index == $x_addr) then false else false)))
 }
 
@@ -35,10 +35,6 @@ function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv6
   (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
-}
-
 function {:extern} memory_store32_le(memory: [bv64]bv8, index: bv64, value: bv32) returns ([bv64]bv8) {
   memory[index := value[8:0]][bvadd64(index, 1bv64) := value[16:8]][bvadd64(index, 2bv64) := value[24:16]][bvadd64(index, 3bv64) := value[32:24]]
 }
@@ -48,17 +44,14 @@ procedure {:extern} rely();
   modifies Gamma_mem, mem;
   ensures (forall i: bv64 :: (((mem[i] == old(mem[i])) ==> (Gamma_mem[i] == old(Gamma_mem[i])))));
   ensures (memory_load32_le(mem, $x_addr) == old(memory_load32_le(mem, $x_addr)));
-  free ensures (memory_load8_le(mem, 2012bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 2013bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 2014bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 2015bv64) == 0bv8);
-  free ensures (memory_load64_le(mem, 69608bv64) == 69660bv64);
-  free ensures (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free ensures (memory_load64_le(mem, 69616bv64) == 1876bv64);
+  free ensures (memory_load32_le(mem, 2012bv64) == 131073bv32);
+  free ensures (memory_load64_le(mem, 68992bv64) == 1872bv64);
+  free ensures (memory_load64_le(mem, 69000bv64) == 1792bv64);
   free ensures (memory_load64_le(mem, 69584bv64) == 69656bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 69652bv64);
-  free ensures (memory_load64_le(mem, 69000bv64) == 1792bv64);
-  free ensures (memory_load64_le(mem, 68992bv64) == 1872bv64);
+  free ensures (memory_load64_le(mem, 69608bv64) == 69660bv64);
+  free ensures (memory_load64_le(mem, 69616bv64) == 1876bv64);
+  free ensures (memory_load64_le(mem, 69640bv64) == 69640bv64);
 
 procedure {:extern} rely_transitive();
   modifies Gamma_mem, mem;
@@ -84,28 +77,22 @@ procedure main();
   modifies Gamma_R0, Gamma_R1, Gamma_mem, R0, R1, mem;
   free requires (memory_load64_le(mem, 69632bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free requires (memory_load8_le(mem, 2012bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 2013bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 2014bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 2015bv64) == 0bv8);
-  free requires (memory_load64_le(mem, 69608bv64) == 69660bv64);
-  free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free requires (memory_load64_le(mem, 69616bv64) == 1876bv64);
+  free requires (memory_load32_le(mem, 2012bv64) == 131073bv32);
+  free requires (memory_load64_le(mem, 68992bv64) == 1872bv64);
+  free requires (memory_load64_le(mem, 69000bv64) == 1792bv64);
   free requires (memory_load64_le(mem, 69584bv64) == 69656bv64);
   free requires (memory_load64_le(mem, 69592bv64) == 69652bv64);
-  free requires (memory_load64_le(mem, 69000bv64) == 1792bv64);
-  free requires (memory_load64_le(mem, 68992bv64) == 1872bv64);
-  free ensures (memory_load8_le(mem, 2012bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 2013bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 2014bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 2015bv64) == 0bv8);
-  free ensures (memory_load64_le(mem, 69608bv64) == 69660bv64);
-  free ensures (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free ensures (memory_load64_le(mem, 69616bv64) == 1876bv64);
+  free requires (memory_load64_le(mem, 69608bv64) == 69660bv64);
+  free requires (memory_load64_le(mem, 69616bv64) == 1876bv64);
+  free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
+  free ensures (memory_load32_le(mem, 2012bv64) == 131073bv32);
+  free ensures (memory_load64_le(mem, 68992bv64) == 1872bv64);
+  free ensures (memory_load64_le(mem, 69000bv64) == 1792bv64);
   free ensures (memory_load64_le(mem, 69584bv64) == 69656bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 69652bv64);
-  free ensures (memory_load64_le(mem, 69000bv64) == 1792bv64);
-  free ensures (memory_load64_le(mem, 68992bv64) == 1872bv64);
+  free ensures (memory_load64_le(mem, 69608bv64) == 69660bv64);
+  free ensures (memory_load64_le(mem, 69616bv64) == 1876bv64);
+  free ensures (memory_load64_le(mem, 69640bv64) == 69640bv64);
 
 implementation main()
 {
diff --git a/src/test/incorrect/basicassign1/clang/basicassign1.expected b/src/test/incorrect/basicassign1/clang/basicassign1.expected
index afb87ecdb..248887914 100644
--- a/src/test/incorrect/basicassign1/clang/basicassign1.expected
+++ b/src/test/incorrect/basicassign1/clang/basicassign1.expected
@@ -14,7 +14,7 @@ var {:extern} mem: [bv64]bv8;
 var {:extern} stack: [bv64]bv8;
 const {:extern} $z_addr: bv64;
 axiom ($z_addr == 69688bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
   (if (index == $z_addr) then true else false)
 }
 
@@ -35,10 +35,6 @@ function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv6
   (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
-}
-
 function {:extern} memory_store32_le(memory: [bv64]bv8, index: bv64, value: bv32) returns ([bv64]bv8) {
   memory[index := value[8:0]][bvadd64(index, 1bv64) := value[16:8]][bvadd64(index, 2bv64) := value[24:16]][bvadd64(index, 3bv64) := value[32:24]]
 }
@@ -46,12 +42,9 @@ function {:extern} memory_store32_le(memory: [bv64]bv8, index: bv64, value: bv32
 function {:extern} {:bvbuiltin "zero_extend 32"} zero_extend32_32(bv32) returns (bv64);
 procedure {:extern} rely();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
-  free ensures (memory_load8_le(mem, 1892bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1893bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1894bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1895bv64) == 0bv8);
+  ensures (mem == old(mem));
+  free ensures (memory_load32_le(mem, 1892bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1812bv64);
@@ -59,8 +52,8 @@ procedure {:extern} rely();
 
 procedure {:extern} rely_transitive();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
+  ensures (mem == old(mem));
 
 implementation {:extern} rely_transitive()
 {
@@ -77,20 +70,14 @@ procedure main();
   modifies Gamma_R0, Gamma_R10, Gamma_R31, Gamma_R8, Gamma_R9, Gamma_mem, Gamma_stack, R0, R10, R31, R8, R9, mem, stack;
   free requires (memory_load64_le(mem, 69664bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
-  free requires (memory_load8_le(mem, 1892bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1893bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1894bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1895bv64) == 0bv8);
+  free requires (memory_load32_le(mem, 1892bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free requires (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free requires (memory_load64_le(mem, 69592bv64) == 1812bv64);
   free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
   free ensures (Gamma_R31 == old(Gamma_R31));
   free ensures (R31 == old(R31));
-  free ensures (memory_load8_le(mem, 1892bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1893bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1894bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1895bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1892bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1812bv64);
diff --git a/src/test/incorrect/basicassign1/clang/basicassign1_gtirb.expected b/src/test/incorrect/basicassign1/clang/basicassign1_gtirb.expected
index 27c5c8876..faf8668f2 100644
--- a/src/test/incorrect/basicassign1/clang/basicassign1_gtirb.expected
+++ b/src/test/incorrect/basicassign1/clang/basicassign1_gtirb.expected
@@ -14,7 +14,7 @@ var {:extern} mem: [bv64]bv8;
 var {:extern} stack: [bv64]bv8;
 const {:extern} $z_addr: bv64;
 axiom ($z_addr == 69688bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
   (if (index == $z_addr) then true else false)
 }
 
@@ -35,10 +35,6 @@ function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv6
   (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
-}
-
 function {:extern} memory_store32_le(memory: [bv64]bv8, index: bv64, value: bv32) returns ([bv64]bv8) {
   memory[index := value[8:0]][bvadd64(index, 1bv64) := value[16:8]][bvadd64(index, 2bv64) := value[24:16]][bvadd64(index, 3bv64) := value[32:24]]
 }
@@ -46,12 +42,9 @@ function {:extern} memory_store32_le(memory: [bv64]bv8, index: bv64, value: bv32
 function {:extern} {:bvbuiltin "zero_extend 32"} zero_extend32_32(bv32) returns (bv64);
 procedure {:extern} rely();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
-  free ensures (memory_load8_le(mem, 1892bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1893bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1894bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1895bv64) == 0bv8);
+  ensures (mem == old(mem));
+  free ensures (memory_load32_le(mem, 1892bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1812bv64);
@@ -59,8 +52,8 @@ procedure {:extern} rely();
 
 procedure {:extern} rely_transitive();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
+  ensures (mem == old(mem));
 
 implementation {:extern} rely_transitive()
 {
@@ -77,20 +70,14 @@ procedure main();
   modifies Gamma_R0, Gamma_R10, Gamma_R31, Gamma_R8, Gamma_R9, Gamma_mem, Gamma_stack, R0, R10, R31, R8, R9, mem, stack;
   free requires (memory_load64_le(mem, 69664bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
-  free requires (memory_load8_le(mem, 1892bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1893bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1894bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1895bv64) == 0bv8);
+  free requires (memory_load32_le(mem, 1892bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free requires (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free requires (memory_load64_le(mem, 69592bv64) == 1812bv64);
   free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
   free ensures (Gamma_R31 == old(Gamma_R31));
   free ensures (R31 == old(R31));
-  free ensures (memory_load8_le(mem, 1892bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1893bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1894bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1895bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1892bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1812bv64);
diff --git a/src/test/incorrect/basicassign1/clang_O2/basicassign1.expected b/src/test/incorrect/basicassign1/clang_O2/basicassign1.expected
index af9853960..646c9e583 100644
--- a/src/test/incorrect/basicassign1/clang_O2/basicassign1.expected
+++ b/src/test/incorrect/basicassign1/clang_O2/basicassign1.expected
@@ -8,7 +8,7 @@ var {:extern} R9: bv64;
 var {:extern} mem: [bv64]bv8;
 const {:extern} $z_addr: bv64;
 axiom ($z_addr == 69688bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
   (if (index == $z_addr) then true else false)
 }
 
@@ -29,10 +29,6 @@ function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv6
   (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
-}
-
 function {:extern} memory_store32_le(memory: [bv64]bv8, index: bv64, value: bv32) returns ([bv64]bv8) {
   memory[index := value[8:0]][bvadd64(index, 1bv64) := value[16:8]][bvadd64(index, 2bv64) := value[24:16]][bvadd64(index, 3bv64) := value[32:24]]
 }
@@ -40,12 +36,9 @@ function {:extern} memory_store32_le(memory: [bv64]bv8, index: bv64, value: bv32
 function {:extern} {:bvbuiltin "zero_extend 32"} zero_extend32_32(bv32) returns (bv64);
 procedure {:extern} rely();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
-  free ensures (memory_load8_le(mem, 1856bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1857bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1858bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1859bv64) == 0bv8);
+  ensures (mem == old(mem));
+  free ensures (memory_load32_le(mem, 1856bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1812bv64);
@@ -53,8 +46,8 @@ procedure {:extern} rely();
 
 procedure {:extern} rely_transitive();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
+  ensures (mem == old(mem));
 
 implementation {:extern} rely_transitive()
 {
@@ -71,18 +64,12 @@ procedure main();
   modifies Gamma_R0, Gamma_R8, Gamma_R9, Gamma_mem, R0, R8, R9, mem;
   free requires (memory_load64_le(mem, 69664bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
-  free requires (memory_load8_le(mem, 1856bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1857bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1858bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1859bv64) == 0bv8);
+  free requires (memory_load32_le(mem, 1856bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free requires (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free requires (memory_load64_le(mem, 69592bv64) == 1812bv64);
   free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
-  free ensures (memory_load8_le(mem, 1856bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1857bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1858bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1859bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1856bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1812bv64);
diff --git a/src/test/incorrect/basicassign1/clang_O2/basicassign1_gtirb.expected b/src/test/incorrect/basicassign1/clang_O2/basicassign1_gtirb.expected
index d74bb0aff..82b0afd4c 100644
--- a/src/test/incorrect/basicassign1/clang_O2/basicassign1_gtirb.expected
+++ b/src/test/incorrect/basicassign1/clang_O2/basicassign1_gtirb.expected
@@ -8,7 +8,7 @@ var {:extern} R9: bv64;
 var {:extern} mem: [bv64]bv8;
 const {:extern} $z_addr: bv64;
 axiom ($z_addr == 69688bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
   (if (index == $z_addr) then true else false)
 }
 
@@ -29,10 +29,6 @@ function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv6
   (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
-}
-
 function {:extern} memory_store32_le(memory: [bv64]bv8, index: bv64, value: bv32) returns ([bv64]bv8) {
   memory[index := value[8:0]][bvadd64(index, 1bv64) := value[16:8]][bvadd64(index, 2bv64) := value[24:16]][bvadd64(index, 3bv64) := value[32:24]]
 }
@@ -40,12 +36,9 @@ function {:extern} memory_store32_le(memory: [bv64]bv8, index: bv64, value: bv32
 function {:extern} {:bvbuiltin "zero_extend 32"} zero_extend32_32(bv32) returns (bv64);
 procedure {:extern} rely();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
-  free ensures (memory_load8_le(mem, 1856bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1857bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1858bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1859bv64) == 0bv8);
+  ensures (mem == old(mem));
+  free ensures (memory_load32_le(mem, 1856bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1812bv64);
@@ -53,8 +46,8 @@ procedure {:extern} rely();
 
 procedure {:extern} rely_transitive();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
+  ensures (mem == old(mem));
 
 implementation {:extern} rely_transitive()
 {
@@ -71,18 +64,12 @@ procedure main();
   modifies Gamma_R0, Gamma_R8, Gamma_R9, Gamma_mem, R0, R8, R9, mem;
   free requires (memory_load64_le(mem, 69664bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
-  free requires (memory_load8_le(mem, 1856bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1857bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1858bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1859bv64) == 0bv8);
+  free requires (memory_load32_le(mem, 1856bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free requires (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free requires (memory_load64_le(mem, 69592bv64) == 1812bv64);
   free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
-  free ensures (memory_load8_le(mem, 1856bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1857bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1858bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1859bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1856bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1812bv64);
diff --git a/src/test/incorrect/basicassign1/clang_pic/basicassign1.expected b/src/test/incorrect/basicassign1/clang_pic/basicassign1.expected
index 0158c8e2d..4764ea3d6 100644
--- a/src/test/incorrect/basicassign1/clang_pic/basicassign1.expected
+++ b/src/test/incorrect/basicassign1/clang_pic/basicassign1.expected
@@ -14,7 +14,7 @@ var {:extern} mem: [bv64]bv8;
 var {:extern} stack: [bv64]bv8;
 const {:extern} $z_addr: bv64;
 axiom ($z_addr == 69688bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
   (if (index == $z_addr) then true else false)
 }
 
@@ -39,10 +39,6 @@ function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv6
   (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
-}
-
 function {:extern} memory_store32_le(memory: [bv64]bv8, index: bv64, value: bv32) returns ([bv64]bv8) {
   memory[index := value[8:0]][bvadd64(index, 1bv64) := value[16:8]][bvadd64(index, 2bv64) := value[24:16]][bvadd64(index, 3bv64) := value[32:24]]
 }
@@ -50,23 +46,20 @@ function {:extern} memory_store32_le(memory: [bv64]bv8, index: bv64, value: bv32
 function {:extern} {:bvbuiltin "zero_extend 32"} zero_extend32_32(bv32) returns (bv64);
 procedure {:extern} rely();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
-  free ensures (memory_load8_le(mem, 1964bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1965bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1966bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1967bv64) == 0bv8);
-  free ensures (memory_load64_le(mem, 69672bv64) == 69672bv64);
-  free ensures (memory_load64_le(mem, 69584bv64) == 69684bv64);
+  ensures (mem == old(mem));
+  free ensures (memory_load32_le(mem, 1964bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69048bv64) == 1872bv64);
+  free ensures (memory_load64_le(mem, 69056bv64) == 1792bv64);
   free ensures (memory_load64_le(mem, 69568bv64) == 69688bv64);
+  free ensures (memory_load64_le(mem, 69584bv64) == 69684bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1876bv64);
-  free ensures (memory_load64_le(mem, 69056bv64) == 1792bv64);
+  free ensures (memory_load64_le(mem, 69672bv64) == 69672bv64);
 
 procedure {:extern} rely_transitive();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
+  ensures (mem == old(mem));
 
 implementation {:extern} rely_transitive()
 {
@@ -83,28 +76,22 @@ procedure main();
   modifies Gamma_R0, Gamma_R10, Gamma_R31, Gamma_R8, Gamma_R9, Gamma_mem, Gamma_stack, R0, R10, R31, R8, R9, mem, stack;
   free requires (memory_load64_le(mem, 69664bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
-  free requires (memory_load8_le(mem, 1964bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1965bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1966bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1967bv64) == 0bv8);
-  free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
-  free requires (memory_load64_le(mem, 69584bv64) == 69684bv64);
+  free requires (memory_load32_le(mem, 1964bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69048bv64) == 1872bv64);
+  free requires (memory_load64_le(mem, 69056bv64) == 1792bv64);
   free requires (memory_load64_le(mem, 69568bv64) == 69688bv64);
+  free requires (memory_load64_le(mem, 69584bv64) == 69684bv64);
   free requires (memory_load64_le(mem, 69592bv64) == 1876bv64);
-  free requires (memory_load64_le(mem, 69056bv64) == 1792bv64);
+  free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
   free ensures (Gamma_R31 == old(Gamma_R31));
   free ensures (R31 == old(R31));
-  free ensures (memory_load8_le(mem, 1964bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1965bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1966bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1967bv64) == 0bv8);
-  free ensures (memory_load64_le(mem, 69672bv64) == 69672bv64);
-  free ensures (memory_load64_le(mem, 69584bv64) == 69684bv64);
+  free ensures (memory_load32_le(mem, 1964bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69048bv64) == 1872bv64);
+  free ensures (memory_load64_le(mem, 69056bv64) == 1792bv64);
   free ensures (memory_load64_le(mem, 69568bv64) == 69688bv64);
+  free ensures (memory_load64_le(mem, 69584bv64) == 69684bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1876bv64);
-  free ensures (memory_load64_le(mem, 69056bv64) == 1792bv64);
+  free ensures (memory_load64_le(mem, 69672bv64) == 69672bv64);
 
 implementation main()
 {
diff --git a/src/test/incorrect/basicassign1/clang_pic/basicassign1_gtirb.expected b/src/test/incorrect/basicassign1/clang_pic/basicassign1_gtirb.expected
index 4aa8567fc..2afdf2baf 100644
--- a/src/test/incorrect/basicassign1/clang_pic/basicassign1_gtirb.expected
+++ b/src/test/incorrect/basicassign1/clang_pic/basicassign1_gtirb.expected
@@ -14,7 +14,7 @@ var {:extern} mem: [bv64]bv8;
 var {:extern} stack: [bv64]bv8;
 const {:extern} $z_addr: bv64;
 axiom ($z_addr == 69688bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
   (if (index == $z_addr) then true else false)
 }
 
@@ -39,10 +39,6 @@ function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv6
   (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
-}
-
 function {:extern} memory_store32_le(memory: [bv64]bv8, index: bv64, value: bv32) returns ([bv64]bv8) {
   memory[index := value[8:0]][bvadd64(index, 1bv64) := value[16:8]][bvadd64(index, 2bv64) := value[24:16]][bvadd64(index, 3bv64) := value[32:24]]
 }
@@ -50,23 +46,20 @@ function {:extern} memory_store32_le(memory: [bv64]bv8, index: bv64, value: bv32
 function {:extern} {:bvbuiltin "zero_extend 32"} zero_extend32_32(bv32) returns (bv64);
 procedure {:extern} rely();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
-  free ensures (memory_load8_le(mem, 1964bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1965bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1966bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1967bv64) == 0bv8);
-  free ensures (memory_load64_le(mem, 69672bv64) == 69672bv64);
-  free ensures (memory_load64_le(mem, 69584bv64) == 69684bv64);
+  ensures (mem == old(mem));
+  free ensures (memory_load32_le(mem, 1964bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69048bv64) == 1872bv64);
+  free ensures (memory_load64_le(mem, 69056bv64) == 1792bv64);
   free ensures (memory_load64_le(mem, 69568bv64) == 69688bv64);
+  free ensures (memory_load64_le(mem, 69584bv64) == 69684bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1876bv64);
-  free ensures (memory_load64_le(mem, 69056bv64) == 1792bv64);
+  free ensures (memory_load64_le(mem, 69672bv64) == 69672bv64);
 
 procedure {:extern} rely_transitive();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
+  ensures (mem == old(mem));
 
 implementation {:extern} rely_transitive()
 {
@@ -83,28 +76,22 @@ procedure main();
   modifies Gamma_R0, Gamma_R10, Gamma_R31, Gamma_R8, Gamma_R9, Gamma_mem, Gamma_stack, R0, R10, R31, R8, R9, mem, stack;
   free requires (memory_load64_le(mem, 69664bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
-  free requires (memory_load8_le(mem, 1964bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1965bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1966bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1967bv64) == 0bv8);
-  free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
-  free requires (memory_load64_le(mem, 69584bv64) == 69684bv64);
+  free requires (memory_load32_le(mem, 1964bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69048bv64) == 1872bv64);
+  free requires (memory_load64_le(mem, 69056bv64) == 1792bv64);
   free requires (memory_load64_le(mem, 69568bv64) == 69688bv64);
+  free requires (memory_load64_le(mem, 69584bv64) == 69684bv64);
   free requires (memory_load64_le(mem, 69592bv64) == 1876bv64);
-  free requires (memory_load64_le(mem, 69056bv64) == 1792bv64);
+  free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
   free ensures (Gamma_R31 == old(Gamma_R31));
   free ensures (R31 == old(R31));
-  free ensures (memory_load8_le(mem, 1964bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1965bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1966bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1967bv64) == 0bv8);
-  free ensures (memory_load64_le(mem, 69672bv64) == 69672bv64);
-  free ensures (memory_load64_le(mem, 69584bv64) == 69684bv64);
+  free ensures (memory_load32_le(mem, 1964bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69048bv64) == 1872bv64);
+  free ensures (memory_load64_le(mem, 69056bv64) == 1792bv64);
   free ensures (memory_load64_le(mem, 69568bv64) == 69688bv64);
+  free ensures (memory_load64_le(mem, 69584bv64) == 69684bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1876bv64);
-  free ensures (memory_load64_le(mem, 69056bv64) == 1792bv64);
+  free ensures (memory_load64_le(mem, 69672bv64) == 69672bv64);
 
 implementation main()
 {
diff --git a/src/test/incorrect/basicassign1/gcc/basicassign1.expected b/src/test/incorrect/basicassign1/gcc/basicassign1.expected
index 192c82d15..d9baf8698 100644
--- a/src/test/incorrect/basicassign1/gcc/basicassign1.expected
+++ b/src/test/incorrect/basicassign1/gcc/basicassign1.expected
@@ -10,7 +10,7 @@ var {:extern} mem: [bv64]bv8;
 var {:extern} stack: [bv64]bv8;
 const {:extern} $z_addr: bv64;
 axiom ($z_addr == 69652bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
   (if (index == $z_addr) then true else false)
 }
 
@@ -31,10 +31,6 @@ function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv6
   (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
-}
-
 function {:extern} memory_store32_le(memory: [bv64]bv8, index: bv64, value: bv32) returns ([bv64]bv8) {
   memory[index := value[8:0]][bvadd64(index, 1bv64) := value[16:8]][bvadd64(index, 2bv64) := value[24:16]][bvadd64(index, 3bv64) := value[32:24]]
 }
@@ -42,12 +38,9 @@ function {:extern} memory_store32_le(memory: [bv64]bv8, index: bv64, value: bv32
 function {:extern} {:bvbuiltin "zero_extend 32"} zero_extend32_32(bv32) returns (bv64);
 procedure {:extern} rely();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
-  free ensures (memory_load8_le(mem, 1916bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1917bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1918bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1919bv64) == 0bv8);
+  ensures (mem == old(mem));
+  free ensures (memory_load32_le(mem, 1916bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69016bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69024bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69616bv64) == 1812bv64);
@@ -55,8 +48,8 @@ procedure {:extern} rely();
 
 procedure {:extern} rely_transitive();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
+  ensures (mem == old(mem));
 
 implementation {:extern} rely_transitive()
 {
@@ -73,20 +66,14 @@ procedure main();
   modifies Gamma_R0, Gamma_R1, Gamma_R31, Gamma_mem, Gamma_stack, R0, R1, R31, mem, stack;
   free requires (memory_load64_le(mem, 69632bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free requires (memory_load8_le(mem, 1916bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1917bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1918bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1919bv64) == 0bv8);
+  free requires (memory_load32_le(mem, 1916bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69016bv64) == 1808bv64);
   free requires (memory_load64_le(mem, 69024bv64) == 1728bv64);
   free requires (memory_load64_le(mem, 69616bv64) == 1812bv64);
   free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
   free ensures (Gamma_R31 == old(Gamma_R31));
   free ensures (R31 == old(R31));
-  free ensures (memory_load8_le(mem, 1916bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1917bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1918bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1919bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1916bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69016bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69024bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69616bv64) == 1812bv64);
diff --git a/src/test/incorrect/basicassign1/gcc/basicassign1_gtirb.expected b/src/test/incorrect/basicassign1/gcc/basicassign1_gtirb.expected
index 92d417367..3e998dfcb 100644
--- a/src/test/incorrect/basicassign1/gcc/basicassign1_gtirb.expected
+++ b/src/test/incorrect/basicassign1/gcc/basicassign1_gtirb.expected
@@ -10,7 +10,7 @@ var {:extern} mem: [bv64]bv8;
 var {:extern} stack: [bv64]bv8;
 const {:extern} $z_addr: bv64;
 axiom ($z_addr == 69652bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
   (if (index == $z_addr) then true else false)
 }
 
@@ -31,10 +31,6 @@ function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv6
   (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
-}
-
 function {:extern} memory_store32_le(memory: [bv64]bv8, index: bv64, value: bv32) returns ([bv64]bv8) {
   memory[index := value[8:0]][bvadd64(index, 1bv64) := value[16:8]][bvadd64(index, 2bv64) := value[24:16]][bvadd64(index, 3bv64) := value[32:24]]
 }
@@ -42,12 +38,9 @@ function {:extern} memory_store32_le(memory: [bv64]bv8, index: bv64, value: bv32
 function {:extern} {:bvbuiltin "zero_extend 32"} zero_extend32_32(bv32) returns (bv64);
 procedure {:extern} rely();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
-  free ensures (memory_load8_le(mem, 1916bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1917bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1918bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1919bv64) == 0bv8);
+  ensures (mem == old(mem));
+  free ensures (memory_load32_le(mem, 1916bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69016bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69024bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69616bv64) == 1812bv64);
@@ -55,8 +48,8 @@ procedure {:extern} rely();
 
 procedure {:extern} rely_transitive();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
+  ensures (mem == old(mem));
 
 implementation {:extern} rely_transitive()
 {
@@ -73,20 +66,14 @@ procedure main();
   modifies Gamma_R0, Gamma_R1, Gamma_R31, Gamma_mem, Gamma_stack, R0, R1, R31, mem, stack;
   free requires (memory_load64_le(mem, 69632bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free requires (memory_load8_le(mem, 1916bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1917bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1918bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1919bv64) == 0bv8);
+  free requires (memory_load32_le(mem, 1916bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69016bv64) == 1808bv64);
   free requires (memory_load64_le(mem, 69024bv64) == 1728bv64);
   free requires (memory_load64_le(mem, 69616bv64) == 1812bv64);
   free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
   free ensures (Gamma_R31 == old(Gamma_R31));
   free ensures (R31 == old(R31));
-  free ensures (memory_load8_le(mem, 1916bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1917bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1918bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1919bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1916bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69016bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69024bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69616bv64) == 1812bv64);
diff --git a/src/test/incorrect/basicassign1/gcc_O2/basicassign1.expected b/src/test/incorrect/basicassign1/gcc_O2/basicassign1.expected
index 9fcdcc2bc..114827622 100644
--- a/src/test/incorrect/basicassign1/gcc_O2/basicassign1.expected
+++ b/src/test/incorrect/basicassign1/gcc_O2/basicassign1.expected
@@ -8,7 +8,7 @@ var {:extern} R2: bv64;
 var {:extern} mem: [bv64]bv8;
 const {:extern} $z_addr: bv64;
 axiom ($z_addr == 69652bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
   (if (index == $z_addr) then true else false)
 }
 
@@ -29,10 +29,6 @@ function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv6
   (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
-}
-
 function {:extern} memory_store32_le(memory: [bv64]bv8, index: bv64, value: bv32) returns ([bv64]bv8) {
   memory[index := value[8:0]][bvadd64(index, 1bv64) := value[16:8]][bvadd64(index, 2bv64) := value[24:16]][bvadd64(index, 3bv64) := value[32:24]]
 }
@@ -40,12 +36,9 @@ function {:extern} memory_store32_le(memory: [bv64]bv8, index: bv64, value: bv32
 function {:extern} {:bvbuiltin "zero_extend 32"} zero_extend32_32(bv32) returns (bv64);
 procedure {:extern} rely();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
-  free ensures (memory_load8_le(mem, 1896bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1897bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1898bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1899bv64) == 0bv8);
+  ensures (mem == old(mem));
+  free ensures (memory_load32_le(mem, 1896bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69016bv64) == 1872bv64);
   free ensures (memory_load64_le(mem, 69024bv64) == 1792bv64);
   free ensures (memory_load64_le(mem, 69616bv64) == 1536bv64);
@@ -53,8 +46,8 @@ procedure {:extern} rely();
 
 procedure {:extern} rely_transitive();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
+  ensures (mem == old(mem));
 
 implementation {:extern} rely_transitive()
 {
@@ -71,18 +64,12 @@ procedure main();
   modifies Gamma_R0, Gamma_R1, Gamma_R2, Gamma_mem, R0, R1, R2, mem;
   free requires (memory_load64_le(mem, 69632bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free requires (memory_load8_le(mem, 1896bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1897bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1898bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1899bv64) == 0bv8);
+  free requires (memory_load32_le(mem, 1896bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69016bv64) == 1872bv64);
   free requires (memory_load64_le(mem, 69024bv64) == 1792bv64);
   free requires (memory_load64_le(mem, 69616bv64) == 1536bv64);
   free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free ensures (memory_load8_le(mem, 1896bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1897bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1898bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1899bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1896bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69016bv64) == 1872bv64);
   free ensures (memory_load64_le(mem, 69024bv64) == 1792bv64);
   free ensures (memory_load64_le(mem, 69616bv64) == 1536bv64);
diff --git a/src/test/incorrect/basicassign1/gcc_O2/basicassign1_gtirb.expected b/src/test/incorrect/basicassign1/gcc_O2/basicassign1_gtirb.expected
index 7ef5b5223..391a905c7 100644
--- a/src/test/incorrect/basicassign1/gcc_O2/basicassign1_gtirb.expected
+++ b/src/test/incorrect/basicassign1/gcc_O2/basicassign1_gtirb.expected
@@ -8,7 +8,7 @@ var {:extern} R2: bv64;
 var {:extern} mem: [bv64]bv8;
 const {:extern} $z_addr: bv64;
 axiom ($z_addr == 69652bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
   (if (index == $z_addr) then true else false)
 }
 
@@ -29,10 +29,6 @@ function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv6
   (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
-}
-
 function {:extern} memory_store32_le(memory: [bv64]bv8, index: bv64, value: bv32) returns ([bv64]bv8) {
   memory[index := value[8:0]][bvadd64(index, 1bv64) := value[16:8]][bvadd64(index, 2bv64) := value[24:16]][bvadd64(index, 3bv64) := value[32:24]]
 }
@@ -40,12 +36,9 @@ function {:extern} memory_store32_le(memory: [bv64]bv8, index: bv64, value: bv32
 function {:extern} {:bvbuiltin "zero_extend 32"} zero_extend32_32(bv32) returns (bv64);
 procedure {:extern} rely();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
-  free ensures (memory_load8_le(mem, 1896bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1897bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1898bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1899bv64) == 0bv8);
+  ensures (mem == old(mem));
+  free ensures (memory_load32_le(mem, 1896bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69016bv64) == 1872bv64);
   free ensures (memory_load64_le(mem, 69024bv64) == 1792bv64);
   free ensures (memory_load64_le(mem, 69616bv64) == 1536bv64);
@@ -53,8 +46,8 @@ procedure {:extern} rely();
 
 procedure {:extern} rely_transitive();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
+  ensures (mem == old(mem));
 
 implementation {:extern} rely_transitive()
 {
@@ -71,18 +64,12 @@ procedure main();
   modifies Gamma_R0, Gamma_R1, Gamma_R2, Gamma_mem, R0, R1, R2, mem;
   free requires (memory_load64_le(mem, 69632bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free requires (memory_load8_le(mem, 1896bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1897bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1898bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1899bv64) == 0bv8);
+  free requires (memory_load32_le(mem, 1896bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69016bv64) == 1872bv64);
   free requires (memory_load64_le(mem, 69024bv64) == 1792bv64);
   free requires (memory_load64_le(mem, 69616bv64) == 1536bv64);
   free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free ensures (memory_load8_le(mem, 1896bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1897bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1898bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1899bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1896bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69016bv64) == 1872bv64);
   free ensures (memory_load64_le(mem, 69024bv64) == 1792bv64);
   free ensures (memory_load64_le(mem, 69616bv64) == 1536bv64);
diff --git a/src/test/incorrect/basicassign1/gcc_pic/basicassign1.expected b/src/test/incorrect/basicassign1/gcc_pic/basicassign1.expected
index 2359fdec8..13d8861f3 100644
--- a/src/test/incorrect/basicassign1/gcc_pic/basicassign1.expected
+++ b/src/test/incorrect/basicassign1/gcc_pic/basicassign1.expected
@@ -10,7 +10,7 @@ var {:extern} mem: [bv64]bv8;
 var {:extern} stack: [bv64]bv8;
 const {:extern} $z_addr: bv64;
 axiom ($z_addr == 69652bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
   (if (index == $z_addr) then true else false)
 }
 
@@ -35,10 +35,6 @@ function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv6
   (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
-}
-
 function {:extern} memory_store32_le(memory: [bv64]bv8, index: bv64, value: bv32) returns ([bv64]bv8) {
   memory[index := value[8:0]][bvadd64(index, 1bv64) := value[16:8]][bvadd64(index, 2bv64) := value[24:16]][bvadd64(index, 3bv64) := value[32:24]]
 }
@@ -46,23 +42,20 @@ function {:extern} memory_store32_le(memory: [bv64]bv8, index: bv64, value: bv32
 function {:extern} {:bvbuiltin "zero_extend 32"} zero_extend32_32(bv32) returns (bv64);
 procedure {:extern} rely();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
-  free ensures (memory_load8_le(mem, 1980bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1981bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1982bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1983bv64) == 0bv8);
-  free ensures (memory_load64_le(mem, 69608bv64) == 69656bv64);
-  free ensures (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free ensures (memory_load64_le(mem, 69616bv64) == 1876bv64);
+  ensures (mem == old(mem));
+  free ensures (memory_load32_le(mem, 1980bv64) == 131073bv32);
+  free ensures (memory_load64_le(mem, 69000bv64) == 1872bv64);
   free ensures (memory_load64_le(mem, 69008bv64) == 1792bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 69652bv64);
-  free ensures (memory_load64_le(mem, 69000bv64) == 1872bv64);
+  free ensures (memory_load64_le(mem, 69608bv64) == 69656bv64);
+  free ensures (memory_load64_le(mem, 69616bv64) == 1876bv64);
+  free ensures (memory_load64_le(mem, 69640bv64) == 69640bv64);
 
 procedure {:extern} rely_transitive();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
+  ensures (mem == old(mem));
 
 implementation {:extern} rely_transitive()
 {
@@ -79,28 +72,22 @@ procedure main();
   modifies Gamma_R0, Gamma_R1, Gamma_R31, Gamma_mem, Gamma_stack, R0, R1, R31, mem, stack;
   free requires (memory_load64_le(mem, 69632bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free requires (memory_load8_le(mem, 1980bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1981bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1982bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1983bv64) == 0bv8);
-  free requires (memory_load64_le(mem, 69608bv64) == 69656bv64);
-  free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free requires (memory_load64_le(mem, 69616bv64) == 1876bv64);
+  free requires (memory_load32_le(mem, 1980bv64) == 131073bv32);
+  free requires (memory_load64_le(mem, 69000bv64) == 1872bv64);
   free requires (memory_load64_le(mem, 69008bv64) == 1792bv64);
   free requires (memory_load64_le(mem, 69592bv64) == 69652bv64);
-  free requires (memory_load64_le(mem, 69000bv64) == 1872bv64);
+  free requires (memory_load64_le(mem, 69608bv64) == 69656bv64);
+  free requires (memory_load64_le(mem, 69616bv64) == 1876bv64);
+  free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
   free ensures (Gamma_R31 == old(Gamma_R31));
   free ensures (R31 == old(R31));
-  free ensures (memory_load8_le(mem, 1980bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1981bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1982bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1983bv64) == 0bv8);
-  free ensures (memory_load64_le(mem, 69608bv64) == 69656bv64);
-  free ensures (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free ensures (memory_load64_le(mem, 69616bv64) == 1876bv64);
+  free ensures (memory_load32_le(mem, 1980bv64) == 131073bv32);
+  free ensures (memory_load64_le(mem, 69000bv64) == 1872bv64);
   free ensures (memory_load64_le(mem, 69008bv64) == 1792bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 69652bv64);
-  free ensures (memory_load64_le(mem, 69000bv64) == 1872bv64);
+  free ensures (memory_load64_le(mem, 69608bv64) == 69656bv64);
+  free ensures (memory_load64_le(mem, 69616bv64) == 1876bv64);
+  free ensures (memory_load64_le(mem, 69640bv64) == 69640bv64);
 
 implementation main()
 {
diff --git a/src/test/incorrect/basicassign1/gcc_pic/basicassign1_gtirb.expected b/src/test/incorrect/basicassign1/gcc_pic/basicassign1_gtirb.expected
index c9d86040b..207860a9c 100644
--- a/src/test/incorrect/basicassign1/gcc_pic/basicassign1_gtirb.expected
+++ b/src/test/incorrect/basicassign1/gcc_pic/basicassign1_gtirb.expected
@@ -10,7 +10,7 @@ var {:extern} mem: [bv64]bv8;
 var {:extern} stack: [bv64]bv8;
 const {:extern} $z_addr: bv64;
 axiom ($z_addr == 69652bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
   (if (index == $z_addr) then true else false)
 }
 
@@ -35,10 +35,6 @@ function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv6
   (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
-}
-
 function {:extern} memory_store32_le(memory: [bv64]bv8, index: bv64, value: bv32) returns ([bv64]bv8) {
   memory[index := value[8:0]][bvadd64(index, 1bv64) := value[16:8]][bvadd64(index, 2bv64) := value[24:16]][bvadd64(index, 3bv64) := value[32:24]]
 }
@@ -46,23 +42,20 @@ function {:extern} memory_store32_le(memory: [bv64]bv8, index: bv64, value: bv32
 function {:extern} {:bvbuiltin "zero_extend 32"} zero_extend32_32(bv32) returns (bv64);
 procedure {:extern} rely();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
-  free ensures (memory_load8_le(mem, 1980bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1981bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1982bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1983bv64) == 0bv8);
-  free ensures (memory_load64_le(mem, 69608bv64) == 69656bv64);
-  free ensures (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free ensures (memory_load64_le(mem, 69616bv64) == 1876bv64);
+  ensures (mem == old(mem));
+  free ensures (memory_load32_le(mem, 1980bv64) == 131073bv32);
+  free ensures (memory_load64_le(mem, 69000bv64) == 1872bv64);
   free ensures (memory_load64_le(mem, 69008bv64) == 1792bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 69652bv64);
-  free ensures (memory_load64_le(mem, 69000bv64) == 1872bv64);
+  free ensures (memory_load64_le(mem, 69608bv64) == 69656bv64);
+  free ensures (memory_load64_le(mem, 69616bv64) == 1876bv64);
+  free ensures (memory_load64_le(mem, 69640bv64) == 69640bv64);
 
 procedure {:extern} rely_transitive();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
+  ensures (mem == old(mem));
 
 implementation {:extern} rely_transitive()
 {
@@ -79,28 +72,22 @@ procedure main();
   modifies Gamma_R0, Gamma_R1, Gamma_R31, Gamma_mem, Gamma_stack, R0, R1, R31, mem, stack;
   free requires (memory_load64_le(mem, 69632bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free requires (memory_load8_le(mem, 1980bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1981bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1982bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1983bv64) == 0bv8);
-  free requires (memory_load64_le(mem, 69608bv64) == 69656bv64);
-  free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free requires (memory_load64_le(mem, 69616bv64) == 1876bv64);
+  free requires (memory_load32_le(mem, 1980bv64) == 131073bv32);
+  free requires (memory_load64_le(mem, 69000bv64) == 1872bv64);
   free requires (memory_load64_le(mem, 69008bv64) == 1792bv64);
   free requires (memory_load64_le(mem, 69592bv64) == 69652bv64);
-  free requires (memory_load64_le(mem, 69000bv64) == 1872bv64);
+  free requires (memory_load64_le(mem, 69608bv64) == 69656bv64);
+  free requires (memory_load64_le(mem, 69616bv64) == 1876bv64);
+  free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
   free ensures (Gamma_R31 == old(Gamma_R31));
   free ensures (R31 == old(R31));
-  free ensures (memory_load8_le(mem, 1980bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1981bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1982bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1983bv64) == 0bv8);
-  free ensures (memory_load64_le(mem, 69608bv64) == 69656bv64);
-  free ensures (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free ensures (memory_load64_le(mem, 69616bv64) == 1876bv64);
+  free ensures (memory_load32_le(mem, 1980bv64) == 131073bv32);
+  free ensures (memory_load64_le(mem, 69000bv64) == 1872bv64);
   free ensures (memory_load64_le(mem, 69008bv64) == 1792bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 69652bv64);
-  free ensures (memory_load64_le(mem, 69000bv64) == 1872bv64);
+  free ensures (memory_load64_le(mem, 69608bv64) == 69656bv64);
+  free ensures (memory_load64_le(mem, 69616bv64) == 1876bv64);
+  free ensures (memory_load64_le(mem, 69640bv64) == 69640bv64);
 
 implementation main()
 {
diff --git a/src/test/incorrect/basicassign2/clang/basicassign2.expected b/src/test/incorrect/basicassign2/clang/basicassign2.expected
index 61c920226..df488c4d1 100644
--- a/src/test/incorrect/basicassign2/clang/basicassign2.expected
+++ b/src/test/incorrect/basicassign2/clang/basicassign2.expected
@@ -16,7 +16,7 @@ const {:extern} $secret_addr: bv64;
 axiom ($secret_addr == 69688bv64);
 const {:extern} $z_addr: bv64;
 axiom ($z_addr == 69696bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
   (if (index == $z_addr) then true else (if (index == $secret_addr) then false else false))
 }
 
@@ -29,12 +29,12 @@ function {:extern} gamma_store64(gammaMap: [bv64]bool, index: bv64, value: bool)
   gammaMap[index := value][bvadd64(index, 1bv64) := value][bvadd64(index, 2bv64) := value][bvadd64(index, 3bv64) := value][bvadd64(index, 4bv64) := value][bvadd64(index, 5bv64) := value][bvadd64(index, 6bv64) := value][bvadd64(index, 7bv64) := value]
 }
 
-function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv64) {
-  (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
+function {:extern} memory_load32_le(memory: [bv64]bv8, index: bv64) returns (bv32) {
+  (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
+function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv64) {
+  (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
 function {:extern} memory_store64_le(memory: [bv64]bv8, index: bv64, value: bv64) returns ([bv64]bv8) {
@@ -43,12 +43,9 @@ function {:extern} memory_store64_le(memory: [bv64]bv8, index: bv64, value: bv64
 
 procedure {:extern} rely();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
-  free ensures (memory_load8_le(mem, 1892bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1893bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1894bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1895bv64) == 0bv8);
+  ensures (mem == old(mem));
+  free ensures (memory_load32_le(mem, 1892bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1812bv64);
@@ -56,8 +53,8 @@ procedure {:extern} rely();
 
 procedure {:extern} rely_transitive();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
+  ensures (mem == old(mem));
 
 implementation {:extern} rely_transitive()
 {
@@ -74,20 +71,14 @@ procedure main();
   modifies Gamma_R0, Gamma_R10, Gamma_R31, Gamma_R8, Gamma_R9, Gamma_mem, Gamma_stack, R0, R10, R31, R8, R9, mem, stack;
   free requires (memory_load64_le(mem, 69664bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
-  free requires (memory_load8_le(mem, 1892bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1893bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1894bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1895bv64) == 0bv8);
+  free requires (memory_load32_le(mem, 1892bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free requires (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free requires (memory_load64_le(mem, 69592bv64) == 1812bv64);
   free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
   free ensures (Gamma_R31 == old(Gamma_R31));
   free ensures (R31 == old(R31));
-  free ensures (memory_load8_le(mem, 1892bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1893bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1894bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1895bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1892bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1812bv64);
diff --git a/src/test/incorrect/basicassign2/clang/basicassign2_gtirb.expected b/src/test/incorrect/basicassign2/clang/basicassign2_gtirb.expected
index 0d8b20ef0..95de0c100 100644
--- a/src/test/incorrect/basicassign2/clang/basicassign2_gtirb.expected
+++ b/src/test/incorrect/basicassign2/clang/basicassign2_gtirb.expected
@@ -16,7 +16,7 @@ const {:extern} $secret_addr: bv64;
 axiom ($secret_addr == 69688bv64);
 const {:extern} $z_addr: bv64;
 axiom ($z_addr == 69696bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
   (if (index == $z_addr) then true else (if (index == $secret_addr) then false else false))
 }
 
@@ -29,12 +29,12 @@ function {:extern} gamma_store64(gammaMap: [bv64]bool, index: bv64, value: bool)
   gammaMap[index := value][bvadd64(index, 1bv64) := value][bvadd64(index, 2bv64) := value][bvadd64(index, 3bv64) := value][bvadd64(index, 4bv64) := value][bvadd64(index, 5bv64) := value][bvadd64(index, 6bv64) := value][bvadd64(index, 7bv64) := value]
 }
 
-function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv64) {
-  (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
+function {:extern} memory_load32_le(memory: [bv64]bv8, index: bv64) returns (bv32) {
+  (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
+function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv64) {
+  (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
 function {:extern} memory_store64_le(memory: [bv64]bv8, index: bv64, value: bv64) returns ([bv64]bv8) {
@@ -43,12 +43,9 @@ function {:extern} memory_store64_le(memory: [bv64]bv8, index: bv64, value: bv64
 
 procedure {:extern} rely();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
-  free ensures (memory_load8_le(mem, 1892bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1893bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1894bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1895bv64) == 0bv8);
+  ensures (mem == old(mem));
+  free ensures (memory_load32_le(mem, 1892bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1812bv64);
@@ -56,8 +53,8 @@ procedure {:extern} rely();
 
 procedure {:extern} rely_transitive();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
+  ensures (mem == old(mem));
 
 implementation {:extern} rely_transitive()
 {
@@ -74,20 +71,14 @@ procedure main();
   modifies Gamma_R0, Gamma_R10, Gamma_R31, Gamma_R8, Gamma_R9, Gamma_mem, Gamma_stack, R0, R10, R31, R8, R9, mem, stack;
   free requires (memory_load64_le(mem, 69664bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
-  free requires (memory_load8_le(mem, 1892bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1893bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1894bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1895bv64) == 0bv8);
+  free requires (memory_load32_le(mem, 1892bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free requires (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free requires (memory_load64_le(mem, 69592bv64) == 1812bv64);
   free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
   free ensures (Gamma_R31 == old(Gamma_R31));
   free ensures (R31 == old(R31));
-  free ensures (memory_load8_le(mem, 1892bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1893bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1894bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1895bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1892bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1812bv64);
diff --git a/src/test/incorrect/basicassign2/clang_O2/basicassign2.expected b/src/test/incorrect/basicassign2/clang_O2/basicassign2.expected
index 9b9dc95d6..55eab7986 100644
--- a/src/test/incorrect/basicassign2/clang_O2/basicassign2.expected
+++ b/src/test/incorrect/basicassign2/clang_O2/basicassign2.expected
@@ -10,7 +10,7 @@ const {:extern} $secret_addr: bv64;
 axiom ($secret_addr == 69688bv64);
 const {:extern} $z_addr: bv64;
 axiom ($z_addr == 69696bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
   (if (index == $z_addr) then true else (if (index == $secret_addr) then false else false))
 }
 
@@ -23,12 +23,12 @@ function {:extern} gamma_store64(gammaMap: [bv64]bool, index: bv64, value: bool)
   gammaMap[index := value][bvadd64(index, 1bv64) := value][bvadd64(index, 2bv64) := value][bvadd64(index, 3bv64) := value][bvadd64(index, 4bv64) := value][bvadd64(index, 5bv64) := value][bvadd64(index, 6bv64) := value][bvadd64(index, 7bv64) := value]
 }
 
-function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv64) {
-  (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
+function {:extern} memory_load32_le(memory: [bv64]bv8, index: bv64) returns (bv32) {
+  (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
+function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv64) {
+  (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
 function {:extern} memory_store64_le(memory: [bv64]bv8, index: bv64, value: bv64) returns ([bv64]bv8) {
@@ -37,12 +37,9 @@ function {:extern} memory_store64_le(memory: [bv64]bv8, index: bv64, value: bv64
 
 procedure {:extern} rely();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
-  free ensures (memory_load8_le(mem, 1856bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1857bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1858bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1859bv64) == 0bv8);
+  ensures (mem == old(mem));
+  free ensures (memory_load32_le(mem, 1856bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1812bv64);
@@ -50,8 +47,8 @@ procedure {:extern} rely();
 
 procedure {:extern} rely_transitive();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
+  ensures (mem == old(mem));
 
 implementation {:extern} rely_transitive()
 {
@@ -68,18 +65,12 @@ procedure main();
   modifies Gamma_R0, Gamma_R8, Gamma_R9, Gamma_mem, R0, R8, R9, mem;
   free requires (memory_load64_le(mem, 69664bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
-  free requires (memory_load8_le(mem, 1856bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1857bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1858bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1859bv64) == 0bv8);
+  free requires (memory_load32_le(mem, 1856bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free requires (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free requires (memory_load64_le(mem, 69592bv64) == 1812bv64);
   free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
-  free ensures (memory_load8_le(mem, 1856bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1857bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1858bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1859bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1856bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1812bv64);
diff --git a/src/test/incorrect/basicassign2/clang_O2/basicassign2_gtirb.expected b/src/test/incorrect/basicassign2/clang_O2/basicassign2_gtirb.expected
index b79b4ebee..ce04d30cc 100644
--- a/src/test/incorrect/basicassign2/clang_O2/basicassign2_gtirb.expected
+++ b/src/test/incorrect/basicassign2/clang_O2/basicassign2_gtirb.expected
@@ -10,7 +10,7 @@ const {:extern} $secret_addr: bv64;
 axiom ($secret_addr == 69688bv64);
 const {:extern} $z_addr: bv64;
 axiom ($z_addr == 69696bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
   (if (index == $z_addr) then true else (if (index == $secret_addr) then false else false))
 }
 
@@ -23,12 +23,12 @@ function {:extern} gamma_store64(gammaMap: [bv64]bool, index: bv64, value: bool)
   gammaMap[index := value][bvadd64(index, 1bv64) := value][bvadd64(index, 2bv64) := value][bvadd64(index, 3bv64) := value][bvadd64(index, 4bv64) := value][bvadd64(index, 5bv64) := value][bvadd64(index, 6bv64) := value][bvadd64(index, 7bv64) := value]
 }
 
-function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv64) {
-  (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
+function {:extern} memory_load32_le(memory: [bv64]bv8, index: bv64) returns (bv32) {
+  (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
+function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv64) {
+  (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
 function {:extern} memory_store64_le(memory: [bv64]bv8, index: bv64, value: bv64) returns ([bv64]bv8) {
@@ -37,12 +37,9 @@ function {:extern} memory_store64_le(memory: [bv64]bv8, index: bv64, value: bv64
 
 procedure {:extern} rely();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
-  free ensures (memory_load8_le(mem, 1856bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1857bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1858bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1859bv64) == 0bv8);
+  ensures (mem == old(mem));
+  free ensures (memory_load32_le(mem, 1856bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1812bv64);
@@ -50,8 +47,8 @@ procedure {:extern} rely();
 
 procedure {:extern} rely_transitive();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
+  ensures (mem == old(mem));
 
 implementation {:extern} rely_transitive()
 {
@@ -68,18 +65,12 @@ procedure main();
   modifies Gamma_R0, Gamma_R8, Gamma_R9, Gamma_mem, R0, R8, R9, mem;
   free requires (memory_load64_le(mem, 69664bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
-  free requires (memory_load8_le(mem, 1856bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1857bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1858bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1859bv64) == 0bv8);
+  free requires (memory_load32_le(mem, 1856bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free requires (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free requires (memory_load64_le(mem, 69592bv64) == 1812bv64);
   free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
-  free ensures (memory_load8_le(mem, 1856bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1857bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1858bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1859bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1856bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1812bv64);
diff --git a/src/test/incorrect/basicassign2/clang_pic/basicassign2.expected b/src/test/incorrect/basicassign2/clang_pic/basicassign2.expected
index ab4b6e7ec..e1615c0c2 100644
--- a/src/test/incorrect/basicassign2/clang_pic/basicassign2.expected
+++ b/src/test/incorrect/basicassign2/clang_pic/basicassign2.expected
@@ -16,7 +16,7 @@ const {:extern} $secret_addr: bv64;
 axiom ($secret_addr == 69688bv64);
 const {:extern} $z_addr: bv64;
 axiom ($z_addr == 69696bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
   (if (index == $z_addr) then true else (if (index == $secret_addr) then false else false))
 }
 
@@ -29,12 +29,12 @@ function {:extern} gamma_store64(gammaMap: [bv64]bool, index: bv64, value: bool)
   gammaMap[index := value][bvadd64(index, 1bv64) := value][bvadd64(index, 2bv64) := value][bvadd64(index, 3bv64) := value][bvadd64(index, 4bv64) := value][bvadd64(index, 5bv64) := value][bvadd64(index, 6bv64) := value][bvadd64(index, 7bv64) := value]
 }
 
-function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv64) {
-  (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
+function {:extern} memory_load32_le(memory: [bv64]bv8, index: bv64) returns (bv32) {
+  (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
+function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv64) {
+  (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
 function {:extern} memory_store64_le(memory: [bv64]bv8, index: bv64, value: bv64) returns ([bv64]bv8) {
@@ -43,23 +43,20 @@ function {:extern} memory_store64_le(memory: [bv64]bv8, index: bv64, value: bv64
 
 procedure {:extern} rely();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
-  free ensures (memory_load8_le(mem, 1964bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1965bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1966bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1967bv64) == 0bv8);
-  free ensures (memory_load64_le(mem, 69672bv64) == 69672bv64);
-  free ensures (memory_load64_le(mem, 69584bv64) == 69688bv64);
+  ensures (mem == old(mem));
+  free ensures (memory_load32_le(mem, 1964bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69048bv64) == 1872bv64);
+  free ensures (memory_load64_le(mem, 69056bv64) == 1792bv64);
   free ensures (memory_load64_le(mem, 69568bv64) == 69696bv64);
+  free ensures (memory_load64_le(mem, 69584bv64) == 69688bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1876bv64);
-  free ensures (memory_load64_le(mem, 69056bv64) == 1792bv64);
+  free ensures (memory_load64_le(mem, 69672bv64) == 69672bv64);
 
 procedure {:extern} rely_transitive();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
+  ensures (mem == old(mem));
 
 implementation {:extern} rely_transitive()
 {
@@ -76,28 +73,22 @@ procedure main();
   modifies Gamma_R0, Gamma_R10, Gamma_R31, Gamma_R8, Gamma_R9, Gamma_mem, Gamma_stack, R0, R10, R31, R8, R9, mem, stack;
   free requires (memory_load64_le(mem, 69664bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
-  free requires (memory_load8_le(mem, 1964bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1965bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1966bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1967bv64) == 0bv8);
-  free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
-  free requires (memory_load64_le(mem, 69584bv64) == 69688bv64);
+  free requires (memory_load32_le(mem, 1964bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69048bv64) == 1872bv64);
+  free requires (memory_load64_le(mem, 69056bv64) == 1792bv64);
   free requires (memory_load64_le(mem, 69568bv64) == 69696bv64);
+  free requires (memory_load64_le(mem, 69584bv64) == 69688bv64);
   free requires (memory_load64_le(mem, 69592bv64) == 1876bv64);
-  free requires (memory_load64_le(mem, 69056bv64) == 1792bv64);
+  free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
   free ensures (Gamma_R31 == old(Gamma_R31));
   free ensures (R31 == old(R31));
-  free ensures (memory_load8_le(mem, 1964bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1965bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1966bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1967bv64) == 0bv8);
-  free ensures (memory_load64_le(mem, 69672bv64) == 69672bv64);
-  free ensures (memory_load64_le(mem, 69584bv64) == 69688bv64);
+  free ensures (memory_load32_le(mem, 1964bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69048bv64) == 1872bv64);
+  free ensures (memory_load64_le(mem, 69056bv64) == 1792bv64);
   free ensures (memory_load64_le(mem, 69568bv64) == 69696bv64);
+  free ensures (memory_load64_le(mem, 69584bv64) == 69688bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1876bv64);
-  free ensures (memory_load64_le(mem, 69056bv64) == 1792bv64);
+  free ensures (memory_load64_le(mem, 69672bv64) == 69672bv64);
 
 implementation main()
 {
diff --git a/src/test/incorrect/basicassign2/clang_pic/basicassign2_gtirb.expected b/src/test/incorrect/basicassign2/clang_pic/basicassign2_gtirb.expected
index 6fa316b8c..c17318876 100644
--- a/src/test/incorrect/basicassign2/clang_pic/basicassign2_gtirb.expected
+++ b/src/test/incorrect/basicassign2/clang_pic/basicassign2_gtirb.expected
@@ -16,7 +16,7 @@ const {:extern} $secret_addr: bv64;
 axiom ($secret_addr == 69688bv64);
 const {:extern} $z_addr: bv64;
 axiom ($z_addr == 69696bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
   (if (index == $z_addr) then true else (if (index == $secret_addr) then false else false))
 }
 
@@ -29,12 +29,12 @@ function {:extern} gamma_store64(gammaMap: [bv64]bool, index: bv64, value: bool)
   gammaMap[index := value][bvadd64(index, 1bv64) := value][bvadd64(index, 2bv64) := value][bvadd64(index, 3bv64) := value][bvadd64(index, 4bv64) := value][bvadd64(index, 5bv64) := value][bvadd64(index, 6bv64) := value][bvadd64(index, 7bv64) := value]
 }
 
-function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv64) {
-  (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
+function {:extern} memory_load32_le(memory: [bv64]bv8, index: bv64) returns (bv32) {
+  (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
+function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv64) {
+  (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
 function {:extern} memory_store64_le(memory: [bv64]bv8, index: bv64, value: bv64) returns ([bv64]bv8) {
@@ -43,23 +43,20 @@ function {:extern} memory_store64_le(memory: [bv64]bv8, index: bv64, value: bv64
 
 procedure {:extern} rely();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
-  free ensures (memory_load8_le(mem, 1964bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1965bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1966bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1967bv64) == 0bv8);
-  free ensures (memory_load64_le(mem, 69672bv64) == 69672bv64);
-  free ensures (memory_load64_le(mem, 69584bv64) == 69688bv64);
+  ensures (mem == old(mem));
+  free ensures (memory_load32_le(mem, 1964bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69048bv64) == 1872bv64);
+  free ensures (memory_load64_le(mem, 69056bv64) == 1792bv64);
   free ensures (memory_load64_le(mem, 69568bv64) == 69696bv64);
+  free ensures (memory_load64_le(mem, 69584bv64) == 69688bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1876bv64);
-  free ensures (memory_load64_le(mem, 69056bv64) == 1792bv64);
+  free ensures (memory_load64_le(mem, 69672bv64) == 69672bv64);
 
 procedure {:extern} rely_transitive();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
+  ensures (mem == old(mem));
 
 implementation {:extern} rely_transitive()
 {
@@ -76,28 +73,22 @@ procedure main();
   modifies Gamma_R0, Gamma_R10, Gamma_R31, Gamma_R8, Gamma_R9, Gamma_mem, Gamma_stack, R0, R10, R31, R8, R9, mem, stack;
   free requires (memory_load64_le(mem, 69664bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
-  free requires (memory_load8_le(mem, 1964bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1965bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1966bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1967bv64) == 0bv8);
-  free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
-  free requires (memory_load64_le(mem, 69584bv64) == 69688bv64);
+  free requires (memory_load32_le(mem, 1964bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69048bv64) == 1872bv64);
+  free requires (memory_load64_le(mem, 69056bv64) == 1792bv64);
   free requires (memory_load64_le(mem, 69568bv64) == 69696bv64);
+  free requires (memory_load64_le(mem, 69584bv64) == 69688bv64);
   free requires (memory_load64_le(mem, 69592bv64) == 1876bv64);
-  free requires (memory_load64_le(mem, 69056bv64) == 1792bv64);
+  free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
   free ensures (Gamma_R31 == old(Gamma_R31));
   free ensures (R31 == old(R31));
-  free ensures (memory_load8_le(mem, 1964bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1965bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1966bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1967bv64) == 0bv8);
-  free ensures (memory_load64_le(mem, 69672bv64) == 69672bv64);
-  free ensures (memory_load64_le(mem, 69584bv64) == 69688bv64);
+  free ensures (memory_load32_le(mem, 1964bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69048bv64) == 1872bv64);
+  free ensures (memory_load64_le(mem, 69056bv64) == 1792bv64);
   free ensures (memory_load64_le(mem, 69568bv64) == 69696bv64);
+  free ensures (memory_load64_le(mem, 69584bv64) == 69688bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1876bv64);
-  free ensures (memory_load64_le(mem, 69056bv64) == 1792bv64);
+  free ensures (memory_load64_le(mem, 69672bv64) == 69672bv64);
 
 implementation main()
 {
diff --git a/src/test/incorrect/basicassign2/gcc/basicassign2.expected b/src/test/incorrect/basicassign2/gcc/basicassign2.expected
index 23656ef15..88af71796 100644
--- a/src/test/incorrect/basicassign2/gcc/basicassign2.expected
+++ b/src/test/incorrect/basicassign2/gcc/basicassign2.expected
@@ -12,7 +12,7 @@ const {:extern} $secret_addr: bv64;
 axiom ($secret_addr == 69664bv64);
 const {:extern} $z_addr: bv64;
 axiom ($z_addr == 69656bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
   (if (index == $z_addr) then true else (if (index == $secret_addr) then false else false))
 }
 
@@ -25,12 +25,12 @@ function {:extern} gamma_store64(gammaMap: [bv64]bool, index: bv64, value: bool)
   gammaMap[index := value][bvadd64(index, 1bv64) := value][bvadd64(index, 2bv64) := value][bvadd64(index, 3bv64) := value][bvadd64(index, 4bv64) := value][bvadd64(index, 5bv64) := value][bvadd64(index, 6bv64) := value][bvadd64(index, 7bv64) := value]
 }
 
-function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv64) {
-  (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
+function {:extern} memory_load32_le(memory: [bv64]bv8, index: bv64) returns (bv32) {
+  (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
+function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv64) {
+  (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
 function {:extern} memory_store64_le(memory: [bv64]bv8, index: bv64, value: bv64) returns ([bv64]bv8) {
@@ -39,12 +39,9 @@ function {:extern} memory_store64_le(memory: [bv64]bv8, index: bv64, value: bv64
 
 procedure {:extern} rely();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
-  free ensures (memory_load8_le(mem, 1916bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1917bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1918bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1919bv64) == 0bv8);
+  ensures (mem == old(mem));
+  free ensures (memory_load32_le(mem, 1916bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69016bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69024bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69616bv64) == 1812bv64);
@@ -52,8 +49,8 @@ procedure {:extern} rely();
 
 procedure {:extern} rely_transitive();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
+  ensures (mem == old(mem));
 
 implementation {:extern} rely_transitive()
 {
@@ -70,20 +67,14 @@ procedure main();
   modifies Gamma_R0, Gamma_R1, Gamma_R31, Gamma_mem, Gamma_stack, R0, R1, R31, mem, stack;
   free requires (memory_load64_le(mem, 69632bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free requires (memory_load8_le(mem, 1916bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1917bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1918bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1919bv64) == 0bv8);
+  free requires (memory_load32_le(mem, 1916bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69016bv64) == 1808bv64);
   free requires (memory_load64_le(mem, 69024bv64) == 1728bv64);
   free requires (memory_load64_le(mem, 69616bv64) == 1812bv64);
   free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
   free ensures (Gamma_R31 == old(Gamma_R31));
   free ensures (R31 == old(R31));
-  free ensures (memory_load8_le(mem, 1916bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1917bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1918bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1919bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1916bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69016bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69024bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69616bv64) == 1812bv64);
diff --git a/src/test/incorrect/basicassign2/gcc/basicassign2_gtirb.expected b/src/test/incorrect/basicassign2/gcc/basicassign2_gtirb.expected
index 1b74dea32..9fe37828d 100644
--- a/src/test/incorrect/basicassign2/gcc/basicassign2_gtirb.expected
+++ b/src/test/incorrect/basicassign2/gcc/basicassign2_gtirb.expected
@@ -12,7 +12,7 @@ const {:extern} $secret_addr: bv64;
 axiom ($secret_addr == 69664bv64);
 const {:extern} $z_addr: bv64;
 axiom ($z_addr == 69656bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
   (if (index == $z_addr) then true else (if (index == $secret_addr) then false else false))
 }
 
@@ -25,12 +25,12 @@ function {:extern} gamma_store64(gammaMap: [bv64]bool, index: bv64, value: bool)
   gammaMap[index := value][bvadd64(index, 1bv64) := value][bvadd64(index, 2bv64) := value][bvadd64(index, 3bv64) := value][bvadd64(index, 4bv64) := value][bvadd64(index, 5bv64) := value][bvadd64(index, 6bv64) := value][bvadd64(index, 7bv64) := value]
 }
 
-function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv64) {
-  (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
+function {:extern} memory_load32_le(memory: [bv64]bv8, index: bv64) returns (bv32) {
+  (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
+function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv64) {
+  (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
 function {:extern} memory_store64_le(memory: [bv64]bv8, index: bv64, value: bv64) returns ([bv64]bv8) {
@@ -39,12 +39,9 @@ function {:extern} memory_store64_le(memory: [bv64]bv8, index: bv64, value: bv64
 
 procedure {:extern} rely();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
-  free ensures (memory_load8_le(mem, 1916bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1917bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1918bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1919bv64) == 0bv8);
+  ensures (mem == old(mem));
+  free ensures (memory_load32_le(mem, 1916bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69016bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69024bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69616bv64) == 1812bv64);
@@ -52,8 +49,8 @@ procedure {:extern} rely();
 
 procedure {:extern} rely_transitive();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
+  ensures (mem == old(mem));
 
 implementation {:extern} rely_transitive()
 {
@@ -70,20 +67,14 @@ procedure main();
   modifies Gamma_R0, Gamma_R1, Gamma_R31, Gamma_mem, Gamma_stack, R0, R1, R31, mem, stack;
   free requires (memory_load64_le(mem, 69632bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free requires (memory_load8_le(mem, 1916bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1917bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1918bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1919bv64) == 0bv8);
+  free requires (memory_load32_le(mem, 1916bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69016bv64) == 1808bv64);
   free requires (memory_load64_le(mem, 69024bv64) == 1728bv64);
   free requires (memory_load64_le(mem, 69616bv64) == 1812bv64);
   free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
   free ensures (Gamma_R31 == old(Gamma_R31));
   free ensures (R31 == old(R31));
-  free ensures (memory_load8_le(mem, 1916bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1917bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1918bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1919bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1916bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69016bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69024bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69616bv64) == 1812bv64);
diff --git a/src/test/incorrect/basicassign2/gcc_O2/basicassign2.expected b/src/test/incorrect/basicassign2/gcc_O2/basicassign2.expected
index cbb173f38..af6252b59 100644
--- a/src/test/incorrect/basicassign2/gcc_O2/basicassign2.expected
+++ b/src/test/incorrect/basicassign2/gcc_O2/basicassign2.expected
@@ -10,7 +10,7 @@ const {:extern} $secret_addr: bv64;
 axiom ($secret_addr == 69664bv64);
 const {:extern} $z_addr: bv64;
 axiom ($z_addr == 69656bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
   (if (index == $z_addr) then true else (if (index == $secret_addr) then false else false))
 }
 
@@ -23,12 +23,12 @@ function {:extern} gamma_store64(gammaMap: [bv64]bool, index: bv64, value: bool)
   gammaMap[index := value][bvadd64(index, 1bv64) := value][bvadd64(index, 2bv64) := value][bvadd64(index, 3bv64) := value][bvadd64(index, 4bv64) := value][bvadd64(index, 5bv64) := value][bvadd64(index, 6bv64) := value][bvadd64(index, 7bv64) := value]
 }
 
-function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv64) {
-  (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
+function {:extern} memory_load32_le(memory: [bv64]bv8, index: bv64) returns (bv32) {
+  (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
+function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv64) {
+  (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
 function {:extern} memory_store64_le(memory: [bv64]bv8, index: bv64, value: bv64) returns ([bv64]bv8) {
@@ -37,12 +37,9 @@ function {:extern} memory_store64_le(memory: [bv64]bv8, index: bv64, value: bv64
 
 procedure {:extern} rely();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
-  free ensures (memory_load8_le(mem, 1896bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1897bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1898bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1899bv64) == 0bv8);
+  ensures (mem == old(mem));
+  free ensures (memory_load32_le(mem, 1896bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69016bv64) == 1872bv64);
   free ensures (memory_load64_le(mem, 69024bv64) == 1792bv64);
   free ensures (memory_load64_le(mem, 69616bv64) == 1536bv64);
@@ -50,8 +47,8 @@ procedure {:extern} rely();
 
 procedure {:extern} rely_transitive();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
+  ensures (mem == old(mem));
 
 implementation {:extern} rely_transitive()
 {
@@ -68,18 +65,12 @@ procedure main();
   modifies Gamma_R0, Gamma_R1, Gamma_R2, Gamma_mem, R0, R1, R2, mem;
   free requires (memory_load64_le(mem, 69632bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free requires (memory_load8_le(mem, 1896bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1897bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1898bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1899bv64) == 0bv8);
+  free requires (memory_load32_le(mem, 1896bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69016bv64) == 1872bv64);
   free requires (memory_load64_le(mem, 69024bv64) == 1792bv64);
   free requires (memory_load64_le(mem, 69616bv64) == 1536bv64);
   free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free ensures (memory_load8_le(mem, 1896bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1897bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1898bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1899bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1896bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69016bv64) == 1872bv64);
   free ensures (memory_load64_le(mem, 69024bv64) == 1792bv64);
   free ensures (memory_load64_le(mem, 69616bv64) == 1536bv64);
diff --git a/src/test/incorrect/basicassign2/gcc_O2/basicassign2_gtirb.expected b/src/test/incorrect/basicassign2/gcc_O2/basicassign2_gtirb.expected
index 8e67f332d..652073954 100644
--- a/src/test/incorrect/basicassign2/gcc_O2/basicassign2_gtirb.expected
+++ b/src/test/incorrect/basicassign2/gcc_O2/basicassign2_gtirb.expected
@@ -10,7 +10,7 @@ const {:extern} $secret_addr: bv64;
 axiom ($secret_addr == 69664bv64);
 const {:extern} $z_addr: bv64;
 axiom ($z_addr == 69656bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
   (if (index == $z_addr) then true else (if (index == $secret_addr) then false else false))
 }
 
@@ -23,12 +23,12 @@ function {:extern} gamma_store64(gammaMap: [bv64]bool, index: bv64, value: bool)
   gammaMap[index := value][bvadd64(index, 1bv64) := value][bvadd64(index, 2bv64) := value][bvadd64(index, 3bv64) := value][bvadd64(index, 4bv64) := value][bvadd64(index, 5bv64) := value][bvadd64(index, 6bv64) := value][bvadd64(index, 7bv64) := value]
 }
 
-function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv64) {
-  (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
+function {:extern} memory_load32_le(memory: [bv64]bv8, index: bv64) returns (bv32) {
+  (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
+function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv64) {
+  (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
 function {:extern} memory_store64_le(memory: [bv64]bv8, index: bv64, value: bv64) returns ([bv64]bv8) {
@@ -37,12 +37,9 @@ function {:extern} memory_store64_le(memory: [bv64]bv8, index: bv64, value: bv64
 
 procedure {:extern} rely();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
-  free ensures (memory_load8_le(mem, 1896bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1897bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1898bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1899bv64) == 0bv8);
+  ensures (mem == old(mem));
+  free ensures (memory_load32_le(mem, 1896bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69016bv64) == 1872bv64);
   free ensures (memory_load64_le(mem, 69024bv64) == 1792bv64);
   free ensures (memory_load64_le(mem, 69616bv64) == 1536bv64);
@@ -50,8 +47,8 @@ procedure {:extern} rely();
 
 procedure {:extern} rely_transitive();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
+  ensures (mem == old(mem));
 
 implementation {:extern} rely_transitive()
 {
@@ -68,18 +65,12 @@ procedure main();
   modifies Gamma_R0, Gamma_R1, Gamma_R2, Gamma_mem, R0, R1, R2, mem;
   free requires (memory_load64_le(mem, 69632bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free requires (memory_load8_le(mem, 1896bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1897bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1898bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1899bv64) == 0bv8);
+  free requires (memory_load32_le(mem, 1896bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69016bv64) == 1872bv64);
   free requires (memory_load64_le(mem, 69024bv64) == 1792bv64);
   free requires (memory_load64_le(mem, 69616bv64) == 1536bv64);
   free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free ensures (memory_load8_le(mem, 1896bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1897bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1898bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1899bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1896bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69016bv64) == 1872bv64);
   free ensures (memory_load64_le(mem, 69024bv64) == 1792bv64);
   free ensures (memory_load64_le(mem, 69616bv64) == 1536bv64);
diff --git a/src/test/incorrect/basicassign2/gcc_pic/basicassign2.expected b/src/test/incorrect/basicassign2/gcc_pic/basicassign2.expected
index f75604861..20875ec1c 100644
--- a/src/test/incorrect/basicassign2/gcc_pic/basicassign2.expected
+++ b/src/test/incorrect/basicassign2/gcc_pic/basicassign2.expected
@@ -12,7 +12,7 @@ const {:extern} $secret_addr: bv64;
 axiom ($secret_addr == 69664bv64);
 const {:extern} $z_addr: bv64;
 axiom ($z_addr == 69656bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
   (if (index == $z_addr) then true else (if (index == $secret_addr) then false else false))
 }
 
@@ -25,12 +25,12 @@ function {:extern} gamma_store64(gammaMap: [bv64]bool, index: bv64, value: bool)
   gammaMap[index := value][bvadd64(index, 1bv64) := value][bvadd64(index, 2bv64) := value][bvadd64(index, 3bv64) := value][bvadd64(index, 4bv64) := value][bvadd64(index, 5bv64) := value][bvadd64(index, 6bv64) := value][bvadd64(index, 7bv64) := value]
 }
 
-function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv64) {
-  (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
+function {:extern} memory_load32_le(memory: [bv64]bv8, index: bv64) returns (bv32) {
+  (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
+function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv64) {
+  (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
 function {:extern} memory_store64_le(memory: [bv64]bv8, index: bv64, value: bv64) returns ([bv64]bv8) {
@@ -39,23 +39,20 @@ function {:extern} memory_store64_le(memory: [bv64]bv8, index: bv64, value: bv64
 
 procedure {:extern} rely();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
-  free ensures (memory_load8_le(mem, 1980bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1981bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1982bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1983bv64) == 0bv8);
-  free ensures (memory_load64_le(mem, 69608bv64) == 69664bv64);
-  free ensures (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free ensures (memory_load64_le(mem, 69616bv64) == 1876bv64);
+  ensures (mem == old(mem));
+  free ensures (memory_load32_le(mem, 1980bv64) == 131073bv32);
+  free ensures (memory_load64_le(mem, 69000bv64) == 1872bv64);
   free ensures (memory_load64_le(mem, 69008bv64) == 1792bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 69656bv64);
-  free ensures (memory_load64_le(mem, 69000bv64) == 1872bv64);
+  free ensures (memory_load64_le(mem, 69608bv64) == 69664bv64);
+  free ensures (memory_load64_le(mem, 69616bv64) == 1876bv64);
+  free ensures (memory_load64_le(mem, 69640bv64) == 69640bv64);
 
 procedure {:extern} rely_transitive();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
+  ensures (mem == old(mem));
 
 implementation {:extern} rely_transitive()
 {
@@ -72,28 +69,22 @@ procedure main();
   modifies Gamma_R0, Gamma_R1, Gamma_R31, Gamma_mem, Gamma_stack, R0, R1, R31, mem, stack;
   free requires (memory_load64_le(mem, 69632bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free requires (memory_load8_le(mem, 1980bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1981bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1982bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1983bv64) == 0bv8);
-  free requires (memory_load64_le(mem, 69608bv64) == 69664bv64);
-  free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free requires (memory_load64_le(mem, 69616bv64) == 1876bv64);
+  free requires (memory_load32_le(mem, 1980bv64) == 131073bv32);
+  free requires (memory_load64_le(mem, 69000bv64) == 1872bv64);
   free requires (memory_load64_le(mem, 69008bv64) == 1792bv64);
   free requires (memory_load64_le(mem, 69592bv64) == 69656bv64);
-  free requires (memory_load64_le(mem, 69000bv64) == 1872bv64);
+  free requires (memory_load64_le(mem, 69608bv64) == 69664bv64);
+  free requires (memory_load64_le(mem, 69616bv64) == 1876bv64);
+  free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
   free ensures (Gamma_R31 == old(Gamma_R31));
   free ensures (R31 == old(R31));
-  free ensures (memory_load8_le(mem, 1980bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1981bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1982bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1983bv64) == 0bv8);
-  free ensures (memory_load64_le(mem, 69608bv64) == 69664bv64);
-  free ensures (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free ensures (memory_load64_le(mem, 69616bv64) == 1876bv64);
+  free ensures (memory_load32_le(mem, 1980bv64) == 131073bv32);
+  free ensures (memory_load64_le(mem, 69000bv64) == 1872bv64);
   free ensures (memory_load64_le(mem, 69008bv64) == 1792bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 69656bv64);
-  free ensures (memory_load64_le(mem, 69000bv64) == 1872bv64);
+  free ensures (memory_load64_le(mem, 69608bv64) == 69664bv64);
+  free ensures (memory_load64_le(mem, 69616bv64) == 1876bv64);
+  free ensures (memory_load64_le(mem, 69640bv64) == 69640bv64);
 
 implementation main()
 {
diff --git a/src/test/incorrect/basicassign2/gcc_pic/basicassign2_gtirb.expected b/src/test/incorrect/basicassign2/gcc_pic/basicassign2_gtirb.expected
index 5b858de70..cb8945060 100644
--- a/src/test/incorrect/basicassign2/gcc_pic/basicassign2_gtirb.expected
+++ b/src/test/incorrect/basicassign2/gcc_pic/basicassign2_gtirb.expected
@@ -12,7 +12,7 @@ const {:extern} $secret_addr: bv64;
 axiom ($secret_addr == 69664bv64);
 const {:extern} $z_addr: bv64;
 axiom ($z_addr == 69656bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
   (if (index == $z_addr) then true else (if (index == $secret_addr) then false else false))
 }
 
@@ -25,12 +25,12 @@ function {:extern} gamma_store64(gammaMap: [bv64]bool, index: bv64, value: bool)
   gammaMap[index := value][bvadd64(index, 1bv64) := value][bvadd64(index, 2bv64) := value][bvadd64(index, 3bv64) := value][bvadd64(index, 4bv64) := value][bvadd64(index, 5bv64) := value][bvadd64(index, 6bv64) := value][bvadd64(index, 7bv64) := value]
 }
 
-function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv64) {
-  (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
+function {:extern} memory_load32_le(memory: [bv64]bv8, index: bv64) returns (bv32) {
+  (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
+function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv64) {
+  (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
 function {:extern} memory_store64_le(memory: [bv64]bv8, index: bv64, value: bv64) returns ([bv64]bv8) {
@@ -39,23 +39,20 @@ function {:extern} memory_store64_le(memory: [bv64]bv8, index: bv64, value: bv64
 
 procedure {:extern} rely();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
-  free ensures (memory_load8_le(mem, 1980bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1981bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1982bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1983bv64) == 0bv8);
-  free ensures (memory_load64_le(mem, 69608bv64) == 69664bv64);
-  free ensures (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free ensures (memory_load64_le(mem, 69616bv64) == 1876bv64);
+  ensures (mem == old(mem));
+  free ensures (memory_load32_le(mem, 1980bv64) == 131073bv32);
+  free ensures (memory_load64_le(mem, 69000bv64) == 1872bv64);
   free ensures (memory_load64_le(mem, 69008bv64) == 1792bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 69656bv64);
-  free ensures (memory_load64_le(mem, 69000bv64) == 1872bv64);
+  free ensures (memory_load64_le(mem, 69608bv64) == 69664bv64);
+  free ensures (memory_load64_le(mem, 69616bv64) == 1876bv64);
+  free ensures (memory_load64_le(mem, 69640bv64) == 69640bv64);
 
 procedure {:extern} rely_transitive();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
+  ensures (mem == old(mem));
 
 implementation {:extern} rely_transitive()
 {
@@ -72,28 +69,22 @@ procedure main();
   modifies Gamma_R0, Gamma_R1, Gamma_R31, Gamma_mem, Gamma_stack, R0, R1, R31, mem, stack;
   free requires (memory_load64_le(mem, 69632bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free requires (memory_load8_le(mem, 1980bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1981bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1982bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1983bv64) == 0bv8);
-  free requires (memory_load64_le(mem, 69608bv64) == 69664bv64);
-  free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free requires (memory_load64_le(mem, 69616bv64) == 1876bv64);
+  free requires (memory_load32_le(mem, 1980bv64) == 131073bv32);
+  free requires (memory_load64_le(mem, 69000bv64) == 1872bv64);
   free requires (memory_load64_le(mem, 69008bv64) == 1792bv64);
   free requires (memory_load64_le(mem, 69592bv64) == 69656bv64);
-  free requires (memory_load64_le(mem, 69000bv64) == 1872bv64);
+  free requires (memory_load64_le(mem, 69608bv64) == 69664bv64);
+  free requires (memory_load64_le(mem, 69616bv64) == 1876bv64);
+  free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
   free ensures (Gamma_R31 == old(Gamma_R31));
   free ensures (R31 == old(R31));
-  free ensures (memory_load8_le(mem, 1980bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1981bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1982bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1983bv64) == 0bv8);
-  free ensures (memory_load64_le(mem, 69608bv64) == 69664bv64);
-  free ensures (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free ensures (memory_load64_le(mem, 69616bv64) == 1876bv64);
+  free ensures (memory_load32_le(mem, 1980bv64) == 131073bv32);
+  free ensures (memory_load64_le(mem, 69000bv64) == 1872bv64);
   free ensures (memory_load64_le(mem, 69008bv64) == 1792bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 69656bv64);
-  free ensures (memory_load64_le(mem, 69000bv64) == 1872bv64);
+  free ensures (memory_load64_le(mem, 69608bv64) == 69664bv64);
+  free ensures (memory_load64_le(mem, 69616bv64) == 1876bv64);
+  free ensures (memory_load64_le(mem, 69640bv64) == 69640bv64);
 
 implementation main()
 {
diff --git a/src/test/incorrect/basicassign3/clang/basicassign3.expected b/src/test/incorrect/basicassign3/clang/basicassign3.expected
index 573fcf38f..1ee2cd40f 100644
--- a/src/test/incorrect/basicassign3/clang/basicassign3.expected
+++ b/src/test/incorrect/basicassign3/clang/basicassign3.expected
@@ -16,7 +16,7 @@ const {:extern} $secret_addr: bv64;
 axiom ($secret_addr == 69681bv64);
 const {:extern} $z_addr: bv64;
 axiom ($z_addr == 69682bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
   (if (index == $secret_addr) then false else (if (index == $z_addr) then true else false))
 }
 
@@ -29,6 +29,10 @@ function {:extern} gamma_store8(gammaMap: [bv64]bool, index: bv64, value: bool)
   gammaMap[index := value]
 }
 
+function {:extern} memory_load32_le(memory: [bv64]bv8, index: bv64) returns (bv32) {
+  (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))
+}
+
 function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv64) {
   (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
@@ -44,12 +48,9 @@ function {:extern} memory_store8_le(memory: [bv64]bv8, index: bv64, value: bv8)
 function {:extern} {:bvbuiltin "zero_extend 56"} zero_extend56_8(bv8) returns (bv64);
 procedure {:extern} rely();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
-  free ensures (memory_load8_le(mem, 1892bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1893bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1894bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1895bv64) == 0bv8);
+  ensures (mem == old(mem));
+  free ensures (memory_load32_le(mem, 1892bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1812bv64);
@@ -57,8 +58,8 @@ procedure {:extern} rely();
 
 procedure {:extern} rely_transitive();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
+  ensures (mem == old(mem));
 
 implementation {:extern} rely_transitive()
 {
@@ -75,20 +76,14 @@ procedure main();
   modifies Gamma_R0, Gamma_R10, Gamma_R31, Gamma_R8, Gamma_R9, Gamma_mem, Gamma_stack, R0, R10, R31, R8, R9, mem, stack;
   free requires (memory_load64_le(mem, 69664bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
-  free requires (memory_load8_le(mem, 1892bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1893bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1894bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1895bv64) == 0bv8);
+  free requires (memory_load32_le(mem, 1892bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free requires (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free requires (memory_load64_le(mem, 69592bv64) == 1812bv64);
   free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
   free ensures (Gamma_R31 == old(Gamma_R31));
   free ensures (R31 == old(R31));
-  free ensures (memory_load8_le(mem, 1892bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1893bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1894bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1895bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1892bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1812bv64);
diff --git a/src/test/incorrect/basicassign3/clang/basicassign3_gtirb.expected b/src/test/incorrect/basicassign3/clang/basicassign3_gtirb.expected
index 9ded6dd3f..dda4fe687 100644
--- a/src/test/incorrect/basicassign3/clang/basicassign3_gtirb.expected
+++ b/src/test/incorrect/basicassign3/clang/basicassign3_gtirb.expected
@@ -16,7 +16,7 @@ const {:extern} $secret_addr: bv64;
 axiom ($secret_addr == 69681bv64);
 const {:extern} $z_addr: bv64;
 axiom ($z_addr == 69682bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
   (if (index == $secret_addr) then false else (if (index == $z_addr) then true else false))
 }
 
@@ -29,6 +29,10 @@ function {:extern} gamma_store8(gammaMap: [bv64]bool, index: bv64, value: bool)
   gammaMap[index := value]
 }
 
+function {:extern} memory_load32_le(memory: [bv64]bv8, index: bv64) returns (bv32) {
+  (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))
+}
+
 function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv64) {
   (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
@@ -45,12 +49,9 @@ function {:extern} {:bvbuiltin "zero_extend 24"} zero_extend24_8(bv8) returns (b
 function {:extern} {:bvbuiltin "zero_extend 32"} zero_extend32_32(bv32) returns (bv64);
 procedure {:extern} rely();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
-  free ensures (memory_load8_le(mem, 1892bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1893bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1894bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1895bv64) == 0bv8);
+  ensures (mem == old(mem));
+  free ensures (memory_load32_le(mem, 1892bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1812bv64);
@@ -58,8 +59,8 @@ procedure {:extern} rely();
 
 procedure {:extern} rely_transitive();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
+  ensures (mem == old(mem));
 
 implementation {:extern} rely_transitive()
 {
@@ -76,20 +77,14 @@ procedure main();
   modifies Gamma_R0, Gamma_R10, Gamma_R31, Gamma_R8, Gamma_R9, Gamma_mem, Gamma_stack, R0, R10, R31, R8, R9, mem, stack;
   free requires (memory_load64_le(mem, 69664bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
-  free requires (memory_load8_le(mem, 1892bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1893bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1894bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1895bv64) == 0bv8);
+  free requires (memory_load32_le(mem, 1892bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free requires (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free requires (memory_load64_le(mem, 69592bv64) == 1812bv64);
   free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
   free ensures (Gamma_R31 == old(Gamma_R31));
   free ensures (R31 == old(R31));
-  free ensures (memory_load8_le(mem, 1892bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1893bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1894bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1895bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1892bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1812bv64);
diff --git a/src/test/incorrect/basicassign3/clang_O2/basicassign3.expected b/src/test/incorrect/basicassign3/clang_O2/basicassign3.expected
index d8dec4426..900ca1cca 100644
--- a/src/test/incorrect/basicassign3/clang_O2/basicassign3.expected
+++ b/src/test/incorrect/basicassign3/clang_O2/basicassign3.expected
@@ -10,7 +10,7 @@ const {:extern} $secret_addr: bv64;
 axiom ($secret_addr == 69684bv64);
 const {:extern} $z_addr: bv64;
 axiom ($z_addr == 69688bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
   (if (index == $secret_addr) then false else (if (index == $z_addr) then true else false))
 }
 
@@ -23,6 +23,10 @@ function {:extern} gamma_store8(gammaMap: [bv64]bool, index: bv64, value: bool)
   gammaMap[index := value]
 }
 
+function {:extern} memory_load32_le(memory: [bv64]bv8, index: bv64) returns (bv32) {
+  (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))
+}
+
 function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv64) {
   (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
@@ -38,12 +42,9 @@ function {:extern} memory_store8_le(memory: [bv64]bv8, index: bv64, value: bv8)
 function {:extern} {:bvbuiltin "zero_extend 56"} zero_extend56_8(bv8) returns (bv64);
 procedure {:extern} rely();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
-  free ensures (memory_load8_le(mem, 1856bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1857bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1858bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1859bv64) == 0bv8);
+  ensures (mem == old(mem));
+  free ensures (memory_load32_le(mem, 1856bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1812bv64);
@@ -51,8 +52,8 @@ procedure {:extern} rely();
 
 procedure {:extern} rely_transitive();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
+  ensures (mem == old(mem));
 
 implementation {:extern} rely_transitive()
 {
@@ -69,18 +70,12 @@ procedure main();
   modifies Gamma_R0, Gamma_R8, Gamma_R9, Gamma_mem, R0, R8, R9, mem;
   free requires (memory_load64_le(mem, 69664bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
-  free requires (memory_load8_le(mem, 1856bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1857bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1858bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1859bv64) == 0bv8);
+  free requires (memory_load32_le(mem, 1856bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free requires (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free requires (memory_load64_le(mem, 69592bv64) == 1812bv64);
   free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
-  free ensures (memory_load8_le(mem, 1856bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1857bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1858bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1859bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1856bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1812bv64);
diff --git a/src/test/incorrect/basicassign3/clang_O2/basicassign3_gtirb.expected b/src/test/incorrect/basicassign3/clang_O2/basicassign3_gtirb.expected
index a00e3afa0..715f96918 100644
--- a/src/test/incorrect/basicassign3/clang_O2/basicassign3_gtirb.expected
+++ b/src/test/incorrect/basicassign3/clang_O2/basicassign3_gtirb.expected
@@ -10,7 +10,7 @@ const {:extern} $secret_addr: bv64;
 axiom ($secret_addr == 69684bv64);
 const {:extern} $z_addr: bv64;
 axiom ($z_addr == 69688bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
   (if (index == $secret_addr) then false else (if (index == $z_addr) then true else false))
 }
 
@@ -23,6 +23,10 @@ function {:extern} gamma_store8(gammaMap: [bv64]bool, index: bv64, value: bool)
   gammaMap[index := value]
 }
 
+function {:extern} memory_load32_le(memory: [bv64]bv8, index: bv64) returns (bv32) {
+  (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))
+}
+
 function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv64) {
   (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
@@ -39,12 +43,9 @@ function {:extern} {:bvbuiltin "zero_extend 24"} zero_extend24_8(bv8) returns (b
 function {:extern} {:bvbuiltin "zero_extend 32"} zero_extend32_32(bv32) returns (bv64);
 procedure {:extern} rely();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
-  free ensures (memory_load8_le(mem, 1856bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1857bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1858bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1859bv64) == 0bv8);
+  ensures (mem == old(mem));
+  free ensures (memory_load32_le(mem, 1856bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1812bv64);
@@ -52,8 +53,8 @@ procedure {:extern} rely();
 
 procedure {:extern} rely_transitive();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
+  ensures (mem == old(mem));
 
 implementation {:extern} rely_transitive()
 {
@@ -70,18 +71,12 @@ procedure main();
   modifies Gamma_R0, Gamma_R8, Gamma_R9, Gamma_mem, R0, R8, R9, mem;
   free requires (memory_load64_le(mem, 69664bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
-  free requires (memory_load8_le(mem, 1856bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1857bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1858bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1859bv64) == 0bv8);
+  free requires (memory_load32_le(mem, 1856bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free requires (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free requires (memory_load64_le(mem, 69592bv64) == 1812bv64);
   free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
-  free ensures (memory_load8_le(mem, 1856bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1857bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1858bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1859bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1856bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1812bv64);
diff --git a/src/test/incorrect/basicassign3/clang_pic/basicassign3.expected b/src/test/incorrect/basicassign3/clang_pic/basicassign3.expected
index d85f4196c..60ce354a8 100644
--- a/src/test/incorrect/basicassign3/clang_pic/basicassign3.expected
+++ b/src/test/incorrect/basicassign3/clang_pic/basicassign3.expected
@@ -16,7 +16,7 @@ const {:extern} $secret_addr: bv64;
 axiom ($secret_addr == 69681bv64);
 const {:extern} $z_addr: bv64;
 axiom ($z_addr == 69682bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
   (if (index == $secret_addr) then false else (if (index == $z_addr) then true else false))
 }
 
@@ -33,6 +33,10 @@ function {:extern} gamma_store8(gammaMap: [bv64]bool, index: bv64, value: bool)
   gammaMap[index := value]
 }
 
+function {:extern} memory_load32_le(memory: [bv64]bv8, index: bv64) returns (bv32) {
+  (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))
+}
+
 function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv64) {
   (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
@@ -48,23 +52,20 @@ function {:extern} memory_store8_le(memory: [bv64]bv8, index: bv64, value: bv8)
 function {:extern} {:bvbuiltin "zero_extend 56"} zero_extend56_8(bv8) returns (bv64);
 procedure {:extern} rely();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
-  free ensures (memory_load8_le(mem, 1964bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1965bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1966bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1967bv64) == 0bv8);
-  free ensures (memory_load64_le(mem, 69672bv64) == 69672bv64);
-  free ensures (memory_load64_le(mem, 69584bv64) == 69681bv64);
+  ensures (mem == old(mem));
+  free ensures (memory_load32_le(mem, 1964bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69048bv64) == 1872bv64);
+  free ensures (memory_load64_le(mem, 69056bv64) == 1792bv64);
   free ensures (memory_load64_le(mem, 69568bv64) == 69682bv64);
+  free ensures (memory_load64_le(mem, 69584bv64) == 69681bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1876bv64);
-  free ensures (memory_load64_le(mem, 69056bv64) == 1792bv64);
+  free ensures (memory_load64_le(mem, 69672bv64) == 69672bv64);
 
 procedure {:extern} rely_transitive();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
+  ensures (mem == old(mem));
 
 implementation {:extern} rely_transitive()
 {
@@ -81,28 +82,22 @@ procedure main();
   modifies Gamma_R0, Gamma_R10, Gamma_R31, Gamma_R8, Gamma_R9, Gamma_mem, Gamma_stack, R0, R10, R31, R8, R9, mem, stack;
   free requires (memory_load64_le(mem, 69664bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
-  free requires (memory_load8_le(mem, 1964bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1965bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1966bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1967bv64) == 0bv8);
-  free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
-  free requires (memory_load64_le(mem, 69584bv64) == 69681bv64);
+  free requires (memory_load32_le(mem, 1964bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69048bv64) == 1872bv64);
+  free requires (memory_load64_le(mem, 69056bv64) == 1792bv64);
   free requires (memory_load64_le(mem, 69568bv64) == 69682bv64);
+  free requires (memory_load64_le(mem, 69584bv64) == 69681bv64);
   free requires (memory_load64_le(mem, 69592bv64) == 1876bv64);
-  free requires (memory_load64_le(mem, 69056bv64) == 1792bv64);
+  free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
   free ensures (Gamma_R31 == old(Gamma_R31));
   free ensures (R31 == old(R31));
-  free ensures (memory_load8_le(mem, 1964bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1965bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1966bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1967bv64) == 0bv8);
-  free ensures (memory_load64_le(mem, 69672bv64) == 69672bv64);
-  free ensures (memory_load64_le(mem, 69584bv64) == 69681bv64);
+  free ensures (memory_load32_le(mem, 1964bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69048bv64) == 1872bv64);
+  free ensures (memory_load64_le(mem, 69056bv64) == 1792bv64);
   free ensures (memory_load64_le(mem, 69568bv64) == 69682bv64);
+  free ensures (memory_load64_le(mem, 69584bv64) == 69681bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1876bv64);
-  free ensures (memory_load64_le(mem, 69056bv64) == 1792bv64);
+  free ensures (memory_load64_le(mem, 69672bv64) == 69672bv64);
 
 implementation main()
 {
diff --git a/src/test/incorrect/basicassign3/clang_pic/basicassign3_gtirb.expected b/src/test/incorrect/basicassign3/clang_pic/basicassign3_gtirb.expected
index 3af45974b..c0e66711e 100644
--- a/src/test/incorrect/basicassign3/clang_pic/basicassign3_gtirb.expected
+++ b/src/test/incorrect/basicassign3/clang_pic/basicassign3_gtirb.expected
@@ -16,7 +16,7 @@ const {:extern} $secret_addr: bv64;
 axiom ($secret_addr == 69681bv64);
 const {:extern} $z_addr: bv64;
 axiom ($z_addr == 69682bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
   (if (index == $secret_addr) then false else (if (index == $z_addr) then true else false))
 }
 
@@ -33,6 +33,10 @@ function {:extern} gamma_store8(gammaMap: [bv64]bool, index: bv64, value: bool)
   gammaMap[index := value]
 }
 
+function {:extern} memory_load32_le(memory: [bv64]bv8, index: bv64) returns (bv32) {
+  (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))
+}
+
 function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv64) {
   (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
@@ -49,23 +53,20 @@ function {:extern} {:bvbuiltin "zero_extend 24"} zero_extend24_8(bv8) returns (b
 function {:extern} {:bvbuiltin "zero_extend 32"} zero_extend32_32(bv32) returns (bv64);
 procedure {:extern} rely();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
-  free ensures (memory_load8_le(mem, 1964bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1965bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1966bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1967bv64) == 0bv8);
-  free ensures (memory_load64_le(mem, 69672bv64) == 69672bv64);
-  free ensures (memory_load64_le(mem, 69584bv64) == 69681bv64);
+  ensures (mem == old(mem));
+  free ensures (memory_load32_le(mem, 1964bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69048bv64) == 1872bv64);
+  free ensures (memory_load64_le(mem, 69056bv64) == 1792bv64);
   free ensures (memory_load64_le(mem, 69568bv64) == 69682bv64);
+  free ensures (memory_load64_le(mem, 69584bv64) == 69681bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1876bv64);
-  free ensures (memory_load64_le(mem, 69056bv64) == 1792bv64);
+  free ensures (memory_load64_le(mem, 69672bv64) == 69672bv64);
 
 procedure {:extern} rely_transitive();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
+  ensures (mem == old(mem));
 
 implementation {:extern} rely_transitive()
 {
@@ -82,28 +83,22 @@ procedure main();
   modifies Gamma_R0, Gamma_R10, Gamma_R31, Gamma_R8, Gamma_R9, Gamma_mem, Gamma_stack, R0, R10, R31, R8, R9, mem, stack;
   free requires (memory_load64_le(mem, 69664bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
-  free requires (memory_load8_le(mem, 1964bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1965bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1966bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1967bv64) == 0bv8);
-  free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
-  free requires (memory_load64_le(mem, 69584bv64) == 69681bv64);
+  free requires (memory_load32_le(mem, 1964bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69048bv64) == 1872bv64);
+  free requires (memory_load64_le(mem, 69056bv64) == 1792bv64);
   free requires (memory_load64_le(mem, 69568bv64) == 69682bv64);
+  free requires (memory_load64_le(mem, 69584bv64) == 69681bv64);
   free requires (memory_load64_le(mem, 69592bv64) == 1876bv64);
-  free requires (memory_load64_le(mem, 69056bv64) == 1792bv64);
+  free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
   free ensures (Gamma_R31 == old(Gamma_R31));
   free ensures (R31 == old(R31));
-  free ensures (memory_load8_le(mem, 1964bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1965bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1966bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1967bv64) == 0bv8);
-  free ensures (memory_load64_le(mem, 69672bv64) == 69672bv64);
-  free ensures (memory_load64_le(mem, 69584bv64) == 69681bv64);
+  free ensures (memory_load32_le(mem, 1964bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69048bv64) == 1872bv64);
+  free ensures (memory_load64_le(mem, 69056bv64) == 1792bv64);
   free ensures (memory_load64_le(mem, 69568bv64) == 69682bv64);
+  free ensures (memory_load64_le(mem, 69584bv64) == 69681bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1876bv64);
-  free ensures (memory_load64_le(mem, 69056bv64) == 1792bv64);
+  free ensures (memory_load64_le(mem, 69672bv64) == 69672bv64);
 
 implementation main()
 {
diff --git a/src/test/incorrect/basicassign3/gcc/basicassign3.expected b/src/test/incorrect/basicassign3/gcc/basicassign3.expected
index 45ac95591..8058b3573 100644
--- a/src/test/incorrect/basicassign3/gcc/basicassign3.expected
+++ b/src/test/incorrect/basicassign3/gcc/basicassign3.expected
@@ -12,7 +12,7 @@ const {:extern} $secret_addr: bv64;
 axiom ($secret_addr == 69650bv64);
 const {:extern} $z_addr: bv64;
 axiom ($z_addr == 69649bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
   (if (index == $secret_addr) then false else (if (index == $z_addr) then true else false))
 }
 
@@ -25,6 +25,10 @@ function {:extern} gamma_store8(gammaMap: [bv64]bool, index: bv64, value: bool)
   gammaMap[index := value]
 }
 
+function {:extern} memory_load32_le(memory: [bv64]bv8, index: bv64) returns (bv32) {
+  (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))
+}
+
 function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv64) {
   (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
@@ -40,12 +44,9 @@ function {:extern} memory_store8_le(memory: [bv64]bv8, index: bv64, value: bv8)
 function {:extern} {:bvbuiltin "zero_extend 56"} zero_extend56_8(bv8) returns (bv64);
 procedure {:extern} rely();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
-  free ensures (memory_load8_le(mem, 1916bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1917bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1918bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1919bv64) == 0bv8);
+  ensures (mem == old(mem));
+  free ensures (memory_load32_le(mem, 1916bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69016bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69024bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69616bv64) == 1812bv64);
@@ -53,8 +54,8 @@ procedure {:extern} rely();
 
 procedure {:extern} rely_transitive();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
+  ensures (mem == old(mem));
 
 implementation {:extern} rely_transitive()
 {
@@ -71,20 +72,14 @@ procedure main();
   modifies Gamma_R0, Gamma_R1, Gamma_R31, Gamma_mem, Gamma_stack, R0, R1, R31, mem, stack;
   free requires (memory_load64_le(mem, 69632bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free requires (memory_load8_le(mem, 1916bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1917bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1918bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1919bv64) == 0bv8);
+  free requires (memory_load32_le(mem, 1916bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69016bv64) == 1808bv64);
   free requires (memory_load64_le(mem, 69024bv64) == 1728bv64);
   free requires (memory_load64_le(mem, 69616bv64) == 1812bv64);
   free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
   free ensures (Gamma_R31 == old(Gamma_R31));
   free ensures (R31 == old(R31));
-  free ensures (memory_load8_le(mem, 1916bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1917bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1918bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1919bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1916bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69016bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69024bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69616bv64) == 1812bv64);
diff --git a/src/test/incorrect/basicassign3/gcc/basicassign3_gtirb.expected b/src/test/incorrect/basicassign3/gcc/basicassign3_gtirb.expected
index 6518433ba..572d5b366 100644
--- a/src/test/incorrect/basicassign3/gcc/basicassign3_gtirb.expected
+++ b/src/test/incorrect/basicassign3/gcc/basicassign3_gtirb.expected
@@ -12,7 +12,7 @@ const {:extern} $secret_addr: bv64;
 axiom ($secret_addr == 69650bv64);
 const {:extern} $z_addr: bv64;
 axiom ($z_addr == 69649bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
   (if (index == $secret_addr) then false else (if (index == $z_addr) then true else false))
 }
 
@@ -25,6 +25,10 @@ function {:extern} gamma_store8(gammaMap: [bv64]bool, index: bv64, value: bool)
   gammaMap[index := value]
 }
 
+function {:extern} memory_load32_le(memory: [bv64]bv8, index: bv64) returns (bv32) {
+  (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))
+}
+
 function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv64) {
   (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
@@ -41,12 +45,9 @@ function {:extern} {:bvbuiltin "zero_extend 24"} zero_extend24_8(bv8) returns (b
 function {:extern} {:bvbuiltin "zero_extend 32"} zero_extend32_32(bv32) returns (bv64);
 procedure {:extern} rely();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
-  free ensures (memory_load8_le(mem, 1916bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1917bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1918bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1919bv64) == 0bv8);
+  ensures (mem == old(mem));
+  free ensures (memory_load32_le(mem, 1916bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69016bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69024bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69616bv64) == 1812bv64);
@@ -54,8 +55,8 @@ procedure {:extern} rely();
 
 procedure {:extern} rely_transitive();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
+  ensures (mem == old(mem));
 
 implementation {:extern} rely_transitive()
 {
@@ -72,20 +73,14 @@ procedure main();
   modifies Gamma_R0, Gamma_R1, Gamma_R31, Gamma_mem, Gamma_stack, R0, R1, R31, mem, stack;
   free requires (memory_load64_le(mem, 69632bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free requires (memory_load8_le(mem, 1916bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1917bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1918bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1919bv64) == 0bv8);
+  free requires (memory_load32_le(mem, 1916bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69016bv64) == 1808bv64);
   free requires (memory_load64_le(mem, 69024bv64) == 1728bv64);
   free requires (memory_load64_le(mem, 69616bv64) == 1812bv64);
   free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
   free ensures (Gamma_R31 == old(Gamma_R31));
   free ensures (R31 == old(R31));
-  free ensures (memory_load8_le(mem, 1916bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1917bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1918bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1919bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1916bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69016bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69024bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69616bv64) == 1812bv64);
diff --git a/src/test/incorrect/basicassign3/gcc_O2/basicassign3.expected b/src/test/incorrect/basicassign3/gcc_O2/basicassign3.expected
index 2e74e5ca1..d14aea98f 100644
--- a/src/test/incorrect/basicassign3/gcc_O2/basicassign3.expected
+++ b/src/test/incorrect/basicassign3/gcc_O2/basicassign3.expected
@@ -10,7 +10,7 @@ const {:extern} $secret_addr: bv64;
 axiom ($secret_addr == 69650bv64);
 const {:extern} $z_addr: bv64;
 axiom ($z_addr == 69649bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
   (if (index == $secret_addr) then false else (if (index == $z_addr) then true else false))
 }
 
@@ -23,6 +23,10 @@ function {:extern} gamma_store8(gammaMap: [bv64]bool, index: bv64, value: bool)
   gammaMap[index := value]
 }
 
+function {:extern} memory_load32_le(memory: [bv64]bv8, index: bv64) returns (bv32) {
+  (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))
+}
+
 function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv64) {
   (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
@@ -38,12 +42,9 @@ function {:extern} memory_store8_le(memory: [bv64]bv8, index: bv64, value: bv8)
 function {:extern} {:bvbuiltin "zero_extend 56"} zero_extend56_8(bv8) returns (bv64);
 procedure {:extern} rely();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
-  free ensures (memory_load8_le(mem, 1896bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1897bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1898bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1899bv64) == 0bv8);
+  ensures (mem == old(mem));
+  free ensures (memory_load32_le(mem, 1896bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69016bv64) == 1872bv64);
   free ensures (memory_load64_le(mem, 69024bv64) == 1792bv64);
   free ensures (memory_load64_le(mem, 69616bv64) == 1536bv64);
@@ -51,8 +52,8 @@ procedure {:extern} rely();
 
 procedure {:extern} rely_transitive();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
+  ensures (mem == old(mem));
 
 implementation {:extern} rely_transitive()
 {
@@ -69,18 +70,12 @@ procedure main();
   modifies Gamma_R0, Gamma_R1, Gamma_R2, Gamma_mem, R0, R1, R2, mem;
   free requires (memory_load64_le(mem, 69632bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free requires (memory_load8_le(mem, 1896bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1897bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1898bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1899bv64) == 0bv8);
+  free requires (memory_load32_le(mem, 1896bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69016bv64) == 1872bv64);
   free requires (memory_load64_le(mem, 69024bv64) == 1792bv64);
   free requires (memory_load64_le(mem, 69616bv64) == 1536bv64);
   free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free ensures (memory_load8_le(mem, 1896bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1897bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1898bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1899bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1896bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69016bv64) == 1872bv64);
   free ensures (memory_load64_le(mem, 69024bv64) == 1792bv64);
   free ensures (memory_load64_le(mem, 69616bv64) == 1536bv64);
diff --git a/src/test/incorrect/basicassign3/gcc_O2/basicassign3_gtirb.expected b/src/test/incorrect/basicassign3/gcc_O2/basicassign3_gtirb.expected
index e83d081a2..3f85361a9 100644
--- a/src/test/incorrect/basicassign3/gcc_O2/basicassign3_gtirb.expected
+++ b/src/test/incorrect/basicassign3/gcc_O2/basicassign3_gtirb.expected
@@ -10,7 +10,7 @@ const {:extern} $secret_addr: bv64;
 axiom ($secret_addr == 69650bv64);
 const {:extern} $z_addr: bv64;
 axiom ($z_addr == 69649bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
   (if (index == $secret_addr) then false else (if (index == $z_addr) then true else false))
 }
 
@@ -23,6 +23,10 @@ function {:extern} gamma_store8(gammaMap: [bv64]bool, index: bv64, value: bool)
   gammaMap[index := value]
 }
 
+function {:extern} memory_load32_le(memory: [bv64]bv8, index: bv64) returns (bv32) {
+  (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))
+}
+
 function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv64) {
   (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
@@ -39,12 +43,9 @@ function {:extern} {:bvbuiltin "zero_extend 24"} zero_extend24_8(bv8) returns (b
 function {:extern} {:bvbuiltin "zero_extend 32"} zero_extend32_32(bv32) returns (bv64);
 procedure {:extern} rely();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
-  free ensures (memory_load8_le(mem, 1896bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1897bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1898bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1899bv64) == 0bv8);
+  ensures (mem == old(mem));
+  free ensures (memory_load32_le(mem, 1896bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69016bv64) == 1872bv64);
   free ensures (memory_load64_le(mem, 69024bv64) == 1792bv64);
   free ensures (memory_load64_le(mem, 69616bv64) == 1536bv64);
@@ -52,8 +53,8 @@ procedure {:extern} rely();
 
 procedure {:extern} rely_transitive();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
+  ensures (mem == old(mem));
 
 implementation {:extern} rely_transitive()
 {
@@ -70,18 +71,12 @@ procedure main();
   modifies Gamma_R0, Gamma_R1, Gamma_R2, Gamma_mem, R0, R1, R2, mem;
   free requires (memory_load64_le(mem, 69632bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free requires (memory_load8_le(mem, 1896bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1897bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1898bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1899bv64) == 0bv8);
+  free requires (memory_load32_le(mem, 1896bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69016bv64) == 1872bv64);
   free requires (memory_load64_le(mem, 69024bv64) == 1792bv64);
   free requires (memory_load64_le(mem, 69616bv64) == 1536bv64);
   free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free ensures (memory_load8_le(mem, 1896bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1897bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1898bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1899bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1896bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69016bv64) == 1872bv64);
   free ensures (memory_load64_le(mem, 69024bv64) == 1792bv64);
   free ensures (memory_load64_le(mem, 69616bv64) == 1536bv64);
diff --git a/src/test/incorrect/basicassign3/gcc_pic/basicassign3.expected b/src/test/incorrect/basicassign3/gcc_pic/basicassign3.expected
index c53177c2b..be209327b 100644
--- a/src/test/incorrect/basicassign3/gcc_pic/basicassign3.expected
+++ b/src/test/incorrect/basicassign3/gcc_pic/basicassign3.expected
@@ -12,7 +12,7 @@ const {:extern} $secret_addr: bv64;
 axiom ($secret_addr == 69650bv64);
 const {:extern} $z_addr: bv64;
 axiom ($z_addr == 69649bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
   (if (index == $secret_addr) then false else (if (index == $z_addr) then true else false))
 }
 
@@ -29,6 +29,10 @@ function {:extern} gamma_store8(gammaMap: [bv64]bool, index: bv64, value: bool)
   gammaMap[index := value]
 }
 
+function {:extern} memory_load32_le(memory: [bv64]bv8, index: bv64) returns (bv32) {
+  (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))
+}
+
 function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv64) {
   (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
@@ -44,23 +48,20 @@ function {:extern} memory_store8_le(memory: [bv64]bv8, index: bv64, value: bv8)
 function {:extern} {:bvbuiltin "zero_extend 56"} zero_extend56_8(bv8) returns (bv64);
 procedure {:extern} rely();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
-  free ensures (memory_load8_le(mem, 1980bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1981bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1982bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1983bv64) == 0bv8);
-  free ensures (memory_load64_le(mem, 69608bv64) == 69650bv64);
-  free ensures (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free ensures (memory_load64_le(mem, 69616bv64) == 1876bv64);
+  ensures (mem == old(mem));
+  free ensures (memory_load32_le(mem, 1980bv64) == 131073bv32);
+  free ensures (memory_load64_le(mem, 69000bv64) == 1872bv64);
   free ensures (memory_load64_le(mem, 69008bv64) == 1792bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 69649bv64);
-  free ensures (memory_load64_le(mem, 69000bv64) == 1872bv64);
+  free ensures (memory_load64_le(mem, 69608bv64) == 69650bv64);
+  free ensures (memory_load64_le(mem, 69616bv64) == 1876bv64);
+  free ensures (memory_load64_le(mem, 69640bv64) == 69640bv64);
 
 procedure {:extern} rely_transitive();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
+  ensures (mem == old(mem));
 
 implementation {:extern} rely_transitive()
 {
@@ -77,28 +78,22 @@ procedure main();
   modifies Gamma_R0, Gamma_R1, Gamma_R31, Gamma_mem, Gamma_stack, R0, R1, R31, mem, stack;
   free requires (memory_load64_le(mem, 69632bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free requires (memory_load8_le(mem, 1980bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1981bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1982bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1983bv64) == 0bv8);
-  free requires (memory_load64_le(mem, 69608bv64) == 69650bv64);
-  free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free requires (memory_load64_le(mem, 69616bv64) == 1876bv64);
+  free requires (memory_load32_le(mem, 1980bv64) == 131073bv32);
+  free requires (memory_load64_le(mem, 69000bv64) == 1872bv64);
   free requires (memory_load64_le(mem, 69008bv64) == 1792bv64);
   free requires (memory_load64_le(mem, 69592bv64) == 69649bv64);
-  free requires (memory_load64_le(mem, 69000bv64) == 1872bv64);
+  free requires (memory_load64_le(mem, 69608bv64) == 69650bv64);
+  free requires (memory_load64_le(mem, 69616bv64) == 1876bv64);
+  free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
   free ensures (Gamma_R31 == old(Gamma_R31));
   free ensures (R31 == old(R31));
-  free ensures (memory_load8_le(mem, 1980bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1981bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1982bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1983bv64) == 0bv8);
-  free ensures (memory_load64_le(mem, 69608bv64) == 69650bv64);
-  free ensures (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free ensures (memory_load64_le(mem, 69616bv64) == 1876bv64);
+  free ensures (memory_load32_le(mem, 1980bv64) == 131073bv32);
+  free ensures (memory_load64_le(mem, 69000bv64) == 1872bv64);
   free ensures (memory_load64_le(mem, 69008bv64) == 1792bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 69649bv64);
-  free ensures (memory_load64_le(mem, 69000bv64) == 1872bv64);
+  free ensures (memory_load64_le(mem, 69608bv64) == 69650bv64);
+  free ensures (memory_load64_le(mem, 69616bv64) == 1876bv64);
+  free ensures (memory_load64_le(mem, 69640bv64) == 69640bv64);
 
 implementation main()
 {
diff --git a/src/test/incorrect/basicassign3/gcc_pic/basicassign3_gtirb.expected b/src/test/incorrect/basicassign3/gcc_pic/basicassign3_gtirb.expected
index ccf993008..f4858673c 100644
--- a/src/test/incorrect/basicassign3/gcc_pic/basicassign3_gtirb.expected
+++ b/src/test/incorrect/basicassign3/gcc_pic/basicassign3_gtirb.expected
@@ -12,7 +12,7 @@ const {:extern} $secret_addr: bv64;
 axiom ($secret_addr == 69650bv64);
 const {:extern} $z_addr: bv64;
 axiom ($z_addr == 69649bv64);
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
   (if (index == $secret_addr) then false else (if (index == $z_addr) then true else false))
 }
 
@@ -29,6 +29,10 @@ function {:extern} gamma_store8(gammaMap: [bv64]bool, index: bv64, value: bool)
   gammaMap[index := value]
 }
 
+function {:extern} memory_load32_le(memory: [bv64]bv8, index: bv64) returns (bv32) {
+  (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))
+}
+
 function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv64) {
   (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
@@ -45,23 +49,20 @@ function {:extern} {:bvbuiltin "zero_extend 24"} zero_extend24_8(bv8) returns (b
 function {:extern} {:bvbuiltin "zero_extend 32"} zero_extend32_32(bv32) returns (bv64);
 procedure {:extern} rely();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
-  free ensures (memory_load8_le(mem, 1980bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1981bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1982bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1983bv64) == 0bv8);
-  free ensures (memory_load64_le(mem, 69608bv64) == 69650bv64);
-  free ensures (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free ensures (memory_load64_le(mem, 69616bv64) == 1876bv64);
+  ensures (mem == old(mem));
+  free ensures (memory_load32_le(mem, 1980bv64) == 131073bv32);
+  free ensures (memory_load64_le(mem, 69000bv64) == 1872bv64);
   free ensures (memory_load64_le(mem, 69008bv64) == 1792bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 69649bv64);
-  free ensures (memory_load64_le(mem, 69000bv64) == 1872bv64);
+  free ensures (memory_load64_le(mem, 69608bv64) == 69650bv64);
+  free ensures (memory_load64_le(mem, 69616bv64) == 1876bv64);
+  free ensures (memory_load64_le(mem, 69640bv64) == 69640bv64);
 
 procedure {:extern} rely_transitive();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
+  ensures (mem == old(mem));
 
 implementation {:extern} rely_transitive()
 {
@@ -78,28 +79,22 @@ procedure main();
   modifies Gamma_R0, Gamma_R1, Gamma_R31, Gamma_mem, Gamma_stack, R0, R1, R31, mem, stack;
   free requires (memory_load64_le(mem, 69632bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free requires (memory_load8_le(mem, 1980bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1981bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1982bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1983bv64) == 0bv8);
-  free requires (memory_load64_le(mem, 69608bv64) == 69650bv64);
-  free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free requires (memory_load64_le(mem, 69616bv64) == 1876bv64);
+  free requires (memory_load32_le(mem, 1980bv64) == 131073bv32);
+  free requires (memory_load64_le(mem, 69000bv64) == 1872bv64);
   free requires (memory_load64_le(mem, 69008bv64) == 1792bv64);
   free requires (memory_load64_le(mem, 69592bv64) == 69649bv64);
-  free requires (memory_load64_le(mem, 69000bv64) == 1872bv64);
+  free requires (memory_load64_le(mem, 69608bv64) == 69650bv64);
+  free requires (memory_load64_le(mem, 69616bv64) == 1876bv64);
+  free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
   free ensures (Gamma_R31 == old(Gamma_R31));
   free ensures (R31 == old(R31));
-  free ensures (memory_load8_le(mem, 1980bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1981bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1982bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1983bv64) == 0bv8);
-  free ensures (memory_load64_le(mem, 69608bv64) == 69650bv64);
-  free ensures (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free ensures (memory_load64_le(mem, 69616bv64) == 1876bv64);
+  free ensures (memory_load32_le(mem, 1980bv64) == 131073bv32);
+  free ensures (memory_load64_le(mem, 69000bv64) == 1872bv64);
   free ensures (memory_load64_le(mem, 69008bv64) == 1792bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 69649bv64);
-  free ensures (memory_load64_le(mem, 69000bv64) == 1872bv64);
+  free ensures (memory_load64_le(mem, 69608bv64) == 69650bv64);
+  free ensures (memory_load64_le(mem, 69616bv64) == 1876bv64);
+  free ensures (memory_load64_le(mem, 69640bv64) == 69640bv64);
 
 implementation main()
 {
diff --git a/src/test/incorrect/iflocal/clang/iflocal.expected b/src/test/incorrect/iflocal/clang/iflocal.expected
index 0bee67490..b4d695d42 100644
--- a/src/test/incorrect/iflocal/clang/iflocal.expected
+++ b/src/test/incorrect/iflocal/clang/iflocal.expected
@@ -39,10 +39,6 @@ function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv6
   (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
-}
-
 function {:extern} memory_store32_le(memory: [bv64]bv8, index: bv64, value: bv32) returns ([bv64]bv8) {
   memory[index := value[8:0]][bvadd64(index, 1bv64) := value[16:8]][bvadd64(index, 2bv64) := value[24:16]][bvadd64(index, 3bv64) := value[32:24]]
 }
@@ -52,12 +48,9 @@ function {:extern} {:bvbuiltin "zero_extend 1"} zero_extend1_32(bv32) returns (b
 function {:extern} {:bvbuiltin "zero_extend 32"} zero_extend32_32(bv32) returns (bv64);
 procedure {:extern} rely();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
-  free ensures (memory_load8_le(mem, 1896bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1897bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1898bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1899bv64) == 0bv8);
+  ensures (mem == old(mem));
+  free ensures (memory_load32_le(mem, 1896bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1812bv64);
@@ -65,8 +58,8 @@ procedure {:extern} rely();
 
 procedure {:extern} rely_transitive();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
+  ensures (mem == old(mem));
 
 implementation {:extern} rely_transitive()
 {
@@ -83,20 +76,14 @@ procedure main();
   modifies CF, Gamma_CF, Gamma_NF, Gamma_R0, Gamma_R31, Gamma_R8, Gamma_VF, Gamma_ZF, Gamma_stack, NF, R0, R31, R8, VF, ZF, stack;
   free requires (memory_load64_le(mem, 69664bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
-  free requires (memory_load8_le(mem, 1896bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1897bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1898bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1899bv64) == 0bv8);
+  free requires (memory_load32_le(mem, 1896bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free requires (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free requires (memory_load64_le(mem, 69592bv64) == 1812bv64);
   free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
   free ensures (Gamma_R31 == old(Gamma_R31));
   free ensures (R31 == old(R31));
-  free ensures (memory_load8_le(mem, 1896bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1897bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1898bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1899bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1896bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1812bv64);
diff --git a/src/test/incorrect/iflocal/clang/iflocal_gtirb.expected b/src/test/incorrect/iflocal/clang/iflocal_gtirb.expected
index 27f877960..7296e2682 100644
--- a/src/test/incorrect/iflocal/clang/iflocal_gtirb.expected
+++ b/src/test/incorrect/iflocal/clang/iflocal_gtirb.expected
@@ -38,10 +38,6 @@ function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv6
   (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
-}
-
 function {:extern} memory_store32_le(memory: [bv64]bv8, index: bv64, value: bv32) returns ([bv64]bv8) {
   memory[index := value[8:0]][bvadd64(index, 1bv64) := value[16:8]][bvadd64(index, 2bv64) := value[24:16]][bvadd64(index, 3bv64) := value[32:24]]
 }
@@ -50,12 +46,9 @@ function {:extern} {:bvbuiltin "zero_extend 1"} zero_extend1_32(bv32) returns (b
 function {:extern} {:bvbuiltin "zero_extend 32"} zero_extend32_32(bv32) returns (bv64);
 procedure {:extern} rely();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
-  free ensures (memory_load8_le(mem, 1896bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1897bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1898bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1899bv64) == 0bv8);
+  ensures (mem == old(mem));
+  free ensures (memory_load32_le(mem, 1896bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1812bv64);
@@ -63,8 +56,8 @@ procedure {:extern} rely();
 
 procedure {:extern} rely_transitive();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
+  ensures (mem == old(mem));
 
 implementation {:extern} rely_transitive()
 {
@@ -81,20 +74,14 @@ procedure main();
   modifies CF, Gamma_CF, Gamma_NF, Gamma_R0, Gamma_R31, Gamma_R8, Gamma_VF, Gamma_ZF, Gamma_stack, NF, R0, R31, R8, VF, ZF, stack;
   free requires (memory_load64_le(mem, 69664bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
-  free requires (memory_load8_le(mem, 1896bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1897bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1898bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1899bv64) == 0bv8);
+  free requires (memory_load32_le(mem, 1896bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free requires (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free requires (memory_load64_le(mem, 69592bv64) == 1812bv64);
   free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
   free ensures (Gamma_R31 == old(Gamma_R31));
   free ensures (R31 == old(R31));
-  free ensures (memory_load8_le(mem, 1896bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1897bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1898bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1899bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1896bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1812bv64);
diff --git a/src/test/incorrect/iflocal/gcc/iflocal.expected b/src/test/incorrect/iflocal/gcc/iflocal.expected
index 56c7ab8a8..f89816a93 100644
--- a/src/test/incorrect/iflocal/gcc/iflocal.expected
+++ b/src/test/incorrect/iflocal/gcc/iflocal.expected
@@ -37,10 +37,6 @@ function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv6
   (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
-}
-
 function {:extern} memory_store32_le(memory: [bv64]bv8, index: bv64, value: bv32) returns ([bv64]bv8) {
   memory[index := value[8:0]][bvadd64(index, 1bv64) := value[16:8]][bvadd64(index, 2bv64) := value[24:16]][bvadd64(index, 3bv64) := value[32:24]]
 }
@@ -50,12 +46,9 @@ function {:extern} {:bvbuiltin "zero_extend 1"} zero_extend1_32(bv32) returns (b
 function {:extern} {:bvbuiltin "zero_extend 32"} zero_extend32_32(bv32) returns (bv64);
 procedure {:extern} rely();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
-  free ensures (memory_load8_le(mem, 1880bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1881bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1882bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1883bv64) == 0bv8);
+  ensures (mem == old(mem));
+  free ensures (memory_load32_le(mem, 1880bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69016bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69024bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69616bv64) == 1812bv64);
@@ -63,8 +56,8 @@ procedure {:extern} rely();
 
 procedure {:extern} rely_transitive();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
+  ensures (mem == old(mem));
 
 implementation {:extern} rely_transitive()
 {
@@ -81,20 +74,14 @@ procedure main();
   modifies CF, Gamma_CF, Gamma_NF, Gamma_R0, Gamma_R31, Gamma_VF, Gamma_ZF, Gamma_stack, NF, R0, R31, VF, ZF, stack;
   free requires (memory_load64_le(mem, 69632bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free requires (memory_load8_le(mem, 1880bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1881bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1882bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1883bv64) == 0bv8);
+  free requires (memory_load32_le(mem, 1880bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69016bv64) == 1808bv64);
   free requires (memory_load64_le(mem, 69024bv64) == 1728bv64);
   free requires (memory_load64_le(mem, 69616bv64) == 1812bv64);
   free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
   free ensures (Gamma_R31 == old(Gamma_R31));
   free ensures (R31 == old(R31));
-  free ensures (memory_load8_le(mem, 1880bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1881bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1882bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1883bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1880bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69016bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69024bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69616bv64) == 1812bv64);
diff --git a/src/test/incorrect/iflocal/gcc/iflocal_gtirb.expected b/src/test/incorrect/iflocal/gcc/iflocal_gtirb.expected
index ff10eb358..f9bfdc01e 100644
--- a/src/test/incorrect/iflocal/gcc/iflocal_gtirb.expected
+++ b/src/test/incorrect/iflocal/gcc/iflocal_gtirb.expected
@@ -36,10 +36,6 @@ function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv6
   (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
-}
-
 function {:extern} memory_store32_le(memory: [bv64]bv8, index: bv64, value: bv32) returns ([bv64]bv8) {
   memory[index := value[8:0]][bvadd64(index, 1bv64) := value[16:8]][bvadd64(index, 2bv64) := value[24:16]][bvadd64(index, 3bv64) := value[32:24]]
 }
@@ -48,12 +44,9 @@ function {:extern} {:bvbuiltin "zero_extend 1"} zero_extend1_32(bv32) returns (b
 function {:extern} {:bvbuiltin "zero_extend 32"} zero_extend32_32(bv32) returns (bv64);
 procedure {:extern} rely();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
-  free ensures (memory_load8_le(mem, 1880bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1881bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1882bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1883bv64) == 0bv8);
+  ensures (mem == old(mem));
+  free ensures (memory_load32_le(mem, 1880bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69016bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69024bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69616bv64) == 1812bv64);
@@ -61,8 +54,8 @@ procedure {:extern} rely();
 
 procedure {:extern} rely_transitive();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
+  ensures (mem == old(mem));
 
 implementation {:extern} rely_transitive()
 {
@@ -79,20 +72,14 @@ procedure main();
   modifies CF, Gamma_CF, Gamma_NF, Gamma_R0, Gamma_R31, Gamma_VF, Gamma_ZF, Gamma_stack, NF, R0, R31, VF, ZF, stack;
   free requires (memory_load64_le(mem, 69632bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free requires (memory_load8_le(mem, 1880bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1881bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1882bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1883bv64) == 0bv8);
+  free requires (memory_load32_le(mem, 1880bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69016bv64) == 1808bv64);
   free requires (memory_load64_le(mem, 69024bv64) == 1728bv64);
   free requires (memory_load64_le(mem, 69616bv64) == 1812bv64);
   free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
   free ensures (Gamma_R31 == old(Gamma_R31));
   free ensures (R31 == old(R31));
-  free ensures (memory_load8_le(mem, 1880bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1881bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1882bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1883bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1880bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69016bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69024bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69616bv64) == 1812bv64);
diff --git a/src/test/incorrect/nestedifglobal/clang/nestedifglobal.expected b/src/test/incorrect/nestedifglobal/clang/nestedifglobal.expected
index 53de1f20f..f21ee0c3b 100644
--- a/src/test/incorrect/nestedifglobal/clang/nestedifglobal.expected
+++ b/src/test/incorrect/nestedifglobal/clang/nestedifglobal.expected
@@ -18,7 +18,7 @@ var {:extern} VF: bv1;
 var {:extern} ZF: bv1;
 var {:extern} mem: [bv64]bv8;
 var {:extern} stack: [bv64]bv8;
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
   false
 }
 
@@ -45,10 +45,6 @@ function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv6
   (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
-}
-
 function {:extern} memory_store32_le(memory: [bv64]bv8, index: bv64, value: bv32) returns ([bv64]bv8) {
   memory[index := value[8:0]][bvadd64(index, 1bv64) := value[16:8]][bvadd64(index, 2bv64) := value[24:16]][bvadd64(index, 3bv64) := value[32:24]]
 }
@@ -58,12 +54,9 @@ function {:extern} {:bvbuiltin "zero_extend 1"} zero_extend1_32(bv32) returns (b
 function {:extern} {:bvbuiltin "zero_extend 32"} zero_extend32_32(bv32) returns (bv64);
 procedure {:extern} rely();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
-  free ensures (memory_load8_le(mem, 1976bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1977bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1978bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1979bv64) == 0bv8);
+  ensures (mem == old(mem));
+  free ensures (memory_load32_le(mem, 1976bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1812bv64);
@@ -71,8 +64,8 @@ procedure {:extern} rely();
 
 procedure {:extern} rely_transitive();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
+  ensures (mem == old(mem));
 
 implementation {:extern} rely_transitive()
 {
@@ -89,20 +82,14 @@ procedure main();
   modifies CF, Gamma_CF, Gamma_NF, Gamma_R0, Gamma_R31, Gamma_R8, Gamma_R9, Gamma_VF, Gamma_ZF, Gamma_mem, Gamma_stack, NF, R0, R31, R8, R9, VF, ZF, mem, stack;
   free requires (memory_load64_le(mem, 69664bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
-  free requires (memory_load8_le(mem, 1976bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1977bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1978bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1979bv64) == 0bv8);
+  free requires (memory_load32_le(mem, 1976bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free requires (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free requires (memory_load64_le(mem, 69592bv64) == 1812bv64);
   free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
   free ensures (Gamma_R31 == old(Gamma_R31));
   free ensures (R31 == old(R31));
-  free ensures (memory_load8_le(mem, 1976bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1977bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1978bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1979bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1976bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1812bv64);
diff --git a/src/test/incorrect/nestedifglobal/clang/nestedifglobal_gtirb.expected b/src/test/incorrect/nestedifglobal/clang/nestedifglobal_gtirb.expected
index d813bfa91..6378df02e 100644
--- a/src/test/incorrect/nestedifglobal/clang/nestedifglobal_gtirb.expected
+++ b/src/test/incorrect/nestedifglobal/clang/nestedifglobal_gtirb.expected
@@ -18,7 +18,7 @@ var {:extern} VF: bv1;
 var {:extern} ZF: bv1;
 var {:extern} mem: [bv64]bv8;
 var {:extern} stack: [bv64]bv8;
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
   false
 }
 
@@ -44,10 +44,6 @@ function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv6
   (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
-}
-
 function {:extern} memory_store32_le(memory: [bv64]bv8, index: bv64, value: bv32) returns ([bv64]bv8) {
   memory[index := value[8:0]][bvadd64(index, 1bv64) := value[16:8]][bvadd64(index, 2bv64) := value[24:16]][bvadd64(index, 3bv64) := value[32:24]]
 }
@@ -57,12 +53,9 @@ function {:extern} {:bvbuiltin "zero_extend 1"} zero_extend1_32(bv32) returns (b
 function {:extern} {:bvbuiltin "zero_extend 32"} zero_extend32_32(bv32) returns (bv64);
 procedure {:extern} rely();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
-  free ensures (memory_load8_le(mem, 1980bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1981bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1982bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1983bv64) == 0bv8);
+  ensures (mem == old(mem));
+  free ensures (memory_load32_le(mem, 1980bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1812bv64);
@@ -70,8 +63,8 @@ procedure {:extern} rely();
 
 procedure {:extern} rely_transitive();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
+  ensures (mem == old(mem));
 
 implementation {:extern} rely_transitive()
 {
@@ -88,20 +81,14 @@ procedure main();
   modifies CF, Gamma_CF, Gamma_NF, Gamma_R0, Gamma_R31, Gamma_R8, Gamma_R9, Gamma_VF, Gamma_ZF, Gamma_mem, Gamma_stack, NF, R0, R31, R8, R9, VF, ZF, mem, stack;
   free requires (memory_load64_le(mem, 69664bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
-  free requires (memory_load8_le(mem, 1980bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1981bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1982bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1983bv64) == 0bv8);
+  free requires (memory_load32_le(mem, 1980bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free requires (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free requires (memory_load64_le(mem, 69592bv64) == 1812bv64);
   free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
   free ensures (Gamma_R31 == old(Gamma_R31));
   free ensures (R31 == old(R31));
-  free ensures (memory_load8_le(mem, 1980bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1981bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1982bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1983bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1980bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69064bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69072bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1812bv64);
diff --git a/src/test/incorrect/nestedifglobal/clang_pic/nestedifglobal.expected b/src/test/incorrect/nestedifglobal/clang_pic/nestedifglobal.expected
index 8f50a130a..80d21764f 100644
--- a/src/test/incorrect/nestedifglobal/clang_pic/nestedifglobal.expected
+++ b/src/test/incorrect/nestedifglobal/clang_pic/nestedifglobal.expected
@@ -18,7 +18,7 @@ var {:extern} VF: bv1;
 var {:extern} ZF: bv1;
 var {:extern} mem: [bv64]bv8;
 var {:extern} stack: [bv64]bv8;
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
   false
 }
 
@@ -53,10 +53,6 @@ function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv6
   (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
-}
-
 function {:extern} memory_store32_le(memory: [bv64]bv8, index: bv64, value: bv32) returns ([bv64]bv8) {
   memory[index := value[8:0]][bvadd64(index, 1bv64) := value[16:8]][bvadd64(index, 2bv64) := value[24:16]][bvadd64(index, 3bv64) := value[32:24]]
 }
@@ -70,23 +66,20 @@ function {:extern} {:bvbuiltin "zero_extend 1"} zero_extend1_32(bv32) returns (b
 function {:extern} {:bvbuiltin "zero_extend 32"} zero_extend32_32(bv32) returns (bv64);
 procedure {:extern} rely();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
-  free ensures (memory_load8_le(mem, 2052bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 2053bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 2054bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 2055bv64) == 0bv8);
-  free ensures (memory_load64_le(mem, 69576bv64) == 69684bv64);
-  free ensures (memory_load64_le(mem, 69672bv64) == 69672bv64);
+  ensures (mem == old(mem));
+  free ensures (memory_load32_le(mem, 2052bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69048bv64) == 1872bv64);
+  free ensures (memory_load64_le(mem, 69056bv64) == 1792bv64);
   free ensures (memory_load64_le(mem, 69568bv64) == 69688bv64);
+  free ensures (memory_load64_le(mem, 69576bv64) == 69684bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1876bv64);
-  free ensures (memory_load64_le(mem, 69056bv64) == 1792bv64);
+  free ensures (memory_load64_le(mem, 69672bv64) == 69672bv64);
 
 procedure {:extern} rely_transitive();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
+  ensures (mem == old(mem));
 
 implementation {:extern} rely_transitive()
 {
@@ -103,28 +96,22 @@ procedure main();
   modifies CF, Gamma_CF, Gamma_NF, Gamma_R0, Gamma_R31, Gamma_R8, Gamma_R9, Gamma_VF, Gamma_ZF, Gamma_mem, Gamma_stack, NF, R0, R31, R8, R9, VF, ZF, mem, stack;
   free requires (memory_load64_le(mem, 69664bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
-  free requires (memory_load8_le(mem, 2052bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 2053bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 2054bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 2055bv64) == 0bv8);
-  free requires (memory_load64_le(mem, 69576bv64) == 69684bv64);
-  free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
+  free requires (memory_load32_le(mem, 2052bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69048bv64) == 1872bv64);
+  free requires (memory_load64_le(mem, 69056bv64) == 1792bv64);
   free requires (memory_load64_le(mem, 69568bv64) == 69688bv64);
+  free requires (memory_load64_le(mem, 69576bv64) == 69684bv64);
   free requires (memory_load64_le(mem, 69592bv64) == 1876bv64);
-  free requires (memory_load64_le(mem, 69056bv64) == 1792bv64);
+  free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
   free ensures (Gamma_R31 == old(Gamma_R31));
   free ensures (R31 == old(R31));
-  free ensures (memory_load8_le(mem, 2052bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 2053bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 2054bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 2055bv64) == 0bv8);
-  free ensures (memory_load64_le(mem, 69576bv64) == 69684bv64);
-  free ensures (memory_load64_le(mem, 69672bv64) == 69672bv64);
+  free ensures (memory_load32_le(mem, 2052bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69048bv64) == 1872bv64);
+  free ensures (memory_load64_le(mem, 69056bv64) == 1792bv64);
   free ensures (memory_load64_le(mem, 69568bv64) == 69688bv64);
+  free ensures (memory_load64_le(mem, 69576bv64) == 69684bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1876bv64);
-  free ensures (memory_load64_le(mem, 69056bv64) == 1792bv64);
+  free ensures (memory_load64_le(mem, 69672bv64) == 69672bv64);
 
 implementation main()
 {
diff --git a/src/test/incorrect/nestedifglobal/clang_pic/nestedifglobal_gtirb.expected b/src/test/incorrect/nestedifglobal/clang_pic/nestedifglobal_gtirb.expected
index 8bce8a767..88dd27ef3 100644
--- a/src/test/incorrect/nestedifglobal/clang_pic/nestedifglobal_gtirb.expected
+++ b/src/test/incorrect/nestedifglobal/clang_pic/nestedifglobal_gtirb.expected
@@ -18,7 +18,7 @@ var {:extern} VF: bv1;
 var {:extern} ZF: bv1;
 var {:extern} mem: [bv64]bv8;
 var {:extern} stack: [bv64]bv8;
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
   false
 }
 
@@ -52,10 +52,6 @@ function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv6
   (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
-}
-
 function {:extern} memory_store32_le(memory: [bv64]bv8, index: bv64, value: bv32) returns ([bv64]bv8) {
   memory[index := value[8:0]][bvadd64(index, 1bv64) := value[16:8]][bvadd64(index, 2bv64) := value[24:16]][bvadd64(index, 3bv64) := value[32:24]]
 }
@@ -69,23 +65,20 @@ function {:extern} {:bvbuiltin "zero_extend 1"} zero_extend1_32(bv32) returns (b
 function {:extern} {:bvbuiltin "zero_extend 32"} zero_extend32_32(bv32) returns (bv64);
 procedure {:extern} rely();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
-  free ensures (memory_load8_le(mem, 2060bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 2061bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 2062bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 2063bv64) == 0bv8);
-  free ensures (memory_load64_le(mem, 69576bv64) == 69684bv64);
-  free ensures (memory_load64_le(mem, 69672bv64) == 69672bv64);
+  ensures (mem == old(mem));
+  free ensures (memory_load32_le(mem, 2060bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69048bv64) == 1872bv64);
+  free ensures (memory_load64_le(mem, 69056bv64) == 1792bv64);
   free ensures (memory_load64_le(mem, 69568bv64) == 69688bv64);
+  free ensures (memory_load64_le(mem, 69576bv64) == 69684bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1876bv64);
-  free ensures (memory_load64_le(mem, 69056bv64) == 1792bv64);
+  free ensures (memory_load64_le(mem, 69672bv64) == 69672bv64);
 
 procedure {:extern} rely_transitive();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
+  ensures (mem == old(mem));
 
 implementation {:extern} rely_transitive()
 {
@@ -102,28 +95,22 @@ procedure main();
   modifies CF, Gamma_CF, Gamma_NF, Gamma_R0, Gamma_R31, Gamma_R8, Gamma_R9, Gamma_VF, Gamma_ZF, Gamma_mem, Gamma_stack, NF, R0, R31, R8, R9, VF, ZF, mem, stack;
   free requires (memory_load64_le(mem, 69664bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
-  free requires (memory_load8_le(mem, 2060bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 2061bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 2062bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 2063bv64) == 0bv8);
-  free requires (memory_load64_le(mem, 69576bv64) == 69684bv64);
-  free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
+  free requires (memory_load32_le(mem, 2060bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69048bv64) == 1872bv64);
+  free requires (memory_load64_le(mem, 69056bv64) == 1792bv64);
   free requires (memory_load64_le(mem, 69568bv64) == 69688bv64);
+  free requires (memory_load64_le(mem, 69576bv64) == 69684bv64);
   free requires (memory_load64_le(mem, 69592bv64) == 1876bv64);
-  free requires (memory_load64_le(mem, 69056bv64) == 1792bv64);
+  free requires (memory_load64_le(mem, 69672bv64) == 69672bv64);
   free ensures (Gamma_R31 == old(Gamma_R31));
   free ensures (R31 == old(R31));
-  free ensures (memory_load8_le(mem, 2060bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 2061bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 2062bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 2063bv64) == 0bv8);
-  free ensures (memory_load64_le(mem, 69576bv64) == 69684bv64);
-  free ensures (memory_load64_le(mem, 69672bv64) == 69672bv64);
+  free ensures (memory_load32_le(mem, 2060bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69048bv64) == 1872bv64);
+  free ensures (memory_load64_le(mem, 69056bv64) == 1792bv64);
   free ensures (memory_load64_le(mem, 69568bv64) == 69688bv64);
+  free ensures (memory_load64_le(mem, 69576bv64) == 69684bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 1876bv64);
-  free ensures (memory_load64_le(mem, 69056bv64) == 1792bv64);
+  free ensures (memory_load64_le(mem, 69672bv64) == 69672bv64);
 
 implementation main()
 {
diff --git a/src/test/incorrect/nestedifglobal/gcc/nestedifglobal.expected b/src/test/incorrect/nestedifglobal/gcc/nestedifglobal.expected
index e2f024896..ef127f1d9 100644
--- a/src/test/incorrect/nestedifglobal/gcc/nestedifglobal.expected
+++ b/src/test/incorrect/nestedifglobal/gcc/nestedifglobal.expected
@@ -16,7 +16,7 @@ var {:extern} VF: bv1;
 var {:extern} ZF: bv1;
 var {:extern} mem: [bv64]bv8;
 var {:extern} stack: [bv64]bv8;
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
   false
 }
 
@@ -43,10 +43,6 @@ function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv6
   (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
-}
-
 function {:extern} memory_store32_le(memory: [bv64]bv8, index: bv64, value: bv32) returns ([bv64]bv8) {
   memory[index := value[8:0]][bvadd64(index, 1bv64) := value[16:8]][bvadd64(index, 2bv64) := value[24:16]][bvadd64(index, 3bv64) := value[32:24]]
 }
@@ -56,12 +52,9 @@ function {:extern} {:bvbuiltin "zero_extend 1"} zero_extend1_32(bv32) returns (b
 function {:extern} {:bvbuiltin "zero_extend 32"} zero_extend32_32(bv32) returns (bv64);
 procedure {:extern} rely();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
-  free ensures (memory_load8_le(mem, 1956bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1957bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1958bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1959bv64) == 0bv8);
+  ensures (mem == old(mem));
+  free ensures (memory_load32_le(mem, 1956bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69016bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69024bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69616bv64) == 1812bv64);
@@ -69,8 +62,8 @@ procedure {:extern} rely();
 
 procedure {:extern} rely_transitive();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
+  ensures (mem == old(mem));
 
 implementation {:extern} rely_transitive()
 {
@@ -87,20 +80,14 @@ procedure main();
   modifies CF, Gamma_CF, Gamma_NF, Gamma_R0, Gamma_R1, Gamma_R31, Gamma_VF, Gamma_ZF, Gamma_mem, Gamma_stack, NF, R0, R1, R31, VF, ZF, mem, stack;
   free requires (memory_load64_le(mem, 69632bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free requires (memory_load8_le(mem, 1956bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1957bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1958bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1959bv64) == 0bv8);
+  free requires (memory_load32_le(mem, 1956bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69016bv64) == 1808bv64);
   free requires (memory_load64_le(mem, 69024bv64) == 1728bv64);
   free requires (memory_load64_le(mem, 69616bv64) == 1812bv64);
   free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
   free ensures (Gamma_R31 == old(Gamma_R31));
   free ensures (R31 == old(R31));
-  free ensures (memory_load8_le(mem, 1956bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1957bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1958bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1959bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1956bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69016bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69024bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69616bv64) == 1812bv64);
diff --git a/src/test/incorrect/nestedifglobal/gcc/nestedifglobal_gtirb.expected b/src/test/incorrect/nestedifglobal/gcc/nestedifglobal_gtirb.expected
index df7992d44..51b6b796d 100644
--- a/src/test/incorrect/nestedifglobal/gcc/nestedifglobal_gtirb.expected
+++ b/src/test/incorrect/nestedifglobal/gcc/nestedifglobal_gtirb.expected
@@ -16,7 +16,7 @@ var {:extern} VF: bv1;
 var {:extern} ZF: bv1;
 var {:extern} mem: [bv64]bv8;
 var {:extern} stack: [bv64]bv8;
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
   false
 }
 
@@ -42,10 +42,6 @@ function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv6
   (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
-}
-
 function {:extern} memory_store32_le(memory: [bv64]bv8, index: bv64, value: bv32) returns ([bv64]bv8) {
   memory[index := value[8:0]][bvadd64(index, 1bv64) := value[16:8]][bvadd64(index, 2bv64) := value[24:16]][bvadd64(index, 3bv64) := value[32:24]]
 }
@@ -55,12 +51,9 @@ function {:extern} {:bvbuiltin "zero_extend 1"} zero_extend1_32(bv32) returns (b
 function {:extern} {:bvbuiltin "zero_extend 32"} zero_extend32_32(bv32) returns (bv64);
 procedure {:extern} rely();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
-  free ensures (memory_load8_le(mem, 1964bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1965bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1966bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1967bv64) == 0bv8);
+  ensures (mem == old(mem));
+  free ensures (memory_load32_le(mem, 1964bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69016bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69024bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69616bv64) == 1812bv64);
@@ -68,8 +61,8 @@ procedure {:extern} rely();
 
 procedure {:extern} rely_transitive();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
+  ensures (mem == old(mem));
 
 implementation {:extern} rely_transitive()
 {
@@ -86,20 +79,14 @@ procedure main();
   modifies CF, Gamma_CF, Gamma_NF, Gamma_R0, Gamma_R1, Gamma_R31, Gamma_VF, Gamma_ZF, Gamma_mem, Gamma_stack, NF, R0, R1, R31, VF, ZF, mem, stack;
   free requires (memory_load64_le(mem, 69632bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free requires (memory_load8_le(mem, 1964bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 1965bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 1966bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 1967bv64) == 0bv8);
+  free requires (memory_load32_le(mem, 1964bv64) == 131073bv32);
   free requires (memory_load64_le(mem, 69016bv64) == 1808bv64);
   free requires (memory_load64_le(mem, 69024bv64) == 1728bv64);
   free requires (memory_load64_le(mem, 69616bv64) == 1812bv64);
   free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
   free ensures (Gamma_R31 == old(Gamma_R31));
   free ensures (R31 == old(R31));
-  free ensures (memory_load8_le(mem, 1964bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 1965bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 1966bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 1967bv64) == 0bv8);
+  free ensures (memory_load32_le(mem, 1964bv64) == 131073bv32);
   free ensures (memory_load64_le(mem, 69016bv64) == 1808bv64);
   free ensures (memory_load64_le(mem, 69024bv64) == 1728bv64);
   free ensures (memory_load64_le(mem, 69616bv64) == 1812bv64);
diff --git a/src/test/incorrect/nestedifglobal/gcc_pic/nestedifglobal.expected b/src/test/incorrect/nestedifglobal/gcc_pic/nestedifglobal.expected
index 03cb61a25..eba786ea8 100644
--- a/src/test/incorrect/nestedifglobal/gcc_pic/nestedifglobal.expected
+++ b/src/test/incorrect/nestedifglobal/gcc_pic/nestedifglobal.expected
@@ -16,7 +16,7 @@ var {:extern} VF: bv1;
 var {:extern} ZF: bv1;
 var {:extern} mem: [bv64]bv8;
 var {:extern} stack: [bv64]bv8;
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
   false
 }
 
@@ -47,10 +47,6 @@ function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv6
   (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
-}
-
 function {:extern} memory_store32_le(memory: [bv64]bv8, index: bv64, value: bv32) returns ([bv64]bv8) {
   memory[index := value[8:0]][bvadd64(index, 1bv64) := value[16:8]][bvadd64(index, 2bv64) := value[24:16]][bvadd64(index, 3bv64) := value[32:24]]
 }
@@ -60,23 +56,20 @@ function {:extern} {:bvbuiltin "zero_extend 1"} zero_extend1_32(bv32) returns (b
 function {:extern} {:bvbuiltin "zero_extend 32"} zero_extend32_32(bv32) returns (bv64);
 procedure {:extern} rely();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
-  free ensures (memory_load8_le(mem, 2020bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 2021bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 2022bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 2023bv64) == 0bv8);
-  free ensures (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free ensures (memory_load64_le(mem, 69616bv64) == 1876bv64);
-  free ensures (memory_load64_le(mem, 69600bv64) == 69652bv64);
+  ensures (mem == old(mem));
+  free ensures (memory_load32_le(mem, 2020bv64) == 131073bv32);
+  free ensures (memory_load64_le(mem, 69000bv64) == 1872bv64);
   free ensures (memory_load64_le(mem, 69008bv64) == 1792bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 69656bv64);
-  free ensures (memory_load64_le(mem, 69000bv64) == 1872bv64);
+  free ensures (memory_load64_le(mem, 69600bv64) == 69652bv64);
+  free ensures (memory_load64_le(mem, 69616bv64) == 1876bv64);
+  free ensures (memory_load64_le(mem, 69640bv64) == 69640bv64);
 
 procedure {:extern} rely_transitive();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
+  ensures (mem == old(mem));
 
 implementation {:extern} rely_transitive()
 {
@@ -93,28 +86,22 @@ procedure main();
   modifies CF, Gamma_CF, Gamma_NF, Gamma_R0, Gamma_R1, Gamma_R31, Gamma_VF, Gamma_ZF, Gamma_mem, Gamma_stack, NF, R0, R1, R31, VF, ZF, mem, stack;
   free requires (memory_load64_le(mem, 69632bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free requires (memory_load8_le(mem, 2020bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 2021bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 2022bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 2023bv64) == 0bv8);
-  free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free requires (memory_load64_le(mem, 69616bv64) == 1876bv64);
-  free requires (memory_load64_le(mem, 69600bv64) == 69652bv64);
+  free requires (memory_load32_le(mem, 2020bv64) == 131073bv32);
+  free requires (memory_load64_le(mem, 69000bv64) == 1872bv64);
   free requires (memory_load64_le(mem, 69008bv64) == 1792bv64);
   free requires (memory_load64_le(mem, 69592bv64) == 69656bv64);
-  free requires (memory_load64_le(mem, 69000bv64) == 1872bv64);
+  free requires (memory_load64_le(mem, 69600bv64) == 69652bv64);
+  free requires (memory_load64_le(mem, 69616bv64) == 1876bv64);
+  free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
   free ensures (Gamma_R31 == old(Gamma_R31));
   free ensures (R31 == old(R31));
-  free ensures (memory_load8_le(mem, 2020bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 2021bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 2022bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 2023bv64) == 0bv8);
-  free ensures (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free ensures (memory_load64_le(mem, 69616bv64) == 1876bv64);
-  free ensures (memory_load64_le(mem, 69600bv64) == 69652bv64);
+  free ensures (memory_load32_le(mem, 2020bv64) == 131073bv32);
+  free ensures (memory_load64_le(mem, 69000bv64) == 1872bv64);
   free ensures (memory_load64_le(mem, 69008bv64) == 1792bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 69656bv64);
-  free ensures (memory_load64_le(mem, 69000bv64) == 1872bv64);
+  free ensures (memory_load64_le(mem, 69600bv64) == 69652bv64);
+  free ensures (memory_load64_le(mem, 69616bv64) == 1876bv64);
+  free ensures (memory_load64_le(mem, 69640bv64) == 69640bv64);
 
 implementation main()
 {
diff --git a/src/test/incorrect/nestedifglobal/gcc_pic/nestedifglobal_gtirb.expected b/src/test/incorrect/nestedifglobal/gcc_pic/nestedifglobal_gtirb.expected
index 1c44677d8..8e445464f 100644
--- a/src/test/incorrect/nestedifglobal/gcc_pic/nestedifglobal_gtirb.expected
+++ b/src/test/incorrect/nestedifglobal/gcc_pic/nestedifglobal_gtirb.expected
@@ -16,7 +16,7 @@ var {:extern} VF: bv1;
 var {:extern} ZF: bv1;
 var {:extern} mem: [bv64]bv8;
 var {:extern} stack: [bv64]bv8;
-function {:extern} L(memory: [bv64]bv8, index: bv64) returns (bool) {
+function {:extern} L(mem$in: [bv64]bv8, index: bv64) returns (bool) {
   false
 }
 
@@ -46,10 +46,6 @@ function {:extern} memory_load64_le(memory: [bv64]bv8, index: bv64) returns (bv6
   (memory[bvadd64(index, 7bv64)] ++ (memory[bvadd64(index, 6bv64)] ++ (memory[bvadd64(index, 5bv64)] ++ (memory[bvadd64(index, 4bv64)] ++ (memory[bvadd64(index, 3bv64)] ++ (memory[bvadd64(index, 2bv64)] ++ (memory[bvadd64(index, 1bv64)] ++ memory[index])))))))
 }
 
-function {:extern} memory_load8_le(memory: [bv64]bv8, index: bv64) returns (bv8) {
-  memory[index]
-}
-
 function {:extern} memory_store32_le(memory: [bv64]bv8, index: bv64, value: bv32) returns ([bv64]bv8) {
   memory[index := value[8:0]][bvadd64(index, 1bv64) := value[16:8]][bvadd64(index, 2bv64) := value[24:16]][bvadd64(index, 3bv64) := value[32:24]]
 }
@@ -59,23 +55,20 @@ function {:extern} {:bvbuiltin "zero_extend 1"} zero_extend1_32(bv32) returns (b
 function {:extern} {:bvbuiltin "zero_extend 32"} zero_extend32_32(bv32) returns (bv64);
 procedure {:extern} rely();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
-  free ensures (memory_load8_le(mem, 2028bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 2029bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 2030bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 2031bv64) == 0bv8);
-  free ensures (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free ensures (memory_load64_le(mem, 69616bv64) == 1876bv64);
-  free ensures (memory_load64_le(mem, 69600bv64) == 69652bv64);
+  ensures (mem == old(mem));
+  free ensures (memory_load32_le(mem, 2028bv64) == 131073bv32);
+  free ensures (memory_load64_le(mem, 69000bv64) == 1872bv64);
   free ensures (memory_load64_le(mem, 69008bv64) == 1792bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 69656bv64);
-  free ensures (memory_load64_le(mem, 69000bv64) == 1872bv64);
+  free ensures (memory_load64_le(mem, 69600bv64) == 69652bv64);
+  free ensures (memory_load64_le(mem, 69616bv64) == 1876bv64);
+  free ensures (memory_load64_le(mem, 69640bv64) == 69640bv64);
 
 procedure {:extern} rely_transitive();
   modifies Gamma_mem, mem;
-  ensures (mem == old(mem));
   ensures (Gamma_mem == old(Gamma_mem));
+  ensures (mem == old(mem));
 
 implementation {:extern} rely_transitive()
 {
@@ -92,28 +85,22 @@ procedure main();
   modifies CF, Gamma_CF, Gamma_NF, Gamma_R0, Gamma_R1, Gamma_R31, Gamma_VF, Gamma_ZF, Gamma_mem, Gamma_stack, NF, R0, R1, R31, VF, ZF, mem, stack;
   free requires (memory_load64_le(mem, 69632bv64) == 0bv64);
   free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free requires (memory_load8_le(mem, 2028bv64) == 1bv8);
-  free requires (memory_load8_le(mem, 2029bv64) == 0bv8);
-  free requires (memory_load8_le(mem, 2030bv64) == 2bv8);
-  free requires (memory_load8_le(mem, 2031bv64) == 0bv8);
-  free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free requires (memory_load64_le(mem, 69616bv64) == 1876bv64);
-  free requires (memory_load64_le(mem, 69600bv64) == 69652bv64);
+  free requires (memory_load32_le(mem, 2028bv64) == 131073bv32);
+  free requires (memory_load64_le(mem, 69000bv64) == 1872bv64);
   free requires (memory_load64_le(mem, 69008bv64) == 1792bv64);
   free requires (memory_load64_le(mem, 69592bv64) == 69656bv64);
-  free requires (memory_load64_le(mem, 69000bv64) == 1872bv64);
+  free requires (memory_load64_le(mem, 69600bv64) == 69652bv64);
+  free requires (memory_load64_le(mem, 69616bv64) == 1876bv64);
+  free requires (memory_load64_le(mem, 69640bv64) == 69640bv64);
   free ensures (Gamma_R31 == old(Gamma_R31));
   free ensures (R31 == old(R31));
-  free ensures (memory_load8_le(mem, 2028bv64) == 1bv8);
-  free ensures (memory_load8_le(mem, 2029bv64) == 0bv8);
-  free ensures (memory_load8_le(mem, 2030bv64) == 2bv8);
-  free ensures (memory_load8_le(mem, 2031bv64) == 0bv8);
-  free ensures (memory_load64_le(mem, 69640bv64) == 69640bv64);
-  free ensures (memory_load64_le(mem, 69616bv64) == 1876bv64);
-  free ensures (memory_load64_le(mem, 69600bv64) == 69652bv64);
+  free ensures (memory_load32_le(mem, 2028bv64) == 131073bv32);
+  free ensures (memory_load64_le(mem, 69000bv64) == 1872bv64);
   free ensures (memory_load64_le(mem, 69008bv64) == 1792bv64);
   free ensures (memory_load64_le(mem, 69592bv64) == 69656bv64);
-  free ensures (memory_load64_le(mem, 69000bv64) == 1872bv64);
+  free ensures (memory_load64_le(mem, 69600bv64) == 69652bv64);
+  free ensures (memory_load64_le(mem, 69616bv64) == 1876bv64);
+  free ensures (memory_load64_le(mem, 69640bv64) == 69640bv64);
 
 implementation main()
 {
diff --git a/src/test/scala/DataStructureAnalysisTest.scala b/src/test/scala/DataStructureAnalysisTest.scala
new file mode 100644
index 000000000..80d848821
--- /dev/null
+++ b/src/test/scala/DataStructureAnalysisTest.scala
@@ -0,0 +1,532 @@
+import analysis.data_structure_analysis.*
+import ir.*
+import org.scalatest.funsuite.AnyFunSuite
+import ir.dsl.*
+import specification.Specification
+import util.{BASILConfig, BASILResult, BoogieGeneratorConfig, ILLoadingConfig, IRContext, RunUtils, StaticAnalysisConfig, StaticAnalysisContext}
+
+/**
+ * This is the test suite for testing DSA functionality
+ * The tests follow a general pattern of running BASIL analyses on a test program
+ * and then asserting properties about the Data Structure Graph (DSG) of the function produced at
+ * different levels
+ *
+ * DSA has three phases.
+ * BASILRESULT.analysis.get.local is the set of graphs from the end of the local phase
+ * BASILRESULT.analysis.get.bu is the set of graphs from the end of the bottom-up phase
+ * BASILRESULT.analysis.get.td is the set of graphs from the end of the top-down phase
+ *
+ */
+class DataStructureAnalysisTest extends AnyFunSuite {
+
+  def runAnalysis(program: Program): StaticAnalysisContext = {
+    cilvisitor.visit_prog(transforms.ReplaceReturns(), program)
+    transforms.addReturnBlocks(program)
+    cilvisitor.visit_prog(transforms.ConvertSingleReturn(), program)
+
+    val emptySpec = Specification(Set(), Set(), Map(), List(), List(), List(), Set())
+    val emptyContext = IRContext(List(), Set(), Set(), Set(), Map(), emptySpec, program)
+    RunUtils.staticAnalysis(StaticAnalysisConfig(), emptyContext)
+  }
+
+  def runTest(path: String): BASILResult = {
+    RunUtils.loadAndTranslate(
+      BASILConfig(
+        loading = ILLoadingConfig(
+          inputFile = path + ".adt",
+          relfFile = path + ".relf",
+          specFile = None,
+          dumpIL = None,
+        ),
+        staticAnalysis = Some(StaticAnalysisConfig()),
+        boogieTranslation = BoogieGeneratorConfig(),
+        outputPrefix = "boogie_out",
+      )
+    )
+  }
+
+  // Local DSA tests
+  /*
+  TODO - rewrite this test with a new input that is more suitable than the removed example
+  test("basic pointer") {
+    val results = RunUtils.loadAndTranslate(
+      BASILConfig(
+        loading = ILLoadingConfig(
+          inputFile = "examples/basicpointer/basicpointer.adt",
+          relfFile = "examples/basicpointer/basicpointer.relf",
+          specFile = None,
+          dumpIL = None,
+        ),
+        staticAnalysis = Some(StaticAnalysisConfig()),
+        boogieTranslation = BoogieGeneratorConfig(),
+        outputPrefix = "boogie_out",
+      )
+    )
+    val program = results.ir.program
+
+    // the dsg of the main procedure after the local phase
+    val dsg = results.analysis.get.localDSA(program.mainProcedure)
+
+    // dsg.formals(R29) is the slice representing formal R29
+    val R29formal = dsg.adjust(dsg.formals(R29))
+
+    // cells representing the stack at various offsets
+    val stack0 = dsg.find(dsg.stackMapping(0).cells(0)) // R31
+    val stack8 = dsg.find(dsg.stackMapping(8).cells(0)) //  R31 + 8
+    val stack40 = dsg.find(dsg.stackMapping(40).cells(0))//  R31 + 40
+    val stack32 = dsg.find(dsg.stackMapping(32).cells(0)) //  R31 + 32
+    val stack24 = dsg.find(dsg.stackMapping(24).cells(0)) //  R31 + 24 and Malloc
+
+    assert(dsg.adjust(stack0.getPointee).equals(R29formal)) // R31 points to the frame pointer
+    assert(dsg.adjust(stack8.getPointee).equals(dsg.adjust(dsg.formals(R30)))) // R31 + 8 points to the link register
+
+    /*
+    Position 0000044F: tmp1 := R31 + 24 // Ev(tmp1) = new Node(R31 + 24).0
+    implicit normalisation: tmp2 := R31 + 32 // Ev(tmp2) = new Node(R31 + 32).0
+    Position 00000457: *tmp2 := tmp1 // merge(Ev(tmp1), E(Ev(tmp2)))
+    Therefore, Node(R31 + 32).0.pointee is merged with Node(R31 + 24).0, making E(Node(R31 + 32).0) == Node(R31 + 24).0
+    at position 00000446 Ev(R0) == Malloc_Node == E(Node(R31 + 24).0) we have
+    mem := mem with [R31 + 0x20, el]:u64 <- R0
+    *(R31 + 32) := R0
+    merge(Ev(R0), E(Ev(R31+ 32))
+    == merge(E(Node(R31 + 24).0), E(Node(R31 + 32).0))
+    == merge(E(Node(R31 + 24).0), Node(R31 + 24).0)
+    which merges make the stack + 24 point to itself
+     */
+
+    // R31 + 32 points to R31 + 24, later set to point to heap but it should point to both (
+    assert(dsg.adjust(stack32.getPointee).equals(stack24))
+    assert(stack24.node.get.collapsed) // 00000497 collapses stack24 concatenation is currently unhandled, any objects referenced in an unhandled operation are collapsed
+    assert(dsg.adjust(stack24.getPointee).equals(stack24)) // 00000466, R31 + 32 and R31 + 24 pointees are merged
+
+    // __stack_chk_guard's pointee is also pointed to by stack40
+    assert(dsg.find(dsg.adjust(stack40.getPointee)).equals(dsg.find(dsg.adjust(dsg.find(dsg.adjust(dsg.globalMapping(AddressRange(69600, 69600)).node.cells(0).getPointee)).getPointee))))
+
+  }
+  */
+
+  // this function asserts universal properties about global objects in Jumptable2  example
+  def assertJumptable2Globals(dsg: Graph): Unit = {
+    // global mappings
+
+    // jump_table relocation
+    assert(dsg.adjust(dsg.globalMapping(AddressRange(69624, 69624 + 8)).node.cells(0).getPointee).equals(dsg.find(dsg.globalMapping(AddressRange(69656, 69656 + 24)).node.cells(0))))
+    // add_two relocation
+    assert(dsg.adjust(dsg.globalMapping(AddressRange(69656, 69656 + 24)).node.cells(0).getPointee).equals(dsg.find(dsg.globalMapping(AddressRange(1940, 1940 + 36)).node.cells(0))))
+    // add_six relocation
+    assert(dsg.adjust(dsg.globalMapping(AddressRange(69656, 69656 + 24)).node.cells(8).getPointee).equals(dsg.find(dsg.globalMapping(AddressRange(1976, 1976 + 36)).node.cells(0))))
+    // sub_seven relocation
+    assert(dsg.adjust(dsg.globalMapping(AddressRange(69656, 69656 + 24)).node.cells(16).getPointee).equals(dsg.find(dsg.globalMapping(AddressRange(2012, 2012 + 36)).node.cells(0))))
+    // main relocation
+    assert(dsg.adjust(dsg.globalMapping(AddressRange(69608, 69608 + 8)).node.cells(0).getPointee).equals(dsg.find(dsg.globalMapping(AddressRange(2048, 2048 + 76)).node.cells(0))))
+    // x relocation
+    assert(dsg.adjust(dsg.globalMapping(AddressRange(69592, 69592 + 8)).node.cells(0).getPointee).equals(dsg.find(dsg.globalMapping(AddressRange(69648, 69648 + 4)).node.cells(0))))
+  }
+
+  test("local jumptable2 callees") {
+    val results = runTest("src/test/indirect_calls/jumptable2/gcc_pic/jumptable2")
+
+    val program = results.ir.program
+    // test that all three callees have the same local graph
+    val callees = Set("sub_seven", "add_two", "add_six")
+    val procs = program.nameToProcedure
+
+    callees.foreach { callee =>
+      val dsg = results.analysis.get.localDSA(procs(callee))
+      assert(dsg.stackMapping.isEmpty) // stack is not used in either callee
+      assertJumptable2Globals(dsg) // globals should be the same everywhere unused in callees
+      // x should point to a collapsed object, in all 3 functions
+      // all three load value of x
+      // the analysis doesn't know if x is a pointer or not therefore assumes it is for soundness
+      // arbitrary pointer is used in arithmetic causing collapse
+      assert(dsg.adjust(dsg.find(dsg.globalMapping(AddressRange(69648, 69648 + 4)).node.cells(0)).getPointee).node.get.collapsed)
+    }
+  }
+
+  test("local jumptable2 main") {
+    val results = runTest("src/test/indirect_calls/jumptable2/gcc_pic/jumptable2")
+
+    val program = results.ir.program
+    val dsg = results.analysis.get.localDSA(program.mainProcedure)
+    val stack0 = dsg.find(dsg.stackMapping(0).cells(0))
+    val stack8 = dsg.find(dsg.stackMapping(8).cells(0))
+    val stack16 = dsg.find(dsg.stackMapping(16).cells(0))
+    val stack28 = dsg.find(dsg.stackMapping(28).cells(0))
+    assert(dsg.adjust(stack0.getPointee).equals(dsg.adjust(dsg.formals(R29))))
+    assert(dsg.adjust(stack8.getPointee).equals(dsg.adjust(dsg.formals(R30))))
+    assert(dsg.adjust(stack16.getPointee).equals(dsg.adjust(dsg.formals(R1)))) // input args
+    assert(dsg.adjust(stack28.getPointee).equals(dsg.adjust(dsg.formals(R0)))) // input args
+
+    // initial global mappings
+    assertJumptable2Globals(dsg)
+
+    // x should not be collapsed in the main function's local graph
+    assert(!dsg.find(dsg.globalMapping(AddressRange(69648, 69648 + 4)).node.cells(0)).getPointee.node.collapsed)
+  }
+
+  test("unsafe pointer arithmetic") {
+    val results = runTest("src/test/dsa/unsafe_pointer_arithmetic/unsafe_pointer_arithmetic")
+
+    val program = results.ir.program
+    val dsg = results.analysis.get.localDSA(program.mainProcedure)
+
+    // stackX is the pointee of stack object at position X instead of the stack object itself
+    val stack0 = dsg.adjust(dsg.find(dsg.stackMapping(0).cells(0)).getPointee)
+    val stack8 = dsg.adjust(dsg.find(dsg.stackMapping(8).cells(0)).getPointee)
+    val stack24 = dsg.adjust(dsg.find(dsg.stackMapping(24).cells(0)).getPointee)
+    val stack32 = dsg.adjust(dsg.find(dsg.stackMapping(32).cells(0)).getPointee)
+    val stack40 = dsg.adjust(dsg.find(dsg.stackMapping(40).cells(0)).getPointee)
+    val stack48 = dsg.adjust(dsg.find(dsg.stackMapping(48).cells(0)).getPointee)
+    val stack56 = dsg.adjust(dsg.find(dsg.stackMapping(56).cells(0)).getPointee)
+
+    assert(stack0.equals(dsg.adjust(dsg.formals(R29))))
+    assert(stack8.equals(dsg.adjust(dsg.formals(R30))))
+
+    // stack24 and stack32 should point to the beginning of first Malloc (size 20)
+    assert(stack24.equals(stack32))
+    assert(stack24.offset == 0)
+    assert(stack24.node.get.allocationRegions.size == 1)
+    assert(stack24.node.get.allocationRegions.head.asInstanceOf[HeapLocation].size == 20)
+
+    // stack24 and stack40 should be pointing to the same cell at different internal offsets
+    val unadjustedStack24Pointee = dsg.find(dsg.stackMapping(24).cells(0)).getPointee
+    val unadjustedStack40Pointee = dsg.find(dsg.stackMapping(40).cells(0)).getPointee
+    assert(unadjustedStack24Pointee.cell.equals(unadjustedStack40Pointee.cell))
+    assert(unadjustedStack40Pointee.internalOffset == 1) // result of unsafe pointer arithmetic
+    assert(unadjustedStack24Pointee.internalOffset == 0)
+    assert(unadjustedStack24Pointee.offset == 0)
+
+    // stack48 points to second malloc (size 8)
+    assert(stack48.node.get.allocationRegions.size == 1)
+    assert(stack48.node.get.allocationRegions.head.asInstanceOf[HeapLocation].size == 8)
+
+    // stack 48 points to a malloc address which point to the pointee of stack40 and stack56
+    assert(dsg.adjust(stack48.getPointee).equals(stack40))
+    assert(dsg.adjust(stack48.getPointee).equals(stack56))
+  }
+
+  test("interproc pointer arithmetic main") {
+    val results = runTest("src/test/dsa/interproc_pointer_arithmetic/interproc_pointer_arithmetic")
+    val program = results.ir.program
+    val dsg = results.analysis.get.localDSA(program.mainProcedure)
+    val stack0 = dsg.adjust(dsg.find(dsg.stackMapping(0).cells(0)).getPointee)
+    val stack8 = dsg.adjust(dsg.find(dsg.stackMapping(8).cells(0)).getPointee)
+    val stack24 = dsg.adjust(dsg.find(dsg.stackMapping(24).cells(0)).getPointee)
+    val stack32 = dsg.adjust(dsg.find(dsg.stackMapping(32).cells(0)).getPointee)
+    val stack40 = dsg.adjust(dsg.find(dsg.stackMapping(40).cells(0)).getPointee)
+
+    assert(stack0.equals(dsg.adjust(dsg.formals(R29))))
+    assert(stack8.equals(dsg.adjust(dsg.formals(R30))))
+
+    // stack24 and 32 point to different offsets of the same node
+    assert(stack24.node.get.equals(stack32.node.get))
+    assert(stack24.offset == 0)
+    assert(stack32.offset == 16)
+
+    // stack40 points to a different offset of stack24's node but the analysis can't determine that in the local phase
+    assert(stack40.pointee.isDefined)
+    assert(!stack40.node.get.equals(stack24.node.get))
+  }
+
+  test("interproc pointer arithmetic callee") {
+    val results = runTest("src/test/dsa/interproc_pointer_arithmetic/interproc_pointer_arithmetic")
+    val program = results.ir.program
+    val dsg = results.analysis.get.localDSA(program.nameToProcedure("callee"))
+    val stack8 = dsg.adjust(dsg.find(dsg.stackMapping(8).cells(0)).getPointee)
+    val stack24 = dsg.adjust(dsg.find(dsg.stackMapping(24).cells(0)).getPointee)
+
+    // stack8 points to the formal argument object
+    assert(stack8.equals(dsg.adjust(dsg.formals(R0))))
+    assert(stack8.offset == 0)
+    // stack 24 points to the formal argument object at offset 16, instead
+    assert(stack24.equals(dsg.adjust(dsg.formals(R0)).node.get.cells(16)))
+  }
+
+
+  test("internal merge") {
+    // this is an internal merge (two cells of the same node overlap and are merged together)
+    val mem = SharedMemory("mem", 64, 8)
+    val locAssign1 = LocalAssign(R6, BinaryExpr(BVADD, R0, BitVecLiteral(4, 64)), Some("00001"))
+    val locAssign2 = LocalAssign(R7, BinaryExpr(BVADD, R0, BitVecLiteral(5, 64)), Some("00002"))
+    val program = prog(
+      proc("main",
+        block("operations",
+          locAssign1, // R6 = R0 + 4
+          locAssign2, // R7 = R0 + 5
+          MemoryStore(mem, R7, R1, Endian.BigEndian, 64, Some("00003")), // *R7 = R1, (*R6 + 1) = R1
+          MemoryStore(mem, R6, R2, Endian.BigEndian, 64, Some("00004")), // *R6 = R2
+          ret
+        )
+      )
+    )
+
+    val results = runAnalysis(program)
+
+    val dsg: Graph = results.localDSA(program.mainProcedure)
+
+    // R6 and R7 address the same cell (overlapping cells in the same node that are merged)
+    assert(dsg.find(dsg.varToCell(locAssign1)(R6)).cell.equals(dsg.find(dsg.varToCell(locAssign2)(R7)).cell))
+
+    // outgoing edges of R6 and R7 are unified since the cells are merged
+    // object of formals R1 and R2 are written to overlapping fields of the same node (R6, R7); causing them to be merged together
+    assert(dsg.adjust(dsg.formals(R1)).equals(dsg.adjust(dsg.formals(R2))))
+    // however, they address different internal offets in those cells
+    assert(dsg.find(dsg.varToCell(locAssign1)(R6)).internalOffset == 0)
+    assert(dsg.find(dsg.varToCell(locAssign2)(R7)).internalOffset == 1)
+
+    // Since R6 and R7 are pointing to the same cell (R1 and R2)
+    // R6 (or R7)'s pointee should be the same as R1 and R2
+    assert(dsg.adjust(dsg.varToCell(locAssign1)(R6)).pointee.isDefined)
+    assert(dsg.adjust(dsg.adjust(dsg.varToCell(locAssign1)(R6)).getPointee).equals(dsg.adjust(dsg.formals(R1))))
+  }
+
+  test("offsetting from middle of cell to a new cell") {
+    val mem = SharedMemory("mem", 64, 8)
+    val locAssign1 = LocalAssign(R6, BinaryExpr(BVADD, R0, BitVecLiteral(4, 64)), Some("00001"))
+    val locAssign2 = LocalAssign(R7, BinaryExpr(BVADD, R0, BitVecLiteral(5, 64)), Some("00002"))
+    val locAssign3 = LocalAssign(R5, BinaryExpr(BVADD, R7,  BitVecLiteral(8, 64)), Some("00005"))
+
+    val program = prog(
+      proc("main",
+        block("operations",
+          locAssign1, // R6 = R0 + 4
+          locAssign2, // R7 = R0 + 5
+          MemoryStore(mem, R7, R1, Endian.BigEndian, 64, Some("00003")),
+          MemoryStore(mem, R6, R2, Endian.BigEndian, 64, Some("00004")),
+          locAssign3, // R5 = R7 + 8
+          ret
+        )
+      )
+    )
+
+    val results = runAnalysis(program)
+    val dsg: Graph = results.localDSA(program.mainProcedure)
+    // check that R5 points to separate cell at offset 13
+    assert(dsg.find(dsg.varToCell(locAssign3)(R5)).offset == 13)
+  }
+
+  test("offsetting from middle of cell to the same cell") {
+    // similar to above except instead of creating new cell the last assign
+    // points R5's cell at an internal offset of 8
+    val mem = SharedMemory("mem", 64, 8)
+    val locAssign1 = LocalAssign(R6, BinaryExpr(BVADD, R0, BitVecLiteral(4, 64)), Some("00001"))
+    val locAssign2 = LocalAssign(R7, BinaryExpr(BVADD, R0, BitVecLiteral(5, 64)), Some("00002"))
+    val locAssign3 = LocalAssign(R5, BinaryExpr(BVADD, R7, BitVecLiteral(7, 64)), Some("00005"))
+
+    val program = prog(
+      proc("main",
+        block("operations",
+          locAssign1,
+          locAssign2,
+          MemoryStore(mem, R7, R1, Endian.BigEndian, 64, Some("00003")),
+          MemoryStore(mem,  R6, R2, Endian.BigEndian, 64, Some("00004")),
+          locAssign3,
+          ret
+        )
+      )
+    )
+
+    val results = runAnalysis(program)
+    val dsg: Graph = results.localDSA(program.mainProcedure)
+    assert(dsg.find(dsg.formals(R1)).equals(dsg.find(dsg.formals(R2))))
+    assert(dsg.find(dsg.varToCell(locAssign1)(R6)).cell.equals(dsg.find(dsg.varToCell(locAssign2)(R7)).cell))
+    assert(dsg.find(dsg.varToCell(locAssign1)(R6)).cell.equals(dsg.find(dsg.varToCell(locAssign3)(R5)).cell))
+    assert(dsg.find(dsg.varToCell(locAssign1)(R6)).internalOffset == 0)
+    assert(dsg.find(dsg.varToCell(locAssign2)(R7)).internalOffset == 1)
+    assert(dsg.find(dsg.varToCell(locAssign3)(R5)).internalOffset == 8)
+    assert(dsg.find(dsg.varToCell(locAssign1)(R6)).cell.pointee.isDefined)
+    assert(dsg.find(dsg.find(dsg.varToCell(locAssign1)(R6)).cell.getPointee).equals(dsg.find(dsg.formals(R1))))
+  }
+
+  test("internal offset transfer") {
+    // this is a test to check assignments transfer internal offset of slices.
+    val mem = SharedMemory("mem", 64, 8)
+    val locAssign1 = LocalAssign(R6, BinaryExpr(BVADD, R0, BitVecLiteral(4, 64)), Some("00001"))
+    val locAssign2 = LocalAssign(R7, BinaryExpr(BVADD, R0, BitVecLiteral(5, 64)), Some("00002"))
+    val locAssign3 = LocalAssign(R5, R7, Some("00005"))
+
+    val program = prog(
+      proc("main",
+        block("operations",
+          //          Assign(R0, MemoryLoad(mem, R0, BigEndian, 0), Some("00000")),
+          locAssign1,
+          locAssign2,
+          MemoryStore(mem, R7, R1, Endian.BigEndian, 64, Some("00003")),
+          MemoryStore(mem, R6, R2, Endian.BigEndian, 64, Some("00004")),
+          locAssign3,
+          ret
+        )
+      )
+    )
+
+    val results = runAnalysis(program)
+
+    val dsg: Graph = results.localDSA(program.mainProcedure)
+    assert(dsg.find(dsg.varToCell(locAssign2)(R7)).equals(dsg.find(dsg.varToCell(locAssign3)(R5))))
+  }
+
+  // bottom up tests
+  ignore("bottom up jumptable2 callees") {
+    // this is the same as local graphs
+    // nothing should be changed
+    // TODO count point-to relations and ensure no more constraints are added in this phase
+    val results = runTest("src/test/indirect_calls/jumptable2/gcc_pic/jumptable2")
+
+    val program = results.ir.program
+    // test that all three callees have the same local graph
+    val callees = Set("sub_seven", "add_two", "add_six")
+    val procs = program.nameToProcedure
+    callees.foreach { callee =>
+      val dsg = results.analysis.get.bottomUpDSA(procs(callee))
+      assert(dsg.stackMapping.isEmpty) // stack is not used in either callee
+      assertJumptable2Globals(dsg) // globals should be the same everywhere unused in callees
+      // x should point to a collapsed object, in all 3 functions
+      // all three load value of x
+      // the analysis doesn't know if x is a pointer or not therefore assumes it is for soundness
+      // arbitrary pointer is used in arithmetic causing collapse
+      assert(dsg.adjust(dsg.find(dsg.globalMapping(AddressRange(69648, 69648 + 4)).node.cells(0)).getPointee).node.get.collapsed)
+    }
+  }
+
+  test("bottom up jumptable2 main") {
+    val results = runTest("src/test/indirect_calls/jumptable2/gcc_pic/jumptable2")
+    val program = results.ir.program
+    val dsg = results.analysis.get.bottomUpDSA(program.mainProcedure)
+
+    val framePointer = dsg.find(dsg.stackMapping(0).cells(0))
+    val stack8 = dsg.find(dsg.stackMapping(8).cells(0))
+    val stack16 = dsg.find(dsg.stackMapping(16).cells(0))
+    val stack28 = dsg.find(dsg.stackMapping(28).cells(0))
+    assert(dsg.adjust(framePointer.getPointee).equals(dsg.adjust(dsg.formals(R29))))
+    assert(dsg.adjust(stack8.getPointee).equals(dsg.adjust(dsg.formals(R30))))
+    assert(dsg.adjust(stack16.getPointee).equals(dsg.adjust(dsg.formals(R1))))
+    assert(dsg.adjust(stack28.getPointee).equals(dsg.adjust(dsg.formals(R0))))
+
+    // initial global mappings
+    assertJumptable2Globals(dsg)
+
+    // bottom-up x now should be collapsed since it was collapsed in callees
+    assert(dsg.find(dsg.globalMapping(AddressRange(69648, 69648 + 4)).node.cells(0)).getPointee.node.collapsed)
+  }
+
+  ignore("bottom up interproc pointer arithmetic callee") {
+    // same as interproc pointer arithmetic callee's local graph (no changes should have been made)
+    val results = runTest("src/test/dsa/interproc_pointer_arithmetic/interproc_pointer_arithmetic")
+    val program = results.ir.program
+    val dsg = results.analysis.get.bottomUpDSA(program.nameToProcedure("callee"))
+    val stack8 = dsg.adjust(dsg.find(dsg.stackMapping(8).cells(0)).getPointee)
+    val stack24 = dsg.adjust(dsg.find(dsg.stackMapping(24).cells(0)).getPointee)
+
+    assert(stack8.equals(dsg.adjust(dsg.formals(R0))))
+    assert(stack8.offset == 0)
+    assert(stack24.equals(dsg.adjust(dsg.formals(R0)).node.get.cells(16)))
+  }
+
+  test("bottom up interproc pointer arithmetic main") {
+    val results = runTest("src/test/dsa/interproc_pointer_arithmetic/interproc_pointer_arithmetic")
+    val program = results.ir.program
+    val dsg = results.analysis.get.bottomUpDSA(program.mainProcedure)
+
+    val stack0 = dsg.adjust(dsg.find(dsg.stackMapping(0).cells(0)).getPointee)
+    val stack8 = dsg.adjust(dsg.find(dsg.stackMapping(8).cells(0)).getPointee)
+    val stack24 = dsg.adjust(dsg.find(dsg.stackMapping(24).cells(0)).getPointee)
+    val stack32 = dsg.adjust(dsg.find(dsg.stackMapping(32).cells(0)).getPointee)
+    val stack40 = dsg.adjust(dsg.find(dsg.stackMapping(40).cells(0)).getPointee)
+
+    // same as the local graph with the difference that stack40 points to cell at
+    // a different of the same node as pointees of stack32 and stack24
+    assert(stack0.equals(dsg.adjust(dsg.formals(R29))))
+    assert(stack8.equals(dsg.adjust(dsg.formals(R30))))
+    assert(stack24.node.get.equals(stack32.node.get))
+    assert(stack24.offset == 0)
+    assert(stack32.offset == 16)
+    assert(stack40.pointee.isDefined)
+    assert(stack40.node.get.equals(stack24.node.get))
+    assert(stack40.offset == 32)
+    assert(dsg.find(dsg.stackMapping(40).cells(0)).getPointee.internalOffset == 0)
+    assert(dsg.find(dsg.stackMapping(32).cells(0)).getPointee.internalOffset == 0)
+    assert(dsg.find(dsg.stackMapping(24).cells(0)).getPointee.internalOffset == 0)
+  }
+
+  // top down tests
+  ignore("top down jumptable2 main") {
+    // no changes should be made from previous phase
+    val results = runTest("src/test/indirect_calls/jumptable2/gcc_pic/jumptable2")
+    val program = results.ir.program
+    val dsg = results.analysis.get.topDownDSA(program.mainProcedure)
+//    assert(dsg.pointTo.size == 13) // 13
+
+    val framePointer = dsg.find(dsg.stackMapping(0).cells(0))
+    val stack8 = dsg.find(dsg.stackMapping(8).cells(0))
+    val stack16 = dsg.find(dsg.stackMapping(16).cells(0))
+    val stack28 = dsg.find(dsg.stackMapping(28).cells(0))
+    assert(dsg.adjust(framePointer.getPointee).equals(dsg.adjust(dsg.formals(R29))))
+    assert(dsg.adjust(stack8.getPointee).equals(dsg.adjust(dsg.formals(R30))))
+    assert(dsg.adjust(stack16.getPointee).equals(dsg.adjust(dsg.formals(R1))))
+    assert(dsg.adjust(stack28.getPointee).equals(dsg.adjust(dsg.formals(R0))))
+    assertJumptable2Globals(dsg)
+
+    // bottom-up
+    assert(dsg.find(dsg.globalMapping(AddressRange(69648, 69648 + 4)).node.cells(0)).getPointee.node.collapsed)
+
+  }
+
+  ignore("top down jumptable2 callees") {
+    val results = runTest("src/test/indirect_calls/jumptable2/gcc_pic/jumptable2")
+
+    val program = results.ir.program
+    // test that all three callees have the same local graph
+    val callees = Set("sub_seven", "add_two", "add_six")
+    val procs = program.nameToProcedure
+    callees.foreach { callee =>
+      val dsg = results.analysis.get.topDownDSA(procs(callee))
+      assert(dsg.stackMapping.isEmpty) // stack is not used in either callee
+      assertJumptable2Globals(dsg) // globals should be the same everywhere unused in callees
+      // x should point to a collapsed object, in all 3 functions
+      // all three load value of x
+      // the analysis doesn't know if x is a pointer or not therefore assumes it is for soundness
+      // arbitrary pointer is used in arithmetic causing collapse
+      assert(dsg.adjust(dsg.find(dsg.globalMapping(AddressRange(69648, 69652)).node.cells(0)).getPointee).node.get.collapsed)
+    }
+  }
+
+  test("top down interproc pointer arithmetic callee") {
+    val results = runTest("src/test/dsa/interproc_pointer_arithmetic/interproc_pointer_arithmetic")
+    val program = results.ir.program
+    val dsg = results.analysis.get.topDownDSA(program.nameToProcedure("callee"))
+
+    val stack8 = dsg.adjust(dsg.find(dsg.stackMapping(8).cells(0)).getPointee)
+    val stack24 = dsg.adjust(dsg.find(dsg.stackMapping(24).cells(0)).getPointee)
+
+    // callee should now have different offsets due to formal and actual input parameters being unified
+    assert(stack8.equals(dsg.adjust(dsg.formals(R0))))
+    assert(stack8.offset == 16)
+    assert(stack24.equals(dsg.adjust(dsg.formals(R0)).node.get.cells(32)))
+  }
+
+  // top-down phase should be the same as bottom-up phase
+  ignore("top down interproc pointer arithmetic main") {
+    val results = runTest("src/test/dsa/interproc_pointer_arithmetic/interproc_pointer_arithmetic")
+    val program = results.ir.program
+    val dsg = results.analysis.get.topDownDSA(program.mainProcedure)
+
+    val stack0 = dsg.adjust(dsg.find(dsg.stackMapping(0).cells(0)).getPointee)
+    val stack8 = dsg.adjust(dsg.find(dsg.stackMapping(8).cells(0)).getPointee)
+    val stack24 = dsg.adjust(dsg.find(dsg.stackMapping(24).cells(0)).getPointee)
+    val stack32 = dsg.adjust(dsg.find(dsg.stackMapping(32).cells(0)).getPointee)
+    val stack40 = dsg.adjust(dsg.find(dsg.stackMapping(40).cells(0)).getPointee)
+
+    assert(stack0.equals(dsg.adjust(dsg.formals(R29))))
+    assert(stack8.equals(dsg.adjust(dsg.formals(R30))))
+    assert(stack24.node.get.equals(stack32.node.get))
+    assert(stack24.offset == 0)
+    assert(stack32.offset == 16)
+    assert(stack40.pointee.isDefined)
+    assert(stack40.node.get.equals(stack24.node.get))
+    assert(stack40.offset == 32)
+    assert(dsg.find(dsg.stackMapping(40).cells(0)).getPointee.internalOffset == 0)
+    assert(dsg.find(dsg.stackMapping(32).cells(0)).getPointee.internalOffset == 0)
+    assert(dsg.find(dsg.stackMapping(24).cells(0)).getPointee.internalOffset == 0)
+  }
+
+}
diff --git a/src/test/scala/IrreducibleLoop.scala b/src/test/scala/IrreducibleLoop.scala
index 7711eadff..e57f90e42 100644
--- a/src/test/scala/IrreducibleLoop.scala
+++ b/src/test/scala/IrreducibleLoop.scala
@@ -22,7 +22,7 @@ class IrreducibleLoop extends AnyFunSuite {
 
   def load(conf: ILLoadingConfig) : Program = {
     val bapProgram = IRLoading.loadBAP(conf.inputFile)
-    val (_, _, _, _, mainAddress) = IRLoading.loadReadELF(conf.relfFile, conf)
+    val (_, _, _, _, _, mainAddress) = IRLoading.loadReadELF(conf.relfFile, conf)
     val IRTranslator = BAPToIR(bapProgram, mainAddress)
     val IRProgram = IRTranslator.translate
     IRProgram
diff --git a/src/test/scala/LiveVarsAnalysisTests.scala b/src/test/scala/LiveVarsAnalysisTests.scala
index 762fd395b..bd7a5ed8e 100644
--- a/src/test/scala/LiveVarsAnalysisTests.scala
+++ b/src/test/scala/LiveVarsAnalysisTests.scala
@@ -1,6 +1,6 @@
 import analysis.{InterLiveVarsAnalysis, TwoElementTop}
 import ir.dsl.*
-import ir.{BitVecLiteral, BitVecType, dsl, Assign, LocalVar, Program, Register, Statement, Variable, transforms, cilvisitor, Procedure}
+import ir.{BitVecLiteral, BitVecType, dsl, LocalAssign, LocalVar, Program, Register, Statement, Variable, transforms, cilvisitor, Procedure}
 import util.{Logger, LogLevel}
 import org.scalatest.funsuite.AnyFunSuite
 import test_util.BASILTest
@@ -30,10 +30,10 @@ class LiveVarsAnalysisTests extends AnyFunSuite, BASILTest {
 
   def differentCalleesBothLive(): Unit = {
     val constant1 = bv64(1)
-    val r0ConstantAssign = Assign(R0, constant1, Some("00001"))
-    val r1ConstantAssign = Assign(R1, constant1, Some("00002"))
-    val r2r0Assign = Assign(R2, R0, Some("00003"))
-    val r2r1Assign = Assign(R2, R1, Some("00004"))
+    val r0ConstantAssign = LocalAssign(R0, constant1, Some("00001"))
+    val r1ConstantAssign = LocalAssign(R1, constant1, Some("00002"))
+    val r2r0Assign = LocalAssign(R2, R0, Some("00003"))
+    val r2r1Assign = LocalAssign(R2, R1, Some("00004"))
 
     val program: Program = prog(
       proc("main",
@@ -70,11 +70,11 @@ class LiveVarsAnalysisTests extends AnyFunSuite, BASILTest {
 
   def differentCalleesOneAlive(): Unit = {
     val constant1 = bv64(1)
-    val r0ConstantAssign = Assign(R0, constant1, Some("00001"))
-    val r1ConstantAssign = Assign(R1, constant1, Some("00002"))
-    val r2r0Assign = Assign(R2, R0, Some("00003"))
-    val r2r1Assign = Assign(R2, R1, Some("00004"))
-    val r1Reassign = Assign(R1, BitVecLiteral(2, 64), Some("00005"))
+    val r0ConstantAssign = LocalAssign(R0, constant1, Some("00001"))
+    val r1ConstantAssign = LocalAssign(R1, constant1, Some("00002"))
+    val r2r0Assign = LocalAssign(R2, R0, Some("00003"))
+    val r2r1Assign = LocalAssign(R2, R1, Some("00004"))
+    val r1Reassign = LocalAssign(R1, BitVecLiteral(2, 64), Some("00005"))
 
     val program: Program = prog(
       proc("main",
@@ -108,9 +108,9 @@ class LiveVarsAnalysisTests extends AnyFunSuite, BASILTest {
 
   def twoCallers(): Unit = {
     val constant1 = bv64(1)
-    val r0ConstantAssign = Assign(R0, constant1, Some("00001"))
-    val r1Assign = Assign(R0, R1, Some("00002"))
-    val r2Assign = Assign(R0, R2, Some("00003"))
+    val r0ConstantAssign = LocalAssign(R0, constant1, Some("00001"))
+    val r1Assign = LocalAssign(R0, R1, Some("00002"))
+    val r2Assign = LocalAssign(R0, R2, Some("00003"))
 
     val program = prog(
       proc("main",
@@ -129,7 +129,7 @@ class LiveVarsAnalysisTests extends AnyFunSuite, BASILTest {
       createSimpleProc("callee3", Seq(r2Assign)),
       proc("wrapper1",
         block("wrapper1_first_call",
-          Assign(R1, constant1),
+          LocalAssign(R1, constant1),
           directCall("callee"),
           goto("wrapper1_second_call")
         ),
@@ -140,7 +140,7 @@ class LiveVarsAnalysisTests extends AnyFunSuite, BASILTest {
       ),
       proc("wrapper2",
         block("wrapper2_first_call",
-          Assign(R2, constant1),
+          LocalAssign(R2, constant1),
           directCall("callee"), goto("wrapper2_second_call")
         ),
         block("wrapper2_second_call",
@@ -167,11 +167,11 @@ class LiveVarsAnalysisTests extends AnyFunSuite, BASILTest {
           directCall("killer"), goto("aftercall")
         ),
         block("aftercall",
-          Assign(R0, R1),
+          LocalAssign(R0, R1),
           ret
         )
       ),
-      createSimpleProc("killer", Seq(Assign(R1, bv64(1))))
+      createSimpleProc("killer", Seq(LocalAssign(R1, bv64(1))))
     )
 
     cilvisitor.visit_prog(transforms.ReplaceReturns(), program)
@@ -186,8 +186,8 @@ class LiveVarsAnalysisTests extends AnyFunSuite, BASILTest {
   }
 
   def simpleBranch(): Unit = {
-    val r1Assign = Assign(R0, R1, Some("00001"))
-    val r2Assign = Assign(R0, R2, Some("00002"))
+    val r1Assign = LocalAssign(R0, R1, Some("00001"))
+    val r2Assign = LocalAssign(R0, R2, Some("00002"))
 
     val program : Program = prog(
       proc(
@@ -228,11 +228,11 @@ class LiveVarsAnalysisTests extends AnyFunSuite, BASILTest {
       proc("main",
         block(
           "lmain",
-          Assign(R0, R1),
+          LocalAssign(R0, R1),
           directCall("main"), goto("return")
         ),
         block("return",
-          Assign(R0, R2),
+          LocalAssign(R0, R2),
           ret
         )
       )
@@ -251,7 +251,7 @@ class LiveVarsAnalysisTests extends AnyFunSuite, BASILTest {
     val program: Program = prog(
       proc("main",
         block("lmain",
-          Assign(R0, R1),
+          LocalAssign(R0, R1),
           goto("recursion", "non-recursion")
         ),
         block(
@@ -259,7 +259,7 @@ class LiveVarsAnalysisTests extends AnyFunSuite, BASILTest {
           directCall("main"), goto("assign")
         ),
         block("assign",
-          Assign(R0, R2),
+          LocalAssign(R0, R2),
           goto("return")
         ),
         block(
diff --git a/src/test/scala/PointsToTest.scala b/src/test/scala/PointsToTest.scala
index acc0a7475..4b267d7e8 100644
--- a/src/test/scala/PointsToTest.scala
+++ b/src/test/scala/PointsToTest.scala
@@ -16,9 +16,10 @@ class PointsToTest extends AnyFunSuite with OneInstancePerTest {
   def runAnalyses(program: Program,
                   externalFunctions: Set[ExternalFunction] = Set.empty,
                   globals: Set[SpecGlobal] = Set.empty,
+                  funcEntries: Set[FuncEntry] = Set.empty,
                   globalOffsets: Map[BigInt, BigInt] = Map.empty): StaticAnalysisContext = {
 
-    val ctx = IRContext(List.empty, externalFunctions, globals, globalOffsets, Specification(Set(), Map(), List(), List(), List(), Set()), program)
+    val ctx = IRContext(List.empty, externalFunctions, globals, funcEntries, globalOffsets, Specification(Set(), Set(), Map(), List(), List(), List(), Set()), program)
     StaticAnalysis.analyse(ctx, StaticAnalysisConfig(), 1)
   }
 
@@ -29,11 +30,11 @@ class PointsToTest extends AnyFunSuite with OneInstancePerTest {
     var program: Program = prog(
       proc("main",
         block("0x0",
-          Assign(R6, R31),
+          LocalAssign(R6, R31),
           goto("0x1")
         ),
         block("0x1",
-          MemoryAssign(mem, BinaryExpr(BVADD, R6, bv64(4)), bv64(10), LittleEndian, 64),
+          MemoryStore(mem, BinaryExpr(BVADD, R6, bv64(4)), bv64(10), LittleEndian, 64),
           goto("returntarget")
         ),
         block("returntarget",
@@ -48,7 +49,7 @@ class PointsToTest extends AnyFunSuite with OneInstancePerTest {
     val results = runAnalyses(program)
     results.mmmResults.pushContext("main")
     assert(results.mmmResults.findStackObject(BigInt(4)).isDefined)
-    assert(results.mmmResults.findStackObject(BigInt(4)).get.start == bv64(4))
+    assert(results.mmmResults.findStackObject(BigInt(4)).get.start == BigInt(4))
     assert(results.mmmResults.findStackObject(BigInt(4)).get.regionIdentifier == "stack_1")
   }
 
@@ -59,8 +60,8 @@ class PointsToTest extends AnyFunSuite with OneInstancePerTest {
     var program: Program = prog(
       proc("main",
         block("0x0",
-          Assign(R1, MemoryLoad(mem, BinaryExpr(BVADD, R31, bv64(6)), LittleEndian, 64)),
-          Assign(R3, MemoryLoad(mem, BinaryExpr(BVADD, R31, bv64(4)), LittleEndian, 64)),
+          MemoryLoad(R1, mem, BinaryExpr(BVADD, R31, bv64(6)), LittleEndian, 64),
+          MemoryLoad(R3, mem, BinaryExpr(BVADD, R31, bv64(4)), LittleEndian, 64),
           goto("0x1")
         ),
         block("0x1",
@@ -81,10 +82,10 @@ class PointsToTest extends AnyFunSuite with OneInstancePerTest {
     assert(results.mmmResults.findStackObject(BigInt(6)).isDefined)
     assert(results.mmmResults.findStackObject(BigInt(10)).isDefined)
 
-    assert(results.mmmResults.findStackObject(BigInt(4)).get.start == bv64(4))
-    assert(results.mmmResults.findStackObject(BigInt(5)).get.start == bv64(4))
-    assert(results.mmmResults.findStackObject(BigInt(6)).get.start == bv64(6))
-    assert(results.mmmResults.findStackObject(BigInt(10)).get.start == bv64(6))
+    assert(results.mmmResults.findStackObject(BigInt(4)).get.start == BigInt(4))
+    assert(results.mmmResults.findStackObject(BigInt(5)).get.start == BigInt(4))
+    assert(results.mmmResults.findStackObject(BigInt(6)).get.start == BigInt(6))
+    assert(results.mmmResults.findStackObject(BigInt(10)).get.start == BigInt(6))
   }
 
 //  /**
@@ -134,8 +135,8 @@ class PointsToTest extends AnyFunSuite with OneInstancePerTest {
     val program: Program = prog(
       proc("main",
         block("0x0",
-          Assign(R0, MemoryLoad(mem, BinaryExpr(BVADD, R31, bv64(6)), LittleEndian, 64)),
-          Assign(R1, BinaryExpr(BVADD, R31, bv64(10))),
+          MemoryLoad(R0, mem, BinaryExpr(BVADD, R31, bv64(6)), LittleEndian, 64),
+          LocalAssign(R1, BinaryExpr(BVADD, R31, bv64(10))),
           goto("0x1")
         ),
         block("0x1",
@@ -147,8 +148,8 @@ class PointsToTest extends AnyFunSuite with OneInstancePerTest {
       ),
       proc("p2",
         block("l_p2",
-          Assign(R3, R0),
-          Assign(R2, MemoryLoad(mem, R1, LittleEndian, 64)),
+          LocalAssign(R3, R0),
+          MemoryLoad(R2, mem, R1, LittleEndian, 64),
           goto("l_p2_1"),
         ),
         block("l_p2_1",
@@ -164,7 +165,7 @@ class PointsToTest extends AnyFunSuite with OneInstancePerTest {
     results.mmmResults.pushContext("main")
     assert(results.mmmResults.findStackObject(BigInt(6)).isDefined)
 
-    assert(results.mmmResults.findStackObject(BigInt(6)).get.start == bv64(6))
+    assert(results.mmmResults.findStackObject(BigInt(6)).get.start == BigInt(6))
 
     /* ------------------------------------------------------------------------- */
 
@@ -172,8 +173,8 @@ class PointsToTest extends AnyFunSuite with OneInstancePerTest {
     assert(results.mmmResults.findSharedStackObject(BigInt(6)).nonEmpty)
     assert(results.mmmResults.findSharedStackObject(BigInt(10)).nonEmpty)
 
-    assert(results.mmmResults.findSharedStackObject(BigInt(6)).head.start == bv64(6))
-    assert(results.mmmResults.findSharedStackObject(BigInt(10)).head.start == bv64(10))
+    assert(results.mmmResults.findSharedStackObject(BigInt(6)).head.start == BigInt(6))
+    assert(results.mmmResults.findSharedStackObject(BigInt(10)).head.start == BigInt(10))
   }
 
   /**
@@ -183,8 +184,8 @@ class PointsToTest extends AnyFunSuite with OneInstancePerTest {
     val program: Program = prog(
       proc("main",
         block("0x0",
-          Assign(R0, MemoryLoad(mem, BinaryExpr(BVADD, R31, bv64(6)), LittleEndian, 64)),
-          Assign(R1, BinaryExpr(BVADD, R31, bv64(10))),
+          MemoryLoad(R0, mem, BinaryExpr(BVADD, R31, bv64(6)), LittleEndian, 64),
+          LocalAssign(R1, BinaryExpr(BVADD, R31, bv64(10))),
           goto("0x1")
         ),
         block("0x1",
@@ -196,8 +197,8 @@ class PointsToTest extends AnyFunSuite with OneInstancePerTest {
       ),
       proc("foo",
         block("l_foo",
-          Assign(R0, MemoryLoad(mem, BinaryExpr(BVADD, R31, bv64(6)), LittleEndian, 64)),
-          Assign(R1, BinaryExpr(BVADD, R31, bv64(10))),
+          MemoryLoad(R0, mem, BinaryExpr(BVADD, R31, bv64(6)), LittleEndian, 64),
+          LocalAssign(R1, BinaryExpr(BVADD, R31, bv64(10))),
           directCall("p2"), goto("l_foo_1")
         ),
         block("l_foo_1",
@@ -206,8 +207,8 @@ class PointsToTest extends AnyFunSuite with OneInstancePerTest {
       ),
       proc("p2",
         block("l_p2",
-          Assign(R3, R0),
-          Assign(R2, MemoryLoad(mem, R1, LittleEndian, 64)),
+          LocalAssign(R3, R0),
+          MemoryLoad(R2, mem, R1, LittleEndian, 64),
           goto("l_p2_1"),
         ),
         block("l_p2_1",
@@ -223,7 +224,7 @@ class PointsToTest extends AnyFunSuite with OneInstancePerTest {
     results.mmmResults.pushContext("main")
     assert(results.mmmResults.findStackObject(BigInt(6)).isDefined)
 
-    assert(results.mmmResults.findStackObject(BigInt(6)).get.start == bv64(6))
+    assert(results.mmmResults.findStackObject(BigInt(6)).get.start == BigInt(6))
 
     /* ------------------------------------------------------------------------- */
 
diff --git a/src/test/scala/SystemTests.scala b/src/test/scala/SystemTests.scala
index 6be01a68e..88d3779e2 100644
--- a/src/test/scala/SystemTests.scala
+++ b/src/test/scala/SystemTests.scala
@@ -176,8 +176,8 @@ trait SystemTests extends AnyFunSuite, BASILTest {
 }
 
 class SystemTestsBAP extends SystemTests {
-  runTests("correct", TestConfig(useBAPFrontend = true, expectVerify = true, logResults = true))
-  runTests("incorrect", TestConfig(useBAPFrontend = true, expectVerify = false, logResults = true))
+  runTests("correct", TestConfig(useBAPFrontend = true, expectVerify = true, checkExpected = true, logResults = true))
+  runTests("incorrect", TestConfig(useBAPFrontend = true, expectVerify = false, checkExpected = true, logResults = true))
   test("summary-BAP") {
     summary("testresult-BAP")
   }
diff --git a/src/test/scala/TaintAnalysisTests.scala b/src/test/scala/TaintAnalysisTests.scala
index 35e7da1ab..2ffeb3215 100644
--- a/src/test/scala/TaintAnalysisTests.scala
+++ b/src/test/scala/TaintAnalysisTests.scala
@@ -7,12 +7,12 @@ import test_util.BASILTest
 
 class TaintAnalysisTests extends AnyFunSuite, BASILTest {
   def getTaintAnalysisResults(program: Program, taint: Map[CFGPosition, Set[Taintable]]): Map[CFGPosition, Set[Taintable]] = {
-    val constPropResults = ConstantPropagationSolver(program).analyze()
+    val constPropResults = InterProcConstantPropagation(program).analyze()
     TaintAnalysis(program, Map(), constPropResults, taint).analyze().map { (c, m) => (c, m.map { (v, _) => v }.toSet)}
   }
 
   def getVarDepResults(program: Program, procedure: Procedure): Map[CFGPosition, Map[Taintable, Set[Taintable]]] = {
-    val constPropResults = ConstantPropagationSolver(program).analyze()
+    val constPropResults = InterProcConstantPropagation(program).analyze()
     val variables = registers
     ProcVariableDependencyAnalysis(program, variables, Map(), constPropResults, Map(), procedure).analyze()
   }
@@ -31,7 +31,7 @@ class TaintAnalysisTests extends AnyFunSuite, BASILTest {
         ),
         proc("f",
           block("assign",
-            Assign(R0, bv64(2), None),
+            LocalAssign(R0, bv64(2), None),
             goto("returnBlock"),
           ),
           block("returnBlock",
@@ -65,7 +65,7 @@ class TaintAnalysisTests extends AnyFunSuite, BASILTest {
         ),
         proc("f",
           block("assign",
-            Assign(R0, BinaryExpr(BVADD, R0, R1), None),
+            LocalAssign(R0, BinaryExpr(BVADD, R0, R1), None),
             goto("returnBlock"),
           ),
           block("returnBlock",
@@ -102,11 +102,11 @@ class TaintAnalysisTests extends AnyFunSuite, BASILTest {
             goto("a", "b"),
           ),
           block("a",
-            Assign(R0, R1, None),
+            LocalAssign(R0, R1, None),
             goto("returnBlock"),
           ),
           block("b",
-            Assign(R0, R2, None),
+            LocalAssign(R0, R2, None),
             goto("returnBlock"),
           ),
           block("returnBlock",
@@ -143,12 +143,12 @@ class TaintAnalysisTests extends AnyFunSuite, BASILTest {
             goto("a", "b"),
           ),
           block("a",
-            Assign(R1, R1, None),
+            LocalAssign(R1, R1, None),
             directCall("g"),
             goto("returnBlock"),
           ),
           block("b",
-            Assign(R1, R2, None),
+            LocalAssign(R1, R2, None),
             directCall("g"),
             goto("returnBlock"),
           ),
@@ -158,7 +158,7 @@ class TaintAnalysisTests extends AnyFunSuite, BASILTest {
         ),
         proc("g",
           block("body",
-            Assign(R0, R1, None),
+            LocalAssign(R0, R1, None),
             goto("returnBlock"),
           ),
           block("returnBlock",
@@ -195,11 +195,11 @@ class TaintAnalysisTests extends AnyFunSuite, BASILTest {
             goto("a", "b"),
           ),
           block("a",
-            Assign(R0, BinaryExpr(BVADD, R0, R1), None),
+            LocalAssign(R0, BinaryExpr(BVADD, R0, R1), None),
             goto("branch"),
           ),
           block("b",
-            Assign(R0, R2, None),
+            LocalAssign(R0, R2, None),
             goto("returnBlock"),
           ),
           block("returnBlock",
diff --git a/src/test/scala/ir/CILVisitorTest.scala b/src/test/scala/ir/CILVisitorTest.scala
index f06528cbf..49eae1cb5 100644
--- a/src/test/scala/ir/CILVisitorTest.scala
+++ b/src/test/scala/ir/CILVisitorTest.scala
@@ -40,7 +40,7 @@ class AddGammas extends CILVisitor {
 
   override def vstmt(s: Statement) = {
     s match {
-      case a: Assign => ChangeTo(List(a, Assign(gamma_v(a.lhs), gamma_e(a.rhs))))
+      case a: LocalAssign => ChangeTo(List(a, LocalAssign(gamma_v(a.lhs), gamma_e(a.rhs))))
       case _         => SkipChildren()
     }
 
@@ -82,10 +82,10 @@ class CILVisitorTest extends AnyFunSuite {
     val program: Program = prog(
       proc(
         "main",
-        block("0x0", Assign(getRegister("R6"), getRegister("R31")), goto("0x1")),
+        block("0x0", LocalAssign(getRegister("R6"), getRegister("R31")), goto("0x1")),
         block(
           "0x1",
-          MemoryAssign(mem, BinaryExpr(BVADD, getRegister("R6"), bv64(4)), bv64(10), Endian.LittleEndian, 64),
+          MemoryStore(mem, BinaryExpr(BVADD, getRegister("R6"), bv64(4)), bv64(10), Endian.LittleEndian, 64),
           goto("returntarget")
         ),
         block("returntarget", ret)
@@ -123,10 +123,10 @@ class CILVisitorTest extends AnyFunSuite {
     val program: Program = prog(
       proc(
         "main",
-        block("0x0", Assign(getRegister("R6"), getRegister("R31")), goto("0x1")),
+        block("0x0", LocalAssign(getRegister("R6"), getRegister("R31")), goto("0x1")),
         block(
           "0x1",
-          MemoryAssign(mem, BinaryExpr(BVADD, getRegister("R6"), bv64(4)), bv64(10), Endian.LittleEndian, 64),
+          MemoryStore(mem, BinaryExpr(BVADD, getRegister("R6"), bv64(4)), bv64(10), Endian.LittleEndian, 64),
           goto("returntarget")
         ),
         block("returntarget", ret)
diff --git a/src/test/scala/ir/IRTest.scala b/src/test/scala/ir/IRTest.scala
index a1592f9eb..f156a83c0 100644
--- a/src/test/scala/ir/IRTest.scala
+++ b/src/test/scala/ir/IRTest.scala
@@ -95,12 +95,12 @@ class IRTest extends AnyFunSuite {
     val p = prog(
       proc("main",
         block("l_main",
-          Assign(R0, bv64(10)),
-          Assign(R1, bv64(10)),
+          LocalAssign(R0, bv64(10)),
+          LocalAssign(R1, bv64(10)),
           goto("newblock")
         ),
         block("l_main_1",
-          Assign(R0, bv64(22)),
+          LocalAssign(R0, bv64(22)),
           directCall("p2"),
           goto("returntarget")
         ),
@@ -109,7 +109,7 @@ class IRTest extends AnyFunSuite {
         )
       ),
       proc("p2",
-        block("l_p2", Assign(R0, bv64(10)), goto("l_p2_1")),
+        block("l_p2", LocalAssign(R0, bv64(10)), goto("l_p2_1")),
         block("l_p2_1", ret)
       )
     )
@@ -154,15 +154,15 @@ class IRTest extends AnyFunSuite {
     )
 
     val b2 = block("newblock2",
-      Assign(R0, bv64(22)),
-      Assign(R0, bv64(22)),
-      Assign(R0, bv64(22)),
+      LocalAssign(R0, bv64(22)),
+      LocalAssign(R0, bv64(22)),
+      LocalAssign(R0, bv64(22)),
       goto("lmain2")
     ).resolve(p)
     val b1 = block("newblock1",
-      Assign(R0, bv64(22)),
-      Assign(R0, bv64(22)),
-      Assign(R0, bv64(22)),
+      LocalAssign(R0, bv64(22)),
+      LocalAssign(R0, bv64(22)),
+      LocalAssign(R0, bv64(22)),
       goto("lmain2")
     ).resolve(p)
 
@@ -191,16 +191,16 @@ class IRTest extends AnyFunSuite {
     )
 
     val b1 = block("newblock2",
-      Assign(R0, bv64(22)),
-      Assign(R0, bv64(22)),
-      Assign(R0, bv64(22)),
+      LocalAssign(R0, bv64(22)),
+      LocalAssign(R0, bv64(22)),
+      LocalAssign(R0, bv64(22)),
       directCall("main"),
       unreachable
     ).resolve(p)
     val b2 = block("newblock1",
-      Assign(R0, bv64(22)),
-      Assign(R0, bv64(22)),
-      Assign(R0, bv64(22)),
+      LocalAssign(R0, bv64(22)),
+      LocalAssign(R0, bv64(22)),
+      LocalAssign(R0, bv64(22)),
       ret
     ).resolve(p)
 
@@ -218,7 +218,7 @@ class IRTest extends AnyFunSuite {
 
     assert(called.incomingCalls().isEmpty)
     val b3 = block("newblock3",
-      Assign(R0, bv64(22)),
+      LocalAssign(R0, bv64(22)),
       directCall("called"),
       unreachable
     ).resolve(p)
@@ -254,8 +254,8 @@ class IRTest extends AnyFunSuite {
     val p = prog(
         proc("main",
           block("l_main",
-            Assign(R0, bv64(10)),
-            Assign(R1, bv64(10)),
+            LocalAssign(R0, bv64(10)),
+            LocalAssign(R1, bv64(10)),
             goto("returntarget")
           ),
           block("returntarget",
@@ -285,13 +285,13 @@ class IRTest extends AnyFunSuite {
     val p = prog(
       proc("p1",
         block("b1",
-          Assign(R0, bv64(10)),
+          LocalAssign(R0, bv64(10)),
           ret
         )
       ),
       proc("main",
         block("l_main",
-          Assign(R0, bv64(10)),
+          LocalAssign(R0, bv64(10)),
           directCall("p1"), goto("returntarget")
         ),
         block("returntarget",
diff --git a/src/test/scala/ir/InterpreterTests.scala b/src/test/scala/ir/InterpreterTests.scala
index 874f20991..92f728ee8 100644
--- a/src/test/scala/ir/InterpreterTests.scala
+++ b/src/test/scala/ir/InterpreterTests.scala
@@ -24,7 +24,7 @@ class InterpreterTests extends AnyFunSuite with BeforeAndAfter {
     )
 
     val bapProgram = loadBAP(loading.inputFile)
-    val (symbols, externalFunctions, globals, _, mainAddress) = loadReadELF(loading.relfFile, loading)
+    val (_, externalFunctions, globals, _, _, mainAddress) = loadReadELF(loading.relfFile, loading)
     val IRTranslator = BAPToIR(bapProgram, mainAddress)
     var IRProgram = IRTranslator.translate
     IRProgram = ExternalRemover(externalFunctions.map(e => e.name)).visitProgram(IRProgram)
diff --git a/src/test/scala/ir/SingleCallInvariant.scala b/src/test/scala/ir/SingleCallInvariant.scala
index d8efb6fc2..4e0061424 100644
--- a/src/test/scala/ir/SingleCallInvariant.scala
+++ b/src/test/scala/ir/SingleCallInvariant.scala
@@ -10,13 +10,13 @@ class InvariantTest extends AnyFunSuite {
     var program: Program = prog(
       proc("main",
         block("first_call",
-          Assign(R0, bv64(10)),
-          Assign(R1, bv64(10)),
+          LocalAssign(R0, bv64(10)),
+          LocalAssign(R1, bv64(10)),
           directCall("callee1"),
           ret 
         ),
         block("second_call",
-          Assign(R0, bv64(10)),
+          LocalAssign(R0, bv64(10)),
           directCall("callee2"),
           ret
         ),
@@ -35,14 +35,14 @@ class InvariantTest extends AnyFunSuite {
     var program: Program = prog(
       proc("main",
         block("first_call",
-          Assign(R0, bv64(10)),
+          LocalAssign(R0, bv64(10)),
           directCall("callee2"),
-          Assign(R1, bv64(10)),
+          LocalAssign(R1, bv64(10)),
           directCall("callee1"),
           ret 
         ),
         block("second_call",
-          Assign(R0, bv64(10)),
+          LocalAssign(R0, bv64(10)),
           ret
         ),
         block("returnBlock",
@@ -60,13 +60,13 @@ class InvariantTest extends AnyFunSuite {
     var program: Program = prog(
       proc("main",
         block("first_call",
-          Assign(R0, bv64(10)),
-          Assign(R1, bv64(10)),
+          LocalAssign(R0, bv64(10)),
+          LocalAssign(R1, bv64(10)),
           ret 
         ),
         block("second_call",
           directCall("callee2"),
-          Assign(R0, bv64(10)),
+          LocalAssign(R0, bv64(10)),
           ret
         ),
         block("returnBlock",