diff options
Diffstat (limited to 'tests/P_all_api_22/all22.rs')
| -rw-r--r-- | tests/P_all_api_22/all22.rs | 2100 |
1 files changed, 1062 insertions, 1038 deletions
diff --git a/tests/P_all_api_22/all22.rs b/tests/P_all_api_22/all22.rs index bb06c21..a5e8018 100644 --- a/tests/P_all_api_22/all22.rs +++ b/tests/P_all_api_22/all22.rs @@ -4771,6 +4771,24 @@ char buf4745[200]; char buf4746[200]; char buf4747[200]; char buf4748[200]; +char buf4749[200]; +char buf4750[200]; +char buf4751[200]; +char buf4752[200]; +char buf4753[200]; +char buf4754[200]; +char buf4755[200]; +char buf4756[200]; +char buf4757[200]; +char buf4758[200]; +char buf4759[200]; +char buf4760[200]; +char buf4761[200]; +char buf4762[200]; +char buf4763[200]; +char buf4764[200]; +char buf4765[200]; +char buf4766[200]; void RS_KERNEL test(int in) { *(uchar*)buf0 = abs(*(char*)buf1); @@ -5403,1162 +5421,1168 @@ void RS_KERNEL test(int in) { *(float2*)buf1468 = max(*(float2*)buf1469, *(float2*)buf1470); *(float3*)buf1471 = max(*(float3*)buf1472, *(float3*)buf1473); *(float4*)buf1474 = max(*(float4*)buf1475, *(float4*)buf1476); - *(char*)buf1477 = max(*(char*)buf1478, *(char*)buf1479); - *(char2*)buf1480 = max(*(char2*)buf1481, *(char2*)buf1482); - *(char3*)buf1483 = max(*(char3*)buf1484, *(char3*)buf1485); - *(char4*)buf1486 = max(*(char4*)buf1487, *(char4*)buf1488); - *(uchar*)buf1489 = max(*(uchar*)buf1490, *(uchar*)buf1491); - *(uchar2*)buf1492 = max(*(uchar2*)buf1493, *(uchar2*)buf1494); - *(uchar3*)buf1495 = max(*(uchar3*)buf1496, *(uchar3*)buf1497); - *(uchar4*)buf1498 = max(*(uchar4*)buf1499, *(uchar4*)buf1500); - *(short*)buf1501 = max(*(short*)buf1502, *(short*)buf1503); - *(short2*)buf1504 = max(*(short2*)buf1505, *(short2*)buf1506); - *(short3*)buf1507 = max(*(short3*)buf1508, *(short3*)buf1509); - *(short4*)buf1510 = max(*(short4*)buf1511, *(short4*)buf1512); - *(ushort*)buf1513 = max(*(ushort*)buf1514, *(ushort*)buf1515); - *(ushort2*)buf1516 = max(*(ushort2*)buf1517, *(ushort2*)buf1518); - *(ushort3*)buf1519 = max(*(ushort3*)buf1520, *(ushort3*)buf1521); - *(ushort4*)buf1522 = max(*(ushort4*)buf1523, *(ushort4*)buf1524); - *(int*)buf1525 = max(*(int*)buf1526, *(int*)buf1527); - *(int2*)buf1528 = max(*(int2*)buf1529, *(int2*)buf1530); - *(int3*)buf1531 = max(*(int3*)buf1532, *(int3*)buf1533); - *(int4*)buf1534 = max(*(int4*)buf1535, *(int4*)buf1536); - *(uint*)buf1537 = max(*(uint*)buf1538, *(uint*)buf1539); - *(uint2*)buf1540 = max(*(uint2*)buf1541, *(uint2*)buf1542); - *(uint3*)buf1543 = max(*(uint3*)buf1544, *(uint3*)buf1545); - *(uint4*)buf1546 = max(*(uint4*)buf1547, *(uint4*)buf1548); - *(long*)buf1549 = max(*(long*)buf1550, *(long*)buf1551); - *(long2*)buf1552 = max(*(long2*)buf1553, *(long2*)buf1554); - *(long3*)buf1555 = max(*(long3*)buf1556, *(long3*)buf1557); - *(long4*)buf1558 = max(*(long4*)buf1559, *(long4*)buf1560); - *(ulong*)buf1561 = max(*(ulong*)buf1562, *(ulong*)buf1563); - *(ulong2*)buf1564 = max(*(ulong2*)buf1565, *(ulong2*)buf1566); - *(ulong3*)buf1567 = max(*(ulong3*)buf1568, *(ulong3*)buf1569); - *(ulong4*)buf1570 = max(*(ulong4*)buf1571, *(ulong4*)buf1572); - *(float*)buf1573 = min(*(float*)buf1574, *(float*)buf1575); - *(float2*)buf1576 = min(*(float2*)buf1577, *(float2*)buf1578); - *(float3*)buf1579 = min(*(float3*)buf1580, *(float3*)buf1581); - *(float4*)buf1582 = min(*(float4*)buf1583, *(float4*)buf1584); - *(char*)buf1585 = min(*(char*)buf1586, *(char*)buf1587); - *(char2*)buf1588 = min(*(char2*)buf1589, *(char2*)buf1590); - *(char3*)buf1591 = min(*(char3*)buf1592, *(char3*)buf1593); - *(char4*)buf1594 = min(*(char4*)buf1595, *(char4*)buf1596); - *(uchar*)buf1597 = min(*(uchar*)buf1598, *(uchar*)buf1599); - *(uchar2*)buf1600 = min(*(uchar2*)buf1601, *(uchar2*)buf1602); - *(uchar3*)buf1603 = min(*(uchar3*)buf1604, *(uchar3*)buf1605); - *(uchar4*)buf1606 = min(*(uchar4*)buf1607, *(uchar4*)buf1608); - *(short*)buf1609 = min(*(short*)buf1610, *(short*)buf1611); - *(short2*)buf1612 = min(*(short2*)buf1613, *(short2*)buf1614); - *(short3*)buf1615 = min(*(short3*)buf1616, *(short3*)buf1617); - *(short4*)buf1618 = min(*(short4*)buf1619, *(short4*)buf1620); - *(ushort*)buf1621 = min(*(ushort*)buf1622, *(ushort*)buf1623); - *(ushort2*)buf1624 = min(*(ushort2*)buf1625, *(ushort2*)buf1626); - *(ushort3*)buf1627 = min(*(ushort3*)buf1628, *(ushort3*)buf1629); - *(ushort4*)buf1630 = min(*(ushort4*)buf1631, *(ushort4*)buf1632); - *(int*)buf1633 = min(*(int*)buf1634, *(int*)buf1635); - *(int2*)buf1636 = min(*(int2*)buf1637, *(int2*)buf1638); - *(int3*)buf1639 = min(*(int3*)buf1640, *(int3*)buf1641); - *(int4*)buf1642 = min(*(int4*)buf1643, *(int4*)buf1644); - *(uint*)buf1645 = min(*(uint*)buf1646, *(uint*)buf1647); - *(uint2*)buf1648 = min(*(uint2*)buf1649, *(uint2*)buf1650); - *(uint3*)buf1651 = min(*(uint3*)buf1652, *(uint3*)buf1653); - *(uint4*)buf1654 = min(*(uint4*)buf1655, *(uint4*)buf1656); - *(long*)buf1657 = min(*(long*)buf1658, *(long*)buf1659); - *(long2*)buf1660 = min(*(long2*)buf1661, *(long2*)buf1662); - *(long3*)buf1663 = min(*(long3*)buf1664, *(long3*)buf1665); - *(long4*)buf1666 = min(*(long4*)buf1667, *(long4*)buf1668); - *(ulong*)buf1669 = min(*(ulong*)buf1670, *(ulong*)buf1671); - *(ulong2*)buf1672 = min(*(ulong2*)buf1673, *(ulong2*)buf1674); - *(ulong3*)buf1675 = min(*(ulong3*)buf1676, *(ulong3*)buf1677); - *(ulong4*)buf1678 = min(*(ulong4*)buf1679, *(ulong4*)buf1680); - *(float*)buf1681 = mix(*(float*)buf1682, *(float*)buf1683, *(float*)buf1684); - *(float2*)buf1685 = mix(*(float2*)buf1686, *(float2*)buf1687, *(float2*)buf1688); - *(float3*)buf1689 = mix(*(float3*)buf1690, *(float3*)buf1691, *(float3*)buf1692); - *(float4*)buf1693 = mix(*(float4*)buf1694, *(float4*)buf1695, *(float4*)buf1696); - *(float2*)buf1697 = mix(*(float2*)buf1698, *(float2*)buf1699, *(float*)buf1700); - *(float3*)buf1701 = mix(*(float3*)buf1702, *(float3*)buf1703, *(float*)buf1704); - *(float4*)buf1705 = mix(*(float4*)buf1706, *(float4*)buf1707, *(float*)buf1708); - *(float*)buf1709 = modf(*(float*)buf1710, (float*) buf1711); - *(float2*)buf1712 = modf(*(float2*)buf1713, (float2*) buf1714); - *(float3*)buf1715 = modf(*(float3*)buf1716, (float3*) buf1717); - *(float4*)buf1718 = modf(*(float4*)buf1719, (float4*) buf1720); - *(float*)buf1721 = nan(*(uint*)buf1722); - *(float*)buf1723 = native_acos(*(float*)buf1724); - *(float2*)buf1725 = native_acos(*(float2*)buf1726); - *(float3*)buf1727 = native_acos(*(float3*)buf1728); - *(float4*)buf1729 = native_acos(*(float4*)buf1730); - *(float*)buf1731 = native_acosh(*(float*)buf1732); - *(float2*)buf1733 = native_acosh(*(float2*)buf1734); - *(float3*)buf1735 = native_acosh(*(float3*)buf1736); - *(float4*)buf1737 = native_acosh(*(float4*)buf1738); - *(float*)buf1739 = native_acospi(*(float*)buf1740); - *(float2*)buf1741 = native_acospi(*(float2*)buf1742); - *(float3*)buf1743 = native_acospi(*(float3*)buf1744); - *(float4*)buf1745 = native_acospi(*(float4*)buf1746); - *(float*)buf1747 = native_asin(*(float*)buf1748); - *(float2*)buf1749 = native_asin(*(float2*)buf1750); - *(float3*)buf1751 = native_asin(*(float3*)buf1752); - *(float4*)buf1753 = native_asin(*(float4*)buf1754); - *(float*)buf1755 = native_asinh(*(float*)buf1756); - *(float2*)buf1757 = native_asinh(*(float2*)buf1758); - *(float3*)buf1759 = native_asinh(*(float3*)buf1760); - *(float4*)buf1761 = native_asinh(*(float4*)buf1762); - *(float*)buf1763 = native_asinpi(*(float*)buf1764); - *(float2*)buf1765 = native_asinpi(*(float2*)buf1766); - *(float3*)buf1767 = native_asinpi(*(float3*)buf1768); - *(float4*)buf1769 = native_asinpi(*(float4*)buf1770); - *(float*)buf1771 = native_atan(*(float*)buf1772); - *(float2*)buf1773 = native_atan(*(float2*)buf1774); - *(float3*)buf1775 = native_atan(*(float3*)buf1776); - *(float4*)buf1777 = native_atan(*(float4*)buf1778); - *(float*)buf1779 = native_atan2(*(float*)buf1780, *(float*)buf1781); - *(float2*)buf1782 = native_atan2(*(float2*)buf1783, *(float2*)buf1784); - *(float3*)buf1785 = native_atan2(*(float3*)buf1786, *(float3*)buf1787); - *(float4*)buf1788 = native_atan2(*(float4*)buf1789, *(float4*)buf1790); - *(float*)buf1791 = native_atan2pi(*(float*)buf1792, *(float*)buf1793); - *(float2*)buf1794 = native_atan2pi(*(float2*)buf1795, *(float2*)buf1796); - *(float3*)buf1797 = native_atan2pi(*(float3*)buf1798, *(float3*)buf1799); - *(float4*)buf1800 = native_atan2pi(*(float4*)buf1801, *(float4*)buf1802); - *(float*)buf1803 = native_atanh(*(float*)buf1804); - *(float2*)buf1805 = native_atanh(*(float2*)buf1806); - *(float3*)buf1807 = native_atanh(*(float3*)buf1808); - *(float4*)buf1809 = native_atanh(*(float4*)buf1810); - *(float*)buf1811 = native_atanpi(*(float*)buf1812); - *(float2*)buf1813 = native_atanpi(*(float2*)buf1814); - *(float3*)buf1815 = native_atanpi(*(float3*)buf1816); - *(float4*)buf1817 = native_atanpi(*(float4*)buf1818); - *(float*)buf1819 = native_cbrt(*(float*)buf1820); - *(float2*)buf1821 = native_cbrt(*(float2*)buf1822); - *(float3*)buf1823 = native_cbrt(*(float3*)buf1824); - *(float4*)buf1825 = native_cbrt(*(float4*)buf1826); - *(float*)buf1827 = native_cos(*(float*)buf1828); - *(float2*)buf1829 = native_cos(*(float2*)buf1830); - *(float3*)buf1831 = native_cos(*(float3*)buf1832); - *(float4*)buf1833 = native_cos(*(float4*)buf1834); - *(float*)buf1835 = native_cosh(*(float*)buf1836); - *(float2*)buf1837 = native_cosh(*(float2*)buf1838); - *(float3*)buf1839 = native_cosh(*(float3*)buf1840); - *(float4*)buf1841 = native_cosh(*(float4*)buf1842); - *(float*)buf1843 = native_cospi(*(float*)buf1844); - *(float2*)buf1845 = native_cospi(*(float2*)buf1846); - *(float3*)buf1847 = native_cospi(*(float3*)buf1848); - *(float4*)buf1849 = native_cospi(*(float4*)buf1850); - *(float*)buf1851 = native_distance(*(float*)buf1852, *(float*)buf1853); - *(float*)buf1854 = native_distance(*(float2*)buf1855, *(float2*)buf1856); - *(float*)buf1857 = native_distance(*(float3*)buf1858, *(float3*)buf1859); - *(float*)buf1860 = native_distance(*(float4*)buf1861, *(float4*)buf1862); - *(float*)buf1863 = native_divide(*(float*)buf1864, *(float*)buf1865); - *(float2*)buf1866 = native_divide(*(float2*)buf1867, *(float2*)buf1868); - *(float3*)buf1869 = native_divide(*(float3*)buf1870, *(float3*)buf1871); - *(float4*)buf1872 = native_divide(*(float4*)buf1873, *(float4*)buf1874); - *(float*)buf1875 = native_exp(*(float*)buf1876); - *(float2*)buf1877 = native_exp(*(float2*)buf1878); - *(float3*)buf1879 = native_exp(*(float3*)buf1880); - *(float4*)buf1881 = native_exp(*(float4*)buf1882); - *(float*)buf1883 = native_exp10(*(float*)buf1884); - *(float2*)buf1885 = native_exp10(*(float2*)buf1886); - *(float3*)buf1887 = native_exp10(*(float3*)buf1888); - *(float4*)buf1889 = native_exp10(*(float4*)buf1890); - *(float*)buf1891 = native_exp2(*(float*)buf1892); - *(float2*)buf1893 = native_exp2(*(float2*)buf1894); - *(float3*)buf1895 = native_exp2(*(float3*)buf1896); - *(float4*)buf1897 = native_exp2(*(float4*)buf1898); - *(float*)buf1899 = native_expm1(*(float*)buf1900); - *(float2*)buf1901 = native_expm1(*(float2*)buf1902); - *(float3*)buf1903 = native_expm1(*(float3*)buf1904); - *(float4*)buf1905 = native_expm1(*(float4*)buf1906); - *(float*)buf1907 = native_hypot(*(float*)buf1908, *(float*)buf1909); - *(float2*)buf1910 = native_hypot(*(float2*)buf1911, *(float2*)buf1912); - *(float3*)buf1913 = native_hypot(*(float3*)buf1914, *(float3*)buf1915); - *(float4*)buf1916 = native_hypot(*(float4*)buf1917, *(float4*)buf1918); - *(float*)buf1919 = native_length(*(float*)buf1920); - *(float*)buf1921 = native_length(*(float2*)buf1922); - *(float*)buf1923 = native_length(*(float3*)buf1924); - *(float*)buf1925 = native_length(*(float4*)buf1926); - *(float*)buf1927 = native_log(*(float*)buf1928); - *(float2*)buf1929 = native_log(*(float2*)buf1930); - *(float3*)buf1931 = native_log(*(float3*)buf1932); - *(float4*)buf1933 = native_log(*(float4*)buf1934); - *(float*)buf1935 = native_log10(*(float*)buf1936); - *(float2*)buf1937 = native_log10(*(float2*)buf1938); - *(float3*)buf1939 = native_log10(*(float3*)buf1940); - *(float4*)buf1941 = native_log10(*(float4*)buf1942); - *(float*)buf1943 = native_log1p(*(float*)buf1944); - *(float2*)buf1945 = native_log1p(*(float2*)buf1946); - *(float3*)buf1947 = native_log1p(*(float3*)buf1948); - *(float4*)buf1949 = native_log1p(*(float4*)buf1950); - *(float*)buf1951 = native_log2(*(float*)buf1952); - *(float2*)buf1953 = native_log2(*(float2*)buf1954); - *(float3*)buf1955 = native_log2(*(float3*)buf1956); - *(float4*)buf1957 = native_log2(*(float4*)buf1958); - *(float*)buf1959 = native_normalize(*(float*)buf1960); - *(float2*)buf1961 = native_normalize(*(float2*)buf1962); - *(float3*)buf1963 = native_normalize(*(float3*)buf1964); - *(float4*)buf1965 = native_normalize(*(float4*)buf1966); - *(float*)buf1967 = native_powr(*(float*)buf1968, *(float*)buf1969); - *(float2*)buf1970 = native_powr(*(float2*)buf1971, *(float2*)buf1972); - *(float3*)buf1973 = native_powr(*(float3*)buf1974, *(float3*)buf1975); - *(float4*)buf1976 = native_powr(*(float4*)buf1977, *(float4*)buf1978); - *(float*)buf1979 = native_recip(*(float*)buf1980); - *(float2*)buf1981 = native_recip(*(float2*)buf1982); - *(float3*)buf1983 = native_recip(*(float3*)buf1984); - *(float4*)buf1985 = native_recip(*(float4*)buf1986); - *(float*)buf1987 = native_rootn(*(float*)buf1988, *(int*)buf1989); - *(float2*)buf1990 = native_rootn(*(float2*)buf1991, *(int2*)buf1992); - *(float3*)buf1993 = native_rootn(*(float3*)buf1994, *(int3*)buf1995); - *(float4*)buf1996 = native_rootn(*(float4*)buf1997, *(int4*)buf1998); - *(float*)buf1999 = native_rsqrt(*(float*)buf2000); - *(float2*)buf2001 = native_rsqrt(*(float2*)buf2002); - *(float3*)buf2003 = native_rsqrt(*(float3*)buf2004); - *(float4*)buf2005 = native_rsqrt(*(float4*)buf2006); - *(float*)buf2007 = native_sin(*(float*)buf2008); - *(float2*)buf2009 = native_sin(*(float2*)buf2010); - *(float3*)buf2011 = native_sin(*(float3*)buf2012); - *(float4*)buf2013 = native_sin(*(float4*)buf2014); - *(float*)buf2015 = native_sincos(*(float*)buf2016, (float*) buf2017); - *(float2*)buf2018 = native_sincos(*(float2*)buf2019, (float2*) buf2020); - *(float3*)buf2021 = native_sincos(*(float3*)buf2022, (float3*) buf2023); - *(float4*)buf2024 = native_sincos(*(float4*)buf2025, (float4*) buf2026); - *(float*)buf2027 = native_sinh(*(float*)buf2028); - *(float2*)buf2029 = native_sinh(*(float2*)buf2030); - *(float3*)buf2031 = native_sinh(*(float3*)buf2032); - *(float4*)buf2033 = native_sinh(*(float4*)buf2034); - *(float*)buf2035 = native_sinpi(*(float*)buf2036); - *(float2*)buf2037 = native_sinpi(*(float2*)buf2038); - *(float3*)buf2039 = native_sinpi(*(float3*)buf2040); - *(float4*)buf2041 = native_sinpi(*(float4*)buf2042); - *(float*)buf2043 = native_sqrt(*(float*)buf2044); - *(float2*)buf2045 = native_sqrt(*(float2*)buf2046); - *(float3*)buf2047 = native_sqrt(*(float3*)buf2048); - *(float4*)buf2049 = native_sqrt(*(float4*)buf2050); - *(float*)buf2051 = native_tan(*(float*)buf2052); - *(float2*)buf2053 = native_tan(*(float2*)buf2054); - *(float3*)buf2055 = native_tan(*(float3*)buf2056); - *(float4*)buf2057 = native_tan(*(float4*)buf2058); - *(float*)buf2059 = native_tanh(*(float*)buf2060); - *(float2*)buf2061 = native_tanh(*(float2*)buf2062); - *(float3*)buf2063 = native_tanh(*(float3*)buf2064); - *(float4*)buf2065 = native_tanh(*(float4*)buf2066); - *(float*)buf2067 = native_tanpi(*(float*)buf2068); - *(float2*)buf2069 = native_tanpi(*(float2*)buf2070); - *(float3*)buf2071 = native_tanpi(*(float3*)buf2072); - *(float4*)buf2073 = native_tanpi(*(float4*)buf2074); - *(float*)buf2075 = nextafter(*(float*)buf2076, *(float*)buf2077); - *(float2*)buf2078 = nextafter(*(float2*)buf2079, *(float2*)buf2080); - *(float3*)buf2081 = nextafter(*(float3*)buf2082, *(float3*)buf2083); - *(float4*)buf2084 = nextafter(*(float4*)buf2085, *(float4*)buf2086); - *(float*)buf2087 = normalize(*(float*)buf2088); - *(float2*)buf2089 = normalize(*(float2*)buf2090); - *(float3*)buf2091 = normalize(*(float3*)buf2092); - *(float4*)buf2093 = normalize(*(float4*)buf2094); - *(float*)buf2095 = pow(*(float*)buf2096, *(float*)buf2097); - *(float2*)buf2098 = pow(*(float2*)buf2099, *(float2*)buf2100); - *(float3*)buf2101 = pow(*(float3*)buf2102, *(float3*)buf2103); - *(float4*)buf2104 = pow(*(float4*)buf2105, *(float4*)buf2106); - *(float*)buf2107 = pown(*(float*)buf2108, *(int*)buf2109); - *(float2*)buf2110 = pown(*(float2*)buf2111, *(int2*)buf2112); - *(float3*)buf2113 = pown(*(float3*)buf2114, *(int3*)buf2115); - *(float4*)buf2116 = pown(*(float4*)buf2117, *(int4*)buf2118); - *(float*)buf2119 = powr(*(float*)buf2120, *(float*)buf2121); - *(float2*)buf2122 = powr(*(float2*)buf2123, *(float2*)buf2124); - *(float3*)buf2125 = powr(*(float3*)buf2126, *(float3*)buf2127); - *(float4*)buf2128 = powr(*(float4*)buf2129, *(float4*)buf2130); - *(float*)buf2131 = radians(*(float*)buf2132); - *(float2*)buf2133 = radians(*(float2*)buf2134); - *(float3*)buf2135 = radians(*(float3*)buf2136); - *(float4*)buf2137 = radians(*(float4*)buf2138); - *(float*)buf2139 = remainder(*(float*)buf2140, *(float*)buf2141); - *(float2*)buf2142 = remainder(*(float2*)buf2143, *(float2*)buf2144); - *(float3*)buf2145 = remainder(*(float3*)buf2146, *(float3*)buf2147); - *(float4*)buf2148 = remainder(*(float4*)buf2149, *(float4*)buf2150); - *(float*)buf2151 = remquo(*(float*)buf2152, *(float*)buf2153, (int*) buf2154); - *(float2*)buf2155 = remquo(*(float2*)buf2156, *(float2*)buf2157, (int2*) buf2158); - *(float3*)buf2159 = remquo(*(float3*)buf2160, *(float3*)buf2161, (int3*) buf2162); - *(float4*)buf2163 = remquo(*(float4*)buf2164, *(float4*)buf2165, (int4*) buf2166); - *(float*)buf2167 = rint(*(float*)buf2168); - *(float2*)buf2169 = rint(*(float2*)buf2170); - *(float3*)buf2171 = rint(*(float3*)buf2172); - *(float4*)buf2173 = rint(*(float4*)buf2174); - *(float*)buf2175 = rootn(*(float*)buf2176, *(int*)buf2177); - *(float2*)buf2178 = rootn(*(float2*)buf2179, *(int2*)buf2180); - *(float3*)buf2181 = rootn(*(float3*)buf2182, *(int3*)buf2183); - *(float4*)buf2184 = rootn(*(float4*)buf2185, *(int4*)buf2186); - *(float*)buf2187 = round(*(float*)buf2188); - *(float2*)buf2189 = round(*(float2*)buf2190); - *(float3*)buf2191 = round(*(float3*)buf2192); - *(float4*)buf2193 = round(*(float4*)buf2194); - rsAllocationCopy1DRange(*(rs_allocation*)buf2195, *(uint32_t*)buf2196, *(uint32_t*)buf2197, *(uint32_t*)buf2198, *(rs_allocation*)buf2199, *(uint32_t*)buf2200, *(uint32_t*)buf2201); - rsAllocationCopy2DRange(*(rs_allocation*)buf2202, *(uint32_t*)buf2203, *(uint32_t*)buf2204, *(uint32_t*)buf2205, *(rs_allocation_cubemap_face*)buf2206, *(uint32_t*)buf2207, *(uint32_t*)buf2208, *(rs_allocation*)buf2209, *(uint32_t*)buf2210, *(uint32_t*)buf2211, *(uint32_t*)buf2212, *(rs_allocation_cubemap_face*)buf2213); - *(uint32_t*)buf2214 = rsAllocationGetDimFaces(*(rs_allocation*)buf2215); - *(uint32_t*)buf2216 = rsAllocationGetDimLOD(*(rs_allocation*)buf2217); - *(uint32_t*)buf2218 = rsAllocationGetDimX(*(rs_allocation*)buf2219); - *(uint32_t*)buf2220 = rsAllocationGetDimY(*(rs_allocation*)buf2221); - *(uint32_t*)buf2222 = rsAllocationGetDimZ(*(rs_allocation*)buf2223); - *(rs_element*)buf2224 = rsAllocationGetElement(*(rs_allocation*)buf2225); - rsAllocationIoReceive(*(rs_allocation*)buf2226); - rsAllocationIoSend(*(rs_allocation*)buf2227); - *(float2*)buf2228 = rsAllocationVLoadX_float2(*(rs_allocation*)buf2229, *(uint32_t*)buf2230); - *(float3*)buf2231 = rsAllocationVLoadX_float3(*(rs_allocation*)buf2232, *(uint32_t*)buf2233); - *(float4*)buf2234 = rsAllocationVLoadX_float4(*(rs_allocation*)buf2235, *(uint32_t*)buf2236); - *(double2*)buf2237 = rsAllocationVLoadX_double2(*(rs_allocation*)buf2238, *(uint32_t*)buf2239); - *(double3*)buf2240 = rsAllocationVLoadX_double3(*(rs_allocation*)buf2241, *(uint32_t*)buf2242); - *(double4*)buf2243 = rsAllocationVLoadX_double4(*(rs_allocation*)buf2244, *(uint32_t*)buf2245); - *(char2*)buf2246 = rsAllocationVLoadX_char2(*(rs_allocation*)buf2247, *(uint32_t*)buf2248); - *(char3*)buf2249 = rsAllocationVLoadX_char3(*(rs_allocation*)buf2250, *(uint32_t*)buf2251); - *(char4*)buf2252 = rsAllocationVLoadX_char4(*(rs_allocation*)buf2253, *(uint32_t*)buf2254); - *(uchar2*)buf2255 = rsAllocationVLoadX_uchar2(*(rs_allocation*)buf2256, *(uint32_t*)buf2257); - *(uchar3*)buf2258 = rsAllocationVLoadX_uchar3(*(rs_allocation*)buf2259, *(uint32_t*)buf2260); - *(uchar4*)buf2261 = rsAllocationVLoadX_uchar4(*(rs_allocation*)buf2262, *(uint32_t*)buf2263); - *(short2*)buf2264 = rsAllocationVLoadX_short2(*(rs_allocation*)buf2265, *(uint32_t*)buf2266); - *(short3*)buf2267 = rsAllocationVLoadX_short3(*(rs_allocation*)buf2268, *(uint32_t*)buf2269); - *(short4*)buf2270 = rsAllocationVLoadX_short4(*(rs_allocation*)buf2271, *(uint32_t*)buf2272); - *(ushort2*)buf2273 = rsAllocationVLoadX_ushort2(*(rs_allocation*)buf2274, *(uint32_t*)buf2275); - *(ushort3*)buf2276 = rsAllocationVLoadX_ushort3(*(rs_allocation*)buf2277, *(uint32_t*)buf2278); - *(ushort4*)buf2279 = rsAllocationVLoadX_ushort4(*(rs_allocation*)buf2280, *(uint32_t*)buf2281); - *(int2*)buf2282 = rsAllocationVLoadX_int2(*(rs_allocation*)buf2283, *(uint32_t*)buf2284); - *(int3*)buf2285 = rsAllocationVLoadX_int3(*(rs_allocation*)buf2286, *(uint32_t*)buf2287); - *(int4*)buf2288 = rsAllocationVLoadX_int4(*(rs_allocation*)buf2289, *(uint32_t*)buf2290); - *(uint2*)buf2291 = rsAllocationVLoadX_uint2(*(rs_allocation*)buf2292, *(uint32_t*)buf2293); - *(uint3*)buf2294 = rsAllocationVLoadX_uint3(*(rs_allocation*)buf2295, *(uint32_t*)buf2296); - *(uint4*)buf2297 = rsAllocationVLoadX_uint4(*(rs_allocation*)buf2298, *(uint32_t*)buf2299); - *(long2*)buf2300 = rsAllocationVLoadX_long2(*(rs_allocation*)buf2301, *(uint32_t*)buf2302); - *(long3*)buf2303 = rsAllocationVLoadX_long3(*(rs_allocation*)buf2304, *(uint32_t*)buf2305); - *(long4*)buf2306 = rsAllocationVLoadX_long4(*(rs_allocation*)buf2307, *(uint32_t*)buf2308); - *(ulong2*)buf2309 = rsAllocationVLoadX_ulong2(*(rs_allocation*)buf2310, *(uint32_t*)buf2311); - *(ulong3*)buf2312 = rsAllocationVLoadX_ulong3(*(rs_allocation*)buf2313, *(uint32_t*)buf2314); - *(ulong4*)buf2315 = rsAllocationVLoadX_ulong4(*(rs_allocation*)buf2316, *(uint32_t*)buf2317); - *(float2*)buf2318 = rsAllocationVLoadX_float2(*(rs_allocation*)buf2319, *(uint32_t*)buf2320, *(uint32_t*)buf2321); - *(float3*)buf2322 = rsAllocationVLoadX_float3(*(rs_allocation*)buf2323, *(uint32_t*)buf2324, *(uint32_t*)buf2325); - *(float4*)buf2326 = rsAllocationVLoadX_float4(*(rs_allocation*)buf2327, *(uint32_t*)buf2328, *(uint32_t*)buf2329); - *(double2*)buf2330 = rsAllocationVLoadX_double2(*(rs_allocation*)buf2331, *(uint32_t*)buf2332, *(uint32_t*)buf2333); - *(double3*)buf2334 = rsAllocationVLoadX_double3(*(rs_allocation*)buf2335, *(uint32_t*)buf2336, *(uint32_t*)buf2337); - *(double4*)buf2338 = rsAllocationVLoadX_double4(*(rs_allocation*)buf2339, *(uint32_t*)buf2340, *(uint32_t*)buf2341); - *(char2*)buf2342 = rsAllocationVLoadX_char2(*(rs_allocation*)buf2343, *(uint32_t*)buf2344, *(uint32_t*)buf2345); - *(char3*)buf2346 = rsAllocationVLoadX_char3(*(rs_allocation*)buf2347, *(uint32_t*)buf2348, *(uint32_t*)buf2349); - *(char4*)buf2350 = rsAllocationVLoadX_char4(*(rs_allocation*)buf2351, *(uint32_t*)buf2352, *(uint32_t*)buf2353); - *(uchar2*)buf2354 = rsAllocationVLoadX_uchar2(*(rs_allocation*)buf2355, *(uint32_t*)buf2356, *(uint32_t*)buf2357); - *(uchar3*)buf2358 = rsAllocationVLoadX_uchar3(*(rs_allocation*)buf2359, *(uint32_t*)buf2360, *(uint32_t*)buf2361); - *(uchar4*)buf2362 = rsAllocationVLoadX_uchar4(*(rs_allocation*)buf2363, *(uint32_t*)buf2364, *(uint32_t*)buf2365); - *(short2*)buf2366 = rsAllocationVLoadX_short2(*(rs_allocation*)buf2367, *(uint32_t*)buf2368, *(uint32_t*)buf2369); - *(short3*)buf2370 = rsAllocationVLoadX_short3(*(rs_allocation*)buf2371, *(uint32_t*)buf2372, *(uint32_t*)buf2373); - *(short4*)buf2374 = rsAllocationVLoadX_short4(*(rs_allocation*)buf2375, *(uint32_t*)buf2376, *(uint32_t*)buf2377); - *(ushort2*)buf2378 = rsAllocationVLoadX_ushort2(*(rs_allocation*)buf2379, *(uint32_t*)buf2380, *(uint32_t*)buf2381); - *(ushort3*)buf2382 = rsAllocationVLoadX_ushort3(*(rs_allocation*)buf2383, *(uint32_t*)buf2384, *(uint32_t*)buf2385); - *(ushort4*)buf2386 = rsAllocationVLoadX_ushort4(*(rs_allocation*)buf2387, *(uint32_t*)buf2388, *(uint32_t*)buf2389); - *(int2*)buf2390 = rsAllocationVLoadX_int2(*(rs_allocation*)buf2391, *(uint32_t*)buf2392, *(uint32_t*)buf2393); - *(int3*)buf2394 = rsAllocationVLoadX_int3(*(rs_allocation*)buf2395, *(uint32_t*)buf2396, *(uint32_t*)buf2397); - *(int4*)buf2398 = rsAllocationVLoadX_int4(*(rs_allocation*)buf2399, *(uint32_t*)buf2400, *(uint32_t*)buf2401); - *(uint2*)buf2402 = rsAllocationVLoadX_uint2(*(rs_allocation*)buf2403, *(uint32_t*)buf2404, *(uint32_t*)buf2405); - *(uint3*)buf2406 = rsAllocationVLoadX_uint3(*(rs_allocation*)buf2407, *(uint32_t*)buf2408, *(uint32_t*)buf2409); - *(uint4*)buf2410 = rsAllocationVLoadX_uint4(*(rs_allocation*)buf2411, *(uint32_t*)buf2412, *(uint32_t*)buf2413); - *(long2*)buf2414 = rsAllocationVLoadX_long2(*(rs_allocation*)buf2415, *(uint32_t*)buf2416, *(uint32_t*)buf2417); - *(long3*)buf2418 = rsAllocationVLoadX_long3(*(rs_allocation*)buf2419, *(uint32_t*)buf2420, *(uint32_t*)buf2421); - *(long4*)buf2422 = rsAllocationVLoadX_long4(*(rs_allocation*)buf2423, *(uint32_t*)buf2424, *(uint32_t*)buf2425); - *(ulong2*)buf2426 = rsAllocationVLoadX_ulong2(*(rs_allocation*)buf2427, *(uint32_t*)buf2428, *(uint32_t*)buf2429); - *(ulong3*)buf2430 = rsAllocationVLoadX_ulong3(*(rs_allocation*)buf2431, *(uint32_t*)buf2432, *(uint32_t*)buf2433); - *(ulong4*)buf2434 = rsAllocationVLoadX_ulong4(*(rs_allocation*)buf2435, *(uint32_t*)buf2436, *(uint32_t*)buf2437); - *(float2*)buf2438 = rsAllocationVLoadX_float2(*(rs_allocation*)buf2439, *(uint32_t*)buf2440, *(uint32_t*)buf2441, *(uint32_t*)buf2442); - *(float3*)buf2443 = rsAllocationVLoadX_float3(*(rs_allocation*)buf2444, *(uint32_t*)buf2445, *(uint32_t*)buf2446, *(uint32_t*)buf2447); - *(float4*)buf2448 = rsAllocationVLoadX_float4(*(rs_allocation*)buf2449, *(uint32_t*)buf2450, *(uint32_t*)buf2451, *(uint32_t*)buf2452); - *(double2*)buf2453 = rsAllocationVLoadX_double2(*(rs_allocation*)buf2454, *(uint32_t*)buf2455, *(uint32_t*)buf2456, *(uint32_t*)buf2457); - *(double3*)buf2458 = rsAllocationVLoadX_double3(*(rs_allocation*)buf2459, *(uint32_t*)buf2460, *(uint32_t*)buf2461, *(uint32_t*)buf2462); - *(double4*)buf2463 = rsAllocationVLoadX_double4(*(rs_allocation*)buf2464, *(uint32_t*)buf2465, *(uint32_t*)buf2466, *(uint32_t*)buf2467); - *(char2*)buf2468 = rsAllocationVLoadX_char2(*(rs_allocation*)buf2469, *(uint32_t*)buf2470, *(uint32_t*)buf2471, *(uint32_t*)buf2472); - *(char3*)buf2473 = rsAllocationVLoadX_char3(*(rs_allocation*)buf2474, *(uint32_t*)buf2475, *(uint32_t*)buf2476, *(uint32_t*)buf2477); - *(char4*)buf2478 = rsAllocationVLoadX_char4(*(rs_allocation*)buf2479, *(uint32_t*)buf2480, *(uint32_t*)buf2481, *(uint32_t*)buf2482); - *(uchar2*)buf2483 = rsAllocationVLoadX_uchar2(*(rs_allocation*)buf2484, *(uint32_t*)buf2485, *(uint32_t*)buf2486, *(uint32_t*)buf2487); - *(uchar3*)buf2488 = rsAllocationVLoadX_uchar3(*(rs_allocation*)buf2489, *(uint32_t*)buf2490, *(uint32_t*)buf2491, *(uint32_t*)buf2492); - *(uchar4*)buf2493 = rsAllocationVLoadX_uchar4(*(rs_allocation*)buf2494, *(uint32_t*)buf2495, *(uint32_t*)buf2496, *(uint32_t*)buf2497); - *(short2*)buf2498 = rsAllocationVLoadX_short2(*(rs_allocation*)buf2499, *(uint32_t*)buf2500, *(uint32_t*)buf2501, *(uint32_t*)buf2502); - *(short3*)buf2503 = rsAllocationVLoadX_short3(*(rs_allocation*)buf2504, *(uint32_t*)buf2505, *(uint32_t*)buf2506, *(uint32_t*)buf2507); - *(short4*)buf2508 = rsAllocationVLoadX_short4(*(rs_allocation*)buf2509, *(uint32_t*)buf2510, *(uint32_t*)buf2511, *(uint32_t*)buf2512); - *(ushort2*)buf2513 = rsAllocationVLoadX_ushort2(*(rs_allocation*)buf2514, *(uint32_t*)buf2515, *(uint32_t*)buf2516, *(uint32_t*)buf2517); - *(ushort3*)buf2518 = rsAllocationVLoadX_ushort3(*(rs_allocation*)buf2519, *(uint32_t*)buf2520, *(uint32_t*)buf2521, *(uint32_t*)buf2522); - *(ushort4*)buf2523 = rsAllocationVLoadX_ushort4(*(rs_allocation*)buf2524, *(uint32_t*)buf2525, *(uint32_t*)buf2526, *(uint32_t*)buf2527); - *(int2*)buf2528 = rsAllocationVLoadX_int2(*(rs_allocation*)buf2529, *(uint32_t*)buf2530, *(uint32_t*)buf2531, *(uint32_t*)buf2532); - *(int3*)buf2533 = rsAllocationVLoadX_int3(*(rs_allocation*)buf2534, *(uint32_t*)buf2535, *(uint32_t*)buf2536, *(uint32_t*)buf2537); - *(int4*)buf2538 = rsAllocationVLoadX_int4(*(rs_allocation*)buf2539, *(uint32_t*)buf2540, *(uint32_t*)buf2541, *(uint32_t*)buf2542); - *(uint2*)buf2543 = rsAllocationVLoadX_uint2(*(rs_allocation*)buf2544, *(uint32_t*)buf2545, *(uint32_t*)buf2546, *(uint32_t*)buf2547); - *(uint3*)buf2548 = rsAllocationVLoadX_uint3(*(rs_allocation*)buf2549, *(uint32_t*)buf2550, *(uint32_t*)buf2551, *(uint32_t*)buf2552); - *(uint4*)buf2553 = rsAllocationVLoadX_uint4(*(rs_allocation*)buf2554, *(uint32_t*)buf2555, *(uint32_t*)buf2556, *(uint32_t*)buf2557); - *(long2*)buf2558 = rsAllocationVLoadX_long2(*(rs_allocation*)buf2559, *(uint32_t*)buf2560, *(uint32_t*)buf2561, *(uint32_t*)buf2562); - *(long3*)buf2563 = rsAllocationVLoadX_long3(*(rs_allocation*)buf2564, *(uint32_t*)buf2565, *(uint32_t*)buf2566, *(uint32_t*)buf2567); - *(long4*)buf2568 = rsAllocationVLoadX_long4(*(rs_allocation*)buf2569, *(uint32_t*)buf2570, *(uint32_t*)buf2571, *(uint32_t*)buf2572); - *(ulong2*)buf2573 = rsAllocationVLoadX_ulong2(*(rs_allocation*)buf2574, *(uint32_t*)buf2575, *(uint32_t*)buf2576, *(uint32_t*)buf2577); - *(ulong3*)buf2578 = rsAllocationVLoadX_ulong3(*(rs_allocation*)buf2579, *(uint32_t*)buf2580, *(uint32_t*)buf2581, *(uint32_t*)buf2582); - *(ulong4*)buf2583 = rsAllocationVLoadX_ulong4(*(rs_allocation*)buf2584, *(uint32_t*)buf2585, *(uint32_t*)buf2586, *(uint32_t*)buf2587); - rsAllocationVStoreX_float2(*(rs_allocation*)buf2588, *(float2*)buf2589, *(uint32_t*)buf2590); - rsAllocationVStoreX_float3(*(rs_allocation*)buf2591, *(float3*)buf2592, *(uint32_t*)buf2593); - rsAllocationVStoreX_float4(*(rs_allocation*)buf2594, *(float4*)buf2595, *(uint32_t*)buf2596); - rsAllocationVStoreX_double2(*(rs_allocation*)buf2597, *(double2*)buf2598, *(uint32_t*)buf2599); - rsAllocationVStoreX_double3(*(rs_allocation*)buf2600, *(double3*)buf2601, *(uint32_t*)buf2602); - rsAllocationVStoreX_double4(*(rs_allocation*)buf2603, *(double4*)buf2604, *(uint32_t*)buf2605); - rsAllocationVStoreX_char2(*(rs_allocation*)buf2606, *(char2*)buf2607, *(uint32_t*)buf2608); - rsAllocationVStoreX_char3(*(rs_allocation*)buf2609, *(char3*)buf2610, *(uint32_t*)buf2611); - rsAllocationVStoreX_char4(*(rs_allocation*)buf2612, *(char4*)buf2613, *(uint32_t*)buf2614); - rsAllocationVStoreX_uchar2(*(rs_allocation*)buf2615, *(uchar2*)buf2616, *(uint32_t*)buf2617); - rsAllocationVStoreX_uchar3(*(rs_allocation*)buf2618, *(uchar3*)buf2619, *(uint32_t*)buf2620); - rsAllocationVStoreX_uchar4(*(rs_allocation*)buf2621, *(uchar4*)buf2622, *(uint32_t*)buf2623); - rsAllocationVStoreX_short2(*(rs_allocation*)buf2624, *(short2*)buf2625, *(uint32_t*)buf2626); - rsAllocationVStoreX_short3(*(rs_allocation*)buf2627, *(short3*)buf2628, *(uint32_t*)buf2629); - rsAllocationVStoreX_short4(*(rs_allocation*)buf2630, *(short4*)buf2631, *(uint32_t*)buf2632); - rsAllocationVStoreX_ushort2(*(rs_allocation*)buf2633, *(ushort2*)buf2634, *(uint32_t*)buf2635); - rsAllocationVStoreX_ushort3(*(rs_allocation*)buf2636, *(ushort3*)buf2637, *(uint32_t*)buf2638); - rsAllocationVStoreX_ushort4(*(rs_allocation*)buf2639, *(ushort4*)buf2640, *(uint32_t*)buf2641); - rsAllocationVStoreX_int2(*(rs_allocation*)buf2642, *(int2*)buf2643, *(uint32_t*)buf2644); - rsAllocationVStoreX_int3(*(rs_allocation*)buf2645, *(int3*)buf2646, *(uint32_t*)buf2647); - rsAllocationVStoreX_int4(*(rs_allocation*)buf2648, *(int4*)buf2649, *(uint32_t*)buf2650); - rsAllocationVStoreX_uint2(*(rs_allocation*)buf2651, *(uint2*)buf2652, *(uint32_t*)buf2653); - rsAllocationVStoreX_uint3(*(rs_allocation*)buf2654, *(uint3*)buf2655, *(uint32_t*)buf2656); - rsAllocationVStoreX_uint4(*(rs_allocation*)buf2657, *(uint4*)buf2658, *(uint32_t*)buf2659); - rsAllocationVStoreX_long2(*(rs_allocation*)buf2660, *(long2*)buf2661, *(uint32_t*)buf2662); - rsAllocationVStoreX_long3(*(rs_allocation*)buf2663, *(long3*)buf2664, *(uint32_t*)buf2665); - rsAllocationVStoreX_long4(*(rs_allocation*)buf2666, *(long4*)buf2667, *(uint32_t*)buf2668); - rsAllocationVStoreX_ulong2(*(rs_allocation*)buf2669, *(ulong2*)buf2670, *(uint32_t*)buf2671); - rsAllocationVStoreX_ulong3(*(rs_allocation*)buf2672, *(ulong3*)buf2673, *(uint32_t*)buf2674); - rsAllocationVStoreX_ulong4(*(rs_allocation*)buf2675, *(ulong4*)buf2676, *(uint32_t*)buf2677); - rsAllocationVStoreX_float2(*(rs_allocation*)buf2678, *(float2*)buf2679, *(uint32_t*)buf2680, *(uint32_t*)buf2681); - rsAllocationVStoreX_float3(*(rs_allocation*)buf2682, *(float3*)buf2683, *(uint32_t*)buf2684, *(uint32_t*)buf2685); - rsAllocationVStoreX_float4(*(rs_allocation*)buf2686, *(float4*)buf2687, *(uint32_t*)buf2688, *(uint32_t*)buf2689); - rsAllocationVStoreX_double2(*(rs_allocation*)buf2690, *(double2*)buf2691, *(uint32_t*)buf2692, *(uint32_t*)buf2693); - rsAllocationVStoreX_double3(*(rs_allocation*)buf2694, *(double3*)buf2695, *(uint32_t*)buf2696, *(uint32_t*)buf2697); - rsAllocationVStoreX_double4(*(rs_allocation*)buf2698, *(double4*)buf2699, *(uint32_t*)buf2700, *(uint32_t*)buf2701); - rsAllocationVStoreX_char2(*(rs_allocation*)buf2702, *(char2*)buf2703, *(uint32_t*)buf2704, *(uint32_t*)buf2705); - rsAllocationVStoreX_char3(*(rs_allocation*)buf2706, *(char3*)buf2707, *(uint32_t*)buf2708, *(uint32_t*)buf2709); - rsAllocationVStoreX_char4(*(rs_allocation*)buf2710, *(char4*)buf2711, *(uint32_t*)buf2712, *(uint32_t*)buf2713); - rsAllocationVStoreX_uchar2(*(rs_allocation*)buf2714, *(uchar2*)buf2715, *(uint32_t*)buf2716, *(uint32_t*)buf2717); - rsAllocationVStoreX_uchar3(*(rs_allocation*)buf2718, *(uchar3*)buf2719, *(uint32_t*)buf2720, *(uint32_t*)buf2721); - rsAllocationVStoreX_uchar4(*(rs_allocation*)buf2722, *(uchar4*)buf2723, *(uint32_t*)buf2724, *(uint32_t*)buf2725); - rsAllocationVStoreX_short2(*(rs_allocation*)buf2726, *(short2*)buf2727, *(uint32_t*)buf2728, *(uint32_t*)buf2729); - rsAllocationVStoreX_short3(*(rs_allocation*)buf2730, *(short3*)buf2731, *(uint32_t*)buf2732, *(uint32_t*)buf2733); - rsAllocationVStoreX_short4(*(rs_allocation*)buf2734, *(short4*)buf2735, *(uint32_t*)buf2736, *(uint32_t*)buf2737); - rsAllocationVStoreX_ushort2(*(rs_allocation*)buf2738, *(ushort2*)buf2739, *(uint32_t*)buf2740, *(uint32_t*)buf2741); - rsAllocationVStoreX_ushort3(*(rs_allocation*)buf2742, *(ushort3*)buf2743, *(uint32_t*)buf2744, *(uint32_t*)buf2745); - rsAllocationVStoreX_ushort4(*(rs_allocation*)buf2746, *(ushort4*)buf2747, *(uint32_t*)buf2748, *(uint32_t*)buf2749); - rsAllocationVStoreX_int2(*(rs_allocation*)buf2750, *(int2*)buf2751, *(uint32_t*)buf2752, *(uint32_t*)buf2753); - rsAllocationVStoreX_int3(*(rs_allocation*)buf2754, *(int3*)buf2755, *(uint32_t*)buf2756, *(uint32_t*)buf2757); - rsAllocationVStoreX_int4(*(rs_allocation*)buf2758, *(int4*)buf2759, *(uint32_t*)buf2760, *(uint32_t*)buf2761); - rsAllocationVStoreX_uint2(*(rs_allocation*)buf2762, *(uint2*)buf2763, *(uint32_t*)buf2764, *(uint32_t*)buf2765); - rsAllocationVStoreX_uint3(*(rs_allocation*)buf2766, *(uint3*)buf2767, *(uint32_t*)buf2768, *(uint32_t*)buf2769); - rsAllocationVStoreX_uint4(*(rs_allocation*)buf2770, *(uint4*)buf2771, *(uint32_t*)buf2772, *(uint32_t*)buf2773); - rsAllocationVStoreX_long2(*(rs_allocation*)buf2774, *(long2*)buf2775, *(uint32_t*)buf2776, *(uint32_t*)buf2777); - rsAllocationVStoreX_long3(*(rs_allocation*)buf2778, *(long3*)buf2779, *(uint32_t*)buf2780, *(uint32_t*)buf2781); - rsAllocationVStoreX_long4(*(rs_allocation*)buf2782, *(long4*)buf2783, *(uint32_t*)buf2784, *(uint32_t*)buf2785); - rsAllocationVStoreX_ulong2(*(rs_allocation*)buf2786, *(ulong2*)buf2787, *(uint32_t*)buf2788, *(uint32_t*)buf2789); - rsAllocationVStoreX_ulong3(*(rs_allocation*)buf2790, *(ulong3*)buf2791, *(uint32_t*)buf2792, *(uint32_t*)buf2793); - rsAllocationVStoreX_ulong4(*(rs_allocation*)buf2794, *(ulong4*)buf2795, *(uint32_t*)buf2796, *(uint32_t*)buf2797); - rsAllocationVStoreX_float2(*(rs_allocation*)buf2798, *(float2*)buf2799, *(uint32_t*)buf2800, *(uint32_t*)buf2801, *(uint32_t*)buf2802); - rsAllocationVStoreX_float3(*(rs_allocation*)buf2803, *(float3*)buf2804, *(uint32_t*)buf2805, *(uint32_t*)buf2806, *(uint32_t*)buf2807); - rsAllocationVStoreX_float4(*(rs_allocation*)buf2808, *(float4*)buf2809, *(uint32_t*)buf2810, *(uint32_t*)buf2811, *(uint32_t*)buf2812); - rsAllocationVStoreX_double2(*(rs_allocation*)buf2813, *(double2*)buf2814, *(uint32_t*)buf2815, *(uint32_t*)buf2816, *(uint32_t*)buf2817); - rsAllocationVStoreX_double3(*(rs_allocation*)buf2818, *(double3*)buf2819, *(uint32_t*)buf2820, *(uint32_t*)buf2821, *(uint32_t*)buf2822); - rsAllocationVStoreX_double4(*(rs_allocation*)buf2823, *(double4*)buf2824, *(uint32_t*)buf2825, *(uint32_t*)buf2826, *(uint32_t*)buf2827); - rsAllocationVStoreX_char2(*(rs_allocation*)buf2828, *(char2*)buf2829, *(uint32_t*)buf2830, *(uint32_t*)buf2831, *(uint32_t*)buf2832); - rsAllocationVStoreX_char3(*(rs_allocation*)buf2833, *(char3*)buf2834, *(uint32_t*)buf2835, *(uint32_t*)buf2836, *(uint32_t*)buf2837); - rsAllocationVStoreX_char4(*(rs_allocation*)buf2838, *(char4*)buf2839, *(uint32_t*)buf2840, *(uint32_t*)buf2841, *(uint32_t*)buf2842); - rsAllocationVStoreX_uchar2(*(rs_allocation*)buf2843, *(uchar2*)buf2844, *(uint32_t*)buf2845, *(uint32_t*)buf2846, *(uint32_t*)buf2847); - rsAllocationVStoreX_uchar3(*(rs_allocation*)buf2848, *(uchar3*)buf2849, *(uint32_t*)buf2850, *(uint32_t*)buf2851, *(uint32_t*)buf2852); - rsAllocationVStoreX_uchar4(*(rs_allocation*)buf2853, *(uchar4*)buf2854, *(uint32_t*)buf2855, *(uint32_t*)buf2856, *(uint32_t*)buf2857); - rsAllocationVStoreX_short2(*(rs_allocation*)buf2858, *(short2*)buf2859, *(uint32_t*)buf2860, *(uint32_t*)buf2861, *(uint32_t*)buf2862); - rsAllocationVStoreX_short3(*(rs_allocation*)buf2863, *(short3*)buf2864, *(uint32_t*)buf2865, *(uint32_t*)buf2866, *(uint32_t*)buf2867); - rsAllocationVStoreX_short4(*(rs_allocation*)buf2868, *(short4*)buf2869, *(uint32_t*)buf2870, *(uint32_t*)buf2871, *(uint32_t*)buf2872); - rsAllocationVStoreX_ushort2(*(rs_allocation*)buf2873, *(ushort2*)buf2874, *(uint32_t*)buf2875, *(uint32_t*)buf2876, *(uint32_t*)buf2877); - rsAllocationVStoreX_ushort3(*(rs_allocation*)buf2878, *(ushort3*)buf2879, *(uint32_t*)buf2880, *(uint32_t*)buf2881, *(uint32_t*)buf2882); - rsAllocationVStoreX_ushort4(*(rs_allocation*)buf2883, *(ushort4*)buf2884, *(uint32_t*)buf2885, *(uint32_t*)buf2886, *(uint32_t*)buf2887); - rsAllocationVStoreX_int2(*(rs_allocation*)buf2888, *(int2*)buf2889, *(uint32_t*)buf2890, *(uint32_t*)buf2891, *(uint32_t*)buf2892); - rsAllocationVStoreX_int3(*(rs_allocation*)buf2893, *(int3*)buf2894, *(uint32_t*)buf2895, *(uint32_t*)buf2896, *(uint32_t*)buf2897); - rsAllocationVStoreX_int4(*(rs_allocation*)buf2898, *(int4*)buf2899, *(uint32_t*)buf2900, *(uint32_t*)buf2901, *(uint32_t*)buf2902); - rsAllocationVStoreX_uint2(*(rs_allocation*)buf2903, *(uint2*)buf2904, *(uint32_t*)buf2905, *(uint32_t*)buf2906, *(uint32_t*)buf2907); - rsAllocationVStoreX_uint3(*(rs_allocation*)buf2908, *(uint3*)buf2909, *(uint32_t*)buf2910, *(uint32_t*)buf2911, *(uint32_t*)buf2912); - rsAllocationVStoreX_uint4(*(rs_allocation*)buf2913, *(uint4*)buf2914, *(uint32_t*)buf2915, *(uint32_t*)buf2916, *(uint32_t*)buf2917); - rsAllocationVStoreX_long2(*(rs_allocation*)buf2918, *(long2*)buf2919, *(uint32_t*)buf2920, *(uint32_t*)buf2921, *(uint32_t*)buf2922); - rsAllocationVStoreX_long3(*(rs_allocation*)buf2923, *(long3*)buf2924, *(uint32_t*)buf2925, *(uint32_t*)buf2926, *(uint32_t*)buf2927); - rsAllocationVStoreX_long4(*(rs_allocation*)buf2928, *(long4*)buf2929, *(uint32_t*)buf2930, *(uint32_t*)buf2931, *(uint32_t*)buf2932); - rsAllocationVStoreX_ulong2(*(rs_allocation*)buf2933, *(ulong2*)buf2934, *(uint32_t*)buf2935, *(uint32_t*)buf2936, *(uint32_t*)buf2937); - rsAllocationVStoreX_ulong3(*(rs_allocation*)buf2938, *(ulong3*)buf2939, *(uint32_t*)buf2940, *(uint32_t*)buf2941, *(uint32_t*)buf2942); - rsAllocationVStoreX_ulong4(*(rs_allocation*)buf2943, *(ulong4*)buf2944, *(uint32_t*)buf2945, *(uint32_t*)buf2946, *(uint32_t*)buf2947); - *(int32_t*)buf2948 = rsAtomicAdd((volatile int32_t*) buf2949, *(int32_t*)buf2950); - *(int32_t*)buf2951 = rsAtomicAdd((volatile uint32_t*) buf2952, *(uint32_t*)buf2953); - *(int32_t*)buf2954 = rsAtomicAnd((volatile int32_t*) buf2955, *(int32_t*)buf2956); - *(int32_t*)buf2957 = rsAtomicAnd((volatile uint32_t*) buf2958, *(uint32_t*)buf2959); - *(int32_t*)buf2960 = rsAtomicCas((volatile int32_t*) buf2961, *(int32_t*)buf2962, *(int32_t*)buf2963); - *(uint32_t*)buf2964 = rsAtomicCas((volatile uint32_t*) buf2965, *(uint32_t*)buf2966, *(uint32_t*)buf2967); - *(int32_t*)buf2968 = rsAtomicDec((volatile int32_t*) buf2969); - *(int32_t*)buf2970 = rsAtomicDec((volatile uint32_t*) buf2971); - *(int32_t*)buf2972 = rsAtomicInc((volatile int32_t*) buf2973); - *(int32_t*)buf2974 = rsAtomicInc((volatile uint32_t*) buf2975); - *(uint32_t*)buf2976 = rsAtomicMax((volatile uint32_t*) buf2977, *(uint32_t*)buf2978); - *(int32_t*)buf2979 = rsAtomicMax((volatile int32_t*) buf2980, *(int32_t*)buf2981); - *(uint32_t*)buf2982 = rsAtomicMin((volatile uint32_t*) buf2983, *(uint32_t*)buf2984); - *(int32_t*)buf2985 = rsAtomicMin((volatile int32_t*) buf2986, *(int32_t*)buf2987); - *(int32_t*)buf2988 = rsAtomicOr((volatile int32_t*) buf2989, *(int32_t*)buf2990); - *(int32_t*)buf2991 = rsAtomicOr((volatile uint32_t*) buf2992, *(uint32_t*)buf2993); - *(int32_t*)buf2994 = rsAtomicSub((volatile int32_t*) buf2995, *(int32_t*)buf2996); - *(int32_t*)buf2997 = rsAtomicSub((volatile uint32_t*) buf2998, *(uint32_t*)buf2999); - *(int32_t*)buf3000 = rsAtomicXor((volatile int32_t*) buf3001, *(int32_t*)buf3002); - *(int32_t*)buf3003 = rsAtomicXor((volatile uint32_t*) buf3004, *(uint32_t*)buf3005); - *(char*)buf3006 = rsClamp(*(char*)buf3007, *(char*)buf3008, *(char*)buf3009); - *(uchar*)buf3010 = rsClamp(*(uchar*)buf3011, *(uchar*)buf3012, *(uchar*)buf3013); - *(short*)buf3014 = rsClamp(*(short*)buf3015, *(short*)buf3016, *(short*)buf3017); - *(ushort*)buf3018 = rsClamp(*(ushort*)buf3019, *(ushort*)buf3020, *(ushort*)buf3021); - *(int*)buf3022 = rsClamp(*(int*)buf3023, *(int*)buf3024, *(int*)buf3025); - *(uint*)buf3026 = rsClamp(*(uint*)buf3027, *(uint*)buf3028, *(uint*)buf3029); - rsClearObject((rs_element*) buf3030); - rsClearObject((rs_type*) buf3031); - rsClearObject((rs_allocation*) buf3032); - rsClearObject((rs_sampler*) buf3033); - rsClearObject((rs_script*) buf3034); + *(float2*)buf1477 = max(*(float2*)buf1478, *(float*)buf1479); + *(float3*)buf1480 = max(*(float3*)buf1481, *(float*)buf1482); + *(float4*)buf1483 = max(*(float4*)buf1484, *(float*)buf1485); + *(char*)buf1486 = max(*(char*)buf1487, *(char*)buf1488); + *(char2*)buf1489 = max(*(char2*)buf1490, *(char2*)buf1491); + *(char3*)buf1492 = max(*(char3*)buf1493, *(char3*)buf1494); + *(char4*)buf1495 = max(*(char4*)buf1496, *(char4*)buf1497); + *(uchar*)buf1498 = max(*(uchar*)buf1499, *(uchar*)buf1500); + *(uchar2*)buf1501 = max(*(uchar2*)buf1502, *(uchar2*)buf1503); + *(uchar3*)buf1504 = max(*(uchar3*)buf1505, *(uchar3*)buf1506); + *(uchar4*)buf1507 = max(*(uchar4*)buf1508, *(uchar4*)buf1509); + *(short*)buf1510 = max(*(short*)buf1511, *(short*)buf1512); + *(short2*)buf1513 = max(*(short2*)buf1514, *(short2*)buf1515); + *(short3*)buf1516 = max(*(short3*)buf1517, *(short3*)buf1518); + *(short4*)buf1519 = max(*(short4*)buf1520, *(short4*)buf1521); + *(ushort*)buf1522 = max(*(ushort*)buf1523, *(ushort*)buf1524); + *(ushort2*)buf1525 = max(*(ushort2*)buf1526, *(ushort2*)buf1527); + *(ushort3*)buf1528 = max(*(ushort3*)buf1529, *(ushort3*)buf1530); + *(ushort4*)buf1531 = max(*(ushort4*)buf1532, *(ushort4*)buf1533); + *(int*)buf1534 = max(*(int*)buf1535, *(int*)buf1536); + *(int2*)buf1537 = max(*(int2*)buf1538, *(int2*)buf1539); + *(int3*)buf1540 = max(*(int3*)buf1541, *(int3*)buf1542); + *(int4*)buf1543 = max(*(int4*)buf1544, *(int4*)buf1545); + *(uint*)buf1546 = max(*(uint*)buf1547, *(uint*)buf1548); + *(uint2*)buf1549 = max(*(uint2*)buf1550, *(uint2*)buf1551); + *(uint3*)buf1552 = max(*(uint3*)buf1553, *(uint3*)buf1554); + *(uint4*)buf1555 = max(*(uint4*)buf1556, *(uint4*)buf1557); + *(long*)buf1558 = max(*(long*)buf1559, *(long*)buf1560); + *(long2*)buf1561 = max(*(long2*)buf1562, *(long2*)buf1563); + *(long3*)buf1564 = max(*(long3*)buf1565, *(long3*)buf1566); + *(long4*)buf1567 = max(*(long4*)buf1568, *(long4*)buf1569); + *(ulong*)buf1570 = max(*(ulong*)buf1571, *(ulong*)buf1572); + *(ulong2*)buf1573 = max(*(ulong2*)buf1574, *(ulong2*)buf1575); + *(ulong3*)buf1576 = max(*(ulong3*)buf1577, *(ulong3*)buf1578); + *(ulong4*)buf1579 = max(*(ulong4*)buf1580, *(ulong4*)buf1581); + *(float*)buf1582 = min(*(float*)buf1583, *(float*)buf1584); + *(float2*)buf1585 = min(*(float2*)buf1586, *(float2*)buf1587); + *(float3*)buf1588 = min(*(float3*)buf1589, *(float3*)buf1590); + *(float4*)buf1591 = min(*(float4*)buf1592, *(float4*)buf1593); + *(float2*)buf1594 = min(*(float2*)buf1595, *(float*)buf1596); + *(float3*)buf1597 = min(*(float3*)buf1598, *(float*)buf1599); + *(float4*)buf1600 = min(*(float4*)buf1601, *(float*)buf1602); + *(char*)buf1603 = min(*(char*)buf1604, *(char*)buf1605); + *(char2*)buf1606 = min(*(char2*)buf1607, *(char2*)buf1608); + *(char3*)buf1609 = min(*(char3*)buf1610, *(char3*)buf1611); + *(char4*)buf1612 = min(*(char4*)buf1613, *(char4*)buf1614); + *(uchar*)buf1615 = min(*(uchar*)buf1616, *(uchar*)buf1617); + *(uchar2*)buf1618 = min(*(uchar2*)buf1619, *(uchar2*)buf1620); + *(uchar3*)buf1621 = min(*(uchar3*)buf1622, *(uchar3*)buf1623); + *(uchar4*)buf1624 = min(*(uchar4*)buf1625, *(uchar4*)buf1626); + *(short*)buf1627 = min(*(short*)buf1628, *(short*)buf1629); + *(short2*)buf1630 = min(*(short2*)buf1631, *(short2*)buf1632); + *(short3*)buf1633 = min(*(short3*)buf1634, *(short3*)buf1635); + *(short4*)buf1636 = min(*(short4*)buf1637, *(short4*)buf1638); + *(ushort*)buf1639 = min(*(ushort*)buf1640, *(ushort*)buf1641); + *(ushort2*)buf1642 = min(*(ushort2*)buf1643, *(ushort2*)buf1644); + *(ushort3*)buf1645 = min(*(ushort3*)buf1646, *(ushort3*)buf1647); + *(ushort4*)buf1648 = min(*(ushort4*)buf1649, *(ushort4*)buf1650); + *(int*)buf1651 = min(*(int*)buf1652, *(int*)buf1653); + *(int2*)buf1654 = min(*(int2*)buf1655, *(int2*)buf1656); + *(int3*)buf1657 = min(*(int3*)buf1658, *(int3*)buf1659); + *(int4*)buf1660 = min(*(int4*)buf1661, *(int4*)buf1662); + *(uint*)buf1663 = min(*(uint*)buf1664, *(uint*)buf1665); + *(uint2*)buf1666 = min(*(uint2*)buf1667, *(uint2*)buf1668); + *(uint3*)buf1669 = min(*(uint3*)buf1670, *(uint3*)buf1671); + *(uint4*)buf1672 = min(*(uint4*)buf1673, *(uint4*)buf1674); + *(long*)buf1675 = min(*(long*)buf1676, *(long*)buf1677); + *(long2*)buf1678 = min(*(long2*)buf1679, *(long2*)buf1680); + *(long3*)buf1681 = min(*(long3*)buf1682, *(long3*)buf1683); + *(long4*)buf1684 = min(*(long4*)buf1685, *(long4*)buf1686); + *(ulong*)buf1687 = min(*(ulong*)buf1688, *(ulong*)buf1689); + *(ulong2*)buf1690 = min(*(ulong2*)buf1691, *(ulong2*)buf1692); + *(ulong3*)buf1693 = min(*(ulong3*)buf1694, *(ulong3*)buf1695); + *(ulong4*)buf1696 = min(*(ulong4*)buf1697, *(ulong4*)buf1698); + *(float*)buf1699 = mix(*(float*)buf1700, *(float*)buf1701, *(float*)buf1702); + *(float2*)buf1703 = mix(*(float2*)buf1704, *(float2*)buf1705, *(float2*)buf1706); + *(float3*)buf1707 = mix(*(float3*)buf1708, *(float3*)buf1709, *(float3*)buf1710); + *(float4*)buf1711 = mix(*(float4*)buf1712, *(float4*)buf1713, *(float4*)buf1714); + *(float2*)buf1715 = mix(*(float2*)buf1716, *(float2*)buf1717, *(float*)buf1718); + *(float3*)buf1719 = mix(*(float3*)buf1720, *(float3*)buf1721, *(float*)buf1722); + *(float4*)buf1723 = mix(*(float4*)buf1724, *(float4*)buf1725, *(float*)buf1726); + *(float*)buf1727 = modf(*(float*)buf1728, (float*) buf1729); + *(float2*)buf1730 = modf(*(float2*)buf1731, (float2*) buf1732); + *(float3*)buf1733 = modf(*(float3*)buf1734, (float3*) buf1735); + *(float4*)buf1736 = modf(*(float4*)buf1737, (float4*) buf1738); + *(float*)buf1739 = nan(*(uint*)buf1740); + *(float*)buf1741 = native_acos(*(float*)buf1742); + *(float2*)buf1743 = native_acos(*(float2*)buf1744); + *(float3*)buf1745 = native_acos(*(float3*)buf1746); + *(float4*)buf1747 = native_acos(*(float4*)buf1748); + *(float*)buf1749 = native_acosh(*(float*)buf1750); + *(float2*)buf1751 = native_acosh(*(float2*)buf1752); + *(float3*)buf1753 = native_acosh(*(float3*)buf1754); + *(float4*)buf1755 = native_acosh(*(float4*)buf1756); + *(float*)buf1757 = native_acospi(*(float*)buf1758); + *(float2*)buf1759 = native_acospi(*(float2*)buf1760); + *(float3*)buf1761 = native_acospi(*(float3*)buf1762); + *(float4*)buf1763 = native_acospi(*(float4*)buf1764); + *(float*)buf1765 = native_asin(*(float*)buf1766); + *(float2*)buf1767 = native_asin(*(float2*)buf1768); + *(float3*)buf1769 = native_asin(*(float3*)buf1770); + *(float4*)buf1771 = native_asin(*(float4*)buf1772); + *(float*)buf1773 = native_asinh(*(float*)buf1774); + *(float2*)buf1775 = native_asinh(*(float2*)buf1776); + *(float3*)buf1777 = native_asinh(*(float3*)buf1778); + *(float4*)buf1779 = native_asinh(*(float4*)buf1780); + *(float*)buf1781 = native_asinpi(*(float*)buf1782); + *(float2*)buf1783 = native_asinpi(*(float2*)buf1784); + *(float3*)buf1785 = native_asinpi(*(float3*)buf1786); + *(float4*)buf1787 = native_asinpi(*(float4*)buf1788); + *(float*)buf1789 = native_atan(*(float*)buf1790); + *(float2*)buf1791 = native_atan(*(float2*)buf1792); + *(float3*)buf1793 = native_atan(*(float3*)buf1794); + *(float4*)buf1795 = native_atan(*(float4*)buf1796); + *(float*)buf1797 = native_atan2(*(float*)buf1798, *(float*)buf1799); + *(float2*)buf1800 = native_atan2(*(float2*)buf1801, *(float2*)buf1802); + *(float3*)buf1803 = native_atan2(*(float3*)buf1804, *(float3*)buf1805); + *(float4*)buf1806 = native_atan2(*(float4*)buf1807, *(float4*)buf1808); + *(float*)buf1809 = native_atan2pi(*(float*)buf1810, *(float*)buf1811); + *(float2*)buf1812 = native_atan2pi(*(float2*)buf1813, *(float2*)buf1814); + *(float3*)buf1815 = native_atan2pi(*(float3*)buf1816, *(float3*)buf1817); + *(float4*)buf1818 = native_atan2pi(*(float4*)buf1819, *(float4*)buf1820); + *(float*)buf1821 = native_atanh(*(float*)buf1822); + *(float2*)buf1823 = native_atanh(*(float2*)buf1824); + *(float3*)buf1825 = native_atanh(*(float3*)buf1826); + *(float4*)buf1827 = native_atanh(*(float4*)buf1828); + *(float*)buf1829 = native_atanpi(*(float*)buf1830); + *(float2*)buf1831 = native_atanpi(*(float2*)buf1832); + *(float3*)buf1833 = native_atanpi(*(float3*)buf1834); + *(float4*)buf1835 = native_atanpi(*(float4*)buf1836); + *(float*)buf1837 = native_cbrt(*(float*)buf1838); + *(float2*)buf1839 = native_cbrt(*(float2*)buf1840); + *(float3*)buf1841 = native_cbrt(*(float3*)buf1842); + *(float4*)buf1843 = native_cbrt(*(float4*)buf1844); + *(float*)buf1845 = native_cos(*(float*)buf1846); + *(float2*)buf1847 = native_cos(*(float2*)buf1848); + *(float3*)buf1849 = native_cos(*(float3*)buf1850); + *(float4*)buf1851 = native_cos(*(float4*)buf1852); + *(float*)buf1853 = native_cosh(*(float*)buf1854); + *(float2*)buf1855 = native_cosh(*(float2*)buf1856); + *(float3*)buf1857 = native_cosh(*(float3*)buf1858); + *(float4*)buf1859 = native_cosh(*(float4*)buf1860); + *(float*)buf1861 = native_cospi(*(float*)buf1862); + *(float2*)buf1863 = native_cospi(*(float2*)buf1864); + *(float3*)buf1865 = native_cospi(*(float3*)buf1866); + *(float4*)buf1867 = native_cospi(*(float4*)buf1868); + *(float*)buf1869 = native_distance(*(float*)buf1870, *(float*)buf1871); + *(float*)buf1872 = native_distance(*(float2*)buf1873, *(float2*)buf1874); + *(float*)buf1875 = native_distance(*(float3*)buf1876, *(float3*)buf1877); + *(float*)buf1878 = native_distance(*(float4*)buf1879, *(float4*)buf1880); + *(float*)buf1881 = native_divide(*(float*)buf1882, *(float*)buf1883); + *(float2*)buf1884 = native_divide(*(float2*)buf1885, *(float2*)buf1886); + *(float3*)buf1887 = native_divide(*(float3*)buf1888, *(float3*)buf1889); + *(float4*)buf1890 = native_divide(*(float4*)buf1891, *(float4*)buf1892); + *(float*)buf1893 = native_exp(*(float*)buf1894); + *(float2*)buf1895 = native_exp(*(float2*)buf1896); + *(float3*)buf1897 = native_exp(*(float3*)buf1898); + *(float4*)buf1899 = native_exp(*(float4*)buf1900); + *(float*)buf1901 = native_exp10(*(float*)buf1902); + *(float2*)buf1903 = native_exp10(*(float2*)buf1904); + *(float3*)buf1905 = native_exp10(*(float3*)buf1906); + *(float4*)buf1907 = native_exp10(*(float4*)buf1908); + *(float*)buf1909 = native_exp2(*(float*)buf1910); + *(float2*)buf1911 = native_exp2(*(float2*)buf1912); + *(float3*)buf1913 = native_exp2(*(float3*)buf1914); + *(float4*)buf1915 = native_exp2(*(float4*)buf1916); + *(float*)buf1917 = native_expm1(*(float*)buf1918); + *(float2*)buf1919 = native_expm1(*(float2*)buf1920); + *(float3*)buf1921 = native_expm1(*(float3*)buf1922); + *(float4*)buf1923 = native_expm1(*(float4*)buf1924); + *(float*)buf1925 = native_hypot(*(float*)buf1926, *(float*)buf1927); + *(float2*)buf1928 = native_hypot(*(float2*)buf1929, *(float2*)buf1930); + *(float3*)buf1931 = native_hypot(*(float3*)buf1932, *(float3*)buf1933); + *(float4*)buf1934 = native_hypot(*(float4*)buf1935, *(float4*)buf1936); + *(float*)buf1937 = native_length(*(float*)buf1938); + *(float*)buf1939 = native_length(*(float2*)buf1940); + *(float*)buf1941 = native_length(*(float3*)buf1942); + *(float*)buf1943 = native_length(*(float4*)buf1944); + *(float*)buf1945 = native_log(*(float*)buf1946); + *(float2*)buf1947 = native_log(*(float2*)buf1948); + *(float3*)buf1949 = native_log(*(float3*)buf1950); + *(float4*)buf1951 = native_log(*(float4*)buf1952); + *(float*)buf1953 = native_log10(*(float*)buf1954); + *(float2*)buf1955 = native_log10(*(float2*)buf1956); + *(float3*)buf1957 = native_log10(*(float3*)buf1958); + *(float4*)buf1959 = native_log10(*(float4*)buf1960); + *(float*)buf1961 = native_log1p(*(float*)buf1962); + *(float2*)buf1963 = native_log1p(*(float2*)buf1964); + *(float3*)buf1965 = native_log1p(*(float3*)buf1966); + *(float4*)buf1967 = native_log1p(*(float4*)buf1968); + *(float*)buf1969 = native_log2(*(float*)buf1970); + *(float2*)buf1971 = native_log2(*(float2*)buf1972); + *(float3*)buf1973 = native_log2(*(float3*)buf1974); + *(float4*)buf1975 = native_log2(*(float4*)buf1976); + *(float*)buf1977 = native_normalize(*(float*)buf1978); + *(float2*)buf1979 = native_normalize(*(float2*)buf1980); + *(float3*)buf1981 = native_normalize(*(float3*)buf1982); + *(float4*)buf1983 = native_normalize(*(float4*)buf1984); + *(float*)buf1985 = native_powr(*(float*)buf1986, *(float*)buf1987); + *(float2*)buf1988 = native_powr(*(float2*)buf1989, *(float2*)buf1990); + *(float3*)buf1991 = native_powr(*(float3*)buf1992, *(float3*)buf1993); + *(float4*)buf1994 = native_powr(*(float4*)buf1995, *(float4*)buf1996); + *(float*)buf1997 = native_recip(*(float*)buf1998); + *(float2*)buf1999 = native_recip(*(float2*)buf2000); + *(float3*)buf2001 = native_recip(*(float3*)buf2002); + *(float4*)buf2003 = native_recip(*(float4*)buf2004); + *(float*)buf2005 = native_rootn(*(float*)buf2006, *(int*)buf2007); + *(float2*)buf2008 = native_rootn(*(float2*)buf2009, *(int2*)buf2010); + *(float3*)buf2011 = native_rootn(*(float3*)buf2012, *(int3*)buf2013); + *(float4*)buf2014 = native_rootn(*(float4*)buf2015, *(int4*)buf2016); + *(float*)buf2017 = native_rsqrt(*(float*)buf2018); + *(float2*)buf2019 = native_rsqrt(*(float2*)buf2020); + *(float3*)buf2021 = native_rsqrt(*(float3*)buf2022); + *(float4*)buf2023 = native_rsqrt(*(float4*)buf2024); + *(float*)buf2025 = native_sin(*(float*)buf2026); + *(float2*)buf2027 = native_sin(*(float2*)buf2028); + *(float3*)buf2029 = native_sin(*(float3*)buf2030); + *(float4*)buf2031 = native_sin(*(float4*)buf2032); + *(float*)buf2033 = native_sincos(*(float*)buf2034, (float*) buf2035); + *(float2*)buf2036 = native_sincos(*(float2*)buf2037, (float2*) buf2038); + *(float3*)buf2039 = native_sincos(*(float3*)buf2040, (float3*) buf2041); + *(float4*)buf2042 = native_sincos(*(float4*)buf2043, (float4*) buf2044); + *(float*)buf2045 = native_sinh(*(float*)buf2046); + *(float2*)buf2047 = native_sinh(*(float2*)buf2048); + *(float3*)buf2049 = native_sinh(*(float3*)buf2050); + *(float4*)buf2051 = native_sinh(*(float4*)buf2052); + *(float*)buf2053 = native_sinpi(*(float*)buf2054); + *(float2*)buf2055 = native_sinpi(*(float2*)buf2056); + *(float3*)buf2057 = native_sinpi(*(float3*)buf2058); + *(float4*)buf2059 = native_sinpi(*(float4*)buf2060); + *(float*)buf2061 = native_sqrt(*(float*)buf2062); + *(float2*)buf2063 = native_sqrt(*(float2*)buf2064); + *(float3*)buf2065 = native_sqrt(*(float3*)buf2066); + *(float4*)buf2067 = native_sqrt(*(float4*)buf2068); + *(float*)buf2069 = native_tan(*(float*)buf2070); + *(float2*)buf2071 = native_tan(*(float2*)buf2072); + *(float3*)buf2073 = native_tan(*(float3*)buf2074); + *(float4*)buf2075 = native_tan(*(float4*)buf2076); + *(float*)buf2077 = native_tanh(*(float*)buf2078); + *(float2*)buf2079 = native_tanh(*(float2*)buf2080); + *(float3*)buf2081 = native_tanh(*(float3*)buf2082); + *(float4*)buf2083 = native_tanh(*(float4*)buf2084); + *(float*)buf2085 = native_tanpi(*(float*)buf2086); + *(float2*)buf2087 = native_tanpi(*(float2*)buf2088); + *(float3*)buf2089 = native_tanpi(*(float3*)buf2090); + *(float4*)buf2091 = native_tanpi(*(float4*)buf2092); + *(float*)buf2093 = nextafter(*(float*)buf2094, *(float*)buf2095); + *(float2*)buf2096 = nextafter(*(float2*)buf2097, *(float2*)buf2098); + *(float3*)buf2099 = nextafter(*(float3*)buf2100, *(float3*)buf2101); + *(float4*)buf2102 = nextafter(*(float4*)buf2103, *(float4*)buf2104); + *(float*)buf2105 = normalize(*(float*)buf2106); + *(float2*)buf2107 = normalize(*(float2*)buf2108); + *(float3*)buf2109 = normalize(*(float3*)buf2110); + *(float4*)buf2111 = normalize(*(float4*)buf2112); + *(float*)buf2113 = pow(*(float*)buf2114, *(float*)buf2115); + *(float2*)buf2116 = pow(*(float2*)buf2117, *(float2*)buf2118); + *(float3*)buf2119 = pow(*(float3*)buf2120, *(float3*)buf2121); + *(float4*)buf2122 = pow(*(float4*)buf2123, *(float4*)buf2124); + *(float*)buf2125 = pown(*(float*)buf2126, *(int*)buf2127); + *(float2*)buf2128 = pown(*(float2*)buf2129, *(int2*)buf2130); + *(float3*)buf2131 = pown(*(float3*)buf2132, *(int3*)buf2133); + *(float4*)buf2134 = pown(*(float4*)buf2135, *(int4*)buf2136); + *(float*)buf2137 = powr(*(float*)buf2138, *(float*)buf2139); + *(float2*)buf2140 = powr(*(float2*)buf2141, *(float2*)buf2142); + *(float3*)buf2143 = powr(*(float3*)buf2144, *(float3*)buf2145); + *(float4*)buf2146 = powr(*(float4*)buf2147, *(float4*)buf2148); + *(float*)buf2149 = radians(*(float*)buf2150); + *(float2*)buf2151 = radians(*(float2*)buf2152); + *(float3*)buf2153 = radians(*(float3*)buf2154); + *(float4*)buf2155 = radians(*(float4*)buf2156); + *(float*)buf2157 = remainder(*(float*)buf2158, *(float*)buf2159); + *(float2*)buf2160 = remainder(*(float2*)buf2161, *(float2*)buf2162); + *(float3*)buf2163 = remainder(*(float3*)buf2164, *(float3*)buf2165); + *(float4*)buf2166 = remainder(*(float4*)buf2167, *(float4*)buf2168); + *(float*)buf2169 = remquo(*(float*)buf2170, *(float*)buf2171, (int*) buf2172); + *(float2*)buf2173 = remquo(*(float2*)buf2174, *(float2*)buf2175, (int2*) buf2176); + *(float3*)buf2177 = remquo(*(float3*)buf2178, *(float3*)buf2179, (int3*) buf2180); + *(float4*)buf2181 = remquo(*(float4*)buf2182, *(float4*)buf2183, (int4*) buf2184); + *(float*)buf2185 = rint(*(float*)buf2186); + *(float2*)buf2187 = rint(*(float2*)buf2188); + *(float3*)buf2189 = rint(*(float3*)buf2190); + *(float4*)buf2191 = rint(*(float4*)buf2192); + *(float*)buf2193 = rootn(*(float*)buf2194, *(int*)buf2195); + *(float2*)buf2196 = rootn(*(float2*)buf2197, *(int2*)buf2198); + *(float3*)buf2199 = rootn(*(float3*)buf2200, *(int3*)buf2201); + *(float4*)buf2202 = rootn(*(float4*)buf2203, *(int4*)buf2204); + *(float*)buf2205 = round(*(float*)buf2206); + *(float2*)buf2207 = round(*(float2*)buf2208); + *(float3*)buf2209 = round(*(float3*)buf2210); + *(float4*)buf2211 = round(*(float4*)buf2212); + rsAllocationCopy1DRange(*(rs_allocation*)buf2213, *(uint32_t*)buf2214, *(uint32_t*)buf2215, *(uint32_t*)buf2216, *(rs_allocation*)buf2217, *(uint32_t*)buf2218, *(uint32_t*)buf2219); + rsAllocationCopy2DRange(*(rs_allocation*)buf2220, *(uint32_t*)buf2221, *(uint32_t*)buf2222, *(uint32_t*)buf2223, *(rs_allocation_cubemap_face*)buf2224, *(uint32_t*)buf2225, *(uint32_t*)buf2226, *(rs_allocation*)buf2227, *(uint32_t*)buf2228, *(uint32_t*)buf2229, *(uint32_t*)buf2230, *(rs_allocation_cubemap_face*)buf2231); + *(uint32_t*)buf2232 = rsAllocationGetDimFaces(*(rs_allocation*)buf2233); + *(uint32_t*)buf2234 = rsAllocationGetDimLOD(*(rs_allocation*)buf2235); + *(uint32_t*)buf2236 = rsAllocationGetDimX(*(rs_allocation*)buf2237); + *(uint32_t*)buf2238 = rsAllocationGetDimY(*(rs_allocation*)buf2239); + *(uint32_t*)buf2240 = rsAllocationGetDimZ(*(rs_allocation*)buf2241); + *(rs_element*)buf2242 = rsAllocationGetElement(*(rs_allocation*)buf2243); + rsAllocationIoReceive(*(rs_allocation*)buf2244); + rsAllocationIoSend(*(rs_allocation*)buf2245); + *(float2*)buf2246 = rsAllocationVLoadX_float2(*(rs_allocation*)buf2247, *(uint32_t*)buf2248); + *(float3*)buf2249 = rsAllocationVLoadX_float3(*(rs_allocation*)buf2250, *(uint32_t*)buf2251); + *(float4*)buf2252 = rsAllocationVLoadX_float4(*(rs_allocation*)buf2253, *(uint32_t*)buf2254); + *(double2*)buf2255 = rsAllocationVLoadX_double2(*(rs_allocation*)buf2256, *(uint32_t*)buf2257); + *(double3*)buf2258 = rsAllocationVLoadX_double3(*(rs_allocation*)buf2259, *(uint32_t*)buf2260); + *(double4*)buf2261 = rsAllocationVLoadX_double4(*(rs_allocation*)buf2262, *(uint32_t*)buf2263); + *(char2*)buf2264 = rsAllocationVLoadX_char2(*(rs_allocation*)buf2265, *(uint32_t*)buf2266); + *(char3*)buf2267 = rsAllocationVLoadX_char3(*(rs_allocation*)buf2268, *(uint32_t*)buf2269); + *(char4*)buf2270 = rsAllocationVLoadX_char4(*(rs_allocation*)buf2271, *(uint32_t*)buf2272); + *(uchar2*)buf2273 = rsAllocationVLoadX_uchar2(*(rs_allocation*)buf2274, *(uint32_t*)buf2275); + *(uchar3*)buf2276 = rsAllocationVLoadX_uchar3(*(rs_allocation*)buf2277, *(uint32_t*)buf2278); + *(uchar4*)buf2279 = rsAllocationVLoadX_uchar4(*(rs_allocation*)buf2280, *(uint32_t*)buf2281); + *(short2*)buf2282 = rsAllocationVLoadX_short2(*(rs_allocation*)buf2283, *(uint32_t*)buf2284); + *(short3*)buf2285 = rsAllocationVLoadX_short3(*(rs_allocation*)buf2286, *(uint32_t*)buf2287); + *(short4*)buf2288 = rsAllocationVLoadX_short4(*(rs_allocation*)buf2289, *(uint32_t*)buf2290); + *(ushort2*)buf2291 = rsAllocationVLoadX_ushort2(*(rs_allocation*)buf2292, *(uint32_t*)buf2293); + *(ushort3*)buf2294 = rsAllocationVLoadX_ushort3(*(rs_allocation*)buf2295, *(uint32_t*)buf2296); + *(ushort4*)buf2297 = rsAllocationVLoadX_ushort4(*(rs_allocation*)buf2298, *(uint32_t*)buf2299); + *(int2*)buf2300 = rsAllocationVLoadX_int2(*(rs_allocation*)buf2301, *(uint32_t*)buf2302); + *(int3*)buf2303 = rsAllocationVLoadX_int3(*(rs_allocation*)buf2304, *(uint32_t*)buf2305); + *(int4*)buf2306 = rsAllocationVLoadX_int4(*(rs_allocation*)buf2307, *(uint32_t*)buf2308); + *(uint2*)buf2309 = rsAllocationVLoadX_uint2(*(rs_allocation*)buf2310, *(uint32_t*)buf2311); + *(uint3*)buf2312 = rsAllocationVLoadX_uint3(*(rs_allocation*)buf2313, *(uint32_t*)buf2314); + *(uint4*)buf2315 = rsAllocationVLoadX_uint4(*(rs_allocation*)buf2316, *(uint32_t*)buf2317); + *(long2*)buf2318 = rsAllocationVLoadX_long2(*(rs_allocation*)buf2319, *(uint32_t*)buf2320); + *(long3*)buf2321 = rsAllocationVLoadX_long3(*(rs_allocation*)buf2322, *(uint32_t*)buf2323); + *(long4*)buf2324 = rsAllocationVLoadX_long4(*(rs_allocation*)buf2325, *(uint32_t*)buf2326); + *(ulong2*)buf2327 = rsAllocationVLoadX_ulong2(*(rs_allocation*)buf2328, *(uint32_t*)buf2329); + *(ulong3*)buf2330 = rsAllocationVLoadX_ulong3(*(rs_allocation*)buf2331, *(uint32_t*)buf2332); + *(ulong4*)buf2333 = rsAllocationVLoadX_ulong4(*(rs_allocation*)buf2334, *(uint32_t*)buf2335); + *(float2*)buf2336 = rsAllocationVLoadX_float2(*(rs_allocation*)buf2337, *(uint32_t*)buf2338, *(uint32_t*)buf2339); + *(float3*)buf2340 = rsAllocationVLoadX_float3(*(rs_allocation*)buf2341, *(uint32_t*)buf2342, *(uint32_t*)buf2343); + *(float4*)buf2344 = rsAllocationVLoadX_float4(*(rs_allocation*)buf2345, *(uint32_t*)buf2346, *(uint32_t*)buf2347); + *(double2*)buf2348 = rsAllocationVLoadX_double2(*(rs_allocation*)buf2349, *(uint32_t*)buf2350, *(uint32_t*)buf2351); + *(double3*)buf2352 = rsAllocationVLoadX_double3(*(rs_allocation*)buf2353, *(uint32_t*)buf2354, *(uint32_t*)buf2355); + *(double4*)buf2356 = rsAllocationVLoadX_double4(*(rs_allocation*)buf2357, *(uint32_t*)buf2358, *(uint32_t*)buf2359); + *(char2*)buf2360 = rsAllocationVLoadX_char2(*(rs_allocation*)buf2361, *(uint32_t*)buf2362, *(uint32_t*)buf2363); + *(char3*)buf2364 = rsAllocationVLoadX_char3(*(rs_allocation*)buf2365, *(uint32_t*)buf2366, *(uint32_t*)buf2367); + *(char4*)buf2368 = rsAllocationVLoadX_char4(*(rs_allocation*)buf2369, *(uint32_t*)buf2370, *(uint32_t*)buf2371); + *(uchar2*)buf2372 = rsAllocationVLoadX_uchar2(*(rs_allocation*)buf2373, *(uint32_t*)buf2374, *(uint32_t*)buf2375); + *(uchar3*)buf2376 = rsAllocationVLoadX_uchar3(*(rs_allocation*)buf2377, *(uint32_t*)buf2378, *(uint32_t*)buf2379); + *(uchar4*)buf2380 = rsAllocationVLoadX_uchar4(*(rs_allocation*)buf2381, *(uint32_t*)buf2382, *(uint32_t*)buf2383); + *(short2*)buf2384 = rsAllocationVLoadX_short2(*(rs_allocation*)buf2385, *(uint32_t*)buf2386, *(uint32_t*)buf2387); + *(short3*)buf2388 = rsAllocationVLoadX_short3(*(rs_allocation*)buf2389, *(uint32_t*)buf2390, *(uint32_t*)buf2391); + *(short4*)buf2392 = rsAllocationVLoadX_short4(*(rs_allocation*)buf2393, *(uint32_t*)buf2394, *(uint32_t*)buf2395); + *(ushort2*)buf2396 = rsAllocationVLoadX_ushort2(*(rs_allocation*)buf2397, *(uint32_t*)buf2398, *(uint32_t*)buf2399); + *(ushort3*)buf2400 = rsAllocationVLoadX_ushort3(*(rs_allocation*)buf2401, *(uint32_t*)buf2402, *(uint32_t*)buf2403); + *(ushort4*)buf2404 = rsAllocationVLoadX_ushort4(*(rs_allocation*)buf2405, *(uint32_t*)buf2406, *(uint32_t*)buf2407); + *(int2*)buf2408 = rsAllocationVLoadX_int2(*(rs_allocation*)buf2409, *(uint32_t*)buf2410, *(uint32_t*)buf2411); + *(int3*)buf2412 = rsAllocationVLoadX_int3(*(rs_allocation*)buf2413, *(uint32_t*)buf2414, *(uint32_t*)buf2415); + *(int4*)buf2416 = rsAllocationVLoadX_int4(*(rs_allocation*)buf2417, *(uint32_t*)buf2418, *(uint32_t*)buf2419); + *(uint2*)buf2420 = rsAllocationVLoadX_uint2(*(rs_allocation*)buf2421, *(uint32_t*)buf2422, *(uint32_t*)buf2423); + *(uint3*)buf2424 = rsAllocationVLoadX_uint3(*(rs_allocation*)buf2425, *(uint32_t*)buf2426, *(uint32_t*)buf2427); + *(uint4*)buf2428 = rsAllocationVLoadX_uint4(*(rs_allocation*)buf2429, *(uint32_t*)buf2430, *(uint32_t*)buf2431); + *(long2*)buf2432 = rsAllocationVLoadX_long2(*(rs_allocation*)buf2433, *(uint32_t*)buf2434, *(uint32_t*)buf2435); + *(long3*)buf2436 = rsAllocationVLoadX_long3(*(rs_allocation*)buf2437, *(uint32_t*)buf2438, *(uint32_t*)buf2439); + *(long4*)buf2440 = rsAllocationVLoadX_long4(*(rs_allocation*)buf2441, *(uint32_t*)buf2442, *(uint32_t*)buf2443); + *(ulong2*)buf2444 = rsAllocationVLoadX_ulong2(*(rs_allocation*)buf2445, *(uint32_t*)buf2446, *(uint32_t*)buf2447); + *(ulong3*)buf2448 = rsAllocationVLoadX_ulong3(*(rs_allocation*)buf2449, *(uint32_t*)buf2450, *(uint32_t*)buf2451); + *(ulong4*)buf2452 = rsAllocationVLoadX_ulong4(*(rs_allocation*)buf2453, *(uint32_t*)buf2454, *(uint32_t*)buf2455); + *(float2*)buf2456 = rsAllocationVLoadX_float2(*(rs_allocation*)buf2457, *(uint32_t*)buf2458, *(uint32_t*)buf2459, *(uint32_t*)buf2460); + *(float3*)buf2461 = rsAllocationVLoadX_float3(*(rs_allocation*)buf2462, *(uint32_t*)buf2463, *(uint32_t*)buf2464, *(uint32_t*)buf2465); + *(float4*)buf2466 = rsAllocationVLoadX_float4(*(rs_allocation*)buf2467, *(uint32_t*)buf2468, *(uint32_t*)buf2469, *(uint32_t*)buf2470); + *(double2*)buf2471 = rsAllocationVLoadX_double2(*(rs_allocation*)buf2472, *(uint32_t*)buf2473, *(uint32_t*)buf2474, *(uint32_t*)buf2475); + *(double3*)buf2476 = rsAllocationVLoadX_double3(*(rs_allocation*)buf2477, *(uint32_t*)buf2478, *(uint32_t*)buf2479, *(uint32_t*)buf2480); + *(double4*)buf2481 = rsAllocationVLoadX_double4(*(rs_allocation*)buf2482, *(uint32_t*)buf2483, *(uint32_t*)buf2484, *(uint32_t*)buf2485); + *(char2*)buf2486 = rsAllocationVLoadX_char2(*(rs_allocation*)buf2487, *(uint32_t*)buf2488, *(uint32_t*)buf2489, *(uint32_t*)buf2490); + *(char3*)buf2491 = rsAllocationVLoadX_char3(*(rs_allocation*)buf2492, *(uint32_t*)buf2493, *(uint32_t*)buf2494, *(uint32_t*)buf2495); + *(char4*)buf2496 = rsAllocationVLoadX_char4(*(rs_allocation*)buf2497, *(uint32_t*)buf2498, *(uint32_t*)buf2499, *(uint32_t*)buf2500); + *(uchar2*)buf2501 = rsAllocationVLoadX_uchar2(*(rs_allocation*)buf2502, *(uint32_t*)buf2503, *(uint32_t*)buf2504, *(uint32_t*)buf2505); + *(uchar3*)buf2506 = rsAllocationVLoadX_uchar3(*(rs_allocation*)buf2507, *(uint32_t*)buf2508, *(uint32_t*)buf2509, *(uint32_t*)buf2510); + *(uchar4*)buf2511 = rsAllocationVLoadX_uchar4(*(rs_allocation*)buf2512, *(uint32_t*)buf2513, *(uint32_t*)buf2514, *(uint32_t*)buf2515); + *(short2*)buf2516 = rsAllocationVLoadX_short2(*(rs_allocation*)buf2517, *(uint32_t*)buf2518, *(uint32_t*)buf2519, *(uint32_t*)buf2520); + *(short3*)buf2521 = rsAllocationVLoadX_short3(*(rs_allocation*)buf2522, *(uint32_t*)buf2523, *(uint32_t*)buf2524, *(uint32_t*)buf2525); + *(short4*)buf2526 = rsAllocationVLoadX_short4(*(rs_allocation*)buf2527, *(uint32_t*)buf2528, *(uint32_t*)buf2529, *(uint32_t*)buf2530); + *(ushort2*)buf2531 = rsAllocationVLoadX_ushort2(*(rs_allocation*)buf2532, *(uint32_t*)buf2533, *(uint32_t*)buf2534, *(uint32_t*)buf2535); + *(ushort3*)buf2536 = rsAllocationVLoadX_ushort3(*(rs_allocation*)buf2537, *(uint32_t*)buf2538, *(uint32_t*)buf2539, *(uint32_t*)buf2540); + *(ushort4*)buf2541 = rsAllocationVLoadX_ushort4(*(rs_allocation*)buf2542, *(uint32_t*)buf2543, *(uint32_t*)buf2544, *(uint32_t*)buf2545); + *(int2*)buf2546 = rsAllocationVLoadX_int2(*(rs_allocation*)buf2547, *(uint32_t*)buf2548, *(uint32_t*)buf2549, *(uint32_t*)buf2550); + *(int3*)buf2551 = rsAllocationVLoadX_int3(*(rs_allocation*)buf2552, *(uint32_t*)buf2553, *(uint32_t*)buf2554, *(uint32_t*)buf2555); + *(int4*)buf2556 = rsAllocationVLoadX_int4(*(rs_allocation*)buf2557, *(uint32_t*)buf2558, *(uint32_t*)buf2559, *(uint32_t*)buf2560); + *(uint2*)buf2561 = rsAllocationVLoadX_uint2(*(rs_allocation*)buf2562, *(uint32_t*)buf2563, *(uint32_t*)buf2564, *(uint32_t*)buf2565); + *(uint3*)buf2566 = rsAllocationVLoadX_uint3(*(rs_allocation*)buf2567, *(uint32_t*)buf2568, *(uint32_t*)buf2569, *(uint32_t*)buf2570); + *(uint4*)buf2571 = rsAllocationVLoadX_uint4(*(rs_allocation*)buf2572, *(uint32_t*)buf2573, *(uint32_t*)buf2574, *(uint32_t*)buf2575); + *(long2*)buf2576 = rsAllocationVLoadX_long2(*(rs_allocation*)buf2577, *(uint32_t*)buf2578, *(uint32_t*)buf2579, *(uint32_t*)buf2580); + *(long3*)buf2581 = rsAllocationVLoadX_long3(*(rs_allocation*)buf2582, *(uint32_t*)buf2583, *(uint32_t*)buf2584, *(uint32_t*)buf2585); + *(long4*)buf2586 = rsAllocationVLoadX_long4(*(rs_allocation*)buf2587, *(uint32_t*)buf2588, *(uint32_t*)buf2589, *(uint32_t*)buf2590); + *(ulong2*)buf2591 = rsAllocationVLoadX_ulong2(*(rs_allocation*)buf2592, *(uint32_t*)buf2593, *(uint32_t*)buf2594, *(uint32_t*)buf2595); + *(ulong3*)buf2596 = rsAllocationVLoadX_ulong3(*(rs_allocation*)buf2597, *(uint32_t*)buf2598, *(uint32_t*)buf2599, *(uint32_t*)buf2600); + *(ulong4*)buf2601 = rsAllocationVLoadX_ulong4(*(rs_allocation*)buf2602, *(uint32_t*)buf2603, *(uint32_t*)buf2604, *(uint32_t*)buf2605); + rsAllocationVStoreX_float2(*(rs_allocation*)buf2606, *(float2*)buf2607, *(uint32_t*)buf2608); + rsAllocationVStoreX_float3(*(rs_allocation*)buf2609, *(float3*)buf2610, *(uint32_t*)buf2611); + rsAllocationVStoreX_float4(*(rs_allocation*)buf2612, *(float4*)buf2613, *(uint32_t*)buf2614); + rsAllocationVStoreX_double2(*(rs_allocation*)buf2615, *(double2*)buf2616, *(uint32_t*)buf2617); + rsAllocationVStoreX_double3(*(rs_allocation*)buf2618, *(double3*)buf2619, *(uint32_t*)buf2620); + rsAllocationVStoreX_double4(*(rs_allocation*)buf2621, *(double4*)buf2622, *(uint32_t*)buf2623); + rsAllocationVStoreX_char2(*(rs_allocation*)buf2624, *(char2*)buf2625, *(uint32_t*)buf2626); + rsAllocationVStoreX_char3(*(rs_allocation*)buf2627, *(char3*)buf2628, *(uint32_t*)buf2629); + rsAllocationVStoreX_char4(*(rs_allocation*)buf2630, *(char4*)buf2631, *(uint32_t*)buf2632); + rsAllocationVStoreX_uchar2(*(rs_allocation*)buf2633, *(uchar2*)buf2634, *(uint32_t*)buf2635); + rsAllocationVStoreX_uchar3(*(rs_allocation*)buf2636, *(uchar3*)buf2637, *(uint32_t*)buf2638); + rsAllocationVStoreX_uchar4(*(rs_allocation*)buf2639, *(uchar4*)buf2640, *(uint32_t*)buf2641); + rsAllocationVStoreX_short2(*(rs_allocation*)buf2642, *(short2*)buf2643, *(uint32_t*)buf2644); + rsAllocationVStoreX_short3(*(rs_allocation*)buf2645, *(short3*)buf2646, *(uint32_t*)buf2647); + rsAllocationVStoreX_short4(*(rs_allocation*)buf2648, *(short4*)buf2649, *(uint32_t*)buf2650); + rsAllocationVStoreX_ushort2(*(rs_allocation*)buf2651, *(ushort2*)buf2652, *(uint32_t*)buf2653); + rsAllocationVStoreX_ushort3(*(rs_allocation*)buf2654, *(ushort3*)buf2655, *(uint32_t*)buf2656); + rsAllocationVStoreX_ushort4(*(rs_allocation*)buf2657, *(ushort4*)buf2658, *(uint32_t*)buf2659); + rsAllocationVStoreX_int2(*(rs_allocation*)buf2660, *(int2*)buf2661, *(uint32_t*)buf2662); + rsAllocationVStoreX_int3(*(rs_allocation*)buf2663, *(int3*)buf2664, *(uint32_t*)buf2665); + rsAllocationVStoreX_int4(*(rs_allocation*)buf2666, *(int4*)buf2667, *(uint32_t*)buf2668); + rsAllocationVStoreX_uint2(*(rs_allocation*)buf2669, *(uint2*)buf2670, *(uint32_t*)buf2671); + rsAllocationVStoreX_uint3(*(rs_allocation*)buf2672, *(uint3*)buf2673, *(uint32_t*)buf2674); + rsAllocationVStoreX_uint4(*(rs_allocation*)buf2675, *(uint4*)buf2676, *(uint32_t*)buf2677); + rsAllocationVStoreX_long2(*(rs_allocation*)buf2678, *(long2*)buf2679, *(uint32_t*)buf2680); + rsAllocationVStoreX_long3(*(rs_allocation*)buf2681, *(long3*)buf2682, *(uint32_t*)buf2683); + rsAllocationVStoreX_long4(*(rs_allocation*)buf2684, *(long4*)buf2685, *(uint32_t*)buf2686); + rsAllocationVStoreX_ulong2(*(rs_allocation*)buf2687, *(ulong2*)buf2688, *(uint32_t*)buf2689); + rsAllocationVStoreX_ulong3(*(rs_allocation*)buf2690, *(ulong3*)buf2691, *(uint32_t*)buf2692); + rsAllocationVStoreX_ulong4(*(rs_allocation*)buf2693, *(ulong4*)buf2694, *(uint32_t*)buf2695); + rsAllocationVStoreX_float2(*(rs_allocation*)buf2696, *(float2*)buf2697, *(uint32_t*)buf2698, *(uint32_t*)buf2699); + rsAllocationVStoreX_float3(*(rs_allocation*)buf2700, *(float3*)buf2701, *(uint32_t*)buf2702, *(uint32_t*)buf2703); + rsAllocationVStoreX_float4(*(rs_allocation*)buf2704, *(float4*)buf2705, *(uint32_t*)buf2706, *(uint32_t*)buf2707); + rsAllocationVStoreX_double2(*(rs_allocation*)buf2708, *(double2*)buf2709, *(uint32_t*)buf2710, *(uint32_t*)buf2711); + rsAllocationVStoreX_double3(*(rs_allocation*)buf2712, *(double3*)buf2713, *(uint32_t*)buf2714, *(uint32_t*)buf2715); + rsAllocationVStoreX_double4(*(rs_allocation*)buf2716, *(double4*)buf2717, *(uint32_t*)buf2718, *(uint32_t*)buf2719); + rsAllocationVStoreX_char2(*(rs_allocation*)buf2720, *(char2*)buf2721, *(uint32_t*)buf2722, *(uint32_t*)buf2723); + rsAllocationVStoreX_char3(*(rs_allocation*)buf2724, *(char3*)buf2725, *(uint32_t*)buf2726, *(uint32_t*)buf2727); + rsAllocationVStoreX_char4(*(rs_allocation*)buf2728, *(char4*)buf2729, *(uint32_t*)buf2730, *(uint32_t*)buf2731); + rsAllocationVStoreX_uchar2(*(rs_allocation*)buf2732, *(uchar2*)buf2733, *(uint32_t*)buf2734, *(uint32_t*)buf2735); + rsAllocationVStoreX_uchar3(*(rs_allocation*)buf2736, *(uchar3*)buf2737, *(uint32_t*)buf2738, *(uint32_t*)buf2739); + rsAllocationVStoreX_uchar4(*(rs_allocation*)buf2740, *(uchar4*)buf2741, *(uint32_t*)buf2742, *(uint32_t*)buf2743); + rsAllocationVStoreX_short2(*(rs_allocation*)buf2744, *(short2*)buf2745, *(uint32_t*)buf2746, *(uint32_t*)buf2747); + rsAllocationVStoreX_short3(*(rs_allocation*)buf2748, *(short3*)buf2749, *(uint32_t*)buf2750, *(uint32_t*)buf2751); + rsAllocationVStoreX_short4(*(rs_allocation*)buf2752, *(short4*)buf2753, *(uint32_t*)buf2754, *(uint32_t*)buf2755); + rsAllocationVStoreX_ushort2(*(rs_allocation*)buf2756, *(ushort2*)buf2757, *(uint32_t*)buf2758, *(uint32_t*)buf2759); + rsAllocationVStoreX_ushort3(*(rs_allocation*)buf2760, *(ushort3*)buf2761, *(uint32_t*)buf2762, *(uint32_t*)buf2763); + rsAllocationVStoreX_ushort4(*(rs_allocation*)buf2764, *(ushort4*)buf2765, *(uint32_t*)buf2766, *(uint32_t*)buf2767); + rsAllocationVStoreX_int2(*(rs_allocation*)buf2768, *(int2*)buf2769, *(uint32_t*)buf2770, *(uint32_t*)buf2771); + rsAllocationVStoreX_int3(*(rs_allocation*)buf2772, *(int3*)buf2773, *(uint32_t*)buf2774, *(uint32_t*)buf2775); + rsAllocationVStoreX_int4(*(rs_allocation*)buf2776, *(int4*)buf2777, *(uint32_t*)buf2778, *(uint32_t*)buf2779); + rsAllocationVStoreX_uint2(*(rs_allocation*)buf2780, *(uint2*)buf2781, *(uint32_t*)buf2782, *(uint32_t*)buf2783); + rsAllocationVStoreX_uint3(*(rs_allocation*)buf2784, *(uint3*)buf2785, *(uint32_t*)buf2786, *(uint32_t*)buf2787); + rsAllocationVStoreX_uint4(*(rs_allocation*)buf2788, *(uint4*)buf2789, *(uint32_t*)buf2790, *(uint32_t*)buf2791); + rsAllocationVStoreX_long2(*(rs_allocation*)buf2792, *(long2*)buf2793, *(uint32_t*)buf2794, *(uint32_t*)buf2795); + rsAllocationVStoreX_long3(*(rs_allocation*)buf2796, *(long3*)buf2797, *(uint32_t*)buf2798, *(uint32_t*)buf2799); + rsAllocationVStoreX_long4(*(rs_allocation*)buf2800, *(long4*)buf2801, *(uint32_t*)buf2802, *(uint32_t*)buf2803); + rsAllocationVStoreX_ulong2(*(rs_allocation*)buf2804, *(ulong2*)buf2805, *(uint32_t*)buf2806, *(uint32_t*)buf2807); + rsAllocationVStoreX_ulong3(*(rs_allocation*)buf2808, *(ulong3*)buf2809, *(uint32_t*)buf2810, *(uint32_t*)buf2811); + rsAllocationVStoreX_ulong4(*(rs_allocation*)buf2812, *(ulong4*)buf2813, *(uint32_t*)buf2814, *(uint32_t*)buf2815); + rsAllocationVStoreX_float2(*(rs_allocation*)buf2816, *(float2*)buf2817, *(uint32_t*)buf2818, *(uint32_t*)buf2819, *(uint32_t*)buf2820); + rsAllocationVStoreX_float3(*(rs_allocation*)buf2821, *(float3*)buf2822, *(uint32_t*)buf2823, *(uint32_t*)buf2824, *(uint32_t*)buf2825); + rsAllocationVStoreX_float4(*(rs_allocation*)buf2826, *(float4*)buf2827, *(uint32_t*)buf2828, *(uint32_t*)buf2829, *(uint32_t*)buf2830); + rsAllocationVStoreX_double2(*(rs_allocation*)buf2831, *(double2*)buf2832, *(uint32_t*)buf2833, *(uint32_t*)buf2834, *(uint32_t*)buf2835); + rsAllocationVStoreX_double3(*(rs_allocation*)buf2836, *(double3*)buf2837, *(uint32_t*)buf2838, *(uint32_t*)buf2839, *(uint32_t*)buf2840); + rsAllocationVStoreX_double4(*(rs_allocation*)buf2841, *(double4*)buf2842, *(uint32_t*)buf2843, *(uint32_t*)buf2844, *(uint32_t*)buf2845); + rsAllocationVStoreX_char2(*(rs_allocation*)buf2846, *(char2*)buf2847, *(uint32_t*)buf2848, *(uint32_t*)buf2849, *(uint32_t*)buf2850); + rsAllocationVStoreX_char3(*(rs_allocation*)buf2851, *(char3*)buf2852, *(uint32_t*)buf2853, *(uint32_t*)buf2854, *(uint32_t*)buf2855); + rsAllocationVStoreX_char4(*(rs_allocation*)buf2856, *(char4*)buf2857, *(uint32_t*)buf2858, *(uint32_t*)buf2859, *(uint32_t*)buf2860); + rsAllocationVStoreX_uchar2(*(rs_allocation*)buf2861, *(uchar2*)buf2862, *(uint32_t*)buf2863, *(uint32_t*)buf2864, *(uint32_t*)buf2865); + rsAllocationVStoreX_uchar3(*(rs_allocation*)buf2866, *(uchar3*)buf2867, *(uint32_t*)buf2868, *(uint32_t*)buf2869, *(uint32_t*)buf2870); + rsAllocationVStoreX_uchar4(*(rs_allocation*)buf2871, *(uchar4*)buf2872, *(uint32_t*)buf2873, *(uint32_t*)buf2874, *(uint32_t*)buf2875); + rsAllocationVStoreX_short2(*(rs_allocation*)buf2876, *(short2*)buf2877, *(uint32_t*)buf2878, *(uint32_t*)buf2879, *(uint32_t*)buf2880); + rsAllocationVStoreX_short3(*(rs_allocation*)buf2881, *(short3*)buf2882, *(uint32_t*)buf2883, *(uint32_t*)buf2884, *(uint32_t*)buf2885); + rsAllocationVStoreX_short4(*(rs_allocation*)buf2886, *(short4*)buf2887, *(uint32_t*)buf2888, *(uint32_t*)buf2889, *(uint32_t*)buf2890); + rsAllocationVStoreX_ushort2(*(rs_allocation*)buf2891, *(ushort2*)buf2892, *(uint32_t*)buf2893, *(uint32_t*)buf2894, *(uint32_t*)buf2895); + rsAllocationVStoreX_ushort3(*(rs_allocation*)buf2896, *(ushort3*)buf2897, *(uint32_t*)buf2898, *(uint32_t*)buf2899, *(uint32_t*)buf2900); + rsAllocationVStoreX_ushort4(*(rs_allocation*)buf2901, *(ushort4*)buf2902, *(uint32_t*)buf2903, *(uint32_t*)buf2904, *(uint32_t*)buf2905); + rsAllocationVStoreX_int2(*(rs_allocation*)buf2906, *(int2*)buf2907, *(uint32_t*)buf2908, *(uint32_t*)buf2909, *(uint32_t*)buf2910); + rsAllocationVStoreX_int3(*(rs_allocation*)buf2911, *(int3*)buf2912, *(uint32_t*)buf2913, *(uint32_t*)buf2914, *(uint32_t*)buf2915); + rsAllocationVStoreX_int4(*(rs_allocation*)buf2916, *(int4*)buf2917, *(uint32_t*)buf2918, *(uint32_t*)buf2919, *(uint32_t*)buf2920); + rsAllocationVStoreX_uint2(*(rs_allocation*)buf2921, *(uint2*)buf2922, *(uint32_t*)buf2923, *(uint32_t*)buf2924, *(uint32_t*)buf2925); + rsAllocationVStoreX_uint3(*(rs_allocation*)buf2926, *(uint3*)buf2927, *(uint32_t*)buf2928, *(uint32_t*)buf2929, *(uint32_t*)buf2930); + rsAllocationVStoreX_uint4(*(rs_allocation*)buf2931, *(uint4*)buf2932, *(uint32_t*)buf2933, *(uint32_t*)buf2934, *(uint32_t*)buf2935); + rsAllocationVStoreX_long2(*(rs_allocation*)buf2936, *(long2*)buf2937, *(uint32_t*)buf2938, *(uint32_t*)buf2939, *(uint32_t*)buf2940); + rsAllocationVStoreX_long3(*(rs_allocation*)buf2941, *(long3*)buf2942, *(uint32_t*)buf2943, *(uint32_t*)buf2944, *(uint32_t*)buf2945); + rsAllocationVStoreX_long4(*(rs_allocation*)buf2946, *(long4*)buf2947, *(uint32_t*)buf2948, *(uint32_t*)buf2949, *(uint32_t*)buf2950); + rsAllocationVStoreX_ulong2(*(rs_allocation*)buf2951, *(ulong2*)buf2952, *(uint32_t*)buf2953, *(uint32_t*)buf2954, *(uint32_t*)buf2955); + rsAllocationVStoreX_ulong3(*(rs_allocation*)buf2956, *(ulong3*)buf2957, *(uint32_t*)buf2958, *(uint32_t*)buf2959, *(uint32_t*)buf2960); + rsAllocationVStoreX_ulong4(*(rs_allocation*)buf2961, *(ulong4*)buf2962, *(uint32_t*)buf2963, *(uint32_t*)buf2964, *(uint32_t*)buf2965); + *(int32_t*)buf2966 = rsAtomicAdd((volatile int32_t*) buf2967, *(int32_t*)buf2968); + *(int32_t*)buf2969 = rsAtomicAdd((volatile uint32_t*) buf2970, *(uint32_t*)buf2971); + *(int32_t*)buf2972 = rsAtomicAnd((volatile int32_t*) buf2973, *(int32_t*)buf2974); + *(int32_t*)buf2975 = rsAtomicAnd((volatile uint32_t*) buf2976, *(uint32_t*)buf2977); + *(int32_t*)buf2978 = rsAtomicCas((volatile int32_t*) buf2979, *(int32_t*)buf2980, *(int32_t*)buf2981); + *(uint32_t*)buf2982 = rsAtomicCas((volatile uint32_t*) buf2983, *(uint32_t*)buf2984, *(uint32_t*)buf2985); + *(int32_t*)buf2986 = rsAtomicDec((volatile int32_t*) buf2987); + *(int32_t*)buf2988 = rsAtomicDec((volatile uint32_t*) buf2989); + *(int32_t*)buf2990 = rsAtomicInc((volatile int32_t*) buf2991); + *(int32_t*)buf2992 = rsAtomicInc((volatile uint32_t*) buf2993); + *(uint32_t*)buf2994 = rsAtomicMax((volatile uint32_t*) buf2995, *(uint32_t*)buf2996); + *(int32_t*)buf2997 = rsAtomicMax((volatile int32_t*) buf2998, *(int32_t*)buf2999); + *(uint32_t*)buf3000 = rsAtomicMin((volatile uint32_t*) buf3001, *(uint32_t*)buf3002); + *(int32_t*)buf3003 = rsAtomicMin((volatile int32_t*) buf3004, *(int32_t*)buf3005); + *(int32_t*)buf3006 = rsAtomicOr((volatile int32_t*) buf3007, *(int32_t*)buf3008); + *(int32_t*)buf3009 = rsAtomicOr((volatile uint32_t*) buf3010, *(uint32_t*)buf3011); + *(int32_t*)buf3012 = rsAtomicSub((volatile int32_t*) buf3013, *(int32_t*)buf3014); + *(int32_t*)buf3015 = rsAtomicSub((volatile uint32_t*) buf3016, *(uint32_t*)buf3017); + *(int32_t*)buf3018 = rsAtomicXor((volatile int32_t*) buf3019, *(int32_t*)buf3020); + *(int32_t*)buf3021 = rsAtomicXor((volatile uint32_t*) buf3022, *(uint32_t*)buf3023); + *(char*)buf3024 = rsClamp(*(char*)buf3025, *(char*)buf3026, *(char*)buf3027); + *(uchar*)buf3028 = rsClamp(*(uchar*)buf3029, *(uchar*)buf3030, *(uchar*)buf3031); + *(short*)buf3032 = rsClamp(*(short*)buf3033, *(short*)buf3034, *(short*)buf3035); + *(ushort*)buf3036 = rsClamp(*(ushort*)buf3037, *(ushort*)buf3038, *(ushort*)buf3039); + *(int*)buf3040 = rsClamp(*(int*)buf3041, *(int*)buf3042, *(int*)buf3043); + *(uint*)buf3044 = rsClamp(*(uint*)buf3045, *(uint*)buf3046, *(uint*)buf3047); + rsClearObject((rs_element*) buf3048); + rsClearObject((rs_type*) buf3049); + rsClearObject((rs_allocation*) buf3050); + rsClearObject((rs_sampler*) buf3051); + rsClearObject((rs_script*) buf3052); #ifndef __LP64__ - rsClearObject((rs_mesh*) buf3035); - rsClearObject((rs_program_fragment*) buf3036); - rsClearObject((rs_program_vertex*) buf3037); - rsClearObject((rs_program_raster*) buf3038); - rsClearObject((rs_program_store*) buf3039); - rsClearObject((rs_font*) buf3040); + rsClearObject((rs_mesh*) buf3053); + rsClearObject((rs_program_fragment*) buf3054); + rsClearObject((rs_program_vertex*) buf3055); + rsClearObject((rs_program_raster*) buf3056); + rsClearObject((rs_program_store*) buf3057); + rsClearObject((rs_font*) buf3058); #endif - rsDebug((const char*) buf3041, *(double*)buf3042); - rsDebug((const char*) buf3043, *(int*)buf3044); - rsDebug((const char*) buf3045, *(uint*)buf3046); - rsDebug((const char*) buf3047, *(long*)buf3048); - rsDebug((const char*) buf3049, *(ulong*)buf3050); - rsDebug((const char*) buf3051, *(int2*)buf3052); - rsDebug((const char*) buf3053, *(int3*)buf3054); - rsDebug((const char*) buf3055, *(int4*)buf3056); - rsDebug((const char*) buf3057, *(uint2*)buf3058); - rsDebug((const char*) buf3059, *(uint3*)buf3060); - rsDebug((const char*) buf3061, *(uint4*)buf3062); - rsDebug((const char*) buf3063, *(long2*)buf3064); - rsDebug((const char*) buf3065, *(long3*)buf3066); - rsDebug((const char*) buf3067, *(long4*)buf3068); - rsDebug((const char*) buf3069, *(ulong2*)buf3070); - rsDebug((const char*) buf3071, *(ulong3*)buf3072); - rsDebug((const char*) buf3073, *(ulong4*)buf3074); - rsDebug((const char*) buf3075, *(float*)buf3076); - rsDebug((const char*) buf3077, *(float2*)buf3078); - rsDebug((const char*) buf3079, *(float3*)buf3080); - rsDebug((const char*) buf3081, *(float4*)buf3082); - rsDebug((const char*) buf3083, *(char*)buf3084); - rsDebug((const char*) buf3085, *(char2*)buf3086); - rsDebug((const char*) buf3087, *(char3*)buf3088); - rsDebug((const char*) buf3089, *(char4*)buf3090); - rsDebug((const char*) buf3091, *(uchar*)buf3092); - rsDebug((const char*) buf3093, *(uchar2*)buf3094); - rsDebug((const char*) buf3095, *(uchar3*)buf3096); - rsDebug((const char*) buf3097, *(uchar4*)buf3098); - rsDebug((const char*) buf3099, *(short*)buf3100); - rsDebug((const char*) buf3101, *(short2*)buf3102); - rsDebug((const char*) buf3103, *(short3*)buf3104); - rsDebug((const char*) buf3105, *(short4*)buf3106); - rsDebug((const char*) buf3107, *(ushort*)buf3108); - rsDebug((const char*) buf3109, *(ushort2*)buf3110); - rsDebug((const char*) buf3111, *(ushort3*)buf3112); - rsDebug((const char*) buf3113, *(ushort4*)buf3114); - rsDebug((const char*) buf3115, *(float*)buf3116, *(float*)buf3117); - rsDebug((const char*) buf3118, *(float*)buf3119, *(float*)buf3120, *(float*)buf3121); - rsDebug((const char*) buf3122, *(float*)buf3123, *(float*)buf3124, *(float*)buf3125, *(float*)buf3126); - rsDebug((const char*) buf3127, *(long long*)buf3128); - rsDebug((const char*) buf3129, *(unsigned long long*)buf3130); - rsDebug((const char*) buf3131, (const void*) buf3132); - rsDebug((const char*) buf3133, (const rs_matrix4x4*) buf3134); - rsDebug((const char*) buf3135, (const rs_matrix3x3*) buf3136); - rsDebug((const char*) buf3137, (const rs_matrix2x2*) buf3138); - *(uint32_t*)buf3139 = rsElementGetBytesSize(*(rs_element*)buf3140); - *(rs_data_kind*)buf3141 = rsElementGetDataKind(*(rs_element*)buf3142); - *(rs_data_type*)buf3143 = rsElementGetDataType(*(rs_element*)buf3144); - *(rs_element*)buf3145 = rsElementGetSubElement(*(rs_element*)buf3146, *(uint32_t*)buf3147); - *(uint32_t*)buf3148 = rsElementGetSubElementArraySize(*(rs_element*)buf3149, *(uint32_t*)buf3150); - *(uint32_t*)buf3151 = rsElementGetSubElementCount(*(rs_element*)buf3152); - *(uint32_t*)buf3153 = rsElementGetSubElementName(*(rs_element*)buf3154, *(uint32_t*)buf3155, (char*) buf3156, *(uint32_t*)buf3157); - *(uint32_t*)buf3158 = rsElementGetSubElementNameLength(*(rs_element*)buf3159, *(uint32_t*)buf3160); - *(uint32_t*)buf3161 = rsElementGetSubElementOffsetBytes(*(rs_element*)buf3162, *(uint32_t*)buf3163); - *(uint32_t*)buf3164 = rsElementGetVectorSize(*(rs_element*)buf3165); - rsExtractFrustumPlanes((const rs_matrix4x4*) buf3166, (float4*) buf3167, (float4*) buf3168, (float4*) buf3169, (float4*) buf3170, (float4*) buf3171, (float4*) buf3172); - rsForEach(*(rs_script*)buf3173, *(rs_allocation*)buf3174, *(rs_allocation*)buf3175); - *(float*)buf3176 = rsFrac(*(float*)buf3177); - *(rs_allocation*)buf3178 = rsGetAllocation((const void*) buf3179); - *(float*)buf3180 = rsGetDt(); - *(const void**)buf3181 = rsGetElementAt(*(rs_allocation*)buf3182, *(uint32_t*)buf3183); - *(const void**)buf3184 = rsGetElementAt(*(rs_allocation*)buf3185, *(uint32_t*)buf3186, *(uint32_t*)buf3187); - *(const void**)buf3188 = rsGetElementAt(*(rs_allocation*)buf3189, *(uint32_t*)buf3190, *(uint32_t*)buf3191, *(uint32_t*)buf3192); - *(float*)buf3193 = rsGetElementAt_float(*(rs_allocation*)buf3194, *(uint32_t*)buf3195); - *(float2*)buf3196 = rsGetElementAt_float2(*(rs_allocation*)buf3197, *(uint32_t*)buf3198); - *(float3*)buf3199 = rsGetElementAt_float3(*(rs_allocation*)buf3200, *(uint32_t*)buf3201); - *(float4*)buf3202 = rsGetElementAt_float4(*(rs_allocation*)buf3203, *(uint32_t*)buf3204); - *(double*)buf3205 = rsGetElementAt_double(*(rs_allocation*)buf3206, *(uint32_t*)buf3207); - *(double2*)buf3208 = rsGetElementAt_double2(*(rs_allocation*)buf3209, *(uint32_t*)buf3210); - *(double3*)buf3211 = rsGetElementAt_double3(*(rs_allocation*)buf3212, *(uint32_t*)buf3213); - *(double4*)buf3214 = rsGetElementAt_double4(*(rs_allocation*)buf3215, *(uint32_t*)buf3216); - *(char*)buf3217 = rsGetElementAt_char(*(rs_allocation*)buf3218, *(uint32_t*)buf3219); - *(char2*)buf3220 = rsGetElementAt_char2(*(rs_allocation*)buf3221, *(uint32_t*)buf3222); - *(char3*)buf3223 = rsGetElementAt_char3(*(rs_allocation*)buf3224, *(uint32_t*)buf3225); - *(char4*)buf3226 = rsGetElementAt_char4(*(rs_allocation*)buf3227, *(uint32_t*)buf3228); - *(uchar*)buf3229 = rsGetElementAt_uchar(*(rs_allocation*)buf3230, *(uint32_t*)buf3231); - *(uchar2*)buf3232 = rsGetElementAt_uchar2(*(rs_allocation*)buf3233, *(uint32_t*)buf3234); - *(uchar3*)buf3235 = rsGetElementAt_uchar3(*(rs_allocation*)buf3236, *(uint32_t*)buf3237); - *(uchar4*)buf3238 = rsGetElementAt_uchar4(*(rs_allocation*)buf3239, *(uint32_t*)buf3240); - *(short*)buf3241 = rsGetElementAt_short(*(rs_allocation*)buf3242, *(uint32_t*)buf3243); - *(short2*)buf3244 = rsGetElementAt_short2(*(rs_allocation*)buf3245, *(uint32_t*)buf3246); - *(short3*)buf3247 = rsGetElementAt_short3(*(rs_allocation*)buf3248, *(uint32_t*)buf3249); - *(short4*)buf3250 = rsGetElementAt_short4(*(rs_allocation*)buf3251, *(uint32_t*)buf3252); - *(ushort*)buf3253 = rsGetElementAt_ushort(*(rs_allocation*)buf3254, *(uint32_t*)buf3255); - *(ushort2*)buf3256 = rsGetElementAt_ushort2(*(rs_allocation*)buf3257, *(uint32_t*)buf3258); - *(ushort3*)buf3259 = rsGetElementAt_ushort3(*(rs_allocation*)buf3260, *(uint32_t*)buf3261); - *(ushort4*)buf3262 = rsGetElementAt_ushort4(*(rs_allocation*)buf3263, *(uint32_t*)buf3264); - *(int*)buf3265 = rsGetElementAt_int(*(rs_allocation*)buf3266, *(uint32_t*)buf3267); - *(int2*)buf3268 = rsGetElementAt_int2(*(rs_allocation*)buf3269, *(uint32_t*)buf3270); - *(int3*)buf3271 = rsGetElementAt_int3(*(rs_allocation*)buf3272, *(uint32_t*)buf3273); - *(int4*)buf3274 = rsGetElementAt_int4(*(rs_allocation*)buf3275, *(uint32_t*)buf3276); - *(uint*)buf3277 = rsGetElementAt_uint(*(rs_allocation*)buf3278, *(uint32_t*)buf3279); - *(uint2*)buf3280 = rsGetElementAt_uint2(*(rs_allocation*)buf3281, *(uint32_t*)buf3282); - *(uint3*)buf3283 = rsGetElementAt_uint3(*(rs_allocation*)buf3284, *(uint32_t*)buf3285); - *(uint4*)buf3286 = rsGetElementAt_uint4(*(rs_allocation*)buf3287, *(uint32_t*)buf3288); - *(long*)buf3289 = rsGetElementAt_long(*(rs_allocation*)buf3290, *(uint32_t*)buf3291); - *(long2*)buf3292 = rsGetElementAt_long2(*(rs_allocation*)buf3293, *(uint32_t*)buf3294); - *(long3*)buf3295 = rsGetElementAt_long3(*(rs_allocation*)buf3296, *(uint32_t*)buf3297); - *(long4*)buf3298 = rsGetElementAt_long4(*(rs_allocation*)buf3299, *(uint32_t*)buf3300); - *(ulong*)buf3301 = rsGetElementAt_ulong(*(rs_allocation*)buf3302, *(uint32_t*)buf3303); - *(ulong2*)buf3304 = rsGetElementAt_ulong2(*(rs_allocation*)buf3305, *(uint32_t*)buf3306); - *(ulong3*)buf3307 = rsGetElementAt_ulong3(*(rs_allocation*)buf3308, *(uint32_t*)buf3309); - *(ulong4*)buf3310 = rsGetElementAt_ulong4(*(rs_allocation*)buf3311, *(uint32_t*)buf3312); - *(float*)buf3313 = rsGetElementAt_float(*(rs_allocation*)buf3314, *(uint32_t*)buf3315, *(uint32_t*)buf3316); - *(float2*)buf3317 = rsGetElementAt_float2(*(rs_allocation*)buf3318, *(uint32_t*)buf3319, *(uint32_t*)buf3320); - *(float3*)buf3321 = rsGetElementAt_float3(*(rs_allocation*)buf3322, *(uint32_t*)buf3323, *(uint32_t*)buf3324); - *(float4*)buf3325 = rsGetElementAt_float4(*(rs_allocation*)buf3326, *(uint32_t*)buf3327, *(uint32_t*)buf3328); - *(double*)buf3329 = rsGetElementAt_double(*(rs_allocation*)buf3330, *(uint32_t*)buf3331, *(uint32_t*)buf3332); - *(double2*)buf3333 = rsGetElementAt_double2(*(rs_allocation*)buf3334, *(uint32_t*)buf3335, *(uint32_t*)buf3336); - *(double3*)buf3337 = rsGetElementAt_double3(*(rs_allocation*)buf3338, *(uint32_t*)buf3339, *(uint32_t*)buf3340); - *(double4*)buf3341 = rsGetElementAt_double4(*(rs_allocation*)buf3342, *(uint32_t*)buf3343, *(uint32_t*)buf3344); - *(char*)buf3345 = rsGetElementAt_char(*(rs_allocation*)buf3346, *(uint32_t*)buf3347, *(uint32_t*)buf3348); - *(char2*)buf3349 = rsGetElementAt_char2(*(rs_allocation*)buf3350, *(uint32_t*)buf3351, *(uint32_t*)buf3352); - *(char3*)buf3353 = rsGetElementAt_char3(*(rs_allocation*)buf3354, *(uint32_t*)buf3355, *(uint32_t*)buf3356); - *(char4*)buf3357 = rsGetElementAt_char4(*(rs_allocation*)buf3358, *(uint32_t*)buf3359, *(uint32_t*)buf3360); - *(uchar*)buf3361 = rsGetElementAt_uchar(*(rs_allocation*)buf3362, *(uint32_t*)buf3363, *(uint32_t*)buf3364); - *(uchar2*)buf3365 = rsGetElementAt_uchar2(*(rs_allocation*)buf3366, *(uint32_t*)buf3367, *(uint32_t*)buf3368); - *(uchar3*)buf3369 = rsGetElementAt_uchar3(*(rs_allocation*)buf3370, *(uint32_t*)buf3371, *(uint32_t*)buf3372); - *(uchar4*)buf3373 = rsGetElementAt_uchar4(*(rs_allocation*)buf3374, *(uint32_t*)buf3375, *(uint32_t*)buf3376); - *(short*)buf3377 = rsGetElementAt_short(*(rs_allocation*)buf3378, *(uint32_t*)buf3379, *(uint32_t*)buf3380); - *(short2*)buf3381 = rsGetElementAt_short2(*(rs_allocation*)buf3382, *(uint32_t*)buf3383, *(uint32_t*)buf3384); - *(short3*)buf3385 = rsGetElementAt_short3(*(rs_allocation*)buf3386, *(uint32_t*)buf3387, *(uint32_t*)buf3388); - *(short4*)buf3389 = rsGetElementAt_short4(*(rs_allocation*)buf3390, *(uint32_t*)buf3391, *(uint32_t*)buf3392); - *(ushort*)buf3393 = rsGetElementAt_ushort(*(rs_allocation*)buf3394, *(uint32_t*)buf3395, *(uint32_t*)buf3396); - *(ushort2*)buf3397 = rsGetElementAt_ushort2(*(rs_allocation*)buf3398, *(uint32_t*)buf3399, *(uint32_t*)buf3400); - *(ushort3*)buf3401 = rsGetElementAt_ushort3(*(rs_allocation*)buf3402, *(uint32_t*)buf3403, *(uint32_t*)buf3404); - *(ushort4*)buf3405 = rsGetElementAt_ushort4(*(rs_allocation*)buf3406, *(uint32_t*)buf3407, *(uint32_t*)buf3408); - *(int*)buf3409 = rsGetElementAt_int(*(rs_allocation*)buf3410, *(uint32_t*)buf3411, *(uint32_t*)buf3412); - *(int2*)buf3413 = rsGetElementAt_int2(*(rs_allocation*)buf3414, *(uint32_t*)buf3415, *(uint32_t*)buf3416); - *(int3*)buf3417 = rsGetElementAt_int3(*(rs_allocation*)buf3418, *(uint32_t*)buf3419, *(uint32_t*)buf3420); - *(int4*)buf3421 = rsGetElementAt_int4(*(rs_allocation*)buf3422, *(uint32_t*)buf3423, *(uint32_t*)buf3424); - *(uint*)buf3425 = rsGetElementAt_uint(*(rs_allocation*)buf3426, *(uint32_t*)buf3427, *(uint32_t*)buf3428); - *(uint2*)buf3429 = rsGetElementAt_uint2(*(rs_allocation*)buf3430, *(uint32_t*)buf3431, *(uint32_t*)buf3432); - *(uint3*)buf3433 = rsGetElementAt_uint3(*(rs_allocation*)buf3434, *(uint32_t*)buf3435, *(uint32_t*)buf3436); - *(uint4*)buf3437 = rsGetElementAt_uint4(*(rs_allocation*)buf3438, *(uint32_t*)buf3439, *(uint32_t*)buf3440); - *(long*)buf3441 = rsGetElementAt_long(*(rs_allocation*)buf3442, *(uint32_t*)buf3443, *(uint32_t*)buf3444); - *(long2*)buf3445 = rsGetElementAt_long2(*(rs_allocation*)buf3446, *(uint32_t*)buf3447, *(uint32_t*)buf3448); - *(long3*)buf3449 = rsGetElementAt_long3(*(rs_allocation*)buf3450, *(uint32_t*)buf3451, *(uint32_t*)buf3452); - *(long4*)buf3453 = rsGetElementAt_long4(*(rs_allocation*)buf3454, *(uint32_t*)buf3455, *(uint32_t*)buf3456); - *(ulong*)buf3457 = rsGetElementAt_ulong(*(rs_allocation*)buf3458, *(uint32_t*)buf3459, *(uint32_t*)buf3460); - *(ulong2*)buf3461 = rsGetElementAt_ulong2(*(rs_allocation*)buf3462, *(uint32_t*)buf3463, *(uint32_t*)buf3464); - *(ulong3*)buf3465 = rsGetElementAt_ulong3(*(rs_allocation*)buf3466, *(uint32_t*)buf3467, *(uint32_t*)buf3468); - *(ulong4*)buf3469 = rsGetElementAt_ulong4(*(rs_allocation*)buf3470, *(uint32_t*)buf3471, *(uint32_t*)buf3472); - *(float*)buf3473 = rsGetElementAt_float(*(rs_allocation*)buf3474, *(uint32_t*)buf3475, *(uint32_t*)buf3476, *(uint32_t*)buf3477); - *(float2*)buf3478 = rsGetElementAt_float2(*(rs_allocation*)buf3479, *(uint32_t*)buf3480, *(uint32_t*)buf3481, *(uint32_t*)buf3482); - *(float3*)buf3483 = rsGetElementAt_float3(*(rs_allocation*)buf3484, *(uint32_t*)buf3485, *(uint32_t*)buf3486, *(uint32_t*)buf3487); - *(float4*)buf3488 = rsGetElementAt_float4(*(rs_allocation*)buf3489, *(uint32_t*)buf3490, *(uint32_t*)buf3491, *(uint32_t*)buf3492); - *(double*)buf3493 = rsGetElementAt_double(*(rs_allocation*)buf3494, *(uint32_t*)buf3495, *(uint32_t*)buf3496, *(uint32_t*)buf3497); - *(double2*)buf3498 = rsGetElementAt_double2(*(rs_allocation*)buf3499, *(uint32_t*)buf3500, *(uint32_t*)buf3501, *(uint32_t*)buf3502); - *(double3*)buf3503 = rsGetElementAt_double3(*(rs_allocation*)buf3504, *(uint32_t*)buf3505, *(uint32_t*)buf3506, *(uint32_t*)buf3507); - *(double4*)buf3508 = rsGetElementAt_double4(*(rs_allocation*)buf3509, *(uint32_t*)buf3510, *(uint32_t*)buf3511, *(uint32_t*)buf3512); - *(char*)buf3513 = rsGetElementAt_char(*(rs_allocation*)buf3514, *(uint32_t*)buf3515, *(uint32_t*)buf3516, *(uint32_t*)buf3517); - *(char2*)buf3518 = rsGetElementAt_char2(*(rs_allocation*)buf3519, *(uint32_t*)buf3520, *(uint32_t*)buf3521, *(uint32_t*)buf3522); - *(char3*)buf3523 = rsGetElementAt_char3(*(rs_allocation*)buf3524, *(uint32_t*)buf3525, *(uint32_t*)buf3526, *(uint32_t*)buf3527); - *(char4*)buf3528 = rsGetElementAt_char4(*(rs_allocation*)buf3529, *(uint32_t*)buf3530, *(uint32_t*)buf3531, *(uint32_t*)buf3532); - *(uchar*)buf3533 = rsGetElementAt_uchar(*(rs_allocation*)buf3534, *(uint32_t*)buf3535, *(uint32_t*)buf3536, *(uint32_t*)buf3537); - *(uchar2*)buf3538 = rsGetElementAt_uchar2(*(rs_allocation*)buf3539, *(uint32_t*)buf3540, *(uint32_t*)buf3541, *(uint32_t*)buf3542); - *(uchar3*)buf3543 = rsGetElementAt_uchar3(*(rs_allocation*)buf3544, *(uint32_t*)buf3545, *(uint32_t*)buf3546, *(uint32_t*)buf3547); - *(uchar4*)buf3548 = rsGetElementAt_uchar4(*(rs_allocation*)buf3549, *(uint32_t*)buf3550, *(uint32_t*)buf3551, *(uint32_t*)buf3552); - *(short*)buf3553 = rsGetElementAt_short(*(rs_allocation*)buf3554, *(uint32_t*)buf3555, *(uint32_t*)buf3556, *(uint32_t*)buf3557); - *(short2*)buf3558 = rsGetElementAt_short2(*(rs_allocation*)buf3559, *(uint32_t*)buf3560, *(uint32_t*)buf3561, *(uint32_t*)buf3562); - *(short3*)buf3563 = rsGetElementAt_short3(*(rs_allocation*)buf3564, *(uint32_t*)buf3565, *(uint32_t*)buf3566, *(uint32_t*)buf3567); - *(short4*)buf3568 = rsGetElementAt_short4(*(rs_allocation*)buf3569, *(uint32_t*)buf3570, *(uint32_t*)buf3571, *(uint32_t*)buf3572); - *(ushort*)buf3573 = rsGetElementAt_ushort(*(rs_allocation*)buf3574, *(uint32_t*)buf3575, *(uint32_t*)buf3576, *(uint32_t*)buf3577); - *(ushort2*)buf3578 = rsGetElementAt_ushort2(*(rs_allocation*)buf3579, *(uint32_t*)buf3580, *(uint32_t*)buf3581, *(uint32_t*)buf3582); - *(ushort3*)buf3583 = rsGetElementAt_ushort3(*(rs_allocation*)buf3584, *(uint32_t*)buf3585, *(uint32_t*)buf3586, *(uint32_t*)buf3587); - *(ushort4*)buf3588 = rsGetElementAt_ushort4(*(rs_allocation*)buf3589, *(uint32_t*)buf3590, *(uint32_t*)buf3591, *(uint32_t*)buf3592); - *(int*)buf3593 = rsGetElementAt_int(*(rs_allocation*)buf3594, *(uint32_t*)buf3595, *(uint32_t*)buf3596, *(uint32_t*)buf3597); - *(int2*)buf3598 = rsGetElementAt_int2(*(rs_allocation*)buf3599, *(uint32_t*)buf3600, *(uint32_t*)buf3601, *(uint32_t*)buf3602); - *(int3*)buf3603 = rsGetElementAt_int3(*(rs_allocation*)buf3604, *(uint32_t*)buf3605, *(uint32_t*)buf3606, *(uint32_t*)buf3607); - *(int4*)buf3608 = rsGetElementAt_int4(*(rs_allocation*)buf3609, *(uint32_t*)buf3610, *(uint32_t*)buf3611, *(uint32_t*)buf3612); - *(uint*)buf3613 = rsGetElementAt_uint(*(rs_allocation*)buf3614, *(uint32_t*)buf3615, *(uint32_t*)buf3616, *(uint32_t*)buf3617); - *(uint2*)buf3618 = rsGetElementAt_uint2(*(rs_allocation*)buf3619, *(uint32_t*)buf3620, *(uint32_t*)buf3621, *(uint32_t*)buf3622); - *(uint3*)buf3623 = rsGetElementAt_uint3(*(rs_allocation*)buf3624, *(uint32_t*)buf3625, *(uint32_t*)buf3626, *(uint32_t*)buf3627); - *(uint4*)buf3628 = rsGetElementAt_uint4(*(rs_allocation*)buf3629, *(uint32_t*)buf3630, *(uint32_t*)buf3631, *(uint32_t*)buf3632); - *(long*)buf3633 = rsGetElementAt_long(*(rs_allocation*)buf3634, *(uint32_t*)buf3635, *(uint32_t*)buf3636, *(uint32_t*)buf3637); - *(long2*)buf3638 = rsGetElementAt_long2(*(rs_allocation*)buf3639, *(uint32_t*)buf3640, *(uint32_t*)buf3641, *(uint32_t*)buf3642); - *(long3*)buf3643 = rsGetElementAt_long3(*(rs_allocation*)buf3644, *(uint32_t*)buf3645, *(uint32_t*)buf3646, *(uint32_t*)buf3647); - *(long4*)buf3648 = rsGetElementAt_long4(*(rs_allocation*)buf3649, *(uint32_t*)buf3650, *(uint32_t*)buf3651, *(uint32_t*)buf3652); - *(ulong*)buf3653 = rsGetElementAt_ulong(*(rs_allocation*)buf3654, *(uint32_t*)buf3655, *(uint32_t*)buf3656, *(uint32_t*)buf3657); - *(ulong2*)buf3658 = rsGetElementAt_ulong2(*(rs_allocation*)buf3659, *(uint32_t*)buf3660, *(uint32_t*)buf3661, *(uint32_t*)buf3662); - *(ulong3*)buf3663 = rsGetElementAt_ulong3(*(rs_allocation*)buf3664, *(uint32_t*)buf3665, *(uint32_t*)buf3666, *(uint32_t*)buf3667); - *(ulong4*)buf3668 = rsGetElementAt_ulong4(*(rs_allocation*)buf3669, *(uint32_t*)buf3670, *(uint32_t*)buf3671, *(uint32_t*)buf3672); - *(uchar*)buf3673 = rsGetElementAtYuv_uchar_U(*(rs_allocation*)buf3674, *(uint32_t*)buf3675, *(uint32_t*)buf3676); - *(uchar*)buf3677 = rsGetElementAtYuv_uchar_V(*(rs_allocation*)buf3678, *(uint32_t*)buf3679, *(uint32_t*)buf3680); - *(uchar*)buf3681 = rsGetElementAtYuv_uchar_Y(*(rs_allocation*)buf3682, *(uint32_t*)buf3683, *(uint32_t*)buf3684); - *(bool*)buf3685 = rsIsObject(*(rs_element*)buf3686); - *(bool*)buf3687 = rsIsObject(*(rs_type*)buf3688); - *(bool*)buf3689 = rsIsObject(*(rs_allocation*)buf3690); - *(bool*)buf3691 = rsIsObject(*(rs_sampler*)buf3692); - *(bool*)buf3693 = rsIsObject(*(rs_script*)buf3694); + rsDebug((const char*) buf3059, *(double*)buf3060); + rsDebug((const char*) buf3061, *(int*)buf3062); + rsDebug((const char*) buf3063, *(uint*)buf3064); + rsDebug((const char*) buf3065, *(long*)buf3066); + rsDebug((const char*) buf3067, *(ulong*)buf3068); + rsDebug((const char*) buf3069, *(int2*)buf3070); + rsDebug((const char*) buf3071, *(int3*)buf3072); + rsDebug((const char*) buf3073, *(int4*)buf3074); + rsDebug((const char*) buf3075, *(uint2*)buf3076); + rsDebug((const char*) buf3077, *(uint3*)buf3078); + rsDebug((const char*) buf3079, *(uint4*)buf3080); + rsDebug((const char*) buf3081, *(long2*)buf3082); + rsDebug((const char*) buf3083, *(long3*)buf3084); + rsDebug((const char*) buf3085, *(long4*)buf3086); + rsDebug((const char*) buf3087, *(ulong2*)buf3088); + rsDebug((const char*) buf3089, *(ulong3*)buf3090); + rsDebug((const char*) buf3091, *(ulong4*)buf3092); + rsDebug((const char*) buf3093, *(float*)buf3094); + rsDebug((const char*) buf3095, *(float2*)buf3096); + rsDebug((const char*) buf3097, *(float3*)buf3098); + rsDebug((const char*) buf3099, *(float4*)buf3100); + rsDebug((const char*) buf3101, *(char*)buf3102); + rsDebug((const char*) buf3103, *(char2*)buf3104); + rsDebug((const char*) buf3105, *(char3*)buf3106); + rsDebug((const char*) buf3107, *(char4*)buf3108); + rsDebug((const char*) buf3109, *(uchar*)buf3110); + rsDebug((const char*) buf3111, *(uchar2*)buf3112); + rsDebug((const char*) buf3113, *(uchar3*)buf3114); + rsDebug((const char*) buf3115, *(uchar4*)buf3116); + rsDebug((const char*) buf3117, *(short*)buf3118); + rsDebug((const char*) buf3119, *(short2*)buf3120); + rsDebug((const char*) buf3121, *(short3*)buf3122); + rsDebug((const char*) buf3123, *(short4*)buf3124); + rsDebug((const char*) buf3125, *(ushort*)buf3126); + rsDebug((const char*) buf3127, *(ushort2*)buf3128); + rsDebug((const char*) buf3129, *(ushort3*)buf3130); + rsDebug((const char*) buf3131, *(ushort4*)buf3132); + rsDebug((const char*) buf3133, *(float*)buf3134, *(float*)buf3135); + rsDebug((const char*) buf3136, *(float*)buf3137, *(float*)buf3138, *(float*)buf3139); + rsDebug((const char*) buf3140, *(float*)buf3141, *(float*)buf3142, *(float*)buf3143, *(float*)buf3144); + rsDebug((const char*) buf3145, *(long long*)buf3146); + rsDebug((const char*) buf3147, *(unsigned long long*)buf3148); + rsDebug((const char*) buf3149, (const void*) buf3150); + rsDebug((const char*) buf3151, (const rs_matrix4x4*) buf3152); + rsDebug((const char*) buf3153, (const rs_matrix3x3*) buf3154); + rsDebug((const char*) buf3155, (const rs_matrix2x2*) buf3156); + *(uint32_t*)buf3157 = rsElementGetBytesSize(*(rs_element*)buf3158); + *(rs_data_kind*)buf3159 = rsElementGetDataKind(*(rs_element*)buf3160); + *(rs_data_type*)buf3161 = rsElementGetDataType(*(rs_element*)buf3162); + *(rs_element*)buf3163 = rsElementGetSubElement(*(rs_element*)buf3164, *(uint32_t*)buf3165); + *(uint32_t*)buf3166 = rsElementGetSubElementArraySize(*(rs_element*)buf3167, *(uint32_t*)buf3168); + *(uint32_t*)buf3169 = rsElementGetSubElementCount(*(rs_element*)buf3170); + *(uint32_t*)buf3171 = rsElementGetSubElementName(*(rs_element*)buf3172, *(uint32_t*)buf3173, (char*) buf3174, *(uint32_t*)buf3175); + *(uint32_t*)buf3176 = rsElementGetSubElementNameLength(*(rs_element*)buf3177, *(uint32_t*)buf3178); + *(uint32_t*)buf3179 = rsElementGetSubElementOffsetBytes(*(rs_element*)buf3180, *(uint32_t*)buf3181); + *(uint32_t*)buf3182 = rsElementGetVectorSize(*(rs_element*)buf3183); + rsExtractFrustumPlanes((const rs_matrix4x4*) buf3184, (float4*) buf3185, (float4*) buf3186, (float4*) buf3187, (float4*) buf3188, (float4*) buf3189, (float4*) buf3190); + rsForEach(*(rs_script*)buf3191, *(rs_allocation*)buf3192, *(rs_allocation*)buf3193); + *(float*)buf3194 = rsFrac(*(float*)buf3195); + *(rs_allocation*)buf3196 = rsGetAllocation((const void*) buf3197); + *(float*)buf3198 = rsGetDt(); + *(const void**)buf3199 = rsGetElementAt(*(rs_allocation*)buf3200, *(uint32_t*)buf3201); + *(const void**)buf3202 = rsGetElementAt(*(rs_allocation*)buf3203, *(uint32_t*)buf3204, *(uint32_t*)buf3205); + *(const void**)buf3206 = rsGetElementAt(*(rs_allocation*)buf3207, *(uint32_t*)buf3208, *(uint32_t*)buf3209, *(uint32_t*)buf3210); + *(float*)buf3211 = rsGetElementAt_float(*(rs_allocation*)buf3212, *(uint32_t*)buf3213); + *(float2*)buf3214 = rsGetElementAt_float2(*(rs_allocation*)buf3215, *(uint32_t*)buf3216); + *(float3*)buf3217 = rsGetElementAt_float3(*(rs_allocation*)buf3218, *(uint32_t*)buf3219); + *(float4*)buf3220 = rsGetElementAt_float4(*(rs_allocation*)buf3221, *(uint32_t*)buf3222); + *(double*)buf3223 = rsGetElementAt_double(*(rs_allocation*)buf3224, *(uint32_t*)buf3225); + *(double2*)buf3226 = rsGetElementAt_double2(*(rs_allocation*)buf3227, *(uint32_t*)buf3228); + *(double3*)buf3229 = rsGetElementAt_double3(*(rs_allocation*)buf3230, *(uint32_t*)buf3231); + *(double4*)buf3232 = rsGetElementAt_double4(*(rs_allocation*)buf3233, *(uint32_t*)buf3234); + *(char*)buf3235 = rsGetElementAt_char(*(rs_allocation*)buf3236, *(uint32_t*)buf3237); + *(char2*)buf3238 = rsGetElementAt_char2(*(rs_allocation*)buf3239, *(uint32_t*)buf3240); + *(char3*)buf3241 = rsGetElementAt_char3(*(rs_allocation*)buf3242, *(uint32_t*)buf3243); + *(char4*)buf3244 = rsGetElementAt_char4(*(rs_allocation*)buf3245, *(uint32_t*)buf3246); + *(uchar*)buf3247 = rsGetElementAt_uchar(*(rs_allocation*)buf3248, *(uint32_t*)buf3249); + *(uchar2*)buf3250 = rsGetElementAt_uchar2(*(rs_allocation*)buf3251, *(uint32_t*)buf3252); + *(uchar3*)buf3253 = rsGetElementAt_uchar3(*(rs_allocation*)buf3254, *(uint32_t*)buf3255); + *(uchar4*)buf3256 = rsGetElementAt_uchar4(*(rs_allocation*)buf3257, *(uint32_t*)buf3258); + *(short*)buf3259 = rsGetElementAt_short(*(rs_allocation*)buf3260, *(uint32_t*)buf3261); + *(short2*)buf3262 = rsGetElementAt_short2(*(rs_allocation*)buf3263, *(uint32_t*)buf3264); + *(short3*)buf3265 = rsGetElementAt_short3(*(rs_allocation*)buf3266, *(uint32_t*)buf3267); + *(short4*)buf3268 = rsGetElementAt_short4(*(rs_allocation*)buf3269, *(uint32_t*)buf3270); + *(ushort*)buf3271 = rsGetElementAt_ushort(*(rs_allocation*)buf3272, *(uint32_t*)buf3273); + *(ushort2*)buf3274 = rsGetElementAt_ushort2(*(rs_allocation*)buf3275, *(uint32_t*)buf3276); + *(ushort3*)buf3277 = rsGetElementAt_ushort3(*(rs_allocation*)buf3278, *(uint32_t*)buf3279); + *(ushort4*)buf3280 = rsGetElementAt_ushort4(*(rs_allocation*)buf3281, *(uint32_t*)buf3282); + *(int*)buf3283 = rsGetElementAt_int(*(rs_allocation*)buf3284, *(uint32_t*)buf3285); + *(int2*)buf3286 = rsGetElementAt_int2(*(rs_allocation*)buf3287, *(uint32_t*)buf3288); + *(int3*)buf3289 = rsGetElementAt_int3(*(rs_allocation*)buf3290, *(uint32_t*)buf3291); + *(int4*)buf3292 = rsGetElementAt_int4(*(rs_allocation*)buf3293, *(uint32_t*)buf3294); + *(uint*)buf3295 = rsGetElementAt_uint(*(rs_allocation*)buf3296, *(uint32_t*)buf3297); + *(uint2*)buf3298 = rsGetElementAt_uint2(*(rs_allocation*)buf3299, *(uint32_t*)buf3300); + *(uint3*)buf3301 = rsGetElementAt_uint3(*(rs_allocation*)buf3302, *(uint32_t*)buf3303); + *(uint4*)buf3304 = rsGetElementAt_uint4(*(rs_allocation*)buf3305, *(uint32_t*)buf3306); + *(long*)buf3307 = rsGetElementAt_long(*(rs_allocation*)buf3308, *(uint32_t*)buf3309); + *(long2*)buf3310 = rsGetElementAt_long2(*(rs_allocation*)buf3311, *(uint32_t*)buf3312); + *(long3*)buf3313 = rsGetElementAt_long3(*(rs_allocation*)buf3314, *(uint32_t*)buf3315); + *(long4*)buf3316 = rsGetElementAt_long4(*(rs_allocation*)buf3317, *(uint32_t*)buf3318); + *(ulong*)buf3319 = rsGetElementAt_ulong(*(rs_allocation*)buf3320, *(uint32_t*)buf3321); + *(ulong2*)buf3322 = rsGetElementAt_ulong2(*(rs_allocation*)buf3323, *(uint32_t*)buf3324); + *(ulong3*)buf3325 = rsGetElementAt_ulong3(*(rs_allocation*)buf3326, *(uint32_t*)buf3327); + *(ulong4*)buf3328 = rsGetElementAt_ulong4(*(rs_allocation*)buf3329, *(uint32_t*)buf3330); + *(float*)buf3331 = rsGetElementAt_float(*(rs_allocation*)buf3332, *(uint32_t*)buf3333, *(uint32_t*)buf3334); + *(float2*)buf3335 = rsGetElementAt_float2(*(rs_allocation*)buf3336, *(uint32_t*)buf3337, *(uint32_t*)buf3338); + *(float3*)buf3339 = rsGetElementAt_float3(*(rs_allocation*)buf3340, *(uint32_t*)buf3341, *(uint32_t*)buf3342); + *(float4*)buf3343 = rsGetElementAt_float4(*(rs_allocation*)buf3344, *(uint32_t*)buf3345, *(uint32_t*)buf3346); + *(double*)buf3347 = rsGetElementAt_double(*(rs_allocation*)buf3348, *(uint32_t*)buf3349, *(uint32_t*)buf3350); + *(double2*)buf3351 = rsGetElementAt_double2(*(rs_allocation*)buf3352, *(uint32_t*)buf3353, *(uint32_t*)buf3354); + *(double3*)buf3355 = rsGetElementAt_double3(*(rs_allocation*)buf3356, *(uint32_t*)buf3357, *(uint32_t*)buf3358); + *(double4*)buf3359 = rsGetElementAt_double4(*(rs_allocation*)buf3360, *(uint32_t*)buf3361, *(uint32_t*)buf3362); + *(char*)buf3363 = rsGetElementAt_char(*(rs_allocation*)buf3364, *(uint32_t*)buf3365, *(uint32_t*)buf3366); + *(char2*)buf3367 = rsGetElementAt_char2(*(rs_allocation*)buf3368, *(uint32_t*)buf3369, *(uint32_t*)buf3370); + *(char3*)buf3371 = rsGetElementAt_char3(*(rs_allocation*)buf3372, *(uint32_t*)buf3373, *(uint32_t*)buf3374); + *(char4*)buf3375 = rsGetElementAt_char4(*(rs_allocation*)buf3376, *(uint32_t*)buf3377, *(uint32_t*)buf3378); + *(uchar*)buf3379 = rsGetElementAt_uchar(*(rs_allocation*)buf3380, *(uint32_t*)buf3381, *(uint32_t*)buf3382); + *(uchar2*)buf3383 = rsGetElementAt_uchar2(*(rs_allocation*)buf3384, *(uint32_t*)buf3385, *(uint32_t*)buf3386); + *(uchar3*)buf3387 = rsGetElementAt_uchar3(*(rs_allocation*)buf3388, *(uint32_t*)buf3389, *(uint32_t*)buf3390); + *(uchar4*)buf3391 = rsGetElementAt_uchar4(*(rs_allocation*)buf3392, *(uint32_t*)buf3393, *(uint32_t*)buf3394); + *(short*)buf3395 = rsGetElementAt_short(*(rs_allocation*)buf3396, *(uint32_t*)buf3397, *(uint32_t*)buf3398); + *(short2*)buf3399 = rsGetElementAt_short2(*(rs_allocation*)buf3400, *(uint32_t*)buf3401, *(uint32_t*)buf3402); + *(short3*)buf3403 = rsGetElementAt_short3(*(rs_allocation*)buf3404, *(uint32_t*)buf3405, *(uint32_t*)buf3406); + *(short4*)buf3407 = rsGetElementAt_short4(*(rs_allocation*)buf3408, *(uint32_t*)buf3409, *(uint32_t*)buf3410); + *(ushort*)buf3411 = rsGetElementAt_ushort(*(rs_allocation*)buf3412, *(uint32_t*)buf3413, *(uint32_t*)buf3414); + *(ushort2*)buf3415 = rsGetElementAt_ushort2(*(rs_allocation*)buf3416, *(uint32_t*)buf3417, *(uint32_t*)buf3418); + *(ushort3*)buf3419 = rsGetElementAt_ushort3(*(rs_allocation*)buf3420, *(uint32_t*)buf3421, *(uint32_t*)buf3422); + *(ushort4*)buf3423 = rsGetElementAt_ushort4(*(rs_allocation*)buf3424, *(uint32_t*)buf3425, *(uint32_t*)buf3426); + *(int*)buf3427 = rsGetElementAt_int(*(rs_allocation*)buf3428, *(uint32_t*)buf3429, *(uint32_t*)buf3430); + *(int2*)buf3431 = rsGetElementAt_int2(*(rs_allocation*)buf3432, *(uint32_t*)buf3433, *(uint32_t*)buf3434); + *(int3*)buf3435 = rsGetElementAt_int3(*(rs_allocation*)buf3436, *(uint32_t*)buf3437, *(uint32_t*)buf3438); + *(int4*)buf3439 = rsGetElementAt_int4(*(rs_allocation*)buf3440, *(uint32_t*)buf3441, *(uint32_t*)buf3442); + *(uint*)buf3443 = rsGetElementAt_uint(*(rs_allocation*)buf3444, *(uint32_t*)buf3445, *(uint32_t*)buf3446); + *(uint2*)buf3447 = rsGetElementAt_uint2(*(rs_allocation*)buf3448, *(uint32_t*)buf3449, *(uint32_t*)buf3450); + *(uint3*)buf3451 = rsGetElementAt_uint3(*(rs_allocation*)buf3452, *(uint32_t*)buf3453, *(uint32_t*)buf3454); + *(uint4*)buf3455 = rsGetElementAt_uint4(*(rs_allocation*)buf3456, *(uint32_t*)buf3457, *(uint32_t*)buf3458); + *(long*)buf3459 = rsGetElementAt_long(*(rs_allocation*)buf3460, *(uint32_t*)buf3461, *(uint32_t*)buf3462); + *(long2*)buf3463 = rsGetElementAt_long2(*(rs_allocation*)buf3464, *(uint32_t*)buf3465, *(uint32_t*)buf3466); + *(long3*)buf3467 = rsGetElementAt_long3(*(rs_allocation*)buf3468, *(uint32_t*)buf3469, *(uint32_t*)buf3470); + *(long4*)buf3471 = rsGetElementAt_long4(*(rs_allocation*)buf3472, *(uint32_t*)buf3473, *(uint32_t*)buf3474); + *(ulong*)buf3475 = rsGetElementAt_ulong(*(rs_allocation*)buf3476, *(uint32_t*)buf3477, *(uint32_t*)buf3478); + *(ulong2*)buf3479 = rsGetElementAt_ulong2(*(rs_allocation*)buf3480, *(uint32_t*)buf3481, *(uint32_t*)buf3482); + *(ulong3*)buf3483 = rsGetElementAt_ulong3(*(rs_allocation*)buf3484, *(uint32_t*)buf3485, *(uint32_t*)buf3486); + *(ulong4*)buf3487 = rsGetElementAt_ulong4(*(rs_allocation*)buf3488, *(uint32_t*)buf3489, *(uint32_t*)buf3490); + *(float*)buf3491 = rsGetElementAt_float(*(rs_allocation*)buf3492, *(uint32_t*)buf3493, *(uint32_t*)buf3494, *(uint32_t*)buf3495); + *(float2*)buf3496 = rsGetElementAt_float2(*(rs_allocation*)buf3497, *(uint32_t*)buf3498, *(uint32_t*)buf3499, *(uint32_t*)buf3500); + *(float3*)buf3501 = rsGetElementAt_float3(*(rs_allocation*)buf3502, *(uint32_t*)buf3503, *(uint32_t*)buf3504, *(uint32_t*)buf3505); + *(float4*)buf3506 = rsGetElementAt_float4(*(rs_allocation*)buf3507, *(uint32_t*)buf3508, *(uint32_t*)buf3509, *(uint32_t*)buf3510); + *(double*)buf3511 = rsGetElementAt_double(*(rs_allocation*)buf3512, *(uint32_t*)buf3513, *(uint32_t*)buf3514, *(uint32_t*)buf3515); + *(double2*)buf3516 = rsGetElementAt_double2(*(rs_allocation*)buf3517, *(uint32_t*)buf3518, *(uint32_t*)buf3519, *(uint32_t*)buf3520); + *(double3*)buf3521 = rsGetElementAt_double3(*(rs_allocation*)buf3522, *(uint32_t*)buf3523, *(uint32_t*)buf3524, *(uint32_t*)buf3525); + *(double4*)buf3526 = rsGetElementAt_double4(*(rs_allocation*)buf3527, *(uint32_t*)buf3528, *(uint32_t*)buf3529, *(uint32_t*)buf3530); + *(char*)buf3531 = rsGetElementAt_char(*(rs_allocation*)buf3532, *(uint32_t*)buf3533, *(uint32_t*)buf3534, *(uint32_t*)buf3535); + *(char2*)buf3536 = rsGetElementAt_char2(*(rs_allocation*)buf3537, *(uint32_t*)buf3538, *(uint32_t*)buf3539, *(uint32_t*)buf3540); + *(char3*)buf3541 = rsGetElementAt_char3(*(rs_allocation*)buf3542, *(uint32_t*)buf3543, *(uint32_t*)buf3544, *(uint32_t*)buf3545); + *(char4*)buf3546 = rsGetElementAt_char4(*(rs_allocation*)buf3547, *(uint32_t*)buf3548, *(uint32_t*)buf3549, *(uint32_t*)buf3550); + *(uchar*)buf3551 = rsGetElementAt_uchar(*(rs_allocation*)buf3552, *(uint32_t*)buf3553, *(uint32_t*)buf3554, *(uint32_t*)buf3555); + *(uchar2*)buf3556 = rsGetElementAt_uchar2(*(rs_allocation*)buf3557, *(uint32_t*)buf3558, *(uint32_t*)buf3559, *(uint32_t*)buf3560); + *(uchar3*)buf3561 = rsGetElementAt_uchar3(*(rs_allocation*)buf3562, *(uint32_t*)buf3563, *(uint32_t*)buf3564, *(uint32_t*)buf3565); + *(uchar4*)buf3566 = rsGetElementAt_uchar4(*(rs_allocation*)buf3567, *(uint32_t*)buf3568, *(uint32_t*)buf3569, *(uint32_t*)buf3570); + *(short*)buf3571 = rsGetElementAt_short(*(rs_allocation*)buf3572, *(uint32_t*)buf3573, *(uint32_t*)buf3574, *(uint32_t*)buf3575); + *(short2*)buf3576 = rsGetElementAt_short2(*(rs_allocation*)buf3577, *(uint32_t*)buf3578, *(uint32_t*)buf3579, *(uint32_t*)buf3580); + *(short3*)buf3581 = rsGetElementAt_short3(*(rs_allocation*)buf3582, *(uint32_t*)buf3583, *(uint32_t*)buf3584, *(uint32_t*)buf3585); + *(short4*)buf3586 = rsGetElementAt_short4(*(rs_allocation*)buf3587, *(uint32_t*)buf3588, *(uint32_t*)buf3589, *(uint32_t*)buf3590); + *(ushort*)buf3591 = rsGetElementAt_ushort(*(rs_allocation*)buf3592, *(uint32_t*)buf3593, *(uint32_t*)buf3594, *(uint32_t*)buf3595); + *(ushort2*)buf3596 = rsGetElementAt_ushort2(*(rs_allocation*)buf3597, *(uint32_t*)buf3598, *(uint32_t*)buf3599, *(uint32_t*)buf3600); + *(ushort3*)buf3601 = rsGetElementAt_ushort3(*(rs_allocation*)buf3602, *(uint32_t*)buf3603, *(uint32_t*)buf3604, *(uint32_t*)buf3605); + *(ushort4*)buf3606 = rsGetElementAt_ushort4(*(rs_allocation*)buf3607, *(uint32_t*)buf3608, *(uint32_t*)buf3609, *(uint32_t*)buf3610); + *(int*)buf3611 = rsGetElementAt_int(*(rs_allocation*)buf3612, *(uint32_t*)buf3613, *(uint32_t*)buf3614, *(uint32_t*)buf3615); + *(int2*)buf3616 = rsGetElementAt_int2(*(rs_allocation*)buf3617, *(uint32_t*)buf3618, *(uint32_t*)buf3619, *(uint32_t*)buf3620); + *(int3*)buf3621 = rsGetElementAt_int3(*(rs_allocation*)buf3622, *(uint32_t*)buf3623, *(uint32_t*)buf3624, *(uint32_t*)buf3625); + *(int4*)buf3626 = rsGetElementAt_int4(*(rs_allocation*)buf3627, *(uint32_t*)buf3628, *(uint32_t*)buf3629, *(uint32_t*)buf3630); + *(uint*)buf3631 = rsGetElementAt_uint(*(rs_allocation*)buf3632, *(uint32_t*)buf3633, *(uint32_t*)buf3634, *(uint32_t*)buf3635); + *(uint2*)buf3636 = rsGetElementAt_uint2(*(rs_allocation*)buf3637, *(uint32_t*)buf3638, *(uint32_t*)buf3639, *(uint32_t*)buf3640); + *(uint3*)buf3641 = rsGetElementAt_uint3(*(rs_allocation*)buf3642, *(uint32_t*)buf3643, *(uint32_t*)buf3644, *(uint32_t*)buf3645); + *(uint4*)buf3646 = rsGetElementAt_uint4(*(rs_allocation*)buf3647, *(uint32_t*)buf3648, *(uint32_t*)buf3649, *(uint32_t*)buf3650); + *(long*)buf3651 = rsGetElementAt_long(*(rs_allocation*)buf3652, *(uint32_t*)buf3653, *(uint32_t*)buf3654, *(uint32_t*)buf3655); + *(long2*)buf3656 = rsGetElementAt_long2(*(rs_allocation*)buf3657, *(uint32_t*)buf3658, *(uint32_t*)buf3659, *(uint32_t*)buf3660); + *(long3*)buf3661 = rsGetElementAt_long3(*(rs_allocation*)buf3662, *(uint32_t*)buf3663, *(uint32_t*)buf3664, *(uint32_t*)buf3665); + *(long4*)buf3666 = rsGetElementAt_long4(*(rs_allocation*)buf3667, *(uint32_t*)buf3668, *(uint32_t*)buf3669, *(uint32_t*)buf3670); + *(ulong*)buf3671 = rsGetElementAt_ulong(*(rs_allocation*)buf3672, *(uint32_t*)buf3673, *(uint32_t*)buf3674, *(uint32_t*)buf3675); + *(ulong2*)buf3676 = rsGetElementAt_ulong2(*(rs_allocation*)buf3677, *(uint32_t*)buf3678, *(uint32_t*)buf3679, *(uint32_t*)buf3680); + *(ulong3*)buf3681 = rsGetElementAt_ulong3(*(rs_allocation*)buf3682, *(uint32_t*)buf3683, *(uint32_t*)buf3684, *(uint32_t*)buf3685); + *(ulong4*)buf3686 = rsGetElementAt_ulong4(*(rs_allocation*)buf3687, *(uint32_t*)buf3688, *(uint32_t*)buf3689, *(uint32_t*)buf3690); + *(uchar*)buf3691 = rsGetElementAtYuv_uchar_U(*(rs_allocation*)buf3692, *(uint32_t*)buf3693, *(uint32_t*)buf3694); + *(uchar*)buf3695 = rsGetElementAtYuv_uchar_V(*(rs_allocation*)buf3696, *(uint32_t*)buf3697, *(uint32_t*)buf3698); + *(uchar*)buf3699 = rsGetElementAtYuv_uchar_Y(*(rs_allocation*)buf3700, *(uint32_t*)buf3701, *(uint32_t*)buf3702); + *(bool*)buf3703 = rsIsObject(*(rs_element*)buf3704); + *(bool*)buf3705 = rsIsObject(*(rs_type*)buf3706); + *(bool*)buf3707 = rsIsObject(*(rs_allocation*)buf3708); + *(bool*)buf3709 = rsIsObject(*(rs_sampler*)buf3710); + *(bool*)buf3711 = rsIsObject(*(rs_script*)buf3712); #ifndef __LP64__ - *(bool*)buf3695 = rsIsObject(*(rs_mesh*)buf3696); - *(bool*)buf3697 = rsIsObject(*(rs_program_fragment*)buf3698); - *(bool*)buf3699 = rsIsObject(*(rs_program_vertex*)buf3700); - *(bool*)buf3701 = rsIsObject(*(rs_program_raster*)buf3702); - *(bool*)buf3703 = rsIsObject(*(rs_program_store*)buf3704); - *(bool*)buf3705 = rsIsObject(*(rs_font*)buf3706); + *(bool*)buf3713 = rsIsObject(*(rs_mesh*)buf3714); + *(bool*)buf3715 = rsIsObject(*(rs_program_fragment*)buf3716); + *(bool*)buf3717 = rsIsObject(*(rs_program_vertex*)buf3718); + *(bool*)buf3719 = rsIsObject(*(rs_program_raster*)buf3720); + *(bool*)buf3721 = rsIsObject(*(rs_program_store*)buf3722); + *(bool*)buf3723 = rsIsObject(*(rs_font*)buf3724); #endif - *(bool*)buf3707 = rsIsSphereInFrustum((float4*) buf3708, (float4*) buf3709, (float4*) buf3710, (float4*) buf3711, (float4*) buf3712, (float4*) buf3713, (float4*) buf3714); - *(rs_tm**)buf3715 = rsLocaltime((rs_tm*) buf3716, (const rs_time_t*) buf3717); - *(float*)buf3718 = rsMatrixGet((const rs_matrix4x4*) buf3719, *(uint32_t*)buf3720, *(uint32_t*)buf3721); - *(float*)buf3722 = rsMatrixGet((const rs_matrix3x3*) buf3723, *(uint32_t*)buf3724, *(uint32_t*)buf3725); - *(float*)buf3726 = rsMatrixGet((const rs_matrix2x2*) buf3727, *(uint32_t*)buf3728, *(uint32_t*)buf3729); - *(bool*)buf3730 = rsMatrixInverse((rs_matrix4x4*) buf3731); - *(bool*)buf3732 = rsMatrixInverseTranspose((rs_matrix4x4*) buf3733); - rsMatrixLoad((rs_matrix4x4*) buf3734, (const float*) buf3735); - rsMatrixLoad((rs_matrix3x3*) buf3736, (const float*) buf3737); - rsMatrixLoad((rs_matrix2x2*) buf3738, (const float*) buf3739); - rsMatrixLoad((rs_matrix4x4*) buf3740, (const rs_matrix4x4*) buf3741); - rsMatrixLoad((rs_matrix3x3*) buf3742, (const rs_matrix3x3*) buf3743); - rsMatrixLoad((rs_matrix2x2*) buf3744, (const rs_matrix2x2*) buf3745); - rsMatrixLoad((rs_matrix4x4*) buf3746, (const rs_matrix3x3*) buf3747); - rsMatrixLoad((rs_matrix4x4*) buf3748, (const rs_matrix2x2*) buf3749); - rsMatrixLoadFrustum((rs_matrix4x4*) buf3750, *(float*)buf3751, *(float*)buf3752, *(float*)buf3753, *(float*)buf3754, *(float*)buf3755, *(float*)buf3756); - rsMatrixLoadIdentity((rs_matrix4x4*) buf3757); - rsMatrixLoadIdentity((rs_matrix3x3*) buf3758); - rsMatrixLoadIdentity((rs_matrix2x2*) buf3759); - rsMatrixLoadMultiply((rs_matrix4x4*) buf3760, (const rs_matrix4x4*) buf3761, (const rs_matrix4x4*) buf3762); - rsMatrixLoadMultiply((rs_matrix3x3*) buf3763, (const rs_matrix3x3*) buf3764, (const rs_matrix3x3*) buf3765); - rsMatrixLoadMultiply((rs_matrix2x2*) buf3766, (const rs_matrix2x2*) buf3767, (const rs_matrix2x2*) buf3768); - rsMatrixLoadOrtho((rs_matrix4x4*) buf3769, *(float*)buf3770, *(float*)buf3771, *(float*)buf3772, *(float*)buf3773, *(float*)buf3774, *(float*)buf3775); - rsMatrixLoadPerspective((rs_matrix4x4*) buf3776, *(float*)buf3777, *(float*)buf3778, *(float*)buf3779, *(float*)buf3780); - rsMatrixLoadRotate((rs_matrix4x4*) buf3781, *(float*)buf3782, *(float*)buf3783, *(float*)buf3784, *(float*)buf3785); - rsMatrixLoadScale((rs_matrix4x4*) buf3786, *(float*)buf3787, *(float*)buf3788, *(float*)buf3789); - rsMatrixLoadTranslate((rs_matrix4x4*) buf3790, *(float*)buf3791, *(float*)buf3792, *(float*)buf3793); - rsMatrixMultiply((rs_matrix4x4*) buf3794, (const rs_matrix4x4*) buf3795); - rsMatrixMultiply((rs_matrix3x3*) buf3796, (const rs_matrix3x3*) buf3797); - rsMatrixMultiply((rs_matrix2x2*) buf3798, (const rs_matrix2x2*) buf3799); - *(float4*)buf3800 = rsMatrixMultiply((const rs_matrix4x4*) buf3801, *(float4*)buf3802); - *(float4*)buf3803 = rsMatrixMultiply((const rs_matrix4x4*) buf3804, *(float3*)buf3805); - *(float4*)buf3806 = rsMatrixMultiply((const rs_matrix4x4*) buf3807, *(float2*)buf3808); - *(float3*)buf3809 = rsMatrixMultiply((const rs_matrix3x3*) buf3810, *(float3*)buf3811); - *(float3*)buf3812 = rsMatrixMultiply((const rs_matrix3x3*) buf3813, *(float2*)buf3814); - *(float2*)buf3815 = rsMatrixMultiply((const rs_matrix2x2*) buf3816, *(float2*)buf3817); - rsMatrixRotate((rs_matrix4x4*) buf3818, *(float*)buf3819, *(float*)buf3820, *(float*)buf3821, *(float*)buf3822); - rsMatrixScale((rs_matrix4x4*) buf3823, *(float*)buf3824, *(float*)buf3825, *(float*)buf3826); - rsMatrixSet((rs_matrix4x4*) buf3827, *(uint32_t*)buf3828, *(uint32_t*)buf3829, *(float*)buf3830); - rsMatrixSet((rs_matrix3x3*) buf3831, *(uint32_t*)buf3832, *(uint32_t*)buf3833, *(float*)buf3834); - rsMatrixSet((rs_matrix2x2*) buf3835, *(uint32_t*)buf3836, *(uint32_t*)buf3837, *(float*)buf3838); - rsMatrixTranslate((rs_matrix4x4*) buf3839, *(float*)buf3840, *(float*)buf3841, *(float*)buf3842); - rsMatrixTranspose((rs_matrix4x4*) buf3843); - rsMatrixTranspose((rs_matrix3x3*) buf3844); - rsMatrixTranspose((rs_matrix2x2*) buf3845); - *(uchar4*)buf3846 = rsPackColorTo8888(*(float*)buf3847, *(float*)buf3848, *(float*)buf3849); - *(uchar4*)buf3850 = rsPackColorTo8888(*(float*)buf3851, *(float*)buf3852, *(float*)buf3853, *(float*)buf3854); - *(uchar4*)buf3855 = rsPackColorTo8888(*(float3*)buf3856); - *(uchar4*)buf3857 = rsPackColorTo8888(*(float4*)buf3858); - rsQuaternionAdd((rs_quaternion*) buf3859, (const rs_quaternion*) buf3860); - rsQuaternionConjugate((rs_quaternion*) buf3861); - *(float*)buf3862 = rsQuaternionDot((const rs_quaternion*) buf3863, (const rs_quaternion*) buf3864); - rsQuaternionGetMatrixUnit((rs_matrix4x4*) buf3865, (const rs_quaternion*) buf3866); - rsQuaternionLoadRotate((rs_quaternion*) buf3867, *(float*)buf3868, *(float*)buf3869, *(float*)buf3870, *(float*)buf3871); - rsQuaternionLoadRotateUnit((rs_quaternion*) buf3872, *(float*)buf3873, *(float*)buf3874, *(float*)buf3875, *(float*)buf3876); - rsQuaternionMultiply((rs_quaternion*) buf3877, *(float*)buf3878); - rsQuaternionMultiply((rs_quaternion*) buf3879, (const rs_quaternion*) buf3880); - rsQuaternionNormalize((rs_quaternion*) buf3881); - rsQuaternionSet((rs_quaternion*) buf3882, *(float*)buf3883, *(float*)buf3884, *(float*)buf3885, *(float*)buf3886); - rsQuaternionSet((rs_quaternion*) buf3887, (const rs_quaternion*) buf3888); - rsQuaternionSlerp((rs_quaternion*) buf3889, (const rs_quaternion*) buf3890, (const rs_quaternion*) buf3891, *(float*)buf3892); - *(int*)buf3893 = rsRand(*(int*)buf3894); - *(int*)buf3895 = rsRand(*(int*)buf3896, *(int*)buf3897); - *(float*)buf3898 = rsRand(*(float*)buf3899); - *(float*)buf3900 = rsRand(*(float*)buf3901, *(float*)buf3902); - *(float4*)buf3903 = rsSample(*(rs_allocation*)buf3904, *(rs_sampler*)buf3905, *(float*)buf3906); - *(float4*)buf3907 = rsSample(*(rs_allocation*)buf3908, *(rs_sampler*)buf3909, *(float*)buf3910, *(float*)buf3911); - *(float4*)buf3912 = rsSample(*(rs_allocation*)buf3913, *(rs_sampler*)buf3914, *(float2*)buf3915); - *(float4*)buf3916 = rsSample(*(rs_allocation*)buf3917, *(rs_sampler*)buf3918, *(float2*)buf3919, *(float*)buf3920); - *(float*)buf3921 = rsSamplerGetAnisotropy(*(rs_sampler*)buf3922); - *(rs_sampler_value*)buf3923 = rsSamplerGetMagnification(*(rs_sampler*)buf3924); - *(rs_sampler_value*)buf3925 = rsSamplerGetMinification(*(rs_sampler*)buf3926); - *(rs_sampler_value*)buf3927 = rsSamplerGetWrapS(*(rs_sampler*)buf3928); - *(rs_sampler_value*)buf3929 = rsSamplerGetWrapT(*(rs_sampler*)buf3930); - *(bool*)buf3931 = rsSendToClient(*(int*)buf3932); - *(bool*)buf3933 = rsSendToClient(*(int*)buf3934, (const void*) buf3935, *(uint*)buf3936); - rsSendToClientBlocking(*(int*)buf3937); - rsSendToClientBlocking(*(int*)buf3938, (const void*) buf3939, *(uint*)buf3940); - rsSetElementAt(*(rs_allocation*)buf3941, (void*) buf3942, *(uint32_t*)buf3943); - rsSetElementAt(*(rs_allocation*)buf3944, (void*) buf3945, *(uint32_t*)buf3946, *(uint32_t*)buf3947); - rsSetElementAt_float(*(rs_allocation*)buf3948, *(float*)buf3949, *(uint32_t*)buf3950); - rsSetElementAt_float2(*(rs_allocation*)buf3951, *(float2*)buf3952, *(uint32_t*)buf3953); - rsSetElementAt_float3(*(rs_allocation*)buf3954, *(float3*)buf3955, *(uint32_t*)buf3956); - rsSetElementAt_float4(*(rs_allocation*)buf3957, *(float4*)buf3958, *(uint32_t*)buf3959); - rsSetElementAt_double(*(rs_allocation*)buf3960, *(double*)buf3961, *(uint32_t*)buf3962); - rsSetElementAt_double2(*(rs_allocation*)buf3963, *(double2*)buf3964, *(uint32_t*)buf3965); - rsSetElementAt_double3(*(rs_allocation*)buf3966, *(double3*)buf3967, *(uint32_t*)buf3968); - rsSetElementAt_double4(*(rs_allocation*)buf3969, *(double4*)buf3970, *(uint32_t*)buf3971); - rsSetElementAt_char(*(rs_allocation*)buf3972, *(char*)buf3973, *(uint32_t*)buf3974); - rsSetElementAt_char2(*(rs_allocation*)buf3975, *(char2*)buf3976, *(uint32_t*)buf3977); - rsSetElementAt_char3(*(rs_allocation*)buf3978, *(char3*)buf3979, *(uint32_t*)buf3980); - rsSetElementAt_char4(*(rs_allocation*)buf3981, *(char4*)buf3982, *(uint32_t*)buf3983); - rsSetElementAt_uchar(*(rs_allocation*)buf3984, *(uchar*)buf3985, *(uint32_t*)buf3986); - rsSetElementAt_uchar2(*(rs_allocation*)buf3987, *(uchar2*)buf3988, *(uint32_t*)buf3989); - rsSetElementAt_uchar3(*(rs_allocation*)buf3990, *(uchar3*)buf3991, *(uint32_t*)buf3992); - rsSetElementAt_uchar4(*(rs_allocation*)buf3993, *(uchar4*)buf3994, *(uint32_t*)buf3995); - rsSetElementAt_short(*(rs_allocation*)buf3996, *(short*)buf3997, *(uint32_t*)buf3998); - rsSetElementAt_short2(*(rs_allocation*)buf3999, *(short2*)buf4000, *(uint32_t*)buf4001); - rsSetElementAt_short3(*(rs_allocation*)buf4002, *(short3*)buf4003, *(uint32_t*)buf4004); - rsSetElementAt_short4(*(rs_allocation*)buf4005, *(short4*)buf4006, *(uint32_t*)buf4007); - rsSetElementAt_ushort(*(rs_allocation*)buf4008, *(ushort*)buf4009, *(uint32_t*)buf4010); - rsSetElementAt_ushort2(*(rs_allocation*)buf4011, *(ushort2*)buf4012, *(uint32_t*)buf4013); - rsSetElementAt_ushort3(*(rs_allocation*)buf4014, *(ushort3*)buf4015, *(uint32_t*)buf4016); - rsSetElementAt_ushort4(*(rs_allocation*)buf4017, *(ushort4*)buf4018, *(uint32_t*)buf4019); - rsSetElementAt_int(*(rs_allocation*)buf4020, *(int*)buf4021, *(uint32_t*)buf4022); - rsSetElementAt_int2(*(rs_allocation*)buf4023, *(int2*)buf4024, *(uint32_t*)buf4025); - rsSetElementAt_int3(*(rs_allocation*)buf4026, *(int3*)buf4027, *(uint32_t*)buf4028); - rsSetElementAt_int4(*(rs_allocation*)buf4029, *(int4*)buf4030, *(uint32_t*)buf4031); - rsSetElementAt_uint(*(rs_allocation*)buf4032, *(uint*)buf4033, *(uint32_t*)buf4034); - rsSetElementAt_uint2(*(rs_allocation*)buf4035, *(uint2*)buf4036, *(uint32_t*)buf4037); - rsSetElementAt_uint3(*(rs_allocation*)buf4038, *(uint3*)buf4039, *(uint32_t*)buf4040); - rsSetElementAt_uint4(*(rs_allocation*)buf4041, *(uint4*)buf4042, *(uint32_t*)buf4043); - rsSetElementAt_long(*(rs_allocation*)buf4044, *(long*)buf4045, *(uint32_t*)buf4046); - rsSetElementAt_long2(*(rs_allocation*)buf4047, *(long2*)buf4048, *(uint32_t*)buf4049); - rsSetElementAt_long3(*(rs_allocation*)buf4050, *(long3*)buf4051, *(uint32_t*)buf4052); - rsSetElementAt_long4(*(rs_allocation*)buf4053, *(long4*)buf4054, *(uint32_t*)buf4055); - rsSetElementAt_ulong(*(rs_allocation*)buf4056, *(ulong*)buf4057, *(uint32_t*)buf4058); - rsSetElementAt_ulong2(*(rs_allocation*)buf4059, *(ulong2*)buf4060, *(uint32_t*)buf4061); - rsSetElementAt_ulong3(*(rs_allocation*)buf4062, *(ulong3*)buf4063, *(uint32_t*)buf4064); - rsSetElementAt_ulong4(*(rs_allocation*)buf4065, *(ulong4*)buf4066, *(uint32_t*)buf4067); - rsSetElementAt_float(*(rs_allocation*)buf4068, *(float*)buf4069, *(uint32_t*)buf4070, *(uint32_t*)buf4071); - rsSetElementAt_float2(*(rs_allocation*)buf4072, *(float2*)buf4073, *(uint32_t*)buf4074, *(uint32_t*)buf4075); - rsSetElementAt_float3(*(rs_allocation*)buf4076, *(float3*)buf4077, *(uint32_t*)buf4078, *(uint32_t*)buf4079); - rsSetElementAt_float4(*(rs_allocation*)buf4080, *(float4*)buf4081, *(uint32_t*)buf4082, *(uint32_t*)buf4083); - rsSetElementAt_double(*(rs_allocation*)buf4084, *(double*)buf4085, *(uint32_t*)buf4086, *(uint32_t*)buf4087); - rsSetElementAt_double2(*(rs_allocation*)buf4088, *(double2*)buf4089, *(uint32_t*)buf4090, *(uint32_t*)buf4091); - rsSetElementAt_double3(*(rs_allocation*)buf4092, *(double3*)buf4093, *(uint32_t*)buf4094, *(uint32_t*)buf4095); - rsSetElementAt_double4(*(rs_allocation*)buf4096, *(double4*)buf4097, *(uint32_t*)buf4098, *(uint32_t*)buf4099); - rsSetElementAt_char(*(rs_allocation*)buf4100, *(char*)buf4101, *(uint32_t*)buf4102, *(uint32_t*)buf4103); - rsSetElementAt_char2(*(rs_allocation*)buf4104, *(char2*)buf4105, *(uint32_t*)buf4106, *(uint32_t*)buf4107); - rsSetElementAt_char3(*(rs_allocation*)buf4108, *(char3*)buf4109, *(uint32_t*)buf4110, *(uint32_t*)buf4111); - rsSetElementAt_char4(*(rs_allocation*)buf4112, *(char4*)buf4113, *(uint32_t*)buf4114, *(uint32_t*)buf4115); - rsSetElementAt_uchar(*(rs_allocation*)buf4116, *(uchar*)buf4117, *(uint32_t*)buf4118, *(uint32_t*)buf4119); - rsSetElementAt_uchar2(*(rs_allocation*)buf4120, *(uchar2*)buf4121, *(uint32_t*)buf4122, *(uint32_t*)buf4123); - rsSetElementAt_uchar3(*(rs_allocation*)buf4124, *(uchar3*)buf4125, *(uint32_t*)buf4126, *(uint32_t*)buf4127); - rsSetElementAt_uchar4(*(rs_allocation*)buf4128, *(uchar4*)buf4129, *(uint32_t*)buf4130, *(uint32_t*)buf4131); - rsSetElementAt_short(*(rs_allocation*)buf4132, *(short*)buf4133, *(uint32_t*)buf4134, *(uint32_t*)buf4135); - rsSetElementAt_short2(*(rs_allocation*)buf4136, *(short2*)buf4137, *(uint32_t*)buf4138, *(uint32_t*)buf4139); - rsSetElementAt_short3(*(rs_allocation*)buf4140, *(short3*)buf4141, *(uint32_t*)buf4142, *(uint32_t*)buf4143); - rsSetElementAt_short4(*(rs_allocation*)buf4144, *(short4*)buf4145, *(uint32_t*)buf4146, *(uint32_t*)buf4147); - rsSetElementAt_ushort(*(rs_allocation*)buf4148, *(ushort*)buf4149, *(uint32_t*)buf4150, *(uint32_t*)buf4151); - rsSetElementAt_ushort2(*(rs_allocation*)buf4152, *(ushort2*)buf4153, *(uint32_t*)buf4154, *(uint32_t*)buf4155); - rsSetElementAt_ushort3(*(rs_allocation*)buf4156, *(ushort3*)buf4157, *(uint32_t*)buf4158, *(uint32_t*)buf4159); - rsSetElementAt_ushort4(*(rs_allocation*)buf4160, *(ushort4*)buf4161, *(uint32_t*)buf4162, *(uint32_t*)buf4163); - rsSetElementAt_int(*(rs_allocation*)buf4164, *(int*)buf4165, *(uint32_t*)buf4166, *(uint32_t*)buf4167); - rsSetElementAt_int2(*(rs_allocation*)buf4168, *(int2*)buf4169, *(uint32_t*)buf4170, *(uint32_t*)buf4171); - rsSetElementAt_int3(*(rs_allocation*)buf4172, *(int3*)buf4173, *(uint32_t*)buf4174, *(uint32_t*)buf4175); - rsSetElementAt_int4(*(rs_allocation*)buf4176, *(int4*)buf4177, *(uint32_t*)buf4178, *(uint32_t*)buf4179); - rsSetElementAt_uint(*(rs_allocation*)buf4180, *(uint*)buf4181, *(uint32_t*)buf4182, *(uint32_t*)buf4183); - rsSetElementAt_uint2(*(rs_allocation*)buf4184, *(uint2*)buf4185, *(uint32_t*)buf4186, *(uint32_t*)buf4187); - rsSetElementAt_uint3(*(rs_allocation*)buf4188, *(uint3*)buf4189, *(uint32_t*)buf4190, *(uint32_t*)buf4191); - rsSetElementAt_uint4(*(rs_allocation*)buf4192, *(uint4*)buf4193, *(uint32_t*)buf4194, *(uint32_t*)buf4195); - rsSetElementAt_long(*(rs_allocation*)buf4196, *(long*)buf4197, *(uint32_t*)buf4198, *(uint32_t*)buf4199); - rsSetElementAt_long2(*(rs_allocation*)buf4200, *(long2*)buf4201, *(uint32_t*)buf4202, *(uint32_t*)buf4203); - rsSetElementAt_long3(*(rs_allocation*)buf4204, *(long3*)buf4205, *(uint32_t*)buf4206, *(uint32_t*)buf4207); - rsSetElementAt_long4(*(rs_allocation*)buf4208, *(long4*)buf4209, *(uint32_t*)buf4210, *(uint32_t*)buf4211); - rsSetElementAt_ulong(*(rs_allocation*)buf4212, *(ulong*)buf4213, *(uint32_t*)buf4214, *(uint32_t*)buf4215); - rsSetElementAt_ulong2(*(rs_allocation*)buf4216, *(ulong2*)buf4217, *(uint32_t*)buf4218, *(uint32_t*)buf4219); - rsSetElementAt_ulong3(*(rs_allocation*)buf4220, *(ulong3*)buf4221, *(uint32_t*)buf4222, *(uint32_t*)buf4223); - rsSetElementAt_ulong4(*(rs_allocation*)buf4224, *(ulong4*)buf4225, *(uint32_t*)buf4226, *(uint32_t*)buf4227); - rsSetElementAt_float(*(rs_allocation*)buf4228, *(float*)buf4229, *(uint32_t*)buf4230, *(uint32_t*)buf4231, *(uint32_t*)buf4232); - rsSetElementAt_float2(*(rs_allocation*)buf4233, *(float2*)buf4234, *(uint32_t*)buf4235, *(uint32_t*)buf4236, *(uint32_t*)buf4237); - rsSetElementAt_float3(*(rs_allocation*)buf4238, *(float3*)buf4239, *(uint32_t*)buf4240, *(uint32_t*)buf4241, *(uint32_t*)buf4242); - rsSetElementAt_float4(*(rs_allocation*)buf4243, *(float4*)buf4244, *(uint32_t*)buf4245, *(uint32_t*)buf4246, *(uint32_t*)buf4247); - rsSetElementAt_double(*(rs_allocation*)buf4248, *(double*)buf4249, *(uint32_t*)buf4250, *(uint32_t*)buf4251, *(uint32_t*)buf4252); - rsSetElementAt_double2(*(rs_allocation*)buf4253, *(double2*)buf4254, *(uint32_t*)buf4255, *(uint32_t*)buf4256, *(uint32_t*)buf4257); - rsSetElementAt_double3(*(rs_allocation*)buf4258, *(double3*)buf4259, *(uint32_t*)buf4260, *(uint32_t*)buf4261, *(uint32_t*)buf4262); - rsSetElementAt_double4(*(rs_allocation*)buf4263, *(double4*)buf4264, *(uint32_t*)buf4265, *(uint32_t*)buf4266, *(uint32_t*)buf4267); - rsSetElementAt_char(*(rs_allocation*)buf4268, *(char*)buf4269, *(uint32_t*)buf4270, *(uint32_t*)buf4271, *(uint32_t*)buf4272); - rsSetElementAt_char2(*(rs_allocation*)buf4273, *(char2*)buf4274, *(uint32_t*)buf4275, *(uint32_t*)buf4276, *(uint32_t*)buf4277); - rsSetElementAt_char3(*(rs_allocation*)buf4278, *(char3*)buf4279, *(uint32_t*)buf4280, *(uint32_t*)buf4281, *(uint32_t*)buf4282); - rsSetElementAt_char4(*(rs_allocation*)buf4283, *(char4*)buf4284, *(uint32_t*)buf4285, *(uint32_t*)buf4286, *(uint32_t*)buf4287); - rsSetElementAt_uchar(*(rs_allocation*)buf4288, *(uchar*)buf4289, *(uint32_t*)buf4290, *(uint32_t*)buf4291, *(uint32_t*)buf4292); - rsSetElementAt_uchar2(*(rs_allocation*)buf4293, *(uchar2*)buf4294, *(uint32_t*)buf4295, *(uint32_t*)buf4296, *(uint32_t*)buf4297); - rsSetElementAt_uchar3(*(rs_allocation*)buf4298, *(uchar3*)buf4299, *(uint32_t*)buf4300, *(uint32_t*)buf4301, *(uint32_t*)buf4302); - rsSetElementAt_uchar4(*(rs_allocation*)buf4303, *(uchar4*)buf4304, *(uint32_t*)buf4305, *(uint32_t*)buf4306, *(uint32_t*)buf4307); - rsSetElementAt_short(*(rs_allocation*)buf4308, *(short*)buf4309, *(uint32_t*)buf4310, *(uint32_t*)buf4311, *(uint32_t*)buf4312); - rsSetElementAt_short2(*(rs_allocation*)buf4313, *(short2*)buf4314, *(uint32_t*)buf4315, *(uint32_t*)buf4316, *(uint32_t*)buf4317); - rsSetElementAt_short3(*(rs_allocation*)buf4318, *(short3*)buf4319, *(uint32_t*)buf4320, *(uint32_t*)buf4321, *(uint32_t*)buf4322); - rsSetElementAt_short4(*(rs_allocation*)buf4323, *(short4*)buf4324, *(uint32_t*)buf4325, *(uint32_t*)buf4326, *(uint32_t*)buf4327); - rsSetElementAt_ushort(*(rs_allocation*)buf4328, *(ushort*)buf4329, *(uint32_t*)buf4330, *(uint32_t*)buf4331, *(uint32_t*)buf4332); - rsSetElementAt_ushort2(*(rs_allocation*)buf4333, *(ushort2*)buf4334, *(uint32_t*)buf4335, *(uint32_t*)buf4336, *(uint32_t*)buf4337); - rsSetElementAt_ushort3(*(rs_allocation*)buf4338, *(ushort3*)buf4339, *(uint32_t*)buf4340, *(uint32_t*)buf4341, *(uint32_t*)buf4342); - rsSetElementAt_ushort4(*(rs_allocation*)buf4343, *(ushort4*)buf4344, *(uint32_t*)buf4345, *(uint32_t*)buf4346, *(uint32_t*)buf4347); - rsSetElementAt_int(*(rs_allocation*)buf4348, *(int*)buf4349, *(uint32_t*)buf4350, *(uint32_t*)buf4351, *(uint32_t*)buf4352); - rsSetElementAt_int2(*(rs_allocation*)buf4353, *(int2*)buf4354, *(uint32_t*)buf4355, *(uint32_t*)buf4356, *(uint32_t*)buf4357); - rsSetElementAt_int3(*(rs_allocation*)buf4358, *(int3*)buf4359, *(uint32_t*)buf4360, *(uint32_t*)buf4361, *(uint32_t*)buf4362); - rsSetElementAt_int4(*(rs_allocation*)buf4363, *(int4*)buf4364, *(uint32_t*)buf4365, *(uint32_t*)buf4366, *(uint32_t*)buf4367); - rsSetElementAt_uint(*(rs_allocation*)buf4368, *(uint*)buf4369, *(uint32_t*)buf4370, *(uint32_t*)buf4371, *(uint32_t*)buf4372); - rsSetElementAt_uint2(*(rs_allocation*)buf4373, *(uint2*)buf4374, *(uint32_t*)buf4375, *(uint32_t*)buf4376, *(uint32_t*)buf4377); - rsSetElementAt_uint3(*(rs_allocation*)buf4378, *(uint3*)buf4379, *(uint32_t*)buf4380, *(uint32_t*)buf4381, *(uint32_t*)buf4382); - rsSetElementAt_uint4(*(rs_allocation*)buf4383, *(uint4*)buf4384, *(uint32_t*)buf4385, *(uint32_t*)buf4386, *(uint32_t*)buf4387); - rsSetElementAt_long(*(rs_allocation*)buf4388, *(long*)buf4389, *(uint32_t*)buf4390, *(uint32_t*)buf4391, *(uint32_t*)buf4392); - rsSetElementAt_long2(*(rs_allocation*)buf4393, *(long2*)buf4394, *(uint32_t*)buf4395, *(uint32_t*)buf4396, *(uint32_t*)buf4397); - rsSetElementAt_long3(*(rs_allocation*)buf4398, *(long3*)buf4399, *(uint32_t*)buf4400, *(uint32_t*)buf4401, *(uint32_t*)buf4402); - rsSetElementAt_long4(*(rs_allocation*)buf4403, *(long4*)buf4404, *(uint32_t*)buf4405, *(uint32_t*)buf4406, *(uint32_t*)buf4407); - rsSetElementAt_ulong(*(rs_allocation*)buf4408, *(ulong*)buf4409, *(uint32_t*)buf4410, *(uint32_t*)buf4411, *(uint32_t*)buf4412); - rsSetElementAt_ulong2(*(rs_allocation*)buf4413, *(ulong2*)buf4414, *(uint32_t*)buf4415, *(uint32_t*)buf4416, *(uint32_t*)buf4417); - rsSetElementAt_ulong3(*(rs_allocation*)buf4418, *(ulong3*)buf4419, *(uint32_t*)buf4420, *(uint32_t*)buf4421, *(uint32_t*)buf4422); - rsSetElementAt_ulong4(*(rs_allocation*)buf4423, *(ulong4*)buf4424, *(uint32_t*)buf4425, *(uint32_t*)buf4426, *(uint32_t*)buf4427); - rsSetObject((rs_element*) buf4428, *(rs_element*)buf4429); - rsSetObject((rs_type*) buf4430, *(rs_type*)buf4431); - rsSetObject((rs_allocation*) buf4432, *(rs_allocation*)buf4433); - rsSetObject((rs_sampler*) buf4434, *(rs_sampler*)buf4435); - rsSetObject((rs_script*) buf4436, *(rs_script*)buf4437); + *(bool*)buf3725 = rsIsSphereInFrustum((float4*) buf3726, (float4*) buf3727, (float4*) buf3728, (float4*) buf3729, (float4*) buf3730, (float4*) buf3731, (float4*) buf3732); + *(rs_tm**)buf3733 = rsLocaltime((rs_tm*) buf3734, (const rs_time_t*) buf3735); + *(float*)buf3736 = rsMatrixGet((const rs_matrix4x4*) buf3737, *(uint32_t*)buf3738, *(uint32_t*)buf3739); + *(float*)buf3740 = rsMatrixGet((const rs_matrix3x3*) buf3741, *(uint32_t*)buf3742, *(uint32_t*)buf3743); + *(float*)buf3744 = rsMatrixGet((const rs_matrix2x2*) buf3745, *(uint32_t*)buf3746, *(uint32_t*)buf3747); + *(bool*)buf3748 = rsMatrixInverse((rs_matrix4x4*) buf3749); + *(bool*)buf3750 = rsMatrixInverseTranspose((rs_matrix4x4*) buf3751); + rsMatrixLoad((rs_matrix4x4*) buf3752, (const float*) buf3753); + rsMatrixLoad((rs_matrix3x3*) buf3754, (const float*) buf3755); + rsMatrixLoad((rs_matrix2x2*) buf3756, (const float*) buf3757); + rsMatrixLoad((rs_matrix4x4*) buf3758, (const rs_matrix4x4*) buf3759); + rsMatrixLoad((rs_matrix3x3*) buf3760, (const rs_matrix3x3*) buf3761); + rsMatrixLoad((rs_matrix2x2*) buf3762, (const rs_matrix2x2*) buf3763); + rsMatrixLoad((rs_matrix4x4*) buf3764, (const rs_matrix3x3*) buf3765); + rsMatrixLoad((rs_matrix4x4*) buf3766, (const rs_matrix2x2*) buf3767); + rsMatrixLoadFrustum((rs_matrix4x4*) buf3768, *(float*)buf3769, *(float*)buf3770, *(float*)buf3771, *(float*)buf3772, *(float*)buf3773, *(float*)buf3774); + rsMatrixLoadIdentity((rs_matrix4x4*) buf3775); + rsMatrixLoadIdentity((rs_matrix3x3*) buf3776); + rsMatrixLoadIdentity((rs_matrix2x2*) buf3777); + rsMatrixLoadMultiply((rs_matrix4x4*) buf3778, (const rs_matrix4x4*) buf3779, (const rs_matrix4x4*) buf3780); + rsMatrixLoadMultiply((rs_matrix3x3*) buf3781, (const rs_matrix3x3*) buf3782, (const rs_matrix3x3*) buf3783); + rsMatrixLoadMultiply((rs_matrix2x2*) buf3784, (const rs_matrix2x2*) buf3785, (const rs_matrix2x2*) buf3786); + rsMatrixLoadOrtho((rs_matrix4x4*) buf3787, *(float*)buf3788, *(float*)buf3789, *(float*)buf3790, *(float*)buf3791, *(float*)buf3792, *(float*)buf3793); + rsMatrixLoadPerspective((rs_matrix4x4*) buf3794, *(float*)buf3795, *(float*)buf3796, *(float*)buf3797, *(float*)buf3798); + rsMatrixLoadRotate((rs_matrix4x4*) buf3799, *(float*)buf3800, *(float*)buf3801, *(float*)buf3802, *(float*)buf3803); + rsMatrixLoadScale((rs_matrix4x4*) buf3804, *(float*)buf3805, *(float*)buf3806, *(float*)buf3807); + rsMatrixLoadTranslate((rs_matrix4x4*) buf3808, *(float*)buf3809, *(float*)buf3810, *(float*)buf3811); + rsMatrixMultiply((rs_matrix4x4*) buf3812, (const rs_matrix4x4*) buf3813); + rsMatrixMultiply((rs_matrix3x3*) buf3814, (const rs_matrix3x3*) buf3815); + rsMatrixMultiply((rs_matrix2x2*) buf3816, (const rs_matrix2x2*) buf3817); + *(float4*)buf3818 = rsMatrixMultiply((const rs_matrix4x4*) buf3819, *(float4*)buf3820); + *(float4*)buf3821 = rsMatrixMultiply((const rs_matrix4x4*) buf3822, *(float3*)buf3823); + *(float4*)buf3824 = rsMatrixMultiply((const rs_matrix4x4*) buf3825, *(float2*)buf3826); + *(float3*)buf3827 = rsMatrixMultiply((const rs_matrix3x3*) buf3828, *(float3*)buf3829); + *(float3*)buf3830 = rsMatrixMultiply((const rs_matrix3x3*) buf3831, *(float2*)buf3832); + *(float2*)buf3833 = rsMatrixMultiply((const rs_matrix2x2*) buf3834, *(float2*)buf3835); + rsMatrixRotate((rs_matrix4x4*) buf3836, *(float*)buf3837, *(float*)buf3838, *(float*)buf3839, *(float*)buf3840); + rsMatrixScale((rs_matrix4x4*) buf3841, *(float*)buf3842, *(float*)buf3843, *(float*)buf3844); + rsMatrixSet((rs_matrix4x4*) buf3845, *(uint32_t*)buf3846, *(uint32_t*)buf3847, *(float*)buf3848); + rsMatrixSet((rs_matrix3x3*) buf3849, *(uint32_t*)buf3850, *(uint32_t*)buf3851, *(float*)buf3852); + rsMatrixSet((rs_matrix2x2*) buf3853, *(uint32_t*)buf3854, *(uint32_t*)buf3855, *(float*)buf3856); + rsMatrixTranslate((rs_matrix4x4*) buf3857, *(float*)buf3858, *(float*)buf3859, *(float*)buf3860); + rsMatrixTranspose((rs_matrix4x4*) buf3861); + rsMatrixTranspose((rs_matrix3x3*) buf3862); + rsMatrixTranspose((rs_matrix2x2*) buf3863); + *(uchar4*)buf3864 = rsPackColorTo8888(*(float*)buf3865, *(float*)buf3866, *(float*)buf3867); + *(uchar4*)buf3868 = rsPackColorTo8888(*(float*)buf3869, *(float*)buf3870, *(float*)buf3871, *(float*)buf3872); + *(uchar4*)buf3873 = rsPackColorTo8888(*(float3*)buf3874); + *(uchar4*)buf3875 = rsPackColorTo8888(*(float4*)buf3876); + rsQuaternionAdd((rs_quaternion*) buf3877, (const rs_quaternion*) buf3878); + rsQuaternionConjugate((rs_quaternion*) buf3879); + *(float*)buf3880 = rsQuaternionDot((const rs_quaternion*) buf3881, (const rs_quaternion*) buf3882); + rsQuaternionGetMatrixUnit((rs_matrix4x4*) buf3883, (const rs_quaternion*) buf3884); + rsQuaternionLoadRotate((rs_quaternion*) buf3885, *(float*)buf3886, *(float*)buf3887, *(float*)buf3888, *(float*)buf3889); + rsQuaternionLoadRotateUnit((rs_quaternion*) buf3890, *(float*)buf3891, *(float*)buf3892, *(float*)buf3893, *(float*)buf3894); + rsQuaternionMultiply((rs_quaternion*) buf3895, *(float*)buf3896); + rsQuaternionMultiply((rs_quaternion*) buf3897, (const rs_quaternion*) buf3898); + rsQuaternionNormalize((rs_quaternion*) buf3899); + rsQuaternionSet((rs_quaternion*) buf3900, *(float*)buf3901, *(float*)buf3902, *(float*)buf3903, *(float*)buf3904); + rsQuaternionSet((rs_quaternion*) buf3905, (const rs_quaternion*) buf3906); + rsQuaternionSlerp((rs_quaternion*) buf3907, (const rs_quaternion*) buf3908, (const rs_quaternion*) buf3909, *(float*)buf3910); + *(int*)buf3911 = rsRand(*(int*)buf3912); + *(int*)buf3913 = rsRand(*(int*)buf3914, *(int*)buf3915); + *(float*)buf3916 = rsRand(*(float*)buf3917); + *(float*)buf3918 = rsRand(*(float*)buf3919, *(float*)buf3920); + *(float4*)buf3921 = rsSample(*(rs_allocation*)buf3922, *(rs_sampler*)buf3923, *(float*)buf3924); + *(float4*)buf3925 = rsSample(*(rs_allocation*)buf3926, *(rs_sampler*)buf3927, *(float*)buf3928, *(float*)buf3929); + *(float4*)buf3930 = rsSample(*(rs_allocation*)buf3931, *(rs_sampler*)buf3932, *(float2*)buf3933); + *(float4*)buf3934 = rsSample(*(rs_allocation*)buf3935, *(rs_sampler*)buf3936, *(float2*)buf3937, *(float*)buf3938); + *(float*)buf3939 = rsSamplerGetAnisotropy(*(rs_sampler*)buf3940); + *(rs_sampler_value*)buf3941 = rsSamplerGetMagnification(*(rs_sampler*)buf3942); + *(rs_sampler_value*)buf3943 = rsSamplerGetMinification(*(rs_sampler*)buf3944); + *(rs_sampler_value*)buf3945 = rsSamplerGetWrapS(*(rs_sampler*)buf3946); + *(rs_sampler_value*)buf3947 = rsSamplerGetWrapT(*(rs_sampler*)buf3948); + *(bool*)buf3949 = rsSendToClient(*(int*)buf3950); + *(bool*)buf3951 = rsSendToClient(*(int*)buf3952, (const void*) buf3953, *(uint*)buf3954); + rsSendToClientBlocking(*(int*)buf3955); + rsSendToClientBlocking(*(int*)buf3956, (const void*) buf3957, *(uint*)buf3958); + rsSetElementAt(*(rs_allocation*)buf3959, (void*) buf3960, *(uint32_t*)buf3961); + rsSetElementAt(*(rs_allocation*)buf3962, (void*) buf3963, *(uint32_t*)buf3964, *(uint32_t*)buf3965); + rsSetElementAt_float(*(rs_allocation*)buf3966, *(float*)buf3967, *(uint32_t*)buf3968); + rsSetElementAt_float2(*(rs_allocation*)buf3969, *(float2*)buf3970, *(uint32_t*)buf3971); + rsSetElementAt_float3(*(rs_allocation*)buf3972, *(float3*)buf3973, *(uint32_t*)buf3974); + rsSetElementAt_float4(*(rs_allocation*)buf3975, *(float4*)buf3976, *(uint32_t*)buf3977); + rsSetElementAt_double(*(rs_allocation*)buf3978, *(double*)buf3979, *(uint32_t*)buf3980); + rsSetElementAt_double2(*(rs_allocation*)buf3981, *(double2*)buf3982, *(uint32_t*)buf3983); + rsSetElementAt_double3(*(rs_allocation*)buf3984, *(double3*)buf3985, *(uint32_t*)buf3986); + rsSetElementAt_double4(*(rs_allocation*)buf3987, *(double4*)buf3988, *(uint32_t*)buf3989); + rsSetElementAt_char(*(rs_allocation*)buf3990, *(char*)buf3991, *(uint32_t*)buf3992); + rsSetElementAt_char2(*(rs_allocation*)buf3993, *(char2*)buf3994, *(uint32_t*)buf3995); + rsSetElementAt_char3(*(rs_allocation*)buf3996, *(char3*)buf3997, *(uint32_t*)buf3998); + rsSetElementAt_char4(*(rs_allocation*)buf3999, *(char4*)buf4000, *(uint32_t*)buf4001); + rsSetElementAt_uchar(*(rs_allocation*)buf4002, *(uchar*)buf4003, *(uint32_t*)buf4004); + rsSetElementAt_uchar2(*(rs_allocation*)buf4005, *(uchar2*)buf4006, *(uint32_t*)buf4007); + rsSetElementAt_uchar3(*(rs_allocation*)buf4008, *(uchar3*)buf4009, *(uint32_t*)buf4010); + rsSetElementAt_uchar4(*(rs_allocation*)buf4011, *(uchar4*)buf4012, *(uint32_t*)buf4013); + rsSetElementAt_short(*(rs_allocation*)buf4014, *(short*)buf4015, *(uint32_t*)buf4016); + rsSetElementAt_short2(*(rs_allocation*)buf4017, *(short2*)buf4018, *(uint32_t*)buf4019); + rsSetElementAt_short3(*(rs_allocation*)buf4020, *(short3*)buf4021, *(uint32_t*)buf4022); + rsSetElementAt_short4(*(rs_allocation*)buf4023, *(short4*)buf4024, *(uint32_t*)buf4025); + rsSetElementAt_ushort(*(rs_allocation*)buf4026, *(ushort*)buf4027, *(uint32_t*)buf4028); + rsSetElementAt_ushort2(*(rs_allocation*)buf4029, *(ushort2*)buf4030, *(uint32_t*)buf4031); + rsSetElementAt_ushort3(*(rs_allocation*)buf4032, *(ushort3*)buf4033, *(uint32_t*)buf4034); + rsSetElementAt_ushort4(*(rs_allocation*)buf4035, *(ushort4*)buf4036, *(uint32_t*)buf4037); + rsSetElementAt_int(*(rs_allocation*)buf4038, *(int*)buf4039, *(uint32_t*)buf4040); + rsSetElementAt_int2(*(rs_allocation*)buf4041, *(int2*)buf4042, *(uint32_t*)buf4043); + rsSetElementAt_int3(*(rs_allocation*)buf4044, *(int3*)buf4045, *(uint32_t*)buf4046); + rsSetElementAt_int4(*(rs_allocation*)buf4047, *(int4*)buf4048, *(uint32_t*)buf4049); + rsSetElementAt_uint(*(rs_allocation*)buf4050, *(uint*)buf4051, *(uint32_t*)buf4052); + rsSetElementAt_uint2(*(rs_allocation*)buf4053, *(uint2*)buf4054, *(uint32_t*)buf4055); + rsSetElementAt_uint3(*(rs_allocation*)buf4056, *(uint3*)buf4057, *(uint32_t*)buf4058); + rsSetElementAt_uint4(*(rs_allocation*)buf4059, *(uint4*)buf4060, *(uint32_t*)buf4061); + rsSetElementAt_long(*(rs_allocation*)buf4062, *(long*)buf4063, *(uint32_t*)buf4064); + rsSetElementAt_long2(*(rs_allocation*)buf4065, *(long2*)buf4066, *(uint32_t*)buf4067); + rsSetElementAt_long3(*(rs_allocation*)buf4068, *(long3*)buf4069, *(uint32_t*)buf4070); + rsSetElementAt_long4(*(rs_allocation*)buf4071, *(long4*)buf4072, *(uint32_t*)buf4073); + rsSetElementAt_ulong(*(rs_allocation*)buf4074, *(ulong*)buf4075, *(uint32_t*)buf4076); + rsSetElementAt_ulong2(*(rs_allocation*)buf4077, *(ulong2*)buf4078, *(uint32_t*)buf4079); + rsSetElementAt_ulong3(*(rs_allocation*)buf4080, *(ulong3*)buf4081, *(uint32_t*)buf4082); + rsSetElementAt_ulong4(*(rs_allocation*)buf4083, *(ulong4*)buf4084, *(uint32_t*)buf4085); + rsSetElementAt_float(*(rs_allocation*)buf4086, *(float*)buf4087, *(uint32_t*)buf4088, *(uint32_t*)buf4089); + rsSetElementAt_float2(*(rs_allocation*)buf4090, *(float2*)buf4091, *(uint32_t*)buf4092, *(uint32_t*)buf4093); + rsSetElementAt_float3(*(rs_allocation*)buf4094, *(float3*)buf4095, *(uint32_t*)buf4096, *(uint32_t*)buf4097); + rsSetElementAt_float4(*(rs_allocation*)buf4098, *(float4*)buf4099, *(uint32_t*)buf4100, *(uint32_t*)buf4101); + rsSetElementAt_double(*(rs_allocation*)buf4102, *(double*)buf4103, *(uint32_t*)buf4104, *(uint32_t*)buf4105); + rsSetElementAt_double2(*(rs_allocation*)buf4106, *(double2*)buf4107, *(uint32_t*)buf4108, *(uint32_t*)buf4109); + rsSetElementAt_double3(*(rs_allocation*)buf4110, *(double3*)buf4111, *(uint32_t*)buf4112, *(uint32_t*)buf4113); + rsSetElementAt_double4(*(rs_allocation*)buf4114, *(double4*)buf4115, *(uint32_t*)buf4116, *(uint32_t*)buf4117); + rsSetElementAt_char(*(rs_allocation*)buf4118, *(char*)buf4119, *(uint32_t*)buf4120, *(uint32_t*)buf4121); + rsSetElementAt_char2(*(rs_allocation*)buf4122, *(char2*)buf4123, *(uint32_t*)buf4124, *(uint32_t*)buf4125); + rsSetElementAt_char3(*(rs_allocation*)buf4126, *(char3*)buf4127, *(uint32_t*)buf4128, *(uint32_t*)buf4129); + rsSetElementAt_char4(*(rs_allocation*)buf4130, *(char4*)buf4131, *(uint32_t*)buf4132, *(uint32_t*)buf4133); + rsSetElementAt_uchar(*(rs_allocation*)buf4134, *(uchar*)buf4135, *(uint32_t*)buf4136, *(uint32_t*)buf4137); + rsSetElementAt_uchar2(*(rs_allocation*)buf4138, *(uchar2*)buf4139, *(uint32_t*)buf4140, *(uint32_t*)buf4141); + rsSetElementAt_uchar3(*(rs_allocation*)buf4142, *(uchar3*)buf4143, *(uint32_t*)buf4144, *(uint32_t*)buf4145); + rsSetElementAt_uchar4(*(rs_allocation*)buf4146, *(uchar4*)buf4147, *(uint32_t*)buf4148, *(uint32_t*)buf4149); + rsSetElementAt_short(*(rs_allocation*)buf4150, *(short*)buf4151, *(uint32_t*)buf4152, *(uint32_t*)buf4153); + rsSetElementAt_short2(*(rs_allocation*)buf4154, *(short2*)buf4155, *(uint32_t*)buf4156, *(uint32_t*)buf4157); + rsSetElementAt_short3(*(rs_allocation*)buf4158, *(short3*)buf4159, *(uint32_t*)buf4160, *(uint32_t*)buf4161); + rsSetElementAt_short4(*(rs_allocation*)buf4162, *(short4*)buf4163, *(uint32_t*)buf4164, *(uint32_t*)buf4165); + rsSetElementAt_ushort(*(rs_allocation*)buf4166, *(ushort*)buf4167, *(uint32_t*)buf4168, *(uint32_t*)buf4169); + rsSetElementAt_ushort2(*(rs_allocation*)buf4170, *(ushort2*)buf4171, *(uint32_t*)buf4172, *(uint32_t*)buf4173); + rsSetElementAt_ushort3(*(rs_allocation*)buf4174, *(ushort3*)buf4175, *(uint32_t*)buf4176, *(uint32_t*)buf4177); + rsSetElementAt_ushort4(*(rs_allocation*)buf4178, *(ushort4*)buf4179, *(uint32_t*)buf4180, *(uint32_t*)buf4181); + rsSetElementAt_int(*(rs_allocation*)buf4182, *(int*)buf4183, *(uint32_t*)buf4184, *(uint32_t*)buf4185); + rsSetElementAt_int2(*(rs_allocation*)buf4186, *(int2*)buf4187, *(uint32_t*)buf4188, *(uint32_t*)buf4189); + rsSetElementAt_int3(*(rs_allocation*)buf4190, *(int3*)buf4191, *(uint32_t*)buf4192, *(uint32_t*)buf4193); + rsSetElementAt_int4(*(rs_allocation*)buf4194, *(int4*)buf4195, *(uint32_t*)buf4196, *(uint32_t*)buf4197); + rsSetElementAt_uint(*(rs_allocation*)buf4198, *(uint*)buf4199, *(uint32_t*)buf4200, *(uint32_t*)buf4201); + rsSetElementAt_uint2(*(rs_allocation*)buf4202, *(uint2*)buf4203, *(uint32_t*)buf4204, *(uint32_t*)buf4205); + rsSetElementAt_uint3(*(rs_allocation*)buf4206, *(uint3*)buf4207, *(uint32_t*)buf4208, *(uint32_t*)buf4209); + rsSetElementAt_uint4(*(rs_allocation*)buf4210, *(uint4*)buf4211, *(uint32_t*)buf4212, *(uint32_t*)buf4213); + rsSetElementAt_long(*(rs_allocation*)buf4214, *(long*)buf4215, *(uint32_t*)buf4216, *(uint32_t*)buf4217); + rsSetElementAt_long2(*(rs_allocation*)buf4218, *(long2*)buf4219, *(uint32_t*)buf4220, *(uint32_t*)buf4221); + rsSetElementAt_long3(*(rs_allocation*)buf4222, *(long3*)buf4223, *(uint32_t*)buf4224, *(uint32_t*)buf4225); + rsSetElementAt_long4(*(rs_allocation*)buf4226, *(long4*)buf4227, *(uint32_t*)buf4228, *(uint32_t*)buf4229); + rsSetElementAt_ulong(*(rs_allocation*)buf4230, *(ulong*)buf4231, *(uint32_t*)buf4232, *(uint32_t*)buf4233); + rsSetElementAt_ulong2(*(rs_allocation*)buf4234, *(ulong2*)buf4235, *(uint32_t*)buf4236, *(uint32_t*)buf4237); + rsSetElementAt_ulong3(*(rs_allocation*)buf4238, *(ulong3*)buf4239, *(uint32_t*)buf4240, *(uint32_t*)buf4241); + rsSetElementAt_ulong4(*(rs_allocation*)buf4242, *(ulong4*)buf4243, *(uint32_t*)buf4244, *(uint32_t*)buf4245); + rsSetElementAt_float(*(rs_allocation*)buf4246, *(float*)buf4247, *(uint32_t*)buf4248, *(uint32_t*)buf4249, *(uint32_t*)buf4250); + rsSetElementAt_float2(*(rs_allocation*)buf4251, *(float2*)buf4252, *(uint32_t*)buf4253, *(uint32_t*)buf4254, *(uint32_t*)buf4255); + rsSetElementAt_float3(*(rs_allocation*)buf4256, *(float3*)buf4257, *(uint32_t*)buf4258, *(uint32_t*)buf4259, *(uint32_t*)buf4260); + rsSetElementAt_float4(*(rs_allocation*)buf4261, *(float4*)buf4262, *(uint32_t*)buf4263, *(uint32_t*)buf4264, *(uint32_t*)buf4265); + rsSetElementAt_double(*(rs_allocation*)buf4266, *(double*)buf4267, *(uint32_t*)buf4268, *(uint32_t*)buf4269, *(uint32_t*)buf4270); + rsSetElementAt_double2(*(rs_allocation*)buf4271, *(double2*)buf4272, *(uint32_t*)buf4273, *(uint32_t*)buf4274, *(uint32_t*)buf4275); + rsSetElementAt_double3(*(rs_allocation*)buf4276, *(double3*)buf4277, *(uint32_t*)buf4278, *(uint32_t*)buf4279, *(uint32_t*)buf4280); + rsSetElementAt_double4(*(rs_allocation*)buf4281, *(double4*)buf4282, *(uint32_t*)buf4283, *(uint32_t*)buf4284, *(uint32_t*)buf4285); + rsSetElementAt_char(*(rs_allocation*)buf4286, *(char*)buf4287, *(uint32_t*)buf4288, *(uint32_t*)buf4289, *(uint32_t*)buf4290); + rsSetElementAt_char2(*(rs_allocation*)buf4291, *(char2*)buf4292, *(uint32_t*)buf4293, *(uint32_t*)buf4294, *(uint32_t*)buf4295); + rsSetElementAt_char3(*(rs_allocation*)buf4296, *(char3*)buf4297, *(uint32_t*)buf4298, *(uint32_t*)buf4299, *(uint32_t*)buf4300); + rsSetElementAt_char4(*(rs_allocation*)buf4301, *(char4*)buf4302, *(uint32_t*)buf4303, *(uint32_t*)buf4304, *(uint32_t*)buf4305); + rsSetElementAt_uchar(*(rs_allocation*)buf4306, *(uchar*)buf4307, *(uint32_t*)buf4308, *(uint32_t*)buf4309, *(uint32_t*)buf4310); + rsSetElementAt_uchar2(*(rs_allocation*)buf4311, *(uchar2*)buf4312, *(uint32_t*)buf4313, *(uint32_t*)buf4314, *(uint32_t*)buf4315); + rsSetElementAt_uchar3(*(rs_allocation*)buf4316, *(uchar3*)buf4317, *(uint32_t*)buf4318, *(uint32_t*)buf4319, *(uint32_t*)buf4320); + rsSetElementAt_uchar4(*(rs_allocation*)buf4321, *(uchar4*)buf4322, *(uint32_t*)buf4323, *(uint32_t*)buf4324, *(uint32_t*)buf4325); + rsSetElementAt_short(*(rs_allocation*)buf4326, *(short*)buf4327, *(uint32_t*)buf4328, *(uint32_t*)buf4329, *(uint32_t*)buf4330); + rsSetElementAt_short2(*(rs_allocation*)buf4331, *(short2*)buf4332, *(uint32_t*)buf4333, *(uint32_t*)buf4334, *(uint32_t*)buf4335); + rsSetElementAt_short3(*(rs_allocation*)buf4336, *(short3*)buf4337, *(uint32_t*)buf4338, *(uint32_t*)buf4339, *(uint32_t*)buf4340); + rsSetElementAt_short4(*(rs_allocation*)buf4341, *(short4*)buf4342, *(uint32_t*)buf4343, *(uint32_t*)buf4344, *(uint32_t*)buf4345); + rsSetElementAt_ushort(*(rs_allocation*)buf4346, *(ushort*)buf4347, *(uint32_t*)buf4348, *(uint32_t*)buf4349, *(uint32_t*)buf4350); + rsSetElementAt_ushort2(*(rs_allocation*)buf4351, *(ushort2*)buf4352, *(uint32_t*)buf4353, *(uint32_t*)buf4354, *(uint32_t*)buf4355); + rsSetElementAt_ushort3(*(rs_allocation*)buf4356, *(ushort3*)buf4357, *(uint32_t*)buf4358, *(uint32_t*)buf4359, *(uint32_t*)buf4360); + rsSetElementAt_ushort4(*(rs_allocation*)buf4361, *(ushort4*)buf4362, *(uint32_t*)buf4363, *(uint32_t*)buf4364, *(uint32_t*)buf4365); + rsSetElementAt_int(*(rs_allocation*)buf4366, *(int*)buf4367, *(uint32_t*)buf4368, *(uint32_t*)buf4369, *(uint32_t*)buf4370); + rsSetElementAt_int2(*(rs_allocation*)buf4371, *(int2*)buf4372, *(uint32_t*)buf4373, *(uint32_t*)buf4374, *(uint32_t*)buf4375); + rsSetElementAt_int3(*(rs_allocation*)buf4376, *(int3*)buf4377, *(uint32_t*)buf4378, *(uint32_t*)buf4379, *(uint32_t*)buf4380); + rsSetElementAt_int4(*(rs_allocation*)buf4381, *(int4*)buf4382, *(uint32_t*)buf4383, *(uint32_t*)buf4384, *(uint32_t*)buf4385); + rsSetElementAt_uint(*(rs_allocation*)buf4386, *(uint*)buf4387, *(uint32_t*)buf4388, *(uint32_t*)buf4389, *(uint32_t*)buf4390); + rsSetElementAt_uint2(*(rs_allocation*)buf4391, *(uint2*)buf4392, *(uint32_t*)buf4393, *(uint32_t*)buf4394, *(uint32_t*)buf4395); + rsSetElementAt_uint3(*(rs_allocation*)buf4396, *(uint3*)buf4397, *(uint32_t*)buf4398, *(uint32_t*)buf4399, *(uint32_t*)buf4400); + rsSetElementAt_uint4(*(rs_allocation*)buf4401, *(uint4*)buf4402, *(uint32_t*)buf4403, *(uint32_t*)buf4404, *(uint32_t*)buf4405); + rsSetElementAt_long(*(rs_allocation*)buf4406, *(long*)buf4407, *(uint32_t*)buf4408, *(uint32_t*)buf4409, *(uint32_t*)buf4410); + rsSetElementAt_long2(*(rs_allocation*)buf4411, *(long2*)buf4412, *(uint32_t*)buf4413, *(uint32_t*)buf4414, *(uint32_t*)buf4415); + rsSetElementAt_long3(*(rs_allocation*)buf4416, *(long3*)buf4417, *(uint32_t*)buf4418, *(uint32_t*)buf4419, *(uint32_t*)buf4420); + rsSetElementAt_long4(*(rs_allocation*)buf4421, *(long4*)buf4422, *(uint32_t*)buf4423, *(uint32_t*)buf4424, *(uint32_t*)buf4425); + rsSetElementAt_ulong(*(rs_allocation*)buf4426, *(ulong*)buf4427, *(uint32_t*)buf4428, *(uint32_t*)buf4429, *(uint32_t*)buf4430); + rsSetElementAt_ulong2(*(rs_allocation*)buf4431, *(ulong2*)buf4432, *(uint32_t*)buf4433, *(uint32_t*)buf4434, *(uint32_t*)buf4435); + rsSetElementAt_ulong3(*(rs_allocation*)buf4436, *(ulong3*)buf4437, *(uint32_t*)buf4438, *(uint32_t*)buf4439, *(uint32_t*)buf4440); + rsSetElementAt_ulong4(*(rs_allocation*)buf4441, *(ulong4*)buf4442, *(uint32_t*)buf4443, *(uint32_t*)buf4444, *(uint32_t*)buf4445); + rsSetObject((rs_element*) buf4446, *(rs_element*)buf4447); + rsSetObject((rs_type*) buf4448, *(rs_type*)buf4449); + rsSetObject((rs_allocation*) buf4450, *(rs_allocation*)buf4451); + rsSetObject((rs_sampler*) buf4452, *(rs_sampler*)buf4453); + rsSetObject((rs_script*) buf4454, *(rs_script*)buf4455); #ifndef __LP64__ - rsSetObject((rs_mesh*) buf4438, *(rs_mesh*)buf4439); - rsSetObject((rs_program_fragment*) buf4440, *(rs_program_fragment*)buf4441); - rsSetObject((rs_program_vertex*) buf4442, *(rs_program_vertex*)buf4443); - rsSetObject((rs_program_raster*) buf4444, *(rs_program_raster*)buf4445); - rsSetObject((rs_program_store*) buf4446, *(rs_program_store*)buf4447); - rsSetObject((rs_font*) buf4448, *(rs_font*)buf4449); + rsSetObject((rs_mesh*) buf4456, *(rs_mesh*)buf4457); + rsSetObject((rs_program_fragment*) buf4458, *(rs_program_fragment*)buf4459); + rsSetObject((rs_program_vertex*) buf4460, *(rs_program_vertex*)buf4461); + rsSetObject((rs_program_raster*) buf4462, *(rs_program_raster*)buf4463); + rsSetObject((rs_program_store*) buf4464, *(rs_program_store*)buf4465); + rsSetObject((rs_font*) buf4466, *(rs_font*)buf4467); #endif - *(rs_time_t*)buf4450 = rsTime((rs_time_t*) buf4451); - *(float4*)buf4452 = rsUnpackColor8888(*(uchar4*)buf4453); - *(int64_t*)buf4454 = rsUptimeMillis(); - *(int64_t*)buf4455 = rsUptimeNanos(); - *(float4*)buf4456 = rsYuvToRGBA_float4(*(uchar*)buf4457, *(uchar*)buf4458, *(uchar*)buf4459); - *(uchar4*)buf4460 = rsYuvToRGBA_uchar4(*(uchar*)buf4461, *(uchar*)buf4462, *(uchar*)buf4463); + *(rs_time_t*)buf4468 = rsTime((rs_time_t*) buf4469); + *(float4*)buf4470 = rsUnpackColor8888(*(uchar4*)buf4471); + *(int64_t*)buf4472 = rsUptimeMillis(); + *(int64_t*)buf4473 = rsUptimeNanos(); + *(float4*)buf4474 = rsYuvToRGBA_float4(*(uchar*)buf4475, *(uchar*)buf4476, *(uchar*)buf4477); + *(uchar4*)buf4478 = rsYuvToRGBA_uchar4(*(uchar*)buf4479, *(uchar*)buf4480, *(uchar*)buf4481); #ifndef __LP64__ - rsgAllocationSyncAll(*(rs_allocation*)buf4464); + rsgAllocationSyncAll(*(rs_allocation*)buf4482); #endif #ifndef __LP64__ - rsgAllocationSyncAll(*(rs_allocation*)buf4465, *(rs_allocation_usage_type*)buf4466); + rsgAllocationSyncAll(*(rs_allocation*)buf4483, *(rs_allocation_usage_type*)buf4484); #endif #ifndef __LP64__ - rsgBindColorTarget(*(rs_allocation*)buf4467, *(uint*)buf4468); + rsgBindColorTarget(*(rs_allocation*)buf4485, *(uint*)buf4486); #endif #ifndef __LP64__ - rsgBindConstant(*(rs_program_fragment*)buf4469, *(uint*)buf4470, *(rs_allocation*)buf4471); + rsgBindConstant(*(rs_program_fragment*)buf4487, *(uint*)buf4488, *(rs_allocation*)buf4489); #endif #ifndef __LP64__ - rsgBindConstant(*(rs_program_vertex*)buf4472, *(uint*)buf4473, *(rs_allocation*)buf4474); + rsgBindConstant(*(rs_program_vertex*)buf4490, *(uint*)buf4491, *(rs_allocation*)buf4492); #endif #ifndef __LP64__ - rsgBindDepthTarget(*(rs_allocation*)buf4475); + rsgBindDepthTarget(*(rs_allocation*)buf4493); #endif #ifndef __LP64__ - rsgBindFont(*(rs_font*)buf4476); + rsgBindFont(*(rs_font*)buf4494); #endif #ifndef __LP64__ - rsgBindProgramFragment(*(rs_program_fragment*)buf4477); + rsgBindProgramFragment(*(rs_program_fragment*)buf4495); #endif #ifndef __LP64__ - rsgBindProgramRaster(*(rs_program_raster*)buf4478); + rsgBindProgramRaster(*(rs_program_raster*)buf4496); #endif #ifndef __LP64__ - rsgBindProgramStore(*(rs_program_store*)buf4479); + rsgBindProgramStore(*(rs_program_store*)buf4497); #endif #ifndef __LP64__ - rsgBindProgramVertex(*(rs_program_vertex*)buf4480); + rsgBindProgramVertex(*(rs_program_vertex*)buf4498); #endif #ifndef __LP64__ - rsgBindSampler(*(rs_program_fragment*)buf4481, *(uint*)buf4482, *(rs_sampler*)buf4483); + rsgBindSampler(*(rs_program_fragment*)buf4499, *(uint*)buf4500, *(rs_sampler*)buf4501); #endif #ifndef __LP64__ - rsgBindTexture(*(rs_program_fragment*)buf4484, *(uint*)buf4485, *(rs_allocation*)buf4486); + rsgBindTexture(*(rs_program_fragment*)buf4502, *(uint*)buf4503, *(rs_allocation*)buf4504); #endif #ifndef __LP64__ rsgClearAllRenderTargets(); #endif #ifndef __LP64__ - rsgClearColor(*(float*)buf4487, *(float*)buf4488, *(float*)buf4489, *(float*)buf4490); + rsgClearColor(*(float*)buf4505, *(float*)buf4506, *(float*)buf4507, *(float*)buf4508); #endif #ifndef __LP64__ - rsgClearColorTarget(*(uint*)buf4491); + rsgClearColorTarget(*(uint*)buf4509); #endif #ifndef __LP64__ - rsgClearDepth(*(float*)buf4492); + rsgClearDepth(*(float*)buf4510); #endif #ifndef __LP64__ rsgClearDepthTarget(); #endif #ifndef __LP64__ - rsgDrawMesh(*(rs_mesh*)buf4493); + rsgDrawMesh(*(rs_mesh*)buf4511); #endif #ifndef __LP64__ - rsgDrawMesh(*(rs_mesh*)buf4494, *(uint*)buf4495); + rsgDrawMesh(*(rs_mesh*)buf4512, *(uint*)buf4513); #endif #ifndef __LP64__ - rsgDrawMesh(*(rs_mesh*)buf4496, *(uint*)buf4497, *(uint*)buf4498, *(uint*)buf4499); + rsgDrawMesh(*(rs_mesh*)buf4514, *(uint*)buf4515, *(uint*)buf4516, *(uint*)buf4517); #endif #ifndef __LP64__ - rsgDrawQuad(*(float*)buf4500, *(float*)buf4501, *(float*)buf4502, *(float*)buf4503, *(float*)buf4504, *(float*)buf4505, *(float*)buf4506, *(float*)buf4507, *(float*)buf4508, *(float*)buf4509, *(float*)buf4510, *(float*)buf4511); + rsgDrawQuad(*(float*)buf4518, *(float*)buf4519, *(float*)buf4520, *(float*)buf4521, *(float*)buf4522, *(float*)buf4523, *(float*)buf4524, *(float*)buf4525, *(float*)buf4526, *(float*)buf4527, *(float*)buf4528, *(float*)buf4529); #endif #ifndef __LP64__ - rsgDrawQuadTexCoords(*(float*)buf4512, *(float*)buf4513, *(float*)buf4514, *(float*)buf4515, *(float*)buf4516, *(float*)buf4517, *(float*)buf4518, *(float*)buf4519, *(float*)buf4520, *(float*)buf4521, *(float*)buf4522, *(float*)buf4523, *(float*)buf4524, *(float*)buf4525, *(float*)buf4526, *(float*)buf4527, *(float*)buf4528, *(float*)buf4529, *(float*)buf4530, *(float*)buf4531); + rsgDrawQuadTexCoords(*(float*)buf4530, *(float*)buf4531, *(float*)buf4532, *(float*)buf4533, *(float*)buf4534, *(float*)buf4535, *(float*)buf4536, *(float*)buf4537, *(float*)buf4538, *(float*)buf4539, *(float*)buf4540, *(float*)buf4541, *(float*)buf4542, *(float*)buf4543, *(float*)buf4544, *(float*)buf4545, *(float*)buf4546, *(float*)buf4547, *(float*)buf4548, *(float*)buf4549); #endif #ifndef __LP64__ - rsgDrawRect(*(float*)buf4532, *(float*)buf4533, *(float*)buf4534, *(float*)buf4535, *(float*)buf4536); + rsgDrawRect(*(float*)buf4550, *(float*)buf4551, *(float*)buf4552, *(float*)buf4553, *(float*)buf4554); #endif #ifndef __LP64__ - rsgDrawSpriteScreenspace(*(float*)buf4537, *(float*)buf4538, *(float*)buf4539, *(float*)buf4540, *(float*)buf4541); + rsgDrawSpriteScreenspace(*(float*)buf4555, *(float*)buf4556, *(float*)buf4557, *(float*)buf4558, *(float*)buf4559); #endif #ifndef __LP64__ - rsgDrawText((const char*) buf4542, *(int*)buf4543, *(int*)buf4544); + rsgDrawText((const char*) buf4560, *(int*)buf4561, *(int*)buf4562); #endif #ifndef __LP64__ - rsgDrawText(*(rs_allocation*)buf4545, *(int*)buf4546, *(int*)buf4547); + rsgDrawText(*(rs_allocation*)buf4563, *(int*)buf4564, *(int*)buf4565); #endif #ifndef __LP64__ - *(uint*)buf4548 = rsgFinish(); + *(uint*)buf4566 = rsgFinish(); #endif #ifndef __LP64__ - rsgFontColor(*(float*)buf4549, *(float*)buf4550, *(float*)buf4551, *(float*)buf4552); + rsgFontColor(*(float*)buf4567, *(float*)buf4568, *(float*)buf4569, *(float*)buf4570); #endif #ifndef __LP64__ - *(uint*)buf4553 = rsgGetHeight(); + *(uint*)buf4571 = rsgGetHeight(); #endif #ifndef __LP64__ - *(uint*)buf4554 = rsgGetWidth(); + *(uint*)buf4572 = rsgGetWidth(); #endif #ifndef __LP64__ - rsgMeasureText((const char*) buf4555, (int*) buf4556, (int*) buf4557, (int*) buf4558, (int*) buf4559); + rsgMeasureText((const char*) buf4573, (int*) buf4574, (int*) buf4575, (int*) buf4576, (int*) buf4577); #endif #ifndef __LP64__ - rsgMeasureText(*(rs_allocation*)buf4560, (int*) buf4561, (int*) buf4562, (int*) buf4563, (int*) buf4564); + rsgMeasureText(*(rs_allocation*)buf4578, (int*) buf4579, (int*) buf4580, (int*) buf4581, (int*) buf4582); #endif #ifndef __LP64__ - rsgMeshComputeBoundingBox(*(rs_mesh*)buf4565, (float*) buf4566, (float*) buf4567, (float*) buf4568, (float*) buf4569, (float*) buf4570, (float*) buf4571); + rsgMeshComputeBoundingBox(*(rs_mesh*)buf4583, (float*) buf4584, (float*) buf4585, (float*) buf4586, (float*) buf4587, (float*) buf4588, (float*) buf4589); #endif #ifndef __LP64__ - rsgMeshComputeBoundingBox(*(rs_mesh*)buf4572, (float3*) buf4573, (float3*) buf4574); + rsgMeshComputeBoundingBox(*(rs_mesh*)buf4590, (float3*) buf4591, (float3*) buf4592); #endif #ifndef __LP64__ - *(rs_allocation*)buf4575 = rsgMeshGetIndexAllocation(*(rs_mesh*)buf4576, *(uint32_t*)buf4577); + *(rs_allocation*)buf4593 = rsgMeshGetIndexAllocation(*(rs_mesh*)buf4594, *(uint32_t*)buf4595); #endif #ifndef __LP64__ - *(rs_primitive*)buf4578 = rsgMeshGetPrimitive(*(rs_mesh*)buf4579, *(uint32_t*)buf4580); + *(rs_primitive*)buf4596 = rsgMeshGetPrimitive(*(rs_mesh*)buf4597, *(uint32_t*)buf4598); #endif #ifndef __LP64__ - *(uint32_t*)buf4581 = rsgMeshGetPrimitiveCount(*(rs_mesh*)buf4582); + *(uint32_t*)buf4599 = rsgMeshGetPrimitiveCount(*(rs_mesh*)buf4600); #endif #ifndef __LP64__ - *(rs_allocation*)buf4583 = rsgMeshGetVertexAllocation(*(rs_mesh*)buf4584, *(uint32_t*)buf4585); + *(rs_allocation*)buf4601 = rsgMeshGetVertexAllocation(*(rs_mesh*)buf4602, *(uint32_t*)buf4603); #endif #ifndef __LP64__ - *(uint32_t*)buf4586 = rsgMeshGetVertexAllocationCount(*(rs_mesh*)buf4587); + *(uint32_t*)buf4604 = rsgMeshGetVertexAllocationCount(*(rs_mesh*)buf4605); #endif #ifndef __LP64__ - rsgProgramFragmentConstantColor(*(rs_program_fragment*)buf4588, *(float*)buf4589, *(float*)buf4590, *(float*)buf4591, *(float*)buf4592); + rsgProgramFragmentConstantColor(*(rs_program_fragment*)buf4606, *(float*)buf4607, *(float*)buf4608, *(float*)buf4609, *(float*)buf4610); #endif #ifndef __LP64__ - *(rs_cull_mode*)buf4593 = rsgProgramRasterGetCullMode(*(rs_program_raster*)buf4594); + *(rs_cull_mode*)buf4611 = rsgProgramRasterGetCullMode(*(rs_program_raster*)buf4612); #endif #ifndef __LP64__ - *(bool*)buf4595 = rsgProgramRasterIsPointSpriteEnabled(*(rs_program_raster*)buf4596); + *(bool*)buf4613 = rsgProgramRasterIsPointSpriteEnabled(*(rs_program_raster*)buf4614); #endif #ifndef __LP64__ - *(rs_blend_dst_func*)buf4597 = rsgProgramStoreGetBlendDstFunc(*(rs_program_store*)buf4598); + *(rs_blend_dst_func*)buf4615 = rsgProgramStoreGetBlendDstFunc(*(rs_program_store*)buf4616); #endif #ifndef __LP64__ - *(rs_blend_src_func*)buf4599 = rsgProgramStoreGetBlendSrcFunc(*(rs_program_store*)buf4600); + *(rs_blend_src_func*)buf4617 = rsgProgramStoreGetBlendSrcFunc(*(rs_program_store*)buf4618); #endif #ifndef __LP64__ - *(rs_depth_func*)buf4601 = rsgProgramStoreGetDepthFunc(*(rs_program_store*)buf4602); + *(rs_depth_func*)buf4619 = rsgProgramStoreGetDepthFunc(*(rs_program_store*)buf4620); #endif #ifndef __LP64__ - *(bool*)buf4603 = rsgProgramStoreIsColorMaskAlphaEnabled(*(rs_program_store*)buf4604); + *(bool*)buf4621 = rsgProgramStoreIsColorMaskAlphaEnabled(*(rs_program_store*)buf4622); #endif #ifndef __LP64__ - *(bool*)buf4605 = rsgProgramStoreIsColorMaskBlueEnabled(*(rs_program_store*)buf4606); + *(bool*)buf4623 = rsgProgramStoreIsColorMaskBlueEnabled(*(rs_program_store*)buf4624); #endif #ifndef __LP64__ - *(bool*)buf4607 = rsgProgramStoreIsColorMaskGreenEnabled(*(rs_program_store*)buf4608); + *(bool*)buf4625 = rsgProgramStoreIsColorMaskGreenEnabled(*(rs_program_store*)buf4626); #endif #ifndef __LP64__ - *(bool*)buf4609 = rsgProgramStoreIsColorMaskRedEnabled(*(rs_program_store*)buf4610); + *(bool*)buf4627 = rsgProgramStoreIsColorMaskRedEnabled(*(rs_program_store*)buf4628); #endif #ifndef __LP64__ - *(bool*)buf4611 = rsgProgramStoreIsDepthMaskEnabled(*(rs_program_store*)buf4612); + *(bool*)buf4629 = rsgProgramStoreIsDepthMaskEnabled(*(rs_program_store*)buf4630); #endif #ifndef __LP64__ - *(bool*)buf4613 = rsgProgramStoreIsDitherEnabled(*(rs_program_store*)buf4614); + *(bool*)buf4631 = rsgProgramStoreIsDitherEnabled(*(rs_program_store*)buf4632); #endif #ifndef __LP64__ - rsgProgramVertexGetProjectionMatrix((rs_matrix4x4*) buf4615); + rsgProgramVertexGetProjectionMatrix((rs_matrix4x4*) buf4633); #endif #ifndef __LP64__ - rsgProgramVertexLoadModelMatrix((const rs_matrix4x4*) buf4616); + rsgProgramVertexLoadModelMatrix((const rs_matrix4x4*) buf4634); #endif #ifndef __LP64__ - rsgProgramVertexLoadProjectionMatrix((const rs_matrix4x4*) buf4617); + rsgProgramVertexLoadProjectionMatrix((const rs_matrix4x4*) buf4635); #endif #ifndef __LP64__ - rsgProgramVertexLoadTextureMatrix((const rs_matrix4x4*) buf4618); + rsgProgramVertexLoadTextureMatrix((const rs_matrix4x4*) buf4636); #endif - *(float*)buf4619 = rsqrt(*(float*)buf4620); - *(float2*)buf4621 = rsqrt(*(float2*)buf4622); - *(float3*)buf4623 = rsqrt(*(float3*)buf4624); - *(float4*)buf4625 = rsqrt(*(float4*)buf4626); - *(float*)buf4627 = sign(*(float*)buf4628); - *(float2*)buf4629 = sign(*(float2*)buf4630); - *(float3*)buf4631 = sign(*(float3*)buf4632); - *(float4*)buf4633 = sign(*(float4*)buf4634); - *(float*)buf4635 = sin(*(float*)buf4636); - *(float2*)buf4637 = sin(*(float2*)buf4638); - *(float3*)buf4639 = sin(*(float3*)buf4640); - *(float4*)buf4641 = sin(*(float4*)buf4642); - *(float*)buf4643 = sincos(*(float*)buf4644, (float*) buf4645); - *(float2*)buf4646 = sincos(*(float2*)buf4647, (float2*) buf4648); - *(float3*)buf4649 = sincos(*(float3*)buf4650, (float3*) buf4651); - *(float4*)buf4652 = sincos(*(float4*)buf4653, (float4*) buf4654); - *(float*)buf4655 = sinh(*(float*)buf4656); - *(float2*)buf4657 = sinh(*(float2*)buf4658); - *(float3*)buf4659 = sinh(*(float3*)buf4660); - *(float4*)buf4661 = sinh(*(float4*)buf4662); - *(float*)buf4663 = sinpi(*(float*)buf4664); - *(float2*)buf4665 = sinpi(*(float2*)buf4666); - *(float3*)buf4667 = sinpi(*(float3*)buf4668); - *(float4*)buf4669 = sinpi(*(float4*)buf4670); - *(float*)buf4671 = sqrt(*(float*)buf4672); - *(float2*)buf4673 = sqrt(*(float2*)buf4674); - *(float3*)buf4675 = sqrt(*(float3*)buf4676); - *(float4*)buf4677 = sqrt(*(float4*)buf4678); - *(float*)buf4679 = step(*(float*)buf4680, *(float*)buf4681); - *(float2*)buf4682 = step(*(float2*)buf4683, *(float2*)buf4684); - *(float3*)buf4685 = step(*(float3*)buf4686, *(float3*)buf4687); - *(float4*)buf4688 = step(*(float4*)buf4689, *(float4*)buf4690); - *(float2*)buf4691 = step(*(float2*)buf4692, *(float*)buf4693); - *(float3*)buf4694 = step(*(float3*)buf4695, *(float*)buf4696); - *(float4*)buf4697 = step(*(float4*)buf4698, *(float*)buf4699); - *(float2*)buf4700 = step(*(float*)buf4701, *(float2*)buf4702); - *(float3*)buf4703 = step(*(float*)buf4704, *(float3*)buf4705); - *(float4*)buf4706 = step(*(float*)buf4707, *(float4*)buf4708); - *(float*)buf4709 = tan(*(float*)buf4710); - *(float2*)buf4711 = tan(*(float2*)buf4712); - *(float3*)buf4713 = tan(*(float3*)buf4714); - *(float4*)buf4715 = tan(*(float4*)buf4716); - *(float*)buf4717 = tanh(*(float*)buf4718); - *(float2*)buf4719 = tanh(*(float2*)buf4720); - *(float3*)buf4721 = tanh(*(float3*)buf4722); - *(float4*)buf4723 = tanh(*(float4*)buf4724); - *(float*)buf4725 = tanpi(*(float*)buf4726); - *(float2*)buf4727 = tanpi(*(float2*)buf4728); - *(float3*)buf4729 = tanpi(*(float3*)buf4730); - *(float4*)buf4731 = tanpi(*(float4*)buf4732); - *(float*)buf4733 = tgamma(*(float*)buf4734); - *(float2*)buf4735 = tgamma(*(float2*)buf4736); - *(float3*)buf4737 = tgamma(*(float3*)buf4738); - *(float4*)buf4739 = tgamma(*(float4*)buf4740); - *(float*)buf4741 = trunc(*(float*)buf4742); - *(float2*)buf4743 = trunc(*(float2*)buf4744); - *(float3*)buf4745 = trunc(*(float3*)buf4746); - *(float4*)buf4747 = trunc(*(float4*)buf4748); + *(float*)buf4637 = rsqrt(*(float*)buf4638); + *(float2*)buf4639 = rsqrt(*(float2*)buf4640); + *(float3*)buf4641 = rsqrt(*(float3*)buf4642); + *(float4*)buf4643 = rsqrt(*(float4*)buf4644); + *(float*)buf4645 = sign(*(float*)buf4646); + *(float2*)buf4647 = sign(*(float2*)buf4648); + *(float3*)buf4649 = sign(*(float3*)buf4650); + *(float4*)buf4651 = sign(*(float4*)buf4652); + *(float*)buf4653 = sin(*(float*)buf4654); + *(float2*)buf4655 = sin(*(float2*)buf4656); + *(float3*)buf4657 = sin(*(float3*)buf4658); + *(float4*)buf4659 = sin(*(float4*)buf4660); + *(float*)buf4661 = sincos(*(float*)buf4662, (float*) buf4663); + *(float2*)buf4664 = sincos(*(float2*)buf4665, (float2*) buf4666); + *(float3*)buf4667 = sincos(*(float3*)buf4668, (float3*) buf4669); + *(float4*)buf4670 = sincos(*(float4*)buf4671, (float4*) buf4672); + *(float*)buf4673 = sinh(*(float*)buf4674); + *(float2*)buf4675 = sinh(*(float2*)buf4676); + *(float3*)buf4677 = sinh(*(float3*)buf4678); + *(float4*)buf4679 = sinh(*(float4*)buf4680); + *(float*)buf4681 = sinpi(*(float*)buf4682); + *(float2*)buf4683 = sinpi(*(float2*)buf4684); + *(float3*)buf4685 = sinpi(*(float3*)buf4686); + *(float4*)buf4687 = sinpi(*(float4*)buf4688); + *(float*)buf4689 = sqrt(*(float*)buf4690); + *(float2*)buf4691 = sqrt(*(float2*)buf4692); + *(float3*)buf4693 = sqrt(*(float3*)buf4694); + *(float4*)buf4695 = sqrt(*(float4*)buf4696); + *(float*)buf4697 = step(*(float*)buf4698, *(float*)buf4699); + *(float2*)buf4700 = step(*(float2*)buf4701, *(float2*)buf4702); + *(float3*)buf4703 = step(*(float3*)buf4704, *(float3*)buf4705); + *(float4*)buf4706 = step(*(float4*)buf4707, *(float4*)buf4708); + *(float2*)buf4709 = step(*(float2*)buf4710, *(float*)buf4711); + *(float3*)buf4712 = step(*(float3*)buf4713, *(float*)buf4714); + *(float4*)buf4715 = step(*(float4*)buf4716, *(float*)buf4717); + *(float2*)buf4718 = step(*(float*)buf4719, *(float2*)buf4720); + *(float3*)buf4721 = step(*(float*)buf4722, *(float3*)buf4723); + *(float4*)buf4724 = step(*(float*)buf4725, *(float4*)buf4726); + *(float*)buf4727 = tan(*(float*)buf4728); + *(float2*)buf4729 = tan(*(float2*)buf4730); + *(float3*)buf4731 = tan(*(float3*)buf4732); + *(float4*)buf4733 = tan(*(float4*)buf4734); + *(float*)buf4735 = tanh(*(float*)buf4736); + *(float2*)buf4737 = tanh(*(float2*)buf4738); + *(float3*)buf4739 = tanh(*(float3*)buf4740); + *(float4*)buf4741 = tanh(*(float4*)buf4742); + *(float*)buf4743 = tanpi(*(float*)buf4744); + *(float2*)buf4745 = tanpi(*(float2*)buf4746); + *(float3*)buf4747 = tanpi(*(float3*)buf4748); + *(float4*)buf4749 = tanpi(*(float4*)buf4750); + *(float*)buf4751 = tgamma(*(float*)buf4752); + *(float2*)buf4753 = tgamma(*(float2*)buf4754); + *(float3*)buf4755 = tgamma(*(float3*)buf4756); + *(float4*)buf4757 = tgamma(*(float4*)buf4758); + *(float*)buf4759 = trunc(*(float*)buf4760); + *(float2*)buf4761 = trunc(*(float2*)buf4762); + *(float3*)buf4763 = trunc(*(float3*)buf4764); + *(float4*)buf4765 = trunc(*(float4*)buf4766); } |