diff --git a/backend/remill/include/remill/Arch/Runtime/Intrinsics.h b/backend/remill/include/remill/Arch/Runtime/Intrinsics.h
index 5bb2d8dc..890f5b6a 100644
--- a/backend/remill/include/remill/Arch/Runtime/Intrinsics.h
+++ b/backend/remill/include/remill/Arch/Runtime/Intrinsics.h
@@ -182,71 +182,71 @@ extern "C" {
  */
 
 
-[[gnu::used]] extern Memory *__remill_compare_exchange_memory_8(Memory *, addr_t addr,
-                                                                uint8_t &expected, uint8_t desired);
+[[gnu::used]] extern void __remill_compare_exchange_memory_8(RuntimeManager *, addr_t addr,
+                                                             uint8_t &expected, uint8_t desired);
 
-[[gnu::used]] extern Memory *
-__remill_compare_exchange_memory_16(Memory *, addr_t addr, uint16_t &expected, uint16_t desired);
+[[gnu::used]] extern void __remill_compare_exchange_memory_16(RuntimeManager *, addr_t addr,
+                                                              uint16_t &expected, uint16_t desired);
 
-[[gnu::used]] extern Memory *
-__remill_compare_exchange_memory_32(Memory *, addr_t addr, uint32_t &expected, uint32_t desired);
+[[gnu::used]] extern void __remill_compare_exchange_memory_32(RuntimeManager *, addr_t addr,
+                                                              uint32_t &expected, uint32_t desired);
 
-[[gnu::used]] extern Memory *
-__remill_compare_exchange_memory_64(Memory *, addr_t addr, uint64_t &expected, uint64_t desired);
+[[gnu::used]] extern void __remill_compare_exchange_memory_64(RuntimeManager *, addr_t addr,
+                                                              uint64_t &expected, uint64_t desired);
 
 #if !defined(REMILL_DISABLE_INT128)
-[[gnu::used]] extern Memory *__remill_compare_exchange_memory_128(Memory *, addr_t addr,
-                                                                  uint128_t &expected,
-                                                                  uint128_t &desired);
+[[gnu::used]] extern void __remill_compare_exchange_memory_128(RuntimeManager *, addr_t addr,
+                                                               uint128_t &expected,
+                                                               uint128_t &desired);
 #endif
 
-[[gnu::used]] extern Memory *__remill_fetch_and_add_8(Memory *, addr_t addr, uint8_t &value);
+[[gnu::used]] extern void __remill_fetch_and_add_8(RuntimeManager *, addr_t addr, uint8_t &value);
 
-[[gnu::used]] extern Memory *__remill_fetch_and_add_16(Memory *, addr_t addr, uint16_t &value);
+[[gnu::used]] extern void __remill_fetch_and_add_16(RuntimeManager *, addr_t addr, uint16_t &value);
 
-[[gnu::used]] extern Memory *__remill_fetch_and_add_32(Memory *, addr_t addr, uint32_t &value);
+[[gnu::used]] extern void __remill_fetch_and_add_32(RuntimeManager *, addr_t addr, uint32_t &value);
 
-[[gnu::used]] extern Memory *__remill_fetch_and_add_64(Memory *, addr_t addr, uint64_t &value);
+[[gnu::used]] extern void __remill_fetch_and_add_64(RuntimeManager *, addr_t addr, uint64_t &value);
 
-[[gnu::used]] extern Memory *__remill_fetch_and_sub_8(Memory *, addr_t addr, uint8_t &value);
+[[gnu::used]] extern void __remill_fetch_and_sub_8(RuntimeManager *, addr_t addr, uint8_t &value);
 
-[[gnu::used]] extern Memory *__remill_fetch_and_sub_16(Memory *, addr_t addr, uint16_t &value);
+[[gnu::used]] extern void __remill_fetch_and_sub_16(RuntimeManager *, addr_t addr, uint16_t &value);
 
-[[gnu::used]] extern Memory *__remill_fetch_and_sub_32(Memory *, addr_t addr, uint32_t &value);
+[[gnu::used]] extern void __remill_fetch_and_sub_32(RuntimeManager *, addr_t addr, uint32_t &value);
 
-[[gnu::used]] extern Memory *__remill_fetch_and_sub_64(Memory *, addr_t addr, uint64_t &value);
+[[gnu::used]] extern void __remill_fetch_and_sub_64(RuntimeManager *, addr_t addr, uint64_t &value);
 
-[[gnu::used]] extern Memory *__remill_fetch_and_and_8(Memory *, addr_t addr, uint8_t &value);
+[[gnu::used]] extern void __remill_fetch_and_and_8(RuntimeManager *, addr_t addr, uint8_t &value);
 
-[[gnu::used]] extern Memory *__remill_fetch_and_and_16(Memory *, addr_t addr, uint16_t &value);
+[[gnu::used]] extern void __remill_fetch_and_and_16(RuntimeManager *, addr_t addr, uint16_t &value);
 
-[[gnu::used]] extern Memory *__remill_fetch_and_and_32(Memory *, addr_t addr, uint32_t &value);
+[[gnu::used]] extern void __remill_fetch_and_and_32(RuntimeManager *, addr_t addr, uint32_t &value);
 
-[[gnu::used]] extern Memory *__remill_fetch_and_and_64(Memory *, addr_t addr, uint64_t &value);
+[[gnu::used]] extern void __remill_fetch_and_and_64(RuntimeManager *, addr_t addr, uint64_t &value);
 
-[[gnu::used]] extern Memory *__remill_fetch_and_or_8(Memory *, addr_t addr, uint8_t &value);
+[[gnu::used]] extern void __remill_fetch_and_or_8(RuntimeManager *, addr_t addr, uint8_t &value);
 
-[[gnu::used]] extern Memory *__remill_fetch_and_or_16(Memory *, addr_t addr, uint16_t &value);
+[[gnu::used]] extern void __remill_fetch_and_or_16(RuntimeManager *, addr_t addr, uint16_t &value);
 
-[[gnu::used]] extern Memory *__remill_fetch_and_or_32(Memory *, addr_t addr, uint32_t &value);
+[[gnu::used]] extern void __remill_fetch_and_or_32(RuntimeManager *, addr_t addr, uint32_t &value);
 
-[[gnu::used]] extern Memory *__remill_fetch_and_or_64(Memory *, addr_t addr, uint64_t &value);
+[[gnu::used]] extern void __remill_fetch_and_or_64(RuntimeManager *, addr_t addr, uint64_t &value);
 
-[[gnu::used]] extern Memory *__remill_fetch_and_xor_8(Memory *, addr_t addr, uint8_t &value);
+[[gnu::used]] extern void __remill_fetch_and_xor_8(RuntimeManager *, addr_t addr, uint8_t &value);
 
-[[gnu::used]] extern Memory *__remill_fetch_and_xor_16(Memory *, addr_t addr, uint16_t &value);
+[[gnu::used]] extern void __remill_fetch_and_xor_16(RuntimeManager *, addr_t addr, uint16_t &value);
 
-[[gnu::used]] extern Memory *__remill_fetch_and_xor_32(Memory *, addr_t addr, uint32_t &value);
+[[gnu::used]] extern void __remill_fetch_and_xor_32(RuntimeManager *, addr_t addr, uint32_t &value);
 
-[[gnu::used]] extern Memory *__remill_fetch_and_xor_64(Memory *, addr_t addr, uint64_t &value);
+[[gnu::used]] extern void __remill_fetch_and_xor_64(RuntimeManager *, addr_t addr, uint64_t &value);
 
-[[gnu::used]] extern Memory *__remill_fetch_and_nand_8(Memory *, addr_t addr, uint8_t &value);
+[[gnu::used]] extern void __remill_fetch_and_nand_8(RuntimeManager *, addr_t addr, uint8_t &value);
 
-[[gnu::used]] extern Memory *__remill_fetch_and_nand_16(Memory *, addr_t addr, uint16_t &value);
+[[gnu::used]] extern void __remill_fetch_and_nand_16(RuntimeManager *, addr_t addr, uint16_t &value);
 
-[[gnu::used]] extern Memory *__remill_fetch_and_nand_32(Memory *, addr_t addr, uint32_t &value);
+[[gnu::used]] extern void __remill_fetch_and_nand_32(RuntimeManager *, addr_t addr, uint32_t &value);
 
-[[gnu::used]] extern Memory *__remill_fetch_and_nand_64(Memory *, addr_t addr, uint64_t &value);
+[[gnu::used]] extern void __remill_fetch_and_nand_64(RuntimeManager *, addr_t addr, uint64_t &value);
 
 // Read and modify the floating point exception state of the (virtual) machine
 // that is executing the actual floating point operations.
@@ -261,17 +261,17 @@ __remill_compare_exchange_memory_64(Memory *, addr_t addr, uint64_t &expected, u
                                                                            int clear_mask);
 
 // Read/write to I/O ports.
-[[gnu::used, gnu::const]] extern uint8_t __remill_read_io_port_8(Memory *, addr_t);
+[[gnu::used, gnu::const]] extern uint8_t __remill_read_io_port_8(RuntimeManager *, addr_t);
 
-[[gnu::used, gnu::const]] extern uint16_t __remill_read_io_port_16(Memory *, addr_t);
+[[gnu::used, gnu::const]] extern uint16_t __remill_read_io_port_16(RuntimeManager *, addr_t);
 
-[[gnu::used, gnu::const]] extern uint32_t __remill_read_io_port_32(Memory *, addr_t);
+[[gnu::used, gnu::const]] extern uint32_t __remill_read_io_port_32(RuntimeManager *, addr_t);
 
-[[gnu::used, gnu::const]] extern Memory *__remill_write_io_port_8(Memory *, addr_t, uint8_t);
+[[gnu::used, gnu::const]] extern void __remill_write_io_port_8(RuntimeManager *, addr_t, uint8_t);
 
-[[gnu::used, gnu::const]] extern Memory *__remill_write_io_port_16(Memory *, addr_t, uint16_t);
+[[gnu::used, gnu::const]] extern void __remill_write_io_port_16(RuntimeManager *, addr_t, uint16_t);
 
-[[gnu::used, gnu::const]] extern Memory *__remill_write_io_port_32(Memory *, addr_t, uint32_t);
+[[gnu::used, gnu::const]] extern void __remill_write_io_port_32(RuntimeManager *, addr_t, uint32_t);
 
 // More specific hyper calls.
 [[gnu::used, gnu::const]] extern Memory *__remill_x86_set_segment_es(Memory *);
diff --git a/backend/remill/tests/AArch64/Run.cpp b/backend/remill/tests/AArch64/Run.cpp
index 02b7431e..a70c361a 100644
--- a/backend/remill/tests/AArch64/Run.cpp
+++ b/backend/remill/tests/AArch64/Run.cpp
@@ -154,43 +154,37 @@ MAKE_RW_FP_MEMORY(128)
 //   return nullptr;
 // }
 
-Memory *__remill_compare_exchange_memory_8(Memory *memory, addr_t addr, uint8_t &expected,
-                                           uint8_t desired) {
+void __remill_compare_exchange_memory_8(RuntimeManager *, addr_t addr, uint8_t &expected,
+                                        uint8_t desired) {
   expected = __sync_val_compare_and_swap(reinterpret_cast<uint8_t *>(addr), expected, desired);
-  return memory;
 }
 
-Memory *__remill_compare_exchange_memory_16(Memory *memory, addr_t addr, uint16_t &expected,
-                                            uint16_t desired) {
+void __remill_compare_exchange_memory_16(RuntimeManager *, addr_t addr, uint16_t &expected,
+                                         uint16_t desired) {
   expected = __sync_val_compare_and_swap(reinterpret_cast<uint16_t *>(addr), expected, desired);
-  return memory;
 }
 
-Memory *__remill_compare_exchange_memory_32(Memory *memory, addr_t addr, uint32_t &expected,
-                                            uint32_t desired) {
+void __remill_compare_exchange_memory_32(RuntimeManager *, addr_t addr, uint32_t &expected,
+                                         uint32_t desired) {
   expected = __sync_val_compare_and_swap(reinterpret_cast<uint32_t *>(addr), expected, desired);
-  return memory;
 }
 
-Memory *__remill_compare_exchange_memory_64(Memory *memory, addr_t addr, uint64_t &expected,
-                                            uint64_t desired) {
+void __remill_compare_exchange_memory_64(RuntimeManager *, addr_t addr, uint64_t &expected,
+                                         uint64_t desired) {
   expected = __sync_val_compare_and_swap(reinterpret_cast<uint64_t *>(addr), expected, desired);
-  return memory;
 }
 
-Memory *__remill_compare_exchange_memory_128(Memory *memory, addr_t addr, uint128_t &expected,
-                                             uint128_t &desired) {
+void __remill_compare_exchange_memory_128(RuntimeManager *, addr_t addr, uint128_t &expected,
+                                          uint128_t &desired) {
 #ifdef _GXX_EXPERIMENTAL_CXX0X__
   expected = __sync_val_compare_and_swap(reinterpret_cast<uint128_t *>(addr), expected, desired);
 #endif
-  return memory;
 }
 
 #define MAKE_ATOMIC_INTRINSIC(intrinsic_name, type_prefix, size) \
-  Memory *__remill_##intrinsic_name##_##size(Memory *memory, addr_t addr, \
-                                             type_prefix##size##_t &value) { \
+  void __remill_##intrinsic_name##_##size(RuntimeManager *, addr_t addr, \
+                                          type_prefix##size##_t &value) { \
     value = __sync_##intrinsic_name(reinterpret_cast<type_prefix##size##_t *>(addr), value); \
-    return memory; \
   }
 
 MAKE_ATOMIC_INTRINSIC(fetch_and_add, uint, 8)
@@ -243,27 +237,27 @@ void __remill_error(uint8_t *, State &, addr_t, RuntimeManager *) {
 void __remill_missing_block(uint8_t *, State &, addr_t, RuntimeManager *) {}
 
 // Read/write to I/O ports.
-uint8_t __remill_read_io_port_8(Memory *, addr_t) {
+uint8_t __remill_read_io_port_8(RuntimeManager *, addr_t) {
   abort();
 }
 
-uint16_t __remill_read_io_port_16(Memory *, addr_t) {
+uint16_t __remill_read_io_port_16(RuntimeManager *, addr_t) {
   abort();
 }
 
-uint32_t __remill_read_io_port_32(Memory *, addr_t) {
+uint32_t __remill_read_io_port_32(RuntimeManager *, addr_t) {
   abort();
 }
 
-Memory *__remill_write_io_port_8(Memory *, addr_t, uint8_t) {
+void __remill_write_io_port_8(RuntimeManager *, addr_t, uint8_t) {
   abort();
 }
 
-Memory *__remill_write_io_port_16(Memory *, addr_t, uint16_t) {
+void __remill_write_io_port_16(RuntimeManager *, addr_t, uint16_t) {
   abort();
 }
 
-Memory *__remill_write_io_port_32(Memory *, addr_t, uint32_t) {
+void __remill_write_io_port_32(RuntimeManager *, addr_t, uint32_t) {
   abort();
 }
 
diff --git a/backend/remill/tests/X86/Run.cpp b/backend/remill/tests/X86/Run.cpp
index 6fcee0fe..ff818cc6 100644
--- a/backend/remill/tests/X86/Run.cpp
+++ b/backend/remill/tests/X86/Run.cpp
@@ -184,32 +184,28 @@ MAKE_RW_FP_MEMORY(128)
 
 // f80 functions are commented out in Intrinsics.h for elfconv
 
-Memory *__remill_compare_exchange_memory_8(Memory *memory, addr_t addr, uint8_t &expected,
-                                           uint8_t desired) {
+void __remill_compare_exchange_memory_8(RuntimeManager *, addr_t addr, uint8_t &expected,
+                                        uint8_t desired) {
   expected = __sync_val_compare_and_swap(reinterpret_cast<uint8_t *>(addr), expected, desired);
-  return memory;
 }
 
-Memory *__remill_compare_exchange_memory_16(Memory *memory, addr_t addr, uint16_t &expected,
-                                            uint16_t desired) {
+void __remill_compare_exchange_memory_16(RuntimeManager *, addr_t addr, uint16_t &expected,
+                                         uint16_t desired) {
   expected = __sync_val_compare_and_swap(reinterpret_cast<uint16_t *>(addr), expected, desired);
-  return memory;
 }
 
-Memory *__remill_compare_exchange_memory_32(Memory *memory, addr_t addr, uint32_t &expected,
-                                            uint32_t desired) {
+void __remill_compare_exchange_memory_32(RuntimeManager *, addr_t addr, uint32_t &expected,
+                                         uint32_t desired) {
   expected = __sync_val_compare_and_swap(reinterpret_cast<uint32_t *>(addr), expected, desired);
-  return memory;
 }
 
-Memory *__remill_compare_exchange_memory_64(Memory *memory, addr_t addr, uint64_t &expected,
-                                            uint64_t desired) {
+void __remill_compare_exchange_memory_64(RuntimeManager *, addr_t addr, uint64_t &expected,
+                                         uint64_t desired) {
   expected = __sync_val_compare_and_swap(reinterpret_cast<uint64_t *>(addr), expected, desired);
-  return memory;
 }
 
-Memory *__remill_compare_exchange_memory_128(Memory *memory, addr_t addr, uint128_t &expected,
-                                             uint128_t &desired) {
+void __remill_compare_exchange_memory_128(RuntimeManager *, addr_t addr, uint128_t &expected,
+                                          uint128_t &desired) {
 #if !(defined(__x86_64__) || defined(__i386__) || defined(_M_X86))
   expected = __sync_val_compare_and_swap(reinterpret_cast<uint128_t *>(addr), expected, desired);
 #else
@@ -232,14 +228,12 @@ Memory *__remill_compare_exchange_memory_128(Memory *memory, addr_t addr, uint12
     expected = *reinterpret_cast<uint128_t *>(addr);
   }
 #endif
-  return memory;
 }
 
 #define MAKE_ATOMIC_INTRINSIC(intrinsic_name, type_prefix, size) \
-  Memory *__remill_##intrinsic_name##_##size(Memory *memory, addr_t addr, \
-                                             type_prefix##size##_t &value) { \
+  void __remill_##intrinsic_name##_##size(RuntimeManager *, addr_t addr, \
+                                          type_prefix##size##_t &value) { \
     value = __sync_##intrinsic_name(reinterpret_cast<type_prefix##size##_t *>(addr), value); \
-    return memory; \
   }
 
 MAKE_ATOMIC_INTRINSIC(fetch_and_add, uint, 8)
@@ -290,27 +284,27 @@ void __remill_error(uint8_t *, State &, addr_t, RuntimeManager *) {
 void __remill_missing_block(uint8_t *, State &, addr_t, RuntimeManager *) {}
 
 // Read/write to I/O ports.
-uint8_t __remill_read_io_port_8(Memory *, addr_t) {
+uint8_t __remill_read_io_port_8(RuntimeManager *, addr_t) {
   abort();
 }
 
-uint16_t __remill_read_io_port_16(Memory *, addr_t) {
+uint16_t __remill_read_io_port_16(RuntimeManager *, addr_t) {
   abort();
 }
 
-uint32_t __remill_read_io_port_32(Memory *, addr_t) {
+uint32_t __remill_read_io_port_32(RuntimeManager *, addr_t) {
   abort();
 }
 
-Memory *__remill_write_io_port_8(Memory *, addr_t, uint8_t) {
+void __remill_write_io_port_8(RuntimeManager *, addr_t, uint8_t) {
   abort();
 }
 
-Memory *__remill_write_io_port_16(Memory *, addr_t, uint16_t) {
+void __remill_write_io_port_16(RuntimeManager *, addr_t, uint16_t) {
   abort();
 }
 
-Memory *__remill_write_io_port_32(Memory *, addr_t, uint32_t) {
+void __remill_write_io_port_32(RuntimeManager *, addr_t, uint32_t) {
   abort();
 }
 
diff --git a/runtime/VmIntrinsics.cpp b/runtime/VmIntrinsics.cpp
index f1d6afa3..53d9e098 100644
--- a/runtime/VmIntrinsics.cpp
+++ b/runtime/VmIntrinsics.cpp
@@ -30,7 +30,7 @@
 #  define PCREG CPUState->gpr.pc.qword
 #elif defined(ELF_IS_AMD64)
 #  include <remill/Arch/X86/Runtime/State.h>
-#  define PCREG CPUState.gpr.rip.qword
+#  define PCREG CPUState->gpr.rip.qword
 #else
 #  define PCREG CPUState.gpr.pc.qword
 #endif
@@ -658,153 +658,121 @@ Memory *__remill_delay_slot_end(Memory *) {
   UNDEFINED_INTRINSICS("__remill_delay_slot_end");
   return 0;
 }
-Memory *__remill_compare_exchange_memory_8(Memory *, addr_t addr, uint8_t &expected,
-                                           uint8_t desired) {
+void __remill_compare_exchange_memory_8(RuntimeManager *, addr_t addr, uint8_t &expected,
+                                        uint8_t desired) {
   UNDEFINED_INTRINSICS("__remill_compare_exchange_memory_8");
-  return 0;
 }
-Memory *__remill_compare_exchange_memory_16(Memory *, addr_t addr, uint16_t &expected,
-                                            uint16_t desired) {
+void __remill_compare_exchange_memory_16(RuntimeManager *, addr_t addr, uint16_t &expected,
+                                         uint16_t desired) {
   UNDEFINED_INTRINSICS("__remill_compare_exchange_memory_16");
-  return 0;
 }
-Memory *__remill_compare_exchange_memory_32(Memory *, addr_t addr, uint32_t &expected,
-                                            uint32_t desired) {
+void __remill_compare_exchange_memory_32(RuntimeManager *, addr_t addr, uint32_t &expected,
+                                         uint32_t desired) {
   UNDEFINED_INTRINSICS("__remill_compare_exchange_memory_32");
-  return 0;
 }
-Memory *__remill_compare_exchange_memory_64(Memory *, addr_t addr, uint64_t &expected,
-                                            uint64_t desired) {
+void __remill_compare_exchange_memory_64(RuntimeManager *, addr_t addr, uint64_t &expected,
+                                         uint64_t desired) {
   UNDEFINED_INTRINSICS("__remill_compare_exchange_memory_64");
-  return 0;
 }
 #if !defined(REMILL_DISABLE_INT128)
-Memory *__remill_compare_exchange_memory_128(Memory *, addr_t addr, uint128_t &expected,
-                                             uint128_t &desired) {
+void __remill_compare_exchange_memory_128(RuntimeManager *, addr_t addr, uint128_t &expected,
+                                          uint128_t &desired) {
   UNDEFINED_INTRINSICS("__remill_compare_exchange_memory_128");
-  return 0;
 }
 #endif
-Memory *__remill_fetch_and_add_8(Memory *, addr_t addr, uint8_t &value) {
+void __remill_fetch_and_add_8(RuntimeManager *, addr_t addr, uint8_t &value) {
   UNDEFINED_INTRINSICS("__remill_fetch_and_add_8");
-  return 0;
 }
-Memory *__remill_fetch_and_add_16(Memory *, addr_t addr, uint16_t &value) {
+void __remill_fetch_and_add_16(RuntimeManager *, addr_t addr, uint16_t &value) {
   UNDEFINED_INTRINSICS("__remill_fetch_and_add_16");
-  return 0;
 }
-Memory *__remill_fetch_and_add_32(Memory *, addr_t addr, uint32_t &value) {
+void __remill_fetch_and_add_32(RuntimeManager *, addr_t addr, uint32_t &value) {
   UNDEFINED_INTRINSICS("__remill_fetch_and_add_32");
-  return 0;
 }
-Memory *__remill_fetch_and_add_64(Memory *, addr_t addr, uint64_t &value) {
+void __remill_fetch_and_add_64(RuntimeManager *, addr_t addr, uint64_t &value) {
   UNDEFINED_INTRINSICS("__remill_fetch_and_add_64");
-  return 0;
 }
-Memory *__remill_fetch_and_sub_8(Memory *, addr_t addr, uint8_t &value) {
+void __remill_fetch_and_sub_8(RuntimeManager *, addr_t addr, uint8_t &value) {
   UNDEFINED_INTRINSICS("__remill_fetch_and_sub_8");
-  return 0;
 }
-Memory *__remill_fetch_and_sub_16(Memory *, addr_t addr, uint16_t &value) {
+void __remill_fetch_and_sub_16(RuntimeManager *, addr_t addr, uint16_t &value) {
   UNDEFINED_INTRINSICS("__remill_fetch_and_sub_16");
-  return 0;
 }
-Memory *__remill_fetch_and_sub_32(Memory *, addr_t addr, uint32_t &value) {
+void __remill_fetch_and_sub_32(RuntimeManager *, addr_t addr, uint32_t &value) {
   UNDEFINED_INTRINSICS("__remill_fetch_and_sub_32");
-  return 0;
 }
-Memory *__remill_fetch_and_sub_64(Memory *, addr_t addr, uint64_t &value) {
+void __remill_fetch_and_sub_64(RuntimeManager *, addr_t addr, uint64_t &value) {
   UNDEFINED_INTRINSICS("__remill_fetch_and_sub_64");
-  return 0;
 }
-Memory *__remill_fetch_and_and_8(Memory *, addr_t addr, uint8_t &value) {
+void __remill_fetch_and_and_8(RuntimeManager *, addr_t addr, uint8_t &value) {
   UNDEFINED_INTRINSICS("__remill_fetch_and_and_8");
-  return 0;
 }
-Memory *__remill_fetch_and_and_16(Memory *, addr_t addr, uint16_t &value) {
+void __remill_fetch_and_and_16(RuntimeManager *, addr_t addr, uint16_t &value) {
   UNDEFINED_INTRINSICS("__remill_fetch_and_and_16");
-  return 0;
 }
-Memory *__remill_fetch_and_and_32(Memory *, addr_t addr, uint32_t &value) {
+void __remill_fetch_and_and_32(RuntimeManager *, addr_t addr, uint32_t &value) {
   UNDEFINED_INTRINSICS("__remill_fetch_and_and_32");
-  return 0;
 }
-Memory *__remill_fetch_and_and_64(Memory *, addr_t addr, uint64_t &value) {
+void __remill_fetch_and_and_64(RuntimeManager *, addr_t addr, uint64_t &value) {
   UNDEFINED_INTRINSICS("__remill_fetch_and_and_64");
-  return 0;
 }
-Memory *__remill_fetch_and_or_8(Memory *, addr_t addr, uint8_t &value) {
+void __remill_fetch_and_or_8(RuntimeManager *, addr_t addr, uint8_t &value) {
   UNDEFINED_INTRINSICS("__remill_fetch_and_or_8");
-  return 0;
 }
-Memory *__remill_fetch_and_or_16(Memory *, addr_t addr, uint16_t &value) {
+void __remill_fetch_and_or_16(RuntimeManager *, addr_t addr, uint16_t &value) {
   UNDEFINED_INTRINSICS("__remill_fetch_and_or_16");
-  return 0;
 }
-Memory *__remill_fetch_and_or_32(Memory *, addr_t addr, uint32_t &value) {
+void __remill_fetch_and_or_32(RuntimeManager *, addr_t addr, uint32_t &value) {
   UNDEFINED_INTRINSICS("__remill_fetch_and_or_32");
-  return 0;
 }
-Memory *__remill_fetch_and_or_64(Memory *, addr_t addr, uint64_t &value) {
+void __remill_fetch_and_or_64(RuntimeManager *, addr_t addr, uint64_t &value) {
   UNDEFINED_INTRINSICS("__remill_fetch_and_or_64");
-  return 0;
 }
-Memory *__remill_fetch_and_xor_8(Memory *, addr_t addr, uint8_t &value) {
+void __remill_fetch_and_xor_8(RuntimeManager *, addr_t addr, uint8_t &value) {
   UNDEFINED_INTRINSICS("__remill_fetch_and_xor_8");
-  return 0;
 }
-Memory *__remill_fetch_and_xor_16(Memory *, addr_t addr, uint16_t &value) {
+void __remill_fetch_and_xor_16(RuntimeManager *, addr_t addr, uint16_t &value) {
   UNDEFINED_INTRINSICS("__remill_fetch_and_xor_16");
-  return 0;
 }
-Memory *__remill_fetch_and_xor_32(Memory *, addr_t addr, uint32_t &value) {
+void __remill_fetch_and_xor_32(RuntimeManager *, addr_t addr, uint32_t &value) {
   UNDEFINED_INTRINSICS("__remill_fetch_and_xor_32");
-  return 0;
 }
-Memory *__remill_fetch_and_xor_64(Memory *, addr_t addr, uint64_t &value) {
+void __remill_fetch_and_xor_64(RuntimeManager *, addr_t addr, uint64_t &value) {
   UNDEFINED_INTRINSICS("__remill_fetch_and_xor_64");
-  return 0;
 }
-Memory *__remill_fetch_and_nand_8(Memory *, addr_t addr, uint8_t &value) {
+void __remill_fetch_and_nand_8(RuntimeManager *, addr_t addr, uint8_t &value) {
   UNDEFINED_INTRINSICS("__remill_fetch_and_nand_8");
-  return 0;
 }
-Memory *__remill_fetch_and_nand_16(Memory *, addr_t addr, uint16_t &value) {
+void __remill_fetch_and_nand_16(RuntimeManager *, addr_t addr, uint16_t &value) {
   UNDEFINED_INTRINSICS("__remill_fetch_and_nand_16");
-  return 0;
 }
-Memory *__remill_fetch_and_nand_32(Memory *, addr_t addr, uint32_t &value) {
+void __remill_fetch_and_nand_32(RuntimeManager *, addr_t addr, uint32_t &value) {
   UNDEFINED_INTRINSICS("__remill_fetch_and_nand_32");
-  return 0;
 }
-Memory *__remill_fetch_and_nand_64(Memory *, addr_t addr, uint64_t &value) {
+void __remill_fetch_and_nand_64(RuntimeManager *, addr_t addr, uint64_t &value) {
   UNDEFINED_INTRINSICS("__remill_fetch_and_nand_64");
-  return 0;
 }
 
-uint8_t __remill_read_io_port_8(Memory *, addr_t) {
+uint8_t __remill_read_io_port_8(RuntimeManager *, addr_t) {
   UNDEFINED_INTRINSICS("__remill_read_io_port_8");
   return 0;
 }
-uint16_t __remill_read_io_port_16(Memory *, addr_t) {
+uint16_t __remill_read_io_port_16(RuntimeManager *, addr_t) {
   UNDEFINED_INTRINSICS("__remill_read_io_port_16");
   return 0;
 }
-uint32_t __remill_read_io_port_32(Memory *, addr_t) {
+uint32_t __remill_read_io_port_32(RuntimeManager *, addr_t) {
   UNDEFINED_INTRINSICS("__remill_read_io_port_32");
   return 0;
 }
-Memory *__remill_write_io_port_8(Memory *, addr_t, uint8_t) {
+void __remill_write_io_port_8(RuntimeManager *, addr_t, uint8_t) {
   UNDEFINED_INTRINSICS("__remill_write_io_port_8");
-  return 0;
 }
-Memory *__remill_write_io_port_16(Memory *, addr_t, uint16_t) {
+void __remill_write_io_port_16(RuntimeManager *, addr_t, uint16_t) {
   UNDEFINED_INTRINSICS("__remill_write_io_port_16");
-  return 0;
 }
-Memory *__remill_write_io_port_32(Memory *, addr_t, uint32_t) {
+void __remill_write_io_port_32(RuntimeManager *, addr_t, uint32_t) {
   UNDEFINED_INTRINSICS("__remill_write_io_port_32");
-  return 0;
 }
 Memory *__remill_x86_set_segment_es(Memory *) {
   UNDEFINED_INTRINSICS("__remill_x86_set_segment_es");