diff --git a/src/dorkbox/util/messagebus/MessageBus.java b/src/dorkbox/util/messagebus/MessageBus.java
index 9cb418f..b5e01d6 100644
--- a/src/dorkbox/util/messagebus/MessageBus.java
+++ b/src/dorkbox/util/messagebus/MessageBus.java
@@ -86,7 +86,8 @@ class MessageBus implements IMessageBus {
      */
     public
     MessageBus(int numberOfThreads) {
-        this(PublishMode.ExactWithSuperTypes, SubscribeMode.MultiArg, numberOfThreads);
+        this(PublishMode.ExactWithSuperTypes, SubscribeMode.FirstArg, numberOfThreads);
+//        this(PublishMode.ExactWithSuperTypes, SubscribeMode.MultiArg, numberOfThreads);
     }
 
     /**
@@ -112,7 +113,7 @@ class MessageBus implements IMessageBus {
             subscriber = new MultiArgSubscriber(errorHandler, classUtils);
         }
         else {
-            subscriber = new FirstArgSubscriber(errorHandler);
+            subscriber = new FirstArgSubscriber(errorHandler, classUtils);
         }
 
         switch (publishMode) {
@@ -127,7 +128,6 @@ class MessageBus implements IMessageBus {
 
             case ExactWithSuperTypes:
                 if (isMultiArg) {
-
                     subscriptionPublisher = new PublisherExactWithSuperTypes_MultiArg(errorHandler, subscriber, lock);
                 }
                 else {
diff --git a/src/dorkbox/util/messagebus/subscription/FirstArgSubscriber.java b/src/dorkbox/util/messagebus/subscription/FirstArgSubscriber.java
index 2236176..94e517b 100644
--- a/src/dorkbox/util/messagebus/subscription/FirstArgSubscriber.java
+++ b/src/dorkbox/util/messagebus/subscription/FirstArgSubscriber.java
@@ -18,6 +18,8 @@ package dorkbox.util.messagebus.subscription;
 import dorkbox.util.messagebus.common.MessageHandler;
 import dorkbox.util.messagebus.common.adapter.JavaVersionAdapter;
 import dorkbox.util.messagebus.error.ErrorHandlingSupport;
+import dorkbox.util.messagebus.utils.ClassUtils;
+import dorkbox.util.messagebus.utils.SubscriptionUtils;
 import dorkbox.util.messagebus.utils.VarArgUtils;
 
 import java.util.ArrayList;
@@ -36,6 +38,8 @@ public class FirstArgSubscriber implements Subscriber {
 
     private final ErrorHandlingSupport errorHandler;
 
+    private final SubscriptionUtils subUtils;
+
     // all subscriptions per message type. We perpetually KEEP the types, as this lowers the amount of locking required
     // this is the primary list for dispatching a specific message
     // write access is synchronized and happens only when a listener of a specific class is registered the first time
@@ -44,11 +48,13 @@ public class FirstArgSubscriber implements Subscriber {
     private final Map<Class<?>, ArrayList<Subscription>> subscriptionsPerMessage;
 
 
-    public FirstArgSubscriber(final ErrorHandlingSupport errorHandler) {
+    public FirstArgSubscriber(final ErrorHandlingSupport errorHandler, final ClassUtils classUtils) {
         this.errorHandler = errorHandler;
 
         // the following are used ONLY for FIRST ARG subscription/publication. (subscriptionsPerMessageMulti isn't used in this case)
         this.subscriptionsPerMessage = JavaVersionAdapter.concurrentMap(32, LOAD_FACTOR, 1);
+
+        this.subUtils = new SubscriptionUtils(classUtils, Subscriber.LOAD_FACTOR);
     }
 
     // inside a write lock
@@ -79,7 +85,7 @@ public class FirstArgSubscriber implements Subscriber {
             size = messageHandlerTypes.length;
 
             if (size == 0) {
-                errorHandler.handleError("Error while trying to subscribe class", listenerClass);
+                errorHandler.handleError("Error while trying to subscribe class: " + messageHandlerTypes.getClass(), listenerClass);
                 continue;
             }
 
@@ -115,50 +121,135 @@ public class FirstArgSubscriber implements Subscriber {
 
     }
 
+    // can return null
     @Override
     public ArrayList<Subscription> getExactAsArray(final Class<?> messageClass) {
         return subscriptionsPerMessage.get(messageClass);
     }
 
+    // can return null
     @Override
     public ArrayList<Subscription> getExactAsArray(final Class<?> messageClass1, final Class<?> messageClass2) {
         return subscriptionsPerMessage.get(messageClass1);
     }
 
+    // can return null
     @Override
     public ArrayList<Subscription> getExactAsArray(final Class<?> messageClass1, final Class<?> messageClass2,
                                                    final Class<?> messageClass3) {
         return subscriptionsPerMessage.get(messageClass1);
     }
 
+    // can return null
     @Override
-    public Subscription[] getExact(final Class<?> deadMessageClass) {
-        return new Subscription[0];
+    public
+    Subscription[] getExact(final Class<?> messageClass) {
+        final ArrayList<Subscription> collection = getExactAsArray(messageClass);
+
+        if (collection != null) {
+            final Subscription[] subscriptions = new Subscription[collection.size()];
+            collection.toArray(subscriptions);
+
+            return subscriptions;
+        }
+
+        return null;
     }
 
+    // can return null
     @Override
     public Subscription[] getExact(final Class<?> messageClass1, final Class<?> messageClass2) {
-        return new Subscription[0];
+        return null;
     }
 
+    // can return null
     @Override
     public Subscription[] getExact(final Class<?> messageClass1, final Class<?> messageClass2, final Class<?> messageClass3) {
-        return new Subscription[0];
+        return null;
     }
 
-
+    // can return null
     @Override
     public Subscription[] getExactAndSuper(final Class<?> messageClass) {
-        return new Subscription[0];
+        ArrayList<Subscription> collection = getExactAsArray(messageClass); // can return null
+
+        // now publish superClasses
+        final ArrayList<Subscription> superSubscriptions = this.subUtils.getSuperSubscriptions(messageClass, this); // NOT return null
+
+        if (collection != null) {
+            collection = new ArrayList<Subscription>(collection);
+
+            if (!superSubscriptions.isEmpty()) {
+                collection.addAll(superSubscriptions);
+            }
+        }
+        else if (!superSubscriptions.isEmpty()) {
+            collection = superSubscriptions;
+        }
+
+        if (collection != null) {
+            final Subscription[] subscriptions = new Subscription[collection.size()];
+            collection.toArray(subscriptions);
+            return subscriptions;
+        }
+        else {
+            return null;
+        }
     }
 
     @Override
     public Subscription[] getExactAndSuper(final Class<?> messageClass1, final Class<?> messageClass2) {
-        return new Subscription[0];
+        ArrayList<Subscription> collection = getExactAsArray(messageClass1); // can return null
+
+        // now publish superClasses
+        final ArrayList<Subscription> superSubscriptions = this.subUtils.getSuperSubscriptions(messageClass1, this); // NOT return null
+
+        if (collection != null) {
+            collection = new ArrayList<Subscription>(collection);
+
+            if (!superSubscriptions.isEmpty()) {
+                collection.addAll(superSubscriptions);
+            }
+        }
+        else if (!superSubscriptions.isEmpty()) {
+            collection = superSubscriptions;
+        }
+
+        if (collection != null) {
+            final Subscription[] subscriptions = new Subscription[collection.size()];
+            collection.toArray(subscriptions);
+            return subscriptions;
+        }
+        else {
+            return null;
+        }
     }
 
     @Override
     public Subscription[] getExactAndSuper(final Class<?> messageClass1, final Class<?> messageClass2, final Class<?> messageClass3) {
-        return new Subscription[0];
+        ArrayList<Subscription> collection = getExactAsArray(messageClass1); // can return null
+
+        // now publish superClasses
+        final ArrayList<Subscription> superSubscriptions = this.subUtils.getSuperSubscriptions(messageClass1, this); // NOT return null
+
+        if (collection != null) {
+            collection = new ArrayList<Subscription>(collection);
+
+            if (!superSubscriptions.isEmpty()) {
+                collection.addAll(superSubscriptions);
+            }
+        }
+        else if (!superSubscriptions.isEmpty()) {
+            collection = superSubscriptions;
+        }
+
+        if (collection != null) {
+            final Subscription[] subscriptions = new Subscription[collection.size()];
+            collection.toArray(subscriptions);
+            return subscriptions;
+        }
+        else {
+            return null;
+        }
     }
 }
diff --git a/src/dorkbox/util/messagebus/subscription/MultiArgSubscriber.java b/src/dorkbox/util/messagebus/subscription/MultiArgSubscriber.java
index bff6d0d..61f1be5 100644
--- a/src/dorkbox/util/messagebus/subscription/MultiArgSubscriber.java
+++ b/src/dorkbox/util/messagebus/subscription/MultiArgSubscriber.java
@@ -196,36 +196,6 @@ class MultiArgSubscriber implements Subscriber {
         return subscriptionsPerMessageMulti.get(messageClass1, messageClass2, messageClass3);
     }
 
-    // can return null
-    @Override
-    public
-    Subscription[] getExactAndSuper(final Class<?> messageClass) {
-        ArrayList<Subscription> collection = getExactAsArray(messageClass); // can return null
-
-        // now publish superClasses
-        final ArrayList<Subscription> superSubscriptions = this.subUtils.getSuperSubscriptions(messageClass, this); // NOT return null
-
-        if (collection != null) {
-            collection = new ArrayList<Subscription>(collection);
-
-            if (!superSubscriptions.isEmpty()) {
-                collection.addAll(superSubscriptions);
-            }
-        }
-        else if (!superSubscriptions.isEmpty()) {
-            collection = superSubscriptions;
-        }
-
-        if (collection != null) {
-            final Subscription[] subscriptions = new Subscription[collection.size()];
-            collection.toArray(subscriptions);
-            return subscriptions;
-        }
-        else {
-            return null;
-        }
-    }
-
     // can return null
     @Override
     public
@@ -275,7 +245,35 @@ class MultiArgSubscriber implements Subscriber {
         return null;
     }
 
+    // can return null
+    @Override
+    public
+    Subscription[] getExactAndSuper(final Class<?> messageClass) {
+        ArrayList<Subscription> collection = getExactAsArray(messageClass); // can return null
 
+        // now publish superClasses
+        final ArrayList<Subscription> superSubscriptions = this.subUtils.getSuperSubscriptions(messageClass, this); // NOT return null
+
+        if (collection != null) {
+            collection = new ArrayList<Subscription>(collection);
+
+            if (!superSubscriptions.isEmpty()) {
+                collection.addAll(superSubscriptions);
+            }
+        }
+        else if (!superSubscriptions.isEmpty()) {
+            collection = superSubscriptions;
+        }
+
+        if (collection != null) {
+            final Subscription[] subscriptions = new Subscription[collection.size()];
+            collection.toArray(subscriptions);
+            return subscriptions;
+        }
+        else {
+            return null;
+        }
+    }
 
     // can return null
     @Override