diff --git a/graphics/java/android/renderscript/RenderScript.java b/graphics/java/android/renderscript/RenderScript.java
index 92ac573..acc58bc 100644
--- a/graphics/java/android/renderscript/RenderScript.java
+++ b/graphics/java/android/renderscript/RenderScript.java
@@ -134,9 +134,6 @@
     native int  nAdapter2DCreate();
 
     native void nScriptBindAllocation(int script, int alloc, int slot);
-    native void nScriptSetClearColor(int script, float r, float g, float b, float a);
-    native void nScriptSetClearDepth(int script, float depth);
-    native void nScriptSetClearStencil(int script, int stencil);
     native void nScriptSetTimeZone(int script, byte[] timeZone);
     native void nScriptInvoke(int id, int slot);
     native void nScriptInvokeData(int id, int slot);
diff --git a/graphics/java/android/renderscript/Script.java b/graphics/java/android/renderscript/Script.java
index 632a459..4c4071a 100644
--- a/graphics/java/android/renderscript/Script.java
+++ b/graphics/java/android/renderscript/Script.java
@@ -81,21 +81,6 @@
         mRS.nScriptSetVarV(mID, index, v.getData());
     }
 
-    public void setClearColor(float r, float g, float b, float a) {
-        mRS.validate();
-        mRS.nScriptSetClearColor(mID, r, g, b, a);
-    }
-
-    public void setClearDepth(float d) {
-        mRS.validate();
-        mRS.nScriptSetClearDepth(mID, d);
-    }
-
-    public void setClearStencil(int stencil) {
-        mRS.validate();
-        mRS.nScriptSetClearStencil(mID, stencil);
-    }
-
     public void setTimeZone(String timeZone) {
         mRS.validate();
         try {
diff --git a/graphics/jni/android_renderscript_RenderScript.cpp b/graphics/jni/android_renderscript_RenderScript.cpp
index 7170e5a..223ef4b 100644
--- a/graphics/jni/android_renderscript_RenderScript.cpp
+++ b/graphics/jni/android_renderscript_RenderScript.cpp
@@ -880,29 +880,6 @@
     _env->ReleaseByteArrayElements(data, ptr, JNI_ABORT);
 }
 
-static void
-nScriptSetClearColor(JNIEnv *_env, jobject _this, jint script, jfloat r, jfloat g, jfloat b, jfloat a)
-{
-    RsContext con = (RsContext)(_env->GetIntField(_this, gContextId));
-    LOG_API("nScriptSetClearColor, con(%p), s(%p), r(%f), g(%f), b(%f), a(%f)", con, (void *)script, r, g, b, a);
-    rsScriptSetClearColor(con, (RsScript)script, r, g, b, a);
-}
-
-static void
-nScriptSetClearDepth(JNIEnv *_env, jobject _this, jint script, jfloat d)
-{
-    RsContext con = (RsContext)(_env->GetIntField(_this, gContextId));
-    LOG_API("nScriptCSetClearDepth, con(%p), s(%p), depth(%f)", con, (void *)script, d);
-    rsScriptSetClearDepth(con, (RsScript)script, d);
-}
-
-static void
-nScriptSetClearStencil(JNIEnv *_env, jobject _this, jint script, jint stencil)
-{
-    RsContext con = (RsContext)(_env->GetIntField(_this, gContextId));
-    LOG_API("nScriptCSetClearStencil, con(%p), s(%p), stencil(%i)", con, (void *)script, stencil);
-    rsScriptSetClearStencil(con, (RsScript)script, stencil);
-}
 
 static void
 nScriptSetTimeZone(JNIEnv *_env, jobject _this, jint script, jbyteArray timeZone)
@@ -1410,9 +1387,6 @@
 {"nAdapter2DCreate",               "()I",                                  (void*)nAdapter2DCreate },
 
 {"nScriptBindAllocation",          "(III)V",                               (void*)nScriptBindAllocation },
-{"nScriptSetClearColor",           "(IFFFF)V",                             (void*)nScriptSetClearColor },
-{"nScriptSetClearDepth",           "(IF)V",                                (void*)nScriptSetClearDepth },
-{"nScriptSetClearStencil",         "(II)V",                                (void*)nScriptSetClearStencil },
 {"nScriptSetTimeZone",             "(I[B)V",                               (void*)nScriptSetTimeZone },
 {"nScriptInvoke",                  "(II)V",                                (void*)nScriptInvoke },
 {"nScriptInvokeData",              "(II)V",                                (void*)nScriptInvokeData },
diff --git a/libs/rs/java/Film/src/com/android/film/FilmRS.java b/libs/rs/java/Film/src/com/android/film/FilmRS.java
index e26b051..93438a0b 100644
--- a/libs/rs/java/Film/src/com/android/film/FilmRS.java
+++ b/libs/rs/java/Film/src/com/android/film/FilmRS.java
@@ -213,13 +213,9 @@
 
         Log.e("rs", "Done loading named");
 
-        //mStripPositionType = Type.createFromClass(mRS, StripPosition.class, 1);
-
         ScriptC.Builder sb = new ScriptC.Builder(mRS);
         sb.setScript(mRes, R.raw.filmstrip);
-        //sb.setType(mStripPositionType, "Pos", 1);
         mScriptStrip = sb.create();
-        mScriptStrip.setClearColor(0.0f, 0.0f, 0.0f, 1.0f);
 
         mAllocPos = Allocation.createTyped(mRS, mStripPositionType);
 
diff --git a/libs/rs/java/Fountain/res/raw/fountain.rs b/libs/rs/java/Fountain/res/raw/fountain.rs
index 5562a77..8b69941 100644
--- a/libs/rs/java/Fountain/res/raw/fountain.rs
+++ b/libs/rs/java/Fountain/res/raw/fountain.rs
@@ -9,7 +9,6 @@
 
 float4 partColor;
 rs_mesh partMesh;
-rs_allocation partBuffer;
 
 typedef struct __attribute__((packed, aligned(4))) Point_s {
     float2 delta;
@@ -18,17 +17,13 @@
 } Point_t;
 Point_t *point;
 
-#pragma rs export_var(point, partColor, partMesh, partBuffer)
-//#pragma rs export_type(Point_s)
-//#pragma rs export_element(point)
+#pragma rs export_var(point, partColor, partMesh)
 
 int root() {
-    debugPf(1, partColor.x);
-    debugPi(4, partMesh);
-    debugPi(5, partBuffer);
-
-    float height = getHeight();
-    int size = allocGetDimX(partBuffer);
+    rsgClearColor(0.f, 0.f, 0.f, 1.f);
+    float height = rsgGetHeight();
+    rs_allocation alloc = rsGetAllocation(point);
+    int size = rsAllocationGetDimX(alloc);
 
     Point_t * p = point;
     for (int ct=0; ct < size; ct++) {
@@ -40,22 +35,31 @@
         p++;
     }
 
-    uploadToBufferObject(partBuffer);
-    drawSimpleMesh(partMesh);
+    rsgUploadToBufferObject(alloc);
+    rsgDrawSimpleMesh(partMesh);
     return 1;
 }
 
 void addParticles(int rate, int x, int y)
 {
-    float rMax = ((float)rate) * 0.005f;
-    int size = allocGetDimX(partBuffer);
+    rsDebug("partColor", partColor);
+    rsDebug("partColor x", partColor.x);
+    rsDebug("partColor y", partColor.y);
+    rsDebug("partColor z", partColor.z);
+    rsDebug("partColor w", partColor.w);
 
-    rs_color4u c = convertColorTo8888(partColor.x, partColor.y, partColor.z);
+    float rMax = ((float)rate) * 0.005f;
+    int size = rsAllocationGetDimX(rsGetAllocation(point));
+
+    rs_color4u c = rsPackColorTo8888(partColor.x, partColor.y, partColor.z);
     Point_t * np = &point[newPart];
 
     float2 p = {x, y};
     while (rate--) {
-        np->delta = vec2Rand(rMax);
+        float angle = rsRand(3.14f * 2.f);
+        float len = rsRand(rMax);
+        np->delta.x = len * sin(angle);
+        np->delta.y = len * cos(angle);
         np->pos = p;
         np->color = c;
         newPart++;
diff --git a/libs/rs/java/Fountain/res/raw/fountain_bc.bc b/libs/rs/java/Fountain/res/raw/fountain_bc.bc
index f147068..45475fa 100644
--- a/libs/rs/java/Fountain/res/raw/fountain_bc.bc
+++ b/libs/rs/java/Fountain/res/raw/fountain_bc.bc
Binary files differ
diff --git a/libs/rs/java/Fountain/src/com/android/fountain/FountainRS.java b/libs/rs/java/Fountain/src/com/android/fountain/FountainRS.java
index d193134..ba09a16 100644
--- a/libs/rs/java/Fountain/src/com/android/fountain/FountainRS.java
+++ b/libs/rs/java/Fountain/src/com/android/fountain/FountainRS.java
@@ -77,9 +77,7 @@
         mSM.bindVertexAllocation(mPoints.getAllocation(), vtxSlot);
 
         mScript = new ScriptC_Fountain(mRS, mRes, true);
-        mScript.setClearColor(0.0f, 0.0f, 0.0f, 1.0f);
         mScript.set_partMesh(mSM);
-        mScript.set_partBuffer(mPoints.getAllocation());
         mScript.bind_point(mPoints);
         mRS.contextBindRootScript(mScript);
     }
diff --git a/libs/rs/java/Fountain/src/com/android/fountain/ScriptC_Fountain.java b/libs/rs/java/Fountain/src/com/android/fountain/ScriptC_Fountain.java
index 7cff390..cace1ec 100644
--- a/libs/rs/java/Fountain/src/com/android/fountain/ScriptC_Fountain.java
+++ b/libs/rs/java/Fountain/src/com/android/fountain/ScriptC_Fountain.java
@@ -20,17 +20,14 @@
     public void set_partMesh(SimpleMesh v) {
         setVar(1, v.getID());
     }
-    public void set_partBuffer(Allocation v) {
-        setVar(2, v.getID());
-    }
 
     private ScriptField_Point mField_point;
     public void bind_point(ScriptField_Point f) {
         mField_point = f;
         if (f == null) {
-            bindAllocation(null, 3);
+            bindAllocation(null, 2);
         } else {
-            bindAllocation(f.getAllocation(), 3);
+            bindAllocation(f.getAllocation(), 2);
         }
     }
     public ScriptField_Point get_point() {
diff --git a/libs/rs/rs.spec b/libs/rs/rs.spec
index 4ad25ae..2a872cd 100644
--- a/libs/rs/rs.spec
+++ b/libs/rs/rs.spec
@@ -248,13 +248,6 @@
 ScriptCBegin {
 	}
 
-ScriptSetClearColor {
-	param RsScript s
-	param float r
-	param float g
-	param float b
-	param float a
-	}
 
 ScriptSetTimeZone {
 	param RsScript s
@@ -262,16 +255,6 @@
 	param uint32_t length
 	}
 
-ScriptSetClearDepth {
-	param RsScript s
-	param float depth
-	}
-
-ScriptSetClearStencil {
-	param RsScript s
-	param uint32_t stencil
-	}
-
 
 ScriptInvoke {
 	param RsScript s
diff --git a/libs/rs/rsContext.cpp b/libs/rs/rsContext.cpp
index da85f83..f99e5f2 100644
--- a/libs/rs/rsContext.cpp
+++ b/libs/rs/rsContext.cpp
@@ -111,9 +111,6 @@
         LOGE("eglCreateContext returned EGL_NO_CONTEXT");
     }
     gGLContextCount++;
-
-    eglQuerySurface(mEGL.mDisplay, mEGL.mSurface, EGL_WIDTH, &mEGL.mWidth);
-    eglQuerySurface(mEGL.mDisplay, mEGL.mSurface, EGL_HEIGHT, &mEGL.mHeight);
 }
 
 void Context::deinitEGL()
@@ -156,21 +153,7 @@
 
 uint32_t Context::runRootScript()
 {
-    timerSet(RS_TIMER_CLEAR_SWAP);
-
     glViewport(0, 0, mWidth, mHeight);
-    glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
-    glClearColor(mRootScript->mEnviroment.mClearColor[0],
-                 mRootScript->mEnviroment.mClearColor[1],
-                 mRootScript->mEnviroment.mClearColor[2],
-                 mRootScript->mEnviroment.mClearColor[3]);
-    if (mUseDepth) {
-        glDepthMask(GL_TRUE);
-        glClearDepthf(mRootScript->mEnviroment.mClearDepth);
-        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
-    } else {
-        glClear(GL_COLOR_BUFFER_BIT);
-    }
 
     timerSet(RS_TIMER_SCRIPT);
     mStateFragmentStore.mLast.clear();
@@ -485,8 +468,6 @@
         checkEglError("eglDestroySurface", ret);
 
         mEGL.mSurface = NULL;
-        mEGL.mWidth = 0;
-        mEGL.mHeight = 0;
         mWidth = 0;
         mHeight = 0;
     }
@@ -514,10 +495,6 @@
 
         mStateVertex.updateSize(this);
 
-        if ((int)mWidth != mEGL.mWidth || (int)mHeight != mEGL.mHeight) {
-            LOGE("EGL/Surface mismatch  EGL (%i x %i)  SF (%i x %i)", mEGL.mWidth, mEGL.mHeight, mWidth, mHeight);
-        }
-
         if (first) {
             mGL.mVersion = glGetString(GL_VERSION);
             mGL.mVendor = glGetString(GL_VENDOR);
@@ -762,8 +739,7 @@
     LOGE("RS Context debug");
 
     LOGE(" EGL ver %i %i", mEGL.mMajorVersion, mEGL.mMinorVersion);
-    LOGE(" EGL context %p  surface %p,  w=%i h=%i  Display=%p", mEGL.mContext,
-         mEGL.mSurface, mEGL.mWidth, mEGL.mHeight, mEGL.mDisplay);
+    LOGE(" EGL context %p  surface %p,  Display=%p", mEGL.mContext, mEGL.mSurface, mEGL.mDisplay);
     LOGE(" GL vendor: %s", mGL.mVendor);
     LOGE(" GL renderer: %s", mGL.mRenderer);
     LOGE(" GL Version: %s", mGL.mVersion);
diff --git a/libs/rs/rsContext.h b/libs/rs/rsContext.h
index 4a6072d60..9df07dc 100644
--- a/libs/rs/rsContext.h
+++ b/libs/rs/rsContext.h
@@ -176,8 +176,6 @@
         EGLConfig mConfig;
         EGLContext mContext;
         EGLSurface mSurface;
-        EGLint mWidth;
-        EGLint mHeight;
         EGLDisplay mDisplay;
     } mEGL;
 
diff --git a/libs/rs/rsScript.cpp b/libs/rs/rsScript.cpp
index b0bbb22..fc22fc3 100644
--- a/libs/rs/rsScript.cpp
+++ b/libs/rs/rsScript.cpp
@@ -24,12 +24,6 @@
     mAllocFile = __FILE__;
     mAllocLine = __LINE__;
     memset(&mEnviroment, 0, sizeof(mEnviroment));
-    mEnviroment.mClearColor[0] = 0;
-    mEnviroment.mClearColor[1] = 0;
-    mEnviroment.mClearColor[2] = 0;
-    mEnviroment.mClearColor[3] = 1;
-    mEnviroment.mClearDepth = 1;
-    mEnviroment.mClearStencil = 0;
 }
 
 Script::~Script()
@@ -61,33 +55,12 @@
     //LOGE("rsi_ScriptBindAllocation %i  %p  %p", slot, a, a->getPtr());
 }
 
-void rsi_ScriptSetClearColor(Context * rsc, RsScript vs, float r, float g, float b, float a)
-{
-    Script *s = static_cast<Script *>(vs);
-    s->mEnviroment.mClearColor[0] = r;
-    s->mEnviroment.mClearColor[1] = g;
-    s->mEnviroment.mClearColor[2] = b;
-    s->mEnviroment.mClearColor[3] = a;
-}
-
 void rsi_ScriptSetTimeZone(Context * rsc, RsScript vs, const char * timeZone, uint32_t length)
 {
     Script *s = static_cast<Script *>(vs);
     s->mEnviroment.mTimeZone = timeZone;
 }
 
-void rsi_ScriptSetClearDepth(Context * rsc, RsScript vs, float v)
-{
-    Script *s = static_cast<Script *>(vs);
-    s->mEnviroment.mClearDepth = v;
-}
-
-void rsi_ScriptSetClearStencil(Context * rsc, RsScript vs, uint32_t v)
-{
-    Script *s = static_cast<Script *>(vs);
-    s->mEnviroment.mClearStencil = v;
-}
-
 void rsi_ScriptSetType(Context * rsc, RsType vt, uint32_t slot, bool writable, const char *name)
 {
     ScriptCState *ss = &rsc->mScriptC;
@@ -99,76 +72,21 @@
 
 void rsi_ScriptInvoke(Context *rsc, RsScript vs, uint32_t slot)
 {
-    //LOGE("rsi_ScriptInvoke %i", slot);
     Script *s = static_cast<Script *>(vs);
-    if ((slot >= s->mEnviroment.mInvokeFunctionCount) ||
-        (s->mEnviroment.mInvokeFunctions[slot] == NULL)) {
-        rsc->setError(RS_ERROR_BAD_SCRIPT, "Calling invoke on bad script");
-        return;
-    }
-    s->setupScript();
-    //LOGE("invoking %i %p", slot, s->mEnviroment.mInvokeFunctions[slot]);
-    s->mEnviroment.mInvokeFunctions[slot]();
-    //LOGE("invoke finished");
+    s->Invoke(rsc, slot, NULL, 0);
 }
 
 
 void rsi_ScriptInvokeData(Context *rsc, RsScript vs, uint32_t slot, void *data)
 {
-    //LOGE("rsi_ScriptInvoke %i", slot);
     Script *s = static_cast<Script *>(vs);
-    if ((slot >= s->mEnviroment.mInvokeFunctionCount) ||
-        (s->mEnviroment.mInvokeFunctions[slot] == NULL)) {
-        rsc->setError(RS_ERROR_BAD_SCRIPT, "Calling invoke on bad script");
-        return;
-    }
-    s->setupScript();
-    //LOGE("invoking %i %p", slot, s->mEnviroment.mInvokeFunctions[slot]);
-    s->mEnviroment.mInvokeFunctions[slot]();
-    //LOGE("invoke finished");
+    s->Invoke(rsc, slot, NULL, 0);
 }
 
 void rsi_ScriptInvokeV(Context *rsc, RsScript vs, uint32_t slot, const void *data, uint32_t len)
 {
-    //LOGE("rsi_ScriptInvoke %i", slot);
     Script *s = static_cast<Script *>(vs);
-    if ((slot >= s->mEnviroment.mInvokeFunctionCount) ||
-        (s->mEnviroment.mInvokeFunctions[slot] == NULL)) {
-        rsc->setError(RS_ERROR_BAD_SCRIPT, "Calling invoke on bad script");
-        return;
-    }
-    s->setupScript();
-
-    //LOGE("rsi_ScriptInvokeV, len=%i", len);
-    const uint32_t * dPtr = (const uint32_t *)data;
-    switch(len) {
-    case 0:
-        s->mEnviroment.mInvokeFunctions[slot]();
-        break;
-    case 4:
-        ((void (*)(uint32_t))
-         s->mEnviroment.mInvokeFunctions[slot])(dPtr[0]);
-        break;
-    case 8:
-        ((void (*)(uint32_t, uint32_t))
-         s->mEnviroment.mInvokeFunctions[slot])(dPtr[0], dPtr[1]);
-        break;
-    case 12:
-        ((void (*)(uint32_t, uint32_t, uint32_t))
-         s->mEnviroment.mInvokeFunctions[slot])(dPtr[0], dPtr[1], dPtr[2]);
-        break;
-    case 16:
-        ((void (*)(uint32_t, uint32_t, uint32_t, uint32_t))
-         s->mEnviroment.mInvokeFunctions[slot])(dPtr[0], dPtr[1], dPtr[2], dPtr[3]);
-        break;
-    case 20:
-        ((void (*)(uint32_t, uint32_t, uint32_t, uint32_t, uint32_t))
-         s->mEnviroment.mInvokeFunctions[slot])(dPtr[0], dPtr[1], dPtr[2], dPtr[3], dPtr[4]);
-        break;
-
-
-    }
-
+    s->Invoke(rsc, slot, data, len);
 }
 
 void rsi_ScriptSetVarI(Context *rsc, RsScript vs, uint32_t slot, int value)
diff --git a/libs/rs/rsScript.h b/libs/rs/rsScript.h
index c2fe8ef..ff13087 100644
--- a/libs/rs/rsScript.h
+++ b/libs/rs/rsScript.h
@@ -40,10 +40,6 @@
     virtual ~Script();
 
     struct Enviroment_t {
-        float mClearColor[4];
-        float mClearDepth;
-        uint32_t mClearStencil;
-
         uint32_t mStartTimeMillis;
         const char* mTimeZone;
 
@@ -68,6 +64,7 @@
 
     void setVar(uint32_t slot, const void *val, uint32_t len);
 
+    virtual void Invoke(Context *rsc, uint32_t slot, const void *data, uint32_t len) = 0;
     virtual void setupScript() = 0;
     virtual uint32_t run(Context *, uint32_t launchID) = 0;
 };
diff --git a/libs/rs/rsScriptC.cpp b/libs/rs/rsScriptC.cpp
index 1cf8f97..3217e64 100644
--- a/libs/rs/rsScriptC.cpp
+++ b/libs/rs/rsScriptC.cpp
@@ -87,6 +87,21 @@
     return NULL;
 }
 
+void ScriptC::setTLS()
+{
+    Context::ScriptTLSStruct * tls = (Context::ScriptTLSStruct *)
+                                  pthread_getspecific(Context::gThreadTLSKey);
+    rsAssert(tls);
+    tls->mScript = this;
+}
+
+void ScriptC::clearTLS()
+{
+    Context::ScriptTLSStruct * tls = (Context::ScriptTLSStruct *)
+                                  pthread_getspecific(Context::gThreadTLSKey);
+    rsAssert(tls);
+    tls->mScript = NULL;
+}
 
 uint32_t ScriptC::run(Context *rsc, uint32_t launchIndex)
 {
@@ -95,10 +110,6 @@
         return 0;
     }
 
-    Context::ScriptTLSStruct * tls =
-    (Context::ScriptTLSStruct *)pthread_getspecific(Context::gThreadTLSKey);
-    rsAssert(tls);
-
     if (mEnviroment.mFragmentStore.get()) {
         rsc->setFragmentStore(mEnviroment.mFragmentStore.get());
     }
@@ -119,14 +130,54 @@
     setupScript();
 
     uint32_t ret = 0;
-    tls->mScript = this;
+    setTLS();
     //LOGE("ScriptC::run %p", mProgram.mRoot);
     ret = mProgram.mRoot();
-    tls->mScript = NULL;
+    clearTLS();
     //LOGE("ScriptC::run ret %i", ret);
     return ret;
 }
 
+void ScriptC::Invoke(Context *rsc, uint32_t slot, const void *data, uint32_t len)
+{
+    //LOGE("rsi_ScriptInvoke %i", slot);
+    if ((slot >= mEnviroment.mInvokeFunctionCount) ||
+        (mEnviroment.mInvokeFunctions[slot] == NULL)) {
+        rsc->setError(RS_ERROR_BAD_SCRIPT, "Calling invoke on bad script");
+        return;
+    }
+    setupScript();
+    setTLS();
+
+    const uint32_t * dPtr = (const uint32_t *)data;
+    switch(len) {
+    case 0:
+        mEnviroment.mInvokeFunctions[slot]();
+        break;
+    case 4:
+        ((void (*)(uint32_t))
+         mEnviroment.mInvokeFunctions[slot])(dPtr[0]);
+        break;
+    case 8:
+        ((void (*)(uint32_t, uint32_t))
+         mEnviroment.mInvokeFunctions[slot])(dPtr[0], dPtr[1]);
+        break;
+    case 12:
+        ((void (*)(uint32_t, uint32_t, uint32_t))
+         mEnviroment.mInvokeFunctions[slot])(dPtr[0], dPtr[1], dPtr[2]);
+        break;
+    case 16:
+        ((void (*)(uint32_t, uint32_t, uint32_t, uint32_t))
+         mEnviroment.mInvokeFunctions[slot])(dPtr[0], dPtr[1], dPtr[2], dPtr[3]);
+        break;
+    case 20:
+        ((void (*)(uint32_t, uint32_t, uint32_t, uint32_t, uint32_t))
+         mEnviroment.mInvokeFunctions[slot])(dPtr[0], dPtr[1], dPtr[2], dPtr[3], dPtr[4]);
+        break;
+    }
+    clearTLS();
+}
+
 ScriptCState::ScriptCState()
 {
     mScript = NULL;
diff --git a/libs/rs/rsScriptC.h b/libs/rs/rsScriptC.h
index 1aab08c..1ee13e1 100644
--- a/libs/rs/rsScriptC.h
+++ b/libs/rs/rsScriptC.h
@@ -54,6 +54,11 @@
 
     const Allocation *ptrToAllocation(const void *) const;
 
+    void setTLS();
+    void clearTLS();
+
+    virtual void Invoke(Context *rsc, uint32_t slot, const void *data, uint32_t len);
+
     virtual void setupScript();
     virtual uint32_t run(Context *, uint32_t launchID);
 };
diff --git a/libs/rs/rsScriptC_Lib.cpp b/libs/rs/rsScriptC_Lib.cpp
index f976676..956773b 100644
--- a/libs/rs/rsScriptC_Lib.cpp
+++ b/libs/rs/rsScriptC_Lib.cpp
@@ -202,9 +202,9 @@
     return 0.2215f * (y * fabsf(y) - y) + y;
 }
 
+
 static float SC_randf(float max)
 {
-    //LOGE("max %f", max);
     float r = (float)rand();
     return r / RAND_MAX * max;
 }
@@ -215,6 +215,16 @@
     return r / RAND_MAX * (max - min) + min;
 }
 
+static int SC_randi(int max)
+{
+    return (int)SC_randf(max);
+}
+
+static int SC_randi2(int min, int max)
+{
+    return (int)SC_randf2(min, max);
+}
+
 static int SC_sign(int value)
 {
     return (value > 0) - (value < 0);
@@ -255,16 +265,6 @@
     return sqrtf(a * a + b * b + c * c);
 }
 
-static float SC_normf(float start, float stop, float value)
-{
-    return (value - start) / (stop - start);
-}
-
-static float SC_mapf(float minStart, float minStop, float maxStart, float maxStop, float value)
-{
-    return maxStart + (maxStart - maxStop) * ((value - minStart) / (minStop - minStart));
-}
-
 static float SC_frac(float v)
 {
     int i = (int)floor(v);
@@ -347,6 +347,24 @@
     return timeinfo->tm_year;
 }
 
+static int64_t SC_uptimeMillis2()
+{
+    return nanoseconds_to_milliseconds(systemTime(SYSTEM_TIME_MONOTONIC));
+}
+
+static int64_t SC_startTimeMillis2()
+{
+    GET_TLS();
+    return sc->mEnviroment.mStartTimeMillis;
+}
+
+static int64_t SC_elapsedTimeMillis2()
+{
+    GET_TLS();
+    return nanoseconds_to_milliseconds(systemTime(SYSTEM_TIME_MONOTONIC))
+            - sc->mEnviroment.mStartTimeMillis;
+}
+
 static int32_t SC_uptimeMillis()
 {
     return nanoseconds_to_milliseconds(systemTime(SYSTEM_TIME_MONOTONIC));
@@ -438,17 +456,6 @@
 }
 
 
-static rsvF_2 SC_vec2Rand(float maxLen)
-{
-    float2 t;
-    float angle = SC_randf(M_PI * 2);
-    float len = SC_randf(maxLen);
-    t.f[0] = len * sinf(angle);
-    t.f[1] = len * cosf(angle);
-    return t.v;
-}
-
-
 //////////////////////////////////////////////////////////////////////////////
 //
 //////////////////////////////////////////////////////////////////////////////
@@ -492,24 +499,23 @@
 
 
 
-static void SC_debugF(const char *s, float f)
-{
-    LOGE("%s %f", s, f);
+static void SC_debugF(const char *s, float f) {
+    LOGE("%s %f, 0x%08x", s, f, *((int *) (&f)));
 }
-
-static void SC_debugHexF(const char *s, float f)
-{
-    LOGE("%s 0x%x", s, *((int *) (&f)));
+static void SC_debugFv2(const char *s, rsvF_2 fv) {
+    float *f = (float *)&fv;
+    LOGE("%s {%f, %f}", s, f[0], f[1]);
 }
-
-static void SC_debugI32(const char *s, int32_t i)
-{
-    LOGE("%s %i", s, i);
+static void SC_debugFv3(const char *s, rsvF_4 fv) {
+    float *f = (float *)&fv;
+    LOGE("%s {%f, %f, %f}", s, f[0], f[1], f[2]);
 }
-
-static void SC_debugHexI32(const char *s, int32_t i)
-{
-    LOGE("%s 0x%x", s, i);
+static void SC_debugFv4(const char *s, rsvF_4 fv) {
+    float *f = (float *)&fv;
+    LOGE("%s {%f, %f, %f, %f}", s, f[0], f[1], f[2], f[3]);
+}
+static void SC_debugI32(const char *s, int32_t i) {
+    LOGE("%s %i  0x%x", s, i, i);
 }
 
 static uchar4 SC_convertColorTo8888_f3(float r, float g, float b) {
@@ -595,94 +601,86 @@
 static ScriptCState::SymbolTable_t gSyms[] = {
     { "__divsi3", (void *)&SC_divsi3 },
 
+    // allocation
+    { "rsAllocationGetDimX", (void *)&SC_allocGetDimX },
+    { "rsAllocationGetDimY", (void *)&SC_allocGetDimY },
+    { "rsAllocationGetDimZ", (void *)&SC_allocGetDimZ },
+    { "rsAllocationGetDimLOD", (void *)&SC_allocGetDimLOD },
+    { "rsAllocationGetDimFaces", (void *)&SC_allocGetDimFaces },
+    { "rsGetAllocation", (void *)&SC_getAllocation },
+
+    // color
+    { "_Z17rsPackColorTo8888fff", (void *)&SC_convertColorTo8888_f3 },
+    { "_Z17rsPackColorTo8888ffff", (void *)&SC_convertColorTo8888_f4 },
+    //extern uchar4 __attribute__((overloadable)) rsPackColorTo8888(float3);
+    //extern uchar4 __attribute__((overloadable)) rsPackColorTo8888(float4);
+    //extern float4 rsUnpackColor8888(uchar4);
+    //extern uchar4 __attribute__((overloadable)) rsPackColorTo565(float r, float g, float b);
+    //extern uchar4 __attribute__((overloadable)) rsPackColorTo565(float3);
+    //extern float4 rsUnpackColor565(uchar4);
+
+    // Debug
+    { "_Z7rsDebugPKcf", (void *)&SC_debugF },
+    { "_Z7rsDebugPKcDv2_f", (void *)&SC_debugFv2 },
+    { "_Z7rsDebugPKcDv3_f", (void *)&SC_debugFv3 },
+    { "_Z7rsDebugPKcDv4_f", (void *)&SC_debugFv4 },
+    { "_Z7rsDebugPKci", (void *)&SC_debugI32 },
+    //extern void __attribute__((overloadable))rsDebug(const char *, const void *);
+
+
+    // RS Math
+    { "_Z6rsRandi", (void *)&SC_randi },
+    { "_Z6rsRandii", (void *)&SC_randi2 },
+    { "_Z6rsRandf", (void *)&SC_randf },
+    { "_Z6rsRandff", (void *)&SC_randf2 },
+    { "_Z6rsFracf", (void *)&SC_frac },
+
+    // time
+    { "rsSecond", (void *)&SC_second },
+    { "rsMinute", (void *)&SC_minute },
+    { "rsHour", (void *)&SC_hour },
+    { "rsDay", (void *)&SC_day },
+    { "rsMonth", (void *)&SC_month },
+    { "rsYear", (void *)&SC_year },
+    { "rsUptimeMillis", (void*)&SC_uptimeMillis2 },
+    { "rsStartTimeMillis", (void*)&SC_startTimeMillis2 },
+    { "rsElapsedTimeMillis", (void*)&SC_elapsedTimeMillis2 },
+
+    { "rsSendToClient", (void *)&SC_toClient },
+
+    // matrix
+    { "rsMatrixLoadIdentity", (void *)&SC_matrixLoadIdentity },
+    { "rsMatrixLoadFloat", (void *)&SC_matrixLoadFloat },
+    { "rsMatrixLoadMat", (void *)&SC_matrixLoadMat },
+    { "rsMatrixLoadRotate", (void *)&SC_matrixLoadRotate },
+    { "rsMatrixLoadScale", (void *)&SC_matrixLoadScale },
+    { "rsMatrixLoadTranslate", (void *)&SC_matrixLoadTranslate },
+    { "rsMatrixLoadMultiply", (void *)&SC_matrixLoadMultiply },
+    { "rsMatrixMultiply", (void *)&SC_matrixMultiply },
+    { "rsMatrixRotate", (void *)&SC_matrixRotate },
+    { "rsMatrixScale", (void *)&SC_matrixScale },
+    { "rsMatrixTranslate", (void *)&SC_matrixTranslate },
+
+
+////////////////////////////////////////////////////////////////////
+
     { "modf", (void *)&fmod },
-    { "_Z4fracf", (void *)&SC_frac },
     //{ "sinf_fast", (void *)&SC_sinf_fast },
     //{ "cosf_fast", (void *)&SC_cosf_fast },
-    { "randf", (void *)&SC_randf },
-    { "randf2", (void *)&SC_randf2 },
-    { "sign", (void *)&SC_sign },
-    { "clamp", (void *)&SC_clamp },
-    { "distf2", (void *)&SC_distf2 },
-    { "distf3", (void *)&SC_distf3 },
-    { "magf2", (void *)&SC_magf2 },
-    { "magf3", (void *)&SC_magf3 },
-    { "normf", (void *)&SC_normf },
-    { "mapf", (void *)&SC_mapf },
+    //{ "sign", (void *)&SC_sign },
+    //{ "clamp", (void *)&SC_clamp },
+    //{ "distf2", (void *)&SC_distf2 },
+    //{ "distf3", (void *)&SC_distf3 },
+    //{ "magf2", (void *)&SC_magf2 },
+    //{ "magf3", (void *)&SC_magf3 },
+    //{ "mapf", (void *)&SC_mapf },
     { "noisef", (void *)&SC_noisef },
     { "noisef2", (void *)&SC_noisef2 },
     { "noisef3", (void *)&SC_noisef3 },
     { "turbulencef2", (void *)&SC_turbulencef2 },
     { "turbulencef3", (void *)&SC_turbulencef3 },
 
-    // time
-    { "second", (void *)&SC_second },
-    { "minute", (void *)&SC_minute },
-    { "hour", (void *)&SC_hour },
-    { "day", (void *)&SC_day },
-    { "month", (void *)&SC_month },
-    { "year", (void *)&SC_year },
-    { "uptimeMillis", (void*)&SC_uptimeMillis },      // TODO: use long instead
-    { "startTimeMillis", (void*)&SC_startTimeMillis },      // TODO: use long instead
-    { "elapsedTimeMillis", (void*)&SC_elapsedTimeMillis },      // TODO: use long instead
-
-    // matrix
-    { "matrixLoadIdentity", (void *)&SC_matrixLoadIdentity },
-    { "matrixLoadFloat", (void *)&SC_matrixLoadFloat },
-    { "matrixLoadMat", (void *)&SC_matrixLoadMat },
-    { "matrixLoadRotate", (void *)&SC_matrixLoadRotate },
-    { "matrixLoadScale", (void *)&SC_matrixLoadScale },
-    { "matrixLoadTranslate", (void *)&SC_matrixLoadTranslate },
-    { "matrixLoadMultiply", (void *)&SC_matrixLoadMultiply },
-    { "matrixMultiply", (void *)&SC_matrixMultiply },
-    { "matrixRotate", (void *)&SC_matrixRotate },
-    { "matrixScale", (void *)&SC_matrixScale },
-    { "matrixTranslate", (void *)&SC_matrixTranslate },
-
-    // vector
-    { "vec2Rand", (void *)&SC_vec2Rand },
-
-    // vec3
-    { "vec3Norm", (void *)&SC_vec3Norm },
-    { "vec3Length", (void *)&SC_vec3Length },
-    { "vec3Add", (void *)&SC_vec3Add },
-    { "vec3Sub", (void *)&SC_vec3Sub },
-    { "vec3Cross", (void *)&SC_vec3Cross },
-    { "vec3Dot", (void *)&SC_vec3Dot },
-    { "vec3Scale", (void *)&SC_vec3Scale },
-
-    // vec4
-    { "vec4Norm", (void *)&SC_vec4Norm },
-    { "vec4Length", (void *)&SC_vec4Length },
-    { "vec4Add", (void *)&SC_vec4Add },
-    { "vec4Sub", (void *)&SC_vec4Sub },
-    { "vec4Dot", (void *)&SC_vec4Dot },
-    { "vec4Scale", (void *)&SC_vec4Scale },
-
-    // allocation
-    { "allocGetDimX", (void *)&SC_allocGetDimX },
-    { "allocGetDimY", (void *)&SC_allocGetDimY },
-    { "allocGetDimZ", (void *)&SC_allocGetDimZ },
-    { "allocGetDimLOD", (void *)&SC_allocGetDimLOD },
-    { "allocGetDimFaces", (void *)&SC_allocGetDimFaces },
-
-
-    // misc
-    { "sendToClient", (void *)&SC_toClient },
-
-    { "_Z18convertColorTo8888fff", (void *)&SC_convertColorTo8888_f3 },
-    { "_Z18convertColorTo8888ffff", (void *)&SC_convertColorTo8888_f4 },
-
-    { "debugF", (void *)&SC_debugF },
-    { "debugI32", (void *)&SC_debugI32 },
-    { "debugHexF", (void *)&SC_debugHexF },
-    { "debugHexI32", (void *)&SC_debugHexI32 },
-    { "debugP", (void *)&SC_debugP },
-    { "debugPf", (void *)&SC_debugPf },
-    { "debugPi", (void *)&SC_debugPi },
-
     { "scriptCall", (void *)&SC_scriptCall },
-    { "rsGetAllocation", (void *)&SC_getAllocation },
 
 
     { NULL, NULL }
diff --git a/libs/rs/rsScriptC_LibGL.cpp b/libs/rs/rsScriptC_LibGL.cpp
index c9d5034..a60aa80 100644
--- a/libs/rs/rsScriptC_LibGL.cpp
+++ b/libs/rs/rsScriptC_LibGL.cpp
@@ -402,11 +402,16 @@
     }
 }
 
-static void SC_uploadToTexture(RsAllocation va, uint32_t baseMipLevel)
+static void SC_uploadToTexture2(RsAllocation va, uint32_t baseMipLevel)
 {
     GET_TLS();
     rsi_AllocationUploadToTexture(rsc, va, false, baseMipLevel);
 }
+static void SC_uploadToTexture(RsAllocation va)
+{
+    GET_TLS();
+    rsi_AllocationUploadToTexture(rsc, va, false, 0);
+}
 
 static void SC_uploadToBufferObject(RsAllocation va)
 {
@@ -414,21 +419,26 @@
     rsi_AllocationUploadToBufferObject(rsc, va);
 }
 
-static void SC_syncToGL(RsAllocation va)
-{
-    GET_TLS();
-    Allocation *a = static_cast<Allocation *>(va);
-
-}
-
 static void SC_ClearColor(float r, float g, float b, float a)
 {
-    //LOGE("c %f %f %f %f", r, g, b, a);
     GET_TLS();
-    sc->mEnviroment.mClearColor[0] = r;
-    sc->mEnviroment.mClearColor[1] = g;
-    sc->mEnviroment.mClearColor[2] = b;
-    sc->mEnviroment.mClearColor[3] = a;
+    if (!rsc->setupCheck()) {
+        return;
+    }
+
+    glClearColor(r, g, b, a);
+    glClear(GL_COLOR_BUFFER_BIT);
+}
+
+static void SC_ClearDepth(float v)
+{
+    GET_TLS();
+    if (!rsc->setupCheck()) {
+        return;
+    }
+
+    glClearDepthf(v);
+    glClear(GL_DEPTH_BUFFER_BIT);
 }
 
 static uint32_t SC_getWidth()
@@ -466,50 +476,50 @@
 //                 ::= d  # double
 
 static ScriptCState::SymbolTable_t gSyms[] = {
+    { "rsgBindProgramFragment", (void *)&SC_bindProgramFragment },
+    { "rsgBindProgramStore", (void *)&SC_bindProgramStore },
+    { "rsgBindProgramVertex", (void *)&SC_bindProgramVertex },
+    { "rsgBindProgramRaster", (void *)&SC_bindProgramRaster },
+    { "rsgBindSampler", (void *)&SC_bindSampler },
+    { "rsgBindTexture", (void *)&SC_bindTexture },
+
+    { "rsgProgramVertexLoadModelMatrix", (void *)&SC_vpLoadModelMatrix },
+    { "rsgProgramVertexLoadTextureMatrix", (void *)&SC_vpLoadTextureMatrix },
+
+    { "rsgGetWidth", (void *)&SC_getWidth },
+    { "rsgGetHeight", (void *)&SC_getHeight },
+
+    { "_Z18rsgUploadToTextureii", (void *)&SC_uploadToTexture2 },
+    { "_Z18rsgUploadToTexturei", (void *)&SC_uploadToTexture },
+    { "rsgUploadToBufferObject", (void *)&SC_uploadToBufferObject },
+
+    { "rsgDrawRect", (void *)&SC_drawRect },
+    { "rsgDrawQuad", (void *)&SC_drawQuad },
+    { "rsgDrawQuadTexCoords", (void *)&SC_drawQuadTexCoords },
+    //{ "drawSprite", (void *)&SC_drawSprite },
+    { "rsgDrawSpriteScreenspace", (void *)&SC_drawSpriteScreenspace },
+    { "rsgDrawSpriteScreenspaceCropped", (void *)&SC_drawSpriteScreenspaceCropped },
+    { "rsgDrawLine", (void *)&SC_drawLine },
+    { "rsgDrawPoint", (void *)&SC_drawPoint },
+    { "_Z17rsgDrawSimpleMeshi", (void *)&SC_drawSimpleMesh },
+    { "_Z17rsgDrawSimpleMeshiii", (void *)&SC_drawSimpleMeshRange },
+
+    { "rsgClearColor", (void *)&SC_ClearColor },
+    { "rsgClearDepth", (void *)&SC_ClearDepth },
+
+
+    //////////////////////////////////////
     // IO
     { "updateSimpleMesh", (void *)&SC_updateSimpleMesh },
 
-    // context
-    { "bindProgramFragment", (void *)&SC_bindProgramFragment },
-    { "bindProgramStore", (void *)&SC_bindProgramStore },
-    { "bindProgramVertex", (void *)&SC_bindProgramVertex },
-    { "bindProgramRaster", (void *)&SC_bindProgramRaster },
-    { "bindSampler", (void *)&SC_bindSampler },
-    { "bindTexture", (void *)&SC_bindTexture },
-
-    // vp
-    { "vpLoadModelMatrix", (void *)&SC_vpLoadModelMatrix },
-    { "vpLoadTextureMatrix", (void *)&SC_vpLoadTextureMatrix },
-
-    // drawing
-    { "drawRect", (void *)&SC_drawRect },
-    { "drawQuad", (void *)&SC_drawQuad },
-    { "drawQuadTexCoords", (void *)&SC_drawQuadTexCoords },
-    { "drawSprite", (void *)&SC_drawSprite },
-    { "drawSpriteScreenspace", (void *)&SC_drawSpriteScreenspace },
-    { "drawSpriteScreenspaceCropped", (void *)&SC_drawSpriteScreenspaceCropped },
-    { "drawLine", (void *)&SC_drawLine },
-    { "drawPoint", (void *)&SC_drawPoint },
-    { "drawSimpleMesh", (void *)&SC_drawSimpleMesh },
-    { "drawSimpleMeshRange", (void *)&SC_drawSimpleMeshRange },
-
-
     // misc
-    { "pfClearColor", (void *)&SC_ClearColor },
+    //{ "pfClearColor", (void *)&SC_ClearColor },
     { "color", (void *)&SC_color },
     { "hsb", (void *)&SC_hsb },
     { "hsbToRgb", (void *)&SC_hsbToRgb },
     { "hsbToAbgr", (void *)&SC_hsbToAbgr },
     { "pointAttenuation", (void *)&SC_pointAttenuation },
 
-    { "uploadToTexture", (void *)&SC_uploadToTexture },
-    { "uploadToBufferObject", (void *)&SC_uploadToBufferObject },
-
-    { "syncToGL", (void *)&SC_syncToGL },
-
-    { "getWidth", (void *)&SC_getWidth },
-    { "getHeight", (void *)&SC_getHeight },
-
     { NULL, NULL }
 };
 
diff --git a/libs/rs/scriptc/rs_cl.rsh b/libs/rs/scriptc/rs_cl.rsh
new file mode 100644
index 0000000..6d578db
--- /dev/null
+++ b/libs/rs/scriptc/rs_cl.rsh
@@ -0,0 +1,620 @@
+// Float ops, 6.11.2
+
+extern float __attribute__((overloadable)) acos(float);
+extern float2 __attribute__((overloadable)) acos(float2);
+extern float3 __attribute__((overloadable)) acos(float3);
+extern float4 __attribute__((overloadable)) acos(float4);
+extern float8 __attribute__((overloadable)) acos(float8);
+extern float16 __attribute__((overloadable)) acos(float16);
+
+extern float __attribute__((overloadable)) acosh(float);
+extern float2 __attribute__((overloadable)) acosh(float2);
+extern float3 __attribute__((overloadable)) acosh(float3);
+extern float4 __attribute__((overloadable)) acosh(float4);
+extern float8 __attribute__((overloadable)) acosh(float8);
+extern float16 __attribute__((overloadable)) acosh(float16);
+
+extern float __attribute__((overloadable)) acospi(float);
+extern float2 __attribute__((overloadable)) acospi(float2);
+extern float3 __attribute__((overloadable)) acospi(float3);
+extern float4 __attribute__((overloadable)) acospi(float4);
+extern float8 __attribute__((overloadable)) acospi(float8);
+extern float16 __attribute__((overloadable)) acospi(float16);
+
+extern float __attribute__((overloadable)) asin(float);
+extern float2 __attribute__((overloadable)) asin(float2);
+extern float3 __attribute__((overloadable)) asin(float3);
+extern float4 __attribute__((overloadable)) asin(float4);
+extern float8 __attribute__((overloadable)) asin(float8);
+extern float16 __attribute__((overloadable)) asin(float16);
+
+extern float __attribute__((overloadable)) asinh(float);
+extern float2 __attribute__((overloadable)) asinh(float2);
+extern float3 __attribute__((overloadable)) asinh(float3);
+extern float4 __attribute__((overloadable)) asinh(float4);
+extern float8 __attribute__((overloadable)) asinh(float8);
+extern float16 __attribute__((overloadable)) asinh(float16);
+
+extern float __attribute__((overloadable)) asinpi(float);
+extern float2 __attribute__((overloadable)) asinpi(float2);
+extern float3 __attribute__((overloadable)) asinpi(float3);
+extern float4 __attribute__((overloadable)) asinpi(float4);
+extern float8 __attribute__((overloadable)) asinpi(float8);
+extern float16 __attribute__((overloadable)) asinpi(float16);
+
+extern float __attribute__((overloadable)) atan(float);
+extern float2 __attribute__((overloadable)) atan(float2);
+extern float3 __attribute__((overloadable)) atan(float3);
+extern float4 __attribute__((overloadable)) atan(float4);
+extern float8 __attribute__((overloadable)) atan(float8);
+extern float16 __attribute__((overloadable)) atan(float16);
+
+extern float __attribute__((overloadable)) atan2(float, float);
+extern float2 __attribute__((overloadable)) atan2(float2, float2);
+extern float3 __attribute__((overloadable)) atan2(float3, float3);
+extern float4 __attribute__((overloadable)) atan2(float4, float4);
+extern float8 __attribute__((overloadable)) atan2(float8, float8);
+extern float16 __attribute__((overloadable)) atan2(float16, float16);
+
+extern float __attribute__((overloadable)) atanh(float);
+extern float2 __attribute__((overloadable)) atanh(float2);
+extern float3 __attribute__((overloadable)) atanh(float3);
+extern float4 __attribute__((overloadable)) atanh(float4);
+extern float8 __attribute__((overloadable)) atanh(float8);
+extern float16 __attribute__((overloadable)) atanh(float16);
+
+extern float __attribute__((overloadable)) atanpi(float);
+extern float2 __attribute__((overloadable)) atanpi(float2);
+extern float3 __attribute__((overloadable)) atanpi(float3);
+extern float4 __attribute__((overloadable)) atanpi(float4);
+extern float8 __attribute__((overloadable)) atanpi(float8);
+extern float16 __attribute__((overloadable)) atanpi(float16);
+
+extern float __attribute__((overloadable)) atan2pi(float, float);
+extern float2 __attribute__((overloadable)) atan2pi(float2, float2);
+extern float3 __attribute__((overloadable)) atan2pi(float3, float3);
+extern float4 __attribute__((overloadable)) atan2pi(float4, float4);
+extern float8 __attribute__((overloadable)) atan2pi(float8, float8);
+extern float16 __attribute__((overloadable)) atan2pi(float16, float16);
+
+extern float __attribute__((overloadable)) cbrt(float);
+extern float2 __attribute__((overloadable)) cbrt(float2);
+extern float3 __attribute__((overloadable)) cbrt(float3);
+extern float4 __attribute__((overloadable)) cbrt(float4);
+extern float8 __attribute__((overloadable)) cbrt(float8);
+extern float16 __attribute__((overloadable)) cbrt(float16);
+
+extern float __attribute__((overloadable)) ceil(float);
+extern float2 __attribute__((overloadable)) ceil(float2);
+extern float3 __attribute__((overloadable)) ceil(float3);
+extern float4 __attribute__((overloadable)) ceil(float4);
+extern float8 __attribute__((overloadable)) ceil(float8);
+extern float16 __attribute__((overloadable)) ceil(float16);
+
+extern float __attribute__((overloadable)) copysign(float, float);
+extern float2 __attribute__((overloadable)) copysign(float2, float2);
+extern float3 __attribute__((overloadable)) copysign(float3, float3);
+extern float4 __attribute__((overloadable)) copysign(float4, float4);
+extern float8 __attribute__((overloadable)) copysign(float8, float8);
+extern float16 __attribute__((overloadable)) copysign(float16, float16);
+
+extern float __attribute__((overloadable)) cos(float);
+extern float2 __attribute__((overloadable)) cos(float2);
+extern float3 __attribute__((overloadable)) cos(float3);
+extern float4 __attribute__((overloadable)) cos(float4);
+extern float8 __attribute__((overloadable)) cos(float8);
+extern float16 __attribute__((overloadable)) cos(float16);
+
+extern float __attribute__((overloadable)) cosh(float);
+extern float2 __attribute__((overloadable)) cosh(float2);
+extern float3 __attribute__((overloadable)) cosh(float3);
+extern float4 __attribute__((overloadable)) cosh(float4);
+extern float8 __attribute__((overloadable)) cosh(float8);
+extern float16 __attribute__((overloadable)) cosh(float16);
+
+extern float __attribute__((overloadable)) cospi(float);
+extern float2 __attribute__((overloadable)) cospi(float2);
+extern float3 __attribute__((overloadable)) cospi(float3);
+extern float4 __attribute__((overloadable)) cospi(float4);
+extern float8 __attribute__((overloadable)) cospi(float8);
+extern float16 __attribute__((overloadable)) cospi(float16);
+
+extern float __attribute__((overloadable)) erfc(float);
+extern float2 __attribute__((overloadable)) erfc(float2);
+extern float3 __attribute__((overloadable)) erfc(float3);
+extern float4 __attribute__((overloadable)) erfc(float4);
+extern float8 __attribute__((overloadable)) erfc(float8);
+extern float16 __attribute__((overloadable)) erfc(float16);
+
+extern float __attribute__((overloadable)) erf(float);
+extern float2 __attribute__((overloadable)) erf(float2);
+extern float3 __attribute__((overloadable)) erf(float3);
+extern float4 __attribute__((overloadable)) erf(float4);
+extern float8 __attribute__((overloadable)) erf(float8);
+extern float16 __attribute__((overloadable)) erf(float16);
+
+extern float __attribute__((overloadable)) exp(float);
+extern float2 __attribute__((overloadable)) exp(float2);
+extern float3 __attribute__((overloadable)) exp(float3);
+extern float4 __attribute__((overloadable)) exp(float4);
+extern float8 __attribute__((overloadable)) exp(float8);
+extern float16 __attribute__((overloadable)) exp(float16);
+
+extern float __attribute__((overloadable)) exp2(float);
+extern float2 __attribute__((overloadable)) exp2(float2);
+extern float3 __attribute__((overloadable)) exp2(float3);
+extern float4 __attribute__((overloadable)) exp2(float4);
+extern float8 __attribute__((overloadable)) exp2(float8);
+extern float16 __attribute__((overloadable)) exp2(float16);
+
+extern float __attribute__((overloadable)) exp10(float);
+extern float2 __attribute__((overloadable)) exp10(float2);
+extern float3 __attribute__((overloadable)) exp10(float3);
+extern float4 __attribute__((overloadable)) exp10(float4);
+extern float8 __attribute__((overloadable)) exp10(float8);
+extern float16 __attribute__((overloadable)) exp10(float16);
+
+extern float __attribute__((overloadable)) expm1(float);
+extern float2 __attribute__((overloadable)) expm1(float2);
+extern float3 __attribute__((overloadable)) expm1(float3);
+extern float4 __attribute__((overloadable)) expm1(float4);
+extern float8 __attribute__((overloadable)) expm1(float8);
+extern float16 __attribute__((overloadable)) expm1(float16);
+
+extern float __attribute__((overloadable)) fabs(float);
+extern float2 __attribute__((overloadable)) fabs(float2);
+extern float3 __attribute__((overloadable)) fabs(float3);
+extern float4 __attribute__((overloadable)) fabs(float4);
+extern float8 __attribute__((overloadable)) fabs(float8);
+extern float16 __attribute__((overloadable)) fabs(float16);
+
+extern float __attribute__((overloadable)) fdim(float, float);
+extern float2 __attribute__((overloadable)) fdim(float2, float2);
+extern float3 __attribute__((overloadable)) fdim(float3, float3);
+extern float4 __attribute__((overloadable)) fdim(float4, float4);
+extern float8 __attribute__((overloadable)) fdim(float8, float8);
+extern float16 __attribute__((overloadable)) fdim(float16, float16);
+
+extern float __attribute__((overloadable)) floor(float);
+extern float2 __attribute__((overloadable)) floor(float2);
+extern float3 __attribute__((overloadable)) floor(float3);
+extern float4 __attribute__((overloadable)) floor(float4);
+extern float8 __attribute__((overloadable)) floor(float8);
+extern float16 __attribute__((overloadable)) floor(float16);
+
+extern float __attribute__((overloadable)) fma(float, float, float);
+extern float2 __attribute__((overloadable)) fma(float2, float2, float2);
+extern float3 __attribute__((overloadable)) fma(float3, float3, float3);
+extern float4 __attribute__((overloadable)) fma(float4, float4, float4);
+extern float8 __attribute__((overloadable)) fma(float8, float8, float8);
+extern float16 __attribute__((overloadable)) fma(float16, float16, float16);
+
+extern float __attribute__((overloadable)) fmax(float, float);
+extern float2 __attribute__((overloadable)) fmax(float2, float2);
+extern float3 __attribute__((overloadable)) fmax(float3, float3);
+extern float4 __attribute__((overloadable)) fmax(float4, float4);
+extern float8 __attribute__((overloadable)) fmax(float8, float8);
+extern float16 __attribute__((overloadable)) fmax(float16, float16);
+extern float2 __attribute__((overloadable)) fmax(float2, float);
+extern float3 __attribute__((overloadable)) fmax(float3, float);
+extern float4 __attribute__((overloadable)) fmax(float4, float);
+extern float8 __attribute__((overloadable)) fmax(float8, float);
+extern float16 __attribute__((overloadable)) fmax(float16, float);
+
+extern float __attribute__((overloadable)) fmin(float, float);
+extern float2 __attribute__((overloadable)) fmin(float2, float2);
+extern float3 __attribute__((overloadable)) fmin(float3, float3);
+extern float4 __attribute__((overloadable)) fmin(float4, float4);
+extern float8 __attribute__((overloadable)) fmin(float8, float8);
+extern float16 __attribute__((overloadable)) fmin(float16, float16);
+extern float2 __attribute__((overloadable)) fmin(float2, float);
+extern float3 __attribute__((overloadable)) fmin(float3, float);
+extern float4 __attribute__((overloadable)) fmin(float4, float);
+extern float8 __attribute__((overloadable)) fmin(float8, float);
+extern float16 __attribute__((overloadable)) fmin(float16, float);
+
+extern float __attribute__((overloadable)) fmod(float, float);
+extern float2 __attribute__((overloadable)) fmod(float2, float2);
+extern float3 __attribute__((overloadable)) fmod(float3, float3);
+extern float4 __attribute__((overloadable)) fmod(float4, float4);
+extern float8 __attribute__((overloadable)) fmod(float8, float8);
+extern float16 __attribute__((overloadable)) fmod(float16, float16);
+
+extern float __attribute__((overloadable)) fract(float, float *);
+extern float2 __attribute__((overloadable)) fract(float2, float2 *);
+extern float3 __attribute__((overloadable)) fract(float3, float3 *);
+extern float4 __attribute__((overloadable)) fract(float4, float4 *);
+extern float8 __attribute__((overloadable)) fract(float8, float8 *);
+extern float16 __attribute__((overloadable)) fract(float16, float16 *);
+
+extern float __attribute__((overloadable)) frexp(float, float *);
+extern float2 __attribute__((overloadable)) frexp(float2, float2 *);
+extern float3 __attribute__((overloadable)) frexp(float3, float3 *);
+extern float4 __attribute__((overloadable)) frexp(float4, float4 *);
+extern float8 __attribute__((overloadable)) frexp(float8, float8 *);
+extern float16 __attribute__((overloadable)) frexp(float16, float16 *);
+
+extern float __attribute__((overloadable)) hypot(float, float);
+extern float2 __attribute__((overloadable)) hypot(float2, float2);
+extern float3 __attribute__((overloadable)) hypot(float3, float3);
+extern float4 __attribute__((overloadable)) hypot(float4, float4);
+extern float8 __attribute__((overloadable)) hypot(float8, float8);
+extern float16 __attribute__((overloadable)) hypot(float16, float16);
+
+extern int __attribute__((overloadable)) ilogb(float);
+extern int2 __attribute__((overloadable)) ilogb(float2);
+extern int3 __attribute__((overloadable)) ilogb(float3);
+extern int4 __attribute__((overloadable)) ilogb(float4);
+extern int8 __attribute__((overloadable)) ilogb(float8);
+extern int16 __attribute__((overloadable)) ilogb(float16);
+
+extern float __attribute__((overloadable)) ldexp(float, int);
+extern float2 __attribute__((overloadable)) ldexp(float2, int2);
+extern float3 __attribute__((overloadable)) ldexp(float3, int3);
+extern float4 __attribute__((overloadable)) ldexp(float4, int4);
+extern float8 __attribute__((overloadable)) ldexp(float8, int8);
+extern float16 __attribute__((overloadable)) ldexp(float16, int16);
+extern float2 __attribute__((overloadable)) ldexp(float2, int);
+extern float3 __attribute__((overloadable)) ldexp(float3, int);
+extern float4 __attribute__((overloadable)) ldexp(float4, int);
+extern float8 __attribute__((overloadable)) ldexp(float8, int);
+extern float16 __attribute__((overloadable)) ldexp(float16, int);
+
+extern float __attribute__((overloadable)) lgamma(float);
+extern float2 __attribute__((overloadable)) lgamma(float2);
+extern float3 __attribute__((overloadable)) lgamma(float3);
+extern float4 __attribute__((overloadable)) lgamma(float4);
+extern float8 __attribute__((overloadable)) lgamma(float8);
+extern float16 __attribute__((overloadable)) lgamma(float16);
+extern float __attribute__((overloadable)) lgamma(float, float *);
+extern float2 __attribute__((overloadable)) lgamma(float2, float2 *);
+extern float3 __attribute__((overloadable)) lgamma(float3, float3 *);
+extern float4 __attribute__((overloadable)) lgamma(float4, float4 *);
+extern float8 __attribute__((overloadable)) lgamma(float8, float8 *);
+extern float16 __attribute__((overloadable)) lgamma(float16, float16 *);
+
+extern float __attribute__((overloadable)) log(float);
+extern float2 __attribute__((overloadable)) log(float2);
+extern float3 __attribute__((overloadable)) log(float3);
+extern float4 __attribute__((overloadable)) log(float4);
+extern float8 __attribute__((overloadable)) log(float8);
+extern float16 __attribute__((overloadable)) log(float16);
+
+extern float __attribute__((overloadable)) log2(float);
+extern float2 __attribute__((overloadable)) log2(float2);
+extern float3 __attribute__((overloadable)) log2(float3);
+extern float4 __attribute__((overloadable)) log2(float4);
+extern float8 __attribute__((overloadable)) log2(float8);
+extern float16 __attribute__((overloadable)) log2(float16);
+
+extern float __attribute__((overloadable)) log10(float);
+extern float2 __attribute__((overloadable)) log10(float2);
+extern float3 __attribute__((overloadable)) log10(float3);
+extern float4 __attribute__((overloadable)) log10(float4);
+extern float8 __attribute__((overloadable)) log10(float8);
+extern float16 __attribute__((overloadable)) log10(float16);
+
+extern float __attribute__((overloadable)) log1p(float);
+extern float2 __attribute__((overloadable)) log1p(float2);
+extern float3 __attribute__((overloadable)) log1p(float3);
+extern float4 __attribute__((overloadable)) log1p(float4);
+extern float8 __attribute__((overloadable)) log1p(float8);
+extern float16 __attribute__((overloadable)) log1p(float16);
+
+extern float __attribute__((overloadable)) logb(float);
+extern float2 __attribute__((overloadable)) logb(float2);
+extern float3 __attribute__((overloadable)) logb(float3);
+extern float4 __attribute__((overloadable)) logb(float4);
+extern float8 __attribute__((overloadable)) logb(float8);
+extern float16 __attribute__((overloadable)) logb(float16);
+
+extern float __attribute__((overloadable)) mad(float, float, float);
+extern float2 __attribute__((overloadable)) mad(float2, float2, float2);
+extern float3 __attribute__((overloadable)) mad(float3, float3, float3);
+extern float4 __attribute__((overloadable)) mad(float4, float4, float4);
+extern float8 __attribute__((overloadable)) mad(float8, float8, float8);
+extern float16 __attribute__((overloadable)) mad(float16, float16, float16);
+
+extern float __attribute__((overloadable)) modf(float, float *);
+extern float2 __attribute__((overloadable)) modf(float2, float2 *);
+extern float3 __attribute__((overloadable)) modf(float3, float3 *);
+extern float4 __attribute__((overloadable)) modf(float4, float4 *);
+extern float8 __attribute__((overloadable)) modf(float8, float8 *);
+extern float16 __attribute__((overloadable)) modf(float16, float16 *);
+
+extern float __attribute__((overloadable)) nan(uint);
+extern float2 __attribute__((overloadable)) nan(uint2);
+extern float3 __attribute__((overloadable)) nan(uint3);
+extern float4 __attribute__((overloadable)) nan(uint4);
+extern float8 __attribute__((overloadable)) nan(uint8);
+extern float16 __attribute__((overloadable)) nan(uint16);
+
+extern float __attribute__((overloadable)) nextafter(float, float);
+extern float2 __attribute__((overloadable)) nextafter(float2, float2);
+extern float3 __attribute__((overloadable)) nextafter(float3, float3);
+extern float4 __attribute__((overloadable)) nextafter(float4, float4);
+extern float8 __attribute__((overloadable)) nextafter(float8, float8);
+extern float16 __attribute__((overloadable)) nextafter(float16, float16);
+
+extern float __attribute__((overloadable)) pow(float, float);
+extern float2 __attribute__((overloadable)) pow(float2, float2);
+extern float3 __attribute__((overloadable)) pow(float3, float3);
+extern float4 __attribute__((overloadable)) pow(float4, float4);
+extern float8 __attribute__((overloadable)) pow(float8, float8);
+extern float16 __attribute__((overloadable)) pow(float16, float16);
+
+extern float __attribute__((overloadable)) pown(float, int);
+extern float2 __attribute__((overloadable)) pown(float2, int2);
+extern float3 __attribute__((overloadable)) pown(float3, int3);
+extern float4 __attribute__((overloadable)) pown(float4, int4);
+extern float8 __attribute__((overloadable)) pown(float8, int8);
+extern float16 __attribute__((overloadable)) pown(float16, int16);
+
+extern float __attribute__((overloadable)) powr(float, float);
+extern float2 __attribute__((overloadable)) powr(float2, float2);
+extern float3 __attribute__((overloadable)) powr(float3, float3);
+extern float4 __attribute__((overloadable)) powr(float4, float4);
+extern float8 __attribute__((overloadable)) powr(float8, float8);
+extern float16 __attribute__((overloadable)) powr(float16, float16);
+
+extern float __attribute__((overloadable)) remainder(float, float);
+extern float2 __attribute__((overloadable)) remainder(float2, float2);
+extern float3 __attribute__((overloadable)) remainder(float3, float3);
+extern float4 __attribute__((overloadable)) remainder(float4, float4);
+extern float8 __attribute__((overloadable)) remainder(float8, float8);
+extern float16 __attribute__((overloadable)) remainder(float16, float16);
+
+extern float __attribute__((overloadable)) remquo(float, float, float *);
+extern float2 __attribute__((overloadable)) remquo(float2, float2, float2 *);
+extern float3 __attribute__((overloadable)) remquo(float3, float3, float3 *);
+extern float4 __attribute__((overloadable)) remquo(float4, float4, float4 *);
+extern float8 __attribute__((overloadable)) remquo(float8, float8, float8 *);
+extern float16 __attribute__((overloadable)) remquo(float16, float16, float16 *);
+
+extern float __attribute__((overloadable)) rint(float);
+extern float2 __attribute__((overloadable)) rint(float2);
+extern float3 __attribute__((overloadable)) rint(float3);
+extern float4 __attribute__((overloadable)) rint(float4);
+extern float8 __attribute__((overloadable)) rint(float8);
+extern float16 __attribute__((overloadable)) rint(float16);
+
+extern float __attribute__((overloadable)) rootn(float, int);
+extern float2 __attribute__((overloadable)) rootn(float2, int2);
+extern float3 __attribute__((overloadable)) rootn(float3, int3);
+extern float4 __attribute__((overloadable)) rootn(float4, int4);
+extern float8 __attribute__((overloadable)) rootn(float8, int8);
+extern float16 __attribute__((overloadable)) rootn(float16, int16);
+
+extern float __attribute__((overloadable)) round(float);
+extern float2 __attribute__((overloadable)) round(float2);
+extern float3 __attribute__((overloadable)) round(float3);
+extern float4 __attribute__((overloadable)) round(float4);
+extern float8 __attribute__((overloadable)) round(float8);
+extern float16 __attribute__((overloadable)) round(float16);
+
+extern float __attribute__((overloadable)) rsqrt(float);
+extern float2 __attribute__((overloadable)) rsqrt(float2);
+extern float3 __attribute__((overloadable)) rsqrt(float3);
+extern float4 __attribute__((overloadable)) rsqrt(float4);
+extern float8 __attribute__((overloadable)) rsqrt(float8);
+extern float16 __attribute__((overloadable)) rsqrt(float16);
+
+extern float __attribute__((overloadable)) sin(float);
+extern float2 __attribute__((overloadable)) sin(float2);
+extern float3 __attribute__((overloadable)) sin(float3);
+extern float4 __attribute__((overloadable)) sin(float4);
+extern float8 __attribute__((overloadable)) sin(float8);
+extern float16 __attribute__((overloadable)) sin(float16);
+
+extern float __attribute__((overloadable)) sincos(float, float *);
+extern float2 __attribute__((overloadable)) sincos(float2, float2 *);
+extern float3 __attribute__((overloadable)) sincos(float3, float3 *);
+extern float4 __attribute__((overloadable)) sincos(float4, float4 *);
+extern float8 __attribute__((overloadable)) sincos(float8, float8 *);
+extern float16 __attribute__((overloadable)) sincos(float16, float16 *);
+
+extern float __attribute__((overloadable)) sinh(float);
+extern float2 __attribute__((overloadable)) sinh(float2);
+extern float3 __attribute__((overloadable)) sinh(float3);
+extern float4 __attribute__((overloadable)) sinh(float4);
+extern float8 __attribute__((overloadable)) sinh(float8);
+extern float16 __attribute__((overloadable)) sinh(float16);
+
+extern float __attribute__((overloadable)) sinpi(float);
+extern float2 __attribute__((overloadable)) sinpi(float2);
+extern float3 __attribute__((overloadable)) sinpi(float3);
+extern float4 __attribute__((overloadable)) sinpi(float4);
+extern float8 __attribute__((overloadable)) sinpi(float8);
+extern float16 __attribute__((overloadable)) sinpi(float16);
+
+extern float __attribute__((overloadable)) sqrt(float);
+extern float2 __attribute__((overloadable)) sqrt(float2);
+extern float3 __attribute__((overloadable)) sqrt(float3);
+extern float4 __attribute__((overloadable)) sqrt(float4);
+extern float8 __attribute__((overloadable)) sqrt(float8);
+extern float16 __attribute__((overloadable)) sqrt(float16);
+
+extern float __attribute__((overloadable)) tan(float);
+extern float2 __attribute__((overloadable)) tan(float2);
+extern float3 __attribute__((overloadable)) tan(float3);
+extern float4 __attribute__((overloadable)) tan(float4);
+extern float8 __attribute__((overloadable)) tan(float8);
+extern float16 __attribute__((overloadable)) tan(float16);
+
+extern float __attribute__((overloadable)) tanh(float);
+extern float2 __attribute__((overloadable)) tanh(float2);
+extern float3 __attribute__((overloadable)) tanh(float3);
+extern float4 __attribute__((overloadable)) tanh(float4);
+extern float8 __attribute__((overloadable)) tanh(float8);
+extern float16 __attribute__((overloadable)) tanh(float16);
+
+extern float __attribute__((overloadable)) tanpi(float);
+extern float2 __attribute__((overloadable)) tanpi(float2);
+extern float3 __attribute__((overloadable)) tanpi(float3);
+extern float4 __attribute__((overloadable)) tanpi(float4);
+extern float8 __attribute__((overloadable)) tanpi(float8);
+extern float16 __attribute__((overloadable)) tanpi(float16);
+
+extern float __attribute__((overloadable)) tgamma(float);
+extern float2 __attribute__((overloadable)) tgamma(float2);
+extern float3 __attribute__((overloadable)) tgamma(float3);
+extern float4 __attribute__((overloadable)) tgamma(float4);
+extern float8 __attribute__((overloadable)) tgamma(float8);
+extern float16 __attribute__((overloadable)) tgamma(float16);
+
+extern float __attribute__((overloadable)) trunc(float);
+extern float2 __attribute__((overloadable)) trunc(float2);
+extern float3 __attribute__((overloadable)) trunc(float3);
+extern float4 __attribute__((overloadable)) trunc(float4);
+extern float8 __attribute__((overloadable)) trunc(float8);
+extern float16 __attribute__((overloadable)) trunc(float16);
+
+// Int ops (partial), 6.11.3
+extern uint __attribute__((overloadable)) abs(int);
+extern ushort __attribute__((overloadable)) abs(short);
+extern uchar __attribute__((overloadable)) abs(char);
+
+extern uint __attribute__((overloadable)) clz(uint);
+extern int __attribute__((overloadable)) clz(int);
+extern ushort __attribute__((overloadable)) clz(ushort);
+extern short __attribute__((overloadable)) clz(short);
+extern uchar __attribute__((overloadable)) clz(uchar);
+extern char __attribute__((overloadable)) clz(char);
+
+extern uint __attribute__((overloadable)) min(uint, uint);
+extern int __attribute__((overloadable)) min(int, int);
+extern ushort __attribute__((overloadable)) min(ushort, ushort);
+extern short __attribute__((overloadable)) min(short, short);
+extern uchar __attribute__((overloadable)) min(uchar, uchar);
+extern char __attribute__((overloadable)) min(char, char);
+
+extern uint __attribute__((overloadable)) max(uint, uint);
+extern int __attribute__((overloadable)) max(int, int);
+extern ushort __attribute__((overloadable)) max(ushort, ushort);
+extern short __attribute__((overloadable)) max(short, short);
+extern uchar __attribute__((overloadable)) max(uchar, uchar);
+extern char __attribute__((overloadable)) max(char, char);
+
+
+
+
+// 6.11.4
+
+extern float __attribute__((overloadable)) clamp(float, float, float);
+extern float2 __attribute__((overloadable)) clamp(float2, float2, float2);
+extern float3 __attribute__((overloadable)) clamp(float3, float3, float3);
+extern float4 __attribute__((overloadable)) clamp(float4, float4, float4);
+extern float8 __attribute__((overloadable)) clamp(float8, float8, float8);
+extern float16 __attribute__((overloadable)) clamp(float16, float16, float16);
+extern float2 __attribute__((overloadable)) clamp(float2, float, float);
+extern float3 __attribute__((overloadable)) clamp(float3, float, float);
+extern float4 __attribute__((overloadable)) clamp(float4, float, float);
+extern float8 __attribute__((overloadable)) clamp(float8, float, float);
+extern float16 __attribute__((overloadable)) clamp(float16, float, float);
+
+extern float __attribute__((overloadable)) degrees(float);
+extern float2 __attribute__((overloadable)) degrees(float2);
+extern float3 __attribute__((overloadable)) degrees(float3);
+extern float4 __attribute__((overloadable)) degrees(float4);
+extern float8 __attribute__((overloadable)) degrees(float8);
+extern float16 __attribute__((overloadable)) degrees(float16);
+
+extern float __attribute__((overloadable)) max(float, float);
+extern float2 __attribute__((overloadable)) max(float2, float2);
+extern float3 __attribute__((overloadable)) max(float3, float3);
+extern float4 __attribute__((overloadable)) max(float4, float4);
+extern float8 __attribute__((overloadable)) max(float8, float8);
+extern float16 __attribute__((overloadable)) max(float16, float16);
+extern float2 __attribute__((overloadable)) max(float2, float);
+extern float3 __attribute__((overloadable)) max(float3, float);
+extern float4 __attribute__((overloadable)) max(float4, float);
+extern float8 __attribute__((overloadable)) max(float8, float);
+extern float16 __attribute__((overloadable)) max(float16, float);
+
+extern float __attribute__((overloadable)) min(float, float);
+extern float2 __attribute__((overloadable)) min(float2, float2);
+extern float3 __attribute__((overloadable)) min(float3, float3);
+extern float4 __attribute__((overloadable)) min(float4, float4);
+extern float8 __attribute__((overloadable)) min(float8, float8);
+extern float16 __attribute__((overloadable)) min(float16, float16);
+extern float2 __attribute__((overloadable)) min(float2, float);
+extern float3 __attribute__((overloadable)) min(float3, float);
+extern float4 __attribute__((overloadable)) min(float4, float);
+extern float8 __attribute__((overloadable)) min(float8, float);
+extern float16 __attribute__((overloadable)) min(float16, float);
+
+extern float __attribute__((overloadable)) mix(float, float, float);
+extern float2 __attribute__((overloadable)) mix(float2, float2, float2);
+extern float3 __attribute__((overloadable)) mix(float3, float3, float3);
+extern float4 __attribute__((overloadable)) mix(float4, float4, float4);
+extern float8 __attribute__((overloadable)) mix(float8, float8, float8);
+extern float16 __attribute__((overloadable)) mix(float16, float16, float16);
+extern float2 __attribute__((overloadable)) mix(float2, float2, float);
+extern float3 __attribute__((overloadable)) mix(float3, float3, float);
+extern float4 __attribute__((overloadable)) mix(float4, float4, float);
+extern float8 __attribute__((overloadable)) mix(float8, float8, float);
+extern float16 __attribute__((overloadable)) mix(float16, float16, float);
+
+extern float __attribute__((overloadable)) radians(float);
+extern float2 __attribute__((overloadable)) radians(float2);
+extern float3 __attribute__((overloadable)) radians(float3);
+extern float4 __attribute__((overloadable)) radians(float4);
+extern float8 __attribute__((overloadable)) radians(float8);
+extern float16 __attribute__((overloadable)) radians(float16);
+
+extern float __attribute__((overloadable)) step(float, float);
+extern float2 __attribute__((overloadable)) step(float2, float2);
+extern float3 __attribute__((overloadable)) step(float3, float3);
+extern float4 __attribute__((overloadable)) step(float4, float4);
+extern float8 __attribute__((overloadable)) step(float8, float8);
+extern float16 __attribute__((overloadable)) step(float16, float16);
+extern float2 __attribute__((overloadable)) step(float, float2);
+extern float3 __attribute__((overloadable)) step(float, float3);
+extern float4 __attribute__((overloadable)) step(float, float4);
+extern float8 __attribute__((overloadable)) step(float, float8);
+extern float16 __attribute__((overloadable)) step(float, float16);
+
+extern float __attribute__((overloadable)) smoothstep(float, float, float);
+extern float2 __attribute__((overloadable)) smoothstep(float2, float2, float2);
+extern float3 __attribute__((overloadable)) smoothstep(float3, float3, float3);
+extern float4 __attribute__((overloadable)) smoothstep(float4, float4, float4);
+extern float8 __attribute__((overloadable)) smoothstep(float8, float8, float8);
+extern float16 __attribute__((overloadable)) smoothstep(float16, float16, float16);
+extern float2 __attribute__((overloadable)) smoothstep(float, float, float2);
+extern float3 __attribute__((overloadable)) smoothstep(float, float, float3);
+extern float4 __attribute__((overloadable)) smoothstep(float, float, float4);
+extern float8 __attribute__((overloadable)) smoothstep(float, float, float8);
+extern float16 __attribute__((overloadable)) smoothstep(float, float, float16);
+
+extern float __attribute__((overloadable)) sign(float);
+extern float2 __attribute__((overloadable)) sign(float2);
+extern float3 __attribute__((overloadable)) sign(float3);
+extern float4 __attribute__((overloadable)) sign(float4);
+extern float8 __attribute__((overloadable)) sign(float8);
+extern float16 __attribute__((overloadable)) sign(float16);
+
+// 6.11.5
+extern float3 __attribute__((overloadable)) cross(float2, float2);
+extern float3 __attribute__((overloadable)) cross(float3, float3);
+extern float4 __attribute__((overloadable)) cross(float4, float4);
+
+extern float __attribute__((overloadable)) dot(float, float);
+extern float __attribute__((overloadable)) dot(float2, float2);
+extern float __attribute__((overloadable)) dot(float3, float3);
+extern float __attribute__((overloadable)) dot(float4, float4);
+
+extern float __attribute__((overloadable)) distance(float, float);
+extern float __attribute__((overloadable)) distance(float2, float2);
+extern float __attribute__((overloadable)) distance(float3, float3);
+extern float __attribute__((overloadable)) distance(float4, float4);
+
+extern float __attribute__((overloadable)) length(float);
+extern float __attribute__((overloadable)) length(float2);
+extern float __attribute__((overloadable)) length(float3);
+extern float __attribute__((overloadable)) length(float4);
+
+extern float __attribute__((overloadable)) normalize(float);
+extern float2 __attribute__((overloadable)) normalize(float2);
+extern float3 __attribute__((overloadable)) normalize(float3);
+extern float4 __attribute__((overloadable)) normalize(float4);
+
diff --git a/libs/rs/scriptc/rs_graphics.rsh b/libs/rs/scriptc/rs_graphics.rsh
index 4696fb3..626f267 100644
--- a/libs/rs/scriptc/rs_graphics.rsh
+++ b/libs/rs/scriptc/rs_graphics.rsh
@@ -1,80 +1,45 @@
+#include "rs_math.rsh"
 
 
-extern float rand(float max);
+// context
+extern void rsgBindProgramFragment(rs_program_fragment);
+extern void rsgBindProgramStore(rs_program_store);
+extern void rsgBindProgramVertex(rs_program_vertex);
+extern void rsgBindProgramRaster(rs_program_raster);
 
-//extern void vec2Rand(float *, float len);
-extern float2 vec2Rand(float len);
+extern void rsgBindSampler(rs_program_fragment, int slot, rs_sampler);
+extern void rsgBindTexture(rs_program_fragment, int slot, rs_allocation);
 
-extern float3 float3Norm(float3);
-extern float float3Length(float3);
-extern float3 float3Add(float3 lhs, float3 rhs);
-extern float3 float3Sub(float3 lhs, float3 rhs);
-extern float3 float3Cross(float3 lhs, float3 rhs);
-extern float float3Dot(float3 lhs, float3 rhs);
-extern float3 float3Scale(float3 v, float scale);
+extern void rsgProgramVertexLoadModelMatrix(const rs_matrix4x4 *);
+extern void rsgProgramVertexLoadTextureMatrix(const rs_matrix4x4 *);
 
-extern float4 float4Add(float4 lhs, float4 rhs);
-extern float4 float4Sub(float4 lhs, float4 rhs);
-extern float4 float4Cross(float4 lhs, float4 rhs);
-extern float float4Dot(float4 lhs, float4 rhs);
-extern float4 float4Scale(float4 v, float scale);
+extern int rsgGetWidth();
+extern int rsgGetHeight();
 
-    // context
-extern void bindProgramFragment(rs_program_fragment);
-extern void bindProgramStore(rs_program_store);
-extern void bindProgramVertex(rs_program_vertex);
+extern void __attribute__((overloadable)) rsgUploadToTexture(rs_allocation);
+extern void __attribute__((overloadable)) rsgUploadToTexture(rs_allocation, int mipLevel);
+extern void rsgUploadToBufferObject(rs_allocation);
+//extern void rsgUploadMesh(rs_mesh);
 
-extern void bindSampler(rs_program_fragment, int slot, rs_sampler);
-extern void bindSampler(rs_program_fragment, int slot, rs_allocation);
+extern void rsgDrawRect(float x1, float y1, float x2, float y2, float z);
+extern void rsgDrawQuad(float x1, float y1, float z1, float x2, float y2, float z2, float x3, float y3, float z3, float x4, float y4, float z4);
+extern void rsgDrawQuadTexCoords(float x1, float y1, float z1, float u1, float v1, float x2, float y2, float z2, float u2, float v2, float x3, float y3, float z3, float u3, float v3, float x4, float y4, float z4, float u4, float v4);
+//extern void rsgDrawSprite(float x, float y, float z, float w, float h);
+extern void rsgDrawSpriteScreenspace(float x, float y, float z, float w, float h);
+extern void rsgDrawLine(float x1, float y1, float z1, float x2, float y2, float z2);
+extern void rsgDrawPoint(float x1, float y1, float z1);
+extern void __attribute__((overloadable)) rsgDrawSimpleMesh(rs_mesh ism);
+extern void __attribute__((overloadable)) rsgDrawSimpleMesh(rs_mesh ism, int start, int len);
 
-extern void vpLoadModelMatrix(const float *);
-extern void vpLoadTextureMatrix(const float *);
+extern void rsgClearColor(float, float, float, float);
+extern void rsgClearDepth(float);
 
-
-// drawing
-extern void drawRect(float x1, float y1, float x2, float y2, float z);
-extern void drawQuad(float x1, float y1, float z1, float x2, float y2, float z2, float x3, float y3, float z3, float x4, float y4, float z4);
-extern void drawQuadTexCoords(float x1, float y1, float z1, float u1, float v1, float x2, float y2, float z2, float u2, float v2, float x3, float y3, float z3, float u3, float v3, float x4, float y4, float z4, float u4, float v4);
-extern void drawSprite(float x, float y, float z, float w, float h);
-extern void drawSpriteScreenspace(float x, float y, float z, float w, float h);
-extern void drawLine(float x1, float y1, float z1, float x2, float y2, float z2);
-extern void drawPoint(float x1, float y1, float z1);
-extern void drawSimpleMesh(int ism);
-extern void drawSimpleMeshRange(int ism, int start, int len);
-
+///////////////////////////////////////////////////////
 // misc
-extern void pfClearColor(float, float, float, float);
 extern void color(float, float, float, float);
 extern void hsb(float, float, float, float);
 extern void hsbToRgb(float, float, float, float*);
 extern int hsbToAbgr(float, float, float, float);
 
-extern void uploadToTexture(int, int);
-extern void uploadToBufferObject(int);
-
-extern int colorFloatRGBAtoUNorm8(float, float, float, float);
-extern int colorFloatRGBto565(float, float, float);
-
-extern int getWidth();
-extern int getHeight();
-
-extern int sendToClient(void *data, int cmdID, int len, int waitForSpace);
-
-extern uint32_t allocGetDimX(rs_allocation);
-extern uint32_t allocGetDimY(rs_allocation);
-extern uint32_t allocGetDimZ(rs_allocation);
-extern uint32_t allocGetDimLOD(rs_allocation);
-extern uint32_t allocGetDimFaces(rs_allocation);
-
-//
-extern float normf(float start, float stop, float value);
-extern float clampf(float amount, float low, float high);
-extern float turbulencef2(float x, float y, float octaves);
-extern float turbulencef3(float x, float y, float z, float octaves);
-
-extern uchar4 __attribute__((overloadable)) convertColorTo8888(float r, float g, float b);
-extern uchar4 __attribute__((overloadable)) convertColorTo8888(float r, float g, float b, float a);
-extern uchar4 __attribute__((overloadable)) convertColorTo8888(float3);
-extern uchar4 __attribute__((overloadable)) convertColorTo8888(float4);
 
 
diff --git a/libs/rs/scriptc/rs_math.rsh b/libs/rs/scriptc/rs_math.rsh
index 1d2f1e4..a9c163d 100644
--- a/libs/rs/scriptc/rs_math.rsh
+++ b/libs/rs/scriptc/rs_math.rsh
@@ -1,654 +1,92 @@
-// Float ops, 6.11.2
+#include "rs_cl.rsh"
 
-extern float __attribute__((overloadable)) acos(float);
-extern float2 __attribute__((overloadable)) acos(float2);
-extern float3 __attribute__((overloadable)) acos(float3);
-extern float4 __attribute__((overloadable)) acos(float4);
-extern float8 __attribute__((overloadable)) acos(float8);
-extern float16 __attribute__((overloadable)) acos(float16);
 
-extern float __attribute__((overloadable)) acosh(float);
-extern float2 __attribute__((overloadable)) acosh(float2);
-extern float3 __attribute__((overloadable)) acosh(float3);
-extern float4 __attribute__((overloadable)) acosh(float4);
-extern float8 __attribute__((overloadable)) acosh(float8);
-extern float16 __attribute__((overloadable)) acosh(float16);
-
-extern float __attribute__((overloadable)) acospi(float);
-extern float2 __attribute__((overloadable)) acospi(float2);
-extern float3 __attribute__((overloadable)) acospi(float3);
-extern float4 __attribute__((overloadable)) acospi(float4);
-extern float8 __attribute__((overloadable)) acospi(float8);
-extern float16 __attribute__((overloadable)) acospi(float16);
-
-extern float __attribute__((overloadable)) asin(float);
-extern float2 __attribute__((overloadable)) asin(float2);
-extern float3 __attribute__((overloadable)) asin(float3);
-extern float4 __attribute__((overloadable)) asin(float4);
-extern float8 __attribute__((overloadable)) asin(float8);
-extern float16 __attribute__((overloadable)) asin(float16);
-
-extern float __attribute__((overloadable)) asinh(float);
-extern float2 __attribute__((overloadable)) asinh(float2);
-extern float3 __attribute__((overloadable)) asinh(float3);
-extern float4 __attribute__((overloadable)) asinh(float4);
-extern float8 __attribute__((overloadable)) asinh(float8);
-extern float16 __attribute__((overloadable)) asinh(float16);
-
-extern float __attribute__((overloadable)) asinpi(float);
-extern float2 __attribute__((overloadable)) asinpi(float2);
-extern float3 __attribute__((overloadable)) asinpi(float3);
-extern float4 __attribute__((overloadable)) asinpi(float4);
-extern float8 __attribute__((overloadable)) asinpi(float8);
-extern float16 __attribute__((overloadable)) asinpi(float16);
-
-extern float __attribute__((overloadable)) atan(float);
-extern float2 __attribute__((overloadable)) atan(float2);
-extern float3 __attribute__((overloadable)) atan(float3);
-extern float4 __attribute__((overloadable)) atan(float4);
-extern float8 __attribute__((overloadable)) atan(float8);
-extern float16 __attribute__((overloadable)) atan(float16);
-
-extern float __attribute__((overloadable)) atan2(float, float);
-extern float2 __attribute__((overloadable)) atan2(float2, float2);
-extern float3 __attribute__((overloadable)) atan2(float3, float3);
-extern float4 __attribute__((overloadable)) atan2(float4, float4);
-extern float8 __attribute__((overloadable)) atan2(float8, float8);
-extern float16 __attribute__((overloadable)) atan2(float16, float16);
-
-extern float __attribute__((overloadable)) atanh(float);
-extern float2 __attribute__((overloadable)) atanh(float2);
-extern float3 __attribute__((overloadable)) atanh(float3);
-extern float4 __attribute__((overloadable)) atanh(float4);
-extern float8 __attribute__((overloadable)) atanh(float8);
-extern float16 __attribute__((overloadable)) atanh(float16);
-
-extern float __attribute__((overloadable)) atanpi(float);
-extern float2 __attribute__((overloadable)) atanpi(float2);
-extern float3 __attribute__((overloadable)) atanpi(float3);
-extern float4 __attribute__((overloadable)) atanpi(float4);
-extern float8 __attribute__((overloadable)) atanpi(float8);
-extern float16 __attribute__((overloadable)) atanpi(float16);
-
-extern float __attribute__((overloadable)) atan2pi(float, float);
-extern float2 __attribute__((overloadable)) atan2pi(float2, float2);
-extern float3 __attribute__((overloadable)) atan2pi(float3, float3);
-extern float4 __attribute__((overloadable)) atan2pi(float4, float4);
-extern float8 __attribute__((overloadable)) atan2pi(float8, float8);
-extern float16 __attribute__((overloadable)) atan2pi(float16, float16);
-
-extern float __attribute__((overloadable)) cbrt(float);
-extern float2 __attribute__((overloadable)) cbrt(float2);
-extern float3 __attribute__((overloadable)) cbrt(float3);
-extern float4 __attribute__((overloadable)) cbrt(float4);
-extern float8 __attribute__((overloadable)) cbrt(float8);
-extern float16 __attribute__((overloadable)) cbrt(float16);
-
-extern float __attribute__((overloadable)) ceil(float);
-extern float2 __attribute__((overloadable)) ceil(float2);
-extern float3 __attribute__((overloadable)) ceil(float3);
-extern float4 __attribute__((overloadable)) ceil(float4);
-extern float8 __attribute__((overloadable)) ceil(float8);
-extern float16 __attribute__((overloadable)) ceil(float16);
-
-extern float __attribute__((overloadable)) copysign(float, float);
-extern float2 __attribute__((overloadable)) copysign(float2, float2);
-extern float3 __attribute__((overloadable)) copysign(float3, float3);
-extern float4 __attribute__((overloadable)) copysign(float4, float4);
-extern float8 __attribute__((overloadable)) copysign(float8, float8);
-extern float16 __attribute__((overloadable)) copysign(float16, float16);
-
-extern float __attribute__((overloadable)) cos(float);
-extern float2 __attribute__((overloadable)) cos(float2);
-extern float3 __attribute__((overloadable)) cos(float3);
-extern float4 __attribute__((overloadable)) cos(float4);
-extern float8 __attribute__((overloadable)) cos(float8);
-extern float16 __attribute__((overloadable)) cos(float16);
-
-extern float __attribute__((overloadable)) cosh(float);
-extern float2 __attribute__((overloadable)) cosh(float2);
-extern float3 __attribute__((overloadable)) cosh(float3);
-extern float4 __attribute__((overloadable)) cosh(float4);
-extern float8 __attribute__((overloadable)) cosh(float8);
-extern float16 __attribute__((overloadable)) cosh(float16);
-
-extern float __attribute__((overloadable)) cospi(float);
-extern float2 __attribute__((overloadable)) cospi(float2);
-extern float3 __attribute__((overloadable)) cospi(float3);
-extern float4 __attribute__((overloadable)) cospi(float4);
-extern float8 __attribute__((overloadable)) cospi(float8);
-extern float16 __attribute__((overloadable)) cospi(float16);
-
-extern float __attribute__((overloadable)) erfc(float);
-extern float2 __attribute__((overloadable)) erfc(float2);
-extern float3 __attribute__((overloadable)) erfc(float3);
-extern float4 __attribute__((overloadable)) erfc(float4);
-extern float8 __attribute__((overloadable)) erfc(float8);
-extern float16 __attribute__((overloadable)) erfc(float16);
-
-extern float __attribute__((overloadable)) erf(float);
-extern float2 __attribute__((overloadable)) erf(float2);
-extern float3 __attribute__((overloadable)) erf(float3);
-extern float4 __attribute__((overloadable)) erf(float4);
-extern float8 __attribute__((overloadable)) erf(float8);
-extern float16 __attribute__((overloadable)) erf(float16);
-
-extern float __attribute__((overloadable)) exp(float);
-extern float2 __attribute__((overloadable)) exp(float2);
-extern float3 __attribute__((overloadable)) exp(float3);
-extern float4 __attribute__((overloadable)) exp(float4);
-extern float8 __attribute__((overloadable)) exp(float8);
-extern float16 __attribute__((overloadable)) exp(float16);
-
-extern float __attribute__((overloadable)) exp2(float);
-extern float2 __attribute__((overloadable)) exp2(float2);
-extern float3 __attribute__((overloadable)) exp2(float3);
-extern float4 __attribute__((overloadable)) exp2(float4);
-extern float8 __attribute__((overloadable)) exp2(float8);
-extern float16 __attribute__((overloadable)) exp2(float16);
-
-extern float __attribute__((overloadable)) exp10(float);
-extern float2 __attribute__((overloadable)) exp10(float2);
-extern float3 __attribute__((overloadable)) exp10(float3);
-extern float4 __attribute__((overloadable)) exp10(float4);
-extern float8 __attribute__((overloadable)) exp10(float8);
-extern float16 __attribute__((overloadable)) exp10(float16);
-
-extern float __attribute__((overloadable)) expm1(float);
-extern float2 __attribute__((overloadable)) expm1(float2);
-extern float3 __attribute__((overloadable)) expm1(float3);
-extern float4 __attribute__((overloadable)) expm1(float4);
-extern float8 __attribute__((overloadable)) expm1(float8);
-extern float16 __attribute__((overloadable)) expm1(float16);
-
-extern float __attribute__((overloadable)) fabs(float);
-extern float2 __attribute__((overloadable)) fabs(float2);
-extern float3 __attribute__((overloadable)) fabs(float3);
-extern float4 __attribute__((overloadable)) fabs(float4);
-extern float8 __attribute__((overloadable)) fabs(float8);
-extern float16 __attribute__((overloadable)) fabs(float16);
-
-extern float __attribute__((overloadable)) fdim(float, float);
-extern float2 __attribute__((overloadable)) fdim(float2, float2);
-extern float3 __attribute__((overloadable)) fdim(float3, float3);
-extern float4 __attribute__((overloadable)) fdim(float4, float4);
-extern float8 __attribute__((overloadable)) fdim(float8, float8);
-extern float16 __attribute__((overloadable)) fdim(float16, float16);
-
-extern float __attribute__((overloadable)) floor(float);
-extern float2 __attribute__((overloadable)) floor(float2);
-extern float3 __attribute__((overloadable)) floor(float3);
-extern float4 __attribute__((overloadable)) floor(float4);
-extern float8 __attribute__((overloadable)) floor(float8);
-extern float16 __attribute__((overloadable)) floor(float16);
-
-extern float __attribute__((overloadable)) fma(float, float, float);
-extern float2 __attribute__((overloadable)) fma(float2, float2, float2);
-extern float3 __attribute__((overloadable)) fma(float3, float3, float3);
-extern float4 __attribute__((overloadable)) fma(float4, float4, float4);
-extern float8 __attribute__((overloadable)) fma(float8, float8, float8);
-extern float16 __attribute__((overloadable)) fma(float16, float16, float16);
-
-extern float __attribute__((overloadable)) fmax(float, float);
-extern float2 __attribute__((overloadable)) fmax(float2, float2);
-extern float3 __attribute__((overloadable)) fmax(float3, float3);
-extern float4 __attribute__((overloadable)) fmax(float4, float4);
-extern float8 __attribute__((overloadable)) fmax(float8, float8);
-extern float16 __attribute__((overloadable)) fmax(float16, float16);
-extern float2 __attribute__((overloadable)) fmax(float2, float);
-extern float3 __attribute__((overloadable)) fmax(float3, float);
-extern float4 __attribute__((overloadable)) fmax(float4, float);
-extern float8 __attribute__((overloadable)) fmax(float8, float);
-extern float16 __attribute__((overloadable)) fmax(float16, float);
-
-extern float __attribute__((overloadable)) fmin(float, float);
-extern float2 __attribute__((overloadable)) fmin(float2, float2);
-extern float3 __attribute__((overloadable)) fmin(float3, float3);
-extern float4 __attribute__((overloadable)) fmin(float4, float4);
-extern float8 __attribute__((overloadable)) fmin(float8, float8);
-extern float16 __attribute__((overloadable)) fmin(float16, float16);
-extern float2 __attribute__((overloadable)) fmin(float2, float);
-extern float3 __attribute__((overloadable)) fmin(float3, float);
-extern float4 __attribute__((overloadable)) fmin(float4, float);
-extern float8 __attribute__((overloadable)) fmin(float8, float);
-extern float16 __attribute__((overloadable)) fmin(float16, float);
-
-extern float __attribute__((overloadable)) fmod(float, float);
-extern float2 __attribute__((overloadable)) fmod(float2, float2);
-extern float3 __attribute__((overloadable)) fmod(float3, float3);
-extern float4 __attribute__((overloadable)) fmod(float4, float4);
-extern float8 __attribute__((overloadable)) fmod(float8, float8);
-extern float16 __attribute__((overloadable)) fmod(float16, float16);
-
-extern float __attribute__((overloadable)) fract(float, float *);
-extern float2 __attribute__((overloadable)) fract(float2, float2 *);
-extern float3 __attribute__((overloadable)) fract(float3, float3 *);
-extern float4 __attribute__((overloadable)) fract(float4, float4 *);
-extern float8 __attribute__((overloadable)) fract(float8, float8 *);
-extern float16 __attribute__((overloadable)) fract(float16, float16 *);
-
-extern float __attribute__((overloadable)) frexp(float, float *);
-extern float2 __attribute__((overloadable)) frexp(float2, float2 *);
-extern float3 __attribute__((overloadable)) frexp(float3, float3 *);
-extern float4 __attribute__((overloadable)) frexp(float4, float4 *);
-extern float8 __attribute__((overloadable)) frexp(float8, float8 *);
-extern float16 __attribute__((overloadable)) frexp(float16, float16 *);
-
-extern float __attribute__((overloadable)) hypot(float, float);
-extern float2 __attribute__((overloadable)) hypot(float2, float2);
-extern float3 __attribute__((overloadable)) hypot(float3, float3);
-extern float4 __attribute__((overloadable)) hypot(float4, float4);
-extern float8 __attribute__((overloadable)) hypot(float8, float8);
-extern float16 __attribute__((overloadable)) hypot(float16, float16);
-
-extern int __attribute__((overloadable)) ilogb(float);
-extern int2 __attribute__((overloadable)) ilogb(float2);
-extern int3 __attribute__((overloadable)) ilogb(float3);
-extern int4 __attribute__((overloadable)) ilogb(float4);
-extern int8 __attribute__((overloadable)) ilogb(float8);
-extern int16 __attribute__((overloadable)) ilogb(float16);
-
-extern float __attribute__((overloadable)) ldexp(float, int);
-extern float2 __attribute__((overloadable)) ldexp(float2, int2);
-extern float3 __attribute__((overloadable)) ldexp(float3, int3);
-extern float4 __attribute__((overloadable)) ldexp(float4, int4);
-extern float8 __attribute__((overloadable)) ldexp(float8, int8);
-extern float16 __attribute__((overloadable)) ldexp(float16, int16);
-extern float2 __attribute__((overloadable)) ldexp(float2, int);
-extern float3 __attribute__((overloadable)) ldexp(float3, int);
-extern float4 __attribute__((overloadable)) ldexp(float4, int);
-extern float8 __attribute__((overloadable)) ldexp(float8, int);
-extern float16 __attribute__((overloadable)) ldexp(float16, int);
-
-extern float __attribute__((overloadable)) lgamma(float);
-extern float2 __attribute__((overloadable)) lgamma(float2);
-extern float3 __attribute__((overloadable)) lgamma(float3);
-extern float4 __attribute__((overloadable)) lgamma(float4);
-extern float8 __attribute__((overloadable)) lgamma(float8);
-extern float16 __attribute__((overloadable)) lgamma(float16);
-extern float __attribute__((overloadable)) lgamma(float, float *);
-extern float2 __attribute__((overloadable)) lgamma(float2, float2 *);
-extern float3 __attribute__((overloadable)) lgamma(float3, float3 *);
-extern float4 __attribute__((overloadable)) lgamma(float4, float4 *);
-extern float8 __attribute__((overloadable)) lgamma(float8, float8 *);
-extern float16 __attribute__((overloadable)) lgamma(float16, float16 *);
-
-extern float __attribute__((overloadable)) log(float);
-extern float2 __attribute__((overloadable)) log(float2);
-extern float3 __attribute__((overloadable)) log(float3);
-extern float4 __attribute__((overloadable)) log(float4);
-extern float8 __attribute__((overloadable)) log(float8);
-extern float16 __attribute__((overloadable)) log(float16);
-
-extern float __attribute__((overloadable)) log2(float);
-extern float2 __attribute__((overloadable)) log2(float2);
-extern float3 __attribute__((overloadable)) log2(float3);
-extern float4 __attribute__((overloadable)) log2(float4);
-extern float8 __attribute__((overloadable)) log2(float8);
-extern float16 __attribute__((overloadable)) log2(float16);
-
-extern float __attribute__((overloadable)) log10(float);
-extern float2 __attribute__((overloadable)) log10(float2);
-extern float3 __attribute__((overloadable)) log10(float3);
-extern float4 __attribute__((overloadable)) log10(float4);
-extern float8 __attribute__((overloadable)) log10(float8);
-extern float16 __attribute__((overloadable)) log10(float16);
-
-extern float __attribute__((overloadable)) log1p(float);
-extern float2 __attribute__((overloadable)) log1p(float2);
-extern float3 __attribute__((overloadable)) log1p(float3);
-extern float4 __attribute__((overloadable)) log1p(float4);
-extern float8 __attribute__((overloadable)) log1p(float8);
-extern float16 __attribute__((overloadable)) log1p(float16);
-
-extern float __attribute__((overloadable)) logb(float);
-extern float2 __attribute__((overloadable)) logb(float2);
-extern float3 __attribute__((overloadable)) logb(float3);
-extern float4 __attribute__((overloadable)) logb(float4);
-extern float8 __attribute__((overloadable)) logb(float8);
-extern float16 __attribute__((overloadable)) logb(float16);
-
-extern float __attribute__((overloadable)) mad(float, float, float);
-extern float2 __attribute__((overloadable)) mad(float2, float2, float2);
-extern float3 __attribute__((overloadable)) mad(float3, float3, float3);
-extern float4 __attribute__((overloadable)) mad(float4, float4, float4);
-extern float8 __attribute__((overloadable)) mad(float8, float8, float8);
-extern float16 __attribute__((overloadable)) mad(float16, float16, float16);
-
-extern float __attribute__((overloadable)) modf(float, float *);
-extern float2 __attribute__((overloadable)) modf(float2, float2 *);
-extern float3 __attribute__((overloadable)) modf(float3, float3 *);
-extern float4 __attribute__((overloadable)) modf(float4, float4 *);
-extern float8 __attribute__((overloadable)) modf(float8, float8 *);
-extern float16 __attribute__((overloadable)) modf(float16, float16 *);
-
-extern float __attribute__((overloadable)) nan(uint);
-extern float2 __attribute__((overloadable)) nan(uint2);
-extern float3 __attribute__((overloadable)) nan(uint3);
-extern float4 __attribute__((overloadable)) nan(uint4);
-extern float8 __attribute__((overloadable)) nan(uint8);
-extern float16 __attribute__((overloadable)) nan(uint16);
-
-extern float __attribute__((overloadable)) nextafter(float, float);
-extern float2 __attribute__((overloadable)) nextafter(float2, float2);
-extern float3 __attribute__((overloadable)) nextafter(float3, float3);
-extern float4 __attribute__((overloadable)) nextafter(float4, float4);
-extern float8 __attribute__((overloadable)) nextafter(float8, float8);
-extern float16 __attribute__((overloadable)) nextafter(float16, float16);
-
-extern float __attribute__((overloadable)) pow(float, float);
-extern float2 __attribute__((overloadable)) pow(float2, float2);
-extern float3 __attribute__((overloadable)) pow(float3, float3);
-extern float4 __attribute__((overloadable)) pow(float4, float4);
-extern float8 __attribute__((overloadable)) pow(float8, float8);
-extern float16 __attribute__((overloadable)) pow(float16, float16);
-
-extern float __attribute__((overloadable)) pown(float, int);
-extern float2 __attribute__((overloadable)) pown(float2, int2);
-extern float3 __attribute__((overloadable)) pown(float3, int3);
-extern float4 __attribute__((overloadable)) pown(float4, int4);
-extern float8 __attribute__((overloadable)) pown(float8, int8);
-extern float16 __attribute__((overloadable)) pown(float16, int16);
-
-extern float __attribute__((overloadable)) powr(float, float);
-extern float2 __attribute__((overloadable)) powr(float2, float2);
-extern float3 __attribute__((overloadable)) powr(float3, float3);
-extern float4 __attribute__((overloadable)) powr(float4, float4);
-extern float8 __attribute__((overloadable)) powr(float8, float8);
-extern float16 __attribute__((overloadable)) powr(float16, float16);
-
-extern float __attribute__((overloadable)) remainder(float, float);
-extern float2 __attribute__((overloadable)) remainder(float2, float2);
-extern float3 __attribute__((overloadable)) remainder(float3, float3);
-extern float4 __attribute__((overloadable)) remainder(float4, float4);
-extern float8 __attribute__((overloadable)) remainder(float8, float8);
-extern float16 __attribute__((overloadable)) remainder(float16, float16);
-
-extern float __attribute__((overloadable)) remquo(float, float, float *);
-extern float2 __attribute__((overloadable)) remquo(float2, float2, float2 *);
-extern float3 __attribute__((overloadable)) remquo(float3, float3, float3 *);
-extern float4 __attribute__((overloadable)) remquo(float4, float4, float4 *);
-extern float8 __attribute__((overloadable)) remquo(float8, float8, float8 *);
-extern float16 __attribute__((overloadable)) remquo(float16, float16, float16 *);
-
-extern float __attribute__((overloadable)) rint(float);
-extern float2 __attribute__((overloadable)) rint(float2);
-extern float3 __attribute__((overloadable)) rint(float3);
-extern float4 __attribute__((overloadable)) rint(float4);
-extern float8 __attribute__((overloadable)) rint(float8);
-extern float16 __attribute__((overloadable)) rint(float16);
-
-extern float __attribute__((overloadable)) rootn(float, int);
-extern float2 __attribute__((overloadable)) rootn(float2, int2);
-extern float3 __attribute__((overloadable)) rootn(float3, int3);
-extern float4 __attribute__((overloadable)) rootn(float4, int4);
-extern float8 __attribute__((overloadable)) rootn(float8, int8);
-extern float16 __attribute__((overloadable)) rootn(float16, int16);
-
-extern float __attribute__((overloadable)) round(float);
-extern float2 __attribute__((overloadable)) round(float2);
-extern float3 __attribute__((overloadable)) round(float3);
-extern float4 __attribute__((overloadable)) round(float4);
-extern float8 __attribute__((overloadable)) round(float8);
-extern float16 __attribute__((overloadable)) round(float16);
-
-extern float __attribute__((overloadable)) rsqrt(float);
-extern float2 __attribute__((overloadable)) rsqrt(float2);
-extern float3 __attribute__((overloadable)) rsqrt(float3);
-extern float4 __attribute__((overloadable)) rsqrt(float4);
-extern float8 __attribute__((overloadable)) rsqrt(float8);
-extern float16 __attribute__((overloadable)) rsqrt(float16);
-
-extern float __attribute__((overloadable)) sin(float);
-extern float2 __attribute__((overloadable)) sin(float2);
-extern float3 __attribute__((overloadable)) sin(float3);
-extern float4 __attribute__((overloadable)) sin(float4);
-extern float8 __attribute__((overloadable)) sin(float8);
-extern float16 __attribute__((overloadable)) sin(float16);
-
-extern float __attribute__((overloadable)) sincos(float, float *);
-extern float2 __attribute__((overloadable)) sincos(float2, float2 *);
-extern float3 __attribute__((overloadable)) sincos(float3, float3 *);
-extern float4 __attribute__((overloadable)) sincos(float4, float4 *);
-extern float8 __attribute__((overloadable)) sincos(float8, float8 *);
-extern float16 __attribute__((overloadable)) sincos(float16, float16 *);
-
-extern float __attribute__((overloadable)) sinh(float);
-extern float2 __attribute__((overloadable)) sinh(float2);
-extern float3 __attribute__((overloadable)) sinh(float3);
-extern float4 __attribute__((overloadable)) sinh(float4);
-extern float8 __attribute__((overloadable)) sinh(float8);
-extern float16 __attribute__((overloadable)) sinh(float16);
-
-extern float __attribute__((overloadable)) sinpi(float);
-extern float2 __attribute__((overloadable)) sinpi(float2);
-extern float3 __attribute__((overloadable)) sinpi(float3);
-extern float4 __attribute__((overloadable)) sinpi(float4);
-extern float8 __attribute__((overloadable)) sinpi(float8);
-extern float16 __attribute__((overloadable)) sinpi(float16);
-
-extern float __attribute__((overloadable)) sqrt(float);
-extern float2 __attribute__((overloadable)) sqrt(float2);
-extern float3 __attribute__((overloadable)) sqrt(float3);
-extern float4 __attribute__((overloadable)) sqrt(float4);
-extern float8 __attribute__((overloadable)) sqrt(float8);
-extern float16 __attribute__((overloadable)) sqrt(float16);
-
-extern float __attribute__((overloadable)) tan(float);
-extern float2 __attribute__((overloadable)) tan(float2);
-extern float3 __attribute__((overloadable)) tan(float3);
-extern float4 __attribute__((overloadable)) tan(float4);
-extern float8 __attribute__((overloadable)) tan(float8);
-extern float16 __attribute__((overloadable)) tan(float16);
-
-extern float __attribute__((overloadable)) tanh(float);
-extern float2 __attribute__((overloadable)) tanh(float2);
-extern float3 __attribute__((overloadable)) tanh(float3);
-extern float4 __attribute__((overloadable)) tanh(float4);
-extern float8 __attribute__((overloadable)) tanh(float8);
-extern float16 __attribute__((overloadable)) tanh(float16);
-
-extern float __attribute__((overloadable)) tanpi(float);
-extern float2 __attribute__((overloadable)) tanpi(float2);
-extern float3 __attribute__((overloadable)) tanpi(float3);
-extern float4 __attribute__((overloadable)) tanpi(float4);
-extern float8 __attribute__((overloadable)) tanpi(float8);
-extern float16 __attribute__((overloadable)) tanpi(float16);
-
-extern float __attribute__((overloadable)) tgamma(float);
-extern float2 __attribute__((overloadable)) tgamma(float2);
-extern float3 __attribute__((overloadable)) tgamma(float3);
-extern float4 __attribute__((overloadable)) tgamma(float4);
-extern float8 __attribute__((overloadable)) tgamma(float8);
-extern float16 __attribute__((overloadable)) tgamma(float16);
-
-extern float __attribute__((overloadable)) trunc(float);
-extern float2 __attribute__((overloadable)) trunc(float2);
-extern float3 __attribute__((overloadable)) trunc(float3);
-extern float4 __attribute__((overloadable)) trunc(float4);
-extern float8 __attribute__((overloadable)) trunc(float8);
-extern float16 __attribute__((overloadable)) trunc(float16);
-
-
-
-
-
-
-// Int ops (partial), 6.11.3
-extern uint __attribute__((overloadable)) abs(int);
-extern ushort __attribute__((overloadable)) abs(short);
-extern uchar __attribute__((overloadable)) abs(char);
-
-extern uint __attribute__((overloadable)) clz(uint);
-extern int __attribute__((overloadable)) clz(int);
-extern ushort __attribute__((overloadable)) clz(ushort);
-extern short __attribute__((overloadable)) clz(short);
-extern uchar __attribute__((overloadable)) clz(uchar);
-extern char __attribute__((overloadable)) clz(char);
-
-extern uint __attribute__((overloadable)) min(uint);
-extern int __attribute__((overloadable)) min(int);
-extern ushort __attribute__((overloadable)) min(ushort);
-extern short __attribute__((overloadable)) min(short);
-extern uchar __attribute__((overloadable)) min(uchar);
-extern char __attribute__((overloadable)) min(char);
-
-extern uint __attribute__((overloadable)) max(uint);
-extern int __attribute__((overloadable)) max(int);
-extern ushort __attribute__((overloadable)) max(ushort);
-extern short __attribute__((overloadable)) max(short);
-extern uchar __attribute__((overloadable)) max(uchar);
-extern char __attribute__((overloadable)) max(char);
-
-
-
-
-// 6.11.4
-
-extern float __attribute__((overloadable)) clamp(float, float, float);
-extern float2 __attribute__((overloadable)) clamp(float2, float2, float2);
-extern float3 __attribute__((overloadable)) clamp(float3, float3, float3);
-extern float4 __attribute__((overloadable)) clamp(float4, float4, float4);
-extern float8 __attribute__((overloadable)) clamp(float8, float8, float8);
-extern float16 __attribute__((overloadable)) clamp(float16, float16, float16);
-extern float2 __attribute__((overloadable)) clamp(float2, float, float);
-extern float3 __attribute__((overloadable)) clamp(float3, float, float);
-extern float4 __attribute__((overloadable)) clamp(float4, float, float);
-extern float8 __attribute__((overloadable)) clamp(float8, float, float);
-extern float16 __attribute__((overloadable)) clamp(float16, float, float);
-
-extern float __attribute__((overloadable)) degrees(float);
-extern float2 __attribute__((overloadable)) degrees(float2);
-extern float3 __attribute__((overloadable)) degrees(float3);
-extern float4 __attribute__((overloadable)) degrees(float4);
-extern float8 __attribute__((overloadable)) degrees(float8);
-extern float16 __attribute__((overloadable)) degrees(float16);
-
-extern float __attribute__((overloadable)) max(float, float);
-extern float2 __attribute__((overloadable)) max(float2, float2);
-extern float3 __attribute__((overloadable)) max(float3, float3);
-extern float4 __attribute__((overloadable)) max(float4, float4);
-extern float8 __attribute__((overloadable)) max(float8, float8);
-extern float16 __attribute__((overloadable)) max(float16, float16);
-extern float2 __attribute__((overloadable)) max(float2, float);
-extern float3 __attribute__((overloadable)) max(float3, float);
-extern float4 __attribute__((overloadable)) max(float4, float);
-extern float8 __attribute__((overloadable)) max(float8, float);
-extern float16 __attribute__((overloadable)) max(float16, float);
-
-extern float __attribute__((overloadable)) min(float, float);
-extern float2 __attribute__((overloadable)) min(float2, float2);
-extern float3 __attribute__((overloadable)) min(float3, float3);
-extern float4 __attribute__((overloadable)) min(float4, float4);
-extern float8 __attribute__((overloadable)) min(float8, float8);
-extern float16 __attribute__((overloadable)) min(float16, float16);
-extern float2 __attribute__((overloadable)) min(float2, float);
-extern float3 __attribute__((overloadable)) min(float3, float);
-extern float4 __attribute__((overloadable)) min(float4, float);
-extern float8 __attribute__((overloadable)) min(float8, float);
-extern float16 __attribute__((overloadable)) min(float16, float);
-
-extern float __attribute__((overloadable)) mix(float, float, float);
-extern float2 __attribute__((overloadable)) mix(float2, float2, float2);
-extern float3 __attribute__((overloadable)) mix(float3, float3, float3);
-extern float4 __attribute__((overloadable)) mix(float4, float4, float4);
-extern float8 __attribute__((overloadable)) mix(float8, float8, float8);
-extern float16 __attribute__((overloadable)) mix(float16, float16, float16);
-extern float2 __attribute__((overloadable)) mix(float2, float2, float);
-extern float3 __attribute__((overloadable)) mix(float3, float3, float);
-extern float4 __attribute__((overloadable)) mix(float4, float4, float);
-extern float8 __attribute__((overloadable)) mix(float8, float8, float);
-extern float16 __attribute__((overloadable)) mix(float16, float16, float);
-
-extern float __attribute__((overloadable)) radians(float);
-extern float2 __attribute__((overloadable)) radians(float2);
-extern float3 __attribute__((overloadable)) radians(float3);
-extern float4 __attribute__((overloadable)) radians(float4);
-extern float8 __attribute__((overloadable)) radians(float8);
-extern float16 __attribute__((overloadable)) radians(float16);
-
-extern float __attribute__((overloadable)) step(float, float);
-extern float2 __attribute__((overloadable)) step(float2, float2);
-extern float3 __attribute__((overloadable)) step(float3, float3);
-extern float4 __attribute__((overloadable)) step(float4, float4);
-extern float8 __attribute__((overloadable)) step(float8, float8);
-extern float16 __attribute__((overloadable)) step(float16, float16);
-extern float2 __attribute__((overloadable)) step(float, float2);
-extern float3 __attribute__((overloadable)) step(float, float3);
-extern float4 __attribute__((overloadable)) step(float, float4);
-extern float8 __attribute__((overloadable)) step(float, float8);
-extern float16 __attribute__((overloadable)) step(float, float16);
-
-extern float __attribute__((overloadable)) smoothstep(float, float, float);
-extern float2 __attribute__((overloadable)) smoothstep(float2, float2, float2);
-extern float3 __attribute__((overloadable)) smoothstep(float3, float3, float3);
-extern float4 __attribute__((overloadable)) smoothstep(float4, float4, float4);
-extern float8 __attribute__((overloadable)) smoothstep(float8, float8, float8);
-extern float16 __attribute__((overloadable)) smoothstep(float16, float16, float16);
-extern float2 __attribute__((overloadable)) smoothstep(float, float, float2);
-extern float3 __attribute__((overloadable)) smoothstep(float, float, float3);
-extern float4 __attribute__((overloadable)) smoothstep(float, float, float4);
-extern float8 __attribute__((overloadable)) smoothstep(float, float, float8);
-extern float16 __attribute__((overloadable)) smoothstep(float, float, float16);
-
-extern float __attribute__((overloadable)) sign(float);
-extern float2 __attribute__((overloadable)) sign(float2);
-extern float3 __attribute__((overloadable)) sign(float3);
-extern float4 __attribute__((overloadable)) sign(float4);
-extern float8 __attribute__((overloadable)) sign(float8);
-extern float16 __attribute__((overloadable)) sign(float16);
-
-// 6.11.5
-extern float3 __attribute__((overloadable)) cross(float2, float2);
-extern float3 __attribute__((overloadable)) cross(float3, float3);
-extern float4 __attribute__((overloadable)) cross(float4, float4);
-
-extern float __attribute__((overloadable)) dot(float, float);
-extern float __attribute__((overloadable)) dot(float2, float2);
-extern float __attribute__((overloadable)) dot(float3, float3);
-extern float __attribute__((overloadable)) dot(float4, float4);
-
-extern float __attribute__((overloadable)) distance(float, float);
-extern float __attribute__((overloadable)) distance(float2, float2);
-extern float __attribute__((overloadable)) distance(float3, float3);
-extern float __attribute__((overloadable)) distance(float4, float4);
-
-extern float __attribute__((overloadable)) length(float);
-extern float __attribute__((overloadable)) length(float2);
-extern float __attribute__((overloadable)) length(float3);
-extern float __attribute__((overloadable)) length(float4);
-
-extern float __attribute__((overloadable)) normalize(float);
-extern float2 __attribute__((overloadable)) normalize(float2);
-extern float3 __attribute__((overloadable)) normalize(float3);
-extern float4 __attribute__((overloadable)) normalize(float4);
-
-
-// RS specific functions
-extern float randf(float);
-extern float randf2(float, float);
-extern float mapf(float, float, float, float, float);
-
-extern float __attribute__((overloadable)) frac(float);
-
-extern void debugP(int, void *);
-extern void debugPi(int, int);
-extern void debugPf(int, float);
-extern void debugF(const char *, float);
-extern void debugI32(const char *, int);
-extern void debugHexI32(const char *, int);
-
-extern void matrixLoadIdentity(void *mat);
-extern void matrixLoadFloat(void *mat, const float *f);
-extern void matrixLoadMat(void *mat, const void *newmat);
-extern void matrixLoadRotate(void *mat, float rot, float x, float y, float z);
-extern void matrixLoadScale(void *mat, float x, float y, float z);
-extern void matrixLoadTranslate(void *mat, float x, float y, float z);
-extern void matrixLoadMultiply(void *mat, const void *lhs, const void *rhs);
-extern void matrixMultiply(void *mat, const void *rhs);
-extern void matrixRotate(void *mat, float rot, float x, float y, float z);
-extern void matrixScale(void *mat, float x, float y, float z);
-extern void matrixTranslate(void *mat, float x, float y, float z);
-
+// Allocations
 extern rs_allocation rsGetAllocation(const void *);
+extern uint32_t rsAllocationGetDimX(rs_allocation);
+extern uint32_t rsAllocationGetDimY(rs_allocation);
+extern uint32_t rsAllocationGetDimZ(rs_allocation);
+extern uint32_t rsAllocationGetDimLOD(rs_allocation);
+extern uint32_t rsAllocationGetDimFaces(rs_allocation);
+
+
+
+// Color conversion
+extern uchar4 __attribute__((overloadable)) rsPackColorTo8888(float r, float g, float b);
+extern uchar4 __attribute__((overloadable)) rsPackColorTo8888(float r, float g, float b, float a);
+extern uchar4 __attribute__((overloadable)) rsPackColorTo8888(float3);
+extern uchar4 __attribute__((overloadable)) rsPackColorTo8888(float4);
+extern float4 rsUnpackColor8888(uchar4);
+
+extern uchar4 __attribute__((overloadable)) rsPackColorTo565(float r, float g, float b);
+extern uchar4 __attribute__((overloadable)) rsPackColorTo565(float3);
+extern float4 rsUnpackColor565(uchar4);
+
+
+// Debugging
+extern void __attribute__((overloadable))rsDebug(const char *, float);
+extern void __attribute__((overloadable))rsDebug(const char *, float2);
+extern void __attribute__((overloadable))rsDebug(const char *, float3);
+extern void __attribute__((overloadable))rsDebug(const char *, float4);
+extern void __attribute__((overloadable))rsDebug(const char *, int);
+extern void __attribute__((overloadable))rsDebug(const char *, const void *);
+#define RS_DEBUG(a) rsDebug(#a, a)
+#define RS_DEBUG_MARKER rsDebug(__FILE__, __LINE__)
+
+// RS Math
+extern int __attribute__((overloadable)) rsRand(int);
+extern int __attribute__((overloadable)) rsRand(int, int);
+extern float __attribute__((overloadable)) rsRand(float);
+extern float __attribute__((overloadable)) rsRand(float, float);
+
+extern float __attribute__((overloadable)) rsFrac(float);
+
+// time
+extern int32_t rsSecond();
+extern int32_t rsMinute();
+extern int32_t rsHour();
+extern int32_t rsDay();
+extern int32_t rsMonth();
+extern int32_t rsYear();
+extern int64_t rsUptimeMillis();
+extern int64_t rsStartTimeMillis();
+extern int64_t rsElapsedTimeMillis();
+
+extern int rsSendToClient(void *data, int cmdID, int len, int waitForSpace);
+
+extern void rsMatrixLoadIdentity(rs_matrix4x4 *mat);
+extern void rsMatrixLoadFloat(rs_matrix4x4 *mat, const float *f);
+extern void rsMatrixLoadMat(rs_matrix4x4 *mat, const rs_matrix4x4 *newmat);
+extern void rsMatrixLoadRotate(rs_matrix4x4 *mat, float rot, float x, float y, float z);
+extern void rsMatrixLoadScale(rs_matrix4x4*mat, float x, float y, float z);
+extern void rsMatrixLoadTranslate(rs_matrix4x4 *mat, float x, float y, float z);
+extern void rsMatrixLoadMultiply(rs_matrix4x4 *mat, const rs_matrix4x4 *lhs, const rs_matrix4x4 *rhs);
+extern void rsMatrixMultiply(rs_matrix4x4 *mat, const rs_matrix4x4 *rhs);
+extern void rsMatrixRotate(rs_matrix4x4 *mat, float rot, float x, float y, float z);
+extern void rsMatrixScale(rs_matrix4x4 *mat, float x, float y, float z);
+extern void rsMatrixTranslate(rs_matrix4x4 *mat, float x, float y, float z);
+
+
+///////////////////////////////////////////////////////////////////
+// non update funcs
+
+extern float turbulencef2(float x, float y, float octaves);
+extern float turbulencef3(float x, float y, float z, float octaves);
+
+/*
+extern float3 float3Norm(float3);
+extern float float3Length(float3);
+extern float3 float3Add(float3 lhs, float3 rhs);
+extern float3 float3Sub(float3 lhs, float3 rhs);
+extern float3 float3Cross(float3 lhs, float3 rhs);
+extern float float3Dot(float3 lhs, float3 rhs);
+extern float3 float3Scale(float3 v, float scale);
+
+extern float4 float4Add(float4 lhs, float4 rhs);
+extern float4 float4Sub(float4 lhs, float4 rhs);
+extern float4 float4Cross(float4 lhs, float4 rhs);
+extern float float4Dot(float4 lhs, float4 rhs);
+extern float4 float4Scale(float4 v, float scale);
+*/
+
 
diff --git a/libs/rs/scriptc/rs_types.rsh b/libs/rs/scriptc/rs_types.rsh
index b710146..185bb83 100644
--- a/libs/rs/scriptc/rs_types.rsh
+++ b/libs/rs/scriptc/rs_types.rsh
@@ -2,17 +2,17 @@
 typedef char int8_t;
 typedef short int16_t;
 typedef int int32_t;
-//typedef long int64_t;
+typedef long long int64_t;
 
 typedef unsigned char uint8_t;
 typedef unsigned short uint16_t;
 typedef unsigned int uint32_t;
-//typedef long uint64_t;
+typedef unsigned long long uint64_t;
 
 typedef uint8_t uchar;
 typedef uint16_t ushort;
 typedef uint32_t uint;
-//typedef uint64_t ulong;
+typedef uint64_t ulong;
 
 typedef int rs_element;
 typedef int rs_type;
@@ -94,3 +94,7 @@
 // RS_KIND_INDEX
 typedef ushort rs_index;
 
+typedef struct {
+    float m[16];
+} rs_matrix4x4;
+