diff --git a/src/emu/addrmap.cpp b/src/emu/addrmap.cpp
index 7e6b56ed3a1..eb3aa2c87e8 100644
--- a/src/emu/addrmap.cpp
+++ b/src/emu/addrmap.cpp
@@ -162,7 +162,7 @@ address_map_entry &address_map_entry::m(device_t *device, address_map_constructo
 address_map_entry &address_map_entry::r(read8_delegate func)
 {
 	assert(!func.isnull());
-	m_read.m_type = AMH_DEVICE_DELEGATE_F;
+	m_read.m_type = AMH_DEVICE_DELEGATE;
 	m_read.m_bits = 8;
 	m_read.m_name = func.name();
 	m_rproto8 = func;
@@ -172,13 +172,33 @@ address_map_entry &address_map_entry::r(read8_delegate func)
 address_map_entry &address_map_entry::w(write8_delegate func)
 {
 	assert(!func.isnull());
-	m_write.m_type = AMH_DEVICE_DELEGATE_F;
+	m_write.m_type = AMH_DEVICE_DELEGATE;
 	m_write.m_bits = 8;
 	m_write.m_name = func.name();
 	m_wproto8 = func;
 	return *this;
 }
 
+address_map_entry &address_map_entry::r(read8m_delegate func)
+{
+	assert(!func.isnull());
+	m_read.m_type = AMH_DEVICE_DELEGATE_M;
+	m_read.m_bits = 8;
+	m_read.m_name = func.name();
+	m_rproto8m = func;
+	return *this;
+}
+
+address_map_entry &address_map_entry::w(write8m_delegate func)
+{
+	assert(!func.isnull());
+	m_write.m_type = AMH_DEVICE_DELEGATE_M;
+	m_write.m_bits = 8;
+	m_write.m_name = func.name();
+	m_wproto8m = func;
+	return *this;
+}
+
 address_map_entry &address_map_entry::r(read8s_delegate func)
 {
 	assert(!func.isnull());
@@ -219,6 +239,26 @@ address_map_entry &address_map_entry::w(write8sm_delegate func)
 	return *this;
 }
 
+address_map_entry &address_map_entry::r(read8mo_delegate func)
+{
+	assert(!func.isnull());
+	m_read.m_type = AMH_DEVICE_DELEGATE_MO;
+	m_read.m_bits = 8;
+	m_read.m_name = func.name();
+	m_rproto8mo = func;
+	return *this;
+}
+
+address_map_entry &address_map_entry::w(write8mo_delegate func)
+{
+	assert(!func.isnull());
+	m_write.m_type = AMH_DEVICE_DELEGATE_MO;
+	m_write.m_bits = 8;
+	m_write.m_name = func.name();
+	m_wproto8mo = func;
+	return *this;
+}
+
 address_map_entry &address_map_entry::r(read8smo_delegate func)
 {
 	assert(!func.isnull());
@@ -248,7 +288,7 @@ address_map_entry &address_map_entry::w(write8smo_delegate func)
 address_map_entry &address_map_entry::r(read16_delegate func)
 {
 	assert(!func.isnull());
-	m_read.m_type = AMH_DEVICE_DELEGATE_F;
+	m_read.m_type = AMH_DEVICE_DELEGATE;
 	m_read.m_bits = 16;
 	m_read.m_name = func.name();
 	m_rproto16 = func;
@@ -258,13 +298,33 @@ address_map_entry &address_map_entry::r(read16_delegate func)
 address_map_entry &address_map_entry::w(write16_delegate func)
 {
 	assert(!func.isnull());
-	m_write.m_type = AMH_DEVICE_DELEGATE_F;
+	m_write.m_type = AMH_DEVICE_DELEGATE;
 	m_write.m_bits = 16;
 	m_write.m_name = func.name();
 	m_wproto16 = func;
 	return *this;
 }
 
+address_map_entry &address_map_entry::r(read16m_delegate func)
+{
+	assert(!func.isnull());
+	m_read.m_type = AMH_DEVICE_DELEGATE_M;
+	m_read.m_bits = 16;
+	m_read.m_name = func.name();
+	m_rproto16m = func;
+	return *this;
+}
+
+address_map_entry &address_map_entry::w(write16m_delegate func)
+{
+	assert(!func.isnull());
+	m_write.m_type = AMH_DEVICE_DELEGATE_M;
+	m_write.m_bits = 16;
+	m_write.m_name = func.name();
+	m_wproto16m = func;
+	return *this;
+}
+
 address_map_entry &address_map_entry::r(read16s_delegate func)
 {
 	assert(!func.isnull());
@@ -305,6 +365,26 @@ address_map_entry &address_map_entry::w(write16sm_delegate func)
 	return *this;
 }
 
+address_map_entry &address_map_entry::r(read16mo_delegate func)
+{
+	assert(!func.isnull());
+	m_read.m_type = AMH_DEVICE_DELEGATE_MO;
+	m_read.m_bits = 16;
+	m_read.m_name = func.name();
+	m_rproto16mo = func;
+	return *this;
+}
+
+address_map_entry &address_map_entry::w(write16mo_delegate func)
+{
+	assert(!func.isnull());
+	m_write.m_type = AMH_DEVICE_DELEGATE_MO;
+	m_write.m_bits = 16;
+	m_write.m_name = func.name();
+	m_wproto16mo = func;
+	return *this;
+}
+
 address_map_entry &address_map_entry::r(read16smo_delegate func)
 {
 	assert(!func.isnull());
@@ -334,7 +414,7 @@ address_map_entry &address_map_entry::w(write16smo_delegate func)
 address_map_entry &address_map_entry::r(read32_delegate func)
 {
 	assert(!func.isnull());
-	m_read.m_type = AMH_DEVICE_DELEGATE_F;
+	m_read.m_type = AMH_DEVICE_DELEGATE;
 	m_read.m_bits = 32;
 	m_read.m_name = func.name();
 	m_rproto32 = func;
@@ -344,13 +424,33 @@ address_map_entry &address_map_entry::r(read32_delegate func)
 address_map_entry &address_map_entry::w(write32_delegate func)
 {
 	assert(!func.isnull());
-	m_write.m_type = AMH_DEVICE_DELEGATE_F;
+	m_write.m_type = AMH_DEVICE_DELEGATE;
 	m_write.m_bits = 32;
 	m_write.m_name = func.name();
 	m_wproto32 = func;
 	return *this;
 }
 
+address_map_entry &address_map_entry::r(read32m_delegate func)
+{
+	assert(!func.isnull());
+	m_read.m_type = AMH_DEVICE_DELEGATE_M;
+	m_read.m_bits = 32;
+	m_read.m_name = func.name();
+	m_rproto32m = func;
+	return *this;
+}
+
+address_map_entry &address_map_entry::w(write32m_delegate func)
+{
+	assert(!func.isnull());
+	m_write.m_type = AMH_DEVICE_DELEGATE_M;
+	m_write.m_bits = 32;
+	m_write.m_name = func.name();
+	m_wproto32m = func;
+	return *this;
+}
+
 address_map_entry &address_map_entry::r(read32s_delegate func)
 {
 	assert(!func.isnull());
@@ -391,6 +491,26 @@ address_map_entry &address_map_entry::w(write32sm_delegate func)
 	return *this;
 }
 
+address_map_entry &address_map_entry::r(read32mo_delegate func)
+{
+	assert(!func.isnull());
+	m_read.m_type = AMH_DEVICE_DELEGATE_MO;
+	m_read.m_bits = 32;
+	m_read.m_name = func.name();
+	m_rproto32mo = func;
+	return *this;
+}
+
+address_map_entry &address_map_entry::w(write32mo_delegate func)
+{
+	assert(!func.isnull());
+	m_write.m_type = AMH_DEVICE_DELEGATE_MO;
+	m_write.m_bits = 32;
+	m_write.m_name = func.name();
+	m_wproto32mo = func;
+	return *this;
+}
+
 address_map_entry &address_map_entry::r(read32smo_delegate func)
 {
 	assert(!func.isnull());
@@ -419,7 +539,7 @@ address_map_entry &address_map_entry::w(write32smo_delegate func)
 address_map_entry &address_map_entry::r(read64_delegate func)
 {
 	assert(!func.isnull());
-	m_read.m_type = AMH_DEVICE_DELEGATE_F;
+	m_read.m_type = AMH_DEVICE_DELEGATE;
 	m_read.m_bits = 64;
 	m_read.m_name = func.name();
 	m_rproto64 = func;
@@ -429,13 +549,33 @@ address_map_entry &address_map_entry::r(read64_delegate func)
 address_map_entry &address_map_entry::w(write64_delegate func)
 {
 	assert(!func.isnull());
-	m_write.m_type = AMH_DEVICE_DELEGATE_F;
+	m_write.m_type = AMH_DEVICE_DELEGATE;
 	m_write.m_bits = 64;
 	m_write.m_name = func.name();
 	m_wproto64 = func;
 	return *this;
 }
 
+address_map_entry &address_map_entry::r(read64m_delegate func)
+{
+	assert(!func.isnull());
+	m_read.m_type = AMH_DEVICE_DELEGATE_M;
+	m_read.m_bits = 64;
+	m_read.m_name = func.name();
+	m_rproto64m = func;
+	return *this;
+}
+
+address_map_entry &address_map_entry::w(write64m_delegate func)
+{
+	assert(!func.isnull());
+	m_write.m_type = AMH_DEVICE_DELEGATE_M;
+	m_write.m_bits = 64;
+	m_write.m_name = func.name();
+	m_wproto64m = func;
+	return *this;
+}
+
 address_map_entry &address_map_entry::r(read64s_delegate func)
 {
 	assert(!func.isnull());
@@ -476,6 +616,26 @@ address_map_entry &address_map_entry::w(write64sm_delegate func)
 	return *this;
 }
 
+address_map_entry &address_map_entry::r(read64mo_delegate func)
+{
+	assert(!func.isnull());
+	m_read.m_type = AMH_DEVICE_DELEGATE_MO;
+	m_read.m_bits = 64;
+	m_read.m_name = func.name();
+	m_rproto64mo = func;
+	return *this;
+}
+
+address_map_entry &address_map_entry::w(write64mo_delegate func)
+{
+	assert(!func.isnull());
+	m_write.m_type = AMH_DEVICE_DELEGATE_MO;
+	m_write.m_bits = 64;
+	m_write.m_name = func.name();
+	m_wproto64mo = func;
+	return *this;
+}
+
 address_map_entry &address_map_entry::r(read64smo_delegate func)
 {
 	assert(!func.isnull());
@@ -952,52 +1112,68 @@ void address_map::map_validity_check(validity_checker &valid, int spacenum) cons
 		}
 
 		// make sure all devices exist
-		if (entry.m_read.m_type == AMH_DEVICE_DELEGATE_F || entry.m_read.m_type == AMH_DEVICE_DELEGATE_S || entry.m_read.m_type == AMH_DEVICE_DELEGATE_SM || entry.m_read.m_type == AMH_DEVICE_DELEGATE_SMO)
+		if (entry.m_read.m_type == AMH_DEVICE_DELEGATE || entry.m_read.m_type == AMH_DEVICE_DELEGATE_M || entry.m_read.m_type == AMH_DEVICE_DELEGATE_S || entry.m_read.m_type == AMH_DEVICE_DELEGATE_SM || entry.m_read.m_type == AMH_DEVICE_DELEGATE_MO || entry.m_read.m_type == AMH_DEVICE_DELEGATE_SMO)
 		{
 			// extract the device tag from the proto-delegate
 			const char *devtag = nullptr;
 			switch (entry.m_read.m_bits)
 			{
 				case 8:
-					if (entry.m_read.m_type == AMH_DEVICE_DELEGATE_F)
+					if (entry.m_read.m_type == AMH_DEVICE_DELEGATE)
 						devtag = entry.m_rproto8.device_name();
+					else if (entry.m_read.m_type == AMH_DEVICE_DELEGATE_M)
+						devtag = entry.m_rproto8m.device_name();
 					else if (entry.m_read.m_type == AMH_DEVICE_DELEGATE_S)
 						devtag = entry.m_rproto8s.device_name();
 					else if (entry.m_read.m_type == AMH_DEVICE_DELEGATE_SM)
 						devtag = entry.m_rproto8sm.device_name();
+					else if (entry.m_read.m_type == AMH_DEVICE_DELEGATE_MO)
+						devtag = entry.m_rproto8mo.device_name();
 					else
 						devtag = entry.m_rproto8smo.device_name();
 					break;
 
 				case 16:
-					if (entry.m_read.m_type == AMH_DEVICE_DELEGATE_F)
+					if (entry.m_read.m_type == AMH_DEVICE_DELEGATE)
 						devtag = entry.m_rproto16.device_name();
+					else if (entry.m_read.m_type == AMH_DEVICE_DELEGATE_M)
+						devtag = entry.m_rproto16m.device_name();
 					else if (entry.m_read.m_type == AMH_DEVICE_DELEGATE_S)
 						devtag = entry.m_rproto16s.device_name();
 					else if (entry.m_read.m_type == AMH_DEVICE_DELEGATE_SM)
 						devtag = entry.m_rproto16sm.device_name();
+					else if (entry.m_read.m_type == AMH_DEVICE_DELEGATE_MO)
+						devtag = entry.m_rproto16mo.device_name();
 					else
 						devtag = entry.m_rproto16smo.device_name();
 					break;
 
 				case 32:
-					if (entry.m_read.m_type == AMH_DEVICE_DELEGATE_F)
+					if (entry.m_read.m_type == AMH_DEVICE_DELEGATE)
 						devtag = entry.m_rproto32.device_name();
+					else if (entry.m_read.m_type == AMH_DEVICE_DELEGATE_M)
+						devtag = entry.m_rproto32m.device_name();
 					else if (entry.m_read.m_type == AMH_DEVICE_DELEGATE_S)
 						devtag = entry.m_rproto32s.device_name();
 					else if (entry.m_read.m_type == AMH_DEVICE_DELEGATE_SM)
 						devtag = entry.m_rproto32sm.device_name();
+					else if (entry.m_read.m_type == AMH_DEVICE_DELEGATE_MO)
+						devtag = entry.m_rproto32mo.device_name();
 					else
 						devtag = entry.m_rproto32smo.device_name();
 					break;
 
 				case 64:
-					if (entry.m_read.m_type == AMH_DEVICE_DELEGATE_F)
+					if (entry.m_read.m_type == AMH_DEVICE_DELEGATE)
 						devtag = entry.m_rproto64.device_name();
+					else if (entry.m_read.m_type == AMH_DEVICE_DELEGATE_M)
+						devtag = entry.m_rproto64m.device_name();
 					else if (entry.m_read.m_type == AMH_DEVICE_DELEGATE_S)
 						devtag = entry.m_rproto64s.device_name();
 					else if (entry.m_read.m_type == AMH_DEVICE_DELEGATE_SM)
 						devtag = entry.m_rproto64sm.device_name();
+					else if (entry.m_read.m_type == AMH_DEVICE_DELEGATE_MO)
+						devtag = entry.m_rproto64mo.device_name();
 					else
 						devtag = entry.m_rproto64smo.device_name();
 					break;
@@ -1008,52 +1184,68 @@ void address_map::map_validity_check(validity_checker &valid, int spacenum) cons
 			(void)entry.unitmask_is_appropriate(entry.m_read.m_bits, entry.m_mask, entry.m_read.m_name);
 #endif
 		}
-		if (entry.m_write.m_type == AMH_DEVICE_DELEGATE_F || entry.m_write.m_type == AMH_DEVICE_DELEGATE_S || entry.m_write.m_type == AMH_DEVICE_DELEGATE_SM || entry.m_write.m_type == AMH_DEVICE_DELEGATE_SMO)
+		if (entry.m_write.m_type == AMH_DEVICE_DELEGATE || entry.m_read.m_type == AMH_DEVICE_DELEGATE_M || entry.m_write.m_type == AMH_DEVICE_DELEGATE_S || entry.m_write.m_type == AMH_DEVICE_DELEGATE_SM || entry.m_read.m_type == AMH_DEVICE_DELEGATE_MO || entry.m_write.m_type == AMH_DEVICE_DELEGATE_SMO)
 		{
 			// extract the device tag from the proto-delegate
 			const char *devtag = nullptr;
 			switch (entry.m_write.m_bits)
 			{
 				case 8:
-					if (entry.m_write.m_type == AMH_DEVICE_DELEGATE_F)
+					if (entry.m_write.m_type == AMH_DEVICE_DELEGATE)
 						devtag = entry.m_wproto8.device_name();
+					else if (entry.m_write.m_type == AMH_DEVICE_DELEGATE_M)
+						devtag = entry.m_wproto8m.device_name();
 					else if (entry.m_write.m_type == AMH_DEVICE_DELEGATE_S)
 						devtag = entry.m_wproto8s.device_name();
 					else if (entry.m_write.m_type == AMH_DEVICE_DELEGATE_SM)
 						devtag = entry.m_wproto8sm.device_name();
+					else if (entry.m_write.m_type == AMH_DEVICE_DELEGATE_MO)
+						devtag = entry.m_wproto8mo.device_name();
 					else
 						devtag = entry.m_wproto8smo.device_name();
 					break;
 
 				case 16:
-					if (entry.m_write.m_type == AMH_DEVICE_DELEGATE_F)
+					if (entry.m_write.m_type == AMH_DEVICE_DELEGATE)
 						devtag = entry.m_wproto16.device_name();
+					else if (entry.m_write.m_type == AMH_DEVICE_DELEGATE_M)
+						devtag = entry.m_wproto16m.device_name();
 					else if (entry.m_write.m_type == AMH_DEVICE_DELEGATE_S)
 						devtag = entry.m_wproto16s.device_name();
 					else if (entry.m_write.m_type == AMH_DEVICE_DELEGATE_SM)
 						devtag = entry.m_wproto16sm.device_name();
+					else if (entry.m_write.m_type == AMH_DEVICE_DELEGATE_MO)
+						devtag = entry.m_wproto16mo.device_name();
 					else
 						devtag = entry.m_wproto16smo.device_name();
 					break;
 
 				case 32:
-					if (entry.m_write.m_type == AMH_DEVICE_DELEGATE_F)
+					if (entry.m_write.m_type == AMH_DEVICE_DELEGATE)
 						devtag = entry.m_wproto32.device_name();
+					else if (entry.m_write.m_type == AMH_DEVICE_DELEGATE_M)
+						devtag = entry.m_wproto32m.device_name();
 					else if (entry.m_write.m_type == AMH_DEVICE_DELEGATE_S)
 						devtag = entry.m_wproto32s.device_name();
 					else if (entry.m_write.m_type == AMH_DEVICE_DELEGATE_SM)
 						devtag = entry.m_wproto32sm.device_name();
+					else if (entry.m_write.m_type == AMH_DEVICE_DELEGATE_MO)
+						devtag = entry.m_wproto32mo.device_name();
 					else
 						devtag = entry.m_wproto32smo.device_name();
 					break;
 
 				case 64:
-					if (entry.m_write.m_type == AMH_DEVICE_DELEGATE_F)
+					if (entry.m_write.m_type == AMH_DEVICE_DELEGATE)
 						devtag = entry.m_wproto64.device_name();
+					else if (entry.m_write.m_type == AMH_DEVICE_DELEGATE_M)
+						devtag = entry.m_wproto64m.device_name();
 					else if (entry.m_write.m_type == AMH_DEVICE_DELEGATE_S)
 						devtag = entry.m_wproto64s.device_name();
 					else if (entry.m_write.m_type == AMH_DEVICE_DELEGATE_SM)
 						devtag = entry.m_wproto64sm.device_name();
+					else if (entry.m_write.m_type == AMH_DEVICE_DELEGATE_MO)
+						devtag = entry.m_wproto64mo.device_name();
 					else
 						devtag = entry.m_wproto64smo.device_name();
 					break;
diff --git a/src/emu/addrmap.h b/src/emu/addrmap.h
index 56d50ef4f7e..9256d22f65d 100644
--- a/src/emu/addrmap.h
+++ b/src/emu/addrmap.h
@@ -32,9 +32,11 @@ enum map_handler_type
 	AMH_ROM,
 	AMH_NOP,
 	AMH_UNMAP,
-	AMH_DEVICE_DELEGATE_F,
+	AMH_DEVICE_DELEGATE,
+	AMH_DEVICE_DELEGATE_M,
 	AMH_DEVICE_DELEGATE_S,
 	AMH_DEVICE_DELEGATE_SM,
+	AMH_DEVICE_DELEGATE_MO,
 	AMH_DEVICE_DELEGATE_SMO,
 	AMH_PORT,
 	AMH_BANK,
@@ -338,6 +340,15 @@ public:
 	write32_delegate        m_wproto32;             // 32-bit write proto-delegate
 	write64_delegate        m_wproto64;             // 64-bit write proto-delegate
 
+	read8m_delegate         m_rproto8m;             // 8-bit read proto-delegate
+	read16m_delegate        m_rproto16m;            // 16-bit read proto-delegate
+	read32m_delegate        m_rproto32m;            // 32-bit read proto-delegate
+	read64m_delegate        m_rproto64m;            // 64-bit read proto-delegate
+	write8m_delegate        m_wproto8m;             // 8-bit write proto-delegate
+	write16m_delegate       m_wproto16m;            // 16-bit write proto-delegate
+	write32m_delegate       m_wproto32m;            // 32-bit write proto-delegate
+	write64m_delegate       m_wproto64m;            // 64-bit write proto-delegate
+
 	read8s_delegate         m_rproto8s;             // 8-bit read proto-delegate
 	read16s_delegate        m_rproto16s;            // 16-bit read proto-delegate
 	read32s_delegate        m_rproto32s;            // 32-bit read proto-delegate
@@ -356,6 +367,15 @@ public:
 	write32sm_delegate      m_wproto32sm;           // 32-bit write proto-delegate
 	write64sm_delegate      m_wproto64sm;           // 64-bit write proto-delegate
 
+	read8mo_delegate        m_rproto8mo;            // 8-bit read proto-delegate
+	read16mo_delegate       m_rproto16mo;           // 16-bit read proto-delegate
+	read32mo_delegate       m_rproto32mo;           // 32-bit read proto-delegate
+	read64mo_delegate       m_rproto64mo;           // 64-bit read proto-delegate
+	write8mo_delegate       m_wproto8mo;            // 8-bit write proto-delegate
+	write16mo_delegate      m_wproto16mo;           // 16-bit write proto-delegate
+	write32mo_delegate      m_wproto32mo;           // 32-bit write proto-delegate
+	write64mo_delegate      m_wproto64mo;           // 64-bit write proto-delegate
+
 	read8smo_delegate       m_rproto8smo;           // 8-bit read proto-delegate
 	read16smo_delegate      m_rproto16smo;          // 16-bit read proto-delegate
 	read32smo_delegate      m_rproto32smo;          // 32-bit read proto-delegate
@@ -374,40 +394,56 @@ public:
 	// handler setters for 8-bit delegates
 	address_map_entry &r(read8_delegate func);
 	address_map_entry &w(write8_delegate func);
+	address_map_entry &r(read8m_delegate func);
+	address_map_entry &w(write8m_delegate func);
 	address_map_entry &r(read8s_delegate func);
 	address_map_entry &w(write8s_delegate func);
 	address_map_entry &r(read8sm_delegate func);
 	address_map_entry &w(write8sm_delegate func);
+	address_map_entry &r(read8mo_delegate func);
+	address_map_entry &w(write8mo_delegate func);
 	address_map_entry &r(read8smo_delegate func);
 	address_map_entry &w(write8smo_delegate func);
 
 	// handler setters for 16-bit delegates
 	address_map_entry &r(read16_delegate func);
 	address_map_entry &w(write16_delegate func);
+	address_map_entry &r(read16m_delegate func);
+	address_map_entry &w(write16m_delegate func);
 	address_map_entry &r(read16s_delegate func);
 	address_map_entry &w(write16s_delegate func);
 	address_map_entry &r(read16sm_delegate func);
 	address_map_entry &w(write16sm_delegate func);
+	address_map_entry &r(read16mo_delegate func);
+	address_map_entry &w(write16mo_delegate func);
 	address_map_entry &r(read16smo_delegate func);
 	address_map_entry &w(write16smo_delegate func);
 
 	// handler setters for 32-bit delegates
 	address_map_entry &r(read32_delegate func);
 	address_map_entry &w(write32_delegate func);
+	address_map_entry &r(read32m_delegate func);
+	address_map_entry &w(write32m_delegate func);
 	address_map_entry &r(read32s_delegate func);
 	address_map_entry &w(write32s_delegate func);
 	address_map_entry &r(read32sm_delegate func);
 	address_map_entry &w(write32sm_delegate func);
+	address_map_entry &r(read32mo_delegate func);
+	address_map_entry &w(write32mo_delegate func);
 	address_map_entry &r(read32smo_delegate func);
 	address_map_entry &w(write32smo_delegate func);
 
 	// handler setters for 64-bit delegates
 	address_map_entry &r(read64_delegate func);
 	address_map_entry &w(write64_delegate func);
+	address_map_entry &r(read64m_delegate func);
+	address_map_entry &w(write64m_delegate func);
 	address_map_entry &r(read64s_delegate func);
 	address_map_entry &w(write64s_delegate func);
 	address_map_entry &r(read64sm_delegate func);
 	address_map_entry &w(write64sm_delegate func);
+	address_map_entry &r(read64mo_delegate func);
+	address_map_entry &w(write64mo_delegate func);
 	address_map_entry &r(read64smo_delegate func);
 	address_map_entry &w(write64smo_delegate func);
 
diff --git a/src/emu/devcb.cpp b/src/emu/devcb.cpp
index 75e43ad606e..3fb8056c787 100644
--- a/src/emu/devcb.cpp
+++ b/src/emu/devcb.cpp
@@ -11,6 +11,7 @@
 #include "emu.h"
 #include "devcb.h"
 
+
 template class devcb_read<u8>;
 template class devcb_read<u16>;
 template class devcb_read<u32>;
@@ -21,36 +22,108 @@ template class devcb_read8::delegate_builder<read8_delegate>;
 template class devcb_read8::delegate_builder<read16_delegate>;
 template class devcb_read8::delegate_builder<read32_delegate>;
 template class devcb_read8::delegate_builder<read64_delegate>;
+template class devcb_read8::delegate_builder<read8s_delegate>;
+template class devcb_read8::delegate_builder<read16s_delegate>;
+template class devcb_read8::delegate_builder<read32s_delegate>;
+template class devcb_read8::delegate_builder<read64s_delegate>;
+template class devcb_read8::delegate_builder<read8sm_delegate>;
+template class devcb_read8::delegate_builder<read16sm_delegate>;
+template class devcb_read8::delegate_builder<read32sm_delegate>;
+template class devcb_read8::delegate_builder<read64sm_delegate>;
+template class devcb_read8::delegate_builder<read8smo_delegate>;
+template class devcb_read8::delegate_builder<read16smo_delegate>;
+template class devcb_read8::delegate_builder<read32smo_delegate>;
+template class devcb_read8::delegate_builder<read64smo_delegate>;
 template class devcb_read8::delegate_builder<read_line_delegate>;
 
 template class devcb_read16::delegate_builder<read8_delegate>;
 template class devcb_read16::delegate_builder<read16_delegate>;
 template class devcb_read16::delegate_builder<read32_delegate>;
 template class devcb_read16::delegate_builder<read64_delegate>;
+template class devcb_read16::delegate_builder<read8s_delegate>;
+template class devcb_read16::delegate_builder<read16s_delegate>;
+template class devcb_read16::delegate_builder<read32s_delegate>;
+template class devcb_read16::delegate_builder<read64s_delegate>;
+template class devcb_read16::delegate_builder<read8sm_delegate>;
+template class devcb_read16::delegate_builder<read16sm_delegate>;
+template class devcb_read16::delegate_builder<read32sm_delegate>;
+template class devcb_read16::delegate_builder<read64sm_delegate>;
+template class devcb_read16::delegate_builder<read8smo_delegate>;
+template class devcb_read16::delegate_builder<read16smo_delegate>;
+template class devcb_read16::delegate_builder<read32smo_delegate>;
+template class devcb_read16::delegate_builder<read64smo_delegate>;
 template class devcb_read16::delegate_builder<read_line_delegate>;
 
 template class devcb_read32::delegate_builder<read8_delegate>;
 template class devcb_read32::delegate_builder<read16_delegate>;
 template class devcb_read32::delegate_builder<read32_delegate>;
 template class devcb_read32::delegate_builder<read64_delegate>;
+template class devcb_read32::delegate_builder<read8s_delegate>;
+template class devcb_read32::delegate_builder<read16s_delegate>;
+template class devcb_read32::delegate_builder<read32s_delegate>;
+template class devcb_read32::delegate_builder<read64s_delegate>;
+template class devcb_read32::delegate_builder<read8sm_delegate>;
+template class devcb_read32::delegate_builder<read16sm_delegate>;
+template class devcb_read32::delegate_builder<read32sm_delegate>;
+template class devcb_read32::delegate_builder<read64sm_delegate>;
+template class devcb_read32::delegate_builder<read8smo_delegate>;
+template class devcb_read32::delegate_builder<read16smo_delegate>;
+template class devcb_read32::delegate_builder<read32smo_delegate>;
+template class devcb_read32::delegate_builder<read64smo_delegate>;
 template class devcb_read32::delegate_builder<read_line_delegate>;
 
 template class devcb_read64::delegate_builder<read8_delegate>;
 template class devcb_read64::delegate_builder<read16_delegate>;
 template class devcb_read64::delegate_builder<read32_delegate>;
 template class devcb_read64::delegate_builder<read64_delegate>;
+template class devcb_read64::delegate_builder<read8s_delegate>;
+template class devcb_read64::delegate_builder<read16s_delegate>;
+template class devcb_read64::delegate_builder<read32s_delegate>;
+template class devcb_read64::delegate_builder<read64s_delegate>;
+template class devcb_read64::delegate_builder<read8sm_delegate>;
+template class devcb_read64::delegate_builder<read16sm_delegate>;
+template class devcb_read64::delegate_builder<read32sm_delegate>;
+template class devcb_read64::delegate_builder<read64sm_delegate>;
+template class devcb_read64::delegate_builder<read8smo_delegate>;
+template class devcb_read64::delegate_builder<read16smo_delegate>;
+template class devcb_read64::delegate_builder<read32smo_delegate>;
+template class devcb_read64::delegate_builder<read64smo_delegate>;
 template class devcb_read64::delegate_builder<read_line_delegate>;
 
 template class devcb_read_line::delegate_builder<read8_delegate>;
 template class devcb_read_line::delegate_builder<read16_delegate>;
 template class devcb_read_line::delegate_builder<read32_delegate>;
 template class devcb_read_line::delegate_builder<read64_delegate>;
+template class devcb_read_line::delegate_builder<read8s_delegate>;
+template class devcb_read_line::delegate_builder<read16s_delegate>;
+template class devcb_read_line::delegate_builder<read32s_delegate>;
+template class devcb_read_line::delegate_builder<read64s_delegate>;
+template class devcb_read_line::delegate_builder<read8sm_delegate>;
+template class devcb_read_line::delegate_builder<read16sm_delegate>;
+template class devcb_read_line::delegate_builder<read32sm_delegate>;
+template class devcb_read_line::delegate_builder<read64sm_delegate>;
+template class devcb_read_line::delegate_builder<read8smo_delegate>;
+template class devcb_read_line::delegate_builder<read16smo_delegate>;
+template class devcb_read_line::delegate_builder<read32smo_delegate>;
+template class devcb_read_line::delegate_builder<read64smo_delegate>;
 template class devcb_read_line::delegate_builder<read_line_delegate>;
 
 template class devcb_read8::creator_impl<devcb_read8::delegate_builder<read8_delegate> >;
 template class devcb_read8::creator_impl<devcb_read8::delegate_builder<read16_delegate> >;
 template class devcb_read8::creator_impl<devcb_read8::delegate_builder<read32_delegate> >;
 template class devcb_read8::creator_impl<devcb_read8::delegate_builder<read64_delegate> >;
+template class devcb_read8::creator_impl<devcb_read8::delegate_builder<read8s_delegate> >;
+template class devcb_read8::creator_impl<devcb_read8::delegate_builder<read16s_delegate> >;
+template class devcb_read8::creator_impl<devcb_read8::delegate_builder<read32s_delegate> >;
+template class devcb_read8::creator_impl<devcb_read8::delegate_builder<read64s_delegate> >;
+template class devcb_read8::creator_impl<devcb_read8::delegate_builder<read8sm_delegate> >;
+template class devcb_read8::creator_impl<devcb_read8::delegate_builder<read16sm_delegate> >;
+template class devcb_read8::creator_impl<devcb_read8::delegate_builder<read32sm_delegate> >;
+template class devcb_read8::creator_impl<devcb_read8::delegate_builder<read64sm_delegate> >;
+template class devcb_read8::creator_impl<devcb_read8::delegate_builder<read8smo_delegate> >;
+template class devcb_read8::creator_impl<devcb_read8::delegate_builder<read16smo_delegate> >;
+template class devcb_read8::creator_impl<devcb_read8::delegate_builder<read32smo_delegate> >;
+template class devcb_read8::creator_impl<devcb_read8::delegate_builder<read64smo_delegate> >;
 template class devcb_read8::creator_impl<devcb_read8::delegate_builder<read_line_delegate> >;
 template class devcb_read8::creator_impl<devcb_read8::ioport_builder>;
 
@@ -58,6 +131,18 @@ template class devcb_read16::creator_impl<devcb_read16::delegate_builder<read8_d
 template class devcb_read16::creator_impl<devcb_read16::delegate_builder<read16_delegate> >;
 template class devcb_read16::creator_impl<devcb_read16::delegate_builder<read32_delegate> >;
 template class devcb_read16::creator_impl<devcb_read16::delegate_builder<read64_delegate> >;
+template class devcb_read16::creator_impl<devcb_read16::delegate_builder<read8s_delegate> >;
+template class devcb_read16::creator_impl<devcb_read16::delegate_builder<read16s_delegate> >;
+template class devcb_read16::creator_impl<devcb_read16::delegate_builder<read32s_delegate> >;
+template class devcb_read16::creator_impl<devcb_read16::delegate_builder<read64s_delegate> >;
+template class devcb_read16::creator_impl<devcb_read16::delegate_builder<read8sm_delegate> >;
+template class devcb_read16::creator_impl<devcb_read16::delegate_builder<read16sm_delegate> >;
+template class devcb_read16::creator_impl<devcb_read16::delegate_builder<read32sm_delegate> >;
+template class devcb_read16::creator_impl<devcb_read16::delegate_builder<read64sm_delegate> >;
+template class devcb_read16::creator_impl<devcb_read16::delegate_builder<read8smo_delegate> >;
+template class devcb_read16::creator_impl<devcb_read16::delegate_builder<read16smo_delegate> >;
+template class devcb_read16::creator_impl<devcb_read16::delegate_builder<read32smo_delegate> >;
+template class devcb_read16::creator_impl<devcb_read16::delegate_builder<read64smo_delegate> >;
 template class devcb_read16::creator_impl<devcb_read16::delegate_builder<read_line_delegate> >;
 template class devcb_read16::creator_impl<devcb_read16::ioport_builder>;
 
@@ -65,6 +150,18 @@ template class devcb_read32::creator_impl<devcb_read32::delegate_builder<read8_d
 template class devcb_read32::creator_impl<devcb_read32::delegate_builder<read16_delegate> >;
 template class devcb_read32::creator_impl<devcb_read32::delegate_builder<read32_delegate> >;
 template class devcb_read32::creator_impl<devcb_read32::delegate_builder<read64_delegate> >;
+template class devcb_read32::creator_impl<devcb_read32::delegate_builder<read8s_delegate> >;
+template class devcb_read32::creator_impl<devcb_read32::delegate_builder<read16s_delegate> >;
+template class devcb_read32::creator_impl<devcb_read32::delegate_builder<read32s_delegate> >;
+template class devcb_read32::creator_impl<devcb_read32::delegate_builder<read64s_delegate> >;
+template class devcb_read32::creator_impl<devcb_read32::delegate_builder<read8sm_delegate> >;
+template class devcb_read32::creator_impl<devcb_read32::delegate_builder<read16sm_delegate> >;
+template class devcb_read32::creator_impl<devcb_read32::delegate_builder<read32sm_delegate> >;
+template class devcb_read32::creator_impl<devcb_read32::delegate_builder<read64sm_delegate> >;
+template class devcb_read32::creator_impl<devcb_read32::delegate_builder<read8smo_delegate> >;
+template class devcb_read32::creator_impl<devcb_read32::delegate_builder<read16smo_delegate> >;
+template class devcb_read32::creator_impl<devcb_read32::delegate_builder<read32smo_delegate> >;
+template class devcb_read32::creator_impl<devcb_read32::delegate_builder<read64smo_delegate> >;
 template class devcb_read32::creator_impl<devcb_read32::delegate_builder<read_line_delegate> >;
 template class devcb_read32::creator_impl<devcb_read32::ioport_builder>;
 
@@ -72,6 +169,18 @@ template class devcb_read64::creator_impl<devcb_read64::delegate_builder<read8_d
 template class devcb_read64::creator_impl<devcb_read64::delegate_builder<read16_delegate> >;
 template class devcb_read64::creator_impl<devcb_read64::delegate_builder<read32_delegate> >;
 template class devcb_read64::creator_impl<devcb_read64::delegate_builder<read64_delegate> >;
+template class devcb_read64::creator_impl<devcb_read64::delegate_builder<read8s_delegate> >;
+template class devcb_read64::creator_impl<devcb_read64::delegate_builder<read16s_delegate> >;
+template class devcb_read64::creator_impl<devcb_read64::delegate_builder<read32s_delegate> >;
+template class devcb_read64::creator_impl<devcb_read64::delegate_builder<read64s_delegate> >;
+template class devcb_read64::creator_impl<devcb_read64::delegate_builder<read8sm_delegate> >;
+template class devcb_read64::creator_impl<devcb_read64::delegate_builder<read16sm_delegate> >;
+template class devcb_read64::creator_impl<devcb_read64::delegate_builder<read32sm_delegate> >;
+template class devcb_read64::creator_impl<devcb_read64::delegate_builder<read64sm_delegate> >;
+template class devcb_read64::creator_impl<devcb_read64::delegate_builder<read8smo_delegate> >;
+template class devcb_read64::creator_impl<devcb_read64::delegate_builder<read16smo_delegate> >;
+template class devcb_read64::creator_impl<devcb_read64::delegate_builder<read32smo_delegate> >;
+template class devcb_read64::creator_impl<devcb_read64::delegate_builder<read64smo_delegate> >;
 template class devcb_read64::creator_impl<devcb_read64::delegate_builder<read_line_delegate> >;
 template class devcb_read64::creator_impl<devcb_read64::ioport_builder>;
 
@@ -79,6 +188,18 @@ template class devcb_read_line::creator_impl<devcb_read_line::delegate_builder<r
 template class devcb_read_line::creator_impl<devcb_read_line::delegate_builder<read16_delegate> >;
 template class devcb_read_line::creator_impl<devcb_read_line::delegate_builder<read32_delegate> >;
 template class devcb_read_line::creator_impl<devcb_read_line::delegate_builder<read64_delegate> >;
+template class devcb_read_line::creator_impl<devcb_read_line::delegate_builder<read8s_delegate> >;
+template class devcb_read_line::creator_impl<devcb_read_line::delegate_builder<read16s_delegate> >;
+template class devcb_read_line::creator_impl<devcb_read_line::delegate_builder<read32s_delegate> >;
+template class devcb_read_line::creator_impl<devcb_read_line::delegate_builder<read64s_delegate> >;
+template class devcb_read_line::creator_impl<devcb_read_line::delegate_builder<read8sm_delegate> >;
+template class devcb_read_line::creator_impl<devcb_read_line::delegate_builder<read16sm_delegate> >;
+template class devcb_read_line::creator_impl<devcb_read_line::delegate_builder<read32sm_delegate> >;
+template class devcb_read_line::creator_impl<devcb_read_line::delegate_builder<read64sm_delegate> >;
+template class devcb_read_line::creator_impl<devcb_read_line::delegate_builder<read8smo_delegate> >;
+template class devcb_read_line::creator_impl<devcb_read_line::delegate_builder<read16smo_delegate> >;
+template class devcb_read_line::creator_impl<devcb_read_line::delegate_builder<read32smo_delegate> >;
+template class devcb_read_line::creator_impl<devcb_read_line::delegate_builder<read64smo_delegate> >;
 template class devcb_read_line::creator_impl<devcb_read_line::delegate_builder<read_line_delegate> >;
 template class devcb_read_line::creator_impl<devcb_read_line::ioport_builder>;
 
@@ -92,36 +213,108 @@ template class devcb_write8::delegate_builder<write8_delegate>;
 template class devcb_write8::delegate_builder<write16_delegate>;
 template class devcb_write8::delegate_builder<write32_delegate>;
 template class devcb_write8::delegate_builder<write64_delegate>;
+template class devcb_write8::delegate_builder<write8s_delegate>;
+template class devcb_write8::delegate_builder<write16s_delegate>;
+template class devcb_write8::delegate_builder<write32s_delegate>;
+template class devcb_write8::delegate_builder<write64s_delegate>;
+template class devcb_write8::delegate_builder<write8sm_delegate>;
+template class devcb_write8::delegate_builder<write16sm_delegate>;
+template class devcb_write8::delegate_builder<write32sm_delegate>;
+template class devcb_write8::delegate_builder<write64sm_delegate>;
+template class devcb_write8::delegate_builder<write8smo_delegate>;
+template class devcb_write8::delegate_builder<write16smo_delegate>;
+template class devcb_write8::delegate_builder<write32smo_delegate>;
+template class devcb_write8::delegate_builder<write64smo_delegate>;
 template class devcb_write8::delegate_builder<write_line_delegate>;
 
 template class devcb_write16::delegate_builder<write8_delegate>;
 template class devcb_write16::delegate_builder<write16_delegate>;
 template class devcb_write16::delegate_builder<write32_delegate>;
 template class devcb_write16::delegate_builder<write64_delegate>;
+template class devcb_write16::delegate_builder<write8s_delegate>;
+template class devcb_write16::delegate_builder<write16s_delegate>;
+template class devcb_write16::delegate_builder<write32s_delegate>;
+template class devcb_write16::delegate_builder<write64s_delegate>;
+template class devcb_write16::delegate_builder<write8sm_delegate>;
+template class devcb_write16::delegate_builder<write16sm_delegate>;
+template class devcb_write16::delegate_builder<write32sm_delegate>;
+template class devcb_write16::delegate_builder<write64sm_delegate>;
+template class devcb_write16::delegate_builder<write8smo_delegate>;
+template class devcb_write16::delegate_builder<write16smo_delegate>;
+template class devcb_write16::delegate_builder<write32smo_delegate>;
+template class devcb_write16::delegate_builder<write64smo_delegate>;
 template class devcb_write16::delegate_builder<write_line_delegate>;
 
 template class devcb_write32::delegate_builder<write8_delegate>;
 template class devcb_write32::delegate_builder<write16_delegate>;
 template class devcb_write32::delegate_builder<write32_delegate>;
 template class devcb_write32::delegate_builder<write64_delegate>;
+template class devcb_write32::delegate_builder<write8s_delegate>;
+template class devcb_write32::delegate_builder<write16s_delegate>;
+template class devcb_write32::delegate_builder<write32s_delegate>;
+template class devcb_write32::delegate_builder<write64s_delegate>;
+template class devcb_write32::delegate_builder<write8sm_delegate>;
+template class devcb_write32::delegate_builder<write16sm_delegate>;
+template class devcb_write32::delegate_builder<write32sm_delegate>;
+template class devcb_write32::delegate_builder<write64sm_delegate>;
+template class devcb_write32::delegate_builder<write8smo_delegate>;
+template class devcb_write32::delegate_builder<write16smo_delegate>;
+template class devcb_write32::delegate_builder<write32smo_delegate>;
+template class devcb_write32::delegate_builder<write64smo_delegate>;
 template class devcb_write32::delegate_builder<write_line_delegate>;
 
 template class devcb_write64::delegate_builder<write8_delegate>;
 template class devcb_write64::delegate_builder<write16_delegate>;
 template class devcb_write64::delegate_builder<write32_delegate>;
 template class devcb_write64::delegate_builder<write64_delegate>;
+template class devcb_write64::delegate_builder<write8s_delegate>;
+template class devcb_write64::delegate_builder<write16s_delegate>;
+template class devcb_write64::delegate_builder<write32s_delegate>;
+template class devcb_write64::delegate_builder<write64s_delegate>;
+template class devcb_write64::delegate_builder<write8sm_delegate>;
+template class devcb_write64::delegate_builder<write16sm_delegate>;
+template class devcb_write64::delegate_builder<write32sm_delegate>;
+template class devcb_write64::delegate_builder<write64sm_delegate>;
+template class devcb_write64::delegate_builder<write8smo_delegate>;
+template class devcb_write64::delegate_builder<write16smo_delegate>;
+template class devcb_write64::delegate_builder<write32smo_delegate>;
+template class devcb_write64::delegate_builder<write64smo_delegate>;
 template class devcb_write64::delegate_builder<write_line_delegate>;
 
 template class devcb_write_line::delegate_builder<write8_delegate>;
 template class devcb_write_line::delegate_builder<write16_delegate>;
 template class devcb_write_line::delegate_builder<write32_delegate>;
 template class devcb_write_line::delegate_builder<write64_delegate>;
+template class devcb_write_line::delegate_builder<write8s_delegate>;
+template class devcb_write_line::delegate_builder<write16s_delegate>;
+template class devcb_write_line::delegate_builder<write32s_delegate>;
+template class devcb_write_line::delegate_builder<write64s_delegate>;
+template class devcb_write_line::delegate_builder<write8sm_delegate>;
+template class devcb_write_line::delegate_builder<write16sm_delegate>;
+template class devcb_write_line::delegate_builder<write32sm_delegate>;
+template class devcb_write_line::delegate_builder<write64sm_delegate>;
+template class devcb_write_line::delegate_builder<write8smo_delegate>;
+template class devcb_write_line::delegate_builder<write16smo_delegate>;
+template class devcb_write_line::delegate_builder<write32smo_delegate>;
+template class devcb_write_line::delegate_builder<write64smo_delegate>;
 template class devcb_write_line::delegate_builder<write_line_delegate>;
 
 template class devcb_write8::creator_impl<devcb_write8::delegate_builder<write8_delegate> >;
 template class devcb_write8::creator_impl<devcb_write8::delegate_builder<write16_delegate> >;
 template class devcb_write8::creator_impl<devcb_write8::delegate_builder<write32_delegate> >;
 template class devcb_write8::creator_impl<devcb_write8::delegate_builder<write64_delegate> >;
+template class devcb_write8::creator_impl<devcb_write8::delegate_builder<write8s_delegate> >;
+template class devcb_write8::creator_impl<devcb_write8::delegate_builder<write16s_delegate> >;
+template class devcb_write8::creator_impl<devcb_write8::delegate_builder<write32s_delegate> >;
+template class devcb_write8::creator_impl<devcb_write8::delegate_builder<write64s_delegate> >;
+template class devcb_write8::creator_impl<devcb_write8::delegate_builder<write8sm_delegate> >;
+template class devcb_write8::creator_impl<devcb_write8::delegate_builder<write16sm_delegate> >;
+template class devcb_write8::creator_impl<devcb_write8::delegate_builder<write32sm_delegate> >;
+template class devcb_write8::creator_impl<devcb_write8::delegate_builder<write64sm_delegate> >;
+template class devcb_write8::creator_impl<devcb_write8::delegate_builder<write8smo_delegate> >;
+template class devcb_write8::creator_impl<devcb_write8::delegate_builder<write16smo_delegate> >;
+template class devcb_write8::creator_impl<devcb_write8::delegate_builder<write32smo_delegate> >;
+template class devcb_write8::creator_impl<devcb_write8::delegate_builder<write64smo_delegate> >;
 template class devcb_write8::creator_impl<devcb_write8::delegate_builder<write_line_delegate> >;
 template class devcb_write8::creator_impl<devcb_write8::inputline_builder>;
 template class devcb_write8::creator_impl<devcb_write8::latched_inputline_builder>;
@@ -134,6 +327,18 @@ template class devcb_write16::creator_impl<devcb_write16::delegate_builder<write
 template class devcb_write16::creator_impl<devcb_write16::delegate_builder<write16_delegate> >;
 template class devcb_write16::creator_impl<devcb_write16::delegate_builder<write32_delegate> >;
 template class devcb_write16::creator_impl<devcb_write16::delegate_builder<write64_delegate> >;
+template class devcb_write16::creator_impl<devcb_write16::delegate_builder<write8s_delegate> >;
+template class devcb_write16::creator_impl<devcb_write16::delegate_builder<write16s_delegate> >;
+template class devcb_write16::creator_impl<devcb_write16::delegate_builder<write32s_delegate> >;
+template class devcb_write16::creator_impl<devcb_write16::delegate_builder<write64s_delegate> >;
+template class devcb_write16::creator_impl<devcb_write16::delegate_builder<write8sm_delegate> >;
+template class devcb_write16::creator_impl<devcb_write16::delegate_builder<write16sm_delegate> >;
+template class devcb_write16::creator_impl<devcb_write16::delegate_builder<write32sm_delegate> >;
+template class devcb_write16::creator_impl<devcb_write16::delegate_builder<write64sm_delegate> >;
+template class devcb_write16::creator_impl<devcb_write16::delegate_builder<write8smo_delegate> >;
+template class devcb_write16::creator_impl<devcb_write16::delegate_builder<write16smo_delegate> >;
+template class devcb_write16::creator_impl<devcb_write16::delegate_builder<write32smo_delegate> >;
+template class devcb_write16::creator_impl<devcb_write16::delegate_builder<write64smo_delegate> >;
 template class devcb_write16::creator_impl<devcb_write16::delegate_builder<write_line_delegate> >;
 template class devcb_write16::creator_impl<devcb_write16::inputline_builder>;
 template class devcb_write16::creator_impl<devcb_write16::latched_inputline_builder>;
@@ -146,6 +351,18 @@ template class devcb_write32::creator_impl<devcb_write32::delegate_builder<write
 template class devcb_write32::creator_impl<devcb_write32::delegate_builder<write16_delegate> >;
 template class devcb_write32::creator_impl<devcb_write32::delegate_builder<write32_delegate> >;
 template class devcb_write32::creator_impl<devcb_write32::delegate_builder<write64_delegate> >;
+template class devcb_write32::creator_impl<devcb_write32::delegate_builder<write8s_delegate> >;
+template class devcb_write32::creator_impl<devcb_write32::delegate_builder<write16s_delegate> >;
+template class devcb_write32::creator_impl<devcb_write32::delegate_builder<write32s_delegate> >;
+template class devcb_write32::creator_impl<devcb_write32::delegate_builder<write64s_delegate> >;
+template class devcb_write32::creator_impl<devcb_write32::delegate_builder<write8sm_delegate> >;
+template class devcb_write32::creator_impl<devcb_write32::delegate_builder<write16sm_delegate> >;
+template class devcb_write32::creator_impl<devcb_write32::delegate_builder<write32sm_delegate> >;
+template class devcb_write32::creator_impl<devcb_write32::delegate_builder<write64sm_delegate> >;
+template class devcb_write32::creator_impl<devcb_write32::delegate_builder<write8smo_delegate> >;
+template class devcb_write32::creator_impl<devcb_write32::delegate_builder<write16smo_delegate> >;
+template class devcb_write32::creator_impl<devcb_write32::delegate_builder<write32smo_delegate> >;
+template class devcb_write32::creator_impl<devcb_write32::delegate_builder<write64smo_delegate> >;
 template class devcb_write32::creator_impl<devcb_write32::delegate_builder<write_line_delegate> >;
 template class devcb_write32::creator_impl<devcb_write32::inputline_builder>;
 template class devcb_write32::creator_impl<devcb_write32::latched_inputline_builder>;
@@ -158,6 +375,18 @@ template class devcb_write64::creator_impl<devcb_write64::delegate_builder<write
 template class devcb_write64::creator_impl<devcb_write64::delegate_builder<write16_delegate> >;
 template class devcb_write64::creator_impl<devcb_write64::delegate_builder<write32_delegate> >;
 template class devcb_write64::creator_impl<devcb_write64::delegate_builder<write64_delegate> >;
+template class devcb_write64::creator_impl<devcb_write64::delegate_builder<write8s_delegate> >;
+template class devcb_write64::creator_impl<devcb_write64::delegate_builder<write16s_delegate> >;
+template class devcb_write64::creator_impl<devcb_write64::delegate_builder<write32s_delegate> >;
+template class devcb_write64::creator_impl<devcb_write64::delegate_builder<write64s_delegate> >;
+template class devcb_write64::creator_impl<devcb_write64::delegate_builder<write8sm_delegate> >;
+template class devcb_write64::creator_impl<devcb_write64::delegate_builder<write16sm_delegate> >;
+template class devcb_write64::creator_impl<devcb_write64::delegate_builder<write32sm_delegate> >;
+template class devcb_write64::creator_impl<devcb_write64::delegate_builder<write64sm_delegate> >;
+template class devcb_write64::creator_impl<devcb_write64::delegate_builder<write8smo_delegate> >;
+template class devcb_write64::creator_impl<devcb_write64::delegate_builder<write16smo_delegate> >;
+template class devcb_write64::creator_impl<devcb_write64::delegate_builder<write32smo_delegate> >;
+template class devcb_write64::creator_impl<devcb_write64::delegate_builder<write64smo_delegate> >;
 template class devcb_write64::creator_impl<devcb_write64::delegate_builder<write_line_delegate> >;
 template class devcb_write64::creator_impl<devcb_write64::inputline_builder>;
 template class devcb_write64::creator_impl<devcb_write64::latched_inputline_builder>;
@@ -170,6 +399,18 @@ template class devcb_write_line::creator_impl<devcb_write_line::delegate_builder
 template class devcb_write_line::creator_impl<devcb_write_line::delegate_builder<write16_delegate> >;
 template class devcb_write_line::creator_impl<devcb_write_line::delegate_builder<write32_delegate> >;
 template class devcb_write_line::creator_impl<devcb_write_line::delegate_builder<write64_delegate> >;
+template class devcb_write_line::creator_impl<devcb_write_line::delegate_builder<write8s_delegate> >;
+template class devcb_write_line::creator_impl<devcb_write_line::delegate_builder<write16s_delegate> >;
+template class devcb_write_line::creator_impl<devcb_write_line::delegate_builder<write32s_delegate> >;
+template class devcb_write_line::creator_impl<devcb_write_line::delegate_builder<write64s_delegate> >;
+template class devcb_write_line::creator_impl<devcb_write_line::delegate_builder<write8sm_delegate> >;
+template class devcb_write_line::creator_impl<devcb_write_line::delegate_builder<write16sm_delegate> >;
+template class devcb_write_line::creator_impl<devcb_write_line::delegate_builder<write32sm_delegate> >;
+template class devcb_write_line::creator_impl<devcb_write_line::delegate_builder<write64sm_delegate> >;
+template class devcb_write_line::creator_impl<devcb_write_line::delegate_builder<write8smo_delegate> >;
+template class devcb_write_line::creator_impl<devcb_write_line::delegate_builder<write16smo_delegate> >;
+template class devcb_write_line::creator_impl<devcb_write_line::delegate_builder<write32smo_delegate> >;
+template class devcb_write_line::creator_impl<devcb_write_line::delegate_builder<write64smo_delegate> >;
 template class devcb_write_line::creator_impl<devcb_write_line::delegate_builder<write_line_delegate> >;
 template class devcb_write_line::creator_impl<devcb_write_line::inputline_builder>;
 template class devcb_write_line::creator_impl<devcb_write_line::latched_inputline_builder>;
diff --git a/src/emu/devcb.h b/src/emu/devcb.h
index 4d858f8b82a..f535b9db84e 100644
--- a/src/emu/devcb.h
+++ b/src/emu/devcb.h
@@ -116,33 +116,12 @@ namespace emu { namespace detail {
 template <typename T, typename Enable = void> struct read_line_device_class { };
 template <typename T, typename Enable = void> struct write_line_device_class { };
 
-template <typename T, typename Ret, typename... Params>
-struct read_line_device_class<Ret (T::*)(Params...), std::enable_if_t<std::is_constructible<read_line_delegate, Ret (T::*)(Params...), char const *, char const *, T *>::value> > { using type = T; };
-template <typename T, typename Ret, typename... Params>
-struct read_line_device_class<Ret (T::*)(Params...) const, std::enable_if_t<std::is_constructible<read_line_delegate, Ret (T::*)(Params...) const, char const *, char const *, T *>::value> > { using type = T; };
-template <typename T, typename Ret, typename... Params>
-struct read_line_device_class<Ret (*)(T &, Params...), std::enable_if_t<std::is_constructible<read_line_delegate, Ret (*)(T &, Params...), char const *, char const *, T *>::value> > { using type = T; };
-template <typename T, typename Ret, typename... Params>
-struct read_line_device_class<Ret (*)(T *, Params...), std::enable_if_t<std::is_constructible<read_line_delegate, Ret (*)(T *, Params...), char const *, char const *, T *>::value> > { using type = T; };
-
-template <typename T, typename Ret, typename... Params>
-struct write_line_device_class<Ret (T::*)(Params...), std::enable_if_t<std::is_constructible<write_line_delegate, Ret (T::*)(Params...), char const *, char const *, T *>::value> > { using type = T; };
-template <typename T, typename Ret, typename... Params>
-struct write_line_device_class<Ret (T::*)(Params...) const, std::enable_if_t<std::is_constructible<write_line_delegate, Ret (T::*)(Params...) const, char const *, char const *, T *>::value> > { using type = T; };
-template <typename T, typename Ret, typename... Params>
-struct write_line_device_class<Ret (*)(T &, Params...), std::enable_if_t<std::is_constructible<write_line_delegate, Ret (*)(T &, Params...), char const *, char const *, T *>::value> > { using type = T; };
-template <typename T, typename Ret, typename... Params>
-struct write_line_device_class<Ret (*)(T *, Params...), std::enable_if_t<std::is_constructible<write_line_delegate, Ret (*)(T *, Params...), char const *, char const *, T *>::value> > { using type = T; };
-
-template <typename T> using read_line_device_class_t = typename read_line_device_class<T>::type;
-template <typename T> using write_line_device_class_t = typename write_line_device_class<T>::type;
-
 template <typename T>
-inline read_line_delegate make_delegate(T &&func, char const *name, char const *tag, read_line_device_class_t<std::remove_reference_t<T> > *obj)
+inline read_line_delegate make_delegate(T &&func, char const *name, char const *tag, rw_device_class_t<read_line_delegate, std::remove_reference_t<T> > *obj)
 { return read_line_delegate(func, name, tag, obj); }
 
 template <typename T>
-inline write_line_delegate make_delegate(T &&func, char const *name, char const *tag, write_line_device_class_t<std::remove_reference_t<T> > *obj)
+inline write_line_delegate make_delegate(T &&func, char const *name, char const *tag, rw_device_class_t<write_line_delegate, std::remove_reference_t<T> > *obj)
 { return write_line_delegate(func, name, tag, obj); }
 
 } } // namespace emu::detail
@@ -210,11 +189,35 @@ protected:
 	template <typename T> struct delegate_type<T, void_t<emu::detail::rw_device_class_t<read16_delegate, std::remove_reference_t<T> > > > { using type = read16_delegate; using device_class = emu::detail::rw_device_class_t<type, std::remove_reference_t<T> >; };
 	template <typename T> struct delegate_type<T, void_t<emu::detail::rw_device_class_t<read32_delegate, std::remove_reference_t<T> > > > { using type = read32_delegate; using device_class = emu::detail::rw_device_class_t<type, std::remove_reference_t<T> >; };
 	template <typename T> struct delegate_type<T, void_t<emu::detail::rw_device_class_t<read64_delegate, std::remove_reference_t<T> > > > { using type = read64_delegate; using device_class = emu::detail::rw_device_class_t<type, std::remove_reference_t<T> >; };
+	template <typename T> struct delegate_type<T, void_t<emu::detail::rw_device_class_t<read8s_delegate, std::remove_reference_t<T> > > > { using type = read8s_delegate; using device_class = emu::detail::rw_device_class_t<type, std::remove_reference_t<T> >; };
+	template <typename T> struct delegate_type<T, void_t<emu::detail::rw_device_class_t<read16s_delegate, std::remove_reference_t<T> > > > { using type = read16s_delegate; using device_class = emu::detail::rw_device_class_t<type, std::remove_reference_t<T> >; };
+	template <typename T> struct delegate_type<T, void_t<emu::detail::rw_device_class_t<read32s_delegate, std::remove_reference_t<T> > > > { using type = read32s_delegate; using device_class = emu::detail::rw_device_class_t<type, std::remove_reference_t<T> >; };
+	template <typename T> struct delegate_type<T, void_t<emu::detail::rw_device_class_t<read64s_delegate, std::remove_reference_t<T> > > > { using type = read64s_delegate; using device_class = emu::detail::rw_device_class_t<type, std::remove_reference_t<T> >; };
+	template <typename T> struct delegate_type<T, void_t<emu::detail::rw_device_class_t<read8sm_delegate, std::remove_reference_t<T> > > > { using type = read8sm_delegate; using device_class = emu::detail::rw_device_class_t<type, std::remove_reference_t<T> >; };
+	template <typename T> struct delegate_type<T, void_t<emu::detail::rw_device_class_t<read16sm_delegate, std::remove_reference_t<T> > > > { using type = read16sm_delegate; using device_class = emu::detail::rw_device_class_t<type, std::remove_reference_t<T> >; };
+	template <typename T> struct delegate_type<T, void_t<emu::detail::rw_device_class_t<read32sm_delegate, std::remove_reference_t<T> > > > { using type = read32sm_delegate; using device_class = emu::detail::rw_device_class_t<type, std::remove_reference_t<T> >; };
+	template <typename T> struct delegate_type<T, void_t<emu::detail::rw_device_class_t<read64sm_delegate, std::remove_reference_t<T> > > > { using type = read64sm_delegate; using device_class = emu::detail::rw_device_class_t<type, std::remove_reference_t<T> >; };
+	template <typename T> struct delegate_type<T, void_t<emu::detail::rw_device_class_t<read8smo_delegate, std::remove_reference_t<T> > > > { using type = read8smo_delegate; using device_class = emu::detail::rw_device_class_t<type, std::remove_reference_t<T> >; };
+	template <typename T> struct delegate_type<T, void_t<emu::detail::rw_device_class_t<read16smo_delegate, std::remove_reference_t<T> > > > { using type = read16smo_delegate; using device_class = emu::detail::rw_device_class_t<type, std::remove_reference_t<T> >; };
+	template <typename T> struct delegate_type<T, void_t<emu::detail::rw_device_class_t<read32smo_delegate, std::remove_reference_t<T> > > > { using type = read32smo_delegate; using device_class = emu::detail::rw_device_class_t<type, std::remove_reference_t<T> >; };
+	template <typename T> struct delegate_type<T, void_t<emu::detail::rw_device_class_t<read64smo_delegate, std::remove_reference_t<T> > > > { using type = read64smo_delegate; using device_class = emu::detail::rw_device_class_t<type, std::remove_reference_t<T> >; };
 	template <typename T> struct delegate_type<T, void_t<emu::detail::rw_device_class_t<read_line_delegate, std::remove_reference_t<T> > > > { using type = read_line_delegate; using device_class = emu::detail::rw_device_class_t<type, std::remove_reference_t<T> >; };
 	template <typename T> struct delegate_type<T, void_t<emu::detail::rw_device_class_t<write8_delegate, std::remove_reference_t<T> > > > { using type = write8_delegate; using device_class = emu::detail::rw_device_class_t<type, std::remove_reference_t<T> >; };
 	template <typename T> struct delegate_type<T, void_t<emu::detail::rw_device_class_t<write16_delegate, std::remove_reference_t<T> > > > { using type = write16_delegate; using device_class = emu::detail::rw_device_class_t<type, std::remove_reference_t<T> >; };
 	template <typename T> struct delegate_type<T, void_t<emu::detail::rw_device_class_t<write32_delegate, std::remove_reference_t<T> > > > { using type = write32_delegate; using device_class = emu::detail::rw_device_class_t<type, std::remove_reference_t<T> >; };
 	template <typename T> struct delegate_type<T, void_t<emu::detail::rw_device_class_t<write64_delegate, std::remove_reference_t<T> > > > { using type = write64_delegate; using device_class = emu::detail::rw_device_class_t<type, std::remove_reference_t<T> >; };
+	template <typename T> struct delegate_type<T, void_t<emu::detail::rw_device_class_t<write8s_delegate, std::remove_reference_t<T> > > > { using type = write8s_delegate; using device_class = emu::detail::rw_device_class_t<type, std::remove_reference_t<T> >; };
+	template <typename T> struct delegate_type<T, void_t<emu::detail::rw_device_class_t<write16s_delegate, std::remove_reference_t<T> > > > { using type = write16s_delegate; using device_class = emu::detail::rw_device_class_t<type, std::remove_reference_t<T> >; };
+	template <typename T> struct delegate_type<T, void_t<emu::detail::rw_device_class_t<write32s_delegate, std::remove_reference_t<T> > > > { using type = write32s_delegate; using device_class = emu::detail::rw_device_class_t<type, std::remove_reference_t<T> >; };
+	template <typename T> struct delegate_type<T, void_t<emu::detail::rw_device_class_t<write64s_delegate, std::remove_reference_t<T> > > > { using type = write64s_delegate; using device_class = emu::detail::rw_device_class_t<type, std::remove_reference_t<T> >; };
+	template <typename T> struct delegate_type<T, void_t<emu::detail::rw_device_class_t<write8sm_delegate, std::remove_reference_t<T> > > > { using type = write8sm_delegate; using device_class = emu::detail::rw_device_class_t<type, std::remove_reference_t<T> >; };
+	template <typename T> struct delegate_type<T, void_t<emu::detail::rw_device_class_t<write16sm_delegate, std::remove_reference_t<T> > > > { using type = write16sm_delegate; using device_class = emu::detail::rw_device_class_t<type, std::remove_reference_t<T> >; };
+	template <typename T> struct delegate_type<T, void_t<emu::detail::rw_device_class_t<write32sm_delegate, std::remove_reference_t<T> > > > { using type = write32sm_delegate; using device_class = emu::detail::rw_device_class_t<type, std::remove_reference_t<T> >; };
+	template <typename T> struct delegate_type<T, void_t<emu::detail::rw_device_class_t<write64sm_delegate, std::remove_reference_t<T> > > > { using type = write64sm_delegate; using device_class = emu::detail::rw_device_class_t<type, std::remove_reference_t<T> >; };
+	template <typename T> struct delegate_type<T, void_t<emu::detail::rw_device_class_t<write8smo_delegate, std::remove_reference_t<T> > > > { using type = write8smo_delegate; using device_class = emu::detail::rw_device_class_t<type, std::remove_reference_t<T> >; };
+	template <typename T> struct delegate_type<T, void_t<emu::detail::rw_device_class_t<write16smo_delegate, std::remove_reference_t<T> > > > { using type = write16smo_delegate; using device_class = emu::detail::rw_device_class_t<type, std::remove_reference_t<T> >; };
+	template <typename T> struct delegate_type<T, void_t<emu::detail::rw_device_class_t<write32smo_delegate, std::remove_reference_t<T> > > > { using type = write32smo_delegate; using device_class = emu::detail::rw_device_class_t<type, std::remove_reference_t<T> >; };
+	template <typename T> struct delegate_type<T, void_t<emu::detail::rw_device_class_t<write64smo_delegate, std::remove_reference_t<T> > > > { using type = write64smo_delegate; using device_class = emu::detail::rw_device_class_t<type, std::remove_reference_t<T> >; };
 	template <typename T> struct delegate_type<T, void_t<emu::detail::rw_device_class_t<write_line_delegate, std::remove_reference_t<T> > > > { using type = write_line_delegate; using device_class = emu::detail::rw_device_class_t<type, std::remove_reference_t<T> >; };
 	template <typename T> using delegate_type_t = typename delegate_type<T>::type;
 	template <typename T> using delegate_device_class_t = typename delegate_type<T>::device_class;
@@ -334,6 +337,18 @@ protected:
 	template <typename T> struct is_read_method<T, void_t<emu::detail::rw_device_class_t<read16_delegate, std::remove_reference_t<T> > > > { static constexpr bool value = true; };
 	template <typename T> struct is_read_method<T, void_t<emu::detail::rw_device_class_t<read32_delegate, std::remove_reference_t<T> > > > { static constexpr bool value = true; };
 	template <typename T> struct is_read_method<T, void_t<emu::detail::rw_device_class_t<read64_delegate, std::remove_reference_t<T> > > > { static constexpr bool value = true; };
+	template <typename T> struct is_read_method<T, void_t<emu::detail::rw_device_class_t<read8s_delegate, std::remove_reference_t<T> > > > { static constexpr bool value = true; };
+	template <typename T> struct is_read_method<T, void_t<emu::detail::rw_device_class_t<read16s_delegate, std::remove_reference_t<T> > > > { static constexpr bool value = true; };
+	template <typename T> struct is_read_method<T, void_t<emu::detail::rw_device_class_t<read32s_delegate, std::remove_reference_t<T> > > > { static constexpr bool value = true; };
+	template <typename T> struct is_read_method<T, void_t<emu::detail::rw_device_class_t<read64s_delegate, std::remove_reference_t<T> > > > { static constexpr bool value = true; };
+	template <typename T> struct is_read_method<T, void_t<emu::detail::rw_device_class_t<read8sm_delegate, std::remove_reference_t<T> > > > { static constexpr bool value = true; };
+	template <typename T> struct is_read_method<T, void_t<emu::detail::rw_device_class_t<read16sm_delegate, std::remove_reference_t<T> > > > { static constexpr bool value = true; };
+	template <typename T> struct is_read_method<T, void_t<emu::detail::rw_device_class_t<read32sm_delegate, std::remove_reference_t<T> > > > { static constexpr bool value = true; };
+	template <typename T> struct is_read_method<T, void_t<emu::detail::rw_device_class_t<read64sm_delegate, std::remove_reference_t<T> > > > { static constexpr bool value = true; };
+	template <typename T> struct is_read_method<T, void_t<emu::detail::rw_device_class_t<read8smo_delegate, std::remove_reference_t<T> > > > { static constexpr bool value = true; };
+	template <typename T> struct is_read_method<T, void_t<emu::detail::rw_device_class_t<read16smo_delegate, std::remove_reference_t<T> > > > { static constexpr bool value = true; };
+	template <typename T> struct is_read_method<T, void_t<emu::detail::rw_device_class_t<read32smo_delegate, std::remove_reference_t<T> > > > { static constexpr bool value = true; };
+	template <typename T> struct is_read_method<T, void_t<emu::detail::rw_device_class_t<read64smo_delegate, std::remove_reference_t<T> > > > { static constexpr bool value = true; };
 	template <typename T> struct is_read_method<T, void_t<emu::detail::rw_device_class_t<read_line_delegate, std::remove_reference_t<T> > > > { static constexpr bool value = true; };
 
 	// Invoking read callbacks
@@ -350,6 +365,18 @@ protected:
 	template <typename Dummy> struct delegate_traits<read16_delegate, Dummy> { static constexpr u16 default_mask = ~u16(0); };
 	template <typename Dummy> struct delegate_traits<read32_delegate, Dummy> { static constexpr u32 default_mask = ~u32(0); };
 	template <typename Dummy> struct delegate_traits<read64_delegate, Dummy> { static constexpr u64 default_mask = ~u64(0); };
+	template <typename Dummy> struct delegate_traits<read8s_delegate, Dummy> { static constexpr u8 default_mask = ~u8(0); };
+	template <typename Dummy> struct delegate_traits<read16s_delegate, Dummy> { static constexpr u16 default_mask = ~u16(0); };
+	template <typename Dummy> struct delegate_traits<read32s_delegate, Dummy> { static constexpr u32 default_mask = ~u32(0); };
+	template <typename Dummy> struct delegate_traits<read64s_delegate, Dummy> { static constexpr u64 default_mask = ~u64(0); };
+	template <typename Dummy> struct delegate_traits<read8sm_delegate, Dummy> { static constexpr u8 default_mask = ~u8(0); };
+	template <typename Dummy> struct delegate_traits<read16sm_delegate, Dummy> { static constexpr u16 default_mask = ~u16(0); };
+	template <typename Dummy> struct delegate_traits<read32sm_delegate, Dummy> { static constexpr u32 default_mask = ~u32(0); };
+	template <typename Dummy> struct delegate_traits<read64sm_delegate, Dummy> { static constexpr u64 default_mask = ~u64(0); };
+	template <typename Dummy> struct delegate_traits<read8smo_delegate, Dummy> { static constexpr u8 default_mask = ~u8(0); };
+	template <typename Dummy> struct delegate_traits<read16smo_delegate, Dummy> { static constexpr u16 default_mask = ~u16(0); };
+	template <typename Dummy> struct delegate_traits<read32smo_delegate, Dummy> { static constexpr u32 default_mask = ~u32(0); };
+	template <typename Dummy> struct delegate_traits<read64smo_delegate, Dummy> { static constexpr u64 default_mask = ~u64(0); };
 	template <typename Dummy> struct delegate_traits<read_line_delegate, Dummy> { static constexpr unsigned default_mask = 1U; };
 
 	using devcb_base::devcb_base;
@@ -384,11 +411,23 @@ protected:
 	template <typename T> struct is_write_method<T, void_t<emu::detail::rw_device_class_t<write16_delegate, std::remove_reference_t<T> > > > { static constexpr bool value = true; };
 	template <typename T> struct is_write_method<T, void_t<emu::detail::rw_device_class_t<write32_delegate, std::remove_reference_t<T> > > > { static constexpr bool value = true; };
 	template <typename T> struct is_write_method<T, void_t<emu::detail::rw_device_class_t<write64_delegate, std::remove_reference_t<T> > > > { static constexpr bool value = true; };
+	template <typename T> struct is_write_method<T, void_t<emu::detail::rw_device_class_t<write8s_delegate, std::remove_reference_t<T> > > > { static constexpr bool value = true; };
+	template <typename T> struct is_write_method<T, void_t<emu::detail::rw_device_class_t<write16s_delegate, std::remove_reference_t<T> > > > { static constexpr bool value = true; };
+	template <typename T> struct is_write_method<T, void_t<emu::detail::rw_device_class_t<write32s_delegate, std::remove_reference_t<T> > > > { static constexpr bool value = true; };
+	template <typename T> struct is_write_method<T, void_t<emu::detail::rw_device_class_t<write64s_delegate, std::remove_reference_t<T> > > > { static constexpr bool value = true; };
+	template <typename T> struct is_write_method<T, void_t<emu::detail::rw_device_class_t<write8sm_delegate, std::remove_reference_t<T> > > > { static constexpr bool value = true; };
+	template <typename T> struct is_write_method<T, void_t<emu::detail::rw_device_class_t<write16sm_delegate, std::remove_reference_t<T> > > > { static constexpr bool value = true; };
+	template <typename T> struct is_write_method<T, void_t<emu::detail::rw_device_class_t<write32sm_delegate, std::remove_reference_t<T> > > > { static constexpr bool value = true; };
+	template <typename T> struct is_write_method<T, void_t<emu::detail::rw_device_class_t<write64sm_delegate, std::remove_reference_t<T> > > > { static constexpr bool value = true; };
+	template <typename T> struct is_write_method<T, void_t<emu::detail::rw_device_class_t<write8smo_delegate, std::remove_reference_t<T> > > > { static constexpr bool value = true; };
+	template <typename T> struct is_write_method<T, void_t<emu::detail::rw_device_class_t<write16smo_delegate, std::remove_reference_t<T> > > > { static constexpr bool value = true; };
+	template <typename T> struct is_write_method<T, void_t<emu::detail::rw_device_class_t<write32smo_delegate, std::remove_reference_t<T> > > > { static constexpr bool value = true; };
+	template <typename T> struct is_write_method<T, void_t<emu::detail::rw_device_class_t<write64smo_delegate, std::remove_reference_t<T> > > > { static constexpr bool value = true; };
 	template <typename T> struct is_write_method<T, void_t<emu::detail::rw_device_class_t<write_line_delegate, std::remove_reference_t<T> > > > { static constexpr bool value = true; };
 
 	// Invoking write callbacks
 	template <typename Input, typename T> static std::enable_if_t<is_write_form1<Input, T>::value> invoke_write(T const &cb, address_space &space, offs_t &offset, Input data, std::make_unsigned_t<Input> mem_mask) { return cb(space, offset, data, mem_mask); }
-	template <typename Input, typename T> static std::enable_if_t<is_write_form2<Input, T>::value> invoke_write(T const &cb, address_space &space, offs_t &offset, Input data, std::make_unsigned_t<Input> mem_mask) { return cb(space, data, offset); }
+	template <typename Input, typename T> static std::enable_if_t<is_write_form2<Input, T>::value> invoke_write(T const &cb, address_space &space, offs_t &offset, Input data, std::make_unsigned_t<Input> mem_mask) { return cb(space, offset, data); }
 	template <typename Input, typename T> static std::enable_if_t<is_write_form3<Input, T>::value> invoke_write(T const &cb, address_space &space, offs_t &offset, Input data, std::make_unsigned_t<Input> mem_mask) { return cb(offset, data, mem_mask); }
 	template <typename Input, typename T> static std::enable_if_t<is_write_form4<Input, T>::value> invoke_write(T const &cb, address_space &space, offs_t &offset, Input data, std::make_unsigned_t<Input> mem_mask) { return cb(offset, data); }
 	template <typename Input, typename T> static std::enable_if_t<is_write_form5<Input, T>::value> invoke_write(T const &cb, address_space &space, offs_t &offset, Input data, std::make_unsigned_t<Input> mem_mask) { return cb(space, data); }
@@ -400,6 +439,18 @@ protected:
 	template <typename Dummy> struct delegate_traits<write16_delegate, Dummy> { using input_t = u16; static constexpr u16 default_mask = ~u16(0); };
 	template <typename Dummy> struct delegate_traits<write32_delegate, Dummy> { using input_t = u32; static constexpr u32 default_mask = ~u32(0); };
 	template <typename Dummy> struct delegate_traits<write64_delegate, Dummy> { using input_t = u64; static constexpr u64 default_mask = ~u64(0); };
+	template <typename Dummy> struct delegate_traits<write8s_delegate, Dummy> { using input_t = u8; static constexpr u8 default_mask = ~u8(0); };
+	template <typename Dummy> struct delegate_traits<write16s_delegate, Dummy> { using input_t = u16; static constexpr u16 default_mask = ~u16(0); };
+	template <typename Dummy> struct delegate_traits<write32s_delegate, Dummy> { using input_t = u32; static constexpr u32 default_mask = ~u32(0); };
+	template <typename Dummy> struct delegate_traits<write64s_delegate, Dummy> { using input_t = u64; static constexpr u64 default_mask = ~u64(0); };
+	template <typename Dummy> struct delegate_traits<write8sm_delegate, Dummy> { using input_t = u8; static constexpr u8 default_mask = ~u8(0); };
+	template <typename Dummy> struct delegate_traits<write16sm_delegate, Dummy> { using input_t = u16; static constexpr u16 default_mask = ~u16(0); };
+	template <typename Dummy> struct delegate_traits<write32sm_delegate, Dummy> { using input_t = u32; static constexpr u32 default_mask = ~u32(0); };
+	template <typename Dummy> struct delegate_traits<write64sm_delegate, Dummy> { using input_t = u64; static constexpr u64 default_mask = ~u64(0); };
+	template <typename Dummy> struct delegate_traits<write8smo_delegate, Dummy> { using input_t = u8; static constexpr u8 default_mask = ~u8(0); };
+	template <typename Dummy> struct delegate_traits<write16smo_delegate, Dummy> { using input_t = u16; static constexpr u16 default_mask = ~u16(0); };
+	template <typename Dummy> struct delegate_traits<write32smo_delegate, Dummy> { using input_t = u32; static constexpr u32 default_mask = ~u32(0); };
+	template <typename Dummy> struct delegate_traits<write64smo_delegate, Dummy> { using input_t = u64; static constexpr u64 default_mask = ~u64(0); };
 	template <typename Dummy> struct delegate_traits<write_line_delegate, Dummy> { using input_t = int; static constexpr unsigned default_mask = 1U; };
 
 	using devcb_base::devcb_base;
@@ -2529,36 +2580,108 @@ extern template class devcb_read8::delegate_builder<read8_delegate>;
 extern template class devcb_read8::delegate_builder<read16_delegate>;
 extern template class devcb_read8::delegate_builder<read32_delegate>;
 extern template class devcb_read8::delegate_builder<read64_delegate>;
+extern template class devcb_read8::delegate_builder<read8s_delegate>;
+extern template class devcb_read8::delegate_builder<read16s_delegate>;
+extern template class devcb_read8::delegate_builder<read32s_delegate>;
+extern template class devcb_read8::delegate_builder<read64s_delegate>;
+extern template class devcb_read8::delegate_builder<read8sm_delegate>;
+extern template class devcb_read8::delegate_builder<read16sm_delegate>;
+extern template class devcb_read8::delegate_builder<read32sm_delegate>;
+extern template class devcb_read8::delegate_builder<read64sm_delegate>;
+extern template class devcb_read8::delegate_builder<read8smo_delegate>;
+extern template class devcb_read8::delegate_builder<read16smo_delegate>;
+extern template class devcb_read8::delegate_builder<read32smo_delegate>;
+extern template class devcb_read8::delegate_builder<read64smo_delegate>;
 extern template class devcb_read8::delegate_builder<read_line_delegate>;
 
 extern template class devcb_read16::delegate_builder<read8_delegate>;
 extern template class devcb_read16::delegate_builder<read16_delegate>;
 extern template class devcb_read16::delegate_builder<read32_delegate>;
 extern template class devcb_read16::delegate_builder<read64_delegate>;
+extern template class devcb_read16::delegate_builder<read8s_delegate>;
+extern template class devcb_read16::delegate_builder<read16s_delegate>;
+extern template class devcb_read16::delegate_builder<read32s_delegate>;
+extern template class devcb_read16::delegate_builder<read64s_delegate>;
+extern template class devcb_read16::delegate_builder<read8sm_delegate>;
+extern template class devcb_read16::delegate_builder<read16sm_delegate>;
+extern template class devcb_read16::delegate_builder<read32sm_delegate>;
+extern template class devcb_read16::delegate_builder<read64sm_delegate>;
+extern template class devcb_read16::delegate_builder<read8smo_delegate>;
+extern template class devcb_read16::delegate_builder<read16smo_delegate>;
+extern template class devcb_read16::delegate_builder<read32smo_delegate>;
+extern template class devcb_read16::delegate_builder<read64smo_delegate>;
 extern template class devcb_read16::delegate_builder<read_line_delegate>;
 
 extern template class devcb_read32::delegate_builder<read8_delegate>;
 extern template class devcb_read32::delegate_builder<read16_delegate>;
 extern template class devcb_read32::delegate_builder<read32_delegate>;
 extern template class devcb_read32::delegate_builder<read64_delegate>;
+extern template class devcb_read32::delegate_builder<read8s_delegate>;
+extern template class devcb_read32::delegate_builder<read16s_delegate>;
+extern template class devcb_read32::delegate_builder<read32s_delegate>;
+extern template class devcb_read32::delegate_builder<read64s_delegate>;
+extern template class devcb_read32::delegate_builder<read8sm_delegate>;
+extern template class devcb_read32::delegate_builder<read16sm_delegate>;
+extern template class devcb_read32::delegate_builder<read32sm_delegate>;
+extern template class devcb_read32::delegate_builder<read64sm_delegate>;
+extern template class devcb_read32::delegate_builder<read8smo_delegate>;
+extern template class devcb_read32::delegate_builder<read16smo_delegate>;
+extern template class devcb_read32::delegate_builder<read32smo_delegate>;
+extern template class devcb_read32::delegate_builder<read64smo_delegate>;
 extern template class devcb_read32::delegate_builder<read_line_delegate>;
 
 extern template class devcb_read64::delegate_builder<read8_delegate>;
 extern template class devcb_read64::delegate_builder<read16_delegate>;
 extern template class devcb_read64::delegate_builder<read32_delegate>;
 extern template class devcb_read64::delegate_builder<read64_delegate>;
+extern template class devcb_read64::delegate_builder<read8s_delegate>;
+extern template class devcb_read64::delegate_builder<read16s_delegate>;
+extern template class devcb_read64::delegate_builder<read32s_delegate>;
+extern template class devcb_read64::delegate_builder<read64s_delegate>;
+extern template class devcb_read64::delegate_builder<read8sm_delegate>;
+extern template class devcb_read64::delegate_builder<read16sm_delegate>;
+extern template class devcb_read64::delegate_builder<read32sm_delegate>;
+extern template class devcb_read64::delegate_builder<read64sm_delegate>;
+extern template class devcb_read64::delegate_builder<read8smo_delegate>;
+extern template class devcb_read64::delegate_builder<read16smo_delegate>;
+extern template class devcb_read64::delegate_builder<read32smo_delegate>;
+extern template class devcb_read64::delegate_builder<read64smo_delegate>;
 extern template class devcb_read64::delegate_builder<read_line_delegate>;
 
 extern template class devcb_read_line::delegate_builder<read8_delegate>;
 extern template class devcb_read_line::delegate_builder<read16_delegate>;
 extern template class devcb_read_line::delegate_builder<read32_delegate>;
 extern template class devcb_read_line::delegate_builder<read64_delegate>;
+extern template class devcb_read_line::delegate_builder<read8s_delegate>;
+extern template class devcb_read_line::delegate_builder<read16s_delegate>;
+extern template class devcb_read_line::delegate_builder<read32s_delegate>;
+extern template class devcb_read_line::delegate_builder<read64s_delegate>;
+extern template class devcb_read_line::delegate_builder<read8sm_delegate>;
+extern template class devcb_read_line::delegate_builder<read16sm_delegate>;
+extern template class devcb_read_line::delegate_builder<read32sm_delegate>;
+extern template class devcb_read_line::delegate_builder<read64sm_delegate>;
+extern template class devcb_read_line::delegate_builder<read8smo_delegate>;
+extern template class devcb_read_line::delegate_builder<read16smo_delegate>;
+extern template class devcb_read_line::delegate_builder<read32smo_delegate>;
+extern template class devcb_read_line::delegate_builder<read64smo_delegate>;
 extern template class devcb_read_line::delegate_builder<read_line_delegate>;
 
 extern template class devcb_read8::creator_impl<devcb_read8::delegate_builder<read8_delegate> >;
 extern template class devcb_read8::creator_impl<devcb_read8::delegate_builder<read16_delegate> >;
 extern template class devcb_read8::creator_impl<devcb_read8::delegate_builder<read32_delegate> >;
 extern template class devcb_read8::creator_impl<devcb_read8::delegate_builder<read64_delegate> >;
+extern template class devcb_read8::creator_impl<devcb_read8::delegate_builder<read8s_delegate> >;
+extern template class devcb_read8::creator_impl<devcb_read8::delegate_builder<read16s_delegate> >;
+extern template class devcb_read8::creator_impl<devcb_read8::delegate_builder<read32s_delegate> >;
+extern template class devcb_read8::creator_impl<devcb_read8::delegate_builder<read64s_delegate> >;
+extern template class devcb_read8::creator_impl<devcb_read8::delegate_builder<read8sm_delegate> >;
+extern template class devcb_read8::creator_impl<devcb_read8::delegate_builder<read16sm_delegate> >;
+extern template class devcb_read8::creator_impl<devcb_read8::delegate_builder<read32sm_delegate> >;
+extern template class devcb_read8::creator_impl<devcb_read8::delegate_builder<read64sm_delegate> >;
+extern template class devcb_read8::creator_impl<devcb_read8::delegate_builder<read8smo_delegate> >;
+extern template class devcb_read8::creator_impl<devcb_read8::delegate_builder<read16smo_delegate> >;
+extern template class devcb_read8::creator_impl<devcb_read8::delegate_builder<read32smo_delegate> >;
+extern template class devcb_read8::creator_impl<devcb_read8::delegate_builder<read64smo_delegate> >;
 extern template class devcb_read8::creator_impl<devcb_read8::delegate_builder<read_line_delegate> >;
 extern template class devcb_read8::creator_impl<devcb_read8::ioport_builder>;
 
@@ -2566,6 +2689,18 @@ extern template class devcb_read16::creator_impl<devcb_read16::delegate_builder<
 extern template class devcb_read16::creator_impl<devcb_read16::delegate_builder<read16_delegate> >;
 extern template class devcb_read16::creator_impl<devcb_read16::delegate_builder<read32_delegate> >;
 extern template class devcb_read16::creator_impl<devcb_read16::delegate_builder<read64_delegate> >;
+extern template class devcb_read16::creator_impl<devcb_read16::delegate_builder<read8s_delegate> >;
+extern template class devcb_read16::creator_impl<devcb_read16::delegate_builder<read16s_delegate> >;
+extern template class devcb_read16::creator_impl<devcb_read16::delegate_builder<read32s_delegate> >;
+extern template class devcb_read16::creator_impl<devcb_read16::delegate_builder<read64s_delegate> >;
+extern template class devcb_read16::creator_impl<devcb_read16::delegate_builder<read8sm_delegate> >;
+extern template class devcb_read16::creator_impl<devcb_read16::delegate_builder<read16sm_delegate> >;
+extern template class devcb_read16::creator_impl<devcb_read16::delegate_builder<read32sm_delegate> >;
+extern template class devcb_read16::creator_impl<devcb_read16::delegate_builder<read64sm_delegate> >;
+extern template class devcb_read16::creator_impl<devcb_read16::delegate_builder<read8smo_delegate> >;
+extern template class devcb_read16::creator_impl<devcb_read16::delegate_builder<read16smo_delegate> >;
+extern template class devcb_read16::creator_impl<devcb_read16::delegate_builder<read32smo_delegate> >;
+extern template class devcb_read16::creator_impl<devcb_read16::delegate_builder<read64smo_delegate> >;
 extern template class devcb_read16::creator_impl<devcb_read16::delegate_builder<read_line_delegate> >;
 extern template class devcb_read16::creator_impl<devcb_read16::ioport_builder>;
 
@@ -2573,6 +2708,18 @@ extern template class devcb_read32::creator_impl<devcb_read32::delegate_builder<
 extern template class devcb_read32::creator_impl<devcb_read32::delegate_builder<read16_delegate> >;
 extern template class devcb_read32::creator_impl<devcb_read32::delegate_builder<read32_delegate> >;
 extern template class devcb_read32::creator_impl<devcb_read32::delegate_builder<read64_delegate> >;
+extern template class devcb_read32::creator_impl<devcb_read32::delegate_builder<read8s_delegate> >;
+extern template class devcb_read32::creator_impl<devcb_read32::delegate_builder<read16s_delegate> >;
+extern template class devcb_read32::creator_impl<devcb_read32::delegate_builder<read32s_delegate> >;
+extern template class devcb_read32::creator_impl<devcb_read32::delegate_builder<read64s_delegate> >;
+extern template class devcb_read32::creator_impl<devcb_read32::delegate_builder<read8sm_delegate> >;
+extern template class devcb_read32::creator_impl<devcb_read32::delegate_builder<read16sm_delegate> >;
+extern template class devcb_read32::creator_impl<devcb_read32::delegate_builder<read32sm_delegate> >;
+extern template class devcb_read32::creator_impl<devcb_read32::delegate_builder<read64sm_delegate> >;
+extern template class devcb_read32::creator_impl<devcb_read32::delegate_builder<read8smo_delegate> >;
+extern template class devcb_read32::creator_impl<devcb_read32::delegate_builder<read16smo_delegate> >;
+extern template class devcb_read32::creator_impl<devcb_read32::delegate_builder<read32smo_delegate> >;
+extern template class devcb_read32::creator_impl<devcb_read32::delegate_builder<read64smo_delegate> >;
 extern template class devcb_read32::creator_impl<devcb_read32::delegate_builder<read_line_delegate> >;
 extern template class devcb_read32::creator_impl<devcb_read32::ioport_builder>;
 
@@ -2580,6 +2727,18 @@ extern template class devcb_read64::creator_impl<devcb_read64::delegate_builder<
 extern template class devcb_read64::creator_impl<devcb_read64::delegate_builder<read16_delegate> >;
 extern template class devcb_read64::creator_impl<devcb_read64::delegate_builder<read32_delegate> >;
 extern template class devcb_read64::creator_impl<devcb_read64::delegate_builder<read64_delegate> >;
+extern template class devcb_read64::creator_impl<devcb_read64::delegate_builder<read8s_delegate> >;
+extern template class devcb_read64::creator_impl<devcb_read64::delegate_builder<read16s_delegate> >;
+extern template class devcb_read64::creator_impl<devcb_read64::delegate_builder<read32s_delegate> >;
+extern template class devcb_read64::creator_impl<devcb_read64::delegate_builder<read64s_delegate> >;
+extern template class devcb_read64::creator_impl<devcb_read64::delegate_builder<read8sm_delegate> >;
+extern template class devcb_read64::creator_impl<devcb_read64::delegate_builder<read16sm_delegate> >;
+extern template class devcb_read64::creator_impl<devcb_read64::delegate_builder<read32sm_delegate> >;
+extern template class devcb_read64::creator_impl<devcb_read64::delegate_builder<read64sm_delegate> >;
+extern template class devcb_read64::creator_impl<devcb_read64::delegate_builder<read8smo_delegate> >;
+extern template class devcb_read64::creator_impl<devcb_read64::delegate_builder<read16smo_delegate> >;
+extern template class devcb_read64::creator_impl<devcb_read64::delegate_builder<read32smo_delegate> >;
+extern template class devcb_read64::creator_impl<devcb_read64::delegate_builder<read64smo_delegate> >;
 extern template class devcb_read64::creator_impl<devcb_read64::delegate_builder<read_line_delegate> >;
 extern template class devcb_read64::creator_impl<devcb_read64::ioport_builder>;
 
@@ -2587,6 +2746,18 @@ extern template class devcb_read_line::creator_impl<devcb_read_line::delegate_bu
 extern template class devcb_read_line::creator_impl<devcb_read_line::delegate_builder<read16_delegate> >;
 extern template class devcb_read_line::creator_impl<devcb_read_line::delegate_builder<read32_delegate> >;
 extern template class devcb_read_line::creator_impl<devcb_read_line::delegate_builder<read64_delegate> >;
+extern template class devcb_read_line::creator_impl<devcb_read_line::delegate_builder<read8s_delegate> >;
+extern template class devcb_read_line::creator_impl<devcb_read_line::delegate_builder<read16s_delegate> >;
+extern template class devcb_read_line::creator_impl<devcb_read_line::delegate_builder<read32s_delegate> >;
+extern template class devcb_read_line::creator_impl<devcb_read_line::delegate_builder<read64s_delegate> >;
+extern template class devcb_read_line::creator_impl<devcb_read_line::delegate_builder<read8sm_delegate> >;
+extern template class devcb_read_line::creator_impl<devcb_read_line::delegate_builder<read16sm_delegate> >;
+extern template class devcb_read_line::creator_impl<devcb_read_line::delegate_builder<read32sm_delegate> >;
+extern template class devcb_read_line::creator_impl<devcb_read_line::delegate_builder<read64sm_delegate> >;
+extern template class devcb_read_line::creator_impl<devcb_read_line::delegate_builder<read8smo_delegate> >;
+extern template class devcb_read_line::creator_impl<devcb_read_line::delegate_builder<read16smo_delegate> >;
+extern template class devcb_read_line::creator_impl<devcb_read_line::delegate_builder<read32smo_delegate> >;
+extern template class devcb_read_line::creator_impl<devcb_read_line::delegate_builder<read64smo_delegate> >;
 extern template class devcb_read_line::creator_impl<devcb_read_line::delegate_builder<read_line_delegate> >;
 extern template class devcb_read_line::creator_impl<devcb_read_line::ioport_builder>;
 
@@ -2600,36 +2771,108 @@ extern template class devcb_write8::delegate_builder<write8_delegate>;
 extern template class devcb_write8::delegate_builder<write16_delegate>;
 extern template class devcb_write8::delegate_builder<write32_delegate>;
 extern template class devcb_write8::delegate_builder<write64_delegate>;
+extern template class devcb_write8::delegate_builder<write8s_delegate>;
+extern template class devcb_write8::delegate_builder<write16s_delegate>;
+extern template class devcb_write8::delegate_builder<write32s_delegate>;
+extern template class devcb_write8::delegate_builder<write64s_delegate>;
+extern template class devcb_write8::delegate_builder<write8sm_delegate>;
+extern template class devcb_write8::delegate_builder<write16sm_delegate>;
+extern template class devcb_write8::delegate_builder<write32sm_delegate>;
+extern template class devcb_write8::delegate_builder<write64sm_delegate>;
+extern template class devcb_write8::delegate_builder<write8smo_delegate>;
+extern template class devcb_write8::delegate_builder<write16smo_delegate>;
+extern template class devcb_write8::delegate_builder<write32smo_delegate>;
+extern template class devcb_write8::delegate_builder<write64smo_delegate>;
 extern template class devcb_write8::delegate_builder<write_line_delegate>;
 
 extern template class devcb_write16::delegate_builder<write8_delegate>;
 extern template class devcb_write16::delegate_builder<write16_delegate>;
 extern template class devcb_write16::delegate_builder<write32_delegate>;
 extern template class devcb_write16::delegate_builder<write64_delegate>;
+extern template class devcb_write16::delegate_builder<write8s_delegate>;
+extern template class devcb_write16::delegate_builder<write16s_delegate>;
+extern template class devcb_write16::delegate_builder<write32s_delegate>;
+extern template class devcb_write16::delegate_builder<write64s_delegate>;
+extern template class devcb_write16::delegate_builder<write8sm_delegate>;
+extern template class devcb_write16::delegate_builder<write16sm_delegate>;
+extern template class devcb_write16::delegate_builder<write32sm_delegate>;
+extern template class devcb_write16::delegate_builder<write64sm_delegate>;
+extern template class devcb_write16::delegate_builder<write8smo_delegate>;
+extern template class devcb_write16::delegate_builder<write16smo_delegate>;
+extern template class devcb_write16::delegate_builder<write32smo_delegate>;
+extern template class devcb_write16::delegate_builder<write64smo_delegate>;
 extern template class devcb_write16::delegate_builder<write_line_delegate>;
 
 extern template class devcb_write32::delegate_builder<write8_delegate>;
 extern template class devcb_write32::delegate_builder<write16_delegate>;
 extern template class devcb_write32::delegate_builder<write32_delegate>;
 extern template class devcb_write32::delegate_builder<write64_delegate>;
+extern template class devcb_write32::delegate_builder<write8s_delegate>;
+extern template class devcb_write32::delegate_builder<write16s_delegate>;
+extern template class devcb_write32::delegate_builder<write32s_delegate>;
+extern template class devcb_write32::delegate_builder<write64s_delegate>;
+extern template class devcb_write32::delegate_builder<write8sm_delegate>;
+extern template class devcb_write32::delegate_builder<write16sm_delegate>;
+extern template class devcb_write32::delegate_builder<write32sm_delegate>;
+extern template class devcb_write32::delegate_builder<write64sm_delegate>;
+extern template class devcb_write32::delegate_builder<write8smo_delegate>;
+extern template class devcb_write32::delegate_builder<write16smo_delegate>;
+extern template class devcb_write32::delegate_builder<write32smo_delegate>;
+extern template class devcb_write32::delegate_builder<write64smo_delegate>;
 extern template class devcb_write32::delegate_builder<write_line_delegate>;
 
 extern template class devcb_write64::delegate_builder<write8_delegate>;
 extern template class devcb_write64::delegate_builder<write16_delegate>;
 extern template class devcb_write64::delegate_builder<write32_delegate>;
 extern template class devcb_write64::delegate_builder<write64_delegate>;
+extern template class devcb_write64::delegate_builder<write8s_delegate>;
+extern template class devcb_write64::delegate_builder<write16s_delegate>;
+extern template class devcb_write64::delegate_builder<write32s_delegate>;
+extern template class devcb_write64::delegate_builder<write64s_delegate>;
+extern template class devcb_write64::delegate_builder<write8sm_delegate>;
+extern template class devcb_write64::delegate_builder<write16sm_delegate>;
+extern template class devcb_write64::delegate_builder<write32sm_delegate>;
+extern template class devcb_write64::delegate_builder<write64sm_delegate>;
+extern template class devcb_write64::delegate_builder<write8smo_delegate>;
+extern template class devcb_write64::delegate_builder<write16smo_delegate>;
+extern template class devcb_write64::delegate_builder<write32smo_delegate>;
+extern template class devcb_write64::delegate_builder<write64smo_delegate>;
 extern template class devcb_write64::delegate_builder<write_line_delegate>;
 
 extern template class devcb_write_line::delegate_builder<write8_delegate>;
 extern template class devcb_write_line::delegate_builder<write16_delegate>;
 extern template class devcb_write_line::delegate_builder<write32_delegate>;
 extern template class devcb_write_line::delegate_builder<write64_delegate>;
+extern template class devcb_write_line::delegate_builder<write8s_delegate>;
+extern template class devcb_write_line::delegate_builder<write16s_delegate>;
+extern template class devcb_write_line::delegate_builder<write32s_delegate>;
+extern template class devcb_write_line::delegate_builder<write64s_delegate>;
+extern template class devcb_write_line::delegate_builder<write8sm_delegate>;
+extern template class devcb_write_line::delegate_builder<write16sm_delegate>;
+extern template class devcb_write_line::delegate_builder<write32sm_delegate>;
+extern template class devcb_write_line::delegate_builder<write64sm_delegate>;
+extern template class devcb_write_line::delegate_builder<write8smo_delegate>;
+extern template class devcb_write_line::delegate_builder<write16smo_delegate>;
+extern template class devcb_write_line::delegate_builder<write32smo_delegate>;
+extern template class devcb_write_line::delegate_builder<write64smo_delegate>;
 extern template class devcb_write_line::delegate_builder<write_line_delegate>;
 
 extern template class devcb_write8::creator_impl<devcb_write8::delegate_builder<write8_delegate> >;
 extern template class devcb_write8::creator_impl<devcb_write8::delegate_builder<write16_delegate> >;
 extern template class devcb_write8::creator_impl<devcb_write8::delegate_builder<write32_delegate> >;
 extern template class devcb_write8::creator_impl<devcb_write8::delegate_builder<write64_delegate> >;
+extern template class devcb_write8::creator_impl<devcb_write8::delegate_builder<write8s_delegate> >;
+extern template class devcb_write8::creator_impl<devcb_write8::delegate_builder<write16s_delegate> >;
+extern template class devcb_write8::creator_impl<devcb_write8::delegate_builder<write32s_delegate> >;
+extern template class devcb_write8::creator_impl<devcb_write8::delegate_builder<write64s_delegate> >;
+extern template class devcb_write8::creator_impl<devcb_write8::delegate_builder<write8sm_delegate> >;
+extern template class devcb_write8::creator_impl<devcb_write8::delegate_builder<write16sm_delegate> >;
+extern template class devcb_write8::creator_impl<devcb_write8::delegate_builder<write32sm_delegate> >;
+extern template class devcb_write8::creator_impl<devcb_write8::delegate_builder<write64sm_delegate> >;
+extern template class devcb_write8::creator_impl<devcb_write8::delegate_builder<write8smo_delegate> >;
+extern template class devcb_write8::creator_impl<devcb_write8::delegate_builder<write16smo_delegate> >;
+extern template class devcb_write8::creator_impl<devcb_write8::delegate_builder<write32smo_delegate> >;
+extern template class devcb_write8::creator_impl<devcb_write8::delegate_builder<write64smo_delegate> >;
 extern template class devcb_write8::creator_impl<devcb_write8::delegate_builder<write_line_delegate> >;
 extern template class devcb_write8::creator_impl<devcb_write8::inputline_builder>;
 extern template class devcb_write8::creator_impl<devcb_write8::latched_inputline_builder>;
@@ -2642,6 +2885,18 @@ extern template class devcb_write16::creator_impl<devcb_write16::delegate_builde
 extern template class devcb_write16::creator_impl<devcb_write16::delegate_builder<write16_delegate> >;
 extern template class devcb_write16::creator_impl<devcb_write16::delegate_builder<write32_delegate> >;
 extern template class devcb_write16::creator_impl<devcb_write16::delegate_builder<write64_delegate> >;
+extern template class devcb_write16::creator_impl<devcb_write16::delegate_builder<write8s_delegate> >;
+extern template class devcb_write16::creator_impl<devcb_write16::delegate_builder<write16s_delegate> >;
+extern template class devcb_write16::creator_impl<devcb_write16::delegate_builder<write32s_delegate> >;
+extern template class devcb_write16::creator_impl<devcb_write16::delegate_builder<write64s_delegate> >;
+extern template class devcb_write16::creator_impl<devcb_write16::delegate_builder<write8sm_delegate> >;
+extern template class devcb_write16::creator_impl<devcb_write16::delegate_builder<write16sm_delegate> >;
+extern template class devcb_write16::creator_impl<devcb_write16::delegate_builder<write32sm_delegate> >;
+extern template class devcb_write16::creator_impl<devcb_write16::delegate_builder<write64sm_delegate> >;
+extern template class devcb_write16::creator_impl<devcb_write16::delegate_builder<write8smo_delegate> >;
+extern template class devcb_write16::creator_impl<devcb_write16::delegate_builder<write16smo_delegate> >;
+extern template class devcb_write16::creator_impl<devcb_write16::delegate_builder<write32smo_delegate> >;
+extern template class devcb_write16::creator_impl<devcb_write16::delegate_builder<write64smo_delegate> >;
 extern template class devcb_write16::creator_impl<devcb_write16::delegate_builder<write_line_delegate> >;
 extern template class devcb_write16::creator_impl<devcb_write16::inputline_builder>;
 extern template class devcb_write16::creator_impl<devcb_write16::latched_inputline_builder>;
@@ -2654,6 +2909,18 @@ extern template class devcb_write32::creator_impl<devcb_write32::delegate_builde
 extern template class devcb_write32::creator_impl<devcb_write32::delegate_builder<write16_delegate> >;
 extern template class devcb_write32::creator_impl<devcb_write32::delegate_builder<write32_delegate> >;
 extern template class devcb_write32::creator_impl<devcb_write32::delegate_builder<write64_delegate> >;
+extern template class devcb_write32::creator_impl<devcb_write32::delegate_builder<write8s_delegate> >;
+extern template class devcb_write32::creator_impl<devcb_write32::delegate_builder<write16s_delegate> >;
+extern template class devcb_write32::creator_impl<devcb_write32::delegate_builder<write32s_delegate> >;
+extern template class devcb_write32::creator_impl<devcb_write32::delegate_builder<write64s_delegate> >;
+extern template class devcb_write32::creator_impl<devcb_write32::delegate_builder<write8sm_delegate> >;
+extern template class devcb_write32::creator_impl<devcb_write32::delegate_builder<write16sm_delegate> >;
+extern template class devcb_write32::creator_impl<devcb_write32::delegate_builder<write32sm_delegate> >;
+extern template class devcb_write32::creator_impl<devcb_write32::delegate_builder<write64sm_delegate> >;
+extern template class devcb_write32::creator_impl<devcb_write32::delegate_builder<write8smo_delegate> >;
+extern template class devcb_write32::creator_impl<devcb_write32::delegate_builder<write16smo_delegate> >;
+extern template class devcb_write32::creator_impl<devcb_write32::delegate_builder<write32smo_delegate> >;
+extern template class devcb_write32::creator_impl<devcb_write32::delegate_builder<write64smo_delegate> >;
 extern template class devcb_write32::creator_impl<devcb_write32::delegate_builder<write_line_delegate> >;
 extern template class devcb_write32::creator_impl<devcb_write32::inputline_builder>;
 extern template class devcb_write32::creator_impl<devcb_write32::latched_inputline_builder>;
@@ -2666,6 +2933,18 @@ extern template class devcb_write64::creator_impl<devcb_write64::delegate_builde
 extern template class devcb_write64::creator_impl<devcb_write64::delegate_builder<write16_delegate> >;
 extern template class devcb_write64::creator_impl<devcb_write64::delegate_builder<write32_delegate> >;
 extern template class devcb_write64::creator_impl<devcb_write64::delegate_builder<write64_delegate> >;
+extern template class devcb_write64::creator_impl<devcb_write64::delegate_builder<write8s_delegate> >;
+extern template class devcb_write64::creator_impl<devcb_write64::delegate_builder<write16s_delegate> >;
+extern template class devcb_write64::creator_impl<devcb_write64::delegate_builder<write32s_delegate> >;
+extern template class devcb_write64::creator_impl<devcb_write64::delegate_builder<write64s_delegate> >;
+extern template class devcb_write64::creator_impl<devcb_write64::delegate_builder<write8sm_delegate> >;
+extern template class devcb_write64::creator_impl<devcb_write64::delegate_builder<write16sm_delegate> >;
+extern template class devcb_write64::creator_impl<devcb_write64::delegate_builder<write32sm_delegate> >;
+extern template class devcb_write64::creator_impl<devcb_write64::delegate_builder<write64sm_delegate> >;
+extern template class devcb_write64::creator_impl<devcb_write64::delegate_builder<write8smo_delegate> >;
+extern template class devcb_write64::creator_impl<devcb_write64::delegate_builder<write16smo_delegate> >;
+extern template class devcb_write64::creator_impl<devcb_write64::delegate_builder<write32smo_delegate> >;
+extern template class devcb_write64::creator_impl<devcb_write64::delegate_builder<write64smo_delegate> >;
 extern template class devcb_write64::creator_impl<devcb_write64::delegate_builder<write_line_delegate> >;
 extern template class devcb_write64::creator_impl<devcb_write64::inputline_builder>;
 extern template class devcb_write64::creator_impl<devcb_write64::latched_inputline_builder>;
@@ -2678,6 +2957,18 @@ extern template class devcb_write_line::creator_impl<devcb_write_line::delegate_
 extern template class devcb_write_line::creator_impl<devcb_write_line::delegate_builder<write16_delegate> >;
 extern template class devcb_write_line::creator_impl<devcb_write_line::delegate_builder<write32_delegate> >;
 extern template class devcb_write_line::creator_impl<devcb_write_line::delegate_builder<write64_delegate> >;
+extern template class devcb_write_line::creator_impl<devcb_write_line::delegate_builder<write8s_delegate> >;
+extern template class devcb_write_line::creator_impl<devcb_write_line::delegate_builder<write16s_delegate> >;
+extern template class devcb_write_line::creator_impl<devcb_write_line::delegate_builder<write32s_delegate> >;
+extern template class devcb_write_line::creator_impl<devcb_write_line::delegate_builder<write64s_delegate> >;
+extern template class devcb_write_line::creator_impl<devcb_write_line::delegate_builder<write8sm_delegate> >;
+extern template class devcb_write_line::creator_impl<devcb_write_line::delegate_builder<write16sm_delegate> >;
+extern template class devcb_write_line::creator_impl<devcb_write_line::delegate_builder<write32sm_delegate> >;
+extern template class devcb_write_line::creator_impl<devcb_write_line::delegate_builder<write64sm_delegate> >;
+extern template class devcb_write_line::creator_impl<devcb_write_line::delegate_builder<write8smo_delegate> >;
+extern template class devcb_write_line::creator_impl<devcb_write_line::delegate_builder<write16smo_delegate> >;
+extern template class devcb_write_line::creator_impl<devcb_write_line::delegate_builder<write32smo_delegate> >;
+extern template class devcb_write_line::creator_impl<devcb_write_line::delegate_builder<write64smo_delegate> >;
 extern template class devcb_write_line::creator_impl<devcb_write_line::delegate_builder<write_line_delegate> >;
 extern template class devcb_write_line::creator_impl<devcb_write_line::inputline_builder>;
 extern template class devcb_write_line::creator_impl<devcb_write_line::latched_inputline_builder>;
diff --git a/src/emu/emumem.cpp b/src/emu/emumem.cpp
index 0ba90cb45ab..3fb7f3a76df 100644
--- a/src/emu/emumem.cpp
+++ b/src/emu/emumem.cpp
@@ -258,6 +258,19 @@ public:
 	void install_write_handler(offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, offs_t addrselect, write64_delegate whandler, u64 unitmask = 0, int cswidth = 0) override;
 	void install_readwrite_handler(offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, offs_t addrselect, read64_delegate rhandler, write64_delegate whandler, u64 unitmask = 0, int cswidth = 0) override;
 
+	void install_read_handler(offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, offs_t addrselect, read8m_delegate rhandler, u64 unitmask = 0, int cswidth = 0) override;
+	void install_write_handler(offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, offs_t addrselect, write8m_delegate whandler, u64 unitmask = 0, int cswidth = 0) override;
+	void install_readwrite_handler(offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, offs_t addrselect, read8m_delegate rhandler, write8m_delegate whandler, u64 unitmask = 0, int cswidth = 0) override;
+	void install_read_handler(offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, offs_t addrselect, read16m_delegate rhandler, u64 unitmask = 0, int cswidth = 0) override;
+	void install_write_handler(offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, offs_t addrselect, write16m_delegate whandler, u64 unitmask = 0, int cswidth = 0) override;
+	void install_readwrite_handler(offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, offs_t addrselect, read16m_delegate rhandler, write16m_delegate whandler, u64 unitmask = 0, int cswidth = 0) override;
+	void install_read_handler(offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, offs_t addrselect, read32m_delegate rhandler, u64 unitmask = 0, int cswidth = 0) override;
+	void install_write_handler(offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, offs_t addrselect, write32m_delegate whandler, u64 unitmask = 0, int cswidth = 0) override;
+	void install_readwrite_handler(offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, offs_t addrselect, read32m_delegate rhandler, write32m_delegate whandler, u64 unitmask = 0, int cswidth = 0) override;
+	void install_read_handler(offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, offs_t addrselect, read64m_delegate rhandler, u64 unitmask = 0, int cswidth = 0) override;
+	void install_write_handler(offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, offs_t addrselect, write64m_delegate whandler, u64 unitmask = 0, int cswidth = 0) override;
+	void install_readwrite_handler(offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, offs_t addrselect, read64m_delegate rhandler, write64m_delegate whandler, u64 unitmask = 0, int cswidth = 0) override;
+
 	void install_read_handler(offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, offs_t addrselect, read8s_delegate rhandler, u64 unitmask = 0, int cswidth = 0) override;
 	void install_write_handler(offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, offs_t addrselect, write8s_delegate whandler, u64 unitmask = 0, int cswidth = 0) override;
 	void install_readwrite_handler(offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, offs_t addrselect, read8s_delegate rhandler, write8s_delegate whandler, u64 unitmask = 0, int cswidth = 0) override;
@@ -284,6 +297,19 @@ public:
 	void install_write_handler(offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, offs_t addrselect, write64sm_delegate whandler, u64 unitmask = 0, int cswidth = 0) override;
 	void install_readwrite_handler(offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, offs_t addrselect, read64sm_delegate rhandler, write64sm_delegate whandler, u64 unitmask = 0, int cswidth = 0) override;
 
+	void install_read_handler(offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, offs_t addrselect, read8mo_delegate rhandler, u64 unitmask = 0, int cswidth = 0) override;
+	void install_write_handler(offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, offs_t addrselect, write8mo_delegate whandler, u64 unitmask = 0, int cswidth = 0) override;
+	void install_readwrite_handler(offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, offs_t addrselect, read8mo_delegate rhandler, write8mo_delegate whandler, u64 unitmask = 0, int cswidth = 0) override;
+	void install_read_handler(offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, offs_t addrselect, read16mo_delegate rhandler, u64 unitmask = 0, int cswidth = 0) override;
+	void install_write_handler(offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, offs_t addrselect, write16mo_delegate whandler, u64 unitmask = 0, int cswidth = 0) override;
+	void install_readwrite_handler(offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, offs_t addrselect, read16mo_delegate rhandler, write16mo_delegate whandler, u64 unitmask = 0, int cswidth = 0) override;
+	void install_read_handler(offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, offs_t addrselect, read32mo_delegate rhandler, u64 unitmask = 0, int cswidth = 0) override;
+	void install_write_handler(offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, offs_t addrselect, write32mo_delegate whandler, u64 unitmask = 0, int cswidth = 0) override;
+	void install_readwrite_handler(offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, offs_t addrselect, read32mo_delegate rhandler, write32mo_delegate whandler, u64 unitmask = 0, int cswidth = 0) override;
+	void install_read_handler(offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, offs_t addrselect, read64mo_delegate rhandler, u64 unitmask = 0, int cswidth = 0) override;
+	void install_write_handler(offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, offs_t addrselect, write64mo_delegate whandler, u64 unitmask = 0, int cswidth = 0) override;
+	void install_readwrite_handler(offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, offs_t addrselect, read64mo_delegate rhandler, write64mo_delegate whandler, u64 unitmask = 0, int cswidth = 0) override;
+
 	void install_read_handler(offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, offs_t addrselect, read8smo_delegate rhandler, u64 unitmask = 0, int cswidth = 0) override;
 	void install_write_handler(offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, offs_t addrselect, write8smo_delegate whandler, u64 unitmask = 0, int cswidth = 0) override;
 	void install_readwrite_handler(offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, offs_t addrselect, read8smo_delegate rhandler, write8smo_delegate whandler, u64 unitmask = 0, int cswidth = 0) override;
@@ -1295,7 +1321,7 @@ void address_space::populate_map_entry(const address_map_entry &entry, read_or_w
 			unmap_generic(entry.m_addrstart, entry.m_addrend, entry.m_addrmirror, readorwrite, false);
 			break;
 
-		case AMH_DEVICE_DELEGATE_F:
+		case AMH_DEVICE_DELEGATE:
 			if (readorwrite == read_or_write::READ)
 				switch (data.m_bits)
 				{
@@ -1314,6 +1340,25 @@ void address_space::populate_map_entry(const address_map_entry &entry, read_or_w
 				}
 			break;
 
+		case AMH_DEVICE_DELEGATE_M:
+			if (readorwrite == read_or_write::READ)
+				switch (data.m_bits)
+				{
+					case 8:     install_read_handler(entry.m_addrstart, entry.m_addrend, entry.m_addrmask, entry.m_addrmirror, entry.m_addrselect, read8m_delegate(entry.m_rproto8m, entry.m_devbase), entry.m_mask, entry.m_cswidth); break;
+					case 16:    install_read_handler(entry.m_addrstart, entry.m_addrend, entry.m_addrmask, entry.m_addrmirror, entry.m_addrselect, read16m_delegate(entry.m_rproto16m, entry.m_devbase), entry.m_mask, entry.m_cswidth); break;
+					case 32:    install_read_handler(entry.m_addrstart, entry.m_addrend, entry.m_addrmask, entry.m_addrmirror, entry.m_addrselect, read32m_delegate(entry.m_rproto32m, entry.m_devbase), entry.m_mask, entry.m_cswidth); break;
+					case 64:    install_read_handler(entry.m_addrstart, entry.m_addrend, entry.m_addrmask, entry.m_addrmirror, entry.m_addrselect, read64m_delegate(entry.m_rproto64m, entry.m_devbase), entry.m_mask, entry.m_cswidth); break;
+				}
+			else
+				switch (data.m_bits)
+				{
+					case 8:     install_write_handler(entry.m_addrstart, entry.m_addrend, entry.m_addrmask, entry.m_addrmirror, entry.m_addrselect, write8m_delegate(entry.m_wproto8m, entry.m_devbase), entry.m_mask, entry.m_cswidth); break;
+					case 16:    install_write_handler(entry.m_addrstart, entry.m_addrend, entry.m_addrmask, entry.m_addrmirror, entry.m_addrselect, write16m_delegate(entry.m_wproto16m, entry.m_devbase), entry.m_mask, entry.m_cswidth); break;
+					case 32:    install_write_handler(entry.m_addrstart, entry.m_addrend, entry.m_addrmask, entry.m_addrmirror, entry.m_addrselect, write32m_delegate(entry.m_wproto32m, entry.m_devbase), entry.m_mask, entry.m_cswidth); break;
+					case 64:    install_write_handler(entry.m_addrstart, entry.m_addrend, entry.m_addrmask, entry.m_addrmirror, entry.m_addrselect, write64m_delegate(entry.m_wproto64m, entry.m_devbase), entry.m_mask, entry.m_cswidth); break;
+				}
+			break;
+
 		case AMH_DEVICE_DELEGATE_S:
 			if (readorwrite == read_or_write::READ)
 				switch (data.m_bits)
@@ -1352,6 +1397,25 @@ void address_space::populate_map_entry(const address_map_entry &entry, read_or_w
 				}
 			break;
 
+		case AMH_DEVICE_DELEGATE_MO:
+			if (readorwrite == read_or_write::READ)
+				switch (data.m_bits)
+				{
+					case 8:     install_read_handler(entry.m_addrstart, entry.m_addrend, entry.m_addrmask, entry.m_addrmirror, entry.m_addrselect, read8mo_delegate(entry.m_rproto8mo, entry.m_devbase), entry.m_mask, entry.m_cswidth); break;
+					case 16:    install_read_handler(entry.m_addrstart, entry.m_addrend, entry.m_addrmask, entry.m_addrmirror, entry.m_addrselect, read16mo_delegate(entry.m_rproto16mo, entry.m_devbase), entry.m_mask, entry.m_cswidth); break;
+					case 32:    install_read_handler(entry.m_addrstart, entry.m_addrend, entry.m_addrmask, entry.m_addrmirror, entry.m_addrselect, read32mo_delegate(entry.m_rproto32mo, entry.m_devbase), entry.m_mask, entry.m_cswidth); break;
+					case 64:    install_read_handler(entry.m_addrstart, entry.m_addrend, entry.m_addrmask, entry.m_addrmirror, entry.m_addrselect, read64mo_delegate(entry.m_rproto64mo, entry.m_devbase), entry.m_mask, entry.m_cswidth); break;
+				}
+			else
+				switch (data.m_bits)
+				{
+					case 8:     install_write_handler(entry.m_addrstart, entry.m_addrend, entry.m_addrmask, entry.m_addrmirror, entry.m_addrselect, write8mo_delegate(entry.m_wproto8mo, entry.m_devbase), entry.m_mask, entry.m_cswidth); break;
+					case 16:    install_write_handler(entry.m_addrstart, entry.m_addrend, entry.m_addrmask, entry.m_addrmirror, entry.m_addrselect, write16mo_delegate(entry.m_wproto16mo, entry.m_devbase), entry.m_mask, entry.m_cswidth); break;
+					case 32:    install_write_handler(entry.m_addrstart, entry.m_addrend, entry.m_addrmask, entry.m_addrmirror, entry.m_addrselect, write32mo_delegate(entry.m_wproto32mo, entry.m_devbase), entry.m_mask, entry.m_cswidth); break;
+					case 64:    install_write_handler(entry.m_addrstart, entry.m_addrend, entry.m_addrmask, entry.m_addrmirror, entry.m_addrselect, write64mo_delegate(entry.m_wproto64mo, entry.m_devbase), entry.m_mask, entry.m_cswidth); break;
+				}
+			break;
+
 		case AMH_DEVICE_DELEGATE_SMO:
 			if (readorwrite == read_or_write::READ)
 				switch (data.m_bits)
@@ -1991,6 +2055,21 @@ template<int Width, int AddrShift, endianness_t Endian> void address_space_speci
 	install_readwrite_handler_helper<0>(addrstart, addrend, addrmask, addrmirror, addrselect, unitmask, cswidth, rhandler, whandler);
 }
 
+template<int Width, int AddrShift, endianness_t Endian> void address_space_specific<Width, AddrShift, Endian>::install_read_handler(offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, offs_t addrselect, read8m_delegate handler, u64 unitmask, int cswidth)
+{
+	install_read_handler_helper<0>(addrstart, addrend, addrmask, addrmirror, addrselect, unitmask, cswidth, handler);
+}
+
+template<int Width, int AddrShift, endianness_t Endian> void address_space_specific<Width, AddrShift, Endian>::install_write_handler(offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, offs_t addrselect, write8m_delegate handler, u64 unitmask, int cswidth)
+{
+	install_write_handler_helper<0>(addrstart, addrend, addrmask, addrmirror, addrselect, unitmask, cswidth, handler);
+}
+
+template<int Width, int AddrShift, endianness_t Endian> void address_space_specific<Width, AddrShift, Endian>::install_readwrite_handler(offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, offs_t addrselect, read8m_delegate rhandler, write8m_delegate whandler, u64 unitmask, int cswidth)
+{
+	install_readwrite_handler_helper<0>(addrstart, addrend, addrmask, addrmirror, addrselect, unitmask, cswidth, rhandler, whandler);
+}
+
 template<int Width, int AddrShift, endianness_t Endian> void address_space_specific<Width, AddrShift, Endian>::install_read_handler(offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, offs_t addrselect, read8s_delegate handler, u64 unitmask, int cswidth)
 {
 	install_read_handler_helper<0>(addrstart, addrend, addrmask, addrmirror, addrselect, unitmask, cswidth, handler);
@@ -2021,6 +2100,21 @@ template<int Width, int AddrShift, endianness_t Endian> void address_space_speci
 	install_readwrite_handler_helper<0>(addrstart, addrend, addrmask, addrmirror, addrselect, unitmask, cswidth, rhandler, whandler);
 }
 
+template<int Width, int AddrShift, endianness_t Endian> void address_space_specific<Width, AddrShift, Endian>::install_read_handler(offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, offs_t addrselect, read8mo_delegate handler, u64 unitmask, int cswidth)
+{
+	install_read_handler_helper<0>(addrstart, addrend, addrmask, addrmirror, addrselect, unitmask, cswidth, handler);
+}
+
+template<int Width, int AddrShift, endianness_t Endian> void address_space_specific<Width, AddrShift, Endian>::install_write_handler(offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, offs_t addrselect, write8mo_delegate handler, u64 unitmask, int cswidth)
+{
+	install_write_handler_helper<0>(addrstart, addrend, addrmask, addrmirror, addrselect, unitmask, cswidth, handler);
+}
+
+template<int Width, int AddrShift, endianness_t Endian> void address_space_specific<Width, AddrShift, Endian>::install_readwrite_handler(offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, offs_t addrselect, read8mo_delegate rhandler, write8mo_delegate whandler, u64 unitmask, int cswidth)
+{
+	install_readwrite_handler_helper<0>(addrstart, addrend, addrmask, addrmirror, addrselect, unitmask, cswidth, rhandler, whandler);
+}
+
 template<int Width, int AddrShift, endianness_t Endian> void address_space_specific<Width, AddrShift, Endian>::install_read_handler(offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, offs_t addrselect, read8smo_delegate handler, u64 unitmask, int cswidth)
 {
 	install_read_handler_helper<0>(addrstart, addrend, addrmask, addrmirror, addrselect, unitmask, cswidth, handler);
@@ -2057,6 +2151,21 @@ template<int Width, int AddrShift, endianness_t Endian> void address_space_speci
 	install_readwrite_handler_helper<1>(addrstart, addrend, addrmask, addrmirror, addrselect, unitmask, cswidth, rhandler, whandler);
 }
 
+template<int Width, int AddrShift, endianness_t Endian> void address_space_specific<Width, AddrShift, Endian>::install_read_handler(offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, offs_t addrselect, read16m_delegate handler, u64 unitmask, int cswidth)
+{
+	install_read_handler_helper<1>(addrstart, addrend, addrmask, addrmirror, addrselect, unitmask, cswidth, handler);
+}
+
+template<int Width, int AddrShift, endianness_t Endian> void address_space_specific<Width, AddrShift, Endian>::install_write_handler(offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, offs_t addrselect, write16m_delegate handler, u64 unitmask, int cswidth)
+{
+	install_write_handler_helper<1>(addrstart, addrend, addrmask, addrmirror, addrselect, unitmask, cswidth, handler);
+}
+
+template<int Width, int AddrShift, endianness_t Endian> void address_space_specific<Width, AddrShift, Endian>::install_readwrite_handler(offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, offs_t addrselect, read16m_delegate rhandler, write16m_delegate whandler, u64 unitmask, int cswidth)
+{
+	install_readwrite_handler_helper<1>(addrstart, addrend, addrmask, addrmirror, addrselect, unitmask, cswidth, rhandler, whandler);
+}
+
 template<int Width, int AddrShift, endianness_t Endian> void address_space_specific<Width, AddrShift, Endian>::install_read_handler(offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, offs_t addrselect, read16s_delegate handler, u64 unitmask, int cswidth)
 {
 	install_read_handler_helper<1>(addrstart, addrend, addrmask, addrmirror, addrselect, unitmask, cswidth, handler);
@@ -2102,6 +2211,21 @@ template<int Width, int AddrShift, endianness_t Endian> void address_space_speci
 	install_readwrite_handler_helper<1>(addrstart, addrend, addrmask, addrmirror, addrselect, unitmask, cswidth, rhandler, whandler);
 }
 
+template<int Width, int AddrShift, endianness_t Endian> void address_space_specific<Width, AddrShift, Endian>::install_read_handler(offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, offs_t addrselect, read16mo_delegate handler, u64 unitmask, int cswidth)
+{
+	install_read_handler_helper<1>(addrstart, addrend, addrmask, addrmirror, addrselect, unitmask, cswidth, handler);
+}
+
+template<int Width, int AddrShift, endianness_t Endian> void address_space_specific<Width, AddrShift, Endian>::install_write_handler(offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, offs_t addrselect, write16mo_delegate handler, u64 unitmask, int cswidth)
+{
+	install_write_handler_helper<1>(addrstart, addrend, addrmask, addrmirror, addrselect, unitmask, cswidth, handler);
+}
+
+template<int Width, int AddrShift, endianness_t Endian> void address_space_specific<Width, AddrShift, Endian>::install_readwrite_handler(offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, offs_t addrselect, read16mo_delegate rhandler, write16mo_delegate whandler, u64 unitmask, int cswidth)
+{
+	install_readwrite_handler_helper<1>(addrstart, addrend, addrmask, addrmirror, addrselect, unitmask, cswidth, rhandler, whandler);
+}
+
 
 //-------------------------------------------------
 //  install_handler - install 32-bit read/write
@@ -2123,6 +2247,21 @@ template<int Width, int AddrShift, endianness_t Endian> void address_space_speci
 	install_readwrite_handler_helper<2>(addrstart, addrend, addrmask, addrmirror, addrselect, unitmask, cswidth, rhandler, whandler);
 }
 
+template<int Width, int AddrShift, endianness_t Endian> void address_space_specific<Width, AddrShift, Endian>::install_read_handler(offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, offs_t addrselect, read32m_delegate handler, u64 unitmask, int cswidth)
+{
+	install_read_handler_helper<2>(addrstart, addrend, addrmask, addrmirror, addrselect, unitmask, cswidth, handler);
+}
+
+template<int Width, int AddrShift, endianness_t Endian> void address_space_specific<Width, AddrShift, Endian>::install_write_handler(offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, offs_t addrselect, write32m_delegate handler, u64 unitmask, int cswidth)
+{
+	install_write_handler_helper<2>(addrstart, addrend, addrmask, addrmirror, addrselect, unitmask, cswidth, handler);
+}
+
+template<int Width, int AddrShift, endianness_t Endian> void address_space_specific<Width, AddrShift, Endian>::install_readwrite_handler(offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, offs_t addrselect, read32m_delegate rhandler, write32m_delegate whandler, u64 unitmask, int cswidth)
+{
+	install_readwrite_handler_helper<2>(addrstart, addrend, addrmask, addrmirror, addrselect, unitmask, cswidth, rhandler, whandler);
+}
+
 template<int Width, int AddrShift, endianness_t Endian> void address_space_specific<Width, AddrShift, Endian>::install_read_handler(offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, offs_t addrselect, read32s_delegate handler, u64 unitmask, int cswidth)
 {
 	install_read_handler_helper<2>(addrstart, addrend, addrmask, addrmirror, addrselect, unitmask, cswidth, handler);
@@ -2153,6 +2292,21 @@ template<int Width, int AddrShift, endianness_t Endian> void address_space_speci
 	install_readwrite_handler_helper<2>(addrstart, addrend, addrmask, addrmirror, addrselect, unitmask, cswidth, rhandler, whandler);
 }
 
+template<int Width, int AddrShift, endianness_t Endian> void address_space_specific<Width, AddrShift, Endian>::install_read_handler(offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, offs_t addrselect, read32mo_delegate handler, u64 unitmask, int cswidth)
+{
+	install_read_handler_helper<2>(addrstart, addrend, addrmask, addrmirror, addrselect, unitmask, cswidth, handler);
+}
+
+template<int Width, int AddrShift, endianness_t Endian> void address_space_specific<Width, AddrShift, Endian>::install_write_handler(offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, offs_t addrselect, write32mo_delegate handler, u64 unitmask, int cswidth)
+{
+	install_write_handler_helper<2>(addrstart, addrend, addrmask, addrmirror, addrselect, unitmask, cswidth, handler);
+}
+
+template<int Width, int AddrShift, endianness_t Endian> void address_space_specific<Width, AddrShift, Endian>::install_readwrite_handler(offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, offs_t addrselect, read32mo_delegate rhandler, write32mo_delegate whandler, u64 unitmask, int cswidth)
+{
+	install_readwrite_handler_helper<2>(addrstart, addrend, addrmask, addrmirror, addrselect, unitmask, cswidth, rhandler, whandler);
+}
+
 template<int Width, int AddrShift, endianness_t Endian> void address_space_specific<Width, AddrShift, Endian>::install_read_handler(offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, offs_t addrselect, read32smo_delegate handler, u64 unitmask, int cswidth)
 {
 	install_read_handler_helper<2>(addrstart, addrend, addrmask, addrmirror, addrselect, unitmask, cswidth, handler);
@@ -2189,6 +2343,21 @@ template<int Width, int AddrShift, endianness_t Endian> void address_space_speci
 	install_readwrite_handler_helper<3>(addrstart, addrend, addrmask, addrmirror, addrselect, unitmask, cswidth, rhandler, whandler);
 }
 
+template<int Width, int AddrShift, endianness_t Endian> void address_space_specific<Width, AddrShift, Endian>::install_read_handler(offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, offs_t addrselect, read64m_delegate handler, u64 unitmask, int cswidth)
+{
+	install_read_handler_helper<3>(addrstart, addrend, addrmask, addrmirror, addrselect, unitmask, cswidth, handler);
+}
+
+template<int Width, int AddrShift, endianness_t Endian> void address_space_specific<Width, AddrShift, Endian>::install_write_handler(offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, offs_t addrselect, write64m_delegate handler, u64 unitmask, int cswidth)
+{
+	install_write_handler_helper<3>(addrstart, addrend, addrmask, addrmirror, addrselect, unitmask, cswidth, handler);
+}
+
+template<int Width, int AddrShift, endianness_t Endian> void address_space_specific<Width, AddrShift, Endian>::install_readwrite_handler(offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, offs_t addrselect, read64m_delegate rhandler, write64m_delegate whandler, u64 unitmask, int cswidth)
+{
+	install_readwrite_handler_helper<3>(addrstart, addrend, addrmask, addrmirror, addrselect, unitmask, cswidth, rhandler, whandler);
+}
+
 template<int Width, int AddrShift, endianness_t Endian> void address_space_specific<Width, AddrShift, Endian>::install_read_handler(offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, offs_t addrselect, read64s_delegate handler, u64 unitmask, int cswidth)
 {
 	install_read_handler_helper<3>(addrstart, addrend, addrmask, addrmirror, addrselect, unitmask, cswidth, handler);
@@ -2219,6 +2388,21 @@ template<int Width, int AddrShift, endianness_t Endian> void address_space_speci
 	install_readwrite_handler_helper<3>(addrstart, addrend, addrmask, addrmirror, addrselect, unitmask, cswidth, rhandler, whandler);
 }
 
+template<int Width, int AddrShift, endianness_t Endian> void address_space_specific<Width, AddrShift, Endian>::install_read_handler(offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, offs_t addrselect, read64mo_delegate handler, u64 unitmask, int cswidth)
+{
+	install_read_handler_helper<3>(addrstart, addrend, addrmask, addrmirror, addrselect, unitmask, cswidth, handler);
+}
+
+template<int Width, int AddrShift, endianness_t Endian> void address_space_specific<Width, AddrShift, Endian>::install_write_handler(offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, offs_t addrselect, write64mo_delegate handler, u64 unitmask, int cswidth)
+{
+	install_write_handler_helper<3>(addrstart, addrend, addrmask, addrmirror, addrselect, unitmask, cswidth, handler);
+}
+
+template<int Width, int AddrShift, endianness_t Endian> void address_space_specific<Width, AddrShift, Endian>::install_readwrite_handler(offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, offs_t addrselect, read64mo_delegate rhandler, write64mo_delegate whandler, u64 unitmask, int cswidth)
+{
+	install_readwrite_handler_helper<3>(addrstart, addrend, addrmask, addrmirror, addrselect, unitmask, cswidth, rhandler, whandler);
+}
+
 template<int Width, int AddrShift, endianness_t Endian> void address_space_specific<Width, AddrShift, Endian>::install_read_handler(offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, offs_t addrselect, read64smo_delegate handler, u64 unitmask, int cswidth)
 {
 	install_read_handler_helper<3>(addrstart, addrend, addrmask, addrmirror, addrselect, unitmask, cswidth, handler);
diff --git a/src/emu/emumem.h b/src/emu/emumem.h
index ec7fae2b258..5cc496bfb1f 100644
--- a/src/emu/emumem.h
+++ b/src/emu/emumem.h
@@ -94,6 +94,11 @@ using read16_delegate = device_delegate<u16 (address_space &, offs_t, u16)>;
 using read32_delegate = device_delegate<u32 (address_space &, offs_t, u32)>;
 using read64_delegate = device_delegate<u64 (address_space &, offs_t, u64)>;
 
+using read8m_delegate  = device_delegate<u8  (address_space &, offs_t)>;
+using read16m_delegate = device_delegate<u16 (address_space &, offs_t)>;
+using read32m_delegate = device_delegate<u32 (address_space &, offs_t)>;
+using read64m_delegate = device_delegate<u64 (address_space &, offs_t)>;
+
 using read8s_delegate  = device_delegate<u8  (offs_t, u8 )>;
 using read16s_delegate = device_delegate<u16 (offs_t, u16)>;
 using read32s_delegate = device_delegate<u32 (offs_t, u32)>;
@@ -104,6 +109,11 @@ using read16sm_delegate = device_delegate<u16 (offs_t)>;
 using read32sm_delegate = device_delegate<u32 (offs_t)>;
 using read64sm_delegate = device_delegate<u64 (offs_t)>;
 
+using read8mo_delegate  = device_delegate<u8  (address_space &)>;
+using read16mo_delegate = device_delegate<u16 (address_space &)>;
+using read32mo_delegate = device_delegate<u32 (address_space &)>;
+using read64mo_delegate = device_delegate<u64 (address_space &)>;
+
 using read8smo_delegate  = device_delegate<u8  ()>;
 using read16smo_delegate = device_delegate<u16 ()>;
 using read32smo_delegate = device_delegate<u32 ()>;
@@ -118,6 +128,11 @@ using write16_delegate = device_delegate<void (address_space &, offs_t, u16, u16
 using write32_delegate = device_delegate<void (address_space &, offs_t, u32, u32)>;
 using write64_delegate = device_delegate<void (address_space &, offs_t, u64, u64)>;
 
+using write8m_delegate  = device_delegate<void (address_space &, offs_t, u8 )>;
+using write16m_delegate = device_delegate<void (address_space &, offs_t, u16)>;
+using write32m_delegate = device_delegate<void (address_space &, offs_t, u32)>;
+using write64m_delegate = device_delegate<void (address_space &, offs_t, u64)>;
+
 using write8s_delegate  = device_delegate<void (offs_t, u8,  u8 )>;
 using write16s_delegate = device_delegate<void (offs_t, u16, u16)>;
 using write32s_delegate = device_delegate<void (offs_t, u32, u32)>;
@@ -128,6 +143,11 @@ using write16sm_delegate = device_delegate<void (offs_t, u16)>;
 using write32sm_delegate = device_delegate<void (offs_t, u32)>;
 using write64sm_delegate = device_delegate<void (offs_t, u64)>;
 
+using write8mo_delegate  = device_delegate<void (address_space &, u8 )>;
+using write16mo_delegate = device_delegate<void (address_space &, u16)>;
+using write32mo_delegate = device_delegate<void (address_space &, u32)>;
+using write64mo_delegate = device_delegate<void (address_space &, u64)>;
+
 using write8smo_delegate  = device_delegate<void (u8 )>;
 using write16smo_delegate = device_delegate<void (u16)>;
 using write32smo_delegate = device_delegate<void (u32)>;
@@ -176,6 +196,33 @@ inline write64_delegate make_delegate(T &&func, const char *name, const char *ta
 { return write64_delegate(func, name, tag, obj); }
 
 
+template <typename T>
+inline read8m_delegate make_delegate(T &&func, const char *name, const char *tag, rw_device_class_t<read8m_delegate, std::remove_reference_t<T> > *obj)
+{ return read8m_delegate(func, name, tag, obj); }
+template <typename T>
+inline read16m_delegate make_delegate(T &&func, const char *name, const char *tag, rw_device_class_t<read16m_delegate, std::remove_reference_t<T> > *obj)
+{ return read16m_delegate(func, name, tag, obj); }
+template <typename T>
+inline read32m_delegate make_delegate(T &&func, const char *name, const char *tag, rw_device_class_t<read32m_delegate, std::remove_reference_t<T> > *obj)
+{ return read32m_delegate(func, name, tag, obj); }
+template <typename T>
+inline read64m_delegate make_delegate(T &&func, const char *name, const char *tag, rw_device_class_t<read64m_delegate, std::remove_reference_t<T> > *obj)
+{ return read64m_delegate(func, name, tag, obj); }
+
+template <typename T>
+inline write8m_delegate make_delegate(T &&func, const char *name, const char *tag, rw_device_class_t<write8m_delegate, std::remove_reference_t<T> > *obj)
+{ return write8m_delegate(func, name, tag, obj); }
+template <typename T>
+inline write16m_delegate make_delegate(T &&func, const char *name, const char *tag, rw_device_class_t<write16m_delegate, std::remove_reference_t<T> > *obj)
+{ return write16m_delegate(func, name, tag, obj); }
+template <typename T>
+inline write32m_delegate make_delegate(T &&func, const char *name, const char *tag, rw_device_class_t<write32m_delegate, std::remove_reference_t<T> > *obj)
+{ return write32m_delegate(func, name, tag, obj); }
+template <typename T>
+inline write64m_delegate make_delegate(T &&func, const char *name, const char *tag, rw_device_class_t<write64m_delegate, std::remove_reference_t<T> > *obj)
+{ return write64m_delegate(func, name, tag, obj); }
+
+
 template <typename T>
 inline read8s_delegate make_delegate(T &&func, const char *name, const char *tag, rw_device_class_t<read8s_delegate, std::remove_reference_t<T> > *obj)
 { return read8s_delegate(func, name, tag, obj); }
@@ -230,6 +277,33 @@ inline write64sm_delegate make_delegate(T &&func, const char *name, const char *
 { return write64sm_delegate(func, name, tag, obj); }
 
 
+template <typename T>
+inline read8mo_delegate make_delegate(T &&func, const char *name, const char *tag, rw_device_class_t<read8mo_delegate, std::remove_reference_t<T> > *obj)
+{ return read8mo_delegate(func, name, tag, obj); }
+template <typename T>
+inline read16mo_delegate make_delegate(T &&func, const char *name, const char *tag, rw_device_class_t<read16mo_delegate, std::remove_reference_t<T> > *obj)
+{ return read16mo_delegate(func, name, tag, obj); }
+template <typename T>
+inline read32mo_delegate make_delegate(T &&func, const char *name, const char *tag, rw_device_class_t<read32mo_delegate, std::remove_reference_t<T> > *obj)
+{ return read32mo_delegate(func, name, tag, obj); }
+template <typename T>
+inline read64mo_delegate make_delegate(T &&func, const char *name, const char *tag, rw_device_class_t<read64mo_delegate, std::remove_reference_t<T> > *obj)
+{ return read64mo_delegate(func, name, tag, obj); }
+
+template <typename T>
+inline write8mo_delegate make_delegate(T &&func, const char *name, const char *tag, rw_device_class_t<write8mo_delegate, std::remove_reference_t<T> > *obj)
+{ return write8mo_delegate(func, name, tag, obj); }
+template <typename T>
+inline write16mo_delegate make_delegate(T &&func, const char *name, const char *tag, rw_device_class_t<write16mo_delegate, std::remove_reference_t<T> > *obj)
+{ return write16mo_delegate(func, name, tag, obj); }
+template <typename T>
+inline write32mo_delegate make_delegate(T &&func, const char *name, const char *tag, rw_device_class_t<write32mo_delegate, std::remove_reference_t<T> > *obj)
+{ return write32mo_delegate(func, name, tag, obj); }
+template <typename T>
+inline write64mo_delegate make_delegate(T &&func, const char *name, const char *tag, rw_device_class_t<write64mo_delegate, std::remove_reference_t<T> > *obj)
+{ return write64mo_delegate(func, name, tag, obj); }
+
+
 template <typename T>
 inline read8smo_delegate make_delegate(T &&func, const char *name, const char *tag, rw_device_class_t<read8smo_delegate, std::remove_reference_t<T> > *obj)
 { return read8smo_delegate(func, name, tag, obj); }
@@ -262,6 +336,10 @@ template <typename L>
 inline std::enable_if_t<std::is_constructible<read8_delegate, L, const char *>::value, read8_delegate> make_lr8_delegate(L l, const char *name)
 { return read8_delegate(l, name); }
 
+template <typename L>
+inline std::enable_if_t<std::is_constructible<read8m_delegate, L, const char *>::value, read8m_delegate> make_lr8_delegate(L l, const char *name)
+{ return read8m_delegate(l, name); }
+
 template <typename L>
 inline std::enable_if_t<std::is_constructible<read8s_delegate, L, const char *>::value, read8s_delegate> make_lr8_delegate(L l, const char *name)
 { return read8s_delegate(l, name); }
@@ -270,6 +348,10 @@ template <typename L>
 inline std::enable_if_t<std::is_constructible<read8sm_delegate, L, const char *>::value, read8sm_delegate> make_lr8_delegate(L l, const char *name)
 { return read8sm_delegate(l, name); }
 
+template <typename L>
+inline std::enable_if_t<std::is_constructible<read8mo_delegate, L, const char *>::value, read8mo_delegate> make_lr8_delegate(L l, const char *name)
+{ return read8mo_delegate(l, name); }
+
 template <typename L>
 inline std::enable_if_t<std::is_constructible<read8smo_delegate, L, const char *>::value, read8smo_delegate> make_lr8_delegate(L l, const char *name)
 { return read8smo_delegate(l, name); }
@@ -278,6 +360,10 @@ template <typename L>
 inline std::enable_if_t<std::is_constructible<read16_delegate, L, const char *>::value, read16_delegate> make_lr16_delegate(L l, const char *name)
 { return read16_delegate(l, name); }
 
+template <typename L>
+inline std::enable_if_t<std::is_constructible<read16m_delegate, L, const char *>::value, read16m_delegate> make_lr16_delegate(L l, const char *name)
+{ return read16m_delegate(l, name); }
+
 template <typename L>
 inline std::enable_if_t<std::is_constructible<read16s_delegate, L, const char *>::value, read16s_delegate> make_lr16_delegate(L l, const char *name)
 { return read16s_delegate(l, name); }
@@ -286,6 +372,10 @@ template <typename L>
 inline std::enable_if_t<std::is_constructible<read16sm_delegate, L, const char *>::value, read16sm_delegate> make_lr16_delegate(L l, const char *name)
 { return read16sm_delegate(l, name); }
 
+template <typename L>
+inline std::enable_if_t<std::is_constructible<read16mo_delegate, L, const char *>::value, read16mo_delegate> make_lr16_delegate(L l, const char *name)
+{ return read16mo_delegate(l, name); }
+
 template <typename L>
 inline std::enable_if_t<std::is_constructible<read16smo_delegate, L, const char *>::value, read16smo_delegate> make_lr16_delegate(L l, const char *name)
 { return read16smo_delegate(l, name); }
@@ -294,6 +384,10 @@ template <typename L>
 inline std::enable_if_t<std::is_constructible<read32_delegate, L, const char *>::value, read32_delegate> make_lr32_delegate(L l, const char *name)
 { return read32_delegate(l, name); }
 
+template <typename L>
+inline std::enable_if_t<std::is_constructible<read32m_delegate, L, const char *>::value, read32m_delegate> make_lr32_delegate(L l, const char *name)
+{ return read32m_delegate(l, name); }
+
 template <typename L>
 inline std::enable_if_t<std::is_constructible<read32s_delegate, L, const char *>::value, read32s_delegate> make_lr32_delegate(L l, const char *name)
 { return read32s_delegate(l, name); }
@@ -302,6 +396,10 @@ template <typename L>
 inline std::enable_if_t<std::is_constructible<read32sm_delegate, L, const char *>::value, read32sm_delegate> make_lr32_delegate(L l, const char *name)
 { return read32sm_delegate(l, name); }
 
+template <typename L>
+inline std::enable_if_t<std::is_constructible<read32mo_delegate, L, const char *>::value, read32mo_delegate> make_lr32_delegate(L l, const char *name)
+{ return read32mo_delegate(l, name); }
+
 template <typename L>
 inline std::enable_if_t<std::is_constructible<read32smo_delegate, L, const char *>::value, read32smo_delegate> make_lr32_delegate(L l, const char *name)
 { return read32smo_delegate(l, name); }
@@ -310,6 +408,10 @@ template <typename L>
 inline std::enable_if_t<std::is_constructible<read64_delegate, L, const char *>::value, read64_delegate> make_lr64_delegate(L l, const char *name)
 { return read64_delegate(l, name); }
 
+template <typename L>
+inline std::enable_if_t<std::is_constructible<read64m_delegate, L, const char *>::value, read64m_delegate> make_lr64_delegate(L l, const char *name)
+{ return read64m_delegate(l, name); }
+
 template <typename L>
 inline std::enable_if_t<std::is_constructible<read64s_delegate, L, const char *>::value, read64s_delegate> make_lr64_delegate(L l, const char *name)
 { return read64s_delegate(l, name); }
@@ -318,6 +420,10 @@ template <typename L>
 inline std::enable_if_t<std::is_constructible<read64sm_delegate, L, const char *>::value, read64sm_delegate> make_lr64_delegate(L l, const char *name)
 { return read64sm_delegate(l, name); }
 
+template <typename L>
+inline std::enable_if_t<std::is_constructible<read64mo_delegate, L, const char *>::value, read64mo_delegate> make_lr64_delegate(L l, const char *name)
+{ return read64mo_delegate(l, name); }
+
 template <typename L>
 inline std::enable_if_t<std::is_constructible<read64smo_delegate, L, const char *>::value, read64smo_delegate> make_lr64_delegate(L l, const char *name)
 { return read64smo_delegate(l, name); }
@@ -327,6 +433,10 @@ template <typename L>
 inline std::enable_if_t<std::is_constructible<write8_delegate, L, const char *>::value, write8_delegate> make_lw8_delegate(L l, const char *name)
 { return write8_delegate(l, name); }
 
+template <typename L>
+inline std::enable_if_t<std::is_constructible<write8m_delegate, L, const char *>::value, write8m_delegate> make_lw8_delegate(L l, const char *name)
+{ return write8m_delegate(l, name); }
+
 template <typename L>
 inline std::enable_if_t<std::is_constructible<write8s_delegate, L, const char *>::value, write8s_delegate> make_lw8_delegate(L l, const char *name)
 { return write8s_delegate(l, name); }
@@ -335,6 +445,10 @@ template <typename L>
 inline std::enable_if_t<std::is_constructible<write8sm_delegate, L, const char *>::value, write8sm_delegate> make_lw8_delegate(L l, const char *name)
 { return write8sm_delegate(l, name); }
 
+template <typename L>
+inline std::enable_if_t<std::is_constructible<write8mo_delegate, L, const char *>::value, write8mo_delegate> make_lw8_delegate(L l, const char *name)
+{ return write8mo_delegate(l, name); }
+
 template <typename L>
 inline std::enable_if_t<std::is_constructible<write8smo_delegate, L, const char *>::value, write8smo_delegate> make_lw8_delegate(L l, const char *name)
 { return write8smo_delegate(l, name); }
@@ -343,6 +457,10 @@ template <typename L>
 inline std::enable_if_t<std::is_constructible<write16_delegate, L, const char *>::value, write16_delegate> make_lw16_delegate(L l, const char *name)
 { return write16_delegate(l, name); }
 
+template <typename L>
+inline std::enable_if_t<std::is_constructible<write16m_delegate, L, const char *>::value, write16m_delegate> make_lw16_delegate(L l, const char *name)
+{ return write16m_delegate(l, name); }
+
 template <typename L>
 inline std::enable_if_t<std::is_constructible<write16s_delegate, L, const char *>::value, write16s_delegate> make_lw16_delegate(L l, const char *name)
 { return write16s_delegate(l, name); }
@@ -351,6 +469,10 @@ template <typename L>
 inline std::enable_if_t<std::is_constructible<write16sm_delegate, L, const char *>::value, write16sm_delegate> make_lw16_delegate(L l, const char *name)
 { return write16sm_delegate(l, name); }
 
+template <typename L>
+inline std::enable_if_t<std::is_constructible<write16mo_delegate, L, const char *>::value, write16mo_delegate> make_lw16_delegate(L l, const char *name)
+{ return write16mo_delegate(l, name); }
+
 template <typename L>
 inline std::enable_if_t<std::is_constructible<write16smo_delegate, L, const char *>::value, write16smo_delegate> make_lw16_delegate(L l, const char *name)
 { return write16smo_delegate(l, name); }
@@ -359,6 +481,10 @@ template <typename L>
 inline std::enable_if_t<std::is_constructible<write32_delegate, L, const char *>::value, write32_delegate> make_lw32_delegate(L l, const char *name)
 { return write32_delegate(l, name); }
 
+template <typename L>
+inline std::enable_if_t<std::is_constructible<write32m_delegate, L, const char *>::value, write32m_delegate> make_lw32_delegate(L l, const char *name)
+{ return write32m_delegate(l, name); }
+
 template <typename L>
 inline std::enable_if_t<std::is_constructible<write32s_delegate, L, const char *>::value, write32s_delegate> make_lw32_delegate(L l, const char *name)
 { return write32s_delegate(l, name); }
@@ -367,6 +493,10 @@ template <typename L>
 inline std::enable_if_t<std::is_constructible<write32sm_delegate, L, const char *>::value, write32sm_delegate> make_lw32_delegate(L l, const char *name)
 { return write32sm_delegate(l, name); }
 
+template <typename L>
+inline std::enable_if_t<std::is_constructible<write32mo_delegate, L, const char *>::value, write32mo_delegate> make_lw32_delegate(L l, const char *name)
+{ return write32mo_delegate(l, name); }
+
 template <typename L>
 inline std::enable_if_t<std::is_constructible<write32smo_delegate, L, const char *>::value, write32smo_delegate> make_lw32_delegate(L l, const char *name)
 { return write32smo_delegate(l, name); }
@@ -375,6 +505,10 @@ template <typename L>
 inline std::enable_if_t<std::is_constructible<write64_delegate, L, const char *>::value, write64_delegate> make_lw64_delegate(L l, const char *name)
 { return write64_delegate(l, name); }
 
+template <typename L>
+inline std::enable_if_t<std::is_constructible<write64m_delegate, L, const char *>::value, write64m_delegate> make_lw64_delegate(L l, const char *name)
+{ return write64m_delegate(l, name); }
+
 template <typename L>
 inline std::enable_if_t<std::is_constructible<write64s_delegate, L, const char *>::value, write64s_delegate> make_lw64_delegate(L l, const char *name)
 { return write64s_delegate(l, name); }
@@ -383,6 +517,10 @@ template <typename L>
 inline std::enable_if_t<std::is_constructible<write64sm_delegate, L, const char *>::value, write64sm_delegate> make_lw64_delegate(L l, const char *name)
 { return write64sm_delegate(l, name); }
 
+template <typename L>
+inline std::enable_if_t<std::is_constructible<write64mo_delegate, L, const char *>::value, write64mo_delegate> make_lw64_delegate(L l, const char *name)
+{ return write64mo_delegate(l, name); }
+
 template <typename L>
 inline std::enable_if_t<std::is_constructible<write64smo_delegate, L, const char *>::value, write64smo_delegate> make_lw64_delegate(L l, const char *name)
 { return write64smo_delegate(l, name); }
@@ -1240,6 +1378,19 @@ public:
 	void install_write_handler(offs_t addrstart, offs_t addrend, write64_delegate whandler, u64 unitmask = 0, int cswidth = 0) { install_write_handler(addrstart, addrend, 0, 0, 0, whandler, unitmask, cswidth); }
 	void install_readwrite_handler(offs_t addrstart, offs_t addrend, read64_delegate rhandler, write64_delegate whandler, u64 unitmask = 0, int cswidth = 0) { install_readwrite_handler(addrstart, addrend, 0, 0, 0, rhandler, whandler, unitmask, cswidth); }
 
+	void install_read_handler(offs_t addrstart, offs_t addrend, read8m_delegate rhandler, u64 unitmask = 0, int cswidth = 0) { install_read_handler(addrstart, addrend, 0, 0, 0, rhandler, unitmask, cswidth); }
+	void install_write_handler(offs_t addrstart, offs_t addrend, write8m_delegate whandler, u64 unitmask = 0, int cswidth = 0) { install_write_handler(addrstart, addrend, 0, 0, 0, whandler, unitmask, cswidth); }
+	void install_readwrite_handler(offs_t addrstart, offs_t addrend, read8m_delegate rhandler, write8m_delegate whandler, u64 unitmask = 0, int cswidth = 0) { return install_readwrite_handler(addrstart, addrend, 0, 0, 0, rhandler, whandler, unitmask, cswidth); }
+	void install_read_handler(offs_t addrstart, offs_t addrend, read16m_delegate rhandler, u64 unitmask = 0, int cswidth = 0) { install_read_handler(addrstart, addrend, 0, 0, 0, rhandler, unitmask, cswidth); }
+	void install_write_handler(offs_t addrstart, offs_t addrend, write16m_delegate whandler, u64 unitmask = 0, int cswidth = 0) { install_write_handler(addrstart, addrend, 0, 0, 0, whandler, unitmask, cswidth); }
+	void install_readwrite_handler(offs_t addrstart, offs_t addrend, read16m_delegate rhandler, write16m_delegate whandler, u64 unitmask = 0, int cswidth = 0) { return install_readwrite_handler(addrstart, addrend, 0, 0, 0, rhandler, whandler, unitmask, cswidth); }
+	void install_read_handler(offs_t addrstart, offs_t addrend, read32m_delegate rhandler, u64 unitmask = 0, int cswidth = 0) { install_read_handler(addrstart, addrend, 0, 0, 0, rhandler, unitmask, cswidth); }
+	void install_write_handler(offs_t addrstart, offs_t addrend, write32m_delegate whandler, u64 unitmask = 0, int cswidth = 0) { install_write_handler(addrstart, addrend, 0, 0, 0, whandler, unitmask, cswidth); }
+	void install_readwrite_handler(offs_t addrstart, offs_t addrend, read32m_delegate rhandler, write32m_delegate whandler, u64 unitmask = 0, int cswidth = 0) { return install_readwrite_handler(addrstart, addrend, 0, 0, 0, rhandler, whandler, unitmask, cswidth); }
+	void install_read_handler(offs_t addrstart, offs_t addrend, read64m_delegate rhandler, u64 unitmask = 0, int cswidth = 0) { install_read_handler(addrstart, addrend, 0, 0, 0, rhandler, unitmask, cswidth); }
+	void install_write_handler(offs_t addrstart, offs_t addrend, write64m_delegate whandler, u64 unitmask = 0, int cswidth = 0) { install_write_handler(addrstart, addrend, 0, 0, 0, whandler, unitmask, cswidth); }
+	void install_readwrite_handler(offs_t addrstart, offs_t addrend, read64m_delegate rhandler, write64m_delegate whandler, u64 unitmask = 0, int cswidth = 0) { install_readwrite_handler(addrstart, addrend, 0, 0, 0, rhandler, whandler, unitmask, cswidth); }
+
 	void install_read_handler(offs_t addrstart, offs_t addrend, read8s_delegate rhandler, u64 unitmask = 0, int cswidth = 0) { install_read_handler(addrstart, addrend, 0, 0, 0, rhandler, unitmask, cswidth); }
 	void install_write_handler(offs_t addrstart, offs_t addrend, write8s_delegate whandler, u64 unitmask = 0, int cswidth = 0) { install_write_handler(addrstart, addrend, 0, 0, 0, whandler, unitmask, cswidth); }
 	void install_readwrite_handler(offs_t addrstart, offs_t addrend, read8s_delegate rhandler, write8s_delegate whandler, u64 unitmask = 0, int cswidth = 0) { return install_readwrite_handler(addrstart, addrend, 0, 0, 0, rhandler, whandler, unitmask, cswidth); }
@@ -1266,6 +1417,19 @@ public:
 	void install_write_handler(offs_t addrstart, offs_t addrend, write64sm_delegate whandler, u64 unitmask = 0, int cswidth = 0) { install_write_handler(addrstart, addrend, 0, 0, 0, whandler, unitmask, cswidth); }
 	void install_readwrite_handler(offs_t addrstart, offs_t addrend, read64sm_delegate rhandler, write64sm_delegate whandler, u64 unitmask = 0, int cswidth = 0) { install_readwrite_handler(addrstart, addrend, 0, 0, 0, rhandler, whandler, unitmask, cswidth); }
 
+	void install_read_handler(offs_t addrstart, offs_t addrend, read8mo_delegate rhandler, u64 unitmask = 0, int cswidth = 0) { install_read_handler(addrstart, addrend, 0, 0, 0, rhandler, unitmask, cswidth); }
+	void install_write_handler(offs_t addrstart, offs_t addrend, write8mo_delegate whandler, u64 unitmask = 0, int cswidth = 0) { install_write_handler(addrstart, addrend, 0, 0, 0, whandler, unitmask, cswidth); }
+	void install_readwrite_handler(offs_t addrstart, offs_t addrend, read8mo_delegate rhandler, write8mo_delegate whandler, u64 unitmask = 0, int cswidth = 0) { return install_readwrite_handler(addrstart, addrend, 0, 0, 0, rhandler, whandler, unitmask, cswidth); }
+	void install_read_handler(offs_t addrstart, offs_t addrend, read16mo_delegate rhandler, u64 unitmask = 0, int cswidth = 0) { install_read_handler(addrstart, addrend, 0, 0, 0, rhandler, unitmask, cswidth); }
+	void install_write_handler(offs_t addrstart, offs_t addrend, write16mo_delegate whandler, u64 unitmask = 0, int cswidth = 0) { install_write_handler(addrstart, addrend, 0, 0, 0, whandler, unitmask, cswidth); }
+	void install_readwrite_handler(offs_t addrstart, offs_t addrend, read16mo_delegate rhandler, write16mo_delegate whandler, u64 unitmask = 0, int cswidth = 0) { return install_readwrite_handler(addrstart, addrend, 0, 0, 0, rhandler, whandler, unitmask, cswidth); }
+	void install_read_handler(offs_t addrstart, offs_t addrend, read32mo_delegate rhandler, u64 unitmask = 0, int cswidth = 0) { install_read_handler(addrstart, addrend, 0, 0, 0, rhandler, unitmask, cswidth); }
+	void install_write_handler(offs_t addrstart, offs_t addrend, write32mo_delegate whandler, u64 unitmask = 0, int cswidth = 0) { install_write_handler(addrstart, addrend, 0, 0, 0, whandler, unitmask, cswidth); }
+	void install_readwrite_handler(offs_t addrstart, offs_t addrend, read32mo_delegate rhandler, write32mo_delegate whandler, u64 unitmask = 0, int cswidth = 0) { return install_readwrite_handler(addrstart, addrend, 0, 0, 0, rhandler, whandler, unitmask, cswidth); }
+	void install_read_handler(offs_t addrstart, offs_t addrend, read64mo_delegate rhandler, u64 unitmask = 0, int cswidth = 0) { install_read_handler(addrstart, addrend, 0, 0, 0, rhandler, unitmask, cswidth); }
+	void install_write_handler(offs_t addrstart, offs_t addrend, write64mo_delegate whandler, u64 unitmask = 0, int cswidth = 0) { install_write_handler(addrstart, addrend, 0, 0, 0, whandler, unitmask, cswidth); }
+	void install_readwrite_handler(offs_t addrstart, offs_t addrend, read64mo_delegate rhandler, write64mo_delegate whandler, u64 unitmask = 0, int cswidth = 0) { install_readwrite_handler(addrstart, addrend, 0, 0, 0, rhandler, whandler, unitmask, cswidth); }
+
 	void install_read_handler(offs_t addrstart, offs_t addrend, read8smo_delegate rhandler, u64 unitmask = 0, int cswidth = 0) { install_read_handler(addrstart, addrend, 0, 0, 0, rhandler, unitmask, cswidth); }
 	void install_write_handler(offs_t addrstart, offs_t addrend, write8smo_delegate whandler, u64 unitmask = 0, int cswidth = 0) { install_write_handler(addrstart, addrend, 0, 0, 0, whandler, unitmask, cswidth); }
 	void install_readwrite_handler(offs_t addrstart, offs_t addrend, read8smo_delegate rhandler, write8smo_delegate whandler, u64 unitmask = 0, int cswidth = 0) { return install_readwrite_handler(addrstart, addrend, 0, 0, 0, rhandler, whandler, unitmask, cswidth); }
@@ -1293,6 +1457,19 @@ public:
 	virtual void install_write_handler(offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, offs_t addrselect, write64_delegate whandler, u64 unitmask = 0, int cswidth = 0) = 0;
 	virtual void install_readwrite_handler(offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, offs_t addrselect, read64_delegate rhandler, write64_delegate whandler, u64 unitmask = 0, int cswidth = 0) = 0;
 
+	virtual void install_read_handler(offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, offs_t addrselect, read8m_delegate rhandler, u64 unitmask = 0, int cswidth = 0) = 0;
+	virtual void install_write_handler(offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, offs_t addrselect, write8m_delegate whandler, u64 unitmask = 0, int cswidth = 0) = 0;
+	virtual void install_readwrite_handler(offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, offs_t addrselect, read8m_delegate rhandler, write8m_delegate whandler, u64 unitmask = 0, int cswidth = 0) = 0;
+	virtual void install_read_handler(offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, offs_t addrselect, read16m_delegate rhandler, u64 unitmask = 0, int cswidth = 0) = 0;
+	virtual void install_write_handler(offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, offs_t addrselect, write16m_delegate whandler, u64 unitmask = 0, int cswidth = 0) = 0;
+	virtual void install_readwrite_handler(offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, offs_t addrselect, read16m_delegate rhandler, write16m_delegate whandler, u64 unitmask = 0, int cswidth = 0) = 0;
+	virtual void install_read_handler(offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, offs_t addrselect, read32m_delegate rhandler, u64 unitmask = 0, int cswidth = 0) = 0;
+	virtual void install_write_handler(offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, offs_t addrselect, write32m_delegate whandler, u64 unitmask = 0, int cswidth = 0) = 0;
+	virtual void install_readwrite_handler(offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, offs_t addrselect, read32m_delegate rhandler, write32m_delegate whandler, u64 unitmask = 0, int cswidth = 0) = 0;
+	virtual void install_read_handler(offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, offs_t addrselect, read64m_delegate rhandler, u64 unitmask = 0, int cswidth = 0) = 0;
+	virtual void install_write_handler(offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, offs_t addrselect, write64m_delegate whandler, u64 unitmask = 0, int cswidth = 0) = 0;
+	virtual void install_readwrite_handler(offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, offs_t addrselect, read64m_delegate rhandler, write64m_delegate whandler, u64 unitmask = 0, int cswidth = 0) = 0;
+
 	virtual void install_read_handler(offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, offs_t addrselect, read8s_delegate rhandler, u64 unitmask = 0, int cswidth = 0) = 0;
 	virtual void install_write_handler(offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, offs_t addrselect, write8s_delegate whandler, u64 unitmask = 0, int cswidth = 0) = 0;
 	virtual void install_readwrite_handler(offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, offs_t addrselect, read8s_delegate rhandler, write8s_delegate whandler, u64 unitmask = 0, int cswidth = 0) = 0;
@@ -1319,6 +1496,19 @@ public:
 	virtual void install_write_handler(offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, offs_t addrselect, write64sm_delegate whandler, u64 unitmask = 0, int cswidth = 0) = 0;
 	virtual void install_readwrite_handler(offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, offs_t addrselect, read64sm_delegate rhandler, write64sm_delegate whandler, u64 unitmask = 0, int cswidth = 0) = 0;
 
+	virtual void install_read_handler(offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, offs_t addrselect, read8mo_delegate rhandler, u64 unitmask = 0, int cswidth = 0) = 0;
+	virtual void install_write_handler(offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, offs_t addrselect, write8mo_delegate whandler, u64 unitmask = 0, int cswidth = 0) = 0;
+	virtual void install_readwrite_handler(offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, offs_t addrselect, read8mo_delegate rhandler, write8mo_delegate whandler, u64 unitmask = 0, int cswidth = 0) = 0;
+	virtual void install_read_handler(offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, offs_t addrselect, read16mo_delegate rhandler, u64 unitmask = 0, int cswidth = 0) = 0;
+	virtual void install_write_handler(offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, offs_t addrselect, write16mo_delegate whandler, u64 unitmask = 0, int cswidth = 0) = 0;
+	virtual void install_readwrite_handler(offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, offs_t addrselect, read16mo_delegate rhandler, write16mo_delegate whandler, u64 unitmask = 0, int cswidth = 0) = 0;
+	virtual void install_read_handler(offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, offs_t addrselect, read32mo_delegate rhandler, u64 unitmask = 0, int cswidth = 0) = 0;
+	virtual void install_write_handler(offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, offs_t addrselect, write32mo_delegate whandler, u64 unitmask = 0, int cswidth = 0) = 0;
+	virtual void install_readwrite_handler(offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, offs_t addrselect, read32mo_delegate rhandler, write32mo_delegate whandler, u64 unitmask = 0, int cswidth = 0) = 0;
+	virtual void install_read_handler(offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, offs_t addrselect, read64mo_delegate rhandler, u64 unitmask = 0, int cswidth = 0) = 0;
+	virtual void install_write_handler(offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, offs_t addrselect, write64mo_delegate whandler, u64 unitmask = 0, int cswidth = 0) = 0;
+	virtual void install_readwrite_handler(offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, offs_t addrselect, read64mo_delegate rhandler, write64mo_delegate whandler, u64 unitmask = 0, int cswidth = 0) = 0;
+
 	virtual void install_read_handler(offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, offs_t addrselect, read8smo_delegate rhandler, u64 unitmask = 0, int cswidth = 0) = 0;
 	virtual void install_write_handler(offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, offs_t addrselect, write8smo_delegate whandler, u64 unitmask = 0, int cswidth = 0) = 0;
 	virtual void install_readwrite_handler(offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, offs_t addrselect, read8smo_delegate rhandler, write8smo_delegate whandler, u64 unitmask = 0, int cswidth = 0) = 0;
diff --git a/src/emu/emumem_hedp.cpp b/src/emu/emumem_hedp.cpp
index c0215493193..84b43191d1d 100644
--- a/src/emu/emumem_hedp.cpp
+++ b/src/emu/emumem_hedp.cpp
@@ -15,6 +15,16 @@ template<int Width, int AddrShift, int Endian, typename READ> template<typename
 	return m_delegate(*inh::m_space, ((offset - inh::m_address_base) & inh::m_address_mask) >> (Width + AddrShift), mem_mask);
 }
 
+template<int Width, int AddrShift, int Endian, typename READ> template<typename R> 
+    std::enable_if_t<std::is_same<R, read8m_delegate>::value ||
+                     std::is_same<R, read16m_delegate>::value ||
+                     std::is_same<R, read32m_delegate>::value ||
+                     std::is_same<R, read64m_delegate>::value,
+                     typename emu::detail::handler_entry_size<Width>::uX> handler_entry_read_delegate<Width, AddrShift, Endian, READ>::read_impl(offs_t offset, uX mem_mask)
+{
+	return m_delegate(*inh::m_space, ((offset - inh::m_address_base) & inh::m_address_mask) >> (Width + AddrShift));
+}
+
 template<int Width, int AddrShift, int Endian, typename READ> template<typename R> 
     std::enable_if_t<std::is_same<R, read8s_delegate>::value ||
                      std::is_same<R, read16s_delegate>::value ||
@@ -35,6 +45,16 @@ template<int Width, int AddrShift, int Endian, typename READ> template<typename
 	return m_delegate(((offset - inh::m_address_base) & inh::m_address_mask) >> (Width + AddrShift));
 }
 
+template<int Width, int AddrShift, int Endian, typename READ> template<typename R> 
+    std::enable_if_t<std::is_same<R, read8mo_delegate>::value ||
+                     std::is_same<R, read16mo_delegate>::value ||
+                     std::is_same<R, read32mo_delegate>::value ||
+                     std::is_same<R, read64mo_delegate>::value,
+                     typename emu::detail::handler_entry_size<Width>::uX> handler_entry_read_delegate<Width, AddrShift, Endian, READ>::read_impl(offs_t offset, uX mem_mask)
+{
+	return m_delegate(*inh::m_space);
+}
+
 template<int Width, int AddrShift, int Endian, typename READ> template<typename R> 
     std::enable_if_t<std::is_same<R, read8smo_delegate>::value ||
                      std::is_same<R, read16smo_delegate>::value ||
@@ -65,6 +85,16 @@ template<int Width, int AddrShift, int Endian, typename WRITE> template<typename
 	m_delegate(*inh::m_space, ((offset - inh::m_address_base) & inh::m_address_mask) >> (Width + AddrShift), data, mem_mask);
 }
 
+template<int Width, int AddrShift, int Endian, typename WRITE> template<typename W>
+    std::enable_if_t<std::is_same<W, write8m_delegate>::value ||
+                     std::is_same<W, write16m_delegate>::value ||
+                     std::is_same<W, write32m_delegate>::value ||
+                     std::is_same<W, write64m_delegate>::value,
+                     void> handler_entry_write_delegate<Width, AddrShift, Endian, WRITE>::write_impl(offs_t offset, uX data, uX mem_mask)
+{
+	m_delegate(*inh::m_space, ((offset - inh::m_address_base) & inh::m_address_mask) >> (Width + AddrShift), data);
+}
+
 template<int Width, int AddrShift, int Endian, typename WRITE> template<typename W>
     std::enable_if_t<std::is_same<W, write8s_delegate>::value ||
                      std::is_same<W, write16s_delegate>::value ||
@@ -85,6 +115,16 @@ template<int Width, int AddrShift, int Endian, typename WRITE> template<typename
 	m_delegate(((offset - inh::m_address_base) & inh::m_address_mask) >> (Width + AddrShift), data);
 }
 
+template<int Width, int AddrShift, int Endian, typename WRITE> template<typename W>
+    std::enable_if_t<std::is_same<W, write8mo_delegate>::value ||
+                     std::is_same<W, write16mo_delegate>::value ||
+                     std::is_same<W, write32mo_delegate>::value ||
+                     std::is_same<W, write64mo_delegate>::value,
+                     void> handler_entry_write_delegate<Width, AddrShift, Endian, WRITE>::write_impl(offs_t offset, uX data, uX mem_mask)
+{
+  m_delegate(*inh::m_space, data);
+}
+
 template<int Width, int AddrShift, int Endian, typename WRITE> template<typename W>
     std::enable_if_t<std::is_same<W, write8smo_delegate>::value ||
                      std::is_same<W, write16smo_delegate>::value ||
@@ -153,6 +193,29 @@ template class handler_entry_read_delegate<3, -2, ENDIANNESS_BIG,    read64_dele
 template class handler_entry_read_delegate<3, -3, ENDIANNESS_LITTLE, read64_delegate>;
 template class handler_entry_read_delegate<3, -3, ENDIANNESS_BIG,    read64_delegate>;
 
+template class handler_entry_read_delegate<0,  0, ENDIANNESS_LITTLE, read8m_delegate>;
+template class handler_entry_read_delegate<0,  0, ENDIANNESS_BIG,    read8m_delegate>;
+template class handler_entry_read_delegate<1,  3, ENDIANNESS_LITTLE, read16m_delegate>;
+template class handler_entry_read_delegate<1,  3, ENDIANNESS_BIG,    read16m_delegate>;
+template class handler_entry_read_delegate<1,  0, ENDIANNESS_LITTLE, read16m_delegate>;
+template class handler_entry_read_delegate<1,  0, ENDIANNESS_BIG,    read16m_delegate>;
+template class handler_entry_read_delegate<1, -1, ENDIANNESS_LITTLE, read16m_delegate>;
+template class handler_entry_read_delegate<1, -1, ENDIANNESS_BIG,    read16m_delegate>;
+template class handler_entry_read_delegate<2,  0, ENDIANNESS_LITTLE, read32m_delegate>;
+template class handler_entry_read_delegate<2,  0, ENDIANNESS_BIG,    read32m_delegate>;
+template class handler_entry_read_delegate<2, -1, ENDIANNESS_LITTLE, read32m_delegate>;
+template class handler_entry_read_delegate<2, -1, ENDIANNESS_BIG,    read32m_delegate>;
+template class handler_entry_read_delegate<2, -2, ENDIANNESS_LITTLE, read32m_delegate>;
+template class handler_entry_read_delegate<2, -2, ENDIANNESS_BIG,    read32m_delegate>;
+template class handler_entry_read_delegate<3,  0, ENDIANNESS_LITTLE, read64m_delegate>;
+template class handler_entry_read_delegate<3,  0, ENDIANNESS_BIG,    read64m_delegate>;
+template class handler_entry_read_delegate<3, -1, ENDIANNESS_LITTLE, read64m_delegate>;
+template class handler_entry_read_delegate<3, -1, ENDIANNESS_BIG,    read64m_delegate>;
+template class handler_entry_read_delegate<3, -2, ENDIANNESS_LITTLE, read64m_delegate>;
+template class handler_entry_read_delegate<3, -2, ENDIANNESS_BIG,    read64m_delegate>;
+template class handler_entry_read_delegate<3, -3, ENDIANNESS_LITTLE, read64m_delegate>;
+template class handler_entry_read_delegate<3, -3, ENDIANNESS_BIG,    read64m_delegate>;
+
 template class handler_entry_read_delegate<0,  0, ENDIANNESS_LITTLE, read8s_delegate>;
 template class handler_entry_read_delegate<0,  0, ENDIANNESS_BIG,    read8s_delegate>;
 template class handler_entry_read_delegate<1,  3, ENDIANNESS_LITTLE, read16s_delegate>;
@@ -199,6 +262,29 @@ template class handler_entry_read_delegate<3, -2, ENDIANNESS_BIG,    read64sm_de
 template class handler_entry_read_delegate<3, -3, ENDIANNESS_LITTLE, read64sm_delegate>;
 template class handler_entry_read_delegate<3, -3, ENDIANNESS_BIG,    read64sm_delegate>;
 
+template class handler_entry_read_delegate<0,  0, ENDIANNESS_LITTLE, read8mo_delegate>;
+template class handler_entry_read_delegate<0,  0, ENDIANNESS_BIG,    read8mo_delegate>;
+template class handler_entry_read_delegate<1,  3, ENDIANNESS_LITTLE, read16mo_delegate>;
+template class handler_entry_read_delegate<1,  3, ENDIANNESS_BIG,    read16mo_delegate>;
+template class handler_entry_read_delegate<1,  0, ENDIANNESS_LITTLE, read16mo_delegate>;
+template class handler_entry_read_delegate<1,  0, ENDIANNESS_BIG,    read16mo_delegate>;
+template class handler_entry_read_delegate<1, -1, ENDIANNESS_LITTLE, read16mo_delegate>;
+template class handler_entry_read_delegate<1, -1, ENDIANNESS_BIG,    read16mo_delegate>;
+template class handler_entry_read_delegate<2,  0, ENDIANNESS_LITTLE, read32mo_delegate>;
+template class handler_entry_read_delegate<2,  0, ENDIANNESS_BIG,    read32mo_delegate>;
+template class handler_entry_read_delegate<2, -1, ENDIANNESS_LITTLE, read32mo_delegate>;
+template class handler_entry_read_delegate<2, -1, ENDIANNESS_BIG,    read32mo_delegate>;
+template class handler_entry_read_delegate<2, -2, ENDIANNESS_LITTLE, read32mo_delegate>;
+template class handler_entry_read_delegate<2, -2, ENDIANNESS_BIG,    read32mo_delegate>;
+template class handler_entry_read_delegate<3,  0, ENDIANNESS_LITTLE, read64mo_delegate>;
+template class handler_entry_read_delegate<3,  0, ENDIANNESS_BIG,    read64mo_delegate>;
+template class handler_entry_read_delegate<3, -1, ENDIANNESS_LITTLE, read64mo_delegate>;
+template class handler_entry_read_delegate<3, -1, ENDIANNESS_BIG,    read64mo_delegate>;
+template class handler_entry_read_delegate<3, -2, ENDIANNESS_LITTLE, read64mo_delegate>;
+template class handler_entry_read_delegate<3, -2, ENDIANNESS_BIG,    read64mo_delegate>;
+template class handler_entry_read_delegate<3, -3, ENDIANNESS_LITTLE, read64mo_delegate>;
+template class handler_entry_read_delegate<3, -3, ENDIANNESS_BIG,    read64mo_delegate>;
+
 template class handler_entry_read_delegate<0,  0, ENDIANNESS_LITTLE, read8smo_delegate>;
 template class handler_entry_read_delegate<0,  0, ENDIANNESS_BIG,    read8smo_delegate>;
 template class handler_entry_read_delegate<1,  3, ENDIANNESS_LITTLE, read16smo_delegate>;
@@ -245,6 +331,29 @@ template class handler_entry_write_delegate<3, -2, ENDIANNESS_BIG,    write64_de
 template class handler_entry_write_delegate<3, -3, ENDIANNESS_LITTLE, write64_delegate>;
 template class handler_entry_write_delegate<3, -3, ENDIANNESS_BIG,    write64_delegate>;
 
+template class handler_entry_write_delegate<0,  0, ENDIANNESS_LITTLE, write8m_delegate>;
+template class handler_entry_write_delegate<0,  0, ENDIANNESS_BIG,    write8m_delegate>;
+template class handler_entry_write_delegate<1,  3, ENDIANNESS_LITTLE, write16m_delegate>;
+template class handler_entry_write_delegate<1,  3, ENDIANNESS_BIG,    write16m_delegate>;
+template class handler_entry_write_delegate<1,  0, ENDIANNESS_LITTLE, write16m_delegate>;
+template class handler_entry_write_delegate<1,  0, ENDIANNESS_BIG,    write16m_delegate>;
+template class handler_entry_write_delegate<1, -1, ENDIANNESS_LITTLE, write16m_delegate>;
+template class handler_entry_write_delegate<1, -1, ENDIANNESS_BIG,    write16m_delegate>;
+template class handler_entry_write_delegate<2,  0, ENDIANNESS_LITTLE, write32m_delegate>;
+template class handler_entry_write_delegate<2,  0, ENDIANNESS_BIG,    write32m_delegate>;
+template class handler_entry_write_delegate<2, -1, ENDIANNESS_LITTLE, write32m_delegate>;
+template class handler_entry_write_delegate<2, -1, ENDIANNESS_BIG,    write32m_delegate>;
+template class handler_entry_write_delegate<2, -2, ENDIANNESS_LITTLE, write32m_delegate>;
+template class handler_entry_write_delegate<2, -2, ENDIANNESS_BIG,    write32m_delegate>;
+template class handler_entry_write_delegate<3,  0, ENDIANNESS_LITTLE, write64m_delegate>;
+template class handler_entry_write_delegate<3,  0, ENDIANNESS_BIG,    write64m_delegate>;
+template class handler_entry_write_delegate<3, -1, ENDIANNESS_LITTLE, write64m_delegate>;
+template class handler_entry_write_delegate<3, -1, ENDIANNESS_BIG,    write64m_delegate>;
+template class handler_entry_write_delegate<3, -2, ENDIANNESS_LITTLE, write64m_delegate>;
+template class handler_entry_write_delegate<3, -2, ENDIANNESS_BIG,    write64m_delegate>;
+template class handler_entry_write_delegate<3, -3, ENDIANNESS_LITTLE, write64m_delegate>;
+template class handler_entry_write_delegate<3, -3, ENDIANNESS_BIG,    write64m_delegate>;
+
 template class handler_entry_write_delegate<0,  0, ENDIANNESS_LITTLE, write8s_delegate>;
 template class handler_entry_write_delegate<0,  0, ENDIANNESS_BIG,    write8s_delegate>;
 template class handler_entry_write_delegate<1,  3, ENDIANNESS_LITTLE, write16s_delegate>;
@@ -291,6 +400,29 @@ template class handler_entry_write_delegate<3, -2, ENDIANNESS_BIG,    write64sm_
 template class handler_entry_write_delegate<3, -3, ENDIANNESS_LITTLE, write64sm_delegate>;
 template class handler_entry_write_delegate<3, -3, ENDIANNESS_BIG,    write64sm_delegate>;
 
+template class handler_entry_write_delegate<0,  0, ENDIANNESS_LITTLE, write8mo_delegate>;
+template class handler_entry_write_delegate<0,  0, ENDIANNESS_BIG,    write8mo_delegate>;
+template class handler_entry_write_delegate<1,  3, ENDIANNESS_LITTLE, write16mo_delegate>;
+template class handler_entry_write_delegate<1,  3, ENDIANNESS_BIG,    write16mo_delegate>;
+template class handler_entry_write_delegate<1,  0, ENDIANNESS_LITTLE, write16mo_delegate>;
+template class handler_entry_write_delegate<1,  0, ENDIANNESS_BIG,    write16mo_delegate>;
+template class handler_entry_write_delegate<1, -1, ENDIANNESS_LITTLE, write16mo_delegate>;
+template class handler_entry_write_delegate<1, -1, ENDIANNESS_BIG,    write16mo_delegate>;
+template class handler_entry_write_delegate<2,  0, ENDIANNESS_LITTLE, write32mo_delegate>;
+template class handler_entry_write_delegate<2,  0, ENDIANNESS_BIG,    write32mo_delegate>;
+template class handler_entry_write_delegate<2, -1, ENDIANNESS_LITTLE, write32mo_delegate>;
+template class handler_entry_write_delegate<2, -1, ENDIANNESS_BIG,    write32mo_delegate>;
+template class handler_entry_write_delegate<2, -2, ENDIANNESS_LITTLE, write32mo_delegate>;
+template class handler_entry_write_delegate<2, -2, ENDIANNESS_BIG,    write32mo_delegate>;
+template class handler_entry_write_delegate<3,  0, ENDIANNESS_LITTLE, write64mo_delegate>;
+template class handler_entry_write_delegate<3,  0, ENDIANNESS_BIG,    write64mo_delegate>;
+template class handler_entry_write_delegate<3, -1, ENDIANNESS_LITTLE, write64mo_delegate>;
+template class handler_entry_write_delegate<3, -1, ENDIANNESS_BIG,    write64mo_delegate>;
+template class handler_entry_write_delegate<3, -2, ENDIANNESS_LITTLE, write64mo_delegate>;
+template class handler_entry_write_delegate<3, -2, ENDIANNESS_BIG,    write64mo_delegate>;
+template class handler_entry_write_delegate<3, -3, ENDIANNESS_LITTLE, write64mo_delegate>;
+template class handler_entry_write_delegate<3, -3, ENDIANNESS_BIG,    write64mo_delegate>;
+
 template class handler_entry_write_delegate<0,  0, ENDIANNESS_LITTLE, write8smo_delegate>;
 template class handler_entry_write_delegate<0,  0, ENDIANNESS_BIG,    write8smo_delegate>;
 template class handler_entry_write_delegate<1,  3, ENDIANNESS_LITTLE, write16smo_delegate>;
diff --git a/src/emu/emumem_hedp.h b/src/emu/emumem_hedp.h
index af16088f21e..4b21085f7a9 100644
--- a/src/emu/emumem_hedp.h
+++ b/src/emu/emumem_hedp.h
@@ -28,6 +28,13 @@ private:
                          std::is_same<R, read64_delegate>::value,
 	                     uX> read_impl(offs_t offset, uX mem_mask);
 
+    template<typename R>
+        std::enable_if_t<std::is_same<R, read8m_delegate>::value ||
+                         std::is_same<R, read16m_delegate>::value ||
+                         std::is_same<R, read32m_delegate>::value ||
+                         std::is_same<R, read64m_delegate>::value,
+	                     uX> read_impl(offs_t offset, uX mem_mask);
+
     template<typename R>
         std::enable_if_t<std::is_same<R, read8s_delegate>::value ||
                          std::is_same<R, read16s_delegate>::value ||
@@ -42,6 +49,13 @@ private:
                          std::is_same<R, read64sm_delegate>::value,
 	                     uX> read_impl(offs_t offset, uX mem_mask);
 
+    template<typename R>
+        std::enable_if_t<std::is_same<R, read8mo_delegate>::value ||
+                         std::is_same<R, read16mo_delegate>::value ||
+                         std::is_same<R, read32mo_delegate>::value ||
+                         std::is_same<R, read64mo_delegate>::value,
+	                     uX> read_impl(offs_t offset, uX mem_mask);
+
     template<typename R>
         std::enable_if_t<std::is_same<R, read8smo_delegate>::value ||
                          std::is_same<R, read16smo_delegate>::value ||
@@ -73,6 +87,13 @@ private:
                          std::is_same<W, write64_delegate>::value,
 	                     void> write_impl(offs_t offset, uX data, uX mem_mask);
 
+    template<typename W>
+        std::enable_if_t<std::is_same<W, write8m_delegate>::value ||
+                         std::is_same<W, write16m_delegate>::value ||
+                         std::is_same<W, write32m_delegate>::value ||
+                         std::is_same<W, write64m_delegate>::value,
+	                     void> write_impl(offs_t offset, uX data, uX mem_mask);
+
     template<typename W>
         std::enable_if_t<std::is_same<W, write8s_delegate>::value ||
                          std::is_same<W, write16s_delegate>::value ||
@@ -87,6 +108,13 @@ private:
                          std::is_same<W, write64sm_delegate>::value,
 	                     void> write_impl(offs_t offset, uX data, uX mem_mask);
 
+    template<typename W>
+        std::enable_if_t<std::is_same<W, write8mo_delegate>::value ||
+                         std::is_same<W, write16mo_delegate>::value ||
+                         std::is_same<W, write32mo_delegate>::value ||
+                         std::is_same<W, write64mo_delegate>::value,
+	                     void> write_impl(offs_t offset, uX data, uX mem_mask);
+
     template<typename W>
         std::enable_if_t<std::is_same<W, write8smo_delegate>::value ||
                          std::is_same<W, write16smo_delegate>::value ||
diff --git a/src/frontend/mame/luaengine.cpp b/src/frontend/mame/luaengine.cpp
index c8d9b81b2f1..ddae8e8aeb6 100644
--- a/src/frontend/mame/luaengine.cpp
+++ b/src/frontend/mame/luaengine.cpp
@@ -201,9 +201,11 @@ namespace sol
 					case AMH_UNMAP:
 						typestr = "unmap";
 						break;
-					case AMH_DEVICE_DELEGATE_F:
+					case AMH_DEVICE_DELEGATE:
+					case AMH_DEVICE_DELEGATE_M:
 					case AMH_DEVICE_DELEGATE_S:
 					case AMH_DEVICE_DELEGATE_SM:
+					case AMH_DEVICE_DELEGATE_MO:
 					case AMH_DEVICE_DELEGATE_SMO:
 						typestr = "delegate";
 						break;