diff --git a/cpu_ref/rsCpuScript.cpp b/cpu_ref/rsCpuScript.cpp
index 3190d79..f975094 100644
--- a/cpu_ref/rsCpuScript.cpp
+++ b/cpu_ref/rsCpuScript.cpp
@@ -533,6 +533,14 @@
     size_t pragmaCount = 0;
     bool isThreadable = true;
 
+    void** fieldAddress = nullptr;
+    bool* fieldIsObject = nullptr;
+    InvokeFunc_t* invokeFunctions = nullptr;
+    ForEachFunc_t* forEachFunctions = nullptr;
+    uint32_t* forEachSignatures = nullptr;
+    const char ** pragmaKeys = nullptr;
+    const char ** pragmaValues = nullptr;
+
     const char *rsInfo = (const char *) dlsym(sharedObj, ".rs.info");
 
     if (strgets(line, MAXLINE, &rsInfo) == nullptr) {
@@ -543,11 +551,19 @@
         return nullptr;
     }
 
-    std::vector<void*> fieldAddress;
+    fieldAddress = new void*[varCount];
+    if (fieldAddress == nullptr) {
+        return nullptr;
+    }
+
+    fieldIsObject = new bool[varCount];
+    if (fieldIsObject == nullptr) {
+        goto error;
+    }
 
     for (size_t i = 0; i < varCount; ++i) {
         if (strgets(line, MAXLINE, &rsInfo) == nullptr) {
-            return nullptr;
+            goto error;
         }
         char *c = strrchr(line, '\n');
         if (c) {
@@ -559,22 +575,26 @@
                   line, dlerror());
             // Not a critical error if we don't find a global variable.
         }
-        fieldAddress.push_back(addr);
+        fieldAddress[i] = addr;
+        fieldIsObject[i] = false;
     }
 
     if (strgets(line, MAXLINE, &rsInfo) == nullptr) {
-        return nullptr;
+        goto error;
     }
     if (sscanf(line, EXPORT_FUNC_STR "%zu", &funcCount) != 1) {
         ALOGE("Invalid export func count!: %s", line);
-        return nullptr;
+        goto error;
     }
 
-    std::vector<InvokeFunc_t> invokeFunctions(funcCount);
+    invokeFunctions = new InvokeFunc_t[funcCount];
+    if (invokeFunctions == nullptr) {
+        goto error;
+    }
 
     for (size_t i = 0; i < funcCount; ++i) {
         if (strgets(line, MAXLINE, &rsInfo) == nullptr) {
-            return nullptr ;
+            goto error;
         }
         char *c = strrchr(line, '\n');
         if (c) {
@@ -585,32 +605,39 @@
         if (invokeFunctions[i] == nullptr) {
             ALOGE("Failed to get function address for %s(): %s",
                   line, dlerror());
-            return nullptr;
+            goto error;
         }
     }
 
     if (strgets(line, MAXLINE, &rsInfo) == nullptr) {
-        return nullptr;
+        goto error;
     }
     if (sscanf(line, EXPORT_FOREACH_STR "%zu", &forEachCount) != 1) {
         ALOGE("Invalid export forEach count!: %s", line);
-        return nullptr;
+        goto error;
     }
 
-    std::vector<ForEachFunc_t> forEachFunctions(forEachCount);
-    std::vector<uint32_t> forEachSignatures(forEachCount);
+    forEachFunctions = new ForEachFunc_t[forEachCount];
+    if (forEachFunctions == nullptr) {
+        goto error;
+    }
+
+    forEachSignatures = new uint32_t[forEachCount];
+    if (forEachSignatures == nullptr) {
+        goto error;
+    }
 
     for (size_t i = 0; i < forEachCount; ++i) {
         unsigned int tmpSig = 0;
         char tmpName[MAXLINE];
 
         if (strgets(line, MAXLINE, &rsInfo) == nullptr) {
-            return nullptr;
+            goto error;
         }
         if (sscanf(line, "%u - %" MAKE_STR(MAXLINE) "s",
                    &tmpSig, tmpName) != 2) {
           ALOGE("Invalid export forEach!: %s", line);
-          return nullptr;
+          goto error;
         }
 
         // Lookup the expanded ForEach kernel.
@@ -623,29 +650,26 @@
             // root() is always specified at location 0.
             ALOGE("Failed to find forEach function address for %s: %s",
                   tmpName, dlerror());
-            return nullptr;
+            goto error;
         }
     }
 
     if (strgets(line, MAXLINE, &rsInfo) == nullptr) {
-        return nullptr;
+        goto error;
     }
     if (sscanf(line, OBJECT_SLOT_STR "%zu", &objectSlotCount) != 1) {
         ALOGE("Invalid object slot count!: %s", line);
-        return nullptr;
+        goto error;
     }
 
-    std::vector<bool> fieldIsObject(varCount, false);
-
-    rsAssert(varCount > 0);
     for (size_t i = 0; i < objectSlotCount; ++i) {
         uint32_t varNum = 0;
         if (strgets(line, MAXLINE, &rsInfo) == nullptr) {
-            return nullptr;
+            goto error;
         }
         if (sscanf(line, "%u", &varNum) != 1) {
             ALOGE("Invalid object slot!: %s", line);
-            return nullptr;
+            goto error;
         }
 
         if (varNum < varCount) {
@@ -653,31 +677,36 @@
         }
     }
 
-#ifdef RS_COMPATIBILITY_LIB
+#ifndef RS_COMPATIBILITY_LIB
     // Do not attempt to read pragmas or isThreadable flag in compat lib path.
     // Neither is applicable for compat lib
-    std::vector<const char *> pragmaKeys(pragmaCount);
-    std::vector<const char *> pragmaValues(pragmaCount);
 
-    isThreadable = true;
-
-#else
     if (strgets(line, MAXLINE, &rsInfo) == nullptr) {
-        return nullptr;
+        goto error;
     }
 
     if (sscanf(line, PRAGMA_STR "%zu", &pragmaCount) != 1) {
         ALOGE("Invalid pragma count!: %s", line);
-        return nullptr;
+        goto error;
     }
 
-    std::vector<const char *> pragmaKeys(pragmaCount);
-    std::vector<const char *> pragmaValues(pragmaCount);
+    pragmaKeys = new const char*[pragmaCount];
+    if (pragmaKeys == nullptr) {
+        goto error;
+    }
+
+    pragmaValues = new const char*[pragmaCount];
+    if (pragmaValues == nullptr) {
+        goto error;
+    }
+
+    bzero(pragmaKeys, sizeof(char*) * pragmaCount);
+    bzero(pragmaValues, sizeof(char*) * pragmaCount);
 
     for (size_t i = 0; i < pragmaCount; ++i) {
         if (strgets(line, MAXLINE, &rsInfo) == nullptr) {
             ALOGE("Unable to read pragma at index %zu!", i);
-            return nullptr;
+            goto error;
         }
 
         char key[MAXLINE];
@@ -691,12 +720,7 @@
         {
             ALOGE("Invalid pragma value!: %s", line);
 
-            // free previously allocated keys and values
-            for (size_t idx = 0; idx < i; ++idx) {
-                delete [] pragmaKeys[idx];
-                delete [] pragmaValues[idx];
-            }
-            return nullptr;
+            goto error;
         }
 
         char *pKey = new char[strlen(key)+1];
@@ -710,35 +734,62 @@
     }
 
     if (strgets(line, MAXLINE, &rsInfo) == nullptr) {
-        return nullptr;
+        goto error;
     }
 
     char tmpFlag[4];
     if (sscanf(line, THREADABLE_STR "%4s", tmpFlag) != 1) {
         ALOGE("Invalid threadable flag!: %s", line);
-        return nullptr;
+        goto error;
     }
-    if (strcmp(tmpFlag, "yes") == 0)
+    if (strcmp(tmpFlag, "yes") == 0) {
         isThreadable = true;
-    else if (strcmp(tmpFlag, "no") == 0)
+    } else if (strcmp(tmpFlag, "no") == 0) {
         isThreadable = false;
-    else {
+    } else {
         ALOGE("Invalid threadable flag!: %s", tmpFlag);
-        return nullptr;
+        goto error;
     }
 
-#endif
+#endif  // RS_COMPATIBILITY_LIB
 
     return new ScriptExecutable(
-        RSContext, fieldAddress, fieldIsObject, invokeFunctions,
-        forEachFunctions, forEachSignatures, pragmaKeys, pragmaValues,
+        RSContext, fieldAddress, fieldIsObject, varCount,
+        invokeFunctions, funcCount,
+        forEachFunctions, forEachSignatures, forEachCount,
+        pragmaKeys, pragmaValues, pragmaCount,
         isThreadable);
+
+error:
+
+#ifndef RS_COMPATIBILITY_LIB
+    for (size_t idx = 0; idx < pragmaCount; ++idx) {
+        if (pragmaKeys[idx] != nullptr) {
+            delete [] pragmaKeys[idx];
+        }
+        if (pragmaValues[idx] != nullptr) {
+            delete [] pragmaValues[idx];
+        }
+    }
+
+    delete[] pragmaValues;
+    delete[] pragmaKeys;
+#endif  // RS_COMPATIBILITY_LIB
+
+    delete[] forEachSignatures;
+    delete[] forEachFunctions;
+    delete[] invokeFunctions;
+    delete[] fieldIsObject;
+    delete[] fieldAddress;
+
+    return nullptr;
 }
 
 bool RsdCpuScriptImpl::init(char const *resName, char const *cacheDir,
                             uint8_t const *bitcode, size_t bitcodeSize,
                             uint32_t flags, char const *bccPluginName) {
-    //ALOGE("rsdScriptCreate %p %p %p %p %i %i %p", rsc, resName, cacheDir, bitcode, bitcodeSize, flags, lookupFunc);
+    //ALOGE("rsdScriptCreate %p %p %p %p %i %i %p", rsc, resName, cacheDir,
+    // bitcode, bitcodeSize, flags, lookupFunc);
     //ALOGE("rsdScriptInit %p %p", rsc, script);
 
     mCtx->lockMutex();
@@ -892,10 +943,8 @@
     script->mHal.info.exportedFunctionCount = mScriptExec->getExportedFunctionCount();
     script->mHal.info.exportedVariableCount = mScriptExec->getExportedVariableCount();
     script->mHal.info.exportedPragmaCount = mScriptExec->getPragmaCount();;
-    script->mHal.info.exportedPragmaKeyList =
-        const_cast<const char**>(&mScriptExec->getPragmaKeys().front());
-    script->mHal.info.exportedPragmaValueList =
-        const_cast<const char**>(&mScriptExec->getPragmaValues().front());
+    script->mHal.info.exportedPragmaKeyList = mScriptExec->getPragmaKeys();
+    script->mHal.info.exportedPragmaValueList = mScriptExec->getPragmaValues();
 
     // Bug, need to stash in metadata
     if (mRootExpand) {
@@ -949,7 +998,8 @@
         for (int Index = inLen; --Index >= 1;) {
             if (!ain0->hasSameDims(ains[Index])) {
                 mCtx->getContext()->setError(RS_ERROR_BAD_SCRIPT,
-                  "Failed to launch kernel; dimensions of input and output allocations do not match.");
+                  "Failed to launch kernel; dimensions of input and output"
+                  "allocations do not match.");
 
                 return false;
             }
@@ -1128,7 +1178,8 @@
         if ((ap = (void*)memalign(16, paramLength)) != nullptr) {
             memcpy(ap, params, paramLength);
         } else {
-            ALOGE("x86_64: invokeFunction memalign error, still use params which is not 16 bytes aligned.");
+            ALOGE("x86_64: invokeFunction memalign error, still use params which"
+                  " is not 16 bytes aligned.");
         }
     }
 #endif
diff --git a/cpu_ref/rsCpuScript.h b/cpu_ref/rsCpuScript.h
index 873a79a..e4ae4d3 100644
--- a/cpu_ref/rsCpuScript.h
+++ b/cpu_ref/rsCpuScript.h
@@ -67,26 +67,25 @@
 class ScriptExecutable {
  public:
   ScriptExecutable(Context* RSContext,
-                   std::vector<void*>& fieldAddress,
-                   std::vector<bool>& fieldIsObject,
-                   std::vector<InvokeFunc_t>& invokeFunctions,
-                   std::vector<ForEachFunc_t>& forEachFunctions,
-                   std::vector<uint32_t>& forEachSignatures,
-                   std::vector<const char *> &pragmaKeys,
-                   std::vector<const char *> &pragmaValues,
-                   bool isThreadable)
-                   : mIsThreadable(isThreadable), mRS(RSContext) {
-      mFieldAddress.swap(fieldAddress);
-      mFieldIsObject.swap(fieldIsObject);
-      mInvokeFunctions.swap(invokeFunctions);
-      mForEachFunctions.swap(forEachFunctions);
-      mForEachSignatures.swap(forEachSignatures);
-      mPragmaKeys.swap(pragmaKeys);
-      mPragmaValues.swap(pragmaValues);
+                   void** fieldAddress, bool* fieldIsObject, size_t varCount,
+                   InvokeFunc_t* invokeFunctions, size_t funcCount,
+                   ForEachFunc_t* forEachFunctions, uint32_t* forEachSignatures,
+                   size_t forEachCount,
+                   const char ** pragmaKeys, const char ** pragmaValues,
+                   size_t pragmaCount,
+                   bool isThreadable) :
+      mFieldAddress(fieldAddress), mFieldIsObject(fieldIsObject),
+      mExportedVarCount(varCount),
+      mInvokeFunctions(invokeFunctions), mFuncCount(funcCount),
+      mForEachFunctions(forEachFunctions), mForEachSignatures(forEachSignatures),
+      mForEachCount(forEachCount),
+      mPragmaKeys(pragmaKeys), mPragmaValues(pragmaValues),
+      mPragmaCount(pragmaCount),
+      mIsThreadable(isThreadable), mRS(RSContext) {
   }
 
   ~ScriptExecutable() {
-      for (size_t i = 0; i < mFieldAddress.size(); ++i) {
+      for (size_t i = 0; i < mExportedVarCount; ++i) {
           if (mFieldIsObject[i]) {
               if (mFieldAddress[i] != nullptr) {
                   rs_object_base *obj_addr =
@@ -96,19 +95,27 @@
           }
       }
 
-      for (size_t i = 0; i < mPragmaKeys.size(); ++i) {
+      for (size_t i = 0; i < mPragmaCount; ++i) {
           delete [] mPragmaKeys[i];
           delete [] mPragmaValues[i];
       }
+
+      delete[] mPragmaValues;
+      delete[] mPragmaKeys;
+      delete[] mForEachSignatures;
+      delete[] mForEachFunctions;
+      delete[] mInvokeFunctions;
+      delete[] mFieldIsObject;
+      delete[] mFieldAddress;
   }
 
   static ScriptExecutable*
   createFromSharedObject(Context* RSContext, void* sharedObj);
 
-  size_t getExportedVariableCount() const { return mFieldAddress.size(); }
-  size_t getExportedFunctionCount() const { return mInvokeFunctions.size(); }
-  size_t getExportedForEachCount() const { return mForEachFunctions.size(); }
-  size_t getPragmaCount() const { return mPragmaKeys.size(); }
+  size_t getExportedVariableCount() const { return mExportedVarCount; }
+  size_t getExportedFunctionCount() const { return mFuncCount; }
+  size_t getExportedForEachCount() const { return mForEachCount; }
+  size_t getPragmaCount() const { return mPragmaCount; }
 
   void* getFieldAddress(int slot) const { return mFieldAddress[slot]; }
   bool getFieldIsObject(int slot) const { return mFieldIsObject[slot]; }
@@ -116,19 +123,26 @@
   ForEachFunc_t getForEachFunction(int slot) const { return mForEachFunctions[slot]; }
   uint32_t getForEachSignature(int slot) const { return mForEachSignatures[slot]; }
 
-  const std::vector<const char *> & getPragmaKeys() const { return mPragmaKeys; }
-  const std::vector<const char *> & getPragmaValues() const { return mPragmaValues; }
+  const char ** getPragmaKeys() const { return mPragmaKeys; }
+  const char ** getPragmaValues() const { return mPragmaValues; }
 
   bool getThreadable() const { return mIsThreadable; }
 
  private:
-  std::vector<void*> mFieldAddress;
-  std::vector<bool> mFieldIsObject;
-  std::vector<InvokeFunc_t> mInvokeFunctions;
-  std::vector<ForEachFunc_t> mForEachFunctions;
-  std::vector<uint32_t> mForEachSignatures;
-  std::vector<const char *> mPragmaKeys;
-  std::vector<const char *> mPragmaValues;
+  void** mFieldAddress;
+  bool* mFieldIsObject;
+  size_t mExportedVarCount;
+
+  InvokeFunc_t* mInvokeFunctions;
+  size_t mFuncCount;
+
+  ForEachFunc_t* mForEachFunctions;
+  uint32_t* mForEachSignatures;
+  size_t mForEachCount;
+
+  const char ** mPragmaKeys;
+  const char ** mPragmaValues;
+  size_t mPragmaCount;
 
   bool mIsThreadable;