Restore missing min and max API.

min(float2/3/4, float) and max(float2/3/4, float) were defined in our
headers in K.  In L, they were removed by mistake.  This continued to
work however because a float would be auto converted by the compiler to
a float4.

In M, we started validating for unexpected external references, which
_Z3minDv4_ff is.  This can prevent programs compiled with K from running
on M.

This CL adds the missing APIs to the tests.

Bug:23389429

Change-Id: Idfece91a9e3ca6a53ac2e40e35f5d539c12b699a
(cherry picked from commit 617d0d964299920793f5d0ab47ad3a08d3e464d0)

1 files changed, 733 insertions, 709 deletions

diff --git a/tests/P_all_api_20/all20.rs b/tests/P_all_api_20/all20.rs
index afe8577..66aa856 100644
--- a/tests/P_all_api_20/all20.rs
+++ b/tests/P_all_api_20/all20.rs
@@ -3407,6 +3407,24 @@ char buf3381[200];
 char buf3382[200];
 char buf3383[200];
 char buf3384[200];
+char buf3385[200];
+char buf3386[200];
+char buf3387[200];
+char buf3388[200];
+char buf3389[200];
+char buf3390[200];
+char buf3391[200];
+char buf3392[200];
+char buf3393[200];
+char buf3394[200];
+char buf3395[200];
+char buf3396[200];
+char buf3397[200];
+char buf3398[200];
+char buf3399[200];
+char buf3400[200];
+char buf3401[200];
+char buf3402[200];
 
 void RS_KERNEL test(int in) {
     *(uchar*)buf0 = abs(*(char*)buf1);
@@ -3886,833 +3904,839 @@ void RS_KERNEL test(int in) {
     *(float2*)buf1162 = max(*(float2*)buf1163, *(float2*)buf1164);
     *(float3*)buf1165 = max(*(float3*)buf1166, *(float3*)buf1167);
     *(float4*)buf1168 = max(*(float4*)buf1169, *(float4*)buf1170);
-    *(char*)buf1171 = max(*(char*)buf1172, *(char*)buf1173);
-    *(uchar*)buf1174 = max(*(uchar*)buf1175, *(uchar*)buf1176);
-    *(short*)buf1177 = max(*(short*)buf1178, *(short*)buf1179);
-    *(ushort*)buf1180 = max(*(ushort*)buf1181, *(ushort*)buf1182);
-    *(int*)buf1183 = max(*(int*)buf1184, *(int*)buf1185);
-    *(uint*)buf1186 = max(*(uint*)buf1187, *(uint*)buf1188);
-    *(char2*)buf1189 = max(*(char2*)buf1190, *(char2*)buf1191);
-    *(uchar2*)buf1192 = max(*(uchar2*)buf1193, *(uchar2*)buf1194);
-    *(short2*)buf1195 = max(*(short2*)buf1196, *(short2*)buf1197);
-    *(ushort2*)buf1198 = max(*(ushort2*)buf1199, *(ushort2*)buf1200);
-    *(int2*)buf1201 = max(*(int2*)buf1202, *(int2*)buf1203);
-    *(uint2*)buf1204 = max(*(uint2*)buf1205, *(uint2*)buf1206);
-    *(char3*)buf1207 = max(*(char3*)buf1208, *(char3*)buf1209);
-    *(uchar3*)buf1210 = max(*(uchar3*)buf1211, *(uchar3*)buf1212);
-    *(short3*)buf1213 = max(*(short3*)buf1214, *(short3*)buf1215);
-    *(ushort3*)buf1216 = max(*(ushort3*)buf1217, *(ushort3*)buf1218);
-    *(int3*)buf1219 = max(*(int3*)buf1220, *(int3*)buf1221);
-    *(uint3*)buf1222 = max(*(uint3*)buf1223, *(uint3*)buf1224);
-    *(char4*)buf1225 = max(*(char4*)buf1226, *(char4*)buf1227);
-    *(uchar4*)buf1228 = max(*(uchar4*)buf1229, *(uchar4*)buf1230);
-    *(short4*)buf1231 = max(*(short4*)buf1232, *(short4*)buf1233);
-    *(ushort4*)buf1234 = max(*(ushort4*)buf1235, *(ushort4*)buf1236);
-    *(int4*)buf1237 = max(*(int4*)buf1238, *(int4*)buf1239);
-    *(uint4*)buf1240 = max(*(uint4*)buf1241, *(uint4*)buf1242);
-    *(float*)buf1243 = min(*(float*)buf1244, *(float*)buf1245);
-    *(float2*)buf1246 = min(*(float2*)buf1247, *(float2*)buf1248);
-    *(float3*)buf1249 = min(*(float3*)buf1250, *(float3*)buf1251);
-    *(float4*)buf1252 = min(*(float4*)buf1253, *(float4*)buf1254);
-    *(char*)buf1255 = min(*(char*)buf1256, *(char*)buf1257);
-    *(uchar*)buf1258 = min(*(uchar*)buf1259, *(uchar*)buf1260);
-    *(short*)buf1261 = min(*(short*)buf1262, *(short*)buf1263);
-    *(ushort*)buf1264 = min(*(ushort*)buf1265, *(ushort*)buf1266);
-    *(int*)buf1267 = min(*(int*)buf1268, *(int*)buf1269);
-    *(uint*)buf1270 = min(*(uint*)buf1271, *(uint*)buf1272);
-    *(char2*)buf1273 = min(*(char2*)buf1274, *(char2*)buf1275);
-    *(uchar2*)buf1276 = min(*(uchar2*)buf1277, *(uchar2*)buf1278);
-    *(short2*)buf1279 = min(*(short2*)buf1280, *(short2*)buf1281);
-    *(ushort2*)buf1282 = min(*(ushort2*)buf1283, *(ushort2*)buf1284);
-    *(int2*)buf1285 = min(*(int2*)buf1286, *(int2*)buf1287);
-    *(uint2*)buf1288 = min(*(uint2*)buf1289, *(uint2*)buf1290);
-    *(char3*)buf1291 = min(*(char3*)buf1292, *(char3*)buf1293);
-    *(uchar3*)buf1294 = min(*(uchar3*)buf1295, *(uchar3*)buf1296);
-    *(short3*)buf1297 = min(*(short3*)buf1298, *(short3*)buf1299);
-    *(ushort3*)buf1300 = min(*(ushort3*)buf1301, *(ushort3*)buf1302);
-    *(int3*)buf1303 = min(*(int3*)buf1304, *(int3*)buf1305);
-    *(uint3*)buf1306 = min(*(uint3*)buf1307, *(uint3*)buf1308);
-    *(char4*)buf1309 = min(*(char4*)buf1310, *(char4*)buf1311);
-    *(uchar4*)buf1312 = min(*(uchar4*)buf1313, *(uchar4*)buf1314);
-    *(short4*)buf1315 = min(*(short4*)buf1316, *(short4*)buf1317);
-    *(ushort4*)buf1318 = min(*(ushort4*)buf1319, *(ushort4*)buf1320);
-    *(int4*)buf1321 = min(*(int4*)buf1322, *(int4*)buf1323);
-    *(uint4*)buf1324 = min(*(uint4*)buf1325, *(uint4*)buf1326);
-    *(float*)buf1327 = mix(*(float*)buf1328, *(float*)buf1329, *(float*)buf1330);
-    *(float2*)buf1331 = mix(*(float2*)buf1332, *(float2*)buf1333, *(float2*)buf1334);
-    *(float3*)buf1335 = mix(*(float3*)buf1336, *(float3*)buf1337, *(float3*)buf1338);
-    *(float4*)buf1339 = mix(*(float4*)buf1340, *(float4*)buf1341, *(float4*)buf1342);
-    *(float2*)buf1343 = mix(*(float2*)buf1344, *(float2*)buf1345, *(float*)buf1346);
-    *(float3*)buf1347 = mix(*(float3*)buf1348, *(float3*)buf1349, *(float*)buf1350);
-    *(float4*)buf1351 = mix(*(float4*)buf1352, *(float4*)buf1353, *(float*)buf1354);
-    *(float*)buf1355 = modf(*(float*)buf1356, (float*) buf1357);
-    *(float2*)buf1358 = modf(*(float2*)buf1359, (float2*) buf1360);
-    *(float3*)buf1361 = modf(*(float3*)buf1362, (float3*) buf1363);
-    *(float4*)buf1364 = modf(*(float4*)buf1365, (float4*) buf1366);
-    *(float*)buf1367 = nan(*(uint*)buf1368);
-    *(float*)buf1369 = native_exp(*(float*)buf1370);
-    *(float2*)buf1371 = native_exp(*(float2*)buf1372);
-    *(float3*)buf1373 = native_exp(*(float3*)buf1374);
-    *(float4*)buf1375 = native_exp(*(float4*)buf1376);
-    *(float*)buf1377 = native_exp10(*(float*)buf1378);
-    *(float2*)buf1379 = native_exp10(*(float2*)buf1380);
-    *(float3*)buf1381 = native_exp10(*(float3*)buf1382);
-    *(float4*)buf1383 = native_exp10(*(float4*)buf1384);
-    *(float*)buf1385 = native_exp2(*(float*)buf1386);
-    *(float2*)buf1387 = native_exp2(*(float2*)buf1388);
-    *(float3*)buf1389 = native_exp2(*(float3*)buf1390);
-    *(float4*)buf1391 = native_exp2(*(float4*)buf1392);
-    *(float*)buf1393 = native_log(*(float*)buf1394);
-    *(float2*)buf1395 = native_log(*(float2*)buf1396);
-    *(float3*)buf1397 = native_log(*(float3*)buf1398);
-    *(float4*)buf1399 = native_log(*(float4*)buf1400);
-    *(float*)buf1401 = native_log10(*(float*)buf1402);
-    *(float2*)buf1403 = native_log10(*(float2*)buf1404);
-    *(float3*)buf1405 = native_log10(*(float3*)buf1406);
-    *(float4*)buf1407 = native_log10(*(float4*)buf1408);
-    *(float*)buf1409 = native_log2(*(float*)buf1410);
-    *(float2*)buf1411 = native_log2(*(float2*)buf1412);
-    *(float3*)buf1413 = native_log2(*(float3*)buf1414);
-    *(float4*)buf1415 = native_log2(*(float4*)buf1416);
-    *(float*)buf1417 = native_powr(*(float*)buf1418, *(float*)buf1419);
-    *(float2*)buf1420 = native_powr(*(float2*)buf1421, *(float2*)buf1422);
-    *(float3*)buf1423 = native_powr(*(float3*)buf1424, *(float3*)buf1425);
-    *(float4*)buf1426 = native_powr(*(float4*)buf1427, *(float4*)buf1428);
-    *(float*)buf1429 = nextafter(*(float*)buf1430, *(float*)buf1431);
-    *(float2*)buf1432 = nextafter(*(float2*)buf1433, *(float2*)buf1434);
-    *(float3*)buf1435 = nextafter(*(float3*)buf1436, *(float3*)buf1437);
-    *(float4*)buf1438 = nextafter(*(float4*)buf1439, *(float4*)buf1440);
-    *(float*)buf1441 = normalize(*(float*)buf1442);
-    *(float2*)buf1443 = normalize(*(float2*)buf1444);
-    *(float3*)buf1445 = normalize(*(float3*)buf1446);
-    *(float4*)buf1447 = normalize(*(float4*)buf1448);
-    *(float*)buf1449 = pow(*(float*)buf1450, *(float*)buf1451);
-    *(float2*)buf1452 = pow(*(float2*)buf1453, *(float2*)buf1454);
-    *(float3*)buf1455 = pow(*(float3*)buf1456, *(float3*)buf1457);
-    *(float4*)buf1458 = pow(*(float4*)buf1459, *(float4*)buf1460);
-    *(float*)buf1461 = pown(*(float*)buf1462, *(int*)buf1463);
-    *(float2*)buf1464 = pown(*(float2*)buf1465, *(int2*)buf1466);
-    *(float3*)buf1467 = pown(*(float3*)buf1468, *(int3*)buf1469);
-    *(float4*)buf1470 = pown(*(float4*)buf1471, *(int4*)buf1472);
-    *(float*)buf1473 = powr(*(float*)buf1474, *(float*)buf1475);
-    *(float2*)buf1476 = powr(*(float2*)buf1477, *(float2*)buf1478);
-    *(float3*)buf1479 = powr(*(float3*)buf1480, *(float3*)buf1481);
-    *(float4*)buf1482 = powr(*(float4*)buf1483, *(float4*)buf1484);
-    *(float*)buf1485 = radians(*(float*)buf1486);
-    *(float2*)buf1487 = radians(*(float2*)buf1488);
-    *(float3*)buf1489 = radians(*(float3*)buf1490);
-    *(float4*)buf1491 = radians(*(float4*)buf1492);
-    *(float*)buf1493 = remainder(*(float*)buf1494, *(float*)buf1495);
-    *(float2*)buf1496 = remainder(*(float2*)buf1497, *(float2*)buf1498);
-    *(float3*)buf1499 = remainder(*(float3*)buf1500, *(float3*)buf1501);
-    *(float4*)buf1502 = remainder(*(float4*)buf1503, *(float4*)buf1504);
-    *(float*)buf1505 = remquo(*(float*)buf1506, *(float*)buf1507, (int*) buf1508);
-    *(float2*)buf1509 = remquo(*(float2*)buf1510, *(float2*)buf1511, (int2*) buf1512);
-    *(float3*)buf1513 = remquo(*(float3*)buf1514, *(float3*)buf1515, (int3*) buf1516);
-    *(float4*)buf1517 = remquo(*(float4*)buf1518, *(float4*)buf1519, (int4*) buf1520);
-    *(float*)buf1521 = rint(*(float*)buf1522);
-    *(float2*)buf1523 = rint(*(float2*)buf1524);
-    *(float3*)buf1525 = rint(*(float3*)buf1526);
-    *(float4*)buf1527 = rint(*(float4*)buf1528);
-    *(float*)buf1529 = rootn(*(float*)buf1530, *(int*)buf1531);
-    *(float2*)buf1532 = rootn(*(float2*)buf1533, *(int2*)buf1534);
-    *(float3*)buf1535 = rootn(*(float3*)buf1536, *(int3*)buf1537);
-    *(float4*)buf1538 = rootn(*(float4*)buf1539, *(int4*)buf1540);
-    *(float*)buf1541 = round(*(float*)buf1542);
-    *(float2*)buf1543 = round(*(float2*)buf1544);
-    *(float3*)buf1545 = round(*(float3*)buf1546);
-    *(float4*)buf1547 = round(*(float4*)buf1548);
-    rsAllocationCopy1DRange(*(rs_allocation*)buf1549, *(uint32_t*)buf1550, *(uint32_t*)buf1551, *(uint32_t*)buf1552, *(rs_allocation*)buf1553, *(uint32_t*)buf1554, *(uint32_t*)buf1555);
-    rsAllocationCopy2DRange(*(rs_allocation*)buf1556, *(uint32_t*)buf1557, *(uint32_t*)buf1558, *(uint32_t*)buf1559, *(rs_allocation_cubemap_face*)buf1560, *(uint32_t*)buf1561, *(uint32_t*)buf1562, *(rs_allocation*)buf1563, *(uint32_t*)buf1564, *(uint32_t*)buf1565, *(uint32_t*)buf1566, *(rs_allocation_cubemap_face*)buf1567);
-    *(uint32_t*)buf1568 = rsAllocationGetDimFaces(*(rs_allocation*)buf1569);
-    *(uint32_t*)buf1570 = rsAllocationGetDimLOD(*(rs_allocation*)buf1571);
-    *(uint32_t*)buf1572 = rsAllocationGetDimX(*(rs_allocation*)buf1573);
-    *(uint32_t*)buf1574 = rsAllocationGetDimY(*(rs_allocation*)buf1575);
-    *(uint32_t*)buf1576 = rsAllocationGetDimZ(*(rs_allocation*)buf1577);
-    *(rs_element*)buf1578 = rsAllocationGetElement(*(rs_allocation*)buf1579);
-    rsAllocationIoReceive(*(rs_allocation*)buf1580);
-    rsAllocationIoSend(*(rs_allocation*)buf1581);
-    *(int32_t*)buf1582 = rsAtomicAdd((volatile int32_t*) buf1583, *(int32_t*)buf1584);
-    *(int32_t*)buf1585 = rsAtomicAdd((volatile uint32_t*) buf1586, *(uint32_t*)buf1587);
-    *(int32_t*)buf1588 = rsAtomicAnd((volatile int32_t*) buf1589, *(int32_t*)buf1590);
-    *(int32_t*)buf1591 = rsAtomicAnd((volatile uint32_t*) buf1592, *(uint32_t*)buf1593);
-    *(int32_t*)buf1594 = rsAtomicCas((volatile int32_t*) buf1595, *(int32_t*)buf1596, *(int32_t*)buf1597);
-    *(uint32_t*)buf1598 = rsAtomicCas((volatile uint32_t*) buf1599, *(uint32_t*)buf1600, *(uint32_t*)buf1601);
-    *(int32_t*)buf1602 = rsAtomicDec((volatile int32_t*) buf1603);
-    *(int32_t*)buf1604 = rsAtomicDec((volatile uint32_t*) buf1605);
-    *(int32_t*)buf1606 = rsAtomicInc((volatile int32_t*) buf1607);
-    *(int32_t*)buf1608 = rsAtomicInc((volatile uint32_t*) buf1609);
-    *(uint32_t*)buf1610 = rsAtomicMax((volatile uint32_t*) buf1611, *(uint32_t*)buf1612);
-    *(int32_t*)buf1613 = rsAtomicMax((volatile int32_t*) buf1614, *(int32_t*)buf1615);
-    *(uint32_t*)buf1616 = rsAtomicMin((volatile uint32_t*) buf1617, *(uint32_t*)buf1618);
-    *(int32_t*)buf1619 = rsAtomicMin((volatile int32_t*) buf1620, *(int32_t*)buf1621);
-    *(int32_t*)buf1622 = rsAtomicOr((volatile int32_t*) buf1623, *(int32_t*)buf1624);
-    *(int32_t*)buf1625 = rsAtomicOr((volatile uint32_t*) buf1626, *(uint32_t*)buf1627);
-    *(int32_t*)buf1628 = rsAtomicSub((volatile int32_t*) buf1629, *(int32_t*)buf1630);
-    *(int32_t*)buf1631 = rsAtomicSub((volatile uint32_t*) buf1632, *(uint32_t*)buf1633);
-    *(int32_t*)buf1634 = rsAtomicXor((volatile int32_t*) buf1635, *(int32_t*)buf1636);
-    *(int32_t*)buf1637 = rsAtomicXor((volatile uint32_t*) buf1638, *(uint32_t*)buf1639);
-    *(char*)buf1640 = rsClamp(*(char*)buf1641, *(char*)buf1642, *(char*)buf1643);
-    *(uchar*)buf1644 = rsClamp(*(uchar*)buf1645, *(uchar*)buf1646, *(uchar*)buf1647);
-    *(short*)buf1648 = rsClamp(*(short*)buf1649, *(short*)buf1650, *(short*)buf1651);
-    *(ushort*)buf1652 = rsClamp(*(ushort*)buf1653, *(ushort*)buf1654, *(ushort*)buf1655);
-    *(int*)buf1656 = rsClamp(*(int*)buf1657, *(int*)buf1658, *(int*)buf1659);
-    *(uint*)buf1660 = rsClamp(*(uint*)buf1661, *(uint*)buf1662, *(uint*)buf1663);
-    rsClearObject((rs_element*) buf1664);
-    rsClearObject((rs_type*) buf1665);
-    rsClearObject((rs_allocation*) buf1666);
-    rsClearObject((rs_sampler*) buf1667);
-    rsClearObject((rs_script*) buf1668);
+    *(float2*)buf1171 = max(*(float2*)buf1172, *(float*)buf1173);
+    *(float3*)buf1174 = max(*(float3*)buf1175, *(float*)buf1176);
+    *(float4*)buf1177 = max(*(float4*)buf1178, *(float*)buf1179);
+    *(char*)buf1180 = max(*(char*)buf1181, *(char*)buf1182);
+    *(uchar*)buf1183 = max(*(uchar*)buf1184, *(uchar*)buf1185);
+    *(short*)buf1186 = max(*(short*)buf1187, *(short*)buf1188);
+    *(ushort*)buf1189 = max(*(ushort*)buf1190, *(ushort*)buf1191);
+    *(int*)buf1192 = max(*(int*)buf1193, *(int*)buf1194);
+    *(uint*)buf1195 = max(*(uint*)buf1196, *(uint*)buf1197);
+    *(char2*)buf1198 = max(*(char2*)buf1199, *(char2*)buf1200);
+    *(uchar2*)buf1201 = max(*(uchar2*)buf1202, *(uchar2*)buf1203);
+    *(short2*)buf1204 = max(*(short2*)buf1205, *(short2*)buf1206);
+    *(ushort2*)buf1207 = max(*(ushort2*)buf1208, *(ushort2*)buf1209);
+    *(int2*)buf1210 = max(*(int2*)buf1211, *(int2*)buf1212);
+    *(uint2*)buf1213 = max(*(uint2*)buf1214, *(uint2*)buf1215);
+    *(char3*)buf1216 = max(*(char3*)buf1217, *(char3*)buf1218);
+    *(uchar3*)buf1219 = max(*(uchar3*)buf1220, *(uchar3*)buf1221);
+    *(short3*)buf1222 = max(*(short3*)buf1223, *(short3*)buf1224);
+    *(ushort3*)buf1225 = max(*(ushort3*)buf1226, *(ushort3*)buf1227);
+    *(int3*)buf1228 = max(*(int3*)buf1229, *(int3*)buf1230);
+    *(uint3*)buf1231 = max(*(uint3*)buf1232, *(uint3*)buf1233);
+    *(char4*)buf1234 = max(*(char4*)buf1235, *(char4*)buf1236);
+    *(uchar4*)buf1237 = max(*(uchar4*)buf1238, *(uchar4*)buf1239);
+    *(short4*)buf1240 = max(*(short4*)buf1241, *(short4*)buf1242);
+    *(ushort4*)buf1243 = max(*(ushort4*)buf1244, *(ushort4*)buf1245);
+    *(int4*)buf1246 = max(*(int4*)buf1247, *(int4*)buf1248);
+    *(uint4*)buf1249 = max(*(uint4*)buf1250, *(uint4*)buf1251);
+    *(float*)buf1252 = min(*(float*)buf1253, *(float*)buf1254);
+    *(float2*)buf1255 = min(*(float2*)buf1256, *(float2*)buf1257);
+    *(float3*)buf1258 = min(*(float3*)buf1259, *(float3*)buf1260);
+    *(float4*)buf1261 = min(*(float4*)buf1262, *(float4*)buf1263);
+    *(float2*)buf1264 = min(*(float2*)buf1265, *(float*)buf1266);
+    *(float3*)buf1267 = min(*(float3*)buf1268, *(float*)buf1269);
+    *(float4*)buf1270 = min(*(float4*)buf1271, *(float*)buf1272);
+    *(char*)buf1273 = min(*(char*)buf1274, *(char*)buf1275);
+    *(uchar*)buf1276 = min(*(uchar*)buf1277, *(uchar*)buf1278);
+    *(short*)buf1279 = min(*(short*)buf1280, *(short*)buf1281);
+    *(ushort*)buf1282 = min(*(ushort*)buf1283, *(ushort*)buf1284);
+    *(int*)buf1285 = min(*(int*)buf1286, *(int*)buf1287);
+    *(uint*)buf1288 = min(*(uint*)buf1289, *(uint*)buf1290);
+    *(char2*)buf1291 = min(*(char2*)buf1292, *(char2*)buf1293);
+    *(uchar2*)buf1294 = min(*(uchar2*)buf1295, *(uchar2*)buf1296);
+    *(short2*)buf1297 = min(*(short2*)buf1298, *(short2*)buf1299);
+    *(ushort2*)buf1300 = min(*(ushort2*)buf1301, *(ushort2*)buf1302);
+    *(int2*)buf1303 = min(*(int2*)buf1304, *(int2*)buf1305);
+    *(uint2*)buf1306 = min(*(uint2*)buf1307, *(uint2*)buf1308);
+    *(char3*)buf1309 = min(*(char3*)buf1310, *(char3*)buf1311);
+    *(uchar3*)buf1312 = min(*(uchar3*)buf1313, *(uchar3*)buf1314);
+    *(short3*)buf1315 = min(*(short3*)buf1316, *(short3*)buf1317);
+    *(ushort3*)buf1318 = min(*(ushort3*)buf1319, *(ushort3*)buf1320);
+    *(int3*)buf1321 = min(*(int3*)buf1322, *(int3*)buf1323);
+    *(uint3*)buf1324 = min(*(uint3*)buf1325, *(uint3*)buf1326);
+    *(char4*)buf1327 = min(*(char4*)buf1328, *(char4*)buf1329);
+    *(uchar4*)buf1330 = min(*(uchar4*)buf1331, *(uchar4*)buf1332);
+    *(short4*)buf1333 = min(*(short4*)buf1334, *(short4*)buf1335);
+    *(ushort4*)buf1336 = min(*(ushort4*)buf1337, *(ushort4*)buf1338);
+    *(int4*)buf1339 = min(*(int4*)buf1340, *(int4*)buf1341);
+    *(uint4*)buf1342 = min(*(uint4*)buf1343, *(uint4*)buf1344);
+    *(float*)buf1345 = mix(*(float*)buf1346, *(float*)buf1347, *(float*)buf1348);
+    *(float2*)buf1349 = mix(*(float2*)buf1350, *(float2*)buf1351, *(float2*)buf1352);
+    *(float3*)buf1353 = mix(*(float3*)buf1354, *(float3*)buf1355, *(float3*)buf1356);
+    *(float4*)buf1357 = mix(*(float4*)buf1358, *(float4*)buf1359, *(float4*)buf1360);
+    *(float2*)buf1361 = mix(*(float2*)buf1362, *(float2*)buf1363, *(float*)buf1364);
+    *(float3*)buf1365 = mix(*(float3*)buf1366, *(float3*)buf1367, *(float*)buf1368);
+    *(float4*)buf1369 = mix(*(float4*)buf1370, *(float4*)buf1371, *(float*)buf1372);
+    *(float*)buf1373 = modf(*(float*)buf1374, (float*) buf1375);
+    *(float2*)buf1376 = modf(*(float2*)buf1377, (float2*) buf1378);
+    *(float3*)buf1379 = modf(*(float3*)buf1380, (float3*) buf1381);
+    *(float4*)buf1382 = modf(*(float4*)buf1383, (float4*) buf1384);
+    *(float*)buf1385 = nan(*(uint*)buf1386);
+    *(float*)buf1387 = native_exp(*(float*)buf1388);
+    *(float2*)buf1389 = native_exp(*(float2*)buf1390);
+    *(float3*)buf1391 = native_exp(*(float3*)buf1392);
+    *(float4*)buf1393 = native_exp(*(float4*)buf1394);
+    *(float*)buf1395 = native_exp10(*(float*)buf1396);
+    *(float2*)buf1397 = native_exp10(*(float2*)buf1398);
+    *(float3*)buf1399 = native_exp10(*(float3*)buf1400);
+    *(float4*)buf1401 = native_exp10(*(float4*)buf1402);
+    *(float*)buf1403 = native_exp2(*(float*)buf1404);
+    *(float2*)buf1405 = native_exp2(*(float2*)buf1406);
+    *(float3*)buf1407 = native_exp2(*(float3*)buf1408);
+    *(float4*)buf1409 = native_exp2(*(float4*)buf1410);
+    *(float*)buf1411 = native_log(*(float*)buf1412);
+    *(float2*)buf1413 = native_log(*(float2*)buf1414);
+    *(float3*)buf1415 = native_log(*(float3*)buf1416);
+    *(float4*)buf1417 = native_log(*(float4*)buf1418);
+    *(float*)buf1419 = native_log10(*(float*)buf1420);
+    *(float2*)buf1421 = native_log10(*(float2*)buf1422);
+    *(float3*)buf1423 = native_log10(*(float3*)buf1424);
+    *(float4*)buf1425 = native_log10(*(float4*)buf1426);
+    *(float*)buf1427 = native_log2(*(float*)buf1428);
+    *(float2*)buf1429 = native_log2(*(float2*)buf1430);
+    *(float3*)buf1431 = native_log2(*(float3*)buf1432);
+    *(float4*)buf1433 = native_log2(*(float4*)buf1434);
+    *(float*)buf1435 = native_powr(*(float*)buf1436, *(float*)buf1437);
+    *(float2*)buf1438 = native_powr(*(float2*)buf1439, *(float2*)buf1440);
+    *(float3*)buf1441 = native_powr(*(float3*)buf1442, *(float3*)buf1443);
+    *(float4*)buf1444 = native_powr(*(float4*)buf1445, *(float4*)buf1446);
+    *(float*)buf1447 = nextafter(*(float*)buf1448, *(float*)buf1449);
+    *(float2*)buf1450 = nextafter(*(float2*)buf1451, *(float2*)buf1452);
+    *(float3*)buf1453 = nextafter(*(float3*)buf1454, *(float3*)buf1455);
+    *(float4*)buf1456 = nextafter(*(float4*)buf1457, *(float4*)buf1458);
+    *(float*)buf1459 = normalize(*(float*)buf1460);
+    *(float2*)buf1461 = normalize(*(float2*)buf1462);
+    *(float3*)buf1463 = normalize(*(float3*)buf1464);
+    *(float4*)buf1465 = normalize(*(float4*)buf1466);
+    *(float*)buf1467 = pow(*(float*)buf1468, *(float*)buf1469);
+    *(float2*)buf1470 = pow(*(float2*)buf1471, *(float2*)buf1472);
+    *(float3*)buf1473 = pow(*(float3*)buf1474, *(float3*)buf1475);
+    *(float4*)buf1476 = pow(*(float4*)buf1477, *(float4*)buf1478);
+    *(float*)buf1479 = pown(*(float*)buf1480, *(int*)buf1481);
+    *(float2*)buf1482 = pown(*(float2*)buf1483, *(int2*)buf1484);
+    *(float3*)buf1485 = pown(*(float3*)buf1486, *(int3*)buf1487);
+    *(float4*)buf1488 = pown(*(float4*)buf1489, *(int4*)buf1490);
+    *(float*)buf1491 = powr(*(float*)buf1492, *(float*)buf1493);
+    *(float2*)buf1494 = powr(*(float2*)buf1495, *(float2*)buf1496);
+    *(float3*)buf1497 = powr(*(float3*)buf1498, *(float3*)buf1499);
+    *(float4*)buf1500 = powr(*(float4*)buf1501, *(float4*)buf1502);
+    *(float*)buf1503 = radians(*(float*)buf1504);
+    *(float2*)buf1505 = radians(*(float2*)buf1506);
+    *(float3*)buf1507 = radians(*(float3*)buf1508);
+    *(float4*)buf1509 = radians(*(float4*)buf1510);
+    *(float*)buf1511 = remainder(*(float*)buf1512, *(float*)buf1513);
+    *(float2*)buf1514 = remainder(*(float2*)buf1515, *(float2*)buf1516);
+    *(float3*)buf1517 = remainder(*(float3*)buf1518, *(float3*)buf1519);
+    *(float4*)buf1520 = remainder(*(float4*)buf1521, *(float4*)buf1522);
+    *(float*)buf1523 = remquo(*(float*)buf1524, *(float*)buf1525, (int*) buf1526);
+    *(float2*)buf1527 = remquo(*(float2*)buf1528, *(float2*)buf1529, (int2*) buf1530);
+    *(float3*)buf1531 = remquo(*(float3*)buf1532, *(float3*)buf1533, (int3*) buf1534);
+    *(float4*)buf1535 = remquo(*(float4*)buf1536, *(float4*)buf1537, (int4*) buf1538);
+    *(float*)buf1539 = rint(*(float*)buf1540);
+    *(float2*)buf1541 = rint(*(float2*)buf1542);
+    *(float3*)buf1543 = rint(*(float3*)buf1544);
+    *(float4*)buf1545 = rint(*(float4*)buf1546);
+    *(float*)buf1547 = rootn(*(float*)buf1548, *(int*)buf1549);
+    *(float2*)buf1550 = rootn(*(float2*)buf1551, *(int2*)buf1552);
+    *(float3*)buf1553 = rootn(*(float3*)buf1554, *(int3*)buf1555);
+    *(float4*)buf1556 = rootn(*(float4*)buf1557, *(int4*)buf1558);
+    *(float*)buf1559 = round(*(float*)buf1560);
+    *(float2*)buf1561 = round(*(float2*)buf1562);
+    *(float3*)buf1563 = round(*(float3*)buf1564);
+    *(float4*)buf1565 = round(*(float4*)buf1566);
+    rsAllocationCopy1DRange(*(rs_allocation*)buf1567, *(uint32_t*)buf1568, *(uint32_t*)buf1569, *(uint32_t*)buf1570, *(rs_allocation*)buf1571, *(uint32_t*)buf1572, *(uint32_t*)buf1573);
+    rsAllocationCopy2DRange(*(rs_allocation*)buf1574, *(uint32_t*)buf1575, *(uint32_t*)buf1576, *(uint32_t*)buf1577, *(rs_allocation_cubemap_face*)buf1578, *(uint32_t*)buf1579, *(uint32_t*)buf1580, *(rs_allocation*)buf1581, *(uint32_t*)buf1582, *(uint32_t*)buf1583, *(uint32_t*)buf1584, *(rs_allocation_cubemap_face*)buf1585);
+    *(uint32_t*)buf1586 = rsAllocationGetDimFaces(*(rs_allocation*)buf1587);
+    *(uint32_t*)buf1588 = rsAllocationGetDimLOD(*(rs_allocation*)buf1589);
+    *(uint32_t*)buf1590 = rsAllocationGetDimX(*(rs_allocation*)buf1591);
+    *(uint32_t*)buf1592 = rsAllocationGetDimY(*(rs_allocation*)buf1593);
+    *(uint32_t*)buf1594 = rsAllocationGetDimZ(*(rs_allocation*)buf1595);
+    *(rs_element*)buf1596 = rsAllocationGetElement(*(rs_allocation*)buf1597);
+    rsAllocationIoReceive(*(rs_allocation*)buf1598);
+    rsAllocationIoSend(*(rs_allocation*)buf1599);
+    *(int32_t*)buf1600 = rsAtomicAdd((volatile int32_t*) buf1601, *(int32_t*)buf1602);
+    *(int32_t*)buf1603 = rsAtomicAdd((volatile uint32_t*) buf1604, *(uint32_t*)buf1605);
+    *(int32_t*)buf1606 = rsAtomicAnd((volatile int32_t*) buf1607, *(int32_t*)buf1608);
+    *(int32_t*)buf1609 = rsAtomicAnd((volatile uint32_t*) buf1610, *(uint32_t*)buf1611);
+    *(int32_t*)buf1612 = rsAtomicCas((volatile int32_t*) buf1613, *(int32_t*)buf1614, *(int32_t*)buf1615);
+    *(uint32_t*)buf1616 = rsAtomicCas((volatile uint32_t*) buf1617, *(uint32_t*)buf1618, *(uint32_t*)buf1619);
+    *(int32_t*)buf1620 = rsAtomicDec((volatile int32_t*) buf1621);
+    *(int32_t*)buf1622 = rsAtomicDec((volatile uint32_t*) buf1623);
+    *(int32_t*)buf1624 = rsAtomicInc((volatile int32_t*) buf1625);
+    *(int32_t*)buf1626 = rsAtomicInc((volatile uint32_t*) buf1627);
+    *(uint32_t*)buf1628 = rsAtomicMax((volatile uint32_t*) buf1629, *(uint32_t*)buf1630);
+    *(int32_t*)buf1631 = rsAtomicMax((volatile int32_t*) buf1632, *(int32_t*)buf1633);
+    *(uint32_t*)buf1634 = rsAtomicMin((volatile uint32_t*) buf1635, *(uint32_t*)buf1636);
+    *(int32_t*)buf1637 = rsAtomicMin((volatile int32_t*) buf1638, *(int32_t*)buf1639);
+    *(int32_t*)buf1640 = rsAtomicOr((volatile int32_t*) buf1641, *(int32_t*)buf1642);
+    *(int32_t*)buf1643 = rsAtomicOr((volatile uint32_t*) buf1644, *(uint32_t*)buf1645);
+    *(int32_t*)buf1646 = rsAtomicSub((volatile int32_t*) buf1647, *(int32_t*)buf1648);
+    *(int32_t*)buf1649 = rsAtomicSub((volatile uint32_t*) buf1650, *(uint32_t*)buf1651);
+    *(int32_t*)buf1652 = rsAtomicXor((volatile int32_t*) buf1653, *(int32_t*)buf1654);
+    *(int32_t*)buf1655 = rsAtomicXor((volatile uint32_t*) buf1656, *(uint32_t*)buf1657);
+    *(char*)buf1658 = rsClamp(*(char*)buf1659, *(char*)buf1660, *(char*)buf1661);
+    *(uchar*)buf1662 = rsClamp(*(uchar*)buf1663, *(uchar*)buf1664, *(uchar*)buf1665);
+    *(short*)buf1666 = rsClamp(*(short*)buf1667, *(short*)buf1668, *(short*)buf1669);
+    *(ushort*)buf1670 = rsClamp(*(ushort*)buf1671, *(ushort*)buf1672, *(ushort*)buf1673);
+    *(int*)buf1674 = rsClamp(*(int*)buf1675, *(int*)buf1676, *(int*)buf1677);
+    *(uint*)buf1678 = rsClamp(*(uint*)buf1679, *(uint*)buf1680, *(uint*)buf1681);
+    rsClearObject((rs_element*) buf1682);
+    rsClearObject((rs_type*) buf1683);
+    rsClearObject((rs_allocation*) buf1684);
+    rsClearObject((rs_sampler*) buf1685);
+    rsClearObject((rs_script*) buf1686);
 #ifndef __LP64__
-    rsClearObject((rs_mesh*) buf1669);
-    rsClearObject((rs_program_fragment*) buf1670);
-    rsClearObject((rs_program_vertex*) buf1671);
-    rsClearObject((rs_program_raster*) buf1672);
-    rsClearObject((rs_program_store*) buf1673);
-    rsClearObject((rs_font*) buf1674);
+    rsClearObject((rs_mesh*) buf1687);
+    rsClearObject((rs_program_fragment*) buf1688);
+    rsClearObject((rs_program_vertex*) buf1689);
+    rsClearObject((rs_program_raster*) buf1690);
+    rsClearObject((rs_program_store*) buf1691);
+    rsClearObject((rs_font*) buf1692);
 #endif
-    rsDebug((const char*) buf1675, *(double*)buf1676);
-    rsDebug((const char*) buf1677, *(int*)buf1678);
-    rsDebug((const char*) buf1679, *(uint*)buf1680);
-    rsDebug((const char*) buf1681, *(long*)buf1682);
-    rsDebug((const char*) buf1683, *(ulong*)buf1684);
-    rsDebug((const char*) buf1685, *(int2*)buf1686);
-    rsDebug((const char*) buf1687, *(int3*)buf1688);
-    rsDebug((const char*) buf1689, *(int4*)buf1690);
-    rsDebug((const char*) buf1691, *(uint2*)buf1692);
-    rsDebug((const char*) buf1693, *(uint3*)buf1694);
-    rsDebug((const char*) buf1695, *(uint4*)buf1696);
-    rsDebug((const char*) buf1697, *(long2*)buf1698);
-    rsDebug((const char*) buf1699, *(long3*)buf1700);
-    rsDebug((const char*) buf1701, *(long4*)buf1702);
-    rsDebug((const char*) buf1703, *(ulong2*)buf1704);
-    rsDebug((const char*) buf1705, *(ulong3*)buf1706);
-    rsDebug((const char*) buf1707, *(ulong4*)buf1708);
-    rsDebug((const char*) buf1709, *(float*)buf1710);
-    rsDebug((const char*) buf1711, *(float2*)buf1712);
-    rsDebug((const char*) buf1713, *(float3*)buf1714);
-    rsDebug((const char*) buf1715, *(float4*)buf1716);
-    rsDebug((const char*) buf1717, *(char*)buf1718);
-    rsDebug((const char*) buf1719, *(char2*)buf1720);
-    rsDebug((const char*) buf1721, *(char3*)buf1722);
-    rsDebug((const char*) buf1723, *(char4*)buf1724);
-    rsDebug((const char*) buf1725, *(uchar*)buf1726);
-    rsDebug((const char*) buf1727, *(uchar2*)buf1728);
-    rsDebug((const char*) buf1729, *(uchar3*)buf1730);
-    rsDebug((const char*) buf1731, *(uchar4*)buf1732);
-    rsDebug((const char*) buf1733, *(short*)buf1734);
-    rsDebug((const char*) buf1735, *(short2*)buf1736);
-    rsDebug((const char*) buf1737, *(short3*)buf1738);
-    rsDebug((const char*) buf1739, *(short4*)buf1740);
-    rsDebug((const char*) buf1741, *(ushort*)buf1742);
-    rsDebug((const char*) buf1743, *(ushort2*)buf1744);
-    rsDebug((const char*) buf1745, *(ushort3*)buf1746);
-    rsDebug((const char*) buf1747, *(ushort4*)buf1748);
-    rsDebug((const char*) buf1749, *(float*)buf1750, *(float*)buf1751);
-    rsDebug((const char*) buf1752, *(float*)buf1753, *(float*)buf1754, *(float*)buf1755);
-    rsDebug((const char*) buf1756, *(float*)buf1757, *(float*)buf1758, *(float*)buf1759, *(float*)buf1760);
-    rsDebug((const char*) buf1761, *(long long*)buf1762);
-    rsDebug((const char*) buf1763, *(unsigned long long*)buf1764);
-    rsDebug((const char*) buf1765, (const void*) buf1766);
-    rsDebug((const char*) buf1767, (const rs_matrix4x4*) buf1768);
-    rsDebug((const char*) buf1769, (const rs_matrix3x3*) buf1770);
-    rsDebug((const char*) buf1771, (const rs_matrix2x2*) buf1772);
-    *(uint32_t*)buf1773 = rsElementGetBytesSize(*(rs_element*)buf1774);
-    *(rs_data_kind*)buf1775 = rsElementGetDataKind(*(rs_element*)buf1776);
-    *(rs_data_type*)buf1777 = rsElementGetDataType(*(rs_element*)buf1778);
-    *(rs_element*)buf1779 = rsElementGetSubElement(*(rs_element*)buf1780, *(uint32_t*)buf1781);
-    *(uint32_t*)buf1782 = rsElementGetSubElementArraySize(*(rs_element*)buf1783, *(uint32_t*)buf1784);
-    *(uint32_t*)buf1785 = rsElementGetSubElementCount(*(rs_element*)buf1786);
-    *(uint32_t*)buf1787 = rsElementGetSubElementName(*(rs_element*)buf1788, *(uint32_t*)buf1789, (char*) buf1790, *(uint32_t*)buf1791);
-    *(uint32_t*)buf1792 = rsElementGetSubElementNameLength(*(rs_element*)buf1793, *(uint32_t*)buf1794);
-    *(uint32_t*)buf1795 = rsElementGetSubElementOffsetBytes(*(rs_element*)buf1796, *(uint32_t*)buf1797);
-    *(uint32_t*)buf1798 = rsElementGetVectorSize(*(rs_element*)buf1799);
-    rsExtractFrustumPlanes((const rs_matrix4x4*) buf1800, (float4*) buf1801, (float4*) buf1802, (float4*) buf1803, (float4*) buf1804, (float4*) buf1805, (float4*) buf1806);
-    rsForEach(*(rs_script*)buf1807, *(rs_allocation*)buf1808, *(rs_allocation*)buf1809, (const void*) buf1810, *(size_t*)buf1811, (const rs_script_call_t*) buf1812);
-    rsForEach(*(rs_script*)buf1813, *(rs_allocation*)buf1814, *(rs_allocation*)buf1815, (const void*) buf1816, *(size_t*)buf1817);
-    rsForEach(*(rs_script*)buf1818, *(rs_allocation*)buf1819, *(rs_allocation*)buf1820);
-    *(float*)buf1821 = rsFrac(*(float*)buf1822);
-    *(rs_allocation*)buf1823 = rsGetAllocation((const void*) buf1824);
-    *(float*)buf1825 = rsGetDt();
-    *(const void**)buf1826 = rsGetElementAt(*(rs_allocation*)buf1827, *(uint32_t*)buf1828);
-    *(const void**)buf1829 = rsGetElementAt(*(rs_allocation*)buf1830, *(uint32_t*)buf1831, *(uint32_t*)buf1832);
-    *(const void**)buf1833 = rsGetElementAt(*(rs_allocation*)buf1834, *(uint32_t*)buf1835, *(uint32_t*)buf1836, *(uint32_t*)buf1837);
-    *(float*)buf1838 = rsGetElementAt_float(*(rs_allocation*)buf1839, *(uint32_t*)buf1840);
-    *(float2*)buf1841 = rsGetElementAt_float2(*(rs_allocation*)buf1842, *(uint32_t*)buf1843);
-    *(float3*)buf1844 = rsGetElementAt_float3(*(rs_allocation*)buf1845, *(uint32_t*)buf1846);
-    *(float4*)buf1847 = rsGetElementAt_float4(*(rs_allocation*)buf1848, *(uint32_t*)buf1849);
-    *(double*)buf1850 = rsGetElementAt_double(*(rs_allocation*)buf1851, *(uint32_t*)buf1852);
-    *(double2*)buf1853 = rsGetElementAt_double2(*(rs_allocation*)buf1854, *(uint32_t*)buf1855);
-    *(double3*)buf1856 = rsGetElementAt_double3(*(rs_allocation*)buf1857, *(uint32_t*)buf1858);
-    *(double4*)buf1859 = rsGetElementAt_double4(*(rs_allocation*)buf1860, *(uint32_t*)buf1861);
-    *(char*)buf1862 = rsGetElementAt_char(*(rs_allocation*)buf1863, *(uint32_t*)buf1864);
-    *(char2*)buf1865 = rsGetElementAt_char2(*(rs_allocation*)buf1866, *(uint32_t*)buf1867);
-    *(char3*)buf1868 = rsGetElementAt_char3(*(rs_allocation*)buf1869, *(uint32_t*)buf1870);
-    *(char4*)buf1871 = rsGetElementAt_char4(*(rs_allocation*)buf1872, *(uint32_t*)buf1873);
-    *(uchar*)buf1874 = rsGetElementAt_uchar(*(rs_allocation*)buf1875, *(uint32_t*)buf1876);
-    *(uchar2*)buf1877 = rsGetElementAt_uchar2(*(rs_allocation*)buf1878, *(uint32_t*)buf1879);
-    *(uchar3*)buf1880 = rsGetElementAt_uchar3(*(rs_allocation*)buf1881, *(uint32_t*)buf1882);
-    *(uchar4*)buf1883 = rsGetElementAt_uchar4(*(rs_allocation*)buf1884, *(uint32_t*)buf1885);
-    *(short*)buf1886 = rsGetElementAt_short(*(rs_allocation*)buf1887, *(uint32_t*)buf1888);
-    *(short2*)buf1889 = rsGetElementAt_short2(*(rs_allocation*)buf1890, *(uint32_t*)buf1891);
-    *(short3*)buf1892 = rsGetElementAt_short3(*(rs_allocation*)buf1893, *(uint32_t*)buf1894);
-    *(short4*)buf1895 = rsGetElementAt_short4(*(rs_allocation*)buf1896, *(uint32_t*)buf1897);
-    *(ushort*)buf1898 = rsGetElementAt_ushort(*(rs_allocation*)buf1899, *(uint32_t*)buf1900);
-    *(ushort2*)buf1901 = rsGetElementAt_ushort2(*(rs_allocation*)buf1902, *(uint32_t*)buf1903);
-    *(ushort3*)buf1904 = rsGetElementAt_ushort3(*(rs_allocation*)buf1905, *(uint32_t*)buf1906);
-    *(ushort4*)buf1907 = rsGetElementAt_ushort4(*(rs_allocation*)buf1908, *(uint32_t*)buf1909);
-    *(int*)buf1910 = rsGetElementAt_int(*(rs_allocation*)buf1911, *(uint32_t*)buf1912);
-    *(int2*)buf1913 = rsGetElementAt_int2(*(rs_allocation*)buf1914, *(uint32_t*)buf1915);
-    *(int3*)buf1916 = rsGetElementAt_int3(*(rs_allocation*)buf1917, *(uint32_t*)buf1918);
-    *(int4*)buf1919 = rsGetElementAt_int4(*(rs_allocation*)buf1920, *(uint32_t*)buf1921);
-    *(uint*)buf1922 = rsGetElementAt_uint(*(rs_allocation*)buf1923, *(uint32_t*)buf1924);
-    *(uint2*)buf1925 = rsGetElementAt_uint2(*(rs_allocation*)buf1926, *(uint32_t*)buf1927);
-    *(uint3*)buf1928 = rsGetElementAt_uint3(*(rs_allocation*)buf1929, *(uint32_t*)buf1930);
-    *(uint4*)buf1931 = rsGetElementAt_uint4(*(rs_allocation*)buf1932, *(uint32_t*)buf1933);
-    *(long*)buf1934 = rsGetElementAt_long(*(rs_allocation*)buf1935, *(uint32_t*)buf1936);
-    *(long2*)buf1937 = rsGetElementAt_long2(*(rs_allocation*)buf1938, *(uint32_t*)buf1939);
-    *(long3*)buf1940 = rsGetElementAt_long3(*(rs_allocation*)buf1941, *(uint32_t*)buf1942);
-    *(long4*)buf1943 = rsGetElementAt_long4(*(rs_allocation*)buf1944, *(uint32_t*)buf1945);
-    *(ulong*)buf1946 = rsGetElementAt_ulong(*(rs_allocation*)buf1947, *(uint32_t*)buf1948);
-    *(ulong2*)buf1949 = rsGetElementAt_ulong2(*(rs_allocation*)buf1950, *(uint32_t*)buf1951);
-    *(ulong3*)buf1952 = rsGetElementAt_ulong3(*(rs_allocation*)buf1953, *(uint32_t*)buf1954);
-    *(ulong4*)buf1955 = rsGetElementAt_ulong4(*(rs_allocation*)buf1956, *(uint32_t*)buf1957);
-    *(float*)buf1958 = rsGetElementAt_float(*(rs_allocation*)buf1959, *(uint32_t*)buf1960, *(uint32_t*)buf1961);
-    *(float2*)buf1962 = rsGetElementAt_float2(*(rs_allocation*)buf1963, *(uint32_t*)buf1964, *(uint32_t*)buf1965);
-    *(float3*)buf1966 = rsGetElementAt_float3(*(rs_allocation*)buf1967, *(uint32_t*)buf1968, *(uint32_t*)buf1969);
-    *(float4*)buf1970 = rsGetElementAt_float4(*(rs_allocation*)buf1971, *(uint32_t*)buf1972, *(uint32_t*)buf1973);
-    *(double*)buf1974 = rsGetElementAt_double(*(rs_allocation*)buf1975, *(uint32_t*)buf1976, *(uint32_t*)buf1977);
-    *(double2*)buf1978 = rsGetElementAt_double2(*(rs_allocation*)buf1979, *(uint32_t*)buf1980, *(uint32_t*)buf1981);
-    *(double3*)buf1982 = rsGetElementAt_double3(*(rs_allocation*)buf1983, *(uint32_t*)buf1984, *(uint32_t*)buf1985);
-    *(double4*)buf1986 = rsGetElementAt_double4(*(rs_allocation*)buf1987, *(uint32_t*)buf1988, *(uint32_t*)buf1989);
-    *(char*)buf1990 = rsGetElementAt_char(*(rs_allocation*)buf1991, *(uint32_t*)buf1992, *(uint32_t*)buf1993);
-    *(char2*)buf1994 = rsGetElementAt_char2(*(rs_allocation*)buf1995, *(uint32_t*)buf1996, *(uint32_t*)buf1997);
-    *(char3*)buf1998 = rsGetElementAt_char3(*(rs_allocation*)buf1999, *(uint32_t*)buf2000, *(uint32_t*)buf2001);
-    *(char4*)buf2002 = rsGetElementAt_char4(*(rs_allocation*)buf2003, *(uint32_t*)buf2004, *(uint32_t*)buf2005);
-    *(uchar*)buf2006 = rsGetElementAt_uchar(*(rs_allocation*)buf2007, *(uint32_t*)buf2008, *(uint32_t*)buf2009);
-    *(uchar2*)buf2010 = rsGetElementAt_uchar2(*(rs_allocation*)buf2011, *(uint32_t*)buf2012, *(uint32_t*)buf2013);
-    *(uchar3*)buf2014 = rsGetElementAt_uchar3(*(rs_allocation*)buf2015, *(uint32_t*)buf2016, *(uint32_t*)buf2017);
-    *(uchar4*)buf2018 = rsGetElementAt_uchar4(*(rs_allocation*)buf2019, *(uint32_t*)buf2020, *(uint32_t*)buf2021);
-    *(short*)buf2022 = rsGetElementAt_short(*(rs_allocation*)buf2023, *(uint32_t*)buf2024, *(uint32_t*)buf2025);
-    *(short2*)buf2026 = rsGetElementAt_short2(*(rs_allocation*)buf2027, *(uint32_t*)buf2028, *(uint32_t*)buf2029);
-    *(short3*)buf2030 = rsGetElementAt_short3(*(rs_allocation*)buf2031, *(uint32_t*)buf2032, *(uint32_t*)buf2033);
-    *(short4*)buf2034 = rsGetElementAt_short4(*(rs_allocation*)buf2035, *(uint32_t*)buf2036, *(uint32_t*)buf2037);
-    *(ushort*)buf2038 = rsGetElementAt_ushort(*(rs_allocation*)buf2039, *(uint32_t*)buf2040, *(uint32_t*)buf2041);
-    *(ushort2*)buf2042 = rsGetElementAt_ushort2(*(rs_allocation*)buf2043, *(uint32_t*)buf2044, *(uint32_t*)buf2045);
-    *(ushort3*)buf2046 = rsGetElementAt_ushort3(*(rs_allocation*)buf2047, *(uint32_t*)buf2048, *(uint32_t*)buf2049);
-    *(ushort4*)buf2050 = rsGetElementAt_ushort4(*(rs_allocation*)buf2051, *(uint32_t*)buf2052, *(uint32_t*)buf2053);
-    *(int*)buf2054 = rsGetElementAt_int(*(rs_allocation*)buf2055, *(uint32_t*)buf2056, *(uint32_t*)buf2057);
-    *(int2*)buf2058 = rsGetElementAt_int2(*(rs_allocation*)buf2059, *(uint32_t*)buf2060, *(uint32_t*)buf2061);
-    *(int3*)buf2062 = rsGetElementAt_int3(*(rs_allocation*)buf2063, *(uint32_t*)buf2064, *(uint32_t*)buf2065);
-    *(int4*)buf2066 = rsGetElementAt_int4(*(rs_allocation*)buf2067, *(uint32_t*)buf2068, *(uint32_t*)buf2069);
-    *(uint*)buf2070 = rsGetElementAt_uint(*(rs_allocation*)buf2071, *(uint32_t*)buf2072, *(uint32_t*)buf2073);
-    *(uint2*)buf2074 = rsGetElementAt_uint2(*(rs_allocation*)buf2075, *(uint32_t*)buf2076, *(uint32_t*)buf2077);
-    *(uint3*)buf2078 = rsGetElementAt_uint3(*(rs_allocation*)buf2079, *(uint32_t*)buf2080, *(uint32_t*)buf2081);
-    *(uint4*)buf2082 = rsGetElementAt_uint4(*(rs_allocation*)buf2083, *(uint32_t*)buf2084, *(uint32_t*)buf2085);
-    *(long*)buf2086 = rsGetElementAt_long(*(rs_allocation*)buf2087, *(uint32_t*)buf2088, *(uint32_t*)buf2089);
-    *(long2*)buf2090 = rsGetElementAt_long2(*(rs_allocation*)buf2091, *(uint32_t*)buf2092, *(uint32_t*)buf2093);
-    *(long3*)buf2094 = rsGetElementAt_long3(*(rs_allocation*)buf2095, *(uint32_t*)buf2096, *(uint32_t*)buf2097);
-    *(long4*)buf2098 = rsGetElementAt_long4(*(rs_allocation*)buf2099, *(uint32_t*)buf2100, *(uint32_t*)buf2101);
-    *(ulong*)buf2102 = rsGetElementAt_ulong(*(rs_allocation*)buf2103, *(uint32_t*)buf2104, *(uint32_t*)buf2105);
-    *(ulong2*)buf2106 = rsGetElementAt_ulong2(*(rs_allocation*)buf2107, *(uint32_t*)buf2108, *(uint32_t*)buf2109);
-    *(ulong3*)buf2110 = rsGetElementAt_ulong3(*(rs_allocation*)buf2111, *(uint32_t*)buf2112, *(uint32_t*)buf2113);
-    *(ulong4*)buf2114 = rsGetElementAt_ulong4(*(rs_allocation*)buf2115, *(uint32_t*)buf2116, *(uint32_t*)buf2117);
-    *(float*)buf2118 = rsGetElementAt_float(*(rs_allocation*)buf2119, *(uint32_t*)buf2120, *(uint32_t*)buf2121, *(uint32_t*)buf2122);
-    *(float2*)buf2123 = rsGetElementAt_float2(*(rs_allocation*)buf2124, *(uint32_t*)buf2125, *(uint32_t*)buf2126, *(uint32_t*)buf2127);
-    *(float3*)buf2128 = rsGetElementAt_float3(*(rs_allocation*)buf2129, *(uint32_t*)buf2130, *(uint32_t*)buf2131, *(uint32_t*)buf2132);
-    *(float4*)buf2133 = rsGetElementAt_float4(*(rs_allocation*)buf2134, *(uint32_t*)buf2135, *(uint32_t*)buf2136, *(uint32_t*)buf2137);
-    *(double*)buf2138 = rsGetElementAt_double(*(rs_allocation*)buf2139, *(uint32_t*)buf2140, *(uint32_t*)buf2141, *(uint32_t*)buf2142);
-    *(double2*)buf2143 = rsGetElementAt_double2(*(rs_allocation*)buf2144, *(uint32_t*)buf2145, *(uint32_t*)buf2146, *(uint32_t*)buf2147);
-    *(double3*)buf2148 = rsGetElementAt_double3(*(rs_allocation*)buf2149, *(uint32_t*)buf2150, *(uint32_t*)buf2151, *(uint32_t*)buf2152);
-    *(double4*)buf2153 = rsGetElementAt_double4(*(rs_allocation*)buf2154, *(uint32_t*)buf2155, *(uint32_t*)buf2156, *(uint32_t*)buf2157);
-    *(char*)buf2158 = rsGetElementAt_char(*(rs_allocation*)buf2159, *(uint32_t*)buf2160, *(uint32_t*)buf2161, *(uint32_t*)buf2162);
-    *(char2*)buf2163 = rsGetElementAt_char2(*(rs_allocation*)buf2164, *(uint32_t*)buf2165, *(uint32_t*)buf2166, *(uint32_t*)buf2167);
-    *(char3*)buf2168 = rsGetElementAt_char3(*(rs_allocation*)buf2169, *(uint32_t*)buf2170, *(uint32_t*)buf2171, *(uint32_t*)buf2172);
-    *(char4*)buf2173 = rsGetElementAt_char4(*(rs_allocation*)buf2174, *(uint32_t*)buf2175, *(uint32_t*)buf2176, *(uint32_t*)buf2177);
-    *(uchar*)buf2178 = rsGetElementAt_uchar(*(rs_allocation*)buf2179, *(uint32_t*)buf2180, *(uint32_t*)buf2181, *(uint32_t*)buf2182);
-    *(uchar2*)buf2183 = rsGetElementAt_uchar2(*(rs_allocation*)buf2184, *(uint32_t*)buf2185, *(uint32_t*)buf2186, *(uint32_t*)buf2187);
-    *(uchar3*)buf2188 = rsGetElementAt_uchar3(*(rs_allocation*)buf2189, *(uint32_t*)buf2190, *(uint32_t*)buf2191, *(uint32_t*)buf2192);
-    *(uchar4*)buf2193 = rsGetElementAt_uchar4(*(rs_allocation*)buf2194, *(uint32_t*)buf2195, *(uint32_t*)buf2196, *(uint32_t*)buf2197);
-    *(short*)buf2198 = rsGetElementAt_short(*(rs_allocation*)buf2199, *(uint32_t*)buf2200, *(uint32_t*)buf2201, *(uint32_t*)buf2202);
-    *(short2*)buf2203 = rsGetElementAt_short2(*(rs_allocation*)buf2204, *(uint32_t*)buf2205, *(uint32_t*)buf2206, *(uint32_t*)buf2207);
-    *(short3*)buf2208 = rsGetElementAt_short3(*(rs_allocation*)buf2209, *(uint32_t*)buf2210, *(uint32_t*)buf2211, *(uint32_t*)buf2212);
-    *(short4*)buf2213 = rsGetElementAt_short4(*(rs_allocation*)buf2214, *(uint32_t*)buf2215, *(uint32_t*)buf2216, *(uint32_t*)buf2217);
-    *(ushort*)buf2218 = rsGetElementAt_ushort(*(rs_allocation*)buf2219, *(uint32_t*)buf2220, *(uint32_t*)buf2221, *(uint32_t*)buf2222);
-    *(ushort2*)buf2223 = rsGetElementAt_ushort2(*(rs_allocation*)buf2224, *(uint32_t*)buf2225, *(uint32_t*)buf2226, *(uint32_t*)buf2227);
-    *(ushort3*)buf2228 = rsGetElementAt_ushort3(*(rs_allocation*)buf2229, *(uint32_t*)buf2230, *(uint32_t*)buf2231, *(uint32_t*)buf2232);
-    *(ushort4*)buf2233 = rsGetElementAt_ushort4(*(rs_allocation*)buf2234, *(uint32_t*)buf2235, *(uint32_t*)buf2236, *(uint32_t*)buf2237);
-    *(int*)buf2238 = rsGetElementAt_int(*(rs_allocation*)buf2239, *(uint32_t*)buf2240, *(uint32_t*)buf2241, *(uint32_t*)buf2242);
-    *(int2*)buf2243 = rsGetElementAt_int2(*(rs_allocation*)buf2244, *(uint32_t*)buf2245, *(uint32_t*)buf2246, *(uint32_t*)buf2247);
-    *(int3*)buf2248 = rsGetElementAt_int3(*(rs_allocation*)buf2249, *(uint32_t*)buf2250, *(uint32_t*)buf2251, *(uint32_t*)buf2252);
-    *(int4*)buf2253 = rsGetElementAt_int4(*(rs_allocation*)buf2254, *(uint32_t*)buf2255, *(uint32_t*)buf2256, *(uint32_t*)buf2257);
-    *(uint*)buf2258 = rsGetElementAt_uint(*(rs_allocation*)buf2259, *(uint32_t*)buf2260, *(uint32_t*)buf2261, *(uint32_t*)buf2262);
-    *(uint2*)buf2263 = rsGetElementAt_uint2(*(rs_allocation*)buf2264, *(uint32_t*)buf2265, *(uint32_t*)buf2266, *(uint32_t*)buf2267);
-    *(uint3*)buf2268 = rsGetElementAt_uint3(*(rs_allocation*)buf2269, *(uint32_t*)buf2270, *(uint32_t*)buf2271, *(uint32_t*)buf2272);
-    *(uint4*)buf2273 = rsGetElementAt_uint4(*(rs_allocation*)buf2274, *(uint32_t*)buf2275, *(uint32_t*)buf2276, *(uint32_t*)buf2277);
-    *(long*)buf2278 = rsGetElementAt_long(*(rs_allocation*)buf2279, *(uint32_t*)buf2280, *(uint32_t*)buf2281, *(uint32_t*)buf2282);
-    *(long2*)buf2283 = rsGetElementAt_long2(*(rs_allocation*)buf2284, *(uint32_t*)buf2285, *(uint32_t*)buf2286, *(uint32_t*)buf2287);
-    *(long3*)buf2288 = rsGetElementAt_long3(*(rs_allocation*)buf2289, *(uint32_t*)buf2290, *(uint32_t*)buf2291, *(uint32_t*)buf2292);
-    *(long4*)buf2293 = rsGetElementAt_long4(*(rs_allocation*)buf2294, *(uint32_t*)buf2295, *(uint32_t*)buf2296, *(uint32_t*)buf2297);
-    *(ulong*)buf2298 = rsGetElementAt_ulong(*(rs_allocation*)buf2299, *(uint32_t*)buf2300, *(uint32_t*)buf2301, *(uint32_t*)buf2302);
-    *(ulong2*)buf2303 = rsGetElementAt_ulong2(*(rs_allocation*)buf2304, *(uint32_t*)buf2305, *(uint32_t*)buf2306, *(uint32_t*)buf2307);
-    *(ulong3*)buf2308 = rsGetElementAt_ulong3(*(rs_allocation*)buf2309, *(uint32_t*)buf2310, *(uint32_t*)buf2311, *(uint32_t*)buf2312);
-    *(ulong4*)buf2313 = rsGetElementAt_ulong4(*(rs_allocation*)buf2314, *(uint32_t*)buf2315, *(uint32_t*)buf2316, *(uint32_t*)buf2317);
-    *(uchar*)buf2318 = rsGetElementAtYuv_uchar_U(*(rs_allocation*)buf2319, *(uint32_t*)buf2320, *(uint32_t*)buf2321);
-    *(uchar*)buf2322 = rsGetElementAtYuv_uchar_V(*(rs_allocation*)buf2323, *(uint32_t*)buf2324, *(uint32_t*)buf2325);
-    *(uchar*)buf2326 = rsGetElementAtYuv_uchar_Y(*(rs_allocation*)buf2327, *(uint32_t*)buf2328, *(uint32_t*)buf2329);
-    *(bool*)buf2330 = rsIsObject(*(rs_element*)buf2331);
-    *(bool*)buf2332 = rsIsObject(*(rs_type*)buf2333);
-    *(bool*)buf2334 = rsIsObject(*(rs_allocation*)buf2335);
-    *(bool*)buf2336 = rsIsObject(*(rs_sampler*)buf2337);
-    *(bool*)buf2338 = rsIsObject(*(rs_script*)buf2339);
+    rsDebug((const char*) buf1693, *(double*)buf1694);
+    rsDebug((const char*) buf1695, *(int*)buf1696);
+    rsDebug((const char*) buf1697, *(uint*)buf1698);
+    rsDebug((const char*) buf1699, *(long*)buf1700);
+    rsDebug((const char*) buf1701, *(ulong*)buf1702);
+    rsDebug((const char*) buf1703, *(int2*)buf1704);
+    rsDebug((const char*) buf1705, *(int3*)buf1706);
+    rsDebug((const char*) buf1707, *(int4*)buf1708);
+    rsDebug((const char*) buf1709, *(uint2*)buf1710);
+    rsDebug((const char*) buf1711, *(uint3*)buf1712);
+    rsDebug((const char*) buf1713, *(uint4*)buf1714);
+    rsDebug((const char*) buf1715, *(long2*)buf1716);
+    rsDebug((const char*) buf1717, *(long3*)buf1718);
+    rsDebug((const char*) buf1719, *(long4*)buf1720);
+    rsDebug((const char*) buf1721, *(ulong2*)buf1722);
+    rsDebug((const char*) buf1723, *(ulong3*)buf1724);
+    rsDebug((const char*) buf1725, *(ulong4*)buf1726);
+    rsDebug((const char*) buf1727, *(float*)buf1728);
+    rsDebug((const char*) buf1729, *(float2*)buf1730);
+    rsDebug((const char*) buf1731, *(float3*)buf1732);
+    rsDebug((const char*) buf1733, *(float4*)buf1734);
+    rsDebug((const char*) buf1735, *(char*)buf1736);
+    rsDebug((const char*) buf1737, *(char2*)buf1738);
+    rsDebug((const char*) buf1739, *(char3*)buf1740);
+    rsDebug((const char*) buf1741, *(char4*)buf1742);
+    rsDebug((const char*) buf1743, *(uchar*)buf1744);
+    rsDebug((const char*) buf1745, *(uchar2*)buf1746);
+    rsDebug((const char*) buf1747, *(uchar3*)buf1748);
+    rsDebug((const char*) buf1749, *(uchar4*)buf1750);
+    rsDebug((const char*) buf1751, *(short*)buf1752);
+    rsDebug((const char*) buf1753, *(short2*)buf1754);
+    rsDebug((const char*) buf1755, *(short3*)buf1756);
+    rsDebug((const char*) buf1757, *(short4*)buf1758);
+    rsDebug((const char*) buf1759, *(ushort*)buf1760);
+    rsDebug((const char*) buf1761, *(ushort2*)buf1762);
+    rsDebug((const char*) buf1763, *(ushort3*)buf1764);
+    rsDebug((const char*) buf1765, *(ushort4*)buf1766);
+    rsDebug((const char*) buf1767, *(float*)buf1768, *(float*)buf1769);
+    rsDebug((const char*) buf1770, *(float*)buf1771, *(float*)buf1772, *(float*)buf1773);
+    rsDebug((const char*) buf1774, *(float*)buf1775, *(float*)buf1776, *(float*)buf1777, *(float*)buf1778);
+    rsDebug((const char*) buf1779, *(long long*)buf1780);
+    rsDebug((const char*) buf1781, *(unsigned long long*)buf1782);
+    rsDebug((const char*) buf1783, (const void*) buf1784);
+    rsDebug((const char*) buf1785, (const rs_matrix4x4*) buf1786);
+    rsDebug((const char*) buf1787, (const rs_matrix3x3*) buf1788);
+    rsDebug((const char*) buf1789, (const rs_matrix2x2*) buf1790);
+    *(uint32_t*)buf1791 = rsElementGetBytesSize(*(rs_element*)buf1792);
+    *(rs_data_kind*)buf1793 = rsElementGetDataKind(*(rs_element*)buf1794);
+    *(rs_data_type*)buf1795 = rsElementGetDataType(*(rs_element*)buf1796);
+    *(rs_element*)buf1797 = rsElementGetSubElement(*(rs_element*)buf1798, *(uint32_t*)buf1799);
+    *(uint32_t*)buf1800 = rsElementGetSubElementArraySize(*(rs_element*)buf1801, *(uint32_t*)buf1802);
+    *(uint32_t*)buf1803 = rsElementGetSubElementCount(*(rs_element*)buf1804);
+    *(uint32_t*)buf1805 = rsElementGetSubElementName(*(rs_element*)buf1806, *(uint32_t*)buf1807, (char*) buf1808, *(uint32_t*)buf1809);
+    *(uint32_t*)buf1810 = rsElementGetSubElementNameLength(*(rs_element*)buf1811, *(uint32_t*)buf1812);
+    *(uint32_t*)buf1813 = rsElementGetSubElementOffsetBytes(*(rs_element*)buf1814, *(uint32_t*)buf1815);
+    *(uint32_t*)buf1816 = rsElementGetVectorSize(*(rs_element*)buf1817);
+    rsExtractFrustumPlanes((const rs_matrix4x4*) buf1818, (float4*) buf1819, (float4*) buf1820, (float4*) buf1821, (float4*) buf1822, (float4*) buf1823, (float4*) buf1824);
+    rsForEach(*(rs_script*)buf1825, *(rs_allocation*)buf1826, *(rs_allocation*)buf1827, (const void*) buf1828, *(size_t*)buf1829, (const rs_script_call_t*) buf1830);
+    rsForEach(*(rs_script*)buf1831, *(rs_allocation*)buf1832, *(rs_allocation*)buf1833, (const void*) buf1834, *(size_t*)buf1835);
+    rsForEach(*(rs_script*)buf1836, *(rs_allocation*)buf1837, *(rs_allocation*)buf1838);
+    *(float*)buf1839 = rsFrac(*(float*)buf1840);
+    *(rs_allocation*)buf1841 = rsGetAllocation((const void*) buf1842);
+    *(float*)buf1843 = rsGetDt();
+    *(const void**)buf1844 = rsGetElementAt(*(rs_allocation*)buf1845, *(uint32_t*)buf1846);
+    *(const void**)buf1847 = rsGetElementAt(*(rs_allocation*)buf1848, *(uint32_t*)buf1849, *(uint32_t*)buf1850);
+    *(const void**)buf1851 = rsGetElementAt(*(rs_allocation*)buf1852, *(uint32_t*)buf1853, *(uint32_t*)buf1854, *(uint32_t*)buf1855);
+    *(float*)buf1856 = rsGetElementAt_float(*(rs_allocation*)buf1857, *(uint32_t*)buf1858);
+    *(float2*)buf1859 = rsGetElementAt_float2(*(rs_allocation*)buf1860, *(uint32_t*)buf1861);
+    *(float3*)buf1862 = rsGetElementAt_float3(*(rs_allocation*)buf1863, *(uint32_t*)buf1864);
+    *(float4*)buf1865 = rsGetElementAt_float4(*(rs_allocation*)buf1866, *(uint32_t*)buf1867);
+    *(double*)buf1868 = rsGetElementAt_double(*(rs_allocation*)buf1869, *(uint32_t*)buf1870);
+    *(double2*)buf1871 = rsGetElementAt_double2(*(rs_allocation*)buf1872, *(uint32_t*)buf1873);
+    *(double3*)buf1874 = rsGetElementAt_double3(*(rs_allocation*)buf1875, *(uint32_t*)buf1876);
+    *(double4*)buf1877 = rsGetElementAt_double4(*(rs_allocation*)buf1878, *(uint32_t*)buf1879);
+    *(char*)buf1880 = rsGetElementAt_char(*(rs_allocation*)buf1881, *(uint32_t*)buf1882);
+    *(char2*)buf1883 = rsGetElementAt_char2(*(rs_allocation*)buf1884, *(uint32_t*)buf1885);
+    *(char3*)buf1886 = rsGetElementAt_char3(*(rs_allocation*)buf1887, *(uint32_t*)buf1888);
+    *(char4*)buf1889 = rsGetElementAt_char4(*(rs_allocation*)buf1890, *(uint32_t*)buf1891);
+    *(uchar*)buf1892 = rsGetElementAt_uchar(*(rs_allocation*)buf1893, *(uint32_t*)buf1894);
+    *(uchar2*)buf1895 = rsGetElementAt_uchar2(*(rs_allocation*)buf1896, *(uint32_t*)buf1897);
+    *(uchar3*)buf1898 = rsGetElementAt_uchar3(*(rs_allocation*)buf1899, *(uint32_t*)buf1900);
+    *(uchar4*)buf1901 = rsGetElementAt_uchar4(*(rs_allocation*)buf1902, *(uint32_t*)buf1903);
+    *(short*)buf1904 = rsGetElementAt_short(*(rs_allocation*)buf1905, *(uint32_t*)buf1906);
+    *(short2*)buf1907 = rsGetElementAt_short2(*(rs_allocation*)buf1908, *(uint32_t*)buf1909);
+    *(short3*)buf1910 = rsGetElementAt_short3(*(rs_allocation*)buf1911, *(uint32_t*)buf1912);
+    *(short4*)buf1913 = rsGetElementAt_short4(*(rs_allocation*)buf1914, *(uint32_t*)buf1915);
+    *(ushort*)buf1916 = rsGetElementAt_ushort(*(rs_allocation*)buf1917, *(uint32_t*)buf1918);
+    *(ushort2*)buf1919 = rsGetElementAt_ushort2(*(rs_allocation*)buf1920, *(uint32_t*)buf1921);
+    *(ushort3*)buf1922 = rsGetElementAt_ushort3(*(rs_allocation*)buf1923, *(uint32_t*)buf1924);
+    *(ushort4*)buf1925 = rsGetElementAt_ushort4(*(rs_allocation*)buf1926, *(uint32_t*)buf1927);
+    *(int*)buf1928 = rsGetElementAt_int(*(rs_allocation*)buf1929, *(uint32_t*)buf1930);
+    *(int2*)buf1931 = rsGetElementAt_int2(*(rs_allocation*)buf1932, *(uint32_t*)buf1933);
+    *(int3*)buf1934 = rsGetElementAt_int3(*(rs_allocation*)buf1935, *(uint32_t*)buf1936);
+    *(int4*)buf1937 = rsGetElementAt_int4(*(rs_allocation*)buf1938, *(uint32_t*)buf1939);
+    *(uint*)buf1940 = rsGetElementAt_uint(*(rs_allocation*)buf1941, *(uint32_t*)buf1942);
+    *(uint2*)buf1943 = rsGetElementAt_uint2(*(rs_allocation*)buf1944, *(uint32_t*)buf1945);
+    *(uint3*)buf1946 = rsGetElementAt_uint3(*(rs_allocation*)buf1947, *(uint32_t*)buf1948);
+    *(uint4*)buf1949 = rsGetElementAt_uint4(*(rs_allocation*)buf1950, *(uint32_t*)buf1951);
+    *(long*)buf1952 = rsGetElementAt_long(*(rs_allocation*)buf1953, *(uint32_t*)buf1954);
+    *(long2*)buf1955 = rsGetElementAt_long2(*(rs_allocation*)buf1956, *(uint32_t*)buf1957);
+    *(long3*)buf1958 = rsGetElementAt_long3(*(rs_allocation*)buf1959, *(uint32_t*)buf1960);
+    *(long4*)buf1961 = rsGetElementAt_long4(*(rs_allocation*)buf1962, *(uint32_t*)buf1963);
+    *(ulong*)buf1964 = rsGetElementAt_ulong(*(rs_allocation*)buf1965, *(uint32_t*)buf1966);
+    *(ulong2*)buf1967 = rsGetElementAt_ulong2(*(rs_allocation*)buf1968, *(uint32_t*)buf1969);
+    *(ulong3*)buf1970 = rsGetElementAt_ulong3(*(rs_allocation*)buf1971, *(uint32_t*)buf1972);
+    *(ulong4*)buf1973 = rsGetElementAt_ulong4(*(rs_allocation*)buf1974, *(uint32_t*)buf1975);
+    *(float*)buf1976 = rsGetElementAt_float(*(rs_allocation*)buf1977, *(uint32_t*)buf1978, *(uint32_t*)buf1979);
+    *(float2*)buf1980 = rsGetElementAt_float2(*(rs_allocation*)buf1981, *(uint32_t*)buf1982, *(uint32_t*)buf1983);
+    *(float3*)buf1984 = rsGetElementAt_float3(*(rs_allocation*)buf1985, *(uint32_t*)buf1986, *(uint32_t*)buf1987);
+    *(float4*)buf1988 = rsGetElementAt_float4(*(rs_allocation*)buf1989, *(uint32_t*)buf1990, *(uint32_t*)buf1991);
+    *(double*)buf1992 = rsGetElementAt_double(*(rs_allocation*)buf1993, *(uint32_t*)buf1994, *(uint32_t*)buf1995);
+    *(double2*)buf1996 = rsGetElementAt_double2(*(rs_allocation*)buf1997, *(uint32_t*)buf1998, *(uint32_t*)buf1999);
+    *(double3*)buf2000 = rsGetElementAt_double3(*(rs_allocation*)buf2001, *(uint32_t*)buf2002, *(uint32_t*)buf2003);
+    *(double4*)buf2004 = rsGetElementAt_double4(*(rs_allocation*)buf2005, *(uint32_t*)buf2006, *(uint32_t*)buf2007);
+    *(char*)buf2008 = rsGetElementAt_char(*(rs_allocation*)buf2009, *(uint32_t*)buf2010, *(uint32_t*)buf2011);
+    *(char2*)buf2012 = rsGetElementAt_char2(*(rs_allocation*)buf2013, *(uint32_t*)buf2014, *(uint32_t*)buf2015);
+    *(char3*)buf2016 = rsGetElementAt_char3(*(rs_allocation*)buf2017, *(uint32_t*)buf2018, *(uint32_t*)buf2019);
+    *(char4*)buf2020 = rsGetElementAt_char4(*(rs_allocation*)buf2021, *(uint32_t*)buf2022, *(uint32_t*)buf2023);
+    *(uchar*)buf2024 = rsGetElementAt_uchar(*(rs_allocation*)buf2025, *(uint32_t*)buf2026, *(uint32_t*)buf2027);
+    *(uchar2*)buf2028 = rsGetElementAt_uchar2(*(rs_allocation*)buf2029, *(uint32_t*)buf2030, *(uint32_t*)buf2031);
+    *(uchar3*)buf2032 = rsGetElementAt_uchar3(*(rs_allocation*)buf2033, *(uint32_t*)buf2034, *(uint32_t*)buf2035);
+    *(uchar4*)buf2036 = rsGetElementAt_uchar4(*(rs_allocation*)buf2037, *(uint32_t*)buf2038, *(uint32_t*)buf2039);
+    *(short*)buf2040 = rsGetElementAt_short(*(rs_allocation*)buf2041, *(uint32_t*)buf2042, *(uint32_t*)buf2043);
+    *(short2*)buf2044 = rsGetElementAt_short2(*(rs_allocation*)buf2045, *(uint32_t*)buf2046, *(uint32_t*)buf2047);
+    *(short3*)buf2048 = rsGetElementAt_short3(*(rs_allocation*)buf2049, *(uint32_t*)buf2050, *(uint32_t*)buf2051);
+    *(short4*)buf2052 = rsGetElementAt_short4(*(rs_allocation*)buf2053, *(uint32_t*)buf2054, *(uint32_t*)buf2055);
+    *(ushort*)buf2056 = rsGetElementAt_ushort(*(rs_allocation*)buf2057, *(uint32_t*)buf2058, *(uint32_t*)buf2059);
+    *(ushort2*)buf2060 = rsGetElementAt_ushort2(*(rs_allocation*)buf2061, *(uint32_t*)buf2062, *(uint32_t*)buf2063);
+    *(ushort3*)buf2064 = rsGetElementAt_ushort3(*(rs_allocation*)buf2065, *(uint32_t*)buf2066, *(uint32_t*)buf2067);
+    *(ushort4*)buf2068 = rsGetElementAt_ushort4(*(rs_allocation*)buf2069, *(uint32_t*)buf2070, *(uint32_t*)buf2071);
+    *(int*)buf2072 = rsGetElementAt_int(*(rs_allocation*)buf2073, *(uint32_t*)buf2074, *(uint32_t*)buf2075);
+    *(int2*)buf2076 = rsGetElementAt_int2(*(rs_allocation*)buf2077, *(uint32_t*)buf2078, *(uint32_t*)buf2079);
+    *(int3*)buf2080 = rsGetElementAt_int3(*(rs_allocation*)buf2081, *(uint32_t*)buf2082, *(uint32_t*)buf2083);
+    *(int4*)buf2084 = rsGetElementAt_int4(*(rs_allocation*)buf2085, *(uint32_t*)buf2086, *(uint32_t*)buf2087);
+    *(uint*)buf2088 = rsGetElementAt_uint(*(rs_allocation*)buf2089, *(uint32_t*)buf2090, *(uint32_t*)buf2091);
+    *(uint2*)buf2092 = rsGetElementAt_uint2(*(rs_allocation*)buf2093, *(uint32_t*)buf2094, *(uint32_t*)buf2095);
+    *(uint3*)buf2096 = rsGetElementAt_uint3(*(rs_allocation*)buf2097, *(uint32_t*)buf2098, *(uint32_t*)buf2099);
+    *(uint4*)buf2100 = rsGetElementAt_uint4(*(rs_allocation*)buf2101, *(uint32_t*)buf2102, *(uint32_t*)buf2103);
+    *(long*)buf2104 = rsGetElementAt_long(*(rs_allocation*)buf2105, *(uint32_t*)buf2106, *(uint32_t*)buf2107);
+    *(long2*)buf2108 = rsGetElementAt_long2(*(rs_allocation*)buf2109, *(uint32_t*)buf2110, *(uint32_t*)buf2111);
+    *(long3*)buf2112 = rsGetElementAt_long3(*(rs_allocation*)buf2113, *(uint32_t*)buf2114, *(uint32_t*)buf2115);
+    *(long4*)buf2116 = rsGetElementAt_long4(*(rs_allocation*)buf2117, *(uint32_t*)buf2118, *(uint32_t*)buf2119);
+    *(ulong*)buf2120 = rsGetElementAt_ulong(*(rs_allocation*)buf2121, *(uint32_t*)buf2122, *(uint32_t*)buf2123);
+    *(ulong2*)buf2124 = rsGetElementAt_ulong2(*(rs_allocation*)buf2125, *(uint32_t*)buf2126, *(uint32_t*)buf2127);
+    *(ulong3*)buf2128 = rsGetElementAt_ulong3(*(rs_allocation*)buf2129, *(uint32_t*)buf2130, *(uint32_t*)buf2131);
+    *(ulong4*)buf2132 = rsGetElementAt_ulong4(*(rs_allocation*)buf2133, *(uint32_t*)buf2134, *(uint32_t*)buf2135);
+    *(float*)buf2136 = rsGetElementAt_float(*(rs_allocation*)buf2137, *(uint32_t*)buf2138, *(uint32_t*)buf2139, *(uint32_t*)buf2140);
+    *(float2*)buf2141 = rsGetElementAt_float2(*(rs_allocation*)buf2142, *(uint32_t*)buf2143, *(uint32_t*)buf2144, *(uint32_t*)buf2145);
+    *(float3*)buf2146 = rsGetElementAt_float3(*(rs_allocation*)buf2147, *(uint32_t*)buf2148, *(uint32_t*)buf2149, *(uint32_t*)buf2150);
+    *(float4*)buf2151 = rsGetElementAt_float4(*(rs_allocation*)buf2152, *(uint32_t*)buf2153, *(uint32_t*)buf2154, *(uint32_t*)buf2155);
+    *(double*)buf2156 = rsGetElementAt_double(*(rs_allocation*)buf2157, *(uint32_t*)buf2158, *(uint32_t*)buf2159, *(uint32_t*)buf2160);
+    *(double2*)buf2161 = rsGetElementAt_double2(*(rs_allocation*)buf2162, *(uint32_t*)buf2163, *(uint32_t*)buf2164, *(uint32_t*)buf2165);
+    *(double3*)buf2166 = rsGetElementAt_double3(*(rs_allocation*)buf2167, *(uint32_t*)buf2168, *(uint32_t*)buf2169, *(uint32_t*)buf2170);
+    *(double4*)buf2171 = rsGetElementAt_double4(*(rs_allocation*)buf2172, *(uint32_t*)buf2173, *(uint32_t*)buf2174, *(uint32_t*)buf2175);
+    *(char*)buf2176 = rsGetElementAt_char(*(rs_allocation*)buf2177, *(uint32_t*)buf2178, *(uint32_t*)buf2179, *(uint32_t*)buf2180);
+    *(char2*)buf2181 = rsGetElementAt_char2(*(rs_allocation*)buf2182, *(uint32_t*)buf2183, *(uint32_t*)buf2184, *(uint32_t*)buf2185);
+    *(char3*)buf2186 = rsGetElementAt_char3(*(rs_allocation*)buf2187, *(uint32_t*)buf2188, *(uint32_t*)buf2189, *(uint32_t*)buf2190);
+    *(char4*)buf2191 = rsGetElementAt_char4(*(rs_allocation*)buf2192, *(uint32_t*)buf2193, *(uint32_t*)buf2194, *(uint32_t*)buf2195);
+    *(uchar*)buf2196 = rsGetElementAt_uchar(*(rs_allocation*)buf2197, *(uint32_t*)buf2198, *(uint32_t*)buf2199, *(uint32_t*)buf2200);
+    *(uchar2*)buf2201 = rsGetElementAt_uchar2(*(rs_allocation*)buf2202, *(uint32_t*)buf2203, *(uint32_t*)buf2204, *(uint32_t*)buf2205);
+    *(uchar3*)buf2206 = rsGetElementAt_uchar3(*(rs_allocation*)buf2207, *(uint32_t*)buf2208, *(uint32_t*)buf2209, *(uint32_t*)buf2210);
+    *(uchar4*)buf2211 = rsGetElementAt_uchar4(*(rs_allocation*)buf2212, *(uint32_t*)buf2213, *(uint32_t*)buf2214, *(uint32_t*)buf2215);
+    *(short*)buf2216 = rsGetElementAt_short(*(rs_allocation*)buf2217, *(uint32_t*)buf2218, *(uint32_t*)buf2219, *(uint32_t*)buf2220);
+    *(short2*)buf2221 = rsGetElementAt_short2(*(rs_allocation*)buf2222, *(uint32_t*)buf2223, *(uint32_t*)buf2224, *(uint32_t*)buf2225);
+    *(short3*)buf2226 = rsGetElementAt_short3(*(rs_allocation*)buf2227, *(uint32_t*)buf2228, *(uint32_t*)buf2229, *(uint32_t*)buf2230);
+    *(short4*)buf2231 = rsGetElementAt_short4(*(rs_allocation*)buf2232, *(uint32_t*)buf2233, *(uint32_t*)buf2234, *(uint32_t*)buf2235);
+    *(ushort*)buf2236 = rsGetElementAt_ushort(*(rs_allocation*)buf2237, *(uint32_t*)buf2238, *(uint32_t*)buf2239, *(uint32_t*)buf2240);
+    *(ushort2*)buf2241 = rsGetElementAt_ushort2(*(rs_allocation*)buf2242, *(uint32_t*)buf2243, *(uint32_t*)buf2244, *(uint32_t*)buf2245);
+    *(ushort3*)buf2246 = rsGetElementAt_ushort3(*(rs_allocation*)buf2247, *(uint32_t*)buf2248, *(uint32_t*)buf2249, *(uint32_t*)buf2250);
+    *(ushort4*)buf2251 = rsGetElementAt_ushort4(*(rs_allocation*)buf2252, *(uint32_t*)buf2253, *(uint32_t*)buf2254, *(uint32_t*)buf2255);
+    *(int*)buf2256 = rsGetElementAt_int(*(rs_allocation*)buf2257, *(uint32_t*)buf2258, *(uint32_t*)buf2259, *(uint32_t*)buf2260);
+    *(int2*)buf2261 = rsGetElementAt_int2(*(rs_allocation*)buf2262, *(uint32_t*)buf2263, *(uint32_t*)buf2264, *(uint32_t*)buf2265);
+    *(int3*)buf2266 = rsGetElementAt_int3(*(rs_allocation*)buf2267, *(uint32_t*)buf2268, *(uint32_t*)buf2269, *(uint32_t*)buf2270);
+    *(int4*)buf2271 = rsGetElementAt_int4(*(rs_allocation*)buf2272, *(uint32_t*)buf2273, *(uint32_t*)buf2274, *(uint32_t*)buf2275);
+    *(uint*)buf2276 = rsGetElementAt_uint(*(rs_allocation*)buf2277, *(uint32_t*)buf2278, *(uint32_t*)buf2279, *(uint32_t*)buf2280);
+    *(uint2*)buf2281 = rsGetElementAt_uint2(*(rs_allocation*)buf2282, *(uint32_t*)buf2283, *(uint32_t*)buf2284, *(uint32_t*)buf2285);
+    *(uint3*)buf2286 = rsGetElementAt_uint3(*(rs_allocation*)buf2287, *(uint32_t*)buf2288, *(uint32_t*)buf2289, *(uint32_t*)buf2290);
+    *(uint4*)buf2291 = rsGetElementAt_uint4(*(rs_allocation*)buf2292, *(uint32_t*)buf2293, *(uint32_t*)buf2294, *(uint32_t*)buf2295);
+    *(long*)buf2296 = rsGetElementAt_long(*(rs_allocation*)buf2297, *(uint32_t*)buf2298, *(uint32_t*)buf2299, *(uint32_t*)buf2300);
+    *(long2*)buf2301 = rsGetElementAt_long2(*(rs_allocation*)buf2302, *(uint32_t*)buf2303, *(uint32_t*)buf2304, *(uint32_t*)buf2305);
+    *(long3*)buf2306 = rsGetElementAt_long3(*(rs_allocation*)buf2307, *(uint32_t*)buf2308, *(uint32_t*)buf2309, *(uint32_t*)buf2310);
+    *(long4*)buf2311 = rsGetElementAt_long4(*(rs_allocation*)buf2312, *(uint32_t*)buf2313, *(uint32_t*)buf2314, *(uint32_t*)buf2315);
+    *(ulong*)buf2316 = rsGetElementAt_ulong(*(rs_allocation*)buf2317, *(uint32_t*)buf2318, *(uint32_t*)buf2319, *(uint32_t*)buf2320);
+    *(ulong2*)buf2321 = rsGetElementAt_ulong2(*(rs_allocation*)buf2322, *(uint32_t*)buf2323, *(uint32_t*)buf2324, *(uint32_t*)buf2325);
+    *(ulong3*)buf2326 = rsGetElementAt_ulong3(*(rs_allocation*)buf2327, *(uint32_t*)buf2328, *(uint32_t*)buf2329, *(uint32_t*)buf2330);
+    *(ulong4*)buf2331 = rsGetElementAt_ulong4(*(rs_allocation*)buf2332, *(uint32_t*)buf2333, *(uint32_t*)buf2334, *(uint32_t*)buf2335);
+    *(uchar*)buf2336 = rsGetElementAtYuv_uchar_U(*(rs_allocation*)buf2337, *(uint32_t*)buf2338, *(uint32_t*)buf2339);
+    *(uchar*)buf2340 = rsGetElementAtYuv_uchar_V(*(rs_allocation*)buf2341, *(uint32_t*)buf2342, *(uint32_t*)buf2343);
+    *(uchar*)buf2344 = rsGetElementAtYuv_uchar_Y(*(rs_allocation*)buf2345, *(uint32_t*)buf2346, *(uint32_t*)buf2347);
+    *(bool*)buf2348 = rsIsObject(*(rs_element*)buf2349);
+    *(bool*)buf2350 = rsIsObject(*(rs_type*)buf2351);
+    *(bool*)buf2352 = rsIsObject(*(rs_allocation*)buf2353);
+    *(bool*)buf2354 = rsIsObject(*(rs_sampler*)buf2355);
+    *(bool*)buf2356 = rsIsObject(*(rs_script*)buf2357);
 #ifndef __LP64__
-    *(bool*)buf2340 = rsIsObject(*(rs_mesh*)buf2341);
-    *(bool*)buf2342 = rsIsObject(*(rs_program_fragment*)buf2343);
-    *(bool*)buf2344 = rsIsObject(*(rs_program_vertex*)buf2345);
-    *(bool*)buf2346 = rsIsObject(*(rs_program_raster*)buf2347);
-    *(bool*)buf2348 = rsIsObject(*(rs_program_store*)buf2349);
-    *(bool*)buf2350 = rsIsObject(*(rs_font*)buf2351);
+    *(bool*)buf2358 = rsIsObject(*(rs_mesh*)buf2359);
+    *(bool*)buf2360 = rsIsObject(*(rs_program_fragment*)buf2361);
+    *(bool*)buf2362 = rsIsObject(*(rs_program_vertex*)buf2363);
+    *(bool*)buf2364 = rsIsObject(*(rs_program_raster*)buf2365);
+    *(bool*)buf2366 = rsIsObject(*(rs_program_store*)buf2367);
+    *(bool*)buf2368 = rsIsObject(*(rs_font*)buf2369);
 #endif
-    *(bool*)buf2352 = rsIsSphereInFrustum((float4*) buf2353, (float4*) buf2354, (float4*) buf2355, (float4*) buf2356, (float4*) buf2357, (float4*) buf2358, (float4*) buf2359);
-    *(rs_tm**)buf2360 = rsLocaltime((rs_tm*) buf2361, (const rs_time_t*) buf2362);
-    *(float*)buf2363 = rsMatrixGet((const rs_matrix4x4*) buf2364, *(uint32_t*)buf2365, *(uint32_t*)buf2366);
-    *(float*)buf2367 = rsMatrixGet((const rs_matrix3x3*) buf2368, *(uint32_t*)buf2369, *(uint32_t*)buf2370);
-    *(float*)buf2371 = rsMatrixGet((const rs_matrix2x2*) buf2372, *(uint32_t*)buf2373, *(uint32_t*)buf2374);
-    *(bool*)buf2375 = rsMatrixInverse((rs_matrix4x4*) buf2376);
-    *(bool*)buf2377 = rsMatrixInverseTranspose((rs_matrix4x4*) buf2378);
-    rsMatrixLoad((rs_matrix4x4*) buf2379, (const float*) buf2380);
-    rsMatrixLoad((rs_matrix3x3*) buf2381, (const float*) buf2382);
-    rsMatrixLoad((rs_matrix2x2*) buf2383, (const float*) buf2384);
-    rsMatrixLoad((rs_matrix4x4*) buf2385, (const rs_matrix4x4*) buf2386);
-    rsMatrixLoad((rs_matrix3x3*) buf2387, (const rs_matrix3x3*) buf2388);
-    rsMatrixLoad((rs_matrix2x2*) buf2389, (const rs_matrix2x2*) buf2390);
-    rsMatrixLoad((rs_matrix4x4*) buf2391, (const rs_matrix3x3*) buf2392);
-    rsMatrixLoad((rs_matrix4x4*) buf2393, (const rs_matrix2x2*) buf2394);
-    rsMatrixLoadFrustum((rs_matrix4x4*) buf2395, *(float*)buf2396, *(float*)buf2397, *(float*)buf2398, *(float*)buf2399, *(float*)buf2400, *(float*)buf2401);
-    rsMatrixLoadIdentity((rs_matrix4x4*) buf2402);
-    rsMatrixLoadIdentity((rs_matrix3x3*) buf2403);
-    rsMatrixLoadIdentity((rs_matrix2x2*) buf2404);
-    rsMatrixLoadMultiply((rs_matrix4x4*) buf2405, (const rs_matrix4x4*) buf2406, (const rs_matrix4x4*) buf2407);
-    rsMatrixLoadMultiply((rs_matrix3x3*) buf2408, (const rs_matrix3x3*) buf2409, (const rs_matrix3x3*) buf2410);
-    rsMatrixLoadMultiply((rs_matrix2x2*) buf2411, (const rs_matrix2x2*) buf2412, (const rs_matrix2x2*) buf2413);
-    rsMatrixLoadOrtho((rs_matrix4x4*) buf2414, *(float*)buf2415, *(float*)buf2416, *(float*)buf2417, *(float*)buf2418, *(float*)buf2419, *(float*)buf2420);
-    rsMatrixLoadPerspective((rs_matrix4x4*) buf2421, *(float*)buf2422, *(float*)buf2423, *(float*)buf2424, *(float*)buf2425);
-    rsMatrixLoadRotate((rs_matrix4x4*) buf2426, *(float*)buf2427, *(float*)buf2428, *(float*)buf2429, *(float*)buf2430);
-    rsMatrixLoadScale((rs_matrix4x4*) buf2431, *(float*)buf2432, *(float*)buf2433, *(float*)buf2434);
-    rsMatrixLoadTranslate((rs_matrix4x4*) buf2435, *(float*)buf2436, *(float*)buf2437, *(float*)buf2438);
-    rsMatrixMultiply((rs_matrix4x4*) buf2439, (const rs_matrix4x4*) buf2440);
-    rsMatrixMultiply((rs_matrix3x3*) buf2441, (const rs_matrix3x3*) buf2442);
-    rsMatrixMultiply((rs_matrix2x2*) buf2443, (const rs_matrix2x2*) buf2444);
-    *(float4*)buf2445 = rsMatrixMultiply((const rs_matrix4x4*) buf2446, *(float4*)buf2447);
-    *(float4*)buf2448 = rsMatrixMultiply((const rs_matrix4x4*) buf2449, *(float3*)buf2450);
-    *(float4*)buf2451 = rsMatrixMultiply((const rs_matrix4x4*) buf2452, *(float2*)buf2453);
-    *(float3*)buf2454 = rsMatrixMultiply((const rs_matrix3x3*) buf2455, *(float3*)buf2456);
-    *(float3*)buf2457 = rsMatrixMultiply((const rs_matrix3x3*) buf2458, *(float2*)buf2459);
-    *(float2*)buf2460 = rsMatrixMultiply((const rs_matrix2x2*) buf2461, *(float2*)buf2462);
-    rsMatrixRotate((rs_matrix4x4*) buf2463, *(float*)buf2464, *(float*)buf2465, *(float*)buf2466, *(float*)buf2467);
-    rsMatrixScale((rs_matrix4x4*) buf2468, *(float*)buf2469, *(float*)buf2470, *(float*)buf2471);
-    rsMatrixSet((rs_matrix4x4*) buf2472, *(uint32_t*)buf2473, *(uint32_t*)buf2474, *(float*)buf2475);
-    rsMatrixSet((rs_matrix3x3*) buf2476, *(uint32_t*)buf2477, *(uint32_t*)buf2478, *(float*)buf2479);
-    rsMatrixSet((rs_matrix2x2*) buf2480, *(uint32_t*)buf2481, *(uint32_t*)buf2482, *(float*)buf2483);
-    rsMatrixTranslate((rs_matrix4x4*) buf2484, *(float*)buf2485, *(float*)buf2486, *(float*)buf2487);
-    rsMatrixTranspose((rs_matrix4x4*) buf2488);
-    rsMatrixTranspose((rs_matrix3x3*) buf2489);
-    rsMatrixTranspose((rs_matrix2x2*) buf2490);
-    *(uchar4*)buf2491 = rsPackColorTo8888(*(float*)buf2492, *(float*)buf2493, *(float*)buf2494);
-    *(uchar4*)buf2495 = rsPackColorTo8888(*(float*)buf2496, *(float*)buf2497, *(float*)buf2498, *(float*)buf2499);
-    *(uchar4*)buf2500 = rsPackColorTo8888(*(float3*)buf2501);
-    *(uchar4*)buf2502 = rsPackColorTo8888(*(float4*)buf2503);
-    rsQuaternionAdd((rs_quaternion*) buf2504, (const rs_quaternion*) buf2505);
-    rsQuaternionConjugate((rs_quaternion*) buf2506);
-    *(float*)buf2507 = rsQuaternionDot((const rs_quaternion*) buf2508, (const rs_quaternion*) buf2509);
-    rsQuaternionGetMatrixUnit((rs_matrix4x4*) buf2510, (const rs_quaternion*) buf2511);
-    rsQuaternionLoadRotate((rs_quaternion*) buf2512, *(float*)buf2513, *(float*)buf2514, *(float*)buf2515, *(float*)buf2516);
-    rsQuaternionLoadRotateUnit((rs_quaternion*) buf2517, *(float*)buf2518, *(float*)buf2519, *(float*)buf2520, *(float*)buf2521);
-    rsQuaternionMultiply((rs_quaternion*) buf2522, *(float*)buf2523);
-    rsQuaternionMultiply((rs_quaternion*) buf2524, (const rs_quaternion*) buf2525);
-    rsQuaternionNormalize((rs_quaternion*) buf2526);
-    rsQuaternionSet((rs_quaternion*) buf2527, *(float*)buf2528, *(float*)buf2529, *(float*)buf2530, *(float*)buf2531);
-    rsQuaternionSet((rs_quaternion*) buf2532, (const rs_quaternion*) buf2533);
-    rsQuaternionSlerp((rs_quaternion*) buf2534, (const rs_quaternion*) buf2535, (const rs_quaternion*) buf2536, *(float*)buf2537);
-    *(int*)buf2538 = rsRand(*(int*)buf2539);
-    *(int*)buf2540 = rsRand(*(int*)buf2541, *(int*)buf2542);
-    *(float*)buf2543 = rsRand(*(float*)buf2544);
-    *(float*)buf2545 = rsRand(*(float*)buf2546, *(float*)buf2547);
-    *(float4*)buf2548 = rsSample(*(rs_allocation*)buf2549, *(rs_sampler*)buf2550, *(float*)buf2551);
-    *(float4*)buf2552 = rsSample(*(rs_allocation*)buf2553, *(rs_sampler*)buf2554, *(float*)buf2555, *(float*)buf2556);
-    *(float4*)buf2557 = rsSample(*(rs_allocation*)buf2558, *(rs_sampler*)buf2559, *(float2*)buf2560);
-    *(float4*)buf2561 = rsSample(*(rs_allocation*)buf2562, *(rs_sampler*)buf2563, *(float2*)buf2564, *(float*)buf2565);
-    *(float*)buf2566 = rsSamplerGetAnisotropy(*(rs_sampler*)buf2567);
-    *(rs_sampler_value*)buf2568 = rsSamplerGetMagnification(*(rs_sampler*)buf2569);
-    *(rs_sampler_value*)buf2570 = rsSamplerGetMinification(*(rs_sampler*)buf2571);
-    *(rs_sampler_value*)buf2572 = rsSamplerGetWrapS(*(rs_sampler*)buf2573);
-    *(rs_sampler_value*)buf2574 = rsSamplerGetWrapT(*(rs_sampler*)buf2575);
-    *(bool*)buf2576 = rsSendToClient(*(int*)buf2577);
-    *(bool*)buf2578 = rsSendToClient(*(int*)buf2579, (const void*) buf2580, *(uint*)buf2581);
-    rsSendToClientBlocking(*(int*)buf2582);
-    rsSendToClientBlocking(*(int*)buf2583, (const void*) buf2584, *(uint*)buf2585);
-    rsSetElementAt(*(rs_allocation*)buf2586, (void*) buf2587, *(uint32_t*)buf2588);
-    rsSetElementAt(*(rs_allocation*)buf2589, (void*) buf2590, *(uint32_t*)buf2591, *(uint32_t*)buf2592);
-    rsSetElementAt_float(*(rs_allocation*)buf2593, *(float*)buf2594, *(uint32_t*)buf2595);
-    rsSetElementAt_float2(*(rs_allocation*)buf2596, *(float2*)buf2597, *(uint32_t*)buf2598);
-    rsSetElementAt_float3(*(rs_allocation*)buf2599, *(float3*)buf2600, *(uint32_t*)buf2601);
-    rsSetElementAt_float4(*(rs_allocation*)buf2602, *(float4*)buf2603, *(uint32_t*)buf2604);
-    rsSetElementAt_double(*(rs_allocation*)buf2605, *(double*)buf2606, *(uint32_t*)buf2607);
-    rsSetElementAt_double2(*(rs_allocation*)buf2608, *(double2*)buf2609, *(uint32_t*)buf2610);
-    rsSetElementAt_double3(*(rs_allocation*)buf2611, *(double3*)buf2612, *(uint32_t*)buf2613);
-    rsSetElementAt_double4(*(rs_allocation*)buf2614, *(double4*)buf2615, *(uint32_t*)buf2616);
-    rsSetElementAt_char(*(rs_allocation*)buf2617, *(char*)buf2618, *(uint32_t*)buf2619);
-    rsSetElementAt_char2(*(rs_allocation*)buf2620, *(char2*)buf2621, *(uint32_t*)buf2622);
-    rsSetElementAt_char3(*(rs_allocation*)buf2623, *(char3*)buf2624, *(uint32_t*)buf2625);
-    rsSetElementAt_char4(*(rs_allocation*)buf2626, *(char4*)buf2627, *(uint32_t*)buf2628);
-    rsSetElementAt_uchar(*(rs_allocation*)buf2629, *(uchar*)buf2630, *(uint32_t*)buf2631);
-    rsSetElementAt_uchar2(*(rs_allocation*)buf2632, *(uchar2*)buf2633, *(uint32_t*)buf2634);
-    rsSetElementAt_uchar3(*(rs_allocation*)buf2635, *(uchar3*)buf2636, *(uint32_t*)buf2637);
-    rsSetElementAt_uchar4(*(rs_allocation*)buf2638, *(uchar4*)buf2639, *(uint32_t*)buf2640);
-    rsSetElementAt_short(*(rs_allocation*)buf2641, *(short*)buf2642, *(uint32_t*)buf2643);
-    rsSetElementAt_short2(*(rs_allocation*)buf2644, *(short2*)buf2645, *(uint32_t*)buf2646);
-    rsSetElementAt_short3(*(rs_allocation*)buf2647, *(short3*)buf2648, *(uint32_t*)buf2649);
-    rsSetElementAt_short4(*(rs_allocation*)buf2650, *(short4*)buf2651, *(uint32_t*)buf2652);
-    rsSetElementAt_ushort(*(rs_allocation*)buf2653, *(ushort*)buf2654, *(uint32_t*)buf2655);
-    rsSetElementAt_ushort2(*(rs_allocation*)buf2656, *(ushort2*)buf2657, *(uint32_t*)buf2658);
-    rsSetElementAt_ushort3(*(rs_allocation*)buf2659, *(ushort3*)buf2660, *(uint32_t*)buf2661);
-    rsSetElementAt_ushort4(*(rs_allocation*)buf2662, *(ushort4*)buf2663, *(uint32_t*)buf2664);
-    rsSetElementAt_int(*(rs_allocation*)buf2665, *(int*)buf2666, *(uint32_t*)buf2667);
-    rsSetElementAt_int2(*(rs_allocation*)buf2668, *(int2*)buf2669, *(uint32_t*)buf2670);
-    rsSetElementAt_int3(*(rs_allocation*)buf2671, *(int3*)buf2672, *(uint32_t*)buf2673);
-    rsSetElementAt_int4(*(rs_allocation*)buf2674, *(int4*)buf2675, *(uint32_t*)buf2676);
-    rsSetElementAt_uint(*(rs_allocation*)buf2677, *(uint*)buf2678, *(uint32_t*)buf2679);
-    rsSetElementAt_uint2(*(rs_allocation*)buf2680, *(uint2*)buf2681, *(uint32_t*)buf2682);
-    rsSetElementAt_uint3(*(rs_allocation*)buf2683, *(uint3*)buf2684, *(uint32_t*)buf2685);
-    rsSetElementAt_uint4(*(rs_allocation*)buf2686, *(uint4*)buf2687, *(uint32_t*)buf2688);
-    rsSetElementAt_long(*(rs_allocation*)buf2689, *(long*)buf2690, *(uint32_t*)buf2691);
-    rsSetElementAt_long2(*(rs_allocation*)buf2692, *(long2*)buf2693, *(uint32_t*)buf2694);
-    rsSetElementAt_long3(*(rs_allocation*)buf2695, *(long3*)buf2696, *(uint32_t*)buf2697);
-    rsSetElementAt_long4(*(rs_allocation*)buf2698, *(long4*)buf2699, *(uint32_t*)buf2700);
-    rsSetElementAt_ulong(*(rs_allocation*)buf2701, *(ulong*)buf2702, *(uint32_t*)buf2703);
-    rsSetElementAt_ulong2(*(rs_allocation*)buf2704, *(ulong2*)buf2705, *(uint32_t*)buf2706);
-    rsSetElementAt_ulong3(*(rs_allocation*)buf2707, *(ulong3*)buf2708, *(uint32_t*)buf2709);
-    rsSetElementAt_ulong4(*(rs_allocation*)buf2710, *(ulong4*)buf2711, *(uint32_t*)buf2712);
-    rsSetElementAt_float(*(rs_allocation*)buf2713, *(float*)buf2714, *(uint32_t*)buf2715, *(uint32_t*)buf2716);
-    rsSetElementAt_float2(*(rs_allocation*)buf2717, *(float2*)buf2718, *(uint32_t*)buf2719, *(uint32_t*)buf2720);
-    rsSetElementAt_float3(*(rs_allocation*)buf2721, *(float3*)buf2722, *(uint32_t*)buf2723, *(uint32_t*)buf2724);
-    rsSetElementAt_float4(*(rs_allocation*)buf2725, *(float4*)buf2726, *(uint32_t*)buf2727, *(uint32_t*)buf2728);
-    rsSetElementAt_double(*(rs_allocation*)buf2729, *(double*)buf2730, *(uint32_t*)buf2731, *(uint32_t*)buf2732);
-    rsSetElementAt_double2(*(rs_allocation*)buf2733, *(double2*)buf2734, *(uint32_t*)buf2735, *(uint32_t*)buf2736);
-    rsSetElementAt_double3(*(rs_allocation*)buf2737, *(double3*)buf2738, *(uint32_t*)buf2739, *(uint32_t*)buf2740);
-    rsSetElementAt_double4(*(rs_allocation*)buf2741, *(double4*)buf2742, *(uint32_t*)buf2743, *(uint32_t*)buf2744);
-    rsSetElementAt_char(*(rs_allocation*)buf2745, *(char*)buf2746, *(uint32_t*)buf2747, *(uint32_t*)buf2748);
-    rsSetElementAt_char2(*(rs_allocation*)buf2749, *(char2*)buf2750, *(uint32_t*)buf2751, *(uint32_t*)buf2752);
-    rsSetElementAt_char3(*(rs_allocation*)buf2753, *(char3*)buf2754, *(uint32_t*)buf2755, *(uint32_t*)buf2756);
-    rsSetElementAt_char4(*(rs_allocation*)buf2757, *(char4*)buf2758, *(uint32_t*)buf2759, *(uint32_t*)buf2760);
-    rsSetElementAt_uchar(*(rs_allocation*)buf2761, *(uchar*)buf2762, *(uint32_t*)buf2763, *(uint32_t*)buf2764);
-    rsSetElementAt_uchar2(*(rs_allocation*)buf2765, *(uchar2*)buf2766, *(uint32_t*)buf2767, *(uint32_t*)buf2768);
-    rsSetElementAt_uchar3(*(rs_allocation*)buf2769, *(uchar3*)buf2770, *(uint32_t*)buf2771, *(uint32_t*)buf2772);
-    rsSetElementAt_uchar4(*(rs_allocation*)buf2773, *(uchar4*)buf2774, *(uint32_t*)buf2775, *(uint32_t*)buf2776);
-    rsSetElementAt_short(*(rs_allocation*)buf2777, *(short*)buf2778, *(uint32_t*)buf2779, *(uint32_t*)buf2780);
-    rsSetElementAt_short2(*(rs_allocation*)buf2781, *(short2*)buf2782, *(uint32_t*)buf2783, *(uint32_t*)buf2784);
-    rsSetElementAt_short3(*(rs_allocation*)buf2785, *(short3*)buf2786, *(uint32_t*)buf2787, *(uint32_t*)buf2788);
-    rsSetElementAt_short4(*(rs_allocation*)buf2789, *(short4*)buf2790, *(uint32_t*)buf2791, *(uint32_t*)buf2792);
-    rsSetElementAt_ushort(*(rs_allocation*)buf2793, *(ushort*)buf2794, *(uint32_t*)buf2795, *(uint32_t*)buf2796);
-    rsSetElementAt_ushort2(*(rs_allocation*)buf2797, *(ushort2*)buf2798, *(uint32_t*)buf2799, *(uint32_t*)buf2800);
-    rsSetElementAt_ushort3(*(rs_allocation*)buf2801, *(ushort3*)buf2802, *(uint32_t*)buf2803, *(uint32_t*)buf2804);
-    rsSetElementAt_ushort4(*(rs_allocation*)buf2805, *(ushort4*)buf2806, *(uint32_t*)buf2807, *(uint32_t*)buf2808);
-    rsSetElementAt_int(*(rs_allocation*)buf2809, *(int*)buf2810, *(uint32_t*)buf2811, *(uint32_t*)buf2812);
-    rsSetElementAt_int2(*(rs_allocation*)buf2813, *(int2*)buf2814, *(uint32_t*)buf2815, *(uint32_t*)buf2816);
-    rsSetElementAt_int3(*(rs_allocation*)buf2817, *(int3*)buf2818, *(uint32_t*)buf2819, *(uint32_t*)buf2820);
-    rsSetElementAt_int4(*(rs_allocation*)buf2821, *(int4*)buf2822, *(uint32_t*)buf2823, *(uint32_t*)buf2824);
-    rsSetElementAt_uint(*(rs_allocation*)buf2825, *(uint*)buf2826, *(uint32_t*)buf2827, *(uint32_t*)buf2828);
-    rsSetElementAt_uint2(*(rs_allocation*)buf2829, *(uint2*)buf2830, *(uint32_t*)buf2831, *(uint32_t*)buf2832);
-    rsSetElementAt_uint3(*(rs_allocation*)buf2833, *(uint3*)buf2834, *(uint32_t*)buf2835, *(uint32_t*)buf2836);
-    rsSetElementAt_uint4(*(rs_allocation*)buf2837, *(uint4*)buf2838, *(uint32_t*)buf2839, *(uint32_t*)buf2840);
-    rsSetElementAt_long(*(rs_allocation*)buf2841, *(long*)buf2842, *(uint32_t*)buf2843, *(uint32_t*)buf2844);
-    rsSetElementAt_long2(*(rs_allocation*)buf2845, *(long2*)buf2846, *(uint32_t*)buf2847, *(uint32_t*)buf2848);
-    rsSetElementAt_long3(*(rs_allocation*)buf2849, *(long3*)buf2850, *(uint32_t*)buf2851, *(uint32_t*)buf2852);
-    rsSetElementAt_long4(*(rs_allocation*)buf2853, *(long4*)buf2854, *(uint32_t*)buf2855, *(uint32_t*)buf2856);
-    rsSetElementAt_ulong(*(rs_allocation*)buf2857, *(ulong*)buf2858, *(uint32_t*)buf2859, *(uint32_t*)buf2860);
-    rsSetElementAt_ulong2(*(rs_allocation*)buf2861, *(ulong2*)buf2862, *(uint32_t*)buf2863, *(uint32_t*)buf2864);
-    rsSetElementAt_ulong3(*(rs_allocation*)buf2865, *(ulong3*)buf2866, *(uint32_t*)buf2867, *(uint32_t*)buf2868);
-    rsSetElementAt_ulong4(*(rs_allocation*)buf2869, *(ulong4*)buf2870, *(uint32_t*)buf2871, *(uint32_t*)buf2872);
-    rsSetElementAt_float(*(rs_allocation*)buf2873, *(float*)buf2874, *(uint32_t*)buf2875, *(uint32_t*)buf2876, *(uint32_t*)buf2877);
-    rsSetElementAt_float2(*(rs_allocation*)buf2878, *(float2*)buf2879, *(uint32_t*)buf2880, *(uint32_t*)buf2881, *(uint32_t*)buf2882);
-    rsSetElementAt_float3(*(rs_allocation*)buf2883, *(float3*)buf2884, *(uint32_t*)buf2885, *(uint32_t*)buf2886, *(uint32_t*)buf2887);
-    rsSetElementAt_float4(*(rs_allocation*)buf2888, *(float4*)buf2889, *(uint32_t*)buf2890, *(uint32_t*)buf2891, *(uint32_t*)buf2892);
-    rsSetElementAt_double(*(rs_allocation*)buf2893, *(double*)buf2894, *(uint32_t*)buf2895, *(uint32_t*)buf2896, *(uint32_t*)buf2897);
-    rsSetElementAt_double2(*(rs_allocation*)buf2898, *(double2*)buf2899, *(uint32_t*)buf2900, *(uint32_t*)buf2901, *(uint32_t*)buf2902);
-    rsSetElementAt_double3(*(rs_allocation*)buf2903, *(double3*)buf2904, *(uint32_t*)buf2905, *(uint32_t*)buf2906, *(uint32_t*)buf2907);
-    rsSetElementAt_double4(*(rs_allocation*)buf2908, *(double4*)buf2909, *(uint32_t*)buf2910, *(uint32_t*)buf2911, *(uint32_t*)buf2912);
-    rsSetElementAt_char(*(rs_allocation*)buf2913, *(char*)buf2914, *(uint32_t*)buf2915, *(uint32_t*)buf2916, *(uint32_t*)buf2917);
-    rsSetElementAt_char2(*(rs_allocation*)buf2918, *(char2*)buf2919, *(uint32_t*)buf2920, *(uint32_t*)buf2921, *(uint32_t*)buf2922);
-    rsSetElementAt_char3(*(rs_allocation*)buf2923, *(char3*)buf2924, *(uint32_t*)buf2925, *(uint32_t*)buf2926, *(uint32_t*)buf2927);
-    rsSetElementAt_char4(*(rs_allocation*)buf2928, *(char4*)buf2929, *(uint32_t*)buf2930, *(uint32_t*)buf2931, *(uint32_t*)buf2932);
-    rsSetElementAt_uchar(*(rs_allocation*)buf2933, *(uchar*)buf2934, *(uint32_t*)buf2935, *(uint32_t*)buf2936, *(uint32_t*)buf2937);
-    rsSetElementAt_uchar2(*(rs_allocation*)buf2938, *(uchar2*)buf2939, *(uint32_t*)buf2940, *(uint32_t*)buf2941, *(uint32_t*)buf2942);
-    rsSetElementAt_uchar3(*(rs_allocation*)buf2943, *(uchar3*)buf2944, *(uint32_t*)buf2945, *(uint32_t*)buf2946, *(uint32_t*)buf2947);
-    rsSetElementAt_uchar4(*(rs_allocation*)buf2948, *(uchar4*)buf2949, *(uint32_t*)buf2950, *(uint32_t*)buf2951, *(uint32_t*)buf2952);
-    rsSetElementAt_short(*(rs_allocation*)buf2953, *(short*)buf2954, *(uint32_t*)buf2955, *(uint32_t*)buf2956, *(uint32_t*)buf2957);
-    rsSetElementAt_short2(*(rs_allocation*)buf2958, *(short2*)buf2959, *(uint32_t*)buf2960, *(uint32_t*)buf2961, *(uint32_t*)buf2962);
-    rsSetElementAt_short3(*(rs_allocation*)buf2963, *(short3*)buf2964, *(uint32_t*)buf2965, *(uint32_t*)buf2966, *(uint32_t*)buf2967);
-    rsSetElementAt_short4(*(rs_allocation*)buf2968, *(short4*)buf2969, *(uint32_t*)buf2970, *(uint32_t*)buf2971, *(uint32_t*)buf2972);
-    rsSetElementAt_ushort(*(rs_allocation*)buf2973, *(ushort*)buf2974, *(uint32_t*)buf2975, *(uint32_t*)buf2976, *(uint32_t*)buf2977);
-    rsSetElementAt_ushort2(*(rs_allocation*)buf2978, *(ushort2*)buf2979, *(uint32_t*)buf2980, *(uint32_t*)buf2981, *(uint32_t*)buf2982);
-    rsSetElementAt_ushort3(*(rs_allocation*)buf2983, *(ushort3*)buf2984, *(uint32_t*)buf2985, *(uint32_t*)buf2986, *(uint32_t*)buf2987);
-    rsSetElementAt_ushort4(*(rs_allocation*)buf2988, *(ushort4*)buf2989, *(uint32_t*)buf2990, *(uint32_t*)buf2991, *(uint32_t*)buf2992);
-    rsSetElementAt_int(*(rs_allocation*)buf2993, *(int*)buf2994, *(uint32_t*)buf2995, *(uint32_t*)buf2996, *(uint32_t*)buf2997);
-    rsSetElementAt_int2(*(rs_allocation*)buf2998, *(int2*)buf2999, *(uint32_t*)buf3000, *(uint32_t*)buf3001, *(uint32_t*)buf3002);
-    rsSetElementAt_int3(*(rs_allocation*)buf3003, *(int3*)buf3004, *(uint32_t*)buf3005, *(uint32_t*)buf3006, *(uint32_t*)buf3007);
-    rsSetElementAt_int4(*(rs_allocation*)buf3008, *(int4*)buf3009, *(uint32_t*)buf3010, *(uint32_t*)buf3011, *(uint32_t*)buf3012);
-    rsSetElementAt_uint(*(rs_allocation*)buf3013, *(uint*)buf3014, *(uint32_t*)buf3015, *(uint32_t*)buf3016, *(uint32_t*)buf3017);
-    rsSetElementAt_uint2(*(rs_allocation*)buf3018, *(uint2*)buf3019, *(uint32_t*)buf3020, *(uint32_t*)buf3021, *(uint32_t*)buf3022);
-    rsSetElementAt_uint3(*(rs_allocation*)buf3023, *(uint3*)buf3024, *(uint32_t*)buf3025, *(uint32_t*)buf3026, *(uint32_t*)buf3027);
-    rsSetElementAt_uint4(*(rs_allocation*)buf3028, *(uint4*)buf3029, *(uint32_t*)buf3030, *(uint32_t*)buf3031, *(uint32_t*)buf3032);
-    rsSetElementAt_long(*(rs_allocation*)buf3033, *(long*)buf3034, *(uint32_t*)buf3035, *(uint32_t*)buf3036, *(uint32_t*)buf3037);
-    rsSetElementAt_long2(*(rs_allocation*)buf3038, *(long2*)buf3039, *(uint32_t*)buf3040, *(uint32_t*)buf3041, *(uint32_t*)buf3042);
-    rsSetElementAt_long3(*(rs_allocation*)buf3043, *(long3*)buf3044, *(uint32_t*)buf3045, *(uint32_t*)buf3046, *(uint32_t*)buf3047);
-    rsSetElementAt_long4(*(rs_allocation*)buf3048, *(long4*)buf3049, *(uint32_t*)buf3050, *(uint32_t*)buf3051, *(uint32_t*)buf3052);
-    rsSetElementAt_ulong(*(rs_allocation*)buf3053, *(ulong*)buf3054, *(uint32_t*)buf3055, *(uint32_t*)buf3056, *(uint32_t*)buf3057);
-    rsSetElementAt_ulong2(*(rs_allocation*)buf3058, *(ulong2*)buf3059, *(uint32_t*)buf3060, *(uint32_t*)buf3061, *(uint32_t*)buf3062);
-    rsSetElementAt_ulong3(*(rs_allocation*)buf3063, *(ulong3*)buf3064, *(uint32_t*)buf3065, *(uint32_t*)buf3066, *(uint32_t*)buf3067);
-    rsSetElementAt_ulong4(*(rs_allocation*)buf3068, *(ulong4*)buf3069, *(uint32_t*)buf3070, *(uint32_t*)buf3071, *(uint32_t*)buf3072);
-    rsSetObject((rs_element*) buf3073, *(rs_element*)buf3074);
-    rsSetObject((rs_type*) buf3075, *(rs_type*)buf3076);
-    rsSetObject((rs_allocation*) buf3077, *(rs_allocation*)buf3078);
-    rsSetObject((rs_sampler*) buf3079, *(rs_sampler*)buf3080);
-    rsSetObject((rs_script*) buf3081, *(rs_script*)buf3082);
+    *(bool*)buf2370 = rsIsSphereInFrustum((float4*) buf2371, (float4*) buf2372, (float4*) buf2373, (float4*) buf2374, (float4*) buf2375, (float4*) buf2376, (float4*) buf2377);
+    *(rs_tm**)buf2378 = rsLocaltime((rs_tm*) buf2379, (const rs_time_t*) buf2380);
+    *(float*)buf2381 = rsMatrixGet((const rs_matrix4x4*) buf2382, *(uint32_t*)buf2383, *(uint32_t*)buf2384);
+    *(float*)buf2385 = rsMatrixGet((const rs_matrix3x3*) buf2386, *(uint32_t*)buf2387, *(uint32_t*)buf2388);
+    *(float*)buf2389 = rsMatrixGet((const rs_matrix2x2*) buf2390, *(uint32_t*)buf2391, *(uint32_t*)buf2392);
+    *(bool*)buf2393 = rsMatrixInverse((rs_matrix4x4*) buf2394);
+    *(bool*)buf2395 = rsMatrixInverseTranspose((rs_matrix4x4*) buf2396);
+    rsMatrixLoad((rs_matrix4x4*) buf2397, (const float*) buf2398);
+    rsMatrixLoad((rs_matrix3x3*) buf2399, (const float*) buf2400);
+    rsMatrixLoad((rs_matrix2x2*) buf2401, (const float*) buf2402);
+    rsMatrixLoad((rs_matrix4x4*) buf2403, (const rs_matrix4x4*) buf2404);
+    rsMatrixLoad((rs_matrix3x3*) buf2405, (const rs_matrix3x3*) buf2406);
+    rsMatrixLoad((rs_matrix2x2*) buf2407, (const rs_matrix2x2*) buf2408);
+    rsMatrixLoad((rs_matrix4x4*) buf2409, (const rs_matrix3x3*) buf2410);
+    rsMatrixLoad((rs_matrix4x4*) buf2411, (const rs_matrix2x2*) buf2412);
+    rsMatrixLoadFrustum((rs_matrix4x4*) buf2413, *(float*)buf2414, *(float*)buf2415, *(float*)buf2416, *(float*)buf2417, *(float*)buf2418, *(float*)buf2419);
+    rsMatrixLoadIdentity((rs_matrix4x4*) buf2420);
+    rsMatrixLoadIdentity((rs_matrix3x3*) buf2421);
+    rsMatrixLoadIdentity((rs_matrix2x2*) buf2422);
+    rsMatrixLoadMultiply((rs_matrix4x4*) buf2423, (const rs_matrix4x4*) buf2424, (const rs_matrix4x4*) buf2425);
+    rsMatrixLoadMultiply((rs_matrix3x3*) buf2426, (const rs_matrix3x3*) buf2427, (const rs_matrix3x3*) buf2428);
+    rsMatrixLoadMultiply((rs_matrix2x2*) buf2429, (const rs_matrix2x2*) buf2430, (const rs_matrix2x2*) buf2431);
+    rsMatrixLoadOrtho((rs_matrix4x4*) buf2432, *(float*)buf2433, *(float*)buf2434, *(float*)buf2435, *(float*)buf2436, *(float*)buf2437, *(float*)buf2438);
+    rsMatrixLoadPerspective((rs_matrix4x4*) buf2439, *(float*)buf2440, *(float*)buf2441, *(float*)buf2442, *(float*)buf2443);
+    rsMatrixLoadRotate((rs_matrix4x4*) buf2444, *(float*)buf2445, *(float*)buf2446, *(float*)buf2447, *(float*)buf2448);
+    rsMatrixLoadScale((rs_matrix4x4*) buf2449, *(float*)buf2450, *(float*)buf2451, *(float*)buf2452);
+    rsMatrixLoadTranslate((rs_matrix4x4*) buf2453, *(float*)buf2454, *(float*)buf2455, *(float*)buf2456);
+    rsMatrixMultiply((rs_matrix4x4*) buf2457, (const rs_matrix4x4*) buf2458);
+    rsMatrixMultiply((rs_matrix3x3*) buf2459, (const rs_matrix3x3*) buf2460);
+    rsMatrixMultiply((rs_matrix2x2*) buf2461, (const rs_matrix2x2*) buf2462);
+    *(float4*)buf2463 = rsMatrixMultiply((const rs_matrix4x4*) buf2464, *(float4*)buf2465);
+    *(float4*)buf2466 = rsMatrixMultiply((const rs_matrix4x4*) buf2467, *(float3*)buf2468);
+    *(float4*)buf2469 = rsMatrixMultiply((const rs_matrix4x4*) buf2470, *(float2*)buf2471);
+    *(float3*)buf2472 = rsMatrixMultiply((const rs_matrix3x3*) buf2473, *(float3*)buf2474);
+    *(float3*)buf2475 = rsMatrixMultiply((const rs_matrix3x3*) buf2476, *(float2*)buf2477);
+    *(float2*)buf2478 = rsMatrixMultiply((const rs_matrix2x2*) buf2479, *(float2*)buf2480);
+    rsMatrixRotate((rs_matrix4x4*) buf2481, *(float*)buf2482, *(float*)buf2483, *(float*)buf2484, *(float*)buf2485);
+    rsMatrixScale((rs_matrix4x4*) buf2486, *(float*)buf2487, *(float*)buf2488, *(float*)buf2489);
+    rsMatrixSet((rs_matrix4x4*) buf2490, *(uint32_t*)buf2491, *(uint32_t*)buf2492, *(float*)buf2493);
+    rsMatrixSet((rs_matrix3x3*) buf2494, *(uint32_t*)buf2495, *(uint32_t*)buf2496, *(float*)buf2497);
+    rsMatrixSet((rs_matrix2x2*) buf2498, *(uint32_t*)buf2499, *(uint32_t*)buf2500, *(float*)buf2501);
+    rsMatrixTranslate((rs_matrix4x4*) buf2502, *(float*)buf2503, *(float*)buf2504, *(float*)buf2505);
+    rsMatrixTranspose((rs_matrix4x4*) buf2506);
+    rsMatrixTranspose((rs_matrix3x3*) buf2507);
+    rsMatrixTranspose((rs_matrix2x2*) buf2508);
+    *(uchar4*)buf2509 = rsPackColorTo8888(*(float*)buf2510, *(float*)buf2511, *(float*)buf2512);
+    *(uchar4*)buf2513 = rsPackColorTo8888(*(float*)buf2514, *(float*)buf2515, *(float*)buf2516, *(float*)buf2517);
+    *(uchar4*)buf2518 = rsPackColorTo8888(*(float3*)buf2519);
+    *(uchar4*)buf2520 = rsPackColorTo8888(*(float4*)buf2521);
+    rsQuaternionAdd((rs_quaternion*) buf2522, (const rs_quaternion*) buf2523);
+    rsQuaternionConjugate((rs_quaternion*) buf2524);
+    *(float*)buf2525 = rsQuaternionDot((const rs_quaternion*) buf2526, (const rs_quaternion*) buf2527);
+    rsQuaternionGetMatrixUnit((rs_matrix4x4*) buf2528, (const rs_quaternion*) buf2529);
+    rsQuaternionLoadRotate((rs_quaternion*) buf2530, *(float*)buf2531, *(float*)buf2532, *(float*)buf2533, *(float*)buf2534);
+    rsQuaternionLoadRotateUnit((rs_quaternion*) buf2535, *(float*)buf2536, *(float*)buf2537, *(float*)buf2538, *(float*)buf2539);
+    rsQuaternionMultiply((rs_quaternion*) buf2540, *(float*)buf2541);
+    rsQuaternionMultiply((rs_quaternion*) buf2542, (const rs_quaternion*) buf2543);
+    rsQuaternionNormalize((rs_quaternion*) buf2544);
+    rsQuaternionSet((rs_quaternion*) buf2545, *(float*)buf2546, *(float*)buf2547, *(float*)buf2548, *(float*)buf2549);
+    rsQuaternionSet((rs_quaternion*) buf2550, (const rs_quaternion*) buf2551);
+    rsQuaternionSlerp((rs_quaternion*) buf2552, (const rs_quaternion*) buf2553, (const rs_quaternion*) buf2554, *(float*)buf2555);
+    *(int*)buf2556 = rsRand(*(int*)buf2557);
+    *(int*)buf2558 = rsRand(*(int*)buf2559, *(int*)buf2560);
+    *(float*)buf2561 = rsRand(*(float*)buf2562);
+    *(float*)buf2563 = rsRand(*(float*)buf2564, *(float*)buf2565);
+    *(float4*)buf2566 = rsSample(*(rs_allocation*)buf2567, *(rs_sampler*)buf2568, *(float*)buf2569);
+    *(float4*)buf2570 = rsSample(*(rs_allocation*)buf2571, *(rs_sampler*)buf2572, *(float*)buf2573, *(float*)buf2574);
+    *(float4*)buf2575 = rsSample(*(rs_allocation*)buf2576, *(rs_sampler*)buf2577, *(float2*)buf2578);
+    *(float4*)buf2579 = rsSample(*(rs_allocation*)buf2580, *(rs_sampler*)buf2581, *(float2*)buf2582, *(float*)buf2583);
+    *(float*)buf2584 = rsSamplerGetAnisotropy(*(rs_sampler*)buf2585);
+    *(rs_sampler_value*)buf2586 = rsSamplerGetMagnification(*(rs_sampler*)buf2587);
+    *(rs_sampler_value*)buf2588 = rsSamplerGetMinification(*(rs_sampler*)buf2589);
+    *(rs_sampler_value*)buf2590 = rsSamplerGetWrapS(*(rs_sampler*)buf2591);
+    *(rs_sampler_value*)buf2592 = rsSamplerGetWrapT(*(rs_sampler*)buf2593);
+    *(bool*)buf2594 = rsSendToClient(*(int*)buf2595);
+    *(bool*)buf2596 = rsSendToClient(*(int*)buf2597, (const void*) buf2598, *(uint*)buf2599);
+    rsSendToClientBlocking(*(int*)buf2600);
+    rsSendToClientBlocking(*(int*)buf2601, (const void*) buf2602, *(uint*)buf2603);
+    rsSetElementAt(*(rs_allocation*)buf2604, (void*) buf2605, *(uint32_t*)buf2606);
+    rsSetElementAt(*(rs_allocation*)buf2607, (void*) buf2608, *(uint32_t*)buf2609, *(uint32_t*)buf2610);
+    rsSetElementAt_float(*(rs_allocation*)buf2611, *(float*)buf2612, *(uint32_t*)buf2613);
+    rsSetElementAt_float2(*(rs_allocation*)buf2614, *(float2*)buf2615, *(uint32_t*)buf2616);
+    rsSetElementAt_float3(*(rs_allocation*)buf2617, *(float3*)buf2618, *(uint32_t*)buf2619);
+    rsSetElementAt_float4(*(rs_allocation*)buf2620, *(float4*)buf2621, *(uint32_t*)buf2622);
+    rsSetElementAt_double(*(rs_allocation*)buf2623, *(double*)buf2624, *(uint32_t*)buf2625);
+    rsSetElementAt_double2(*(rs_allocation*)buf2626, *(double2*)buf2627, *(uint32_t*)buf2628);
+    rsSetElementAt_double3(*(rs_allocation*)buf2629, *(double3*)buf2630, *(uint32_t*)buf2631);
+    rsSetElementAt_double4(*(rs_allocation*)buf2632, *(double4*)buf2633, *(uint32_t*)buf2634);
+    rsSetElementAt_char(*(rs_allocation*)buf2635, *(char*)buf2636, *(uint32_t*)buf2637);
+    rsSetElementAt_char2(*(rs_allocation*)buf2638, *(char2*)buf2639, *(uint32_t*)buf2640);
+    rsSetElementAt_char3(*(rs_allocation*)buf2641, *(char3*)buf2642, *(uint32_t*)buf2643);
+    rsSetElementAt_char4(*(rs_allocation*)buf2644, *(char4*)buf2645, *(uint32_t*)buf2646);
+    rsSetElementAt_uchar(*(rs_allocation*)buf2647, *(uchar*)buf2648, *(uint32_t*)buf2649);
+    rsSetElementAt_uchar2(*(rs_allocation*)buf2650, *(uchar2*)buf2651, *(uint32_t*)buf2652);
+    rsSetElementAt_uchar3(*(rs_allocation*)buf2653, *(uchar3*)buf2654, *(uint32_t*)buf2655);
+    rsSetElementAt_uchar4(*(rs_allocation*)buf2656, *(uchar4*)buf2657, *(uint32_t*)buf2658);
+    rsSetElementAt_short(*(rs_allocation*)buf2659, *(short*)buf2660, *(uint32_t*)buf2661);
+    rsSetElementAt_short2(*(rs_allocation*)buf2662, *(short2*)buf2663, *(uint32_t*)buf2664);
+    rsSetElementAt_short3(*(rs_allocation*)buf2665, *(short3*)buf2666, *(uint32_t*)buf2667);
+    rsSetElementAt_short4(*(rs_allocation*)buf2668, *(short4*)buf2669, *(uint32_t*)buf2670);
+    rsSetElementAt_ushort(*(rs_allocation*)buf2671, *(ushort*)buf2672, *(uint32_t*)buf2673);
+    rsSetElementAt_ushort2(*(rs_allocation*)buf2674, *(ushort2*)buf2675, *(uint32_t*)buf2676);
+    rsSetElementAt_ushort3(*(rs_allocation*)buf2677, *(ushort3*)buf2678, *(uint32_t*)buf2679);
+    rsSetElementAt_ushort4(*(rs_allocation*)buf2680, *(ushort4*)buf2681, *(uint32_t*)buf2682);
+    rsSetElementAt_int(*(rs_allocation*)buf2683, *(int*)buf2684, *(uint32_t*)buf2685);
+    rsSetElementAt_int2(*(rs_allocation*)buf2686, *(int2*)buf2687, *(uint32_t*)buf2688);
+    rsSetElementAt_int3(*(rs_allocation*)buf2689, *(int3*)buf2690, *(uint32_t*)buf2691);
+    rsSetElementAt_int4(*(rs_allocation*)buf2692, *(int4*)buf2693, *(uint32_t*)buf2694);
+    rsSetElementAt_uint(*(rs_allocation*)buf2695, *(uint*)buf2696, *(uint32_t*)buf2697);
+    rsSetElementAt_uint2(*(rs_allocation*)buf2698, *(uint2*)buf2699, *(uint32_t*)buf2700);
+    rsSetElementAt_uint3(*(rs_allocation*)buf2701, *(uint3*)buf2702, *(uint32_t*)buf2703);
+    rsSetElementAt_uint4(*(rs_allocation*)buf2704, *(uint4*)buf2705, *(uint32_t*)buf2706);
+    rsSetElementAt_long(*(rs_allocation*)buf2707, *(long*)buf2708, *(uint32_t*)buf2709);
+    rsSetElementAt_long2(*(rs_allocation*)buf2710, *(long2*)buf2711, *(uint32_t*)buf2712);
+    rsSetElementAt_long3(*(rs_allocation*)buf2713, *(long3*)buf2714, *(uint32_t*)buf2715);
+    rsSetElementAt_long4(*(rs_allocation*)buf2716, *(long4*)buf2717, *(uint32_t*)buf2718);
+    rsSetElementAt_ulong(*(rs_allocation*)buf2719, *(ulong*)buf2720, *(uint32_t*)buf2721);
+    rsSetElementAt_ulong2(*(rs_allocation*)buf2722, *(ulong2*)buf2723, *(uint32_t*)buf2724);
+    rsSetElementAt_ulong3(*(rs_allocation*)buf2725, *(ulong3*)buf2726, *(uint32_t*)buf2727);
+    rsSetElementAt_ulong4(*(rs_allocation*)buf2728, *(ulong4*)buf2729, *(uint32_t*)buf2730);
+    rsSetElementAt_float(*(rs_allocation*)buf2731, *(float*)buf2732, *(uint32_t*)buf2733, *(uint32_t*)buf2734);
+    rsSetElementAt_float2(*(rs_allocation*)buf2735, *(float2*)buf2736, *(uint32_t*)buf2737, *(uint32_t*)buf2738);
+    rsSetElementAt_float3(*(rs_allocation*)buf2739, *(float3*)buf2740, *(uint32_t*)buf2741, *(uint32_t*)buf2742);
+    rsSetElementAt_float4(*(rs_allocation*)buf2743, *(float4*)buf2744, *(uint32_t*)buf2745, *(uint32_t*)buf2746);
+    rsSetElementAt_double(*(rs_allocation*)buf2747, *(double*)buf2748, *(uint32_t*)buf2749, *(uint32_t*)buf2750);
+    rsSetElementAt_double2(*(rs_allocation*)buf2751, *(double2*)buf2752, *(uint32_t*)buf2753, *(uint32_t*)buf2754);
+    rsSetElementAt_double3(*(rs_allocation*)buf2755, *(double3*)buf2756, *(uint32_t*)buf2757, *(uint32_t*)buf2758);
+    rsSetElementAt_double4(*(rs_allocation*)buf2759, *(double4*)buf2760, *(uint32_t*)buf2761, *(uint32_t*)buf2762);
+    rsSetElementAt_char(*(rs_allocation*)buf2763, *(char*)buf2764, *(uint32_t*)buf2765, *(uint32_t*)buf2766);
+    rsSetElementAt_char2(*(rs_allocation*)buf2767, *(char2*)buf2768, *(uint32_t*)buf2769, *(uint32_t*)buf2770);
+    rsSetElementAt_char3(*(rs_allocation*)buf2771, *(char3*)buf2772, *(uint32_t*)buf2773, *(uint32_t*)buf2774);
+    rsSetElementAt_char4(*(rs_allocation*)buf2775, *(char4*)buf2776, *(uint32_t*)buf2777, *(uint32_t*)buf2778);
+    rsSetElementAt_uchar(*(rs_allocation*)buf2779, *(uchar*)buf2780, *(uint32_t*)buf2781, *(uint32_t*)buf2782);
+    rsSetElementAt_uchar2(*(rs_allocation*)buf2783, *(uchar2*)buf2784, *(uint32_t*)buf2785, *(uint32_t*)buf2786);
+    rsSetElementAt_uchar3(*(rs_allocation*)buf2787, *(uchar3*)buf2788, *(uint32_t*)buf2789, *(uint32_t*)buf2790);
+    rsSetElementAt_uchar4(*(rs_allocation*)buf2791, *(uchar4*)buf2792, *(uint32_t*)buf2793, *(uint32_t*)buf2794);
+    rsSetElementAt_short(*(rs_allocation*)buf2795, *(short*)buf2796, *(uint32_t*)buf2797, *(uint32_t*)buf2798);
+    rsSetElementAt_short2(*(rs_allocation*)buf2799, *(short2*)buf2800, *(uint32_t*)buf2801, *(uint32_t*)buf2802);
+    rsSetElementAt_short3(*(rs_allocation*)buf2803, *(short3*)buf2804, *(uint32_t*)buf2805, *(uint32_t*)buf2806);
+    rsSetElementAt_short4(*(rs_allocation*)buf2807, *(short4*)buf2808, *(uint32_t*)buf2809, *(uint32_t*)buf2810);
+    rsSetElementAt_ushort(*(rs_allocation*)buf2811, *(ushort*)buf2812, *(uint32_t*)buf2813, *(uint32_t*)buf2814);
+    rsSetElementAt_ushort2(*(rs_allocation*)buf2815, *(ushort2*)buf2816, *(uint32_t*)buf2817, *(uint32_t*)buf2818);
+    rsSetElementAt_ushort3(*(rs_allocation*)buf2819, *(ushort3*)buf2820, *(uint32_t*)buf2821, *(uint32_t*)buf2822);
+    rsSetElementAt_ushort4(*(rs_allocation*)buf2823, *(ushort4*)buf2824, *(uint32_t*)buf2825, *(uint32_t*)buf2826);
+    rsSetElementAt_int(*(rs_allocation*)buf2827, *(int*)buf2828, *(uint32_t*)buf2829, *(uint32_t*)buf2830);
+    rsSetElementAt_int2(*(rs_allocation*)buf2831, *(int2*)buf2832, *(uint32_t*)buf2833, *(uint32_t*)buf2834);
+    rsSetElementAt_int3(*(rs_allocation*)buf2835, *(int3*)buf2836, *(uint32_t*)buf2837, *(uint32_t*)buf2838);
+    rsSetElementAt_int4(*(rs_allocation*)buf2839, *(int4*)buf2840, *(uint32_t*)buf2841, *(uint32_t*)buf2842);
+    rsSetElementAt_uint(*(rs_allocation*)buf2843, *(uint*)buf2844, *(uint32_t*)buf2845, *(uint32_t*)buf2846);
+    rsSetElementAt_uint2(*(rs_allocation*)buf2847, *(uint2*)buf2848, *(uint32_t*)buf2849, *(uint32_t*)buf2850);
+    rsSetElementAt_uint3(*(rs_allocation*)buf2851, *(uint3*)buf2852, *(uint32_t*)buf2853, *(uint32_t*)buf2854);
+    rsSetElementAt_uint4(*(rs_allocation*)buf2855, *(uint4*)buf2856, *(uint32_t*)buf2857, *(uint32_t*)buf2858);
+    rsSetElementAt_long(*(rs_allocation*)buf2859, *(long*)buf2860, *(uint32_t*)buf2861, *(uint32_t*)buf2862);
+    rsSetElementAt_long2(*(rs_allocation*)buf2863, *(long2*)buf2864, *(uint32_t*)buf2865, *(uint32_t*)buf2866);
+    rsSetElementAt_long3(*(rs_allocation*)buf2867, *(long3*)buf2868, *(uint32_t*)buf2869, *(uint32_t*)buf2870);
+    rsSetElementAt_long4(*(rs_allocation*)buf2871, *(long4*)buf2872, *(uint32_t*)buf2873, *(uint32_t*)buf2874);
+    rsSetElementAt_ulong(*(rs_allocation*)buf2875, *(ulong*)buf2876, *(uint32_t*)buf2877, *(uint32_t*)buf2878);
+    rsSetElementAt_ulong2(*(rs_allocation*)buf2879, *(ulong2*)buf2880, *(uint32_t*)buf2881, *(uint32_t*)buf2882);
+    rsSetElementAt_ulong3(*(rs_allocation*)buf2883, *(ulong3*)buf2884, *(uint32_t*)buf2885, *(uint32_t*)buf2886);
+    rsSetElementAt_ulong4(*(rs_allocation*)buf2887, *(ulong4*)buf2888, *(uint32_t*)buf2889, *(uint32_t*)buf2890);
+    rsSetElementAt_float(*(rs_allocation*)buf2891, *(float*)buf2892, *(uint32_t*)buf2893, *(uint32_t*)buf2894, *(uint32_t*)buf2895);
+    rsSetElementAt_float2(*(rs_allocation*)buf2896, *(float2*)buf2897, *(uint32_t*)buf2898, *(uint32_t*)buf2899, *(uint32_t*)buf2900);
+    rsSetElementAt_float3(*(rs_allocation*)buf2901, *(float3*)buf2902, *(uint32_t*)buf2903, *(uint32_t*)buf2904, *(uint32_t*)buf2905);
+    rsSetElementAt_float4(*(rs_allocation*)buf2906, *(float4*)buf2907, *(uint32_t*)buf2908, *(uint32_t*)buf2909, *(uint32_t*)buf2910);
+    rsSetElementAt_double(*(rs_allocation*)buf2911, *(double*)buf2912, *(uint32_t*)buf2913, *(uint32_t*)buf2914, *(uint32_t*)buf2915);
+    rsSetElementAt_double2(*(rs_allocation*)buf2916, *(double2*)buf2917, *(uint32_t*)buf2918, *(uint32_t*)buf2919, *(uint32_t*)buf2920);
+    rsSetElementAt_double3(*(rs_allocation*)buf2921, *(double3*)buf2922, *(uint32_t*)buf2923, *(uint32_t*)buf2924, *(uint32_t*)buf2925);
+    rsSetElementAt_double4(*(rs_allocation*)buf2926, *(double4*)buf2927, *(uint32_t*)buf2928, *(uint32_t*)buf2929, *(uint32_t*)buf2930);
+    rsSetElementAt_char(*(rs_allocation*)buf2931, *(char*)buf2932, *(uint32_t*)buf2933, *(uint32_t*)buf2934, *(uint32_t*)buf2935);
+    rsSetElementAt_char2(*(rs_allocation*)buf2936, *(char2*)buf2937, *(uint32_t*)buf2938, *(uint32_t*)buf2939, *(uint32_t*)buf2940);
+    rsSetElementAt_char3(*(rs_allocation*)buf2941, *(char3*)buf2942, *(uint32_t*)buf2943, *(uint32_t*)buf2944, *(uint32_t*)buf2945);
+    rsSetElementAt_char4(*(rs_allocation*)buf2946, *(char4*)buf2947, *(uint32_t*)buf2948, *(uint32_t*)buf2949, *(uint32_t*)buf2950);
+    rsSetElementAt_uchar(*(rs_allocation*)buf2951, *(uchar*)buf2952, *(uint32_t*)buf2953, *(uint32_t*)buf2954, *(uint32_t*)buf2955);
+    rsSetElementAt_uchar2(*(rs_allocation*)buf2956, *(uchar2*)buf2957, *(uint32_t*)buf2958, *(uint32_t*)buf2959, *(uint32_t*)buf2960);
+    rsSetElementAt_uchar3(*(rs_allocation*)buf2961, *(uchar3*)buf2962, *(uint32_t*)buf2963, *(uint32_t*)buf2964, *(uint32_t*)buf2965);
+    rsSetElementAt_uchar4(*(rs_allocation*)buf2966, *(uchar4*)buf2967, *(uint32_t*)buf2968, *(uint32_t*)buf2969, *(uint32_t*)buf2970);
+    rsSetElementAt_short(*(rs_allocation*)buf2971, *(short*)buf2972, *(uint32_t*)buf2973, *(uint32_t*)buf2974, *(uint32_t*)buf2975);
+    rsSetElementAt_short2(*(rs_allocation*)buf2976, *(short2*)buf2977, *(uint32_t*)buf2978, *(uint32_t*)buf2979, *(uint32_t*)buf2980);
+    rsSetElementAt_short3(*(rs_allocation*)buf2981, *(short3*)buf2982, *(uint32_t*)buf2983, *(uint32_t*)buf2984, *(uint32_t*)buf2985);
+    rsSetElementAt_short4(*(rs_allocation*)buf2986, *(short4*)buf2987, *(uint32_t*)buf2988, *(uint32_t*)buf2989, *(uint32_t*)buf2990);
+    rsSetElementAt_ushort(*(rs_allocation*)buf2991, *(ushort*)buf2992, *(uint32_t*)buf2993, *(uint32_t*)buf2994, *(uint32_t*)buf2995);
+    rsSetElementAt_ushort2(*(rs_allocation*)buf2996, *(ushort2*)buf2997, *(uint32_t*)buf2998, *(uint32_t*)buf2999, *(uint32_t*)buf3000);
+    rsSetElementAt_ushort3(*(rs_allocation*)buf3001, *(ushort3*)buf3002, *(uint32_t*)buf3003, *(uint32_t*)buf3004, *(uint32_t*)buf3005);
+    rsSetElementAt_ushort4(*(rs_allocation*)buf3006, *(ushort4*)buf3007, *(uint32_t*)buf3008, *(uint32_t*)buf3009, *(uint32_t*)buf3010);
+    rsSetElementAt_int(*(rs_allocation*)buf3011, *(int*)buf3012, *(uint32_t*)buf3013, *(uint32_t*)buf3014, *(uint32_t*)buf3015);
+    rsSetElementAt_int2(*(rs_allocation*)buf3016, *(int2*)buf3017, *(uint32_t*)buf3018, *(uint32_t*)buf3019, *(uint32_t*)buf3020);
+    rsSetElementAt_int3(*(rs_allocation*)buf3021, *(int3*)buf3022, *(uint32_t*)buf3023, *(uint32_t*)buf3024, *(uint32_t*)buf3025);
+    rsSetElementAt_int4(*(rs_allocation*)buf3026, *(int4*)buf3027, *(uint32_t*)buf3028, *(uint32_t*)buf3029, *(uint32_t*)buf3030);
+    rsSetElementAt_uint(*(rs_allocation*)buf3031, *(uint*)buf3032, *(uint32_t*)buf3033, *(uint32_t*)buf3034, *(uint32_t*)buf3035);
+    rsSetElementAt_uint2(*(rs_allocation*)buf3036, *(uint2*)buf3037, *(uint32_t*)buf3038, *(uint32_t*)buf3039, *(uint32_t*)buf3040);
+    rsSetElementAt_uint3(*(rs_allocation*)buf3041, *(uint3*)buf3042, *(uint32_t*)buf3043, *(uint32_t*)buf3044, *(uint32_t*)buf3045);
+    rsSetElementAt_uint4(*(rs_allocation*)buf3046, *(uint4*)buf3047, *(uint32_t*)buf3048, *(uint32_t*)buf3049, *(uint32_t*)buf3050);
+    rsSetElementAt_long(*(rs_allocation*)buf3051, *(long*)buf3052, *(uint32_t*)buf3053, *(uint32_t*)buf3054, *(uint32_t*)buf3055);
+    rsSetElementAt_long2(*(rs_allocation*)buf3056, *(long2*)buf3057, *(uint32_t*)buf3058, *(uint32_t*)buf3059, *(uint32_t*)buf3060);
+    rsSetElementAt_long3(*(rs_allocation*)buf3061, *(long3*)buf3062, *(uint32_t*)buf3063, *(uint32_t*)buf3064, *(uint32_t*)buf3065);
+    rsSetElementAt_long4(*(rs_allocation*)buf3066, *(long4*)buf3067, *(uint32_t*)buf3068, *(uint32_t*)buf3069, *(uint32_t*)buf3070);
+    rsSetElementAt_ulong(*(rs_allocation*)buf3071, *(ulong*)buf3072, *(uint32_t*)buf3073, *(uint32_t*)buf3074, *(uint32_t*)buf3075);
+    rsSetElementAt_ulong2(*(rs_allocation*)buf3076, *(ulong2*)buf3077, *(uint32_t*)buf3078, *(uint32_t*)buf3079, *(uint32_t*)buf3080);
+    rsSetElementAt_ulong3(*(rs_allocation*)buf3081, *(ulong3*)buf3082, *(uint32_t*)buf3083, *(uint32_t*)buf3084, *(uint32_t*)buf3085);
+    rsSetElementAt_ulong4(*(rs_allocation*)buf3086, *(ulong4*)buf3087, *(uint32_t*)buf3088, *(uint32_t*)buf3089, *(uint32_t*)buf3090);
+    rsSetObject((rs_element*) buf3091, *(rs_element*)buf3092);
+    rsSetObject((rs_type*) buf3093, *(rs_type*)buf3094);
+    rsSetObject((rs_allocation*) buf3095, *(rs_allocation*)buf3096);
+    rsSetObject((rs_sampler*) buf3097, *(rs_sampler*)buf3098);
+    rsSetObject((rs_script*) buf3099, *(rs_script*)buf3100);
 #ifndef __LP64__
-    rsSetObject((rs_mesh*) buf3083, *(rs_mesh*)buf3084);
-    rsSetObject((rs_program_fragment*) buf3085, *(rs_program_fragment*)buf3086);
-    rsSetObject((rs_program_vertex*) buf3087, *(rs_program_vertex*)buf3088);
-    rsSetObject((rs_program_raster*) buf3089, *(rs_program_raster*)buf3090);
-    rsSetObject((rs_program_store*) buf3091, *(rs_program_store*)buf3092);
-    rsSetObject((rs_font*) buf3093, *(rs_font*)buf3094);
+    rsSetObject((rs_mesh*) buf3101, *(rs_mesh*)buf3102);
+    rsSetObject((rs_program_fragment*) buf3103, *(rs_program_fragment*)buf3104);
+    rsSetObject((rs_program_vertex*) buf3105, *(rs_program_vertex*)buf3106);
+    rsSetObject((rs_program_raster*) buf3107, *(rs_program_raster*)buf3108);
+    rsSetObject((rs_program_store*) buf3109, *(rs_program_store*)buf3110);
+    rsSetObject((rs_font*) buf3111, *(rs_font*)buf3112);
 #endif
-    *(rs_time_t*)buf3095 = rsTime((rs_time_t*) buf3096);
-    *(float4*)buf3097 = rsUnpackColor8888(*(uchar4*)buf3098);
-    *(int64_t*)buf3099 = rsUptimeMillis();
-    *(int64_t*)buf3100 = rsUptimeNanos();
-    *(float4*)buf3101 = rsYuvToRGBA_float4(*(uchar*)buf3102, *(uchar*)buf3103, *(uchar*)buf3104);
-    *(uchar4*)buf3105 = rsYuvToRGBA_uchar4(*(uchar*)buf3106, *(uchar*)buf3107, *(uchar*)buf3108);
+    *(rs_time_t*)buf3113 = rsTime((rs_time_t*) buf3114);
+    *(float4*)buf3115 = rsUnpackColor8888(*(uchar4*)buf3116);
+    *(int64_t*)buf3117 = rsUptimeMillis();
+    *(int64_t*)buf3118 = rsUptimeNanos();
+    *(float4*)buf3119 = rsYuvToRGBA_float4(*(uchar*)buf3120, *(uchar*)buf3121, *(uchar*)buf3122);
+    *(uchar4*)buf3123 = rsYuvToRGBA_uchar4(*(uchar*)buf3124, *(uchar*)buf3125, *(uchar*)buf3126);
 #ifndef __LP64__
-    rsgAllocationSyncAll(*(rs_allocation*)buf3109);
+    rsgAllocationSyncAll(*(rs_allocation*)buf3127);
 #endif
 #ifndef __LP64__
-    rsgAllocationSyncAll(*(rs_allocation*)buf3110, *(rs_allocation_usage_type*)buf3111);
+    rsgAllocationSyncAll(*(rs_allocation*)buf3128, *(rs_allocation_usage_type*)buf3129);
 #endif
 #ifndef __LP64__
-    rsgBindColorTarget(*(rs_allocation*)buf3112, *(uint*)buf3113);
+    rsgBindColorTarget(*(rs_allocation*)buf3130, *(uint*)buf3131);
 #endif
 #ifndef __LP64__
-    rsgBindConstant(*(rs_program_fragment*)buf3114, *(uint*)buf3115, *(rs_allocation*)buf3116);
+    rsgBindConstant(*(rs_program_fragment*)buf3132, *(uint*)buf3133, *(rs_allocation*)buf3134);
 #endif
 #ifndef __LP64__
-    rsgBindConstant(*(rs_program_vertex*)buf3117, *(uint*)buf3118, *(rs_allocation*)buf3119);
+    rsgBindConstant(*(rs_program_vertex*)buf3135, *(uint*)buf3136, *(rs_allocation*)buf3137);
 #endif
 #ifndef __LP64__
-    rsgBindDepthTarget(*(rs_allocation*)buf3120);
+    rsgBindDepthTarget(*(rs_allocation*)buf3138);
 #endif
 #ifndef __LP64__
-    rsgBindFont(*(rs_font*)buf3121);
+    rsgBindFont(*(rs_font*)buf3139);
 #endif
 #ifndef __LP64__
-    rsgBindProgramFragment(*(rs_program_fragment*)buf3122);
+    rsgBindProgramFragment(*(rs_program_fragment*)buf3140);
 #endif
 #ifndef __LP64__
-    rsgBindProgramRaster(*(rs_program_raster*)buf3123);
+    rsgBindProgramRaster(*(rs_program_raster*)buf3141);
 #endif
 #ifndef __LP64__
-    rsgBindProgramStore(*(rs_program_store*)buf3124);
+    rsgBindProgramStore(*(rs_program_store*)buf3142);
 #endif
 #ifndef __LP64__
-    rsgBindProgramVertex(*(rs_program_vertex*)buf3125);
+    rsgBindProgramVertex(*(rs_program_vertex*)buf3143);
 #endif
 #ifndef __LP64__
-    rsgBindSampler(*(rs_program_fragment*)buf3126, *(uint*)buf3127, *(rs_sampler*)buf3128);
+    rsgBindSampler(*(rs_program_fragment*)buf3144, *(uint*)buf3145, *(rs_sampler*)buf3146);
 #endif
 #ifndef __LP64__
-    rsgBindTexture(*(rs_program_fragment*)buf3129, *(uint*)buf3130, *(rs_allocation*)buf3131);
+    rsgBindTexture(*(rs_program_fragment*)buf3147, *(uint*)buf3148, *(rs_allocation*)buf3149);
 #endif
 #ifndef __LP64__
     rsgClearAllRenderTargets();
 #endif
 #ifndef __LP64__
-    rsgClearColor(*(float*)buf3132, *(float*)buf3133, *(float*)buf3134, *(float*)buf3135);
+    rsgClearColor(*(float*)buf3150, *(float*)buf3151, *(float*)buf3152, *(float*)buf3153);
 #endif
 #ifndef __LP64__
-    rsgClearColorTarget(*(uint*)buf3136);
+    rsgClearColorTarget(*(uint*)buf3154);
 #endif
 #ifndef __LP64__
-    rsgClearDepth(*(float*)buf3137);
+    rsgClearDepth(*(float*)buf3155);
 #endif
 #ifndef __LP64__
     rsgClearDepthTarget();
 #endif
 #ifndef __LP64__
-    rsgDrawMesh(*(rs_mesh*)buf3138);
+    rsgDrawMesh(*(rs_mesh*)buf3156);
 #endif
 #ifndef __LP64__
-    rsgDrawMesh(*(rs_mesh*)buf3139, *(uint*)buf3140);
+    rsgDrawMesh(*(rs_mesh*)buf3157, *(uint*)buf3158);
 #endif
 #ifndef __LP64__
-    rsgDrawMesh(*(rs_mesh*)buf3141, *(uint*)buf3142, *(uint*)buf3143, *(uint*)buf3144);
+    rsgDrawMesh(*(rs_mesh*)buf3159, *(uint*)buf3160, *(uint*)buf3161, *(uint*)buf3162);
 #endif
 #ifndef __LP64__
-    rsgDrawQuad(*(float*)buf3145, *(float*)buf3146, *(float*)buf3147, *(float*)buf3148, *(float*)buf3149, *(float*)buf3150, *(float*)buf3151, *(float*)buf3152, *(float*)buf3153, *(float*)buf3154, *(float*)buf3155, *(float*)buf3156);
+    rsgDrawQuad(*(float*)buf3163, *(float*)buf3164, *(float*)buf3165, *(float*)buf3166, *(float*)buf3167, *(float*)buf3168, *(float*)buf3169, *(float*)buf3170, *(float*)buf3171, *(float*)buf3172, *(float*)buf3173, *(float*)buf3174);
 #endif
 #ifndef __LP64__
-    rsgDrawQuadTexCoords(*(float*)buf3157, *(float*)buf3158, *(float*)buf3159, *(float*)buf3160, *(float*)buf3161, *(float*)buf3162, *(float*)buf3163, *(float*)buf3164, *(float*)buf3165, *(float*)buf3166, *(float*)buf3167, *(float*)buf3168, *(float*)buf3169, *(float*)buf3170, *(float*)buf3171, *(float*)buf3172, *(float*)buf3173, *(float*)buf3174, *(float*)buf3175, *(float*)buf3176);
+    rsgDrawQuadTexCoords(*(float*)buf3175, *(float*)buf3176, *(float*)buf3177, *(float*)buf3178, *(float*)buf3179, *(float*)buf3180, *(float*)buf3181, *(float*)buf3182, *(float*)buf3183, *(float*)buf3184, *(float*)buf3185, *(float*)buf3186, *(float*)buf3187, *(float*)buf3188, *(float*)buf3189, *(float*)buf3190, *(float*)buf3191, *(float*)buf3192, *(float*)buf3193, *(float*)buf3194);
 #endif
 #ifndef __LP64__
-    rsgDrawRect(*(float*)buf3177, *(float*)buf3178, *(float*)buf3179, *(float*)buf3180, *(float*)buf3181);
+    rsgDrawRect(*(float*)buf3195, *(float*)buf3196, *(float*)buf3197, *(float*)buf3198, *(float*)buf3199);
 #endif
 #ifndef __LP64__
-    rsgDrawSpriteScreenspace(*(float*)buf3182, *(float*)buf3183, *(float*)buf3184, *(float*)buf3185, *(float*)buf3186);
+    rsgDrawSpriteScreenspace(*(float*)buf3200, *(float*)buf3201, *(float*)buf3202, *(float*)buf3203, *(float*)buf3204);
 #endif
 #ifndef __LP64__
-    rsgDrawText((const char*) buf3187, *(int*)buf3188, *(int*)buf3189);
+    rsgDrawText((const char*) buf3205, *(int*)buf3206, *(int*)buf3207);
 #endif
 #ifndef __LP64__
-    rsgDrawText(*(rs_allocation*)buf3190, *(int*)buf3191, *(int*)buf3192);
+    rsgDrawText(*(rs_allocation*)buf3208, *(int*)buf3209, *(int*)buf3210);
 #endif
 #ifndef __LP64__
-    *(uint*)buf3193 = rsgFinish();
+    *(uint*)buf3211 = rsgFinish();
 #endif
 #ifndef __LP64__
-    rsgFontColor(*(float*)buf3194, *(float*)buf3195, *(float*)buf3196, *(float*)buf3197);
+    rsgFontColor(*(float*)buf3212, *(float*)buf3213, *(float*)buf3214, *(float*)buf3215);
 #endif
 #ifndef __LP64__
-    *(uint*)buf3198 = rsgGetHeight();
+    *(uint*)buf3216 = rsgGetHeight();
 #endif
 #ifndef __LP64__
-    *(uint*)buf3199 = rsgGetWidth();
+    *(uint*)buf3217 = rsgGetWidth();
 #endif
 #ifndef __LP64__
-    rsgMeasureText((const char*) buf3200, (int*) buf3201, (int*) buf3202, (int*) buf3203, (int*) buf3204);
+    rsgMeasureText((const char*) buf3218, (int*) buf3219, (int*) buf3220, (int*) buf3221, (int*) buf3222);
 #endif
 #ifndef __LP64__
-    rsgMeasureText(*(rs_allocation*)buf3205, (int*) buf3206, (int*) buf3207, (int*) buf3208, (int*) buf3209);
+    rsgMeasureText(*(rs_allocation*)buf3223, (int*) buf3224, (int*) buf3225, (int*) buf3226, (int*) buf3227);
 #endif
 #ifndef __LP64__
-    rsgMeshComputeBoundingBox(*(rs_mesh*)buf3210, (float*) buf3211, (float*) buf3212, (float*) buf3213, (float*) buf3214, (float*) buf3215, (float*) buf3216);
+    rsgMeshComputeBoundingBox(*(rs_mesh*)buf3228, (float*) buf3229, (float*) buf3230, (float*) buf3231, (float*) buf3232, (float*) buf3233, (float*) buf3234);
 #endif
 #ifndef __LP64__
-    rsgMeshComputeBoundingBox(*(rs_mesh*)buf3217, (float3*) buf3218, (float3*) buf3219);
+    rsgMeshComputeBoundingBox(*(rs_mesh*)buf3235, (float3*) buf3236, (float3*) buf3237);
 #endif
 #ifndef __LP64__
-    *(rs_allocation*)buf3220 = rsgMeshGetIndexAllocation(*(rs_mesh*)buf3221, *(uint32_t*)buf3222);
+    *(rs_allocation*)buf3238 = rsgMeshGetIndexAllocation(*(rs_mesh*)buf3239, *(uint32_t*)buf3240);
 #endif
 #ifndef __LP64__
-    *(rs_primitive*)buf3223 = rsgMeshGetPrimitive(*(rs_mesh*)buf3224, *(uint32_t*)buf3225);
+    *(rs_primitive*)buf3241 = rsgMeshGetPrimitive(*(rs_mesh*)buf3242, *(uint32_t*)buf3243);
 #endif
 #ifndef __LP64__
-    *(uint32_t*)buf3226 = rsgMeshGetPrimitiveCount(*(rs_mesh*)buf3227);
+    *(uint32_t*)buf3244 = rsgMeshGetPrimitiveCount(*(rs_mesh*)buf3245);
 #endif
 #ifndef __LP64__
-    *(rs_allocation*)buf3228 = rsgMeshGetVertexAllocation(*(rs_mesh*)buf3229, *(uint32_t*)buf3230);
+    *(rs_allocation*)buf3246 = rsgMeshGetVertexAllocation(*(rs_mesh*)buf3247, *(uint32_t*)buf3248);
 #endif
 #ifndef __LP64__
-    *(uint32_t*)buf3231 = rsgMeshGetVertexAllocationCount(*(rs_mesh*)buf3232);
+    *(uint32_t*)buf3249 = rsgMeshGetVertexAllocationCount(*(rs_mesh*)buf3250);
 #endif
 #ifndef __LP64__
-    rsgProgramFragmentConstantColor(*(rs_program_fragment*)buf3233, *(float*)buf3234, *(float*)buf3235, *(float*)buf3236, *(float*)buf3237);
+    rsgProgramFragmentConstantColor(*(rs_program_fragment*)buf3251, *(float*)buf3252, *(float*)buf3253, *(float*)buf3254, *(float*)buf3255);
 #endif
 #ifndef __LP64__
-    *(rs_cull_mode*)buf3238 = rsgProgramRasterGetCullMode(*(rs_program_raster*)buf3239);
+    *(rs_cull_mode*)buf3256 = rsgProgramRasterGetCullMode(*(rs_program_raster*)buf3257);
 #endif
 #ifndef __LP64__
-    *(bool*)buf3240 = rsgProgramRasterIsPointSpriteEnabled(*(rs_program_raster*)buf3241);
+    *(bool*)buf3258 = rsgProgramRasterIsPointSpriteEnabled(*(rs_program_raster*)buf3259);
 #endif
 #ifndef __LP64__
-    *(rs_blend_dst_func*)buf3242 = rsgProgramStoreGetBlendDstFunc(*(rs_program_store*)buf3243);
+    *(rs_blend_dst_func*)buf3260 = rsgProgramStoreGetBlendDstFunc(*(rs_program_store*)buf3261);
 #endif
 #ifndef __LP64__
-    *(rs_blend_src_func*)buf3244 = rsgProgramStoreGetBlendSrcFunc(*(rs_program_store*)buf3245);
+    *(rs_blend_src_func*)buf3262 = rsgProgramStoreGetBlendSrcFunc(*(rs_program_store*)buf3263);
 #endif
 #ifndef __LP64__
-    *(rs_depth_func*)buf3246 = rsgProgramStoreGetDepthFunc(*(rs_program_store*)buf3247);
+    *(rs_depth_func*)buf3264 = rsgProgramStoreGetDepthFunc(*(rs_program_store*)buf3265);
 #endif
 #ifndef __LP64__
-    *(bool*)buf3248 = rsgProgramStoreIsColorMaskAlphaEnabled(*(rs_program_store*)buf3249);
+    *(bool*)buf3266 = rsgProgramStoreIsColorMaskAlphaEnabled(*(rs_program_store*)buf3267);
 #endif
 #ifndef __LP64__
-    *(bool*)buf3250 = rsgProgramStoreIsColorMaskBlueEnabled(*(rs_program_store*)buf3251);
+    *(bool*)buf3268 = rsgProgramStoreIsColorMaskBlueEnabled(*(rs_program_store*)buf3269);
 #endif
 #ifndef __LP64__
-    *(bool*)buf3252 = rsgProgramStoreIsColorMaskGreenEnabled(*(rs_program_store*)buf3253);
+    *(bool*)buf3270 = rsgProgramStoreIsColorMaskGreenEnabled(*(rs_program_store*)buf3271);
 #endif
 #ifndef __LP64__
-    *(bool*)buf3254 = rsgProgramStoreIsColorMaskRedEnabled(*(rs_program_store*)buf3255);
+    *(bool*)buf3272 = rsgProgramStoreIsColorMaskRedEnabled(*(rs_program_store*)buf3273);
 #endif
 #ifndef __LP64__
-    *(bool*)buf3256 = rsgProgramStoreIsDepthMaskEnabled(*(rs_program_store*)buf3257);
+    *(bool*)buf3274 = rsgProgramStoreIsDepthMaskEnabled(*(rs_program_store*)buf3275);
 #endif
 #ifndef __LP64__
-    *(bool*)buf3258 = rsgProgramStoreIsDitherEnabled(*(rs_program_store*)buf3259);
+    *(bool*)buf3276 = rsgProgramStoreIsDitherEnabled(*(rs_program_store*)buf3277);
 #endif
 #ifndef __LP64__
-    rsgProgramVertexGetProjectionMatrix((rs_matrix4x4*) buf3260);
+    rsgProgramVertexGetProjectionMatrix((rs_matrix4x4*) buf3278);
 #endif
 #ifndef __LP64__
-    rsgProgramVertexLoadModelMatrix((const rs_matrix4x4*) buf3261);
+    rsgProgramVertexLoadModelMatrix((const rs_matrix4x4*) buf3279);
 #endif
 #ifndef __LP64__
-    rsgProgramVertexLoadProjectionMatrix((const rs_matrix4x4*) buf3262);
+    rsgProgramVertexLoadProjectionMatrix((const rs_matrix4x4*) buf3280);
 #endif
 #ifndef __LP64__
-    rsgProgramVertexLoadTextureMatrix((const rs_matrix4x4*) buf3263);
+    rsgProgramVertexLoadTextureMatrix((const rs_matrix4x4*) buf3281);
 #endif
-    *(float*)buf3264 = rsqrt(*(float*)buf3265);
-    *(float2*)buf3266 = rsqrt(*(float2*)buf3267);
-    *(float3*)buf3268 = rsqrt(*(float3*)buf3269);
-    *(float4*)buf3270 = rsqrt(*(float4*)buf3271);
-    *(float*)buf3272 = sign(*(float*)buf3273);
-    *(float2*)buf3274 = sign(*(float2*)buf3275);
-    *(float3*)buf3276 = sign(*(float3*)buf3277);
-    *(float4*)buf3278 = sign(*(float4*)buf3279);
-    *(float*)buf3280 = sin(*(float*)buf3281);
-    *(float2*)buf3282 = sin(*(float2*)buf3283);
-    *(float3*)buf3284 = sin(*(float3*)buf3285);
-    *(float4*)buf3286 = sin(*(float4*)buf3287);
-    *(float*)buf3288 = sincos(*(float*)buf3289, (float*) buf3290);
-    *(float2*)buf3291 = sincos(*(float2*)buf3292, (float2*) buf3293);
-    *(float3*)buf3294 = sincos(*(float3*)buf3295, (float3*) buf3296);
-    *(float4*)buf3297 = sincos(*(float4*)buf3298, (float4*) buf3299);
-    *(float*)buf3300 = sinh(*(float*)buf3301);
-    *(float2*)buf3302 = sinh(*(float2*)buf3303);
-    *(float3*)buf3304 = sinh(*(float3*)buf3305);
-    *(float4*)buf3306 = sinh(*(float4*)buf3307);
-    *(float*)buf3308 = sinpi(*(float*)buf3309);
-    *(float2*)buf3310 = sinpi(*(float2*)buf3311);
-    *(float3*)buf3312 = sinpi(*(float3*)buf3313);
-    *(float4*)buf3314 = sinpi(*(float4*)buf3315);
-    *(float*)buf3316 = sqrt(*(float*)buf3317);
-    *(float2*)buf3318 = sqrt(*(float2*)buf3319);
-    *(float3*)buf3320 = sqrt(*(float3*)buf3321);
-    *(float4*)buf3322 = sqrt(*(float4*)buf3323);
-    *(float*)buf3324 = step(*(float*)buf3325, *(float*)buf3326);
-    *(float2*)buf3327 = step(*(float2*)buf3328, *(float2*)buf3329);
-    *(float3*)buf3330 = step(*(float3*)buf3331, *(float3*)buf3332);
-    *(float4*)buf3333 = step(*(float4*)buf3334, *(float4*)buf3335);
-    *(float2*)buf3336 = step(*(float2*)buf3337, *(float*)buf3338);
-    *(float3*)buf3339 = step(*(float3*)buf3340, *(float*)buf3341);
-    *(float4*)buf3342 = step(*(float4*)buf3343, *(float*)buf3344);
-    *(float*)buf3345 = tan(*(float*)buf3346);
-    *(float2*)buf3347 = tan(*(float2*)buf3348);
-    *(float3*)buf3349 = tan(*(float3*)buf3350);
-    *(float4*)buf3351 = tan(*(float4*)buf3352);
-    *(float*)buf3353 = tanh(*(float*)buf3354);
-    *(float2*)buf3355 = tanh(*(float2*)buf3356);
-    *(float3*)buf3357 = tanh(*(float3*)buf3358);
-    *(float4*)buf3359 = tanh(*(float4*)buf3360);
-    *(float*)buf3361 = tanpi(*(float*)buf3362);
-    *(float2*)buf3363 = tanpi(*(float2*)buf3364);
-    *(float3*)buf3365 = tanpi(*(float3*)buf3366);
-    *(float4*)buf3367 = tanpi(*(float4*)buf3368);
-    *(float*)buf3369 = tgamma(*(float*)buf3370);
-    *(float2*)buf3371 = tgamma(*(float2*)buf3372);
-    *(float3*)buf3373 = tgamma(*(float3*)buf3374);
-    *(float4*)buf3375 = tgamma(*(float4*)buf3376);
-    *(float*)buf3377 = trunc(*(float*)buf3378);
-    *(float2*)buf3379 = trunc(*(float2*)buf3380);
-    *(float3*)buf3381 = trunc(*(float3*)buf3382);
-    *(float4*)buf3383 = trunc(*(float4*)buf3384);
+    *(float*)buf3282 = rsqrt(*(float*)buf3283);
+    *(float2*)buf3284 = rsqrt(*(float2*)buf3285);
+    *(float3*)buf3286 = rsqrt(*(float3*)buf3287);
+    *(float4*)buf3288 = rsqrt(*(float4*)buf3289);
+    *(float*)buf3290 = sign(*(float*)buf3291);
+    *(float2*)buf3292 = sign(*(float2*)buf3293);
+    *(float3*)buf3294 = sign(*(float3*)buf3295);
+    *(float4*)buf3296 = sign(*(float4*)buf3297);
+    *(float*)buf3298 = sin(*(float*)buf3299);
+    *(float2*)buf3300 = sin(*(float2*)buf3301);
+    *(float3*)buf3302 = sin(*(float3*)buf3303);
+    *(float4*)buf3304 = sin(*(float4*)buf3305);
+    *(float*)buf3306 = sincos(*(float*)buf3307, (float*) buf3308);
+    *(float2*)buf3309 = sincos(*(float2*)buf3310, (float2*) buf3311);
+    *(float3*)buf3312 = sincos(*(float3*)buf3313, (float3*) buf3314);
+    *(float4*)buf3315 = sincos(*(float4*)buf3316, (float4*) buf3317);
+    *(float*)buf3318 = sinh(*(float*)buf3319);
+    *(float2*)buf3320 = sinh(*(float2*)buf3321);
+    *(float3*)buf3322 = sinh(*(float3*)buf3323);
+    *(float4*)buf3324 = sinh(*(float4*)buf3325);
+    *(float*)buf3326 = sinpi(*(float*)buf3327);
+    *(float2*)buf3328 = sinpi(*(float2*)buf3329);
+    *(float3*)buf3330 = sinpi(*(float3*)buf3331);
+    *(float4*)buf3332 = sinpi(*(float4*)buf3333);
+    *(float*)buf3334 = sqrt(*(float*)buf3335);
+    *(float2*)buf3336 = sqrt(*(float2*)buf3337);
+    *(float3*)buf3338 = sqrt(*(float3*)buf3339);
+    *(float4*)buf3340 = sqrt(*(float4*)buf3341);
+    *(float*)buf3342 = step(*(float*)buf3343, *(float*)buf3344);
+    *(float2*)buf3345 = step(*(float2*)buf3346, *(float2*)buf3347);
+    *(float3*)buf3348 = step(*(float3*)buf3349, *(float3*)buf3350);
+    *(float4*)buf3351 = step(*(float4*)buf3352, *(float4*)buf3353);
+    *(float2*)buf3354 = step(*(float2*)buf3355, *(float*)buf3356);
+    *(float3*)buf3357 = step(*(float3*)buf3358, *(float*)buf3359);
+    *(float4*)buf3360 = step(*(float4*)buf3361, *(float*)buf3362);
+    *(float*)buf3363 = tan(*(float*)buf3364);
+    *(float2*)buf3365 = tan(*(float2*)buf3366);
+    *(float3*)buf3367 = tan(*(float3*)buf3368);
+    *(float4*)buf3369 = tan(*(float4*)buf3370);
+    *(float*)buf3371 = tanh(*(float*)buf3372);
+    *(float2*)buf3373 = tanh(*(float2*)buf3374);
+    *(float3*)buf3375 = tanh(*(float3*)buf3376);
+    *(float4*)buf3377 = tanh(*(float4*)buf3378);
+    *(float*)buf3379 = tanpi(*(float*)buf3380);
+    *(float2*)buf3381 = tanpi(*(float2*)buf3382);
+    *(float3*)buf3383 = tanpi(*(float3*)buf3384);
+    *(float4*)buf3385 = tanpi(*(float4*)buf3386);
+    *(float*)buf3387 = tgamma(*(float*)buf3388);
+    *(float2*)buf3389 = tgamma(*(float2*)buf3390);
+    *(float3*)buf3391 = tgamma(*(float3*)buf3392);
+    *(float4*)buf3393 = tgamma(*(float4*)buf3394);
+    *(float*)buf3395 = trunc(*(float*)buf3396);
+    *(float2*)buf3397 = trunc(*(float2*)buf3398);
+    *(float3*)buf3399 = trunc(*(float3*)buf3400);
+    *(float4*)buf3401 = trunc(*(float4*)buf3402);
 }