diff --git a/1.0/Device.cpp b/1.0/Device.cpp
index 6516a53..e4b4f53 100644
--- a/1.0/Device.cpp
+++ b/1.0/Device.cpp
@@ -89,7 +89,7 @@
 void Device::asyncPrepare(const Model& model, const sp<IPreparedModelCallback>& callback) {
     std::shared_ptr<hexagon::Model> hexagonModel = std::make_shared<hexagon::Model>(model);
 
-    if (hexagonModel->compile()) {
+    if (hexagonModel->prepare()) {
         callback->notify(ErrorStatus::NONE, new PreparedModel(model, hexagonModel));
     }
     else {
@@ -114,9 +114,9 @@
         return ErrorStatus::DEVICE_UNAVAILABLE;
     }
 
-    // This thread is intentionally detached because the sample driver service
-    // is expected to live forever.
-    std::thread([this, model, callback]{ asyncPrepare(model, callback); }).detach();
+    // TODO: once nnlib hanging issue is resolved, make this function
+    // asynchronous again
+    asyncPrepare(model, callback);
 
     return ErrorStatus::NONE;
 }
diff --git a/1.0/HexagonController.cpp b/1.0/HexagonController.cpp
index be36f40..343e8fa 100644
--- a/1.0/HexagonController.cpp
+++ b/1.0/HexagonController.cpp
@@ -21,10 +21,35 @@
 #define LOAD_HEXAGON_FUNCTION(name) \
     mFn_##name = loadFunction<hexagon_nn_controller_##name##_fn>("hexagon_nn_controller_"#name);
 
-#define CONTROLLER_CHECK(function, ...)                         \
-    int err = mFn_##function(__VA_ARGS__);                      \
-    if (err != 0) {                                             \
-        return err;                                             \
+#define CLOSE_HEXAGON_FUNCTION(name) mFn_##name = nullptr;
+
+#define FOR_EACH_FUNCTION(MACRO)   \
+    MACRO(init)                    \
+    MACRO(getlog)                  \
+    MACRO(snpprint)                \
+    MACRO(set_debug_level)         \
+    MACRO(prepare)                 \
+    MACRO(append_node)             \
+    MACRO(append_const_node)       \
+    MACRO(execute_new)             \
+    MACRO(execute)                 \
+    MACRO(teardown)                \
+    MACRO(get_perfinfo)            \
+    MACRO(reset_perfinfo)          \
+    MACRO(version)                 \
+    MACRO(last_execution_cycles)   \
+    MACRO(GetHexagonBinaryVersion) \
+    MACRO(PrintLog)                \
+    MACRO(op_name_to_id)           \
+    MACRO(op_id_to_name)           \
+    MACRO(disable_dcvs)            \
+    MACRO(set_powersave_level)     \
+    MACRO(config)
+
+#define CONTROLLER_CHECK(function, ...)    \
+    int err = mFn_##function(__VA_ARGS__); \
+    if (err != 0) {                        \
+        return err;                        \
     }
 
 namespace android {
@@ -34,41 +59,35 @@
 namespace implementation {
 namespace hexagon {
 
+const char Controller::kFilename[] = "libhexagon_nn_controller.so";
+
 Controller::Controller() {
-    const char* filename = "libhexagon_nn_controller.so";
-
-    mHandle = dlopen(filename, RTLD_LAZY | RTLD_LOCAL);
-    if (mHandle == nullptr) {
-        LOG(ERROR) << "FAILED TO LOAD LIBRARY libhexagon_nn_controller: " << dlerror();
-    }
-
-    LOAD_HEXAGON_FUNCTION(init)
-    LOAD_HEXAGON_FUNCTION(getlog)
-    LOAD_HEXAGON_FUNCTION(snpprint)
-    LOAD_HEXAGON_FUNCTION(set_debug_level)
-    LOAD_HEXAGON_FUNCTION(prepare)
-    LOAD_HEXAGON_FUNCTION(append_node)
-    LOAD_HEXAGON_FUNCTION(append_const_node)
-    LOAD_HEXAGON_FUNCTION(execute_new)
-    LOAD_HEXAGON_FUNCTION(execute)
-    LOAD_HEXAGON_FUNCTION(teardown)
-    LOAD_HEXAGON_FUNCTION(get_perfinfo)
-    LOAD_HEXAGON_FUNCTION(reset_perfinfo)
-    LOAD_HEXAGON_FUNCTION(version)
-    LOAD_HEXAGON_FUNCTION(last_execution_cycles)
-    LOAD_HEXAGON_FUNCTION(GetHexagonBinaryVersion)
-    LOAD_HEXAGON_FUNCTION(PrintLog)
-    LOAD_HEXAGON_FUNCTION(op_name_to_id)
-    LOAD_HEXAGON_FUNCTION(op_id_to_name)
-    LOAD_HEXAGON_FUNCTION(disable_dcvs)
-    LOAD_HEXAGON_FUNCTION(set_powersave_level)
-    LOAD_HEXAGON_FUNCTION(config)
+    openNnlib();
 }
 
 Controller::~Controller() {
+    closeNnlib();
+}
+
+bool Controller::openNnlib() {
+    mHandle = dlopen(kFilename, RTLD_LAZY | RTLD_LOCAL);
+    HEXAGON_SOFT_ASSERT_NE(mHandle, 0, "FAILED TO LOAD LIBRARY "/* << kFilename << ": " << dlerror()*/);
+    FOR_EACH_FUNCTION(LOAD_HEXAGON_FUNCTION)
+    return true;
+}
+
+bool Controller::closeNnlib() {
+    FOR_EACH_FUNCTION(CLOSE_HEXAGON_FUNCTION)
     if (mHandle != nullptr) {
-        dlclose(mHandle);
+        int err = dlclose(mHandle);
+        mHandle = nullptr;
+        HEXAGON_SOFT_ASSERT_EQ(err, 0, "FAILED TO CLOSE LIBRARY " << kFilename);
     }
+    return true;
+}
+
+bool Controller::resetNnlib() {
+    return closeNnlib() && openNnlib();
 }
 
 Controller& Controller::getInstance() {
diff --git a/1.0/HexagonController.h b/1.0/HexagonController.h
index 04775ec..7a31c74 100644
--- a/1.0/HexagonController.h
+++ b/1.0/HexagonController.h
@@ -49,8 +49,12 @@
         return reinterpret_cast<Function>(fn);
     }
 
+    bool openNnlib();
+    bool closeNnlib();
+
 public:
     static Controller& getInstance();
+    bool resetNnlib();
 
     hexagon_nn_nn_id init();
 
@@ -132,7 +136,8 @@
 
 // members
 private:
-    void*                                         mHandle;
+    static const char                                kFilename[];
+    void*                                            mHandle;
     hexagon_nn_controller_init_fn                    mFn_init;
     hexagon_nn_controller_getlog_fn                  mFn_getlog;
     hexagon_nn_controller_snpprint_fn                mFn_snpprint;
diff --git a/1.0/HexagonModel.cpp b/1.0/HexagonModel.cpp
index 6e7e773..7f7b1c8 100644
--- a/1.0/HexagonModel.cpp
+++ b/1.0/HexagonModel.cpp
@@ -46,10 +46,7 @@
     return info;
 }
 
-Model::Model(const NeuralnetworksModel& model) : mNodeCount(0), mCompiled(false) {
-    mGraphId = hexagon::Controller::getInstance().init();
-    hexagon::Controller::getInstance().set_debug_level(mGraphId, 99);
-
+Model::Model(const NeuralnetworksModel& model) : mGraphId(0), mNodeCount(0), mCompiled(false) {
     mPools = mapPools(model.pools);
     mOperands = getOperandsInfo(model, mPools);
     std::for_each(mPools.begin(), mPools.end(), [](RunTimePoolInfo& mem) { mem.update(); });
@@ -64,41 +61,42 @@
 }
 
 Model& Model::operator=(Model&& other) {
-    mNodeCount      = other.mNodeCount;
-    mGraphId        = other.mGraphId;
-    mCompiled       = other.mCompiled;
-    mOperands       = std::move(other.mOperands);
-    mOperations     = std::move(other.mOperations);
-    mInputs         = std::move(other.mInputs);
-    mOutputs        = std::move(other.mOutputs);
-    mPools          = std::move(other.mPools);
-    other.mGraphId  = {};
-    other.mCompiled = false;
+    if (this != &other) {
+        mNodeCount       = other.mNodeCount;
+        mGraphId         = other.mGraphId;
+        mCompiled        = other.mCompiled;
+        mOperands        = std::move(other.mOperands);
+        mOperations      = std::move(other.mOperations);
+        mInputs          = std::move(other.mInputs);
+        mOutputs         = std::move(other.mOutputs);
+        mPools           = std::move(other.mPools);
+        other.mNodeCount = 0;
+        other.mGraphId   = {};
+        other.mCompiled  = false;
+    }
     return *this;
 }
 
 Model::~Model() {
-    if (mGraphId != hexagon_nn_nn_id{}) {
-        hexagon::Controller::getInstance().teardown(mGraphId);
-    }
-}
-
-std::string Model::getDebugLog() {
-    char buffer[16*1024];
-    int err = hexagon::Controller::getInstance().getlog(
-            mGraphId, reinterpret_cast<uint8_t*>(buffer), sizeof(buffer));
-    HEXAGON_SOFT_ASSERT_EQ(0, err, "failed getDebugLog");
-    return buffer;
+    clearModel();
 }
 
 std::string Model::getLog() {
     char buffer[16*1024];
-    int err = hexagon::Controller::getInstance().snpprint(
+    int err = hexagon::Controller::getInstance().getlog(
             mGraphId, reinterpret_cast<uint8_t*>(buffer), sizeof(buffer));
     HEXAGON_SOFT_ASSERT_EQ(0, err, "failed getLog");
     return buffer;
 }
 
+std::string Model::getGraph() {
+    char buffer[16*1024];
+    int err = hexagon::Controller::getInstance().snpprint(
+            mGraphId, reinterpret_cast<uint8_t*>(buffer), sizeof(buffer));
+    HEXAGON_SOFT_ASSERT_EQ(0, err, "failed getGraph");
+    return buffer;
+}
+
 uint32_t Model::getNextNode() {
     return ++mNodeCount;
 }
@@ -167,8 +165,9 @@
 const hexagon_nn_input& Model::getQuantizationMin(uint32_t operand) {
     OperandInfo& operandInfo = mOperands[operand];
     if (operandInfo.hexagon_input_min == hexagon_nn_input{}) {
-        float real_value =
-                (std::numeric_limits<uint8_t>::min() - operandInfo.zeroPoint) * operandInfo.scale;
+        float real_value = operandInfo.type == OperandType::TENSOR_QUANT8_ASYMM ?
+                (std::numeric_limits<uint8_t>::min() - operandInfo.zeroPoint) * operandInfo.scale :
+                std::numeric_limits<uint32_t>::min() * operandInfo.scale;
         operandInfo.hexagon_input_min = createValues<float>({real_value});
     }
     return operandInfo.hexagon_input_min;
@@ -177,8 +176,9 @@
 const hexagon_nn_input& Model::getQuantizationMax(uint32_t operand) {
     OperandInfo& operandInfo = mOperands[operand];
     if (operandInfo.hexagon_input_max == hexagon_nn_input{}) {
-        float real_value =
-                (std::numeric_limits<uint8_t>::max() - operandInfo.zeroPoint) * operandInfo.scale;
+        float real_value = operandInfo.type == OperandType::TENSOR_QUANT8_ASYMM ?
+                (std::numeric_limits<uint8_t>::max() - operandInfo.zeroPoint) * operandInfo.scale :
+                std::numeric_limits<uint32_t>::max() * operandInfo.scale;
         operandInfo.hexagon_input_max = createValues<float>({real_value});
     }
     return operandInfo.hexagon_input_max;
@@ -408,7 +408,7 @@
 
 bool Model::addFusedQuant8Operation(op_type op,
                                     hexagon_nn_padding_type pad,
-                                    const hexagon_nn_input& bias,
+                                    const std::vector<hexagon_nn_input>& bias,
                                     op_type activation,
                                     const std::vector<hexagon_nn_input>& inputs,
                                     const std::vector<uint32_t>& outputs) {
@@ -430,28 +430,32 @@
     // base operation
     node = addOperationInternal(op, pad, inputs, out32);
     HEXAGON_SOFT_ASSERT_NE(0, node, "Error adding base operation");
-    const hexagon_nn_input old_min = {.src_id = node, .output_idx = 1};
-    const hexagon_nn_input old_max = {.src_id = node, .output_idx = 2};
+    hexagon_nn_input previous     = {.src_id = node, .output_idx = 0};
+    hexagon_nn_input previous_min = {.src_id = node, .output_idx = 1};
+    hexagon_nn_input previous_max = {.src_id = node, .output_idx = 2};
 
     // add bias
-    if (bias != hexagon_nn_input{}) {
-        std::vector<hexagon_nn_input> buffer1_in = {{.src_id = node, .output_idx = 0}, bias,
-                                                    old_min, old_max, old_min, old_max};
-        node = addOperationInternal(OP_QuantizedBiasAdd_32p32to32, NN_PAD_NA, buffer1_in, out32);
+    if (bias.size() == 3) {
+        node = addOperationInternal(OP_QuantizedBiasAdd_32p32to32, NN_PAD_NA,
+                {previous, bias[0], previous_min, previous_max, bias[1], bias[2]}, out32);
         HEXAGON_SOFT_ASSERT_NE(0, node, "Error adding bias operation");
+        previous.src_id = node;
+        previous_min.src_id = node;
+        previous_max.src_id = node;
     }
 
     // requantize
-    const hexagon_nn_input buffer2_in = {.src_id = node, .output_idx = 0};
     node = addOperationInternal(OP_Requantize_32to8, NN_PAD_NA,
-                                {buffer2_in, old_min, old_max, new_min, new_max}, out8);
+                                {previous, previous_min, previous_max, new_min, new_max}, out8);
     HEXAGON_SOFT_ASSERT_NE(0, node, "Error adding requantize operation");
+    previous.src_id = node;
+    previous_min.src_id = node;
+    previous_max.src_id = node;
 
     // activation
-    std::vector<hexagon_nn_input> buffer3 = {{.src_id = node, .output_idx = 0},
-            {.src_id = node, .output_idx = 1}, {.src_id = node, .output_idx = 2}};
-    buffer3.insert(buffer3.end(), actArgs.begin(), actArgs.end());
-    node = addOperationInternal(activation, NN_PAD_NA, buffer3, out8);
+    std::vector<hexagon_nn_input> buffer = {previous, previous_min, previous_max};
+    buffer.insert(buffer.end(), actArgs.begin(), actArgs.end());
+    node = addOperationInternal(activation, NN_PAD_NA, buffer, out8);
     HEXAGON_SOFT_ASSERT_NE(0, node, "Error adding activation operation");
 
     return registerHexagonInputs(outputs, node);
@@ -526,17 +530,17 @@
     return true;
 }
 
-void Model::resetModel() {
+void Model::clearModel() {
     mCompiled = false;
     for (OperandInfo& operand : mOperands) {
         operand.hexagon_input = {};
+        operand.hexagon_input_min = {};
+        operand.hexagon_input_max = {};
         operand.hexagon_output = {};
     }
     if (mGraphId != hexagon_nn_nn_id{}) {
         hexagon::Controller::getInstance().teardown(mGraphId);
     }
-    mGraphId = hexagon::Controller::getInstance().init();
-    hexagon::Controller::getInstance().set_debug_level(mGraphId, 99);
 }
 
 std::vector<bool> Model::supportedOperations() {
@@ -554,13 +558,17 @@
     return supported;
 }
 
-bool Model::compile() {
+bool Model::prepare() {
     if (!verifyOperations() || !verifyOperands()) {
         return false;
     }
 
+    mGraphId = hexagon::Controller::getInstance().init();
+    HEXAGON_SOFT_ASSERT_NE(0, mGraphId, "Hexagon could not allocate new graph");
+    hexagon::Controller::getInstance().set_debug_level(mGraphId, 0);
+
     if (!addInputs() || !addOperations() || !addOutputs()) {
-        resetModel();
+        clearModel();
         return false;
     }
 
diff --git a/1.0/HexagonModel.h b/1.0/HexagonModel.h
index 500c074..40b3bc2 100644
--- a/1.0/HexagonModel.h
+++ b/1.0/HexagonModel.h
@@ -79,8 +79,8 @@
     Model(const NeuralnetworksModel& model);
     ~Model();
 
-    std::string getDebugLog();
     std::string getLog();
+    std::string getGraph();
 
     // model check
     const int32_t* getPointer(uint32_t operand);
@@ -127,13 +127,13 @@
                                 const std::vector<uint32_t>& outputs);
     bool addFusedQuant8Operation(op_type op,
                                  hexagon_nn_padding_type pad,
-                                 const hexagon_nn_input& bias,
+                                 const std::vector<hexagon_nn_input>& bias,
                                  op_type activation,
                                  const std::vector<hexagon_nn_input>& inputs,
                                  const std::vector<uint32_t>& outputs);
 
     std::vector<bool> supportedOperations();
-    bool compile();
+    bool prepare();
     bool execute(const Request& request);
 
 private:
@@ -155,7 +155,7 @@
     bool addOperations();
     bool addOutputs();
 
-    void resetModel();
+    void clearModel();
 
 // members
     hexagon_nn_nn_id             mGraphId;
diff --git a/1.0/HexagonOperationsPrepare.cpp b/1.0/HexagonOperationsPrepare.cpp
index 1c2d7cd..0a6b392 100644
--- a/1.0/HexagonOperationsPrepare.cpp
+++ b/1.0/HexagonOperationsPrepare.cpp
@@ -511,7 +511,7 @@
 
     // add node to graph
     return model->addFusedQuant8Operation(OP_QuantizedAdd_8p8to32, NN_PAD_NA, {}, act,
-                                          {in1, in2, in1_min, in2_min, in1_max, in2_max}, outs);
+                                          {in1, in2, in1_min, in1_max, in2_min, in2_max}, outs);
 }
 
 bool average_pool_2d(const std::vector<uint32_t>& ins, const std::vector<uint32_t>& outs,
@@ -638,13 +638,15 @@
     const hexagon_nn_input& input_max  = model->getQuantizationMax(ins[0]);
     const hexagon_nn_input& filter_min = model->getQuantizationMin(ins[1]);
     const hexagon_nn_input& filter_max = model->getQuantizationMax(ins[1]);
+    const hexagon_nn_input& bias_min   = model->getQuantizationMin(ins[2]);
+    const hexagon_nn_input& bias_max   = model->getQuantizationMax(ins[2]);
 
     const hexagon_nn_input stride = model->createShape(1, stride_height, stride_width, 1);
 
     // add node to graph
-    return model->addFusedQuant8Operation(OP_QuantizedConv2d_8x8to32, pad, bias, act,
-                                          {input, filter, input_min, input_max,
-                                            filter_min, filter_max, stride}, outs);
+    return model->addFusedQuant8Operation(
+            OP_QuantizedConv2d_8x8to32, pad, {bias, bias_min, bias_max}, act,
+            {input, filter, input_min, input_max, filter_min, filter_max, stride}, outs);
 }
 
 bool depthwise_conv_2d(const std::vector<uint32_t>& ins, const std::vector<uint32_t>& outs,
@@ -695,14 +697,16 @@
     const hexagon_nn_input& input_max  = model->getQuantizationMax(ins[0]);
     const hexagon_nn_input& filter_min = model->getQuantizationMin(ins[1]);
     const hexagon_nn_input& filter_max = model->getQuantizationMax(ins[1]);
+    const hexagon_nn_input& bias_min   = model->getQuantizationMin(ins[2]);
+    const hexagon_nn_input& bias_max   = model->getQuantizationMax(ins[2]);
 
     const hexagon_nn_input filter = model->createDepthwiseFilterTensor(ins[1], depth_multiplier);
     const hexagon_nn_input stride = model->createShape(1, stride_height, stride_width, 1);
 
     // add node to graph
-    return model->addFusedQuant8Operation(OP_QuantizedDepthwiseConv2d_8x8to32, pad, bias, act,
-                                          {input, filter, input_min, input_max, filter_min,
-                                            filter_max, stride}, outs);
+    return model->addFusedQuant8Operation(
+            OP_QuantizedDepthwiseConv2d_8x8to32, pad, {bias, bias_min, bias_max}, act,
+            {input, filter, input_min, input_max, filter_min, filter_max, stride}, outs);
 }
 
 bool dequantize(const std::vector<uint32_t>& ins, const std::vector<uint32_t>& outs,
@@ -736,11 +740,13 @@
     const hexagon_nn_input& input_max   = model->getQuantizationMax(ins[0]);
     const hexagon_nn_input& weights_min = model->getQuantizationMin(ins[1]);
     const hexagon_nn_input& weights_max = model->getQuantizationMax(ins[1]);
+    const hexagon_nn_input& bias_min    = model->getQuantizationMin(ins[2]);
+    const hexagon_nn_input& bias_max    = model->getQuantizationMax(ins[2]);
 
     // add node to graph
-    return model->addFusedQuant8Operation(OP_QuantizedMatMul_8x8to32, NN_PAD_NA, bias, act,
-                                          {input, weights, input_min, input_max,
-                                            weights_min, weights_max}, outs);
+    return model->addFusedQuant8Operation(
+            OP_QuantizedMatMul_8x8to32, NN_PAD_NA, {bias, bias_min, bias_max}, act,
+            {input, weights, input_min, input_max, weights_min, weights_max}, outs);
 }
 
 bool logistic(const std::vector<uint32_t>& ins, const std::vector<uint32_t>& outs,
diff --git a/1.0/HexagonUtils.cpp b/1.0/HexagonUtils.cpp
index a1c55d2..2ed6ad2 100644
--- a/1.0/HexagonUtils.cpp
+++ b/1.0/HexagonUtils.cpp
@@ -32,7 +32,12 @@
 
 bool isHexagonAvailable() {
     int version = -1;
-    hexagon::Controller::getInstance().version(&version);
+    Controller::getInstance().version(&version);
+    if (version != 92) {
+        LOG(INFO) << "ATTEMPTING TO RESTART NNLIB";
+        Controller::getInstance().resetNnlib();
+        Controller::getInstance().version(&version);
+    }
     return version == 92;
 }
 
@@ -198,206 +203,6 @@
     return output;
 }
 
-namespace {
-
-const char* kOps[] = {
-    "OP_INPUT",
-    "OP_OUTPUT",
-    "OP_Nop",
-    "OP_Const",
-    "OP_Check",
-    "OP_Close_f",
-    "OP_Close_quint8",
-    "OP_Close_q_quint8",
-    "OP_Close_int32",
-    "OP_Close_qint32",
-    "OP_PPrint_8",
-    "OP_PPrint_32",
-    "OP_PPrint_f",
-    "OP_PreFree",
-    "OP_Flatten",
-    "OP_QuantizedConv2d_8x8to32",
-    "OP_QuantizedConv2d_8x8to32_ref",
-    "OP_QuantizedMatMul_8x8to32",
-    "OP_QuantizedMatMul_8x8to32_ref",
-    "OP_QuantizeDownAndShrinkRange_32to8",
-    "OP_QuantizeDownAndShrinkRange_32to8_ref",
-    "OP_QuantizedRelu_8",
-    "OP_QuantizedRelu_8_ref",
-    "OP_QuantizedReluX_8",
-    "OP_QuantizedReluX_8_ref",
-    "OP_QuantizedMaxPool_8",
-    "OP_QuantizedMaxPool_8_ref",
-    "OP_QuantizedAvgPool_8",
-    "OP_QuantizedAvgPool_8_ref",
-    "OP_QuantizedL2Pool_8",
-    "OP_QuantizedL2Pool_8_ref",
-    "OP_QuantizedConcat_8",
-    "OP_QuantizedConcat_8_ref",
-    "OP_QuantizedBiasAdd_8p8to32",
-    "OP_QuantizedBiasAdd_8p8to32_ref",
-    "OP_Min_f",
-    "OP_Min_f_ref",
-    "OP_Max_f",
-    "OP_Max_f_ref",
-    "OP_Quantize",
-    "OP_Quantize_ref",
-    "OP_Dequantize",
-    "OP_Dequantize_ref",
-    "OP_Supernode_8x8p8to8",
-    "OP_Supernode_8x8p8to8_ref",
-    "OP_QuantizedFlatten",
-    "OP_Softmax_f",
-    "OP_Conv2d_f",
-    "OP_MatMul_f",
-    "OP_Relu_f",
-    "OP_ReluX_f",
-    "OP_AvgPool_f",
-    "OP_L2Pool_f",
-    "OP_MaxPool_f",
-    "OP_Concat_f",
-    "OP_BiasAdd_f",
-    "OP_LRN_f",
-    "OP_Variable",
-    "OP_Assign",
-    "OP_Reshape",
-    "OP_QuantizedReshape",
-    "OP_Tanh_f",
-    "OP_Sigmoid_f",
-    "OP_Slice_8",
-    "OP_Slice_f",
-    "OP_QuantizedSlice_8",
-    "OP_Add_f",
-    "OP_Mul_f",
-    "OP_Minimum_f",
-    "OP_Maximum_f",
-    "OP_Requantize_32to8",
-    "OP_Requantize_32to8_ref",
-    "OP_RequantizationRange_32",
-    "OP_RequantizationRange_32_ref",
-    "OP_Neg_f",
-    "OP_Sub_f",
-    "OP_AddN_f",
-    "OP_Range_int32",
-    "OP_Rank_int32",
-    "OP_Transpose_int32",
-    "OP_Transpose_f",
-    "OP_InstanceNorm_f",
-    "OP_QuantizedInstanceNorm_8",
-    "OP_QuantizedInstanceNorm_8_ref",
-    "OP_Sub_int32",
-    "OP_Add_int32",
-    "OP_Split_f",
-    "OP_Dequantize_qint32_f",
-    "OP_PRelu_f",
-    "OP_QuantizedPRelu_8",
-    "OP_QuantizedPRelu_8_ref",
-    "OP_Sum_f",
-    "OP_Prod_f",
-    "OP_Mul_int32",
-    "OP_LogicalAnd_int32",
-    "OP_LogicalOr_int32",
-    "OP_LogicalXor_int32",
-    "OP_Shape_int32",
-    "OP_Pack_int32",
-    "OP_MirrorPad_f",
-    "OP_ResizeNearestNeighbor_f",
-    "OP_StridedSlice_int32",
-    "OP_StridedSlice_f",
-    "OP_ExpandDims_int32",
-    "OP_ExpandDims_f",
-    "OP_LogSoftmax_f",
-    "OP_Split_int32",
-    "OP_QuantizedSplit_8",
-    "OP_Deconv_f",
-    "OP_QuantizedDeconv_8x8to32",
-    "OP_QuantizedDeconv_8x8to32_ref",
-    "OP_QuantizedMul_8x8to32",
-    "OP_QuantizedMul_8x8to32_ref",
-    "OP_QuantizedAdd_8p8to32",
-    "OP_QuantizedAdd_8p8to32_ref",
-    "OP_QuantizedSigmoid_8",
-    "OP_QuantizedSigmoid_8_ref",
-    "OP_QuantizedTanh_8",
-    "OP_QuantizedTanh_8_ref",
-    "OP_QuantizedSoftmax_8",
-    "OP_QuantizedSoftmax_8_ref",
-    "OP_QuantizedLRN_8",
-    "OP_QuantizedLRN_8_ref",
-    "OP_Quantizedpad2d_frame_8p",
-    "OP_Quantizedpad2d_frame_8p_ref",
-    "OP_QuantizedSub_8p8to32",
-    "OP_QuantizedSub_8p8to32_ref",
-    "OP_QuantizedMaximum_8",
-    "OP_QuantizedMaximum_8_ref",
-    "OP_QuantizedMinimum_8",
-    "OP_QuantizedMinimum_8_ref",
-    "OP_Pad_f",
-    "OP_SpaceToBatchND_f",
-    "OP_BatchToSpaceND_f",
-    "OP_QuantizedPad_8",
-    "OP_ResizeBilinear_f",
-    "OP_ConcatV2_f",
-    "OP_ConcatV2_int32",
-    "OP_Prod_int32",
-    "OP_Slice_int32",
-    "OP_QuantizedAdd_8p8to8",
-    "OP_QuantizedResizeBilinear_8",
-    "OP_Supernode_8x8p8to8_d32",
-    "OP_Convert_to_d32",
-    "OP_Convert_from_d32",
-    "OP_QuantizedMaxPool_8_d32",
-    "OP_QuantizedMaxPool_8_d32_ref",
-    "OP_QuantizedConcat_8_d32",
-    "OP_QuantizedConcat_8_d32_ref",
-    "OP_QuantizedAvgPool_8_d32",
-    "OP_QuantizedAvgPool_8_d32_ref",
-    "OP_Sink",
-    "OP_QuantizedPRelu_8_d32",
-    "OP_QuantizedPRelu_8_d32_ref",
-    "OP_AutoQuantize",
-    "OP_AutoQuantize_ref",
-    "OP_QuantizedDepthwiseConv2d_8x8to32",
-    "OP_QuantizedDepthwiseConv2d_8x8to32_ref",
-    "OP_DepthwiseConv2d_f",
-    "OP_DepthwiseSupernode_8x8p8to8",
-    "OP_DepthwiseSupernode_8x8p8to8_d32",
-    "OP_QuantizedMul_8x8to8_d32",
-    "OP_QuantizedMul_8x8to8_d32_ref",
-    "OP_FullyConnected_u8",
-    "OP_QuantizedAdd_8x8to8_d32",
-    "OP_QuantizedAdd_8x8to8_d32_ref",
-    "OP_QuantizedClamp_8",
-    "OP_QuantizedClamp_8_ref",
-    "OP_Clamp_f",
-    "OP_QuantizeForTest_d32",
-    "OP_Close_d32",
-    "OP_QuantizedSub_8x8to8_d32",
-    "OP_QuantizedSub_8x8to8_d32_ref",
-    "OP_InputSupernode_8x8p8to8_outd32",
-    "OP_QuantizedLRN_8_d32",
-    "OP_QuantizedBiasAdd_32p32to32",
-    "OP_QuantizedBiasAdd_32p32to32_ref",
-    "OP_Quantize_int32",
-    "OP_Quantize_int32_ref",
-    "OP_Supernode_8x8p32to8",
-    "OP_DepthwiseSupernode_8x8p32to8",
-    "OP_Supernode_8x8p32to8_d32",
-    "OP_DepthwiseSupernode_8x8p32to8_d32",
-    "OP_InputSupernode_8x8p32to8_outd32",
-};
-
-const char* kPadding[] = {
-    "NN_PAD_NA",
-    "NN_PAD_SAME",
-    "NN_PAD_VALID",
-    "NN_PAD_MIRROR_REFLECT",
-    "NN_PAD_MIRROR_SYMMETRIC",
-    "NN_PAD_SAME_CAFFE",
-};
-
-} // anonymous namespace
-
 // printers
 std::string toString(uint32_t val) {
     return std::to_string(val);
@@ -412,13 +217,26 @@
 }
 
 std::string toString(op_type op) {
-    return static_cast<size_t>(op) < sizeof(kOps) / sizeof(char*) ?
-            kOps[static_cast<size_t>(op)] : "<invalid op_type>";
+    static const char* opText[] = {
+        #define DEF_OP(NAME,...) "OP_"#NAME,
+        #include "hexagon_nn_controller/ops.def"
+        #undef DEF_OP
+    };
+    return static_cast<size_t>(op) < sizeof(opText) / sizeof(char*) ?
+            opText[static_cast<size_t>(op)] : "<invalid op_type>";
 }
 
 std::string toString(hexagon_nn_padding_type padding) {
-    return static_cast<size_t>(padding) < sizeof(kPadding) / sizeof(char*) ?
-            kPadding[static_cast<size_t>(padding)] : "<invalid hexagon_nn_padding_type>";
+    static const char* paddingText[] = {
+        "NN_PAD_NA",
+        "NN_PAD_SAME",
+        "NN_PAD_VALID",
+        "NN_PAD_MIRROR_REFLECT",
+        "NN_PAD_MIRROR_SYMMETRIC",
+        "NN_PAD_SAME_CAFFE",
+    };
+    return static_cast<size_t>(padding) < sizeof(paddingText) / sizeof(char*) ?
+            paddingText[static_cast<size_t>(padding)] : "<invalid hexagon_nn_padding_type>";
 }
 
 std::string toString(const hexagon_nn_input& input) {
diff --git a/1.0/PreparedModel.cpp b/1.0/PreparedModel.cpp
index 735f564..4e091e2 100644
--- a/1.0/PreparedModel.cpp
+++ b/1.0/PreparedModel.cpp
@@ -56,9 +56,9 @@
         return ErrorStatus::DEVICE_UNAVAILABLE;
     }
 
-    // This thread is intentionally detached because the sample driver service
-    // is expected to live forever.
-    std::thread(asyncExecute, mHexagonModel, request, callback).detach();
+    // TODO: once nnlib hanging issue is resolved, make this function
+    // asynchronous again
+    asyncExecute(mHexagonModel, request, callback);
 
     return ErrorStatus::NONE;
 }
diff --git a/1.0/hexagon_nn_controller/ops.def b/1.0/hexagon_nn_controller/ops.def
index f8b91ee..b6d727d 100644
--- a/1.0/hexagon_nn_controller/ops.def
+++ b/1.0/hexagon_nn_controller/ops.def
@@ -198,7 +198,7 @@
 DEF_OP_WREF(QuantizedFC_8x8p8to8)
 #endif
 
-DEF_OP_WREF(QuantizedAdd_8x8to8_d32)
+DEF_OP_WREF(QuantizedAdd_8p8to8_d32)
 
 DEF_OP_WREF(QuantizedClamp_8)
 DEF_OP(Clamp_f)
@@ -217,6 +217,13 @@
 DEF_OP(DepthwiseSupernode_8x8p32to8_d32)
 DEF_OP(InputSupernode_8x8p32to8_outd32)
 
+DEF_OP(PPrint_8_d32)
+DEF_OP(PPrintWithPadding_8_d32)
+DEF_OP_WREF(AutoQuantize_d32)
+
+DEF_OP_WREF(QuantizedTanh_8_d32)
+DEF_OP_WREF(QuantizedSigmoid_8_d32)
+
 #ifdef __SELF_DEF_OP_WREF
 #undef __SELF_DEF_OP_WREF
 #undef DEF_OP_WREF