diff --git a/ModelToINetworkConverter.cpp b/ModelToINetworkConverter.cpp
index 05e6046..24fb490 100644
--- a/ModelToINetworkConverter.cpp
+++ b/ModelToINetworkConverter.cpp
@@ -6,8 +6,10 @@
 #define LOG_TAG "ArmnnDriver"
 
 #include "ModelToINetworkConverter.hpp"
+#include "Utils.hpp"
 
 #include <log/log.h>
+#include <type_traits>
 
 namespace armnn_driver
 {
@@ -62,21 +64,29 @@
 
     // add operations to it
     // track which layer outputs each operand
-    m_Data.m_OutputSlotForOperand = std::vector<armnn::IOutputSlot*>(m_Model.operands.size(), nullptr);
-
+    ALOGV("ModelToINetworkConverter::Convert(): m_OutputSlotForOperand");
+    m_Data.m_OutputSlotForOperand = std::vector<armnn::IOutputSlot*>(getMainModel(m_Model).operands.size(), nullptr);
     try
     {
-        for (uint32_t i = 0; i < m_Model.inputIndexes.size(); i++)
+        ALOGV("ModelToINetworkConverter::Convert(): for getMainModel(m_Model).inputIndexes.size()");
+        for (uint32_t i = 0; i < getMainModel(m_Model).inputIndexes.size(); i++)
         {
+            ALOGV("ModelToINetworkConverter::Convert(): getMainModel(m_Model).inputIndexes[i]");
             // inputs in android nn are represented by operands
-            uint32_t inputIndex = m_Model.inputIndexes[i];
-            const HalOperand& operand = m_Model.operands[inputIndex];
+            uint32_t inputIndex = getMainModel(m_Model).inputIndexes[i];
+            ALOGV("ModelToINetworkConverter::Convert(): getMainModel(m_Model).operands[inputIndex];");
+            const HalOperand& operand = getMainModel(m_Model).operands[inputIndex];
+            ALOGV("ModelToINetworkConverter::Convert(): GetTensorInfoForOperand(operand)");
             const armnn::TensorInfo& tensor = GetTensorInfoForOperand(operand);
+            ALOGV("ModelToINetworkConverter::Convert(): m_Data.m_Network->AddInputLayer(i)");
             armnn::IConnectableLayer* layer = m_Data.m_Network->AddInputLayer(i);
 
+            ALOGV("ModelToINetworkConverter::Convert(): layer->GetOutputSlot(0)");
             armnn::IOutputSlot& outputSlot = layer->GetOutputSlot(0);
+            ALOGV("ModelToINetworkConverter::Convert(): outputSlot.SetTensorInfo(GetTensorInfoForOperand(operand))");
             outputSlot.SetTensorInfo(GetTensorInfoForOperand(operand));
 
+            ALOGV("ModelToINetworkConverter::Convert(): m_Data.m_OutputSlotForOperand[inputIndex] = &outputSlot");
             // store for later layers
             m_Data.m_OutputSlotForOperand[inputIndex] = &outputSlot;
         }
@@ -92,9 +102,9 @@
         m_ConversionResult = ConversionResult::UnsupportedFeature;
     }
 
-    for (uint32_t operationIdx = 0; operationIdx < m_Model.operations.size(); operationIdx++)
+    for (uint32_t operationIdx = 0; operationIdx < getMainModel(m_Model).operations.size(); operationIdx++)
     {
-        const auto& operation = m_Model.operations[operationIdx];
+        const auto& operation = getMainModel(m_Model).operations[operationIdx];
 
         bool ok = true;
         if (m_ForcedUnsupportedOperations.find(operationIdx) != m_ForcedUnsupportedOperations.end())
@@ -135,11 +145,11 @@
     {
         if (m_ConversionResult == ConversionResult::Success)
         {
-            for (uint32_t i = 0; i < m_Model.outputIndexes.size(); i++)
+            for (uint32_t i = 0; i < getMainModel(m_Model).outputIndexes.size(); i++)
             {
                 // outputs in android nn are represented by operands
-                uint32_t outputIndex = m_Model.outputIndexes[i];
-                const HalOperand& operand = m_Model.operands[outputIndex];
+                uint32_t outputIndex = getMainModel(m_Model).outputIndexes[i];
+                const HalOperand& operand = getMainModel(m_Model).operands[outputIndex];
                 const armnn::TensorInfo& tensor = GetTensorInfoForOperand(operand);
                 armnn::IConnectableLayer* layer = m_Data.m_Network->AddOutputLayer(i);
 
@@ -178,4 +188,10 @@
 template class ModelToINetworkConverter<hal_1_2::HalPolicy>;
 #endif
 
+#ifdef ARMNN_ANDROID_NN_V1_3
+template class ModelToINetworkConverter<hal_1_1::HalPolicy>;
+template class ModelToINetworkConverter<hal_1_2::HalPolicy>;
+template class ModelToINetworkConverter<hal_1_3::HalPolicy>;
+#endif
+
 } // armnn_driver