Attachment 373181 Details for Bug 198186 – WIP

[patch] WIP

bug-198186-20190629195208.patch (text/plain), 2.76 MB, created by Myles C. Maxfield on 2019-06-29 19:52:26 PDT

(hide)

Description:

Filename:

MIME Type:

Creator: Myles C. Maxfield

Created: 2019-06-29 19:52:26 PDT

Size: 2.76 MB

patch

obsolete

>Subversion Revision: 246947
>diff --git a/Source/WebCore/ChangeLog b/Source/WebCore/ChangeLog
>index 5e5bacdb18fb9788f8cfb0c2a6a97f5efd1a8c54..64bb268cdb0bd05a07bbce3d97c54453bc5f6a61 100644
>--- a/Source/WebCore/ChangeLog
>+++ b/Source/WebCore/ChangeLog
>@@ -1,3 +1,34 @@
>+2019-06-25  Myles C. Maxfield  <mmaxfield@apple.com>
>+
>+        [WHLSL] Standard library is too big to directly include in WebCore
>+        https://bugs.webkit.org/show_bug.cgi?id=198186
>+
>+        Reviewed by NOBODY (OOPS!).
>+
>+        No new tests (OOPS!).
>+
>+        * DerivedSources.make:
>+        * Modules/webgpu/WHLSL/AST/WHLSLCallExpression.h:
>+        (WebCore::WHLSL::AST::CallExpression::setOverloads):
>+        (WebCore::WHLSL::AST::CallExpression::function):
>+        (WebCore::WHLSL::AST::CallExpression::setFunction):
>+        * Modules/webgpu/WHLSL/Cocoa/WHLSLStandardLibraryUtilities.cpp: Added.
>+        (WebCore::WHLSL::decompressStandardLibrary):
>+        (WebCore::WHLSL::decompressAndDecodeStandardLibrary):
>+        (WebCore::WHLSL::cachedStandardLibrary):
>+        * Modules/webgpu/WHLSL/Metal/WHLSLFunctionWriter.cpp:
>+        (WebCore::WHLSL::Metal::FunctionDefinitionWriter::visit):
>+        (WebCore::WHLSL::Metal::metalFunctions):
>+        * Modules/webgpu/WHLSL/WHLSLChecker.cpp:
>+        (WebCore::WHLSL::Checker::visit):
>+        * Modules/webgpu/WHLSL/WHLSLFunctionStageChecker.cpp:
>+        * Modules/webgpu/WHLSL/WHLSLPrepare.cpp:
>+        (WebCore::WHLSL::prepareShared):
>+        * Modules/webgpu/WHLSL/WHLSLRecursionChecker.cpp:
>+        * Modules/webgpu/WHLSL/WHLSLStandardLibraryUtilities.h: Copied from Source/WebCore/Modules/webgpu/WHLSL/WHLSLRecursionChecker.cpp.
>+        * SourcesCocoa.txt:
>+        * WebCore.xcodeproj/project.pbxproj:
>+
> 2019-06-28  Zalan Bujtas  <zalan@apple.com>
> 
>         [Text autosizing][iPadOS] bing.com is hard to read even with boosted text because of the line height
>diff --git a/Source/WebCore/DerivedSources-input.xcfilelist b/Source/WebCore/DerivedSources-input.xcfilelist
>index 57c537c3ec9d428227e8de5e88163569b7607bce..c69d3dd417bbd924f9522c14748ce81e27d013d1 100644
>--- a/Source/WebCore/DerivedSources-input.xcfilelist
>+++ b/Source/WebCore/DerivedSources-input.xcfilelist
>@@ -345,6 +345,7 @@ $(PROJECT_DIR)/Modules/webgpu/GPUVertexAttributeDescriptor.idl
> $(PROJECT_DIR)/Modules/webgpu/GPUVertexBufferDescriptor.idl
> $(PROJECT_DIR)/Modules/webgpu/GPUVertexInputDescriptor.idl
> $(PROJECT_DIR)/Modules/webgpu/NavigatorGPU.idl
>+$(PROJECT_DIR)/Modules/webgpu/WHLSL/WHLSLBuildStandardLibraryFunctionMap.py
> $(PROJECT_DIR)/Modules/webgpu/WHLSL/WHLSLStandardLibrary.txt
> $(PROJECT_DIR)/Modules/webgpu/WebGPU.idl
> $(PROJECT_DIR)/Modules/webgpu/WebGPUAdapter.idl
>diff --git a/Source/WebCore/DerivedSources-output.xcfilelist b/Source/WebCore/DerivedSources-output.xcfilelist
>index d0e0a8f27f83e68946f8eb043163c6609c7d7422..37c3c8b1ba52b2630f1f053f2b052535cdc50cb7 100644
>--- a/Source/WebCore/DerivedSources-output.xcfilelist
>+++ b/Source/WebCore/DerivedSources-output.xcfilelist
>@@ -2095,6 +2095,7 @@ $(BUILT_PRODUCTS_DIR)/DerivedSources/WebCore/UserAgentScripts.h
> $(BUILT_PRODUCTS_DIR)/DerivedSources/WebCore/UserAgentScriptsData.cpp
> $(BUILT_PRODUCTS_DIR)/DerivedSources/WebCore/UserAgentStyleSheets.h
> $(BUILT_PRODUCTS_DIR)/DerivedSources/WebCore/WHLSLStandardLibrary.h
>+$(BUILT_PRODUCTS_DIR)/DerivedSources/WebCore/WHLSLStandardLibraryFunctionMap.cpp
> $(BUILT_PRODUCTS_DIR)/DerivedSources/WebCore/WebCoreJSBuiltinInternals.cpp
> $(BUILT_PRODUCTS_DIR)/DerivedSources/WebCore/WebCoreJSBuiltinInternals.h
> $(BUILT_PRODUCTS_DIR)/DerivedSources/WebCore/WebCoreJSBuiltins.cpp
>diff --git a/Source/WebCore/DerivedSources.make b/Source/WebCore/DerivedSources.make
>index d88aed458f0ef6eae31478e1e8b8071fceed91df..7eeb427c27d18ac4cb87c9fb2fef03ee06bf666d 100644
>--- a/Source/WebCore/DerivedSources.make
>+++ b/Source/WebCore/DerivedSources.make
>@@ -1636,10 +1636,13 @@ $(GENERATE_SETTINGS_PATTERNS) : $(WebCore)/Scripts/GenerateSettings.rb $(GENERAT
> 
> # WHLSL Standard Library
> 
>-all : WHLSLStandardLibrary.h
>+all : WHLSLStandardLibrary.h WHLSLStandardLibraryFunctionMap.cpp
> 
> WHLSLStandardLibrary.h : $(JavaScriptCore_SCRIPTS_DIR)/xxd.pl $(WebCore)/Modules/webgpu/WHLSL/WHLSLStandardLibrary.txt
>-	$(PERL) $< WHLSLStandardLibrary $(WebCore)/Modules/webgpu/WHLSL/WHLSLStandardLibrary.txt $@
>+	bash -c "$(PERL) $< WHLSLStandardLibrary <(gzip -cn $(WebCore)/Modules/webgpu/WHLSL/WHLSLStandardLibrary.txt) $@"
>+
>+WHLSLStandardLibraryFunctionMap.cpp : $(WebCore)/Modules/webgpu/WHLSL/WHLSLBuildStandardLibraryFunctionMap.py $(WebCore)/Modules/webgpu/WHLSL/WHLSLStandardLibrary.txt
>+	$(PYTHON) $< $(WebCore)/Modules/webgpu/WHLSL/WHLSLStandardLibrary.txt $@
> 
> # --------
> 
>diff --git a/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLCallExpression.h b/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLCallExpression.h
>index 1a0d0274e4d3c72ed2f6c0c8ab1de194d5fe544c..17b94cdca071ce9a042970df7986399494855755 100644
>--- a/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLCallExpression.h
>+++ b/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLCallExpression.h
>@@ -71,15 +71,19 @@ public:
>     Optional<Vector<std::reference_wrapper<FunctionDeclaration>, 1>>& overloads() { return m_overloads; }
>     void setOverloads(const Vector<std::reference_wrapper<FunctionDeclaration>, 1>& overloads)
>     {
>-        assert(!hasOverloads());
>+        ASSERT(!hasOverloads());
>         m_overloads = overloads;
>     }
> 
>-    FunctionDeclaration* function() { return m_function; }
>+    FunctionDeclaration& function()
>+    {
>+        ASSERT(m_function);
>+        return *m_function;
>+    }
> 
>     void setFunction(FunctionDeclaration& functionDeclaration)
>     {
>-        assert(!m_function);
>+        ASSERT(!m_function);
>         m_function = &functionDeclaration;
>     }
> 
>diff --git a/Source/WebCore/Modules/webgpu/WHLSL/Cocoa/WHLSLStandardLibraryUtilities.cpp b/Source/WebCore/Modules/webgpu/WHLSL/Cocoa/WHLSLStandardLibraryUtilities.cpp
>new file mode 100644
>index 0000000000000000000000000000000000000000..39858ba40dbd4956257a324bf7a76a31b403dc34
>--- /dev/null
>+++ b/Source/WebCore/Modules/webgpu/WHLSL/Cocoa/WHLSLStandardLibraryUtilities.cpp
>@@ -0,0 +1,145 @@
>+/*
>+ * Copyright (C) 2019 Apple Inc. All rights reserved.
>+ *
>+ * Redistribution and use in source and binary forms, with or without
>+ * modification, are permitted provided that the following conditions
>+ * are met:
>+ * 1. Redistributions of source code must retain the above copyright
>+ *    notice, this list of conditions and the following disclaimer.
>+ * 2. Redistributions in binary form must reproduce the above copyright
>+ *    notice, this list of conditions and the following disclaimer in the
>+ *    documentation and/or other materials provided with the distribution.
>+ *
>+ * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''
>+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
>+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
>+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
>+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
>+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
>+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
>+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
>+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
>+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
>+ * THE POSSIBILITY OF SUCH DAMAGE.
>+ */
>+
>+#include "config.h"
>+#include "WHLSLStandardLibraryUtilities.h"
>+
>+#if ENABLE(WEBGPU)
>+
>+#include "WHLSLCallExpression.h"
>+#include "WHLSLParser.h"
>+#include "WHLSLStandardLibrary.h"
>+#include "WHLSLStandardLibraryFunctionMap.h"
>+#include "WHLSLVisitor.h"
>+#include <compression.h>
>+#include <wtf/HashSet.h>
>+#include <wtf/NeverDestroyed.h>
>+
>+namespace WebCore {
>+
>+namespace WHLSL {
>+
>+static Vector<LChar> decompressStandardLibrary()
>+{
>+    Vector<LChar> result;
>+
>+    // Parse the gzip header.
>+    auto checks = [&]() {
>+        return sizeof(WHLSLStandardLibrary) >= 10 && WHLSLStandardLibrary[0] == 0x1f && WHLSLStandardLibrary[1] == 0x8b && WHLSLStandardLibrary[2] == 0x8 && WHLSLStandardLibrary[3] == 0x0;
>+    };
>+    ASSERT(checks());
>+    if (!checks())
>+        return { };
>+
>+    constexpr auto ignoredByteCount = 10;
>+
>+    compression_stream stream;
>+    auto status = compression_stream_init(&stream, COMPRESSION_STREAM_DECODE, COMPRESSION_ZLIB);
>+    ASSERT(status == COMPRESSION_STATUS_OK);
>+    if (status != COMPRESSION_STATUS_OK)
>+        return { };
>+    stream.dst_ptr = result.data();
>+    stream.dst_size = result.size();
>+    stream.src_ptr = WHLSLStandardLibrary + ignoredByteCount;
>+    stream.src_size = sizeof(WHLSLStandardLibrary) - ignoredByteCount;
>+    size_t offset = 0;
>+
>+    do {
>+        uint8_t* originalDestinationPointer = stream.dst_ptr;
>+        status = compression_stream_process(&stream, COMPRESSION_STREAM_FINALIZE);
>+        uint8_t* newDestinationPointer = stream.dst_ptr;
>+        offset += newDestinationPointer - originalDestinationPointer;
>+        switch (status) {
>+        case COMPRESSION_STATUS_OK: {
>+            auto newSize = offset * 1.5 + 1;
>+            if (newSize > result.size())
>+                result.grow(newSize);
>+            stream.dst_ptr = result.data() + offset;
>+            stream.dst_size = result.size() - offset;
>+            break;
>+        }
>+        case COMPRESSION_STATUS_END:
>+            status = compression_stream_destroy(&stream);
>+            ASSERT(status == COMPRESSION_STATUS_OK);
>+            if (status == COMPRESSION_STATUS_OK) {
>+                result.shrink(stream.dst_ptr - result.data());
>+                return result;
>+            }
>+            return { };
>+        case COMPRESSION_STATUS_ERROR:
>+        default:
>+            ASSERT_NOT_REACHED();
>+            compression_stream_destroy(&stream);
>+            return { };
>+        }
>+    } while (true);
>+}
>+
>+static String decompressAndDecodeStandardLibrary()
>+{
>+    auto decompressedStandardLibrary = decompressStandardLibrary();
>+    return String::fromUTF8(decompressedStandardLibrary.data(), decompressedStandardLibrary.size());
>+}
>+
>+class NameFinder : public Visitor {
>+public:
>+    void visit(AST::CallExpression& callExpression) override
>+    {
>+        m_functionNames.add(callExpression.name());
>+    }
>+
>+    HashSet<String> takeFunctionNames() { return WTFMove(m_functionNames); }
>+
>+private:
>+    HashSet<String> m_functionNames;
>+};
>+
>+void includeStandardLibrary(Program& program, Parser& parser)
>+{
>+    static NeverDestroyed<String> standardLibrary(decompressAndDecodeStandardLibrary());
>+    static NeverDestroyed<HashMap<String, SubstringLocation>> standardLibraryFunctionMap(computeStandardLibraryFunctionMap());
>+
>+    NameFinder nameFinder;
>+    nameFinder.Visitor::visit(program);
>+    HashSet<String> functionNames = nameFinder.takeFunctionNames();
>+    while (!functionNames.isEmpty()) {
>+        for (const auto& name : functionNames) {
>+            auto iterator = standardLibraryFunctionMap.get().find(name);
>+            if (iterator == standardLibraryFunctionMap.get().end())
>+                continue;
>+            auto stringView = StringView(standardLibrary.get()).substring(iterator->value.start, iterator->value.end);
>+            auto parseFailure = parser.parse(program, stringView, Parser::Mode::StandardLibrary);
>+            ASSERT_UNUSED(parseFailure, !parseFailure);
>+        }
>+        functionNames.clear();
>+        // FIXME: Make this recursive.
>+    }
>+}
>+
>+}
>+
>+}
>+
>+#endif
>diff --git a/Source/WebCore/Modules/webgpu/WHLSL/Metal/WHLSLFunctionWriter.cpp b/Source/WebCore/Modules/webgpu/WHLSL/Metal/WHLSLFunctionWriter.cpp
>index 94916b643ac99f756c0695e64634bd398e875e9a..0b5980f620a91e3d6165bca6937216e7f0f90115 100644
>--- a/Source/WebCore/Modules/webgpu/WHLSL/Metal/WHLSLFunctionWriter.cpp
>+++ b/Source/WebCore/Modules/webgpu/WHLSL/Metal/WHLSLFunctionWriter.cpp
>@@ -35,6 +35,7 @@
> #include "WHLSLTypeNamer.h"
> #include "WHLSLVisitor.h"
> #include <wtf/HashMap.h>
>+#include <wtf/HashSet.h>
> #include <wtf/SetForScope.h>
> #include <wtf/text/StringBuilder.h>
> 
>@@ -554,8 +555,7 @@ void FunctionDefinitionWriter::visit(AST::CallExpression& callExpression)
>         checkErrorAndVisit(argument);
>         argumentNames.append(takeLastValue());
>     }
>-    ASSERT(callExpression.function());
>-    auto iterator = m_functionMapping.find(callExpression.function());
>+    auto iterator = m_functionMapping.find(&callExpression.function());
>     ASSERT(iterator != m_functionMapping.end());
>     auto variableName = generateNextVariableName();
>     if (!matches(callExpression.resolvedType(), m_intrinsics.voidType()))
>@@ -763,7 +763,7 @@ struct SharedMetalFunctionsResult {
>     HashMap<AST::FunctionDeclaration*, String> functionMapping;
>     String metalFunctions;
> };
>-static SharedMetalFunctionsResult sharedMetalFunctions(Program& program, TypeNamer& typeNamer)
>+static SharedMetalFunctionsResult sharedMetalFunctions(Program& program, TypeNamer& typeNamer, const HashSet<AST::FunctionDeclaration*>& reachableFunctions)
> {
>     StringBuilder stringBuilder;
> 
>@@ -780,10 +780,12 @@ static SharedMetalFunctionsResult sharedMetalFunctions(Program& program, TypeNam
> 
>     {
>         FunctionDeclarationWriter functionDeclarationWriter(typeNamer, functionMapping);
>-        for (auto& nativeFunctionDeclaration : program.nativeFunctionDeclarations())
>-            functionDeclarationWriter.visit(nativeFunctionDeclaration);
>+        for (auto& nativeFunctionDeclaration : program.nativeFunctionDeclarations()) {
>+            if (reachableFunctions.contains(&nativeFunctionDeclaration))
>+                functionDeclarationWriter.visit(nativeFunctionDeclaration);
>+        }
>         for (auto& functionDefinition : program.functionDefinitions()) {
>-            if (!functionDefinition->entryPointType())
>+            if (!functionDefinition->entryPointType() && reachableFunctions.contains(&functionDefinition))
>                 functionDeclarationWriter.visit(functionDefinition);
>         }
>         stringBuilder.append(functionDeclarationWriter.toString());
>@@ -793,49 +795,89 @@ static SharedMetalFunctionsResult sharedMetalFunctions(Program& program, TypeNam
>     return { WTFMove(functionMapping), stringBuilder.toString() };
> }
> 
>+class ReachableFunctionsGatherer : public Visitor {
>+public:
>+    void visit(AST::FunctionDeclaration& functionDeclaration) override
>+    {
>+        Visitor::visit(functionDeclaration);
>+        m_reachableFunctions.add(&functionDeclaration);
>+    }
>+
>+    void visit(AST::CallExpression& callExpression) override
>+    {
>+        Visitor::visit(callExpression);
>+        if (is<AST::FunctionDefinition>(callExpression.function()))
>+            checkErrorAndVisit(downcast<AST::FunctionDefinition>(callExpression.function()));
>+        else
>+            checkErrorAndVisit(downcast<AST::NativeFunctionDeclaration>(callExpression.function()));
>+    }
>+
>+    HashSet<AST::FunctionDeclaration*> takeReachableFunctions() { return WTFMove(m_reachableFunctions); }
>+
>+private:
>+    HashSet<AST::FunctionDeclaration*> m_reachableFunctions;
>+};
>+
> RenderMetalFunctions metalFunctions(Program& program, TypeNamer& typeNamer, MatchedRenderSemantics&& matchedSemantics, Layout& layout)
> {
>-    auto sharedMetalFunctions = Metal::sharedMetalFunctions(program, typeNamer);
>+    auto& vertexShaderEntryPoint = *matchedSemantics.vertexShader;
>+    auto& fragmentShaderEntryPoint = *matchedSemantics.fragmentShader;
>+
>+    ReachableFunctionsGatherer reachableFunctionsGatherer;
>+    reachableFunctionsGatherer.Visitor::visit(vertexShaderEntryPoint);
>+    reachableFunctionsGatherer.Visitor::visit(fragmentShaderEntryPoint);
>+    auto reachableFunctions = reachableFunctionsGatherer.takeReachableFunctions();
>+
>+    auto sharedMetalFunctions = Metal::sharedMetalFunctions(program, typeNamer, reachableFunctions);
> 
>     StringBuilder stringBuilder;
>     stringBuilder.append(sharedMetalFunctions.metalFunctions);
> 
>-    auto* vertexShaderEntryPoint = matchedSemantics.vertexShader;
>-    auto* fragmentShaderEntryPoint = matchedSemantics.fragmentShader;
>-
>     RenderFunctionDefinitionWriter functionDefinitionWriter(program.intrinsics(), typeNamer, sharedMetalFunctions.functionMapping, WTFMove(matchedSemantics), layout);
>-    for (auto& nativeFunctionDeclaration : program.nativeFunctionDeclarations())
>-        functionDefinitionWriter.visit(nativeFunctionDeclaration);
>-    for (auto& functionDefinition : program.functionDefinitions())
>-        functionDefinitionWriter.visit(functionDefinition);
>+    for (auto& nativeFunctionDeclaration : program.nativeFunctionDeclarations()) {
>+        if (reachableFunctions.contains(&nativeFunctionDeclaration))
>+            functionDefinitionWriter.visit(nativeFunctionDeclaration);
>+    }
>+    for (auto& functionDefinition : program.functionDefinitions()) {
>+        if (reachableFunctions.contains(&functionDefinition))
>+            functionDefinitionWriter.visit(functionDefinition);
>+    }
>     stringBuilder.append(functionDefinitionWriter.toString());
> 
>     RenderMetalFunctions result;
>     result.metalSource = stringBuilder.toString();
>-    result.mangledVertexEntryPointName = sharedMetalFunctions.functionMapping.get(vertexShaderEntryPoint);
>-    result.mangledFragmentEntryPointName = sharedMetalFunctions.functionMapping.get(fragmentShaderEntryPoint);
>+    result.mangledVertexEntryPointName = sharedMetalFunctions.functionMapping.get(&vertexShaderEntryPoint);
>+    result.mangledFragmentEntryPointName = sharedMetalFunctions.functionMapping.get(&fragmentShaderEntryPoint);
>     return result;
> }
> 
> ComputeMetalFunctions metalFunctions(Program& program, TypeNamer& typeNamer, MatchedComputeSemantics&& matchedSemantics, Layout& layout)
> {
>-    auto sharedMetalFunctions = Metal::sharedMetalFunctions(program, typeNamer);
>+    auto& entryPoint = *matchedSemantics.shader;
>+
>+    ReachableFunctionsGatherer reachableFunctionsGatherer;
>+    reachableFunctionsGatherer.Visitor::visit(entryPoint);
>+    auto reachableFunctions = reachableFunctionsGatherer.takeReachableFunctions();
>+
>+    auto sharedMetalFunctions = Metal::sharedMetalFunctions(program, typeNamer, reachableFunctions);
> 
>     StringBuilder stringBuilder;
>     stringBuilder.append(sharedMetalFunctions.metalFunctions);
> 
>-    auto* entryPoint = matchedSemantics.shader;
>-
>     ComputeFunctionDefinitionWriter functionDefinitionWriter(program.intrinsics(), typeNamer, sharedMetalFunctions.functionMapping, WTFMove(matchedSemantics), layout);
>-    for (auto& nativeFunctionDeclaration : program.nativeFunctionDeclarations())
>-        functionDefinitionWriter.visit(nativeFunctionDeclaration);
>-    for (auto& functionDefinition : program.functionDefinitions())
>-        functionDefinitionWriter.visit(functionDefinition);
>+    for (auto& nativeFunctionDeclaration : program.nativeFunctionDeclarations()) {
>+        if (reachableFunctions.contains(&nativeFunctionDeclaration))
>+            functionDefinitionWriter.visit(nativeFunctionDeclaration);
>+    }
>+    for (auto& functionDefinition : program.functionDefinitions()) {
>+        if (reachableFunctions.contains(&functionDefinition))
>+            functionDefinitionWriter.visit(functionDefinition);
>+    }
>     stringBuilder.append(functionDefinitionWriter.toString());
> 
>     ComputeMetalFunctions result;
>     result.metalSource = stringBuilder.toString();
>-    result.mangledEntryPointName = sharedMetalFunctions.functionMapping.get(entryPoint);
>+    result.mangledEntryPointName = sharedMetalFunctions.functionMapping.get(&entryPoint);
>     return result;
> }
> 
>diff --git a/Source/WebCore/Modules/webgpu/WHLSL/Metal/WHLSLNativeFunctionWriter.cpp b/Source/WebCore/Modules/webgpu/WHLSL/Metal/WHLSLNativeFunctionWriter.cpp
>index 3aec9ff80e4d654fa8e52704759cae764d809e82..f250faae46f00aa03d9cecaa671095fd69c0e25b 100644
>--- a/Source/WebCore/Modules/webgpu/WHLSL/Metal/WHLSLNativeFunctionWriter.cpp
>+++ b/Source/WebCore/Modules/webgpu/WHLSL/Metal/WHLSLNativeFunctionWriter.cpp
>@@ -135,20 +135,6 @@ String writeNativeFunction(AST::NativeFunctionDeclaration& nativeFunctionDeclara
> 
>         ASSERT(nativeFunctionDeclaration.parameters().size() == 1);
>         auto metalParameterName = typeNamer.mangledNameForType(*nativeFunctionDeclaration.parameters()[0]->type());
>-        auto& parameterType = nativeFunctionDeclaration.parameters()[0]->type()->unifyNode();
>-        if (is<AST::NamedType>(parameterType)) {
>-            auto& parameterNamedType = downcast<AST::NamedType>(parameterType);
>-            if (is<AST::NativeTypeDeclaration>(parameterNamedType)) {
>-                auto& parameterNativeTypeDeclaration = downcast<AST::NativeTypeDeclaration>(parameterNamedType);
>-                if (parameterNativeTypeDeclaration.isAtomic()) {
>-                    stringBuilder.append(makeString(metalReturnName, ' ', outputFunctionName, '(', metalParameterName, " x) {\n"));
>-                    stringBuilder.append("    return atomic_load_explicit(&x, memory_order_relaxed);\n");
>-                    stringBuilder.append("}\n");
>-                    return stringBuilder.toString();
>-                }
>-            }
>-        }
>-
>         stringBuilder.append(makeString(metalReturnName, ' ', outputFunctionName, '(', metalParameterName, " x) {\n"));
>         stringBuilder.append(makeString("    return static_cast<", metalReturnName, ">(x);\n"));
>         stringBuilder.append("}\n");
>@@ -363,11 +349,6 @@ String writeNativeFunction(AST::NativeFunctionDeclaration& nativeFunctionDeclara
>         return stringBuilder.toString();
>     }
> 
>-    if (nativeFunctionDeclaration.name() == "f16tof32" || nativeFunctionDeclaration.name() == "f32tof16") {
>-        // FIXME: https://bugs.webkit.org/show_bug.cgi?id=195813 Implement this
>-        notImplemented();
>-    }
>-
>     if (nativeFunctionDeclaration.name() == "AllMemoryBarrierWithGroupSync") {
>         ASSERT(!nativeFunctionDeclaration.parameters().size());
>         stringBuilder.append(makeString("void ", outputFunctionName, "() {\n"));
>@@ -406,7 +387,7 @@ String writeNativeFunction(AST::NativeFunctionDeclaration& nativeFunctionDeclara
>             auto fourthArgumentAddressSpace = fourthArgumentPointer.addressSpace();
>             auto fourthArgumentPointee = typeNamer.mangledNameForType(fourthArgumentPointer.elementType());
>             stringBuilder.append(makeString("void ", outputFunctionName, '(', toString(firstArgumentAddressSpace), ' ', firstArgumentPointee, "* object, ", secondArgument, " compare, ", thirdArgument, " desired, ", toString(fourthArgumentAddressSpace), ' ', fourthArgumentPointee, "* out) {\n"));
>-            stringBuilder.append("    atomic_compare_exchange_weak_explicit(object, &compare, desired, memory_order_relaxed);\n");
>+            stringBuilder.append("    atomic_compare_exchange_weak_explicit(object, &compare, desired, memory_order_relaxed, memory_order_relaxed);\n");
>             stringBuilder.append("    *out = compare;\n");
>             stringBuilder.append("}\n");
>             return stringBuilder.toString();
>@@ -422,7 +403,7 @@ String writeNativeFunction(AST::NativeFunctionDeclaration& nativeFunctionDeclara
>         auto thirdArgumentPointee = typeNamer.mangledNameForType(thirdArgumentPointer.elementType());
>         auto name = atomicName(nativeFunctionDeclaration.name().substring("Interlocked"_str.length()));
>         stringBuilder.append(makeString("void ", outputFunctionName, '(', toString(firstArgumentAddressSpace), ' ', firstArgumentPointee, "* object, ", secondArgument, " operand, ", toString(thirdArgumentAddressSpace), ' ', thirdArgumentPointee, "* out) {\n"));
>-        stringBuilder.append(makeString("    *out = atomic_fetch_", name, "_explicit(object, operand, memory_order_relaxed);\n"));
>+        stringBuilder.append(makeString("    *out = atomic_", name, "_explicit(object, operand, memory_order_relaxed);\n"));
>         stringBuilder.append("}\n");
>         return stringBuilder.toString();
>     }
>@@ -509,6 +490,26 @@ String writeNativeFunction(AST::NativeFunctionDeclaration& nativeFunctionDeclara
>         return stringBuilder.toString();
>     }
> 
>+    if (nativeFunctionDeclaration.name() == "load") {
>+        ASSERT(nativeFunctionDeclaration.parameters().size() == 1);
>+        auto metalParameterName = typeNamer.mangledNameForType(*nativeFunctionDeclaration.parameters()[0]->type());
>+        auto metalReturnName = typeNamer.mangledNameForType(nativeFunctionDeclaration.type());
>+        stringBuilder.append(makeString(metalReturnName, ' ', outputFunctionName, '(', metalParameterName, " x) {\n"));
>+        stringBuilder.append("    return atomic_load_explicit(x, memory_order_relaxed);\n");
>+        stringBuilder.append("}\n");
>+        return stringBuilder.toString();
>+    }
>+
>+    if (nativeFunctionDeclaration.name() == "store") {
>+        ASSERT(nativeFunctionDeclaration.parameters().size() == 2);
>+        auto metalParameter1Name = typeNamer.mangledNameForType(*nativeFunctionDeclaration.parameters()[0]->type());
>+        auto metalParameter2Name = typeNamer.mangledNameForType(*nativeFunctionDeclaration.parameters()[1]->type());
>+        stringBuilder.append(makeString("void ", outputFunctionName, '(', metalParameter1Name, " x, ", metalParameter2Name, " y) {\n"));
>+        stringBuilder.append("    atomic_store_explicit(x, y, memory_order_relaxed);\n");
>+        stringBuilder.append("}\n");
>+        return stringBuilder.toString();
>+    }
>+
>     if (nativeFunctionDeclaration.name() == "GetDimensions") {
>         auto& textureType = downcast<AST::NativeTypeDeclaration>(downcast<AST::NamedType>(nativeFunctionDeclaration.parameters()[0]->type()->unifyNode()));
> 
>@@ -533,7 +534,7 @@ String writeNativeFunction(AST::NativeFunctionDeclaration& nativeFunctionDeclara
>             ++index;
>         }
>         String numberOfLevelsTypeName;
>-        if (!textureType.isWritableTexture()) {
>+        if (!textureType.isWritableTexture() && textureType.textureDimension() != 1) {
>             numberOfLevelsTypeName = typeNamer.mangledNameForType(*nativeFunctionDeclaration.parameters()[index]->type());
>             ++index;
>         }
>diff --git a/Source/WebCore/Modules/webgpu/WHLSL/WHLSLBuildStandardLibraryFunctionMap.py b/Source/WebCore/Modules/webgpu/WHLSL/WHLSLBuildStandardLibraryFunctionMap.py
>new file mode 100644
>index 0000000000000000000000000000000000000000..4ca6e1cea5761a3ad70c6de18081924c8fada689
>--- /dev/null
>+++ b/Source/WebCore/Modules/webgpu/WHLSL/WHLSLBuildStandardLibraryFunctionMap.py
>@@ -0,0 +1,96 @@
>+#!/usr/bin/env python
>+#
>+# Copyright (C) 2014 Apple Inc. All rights reserved.
>+#
>+# Redistribution and use in source and binary forms, with or without
>+# modification, are permitted provided that the following conditions
>+# are met:
>+# 1. Redistributions of source code must retain the above copyright
>+#    notice, this list of conditions and the following disclaimer.
>+# 2. Redistributions in binary form must reproduce the above copyright
>+#    notice, this list of conditions and the following disclaimer in the
>+#    documentation and/or other materials provided with the distribution.
>+#
>+# THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''
>+# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
>+# THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
>+# PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
>+# BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
>+# CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
>+# SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
>+# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
>+# CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
>+# ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
>+# THE POSSIBILITY OF SUCH DAMAGE.
>+
>+import sys
>+import re
>+
>+regularExpression = re.compile("/\* Functions named (.*) \*/")
>+
>+infile = open(sys.argv[1], "r")
>+contents = infile.read()
>+infile.close()
>+
>+outfile = open(sys.argv[2], "w")
>+outfile.write("""
>+/*
>+ * Copyright (C) 2019 Apple Inc. All rights reserved.
>+ *
>+ * Redistribution and use in source and binary forms, with or without
>+ * modification, are permitted provided that the following conditions
>+ * are met:
>+ * 1. Redistributions of source code must retain the above copyright
>+ *    notice, this list of conditions and the following disclaimer.
>+ * 2. Redistributions in binary form must reproduce the above copyright
>+ *    notice, this list of conditions and the following disclaimer in the
>+ *    documentation and/or other materials provided with the distribution.
>+ *
>+ * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''
>+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
>+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
>+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
>+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
>+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
>+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
>+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
>+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
>+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
>+ * THE POSSIBILITY OF SUCH DAMAGE.
>+ */
>+
>+#include "config.h"
>+#include "WHLSLStandardLibraryFunctionMap.h"
>+
>+#if ENABLE(WEBGPU)
>+
>+namespace WebCore {
>+
>+namespace WHLSL {
>+
>+HashMap<String, SubstringLocation> computeStandardLibraryFunctionMap()
>+{
>+    HashMap<String, SubstringLocation> result;
>+""")
>+previous = 0
>+previousName = ""
>+for match in regularExpression.finditer(contents):
>+    if previous == 0:
>+        previous = match.start()
>+        previousName = match.group(1)
>+        continue
>+    outfile.write("    result.add(\"" + previousName + "\"_str, SubstringLocation { " + str(previous) + ", " + str(match.start()) + " });\n")
>+    previous = match.start()
>+    previousName = match.group(1)
>+outfile.write("    result.add(\"" + previousName + "\"_str, SubstringLocation { " + str(previous) + ", " + str(len(contents)) + " });\n")
>+outfile.write("""
>+    return result;
>+}
>+
>+}
>+
>+}
>+
>+#endif
>+""")
>+outfile.close()
>diff --git a/Source/WebCore/Modules/webgpu/WHLSL/WHLSLChecker.cpp b/Source/WebCore/Modules/webgpu/WHLSL/WHLSLChecker.cpp
>index 98cd2ceb0456fbca7937c4beae3f833545a84f02..825a28286b33e7d32b58151daf4a5d9f3f76e650 100644
>--- a/Source/WebCore/Modules/webgpu/WHLSL/WHLSLChecker.cpp
>+++ b/Source/WebCore/Modules/webgpu/WHLSL/WHLSLChecker.cpp
>@@ -194,7 +194,8 @@ static Optional<AST::NativeFunctionDeclaration> resolveByInstantiation(const Str
>     } else if (name == "operator==" && types.size() == 2) {
>         auto acceptability = [](ResolvingType& resolvingType) -> Acceptability {
>             return resolvingType.visit(WTF::makeVisitor([](UniqueRef<AST::UnnamedType>& unnamedType) -> Acceptability {
>-                return is<AST::ReferenceType>(static_cast<AST::UnnamedType&>(unnamedType)) ? Acceptability::Yes : Acceptability::No;
>+                auto& unifyNode = unnamedType->unifyNode();
>+                return is<AST::UnnamedType>(unifyNode) && is<AST::ReferenceType>(downcast<AST::UnnamedType>(unifyNode)) ? Acceptability::Yes : Acceptability::No;
>             }, [](RefPtr<ResolvableTypeReference>& resolvableTypeReference) -> Acceptability {
>                 return is<AST::NullLiteralType>(resolvableTypeReference->resolvableType()) ? Acceptability::Maybe : Acceptability::No;
>             }));
>@@ -416,7 +417,7 @@ static bool checkOperatorOverload(const AST::FunctionDefinition& functionDefinit
>         || functionDefinition.name() == "operator|"
>         || functionDefinition.name() == "operator^"
>         || functionDefinition.name() == "operator<<"
>-        || functionDefinition.name() == "opreator>>")
>+        || functionDefinition.name() == "operator>>")
>         return functionDefinition.parameters().size() == 2;
>     if (functionDefinition.name() == "operator~")
>         return functionDefinition.parameters().size() == 1;
>@@ -1137,7 +1138,6 @@ void Checker::visit(AST::VariableReference& variableReference)
> 
> void Checker::visit(AST::Return& returnStatement)
> {
>-    ASSERT(returnStatement.function());
>     if (returnStatement.value()) {
>         auto valueInfo = recurseAndGetInfo(*returnStatement.value());
>         if (!valueInfo)
>diff --git a/Source/WebCore/Modules/webgpu/WHLSL/WHLSLFunctionStageChecker.cpp b/Source/WebCore/Modules/webgpu/WHLSL/WHLSLFunctionStageChecker.cpp
>index f4ce762dd6c32e1014d779a12357a454efe68066..f08efaa392bc0bf5e15a4329a28bea307d256d99 100644
>--- a/Source/WebCore/Modules/webgpu/WHLSL/WHLSLFunctionStageChecker.cpp
>+++ b/Source/WebCore/Modules/webgpu/WHLSL/WHLSLFunctionStageChecker.cpp
>@@ -49,18 +49,16 @@ public:
> public:
>     void visit(AST::CallExpression& callExpression) override
>     {
>-        ASSERT(callExpression.function());
>-        if ((callExpression.function() == &m_intrinsics.ddx() || callExpression.function() == &m_intrinsics.ddy()) && m_entryPointType != AST::EntryPointType::Fragment) {
>+        if ((&callExpression.function() == &m_intrinsics.ddx() || &callExpression.function() == &m_intrinsics.ddy()) && m_entryPointType != AST::EntryPointType::Fragment) {
>             setError();
>             return;
>         }
>-        if ((callExpression.function() == &m_intrinsics.allMemoryBarrier() || callExpression.function() == &m_intrinsics.deviceMemoryBarrier() || callExpression.function() == &m_intrinsics.groupMemoryBarrier())
>+        if ((&callExpression.function() == &m_intrinsics.allMemoryBarrier() || &callExpression.function() == &m_intrinsics.deviceMemoryBarrier() || &callExpression.function() == &m_intrinsics.groupMemoryBarrier())
>             && m_entryPointType != AST::EntryPointType::Compute) {
>             setError();
>             return;
>         }
>-        ASSERT(callExpression.function());
>-        Visitor::visit(*callExpression.function());
>+        Visitor::visit(callExpression.function());
>     }
> 
>     AST::EntryPointType m_entryPointType;
>diff --git a/Source/WebCore/Modules/webgpu/WHLSL/WHLSLLexer.h b/Source/WebCore/Modules/webgpu/WHLSL/WHLSLLexer.h
>index bbde9fe4f8bc4b1e2c35b05909c511fe47b22c1b..4f213d19b5065f7478a4b97caeb6df8f47404e5f 100644
>--- a/Source/WebCore/Modules/webgpu/WHLSL/WHLSLLexer.h
>+++ b/Source/WebCore/Modules/webgpu/WHLSL/WHLSLLexer.h
>@@ -46,7 +46,9 @@ public:
>         : m_stringView(stringView)
>     {
>         skipWhitespaceAndComments();
>+        m_offsetRingBuffer[0] = m_offset;
>         m_ringBuffer[0] = consumeTokenFromStream();
>+        m_offsetRingBuffer[1] = m_offset;
>         m_ringBuffer[1] = consumeTokenFromStream();
>     }
> 
>@@ -180,25 +182,29 @@ public:
>     Optional<Token> consumeToken()
>     {
>         auto result = m_ringBuffer[m_ringBufferIndex];
>+        m_offsetRingBuffer[m_ringBufferIndex] = m_offset;
>         m_ringBuffer[m_ringBufferIndex] = consumeTokenFromStream();
>         m_ringBufferIndex = (m_ringBufferIndex + 1) % 2;
>         return result;
>     }
> 
>-    Optional<Token> peek()
>+    Optional<Token> peek() const
>     {
>         return m_ringBuffer[m_ringBufferIndex];
>     }
> 
>-    Optional<Token> peekFurther()
>+    Optional<Token> peekFurther() const
>     {
>         return m_ringBuffer[(m_ringBufferIndex + 1) % 2];
>     }
> 
>+    Optional<unsigned> position() const { return m_offsetRingBuffer[m_ringBufferIndex]; }
>+
>     // FIXME: We should not need this
>     // https://bugs.webkit.org/show_bug.cgi?id=198357
>     struct State {
>         Optional<Token> ringBuffer[2];
>+        Optional<unsigned> m_offsetRingBuffer[2];
>         unsigned ringBufferIndex;
>         unsigned offset;
>         unsigned lineNumber;
>@@ -209,6 +215,8 @@ public:
>         State state;
>         state.ringBuffer[0] = m_ringBuffer[0];
>         state.ringBuffer[1] = m_ringBuffer[1];
>+        state.m_offsetRingBuffer[0] = m_offsetRingBuffer[0];
>+        state.m_offsetRingBuffer[1] = m_offsetRingBuffer[1];
>         state.ringBufferIndex = m_ringBufferIndex;
>         state.offset = m_offset;
>         state.lineNumber = m_lineNumber;
>@@ -219,6 +227,8 @@ public:
>     {
>         m_ringBuffer[0] = state.ringBuffer[0];
>         m_ringBuffer[1] = state.ringBuffer[1];
>+        m_offsetRingBuffer[0] = state.m_offsetRingBuffer[0];
>+        m_offsetRingBuffer[1] = state.m_offsetRingBuffer[1];
>         m_ringBufferIndex = state.ringBufferIndex;
>         m_offset = state.offset;
>         m_lineNumber = state.lineNumber;
>@@ -229,6 +239,8 @@ public:
>     {
>         m_ringBuffer[0] = WTFMove(state.ringBuffer[0]);
>         m_ringBuffer[1] = WTFMove(state.ringBuffer[1]);
>+        m_offsetRingBuffer[0] = WTFMove(state.m_offsetRingBuffer[0]);
>+        m_offsetRingBuffer[1] = WTFMove(state.m_offsetRingBuffer[1]);
>         m_ringBufferIndex = WTFMove(state.ringBufferIndex);
>         m_offset = WTFMove(state.offset);
>         m_lineNumber = WTFMove(state.lineNumber);
>@@ -236,7 +248,7 @@ public:
> 
>     bool isFullyConsumed() const
>     {
>-        return m_offset == m_stringView.length();
>+        return !peek();
>     }
> 
>     String errorString(const Token& token, const String& message)
>@@ -276,6 +288,7 @@ private:
> 
>     StringView m_stringView;
>     Optional<Token> m_ringBuffer[2];
>+    Optional<unsigned> m_offsetRingBuffer[2];
>     unsigned m_ringBufferIndex { 0 };
>     unsigned m_offset { 0 };
>     unsigned m_lineNumber { 0 };
>diff --git a/Source/WebCore/Modules/webgpu/WHLSL/WHLSLParser.cpp b/Source/WebCore/Modules/webgpu/WHLSL/WHLSLParser.cpp
>index 4fa5c6e65eece0114ca63eaed4b337651b861e4f..262c38fb6c2e96c3f10c75c21b8ad2f35f8f975a 100644
>--- a/Source/WebCore/Modules/webgpu/WHLSL/WHLSLParser.cpp
>+++ b/Source/WebCore/Modules/webgpu/WHLSL/WHLSLParser.cpp
>@@ -68,6 +68,7 @@ auto Parser::parse(Program& program, StringView stringView, Mode mode) -> Option
>         auto token = m_lexer.peek();
>         if (!token)
>             break;
>+        auto startPosition = *m_lexer.position();
>         switch (token->type) {
>         case Lexer::Token::Type::Semicolon:
>             m_lexer.consumeToken();
>@@ -108,6 +109,9 @@ auto Parser::parse(Program& program, StringView stringView, Mode mode) -> Option
>             auto nativeFunctionDeclaration = parseNativeFunctionDeclaration();
>             if (!nativeFunctionDeclaration)
>                 return nativeFunctionDeclaration.error();
>+            auto endPosition = m_lexer.position().valueOr(stringView.length());
>+            if (m_mode == Mode::StandardLibrary)
>+                WTFLogAlways("%s %u %u", nativeFunctionDeclaration->name().utf8().data(), startPosition, endPosition);
>             program.append(WTFMove(*nativeFunctionDeclaration));
>             continue;
>         }
>@@ -115,6 +119,9 @@ auto Parser::parse(Program& program, StringView stringView, Mode mode) -> Option
>             auto functionDefinition = parseFunctionDefinition();
>             if (!functionDefinition)
>                 return functionDefinition.error();
>+            auto endPosition = m_lexer.position().valueOr(stringView.length());
>+            if (m_mode == Mode::StandardLibrary)
>+                WTFLogAlways("%s %u %u", functionDefinition->name().utf8().data(), startPosition, endPosition);
>             program.append(WTFMove(*functionDefinition));
>             continue;
>         }
>diff --git a/Source/WebCore/Modules/webgpu/WHLSL/WHLSLPrepare.cpp b/Source/WebCore/Modules/webgpu/WHLSL/WHLSLPrepare.cpp
>index ed9930b6993b64a528806897fc9b821ba4a7ad95..228a48fc593a7793913f899f16d0d92fa5fb8f28 100644
>--- a/Source/WebCore/Modules/webgpu/WHLSL/WHLSLPrepare.cpp
>+++ b/Source/WebCore/Modules/webgpu/WHLSL/WHLSLPrepare.cpp
>@@ -46,7 +46,7 @@
> #include "WHLSLRecursionChecker.h"
> #include "WHLSLRecursiveTypeChecker.h"
> #include "WHLSLSemanticMatcher.h"
>-#include "WHLSLStandardLibrary.h"
>+#include "WHLSLStandardLibraryUtilities.h"
> #include "WHLSLStatementBehaviorChecker.h"
> #include "WHLSLSynthesizeArrayOperatorLength.h"
> #include "WHLSLSynthesizeConstructors.h"
>@@ -110,17 +110,12 @@ static Optional<Program> prepareShared(String& whlslSource)
> {
>     Program program;
>     Parser parser;
>-    auto standardLibrary = String::fromUTF8(WHLSLStandardLibrary, sizeof(WHLSLStandardLibrary));
>-    auto parseStdLibFailure = parser.parse(program, standardLibrary, Parser::Mode::StandardLibrary);
>-    if (!ASSERT_DISABLED && parseStdLibFailure) {
>-        dataLogLn("failed to parse the standard library: ", *parseStdLibFailure);
>-        RELEASE_ASSERT_NOT_REACHED();
>-    }
>     if (auto parseFailure = parser.parse(program, whlslSource, Parser::Mode::User)) {
>         if (dumpPassFailure)
>             dataLogLn("failed to parse the program: ", *parseFailure);
>         return WTF::nullopt;
>     }
>+    includeStandardLibrary(program, parser);
> 
>     if (!dumpASTBetweenEachPassIfNeeded(program, "AST after parsing"))
>         dumpASTAfterParsingIfNeeded(program);
>diff --git a/Source/WebCore/Modules/webgpu/WHLSL/WHLSLPreserveVariableLifetimes.cpp b/Source/WebCore/Modules/webgpu/WHLSL/WHLSLPreserveVariableLifetimes.cpp
>index fc7a4df1b505f772f43b730b0eef523a1e5f7c09..417efd18d6ed6dcc29d3ea754fde7428228cb337 100644
>--- a/Source/WebCore/Modules/webgpu/WHLSL/WHLSLPreserveVariableLifetimes.cpp
>+++ b/Source/WebCore/Modules/webgpu/WHLSL/WHLSLPreserveVariableLifetimes.cpp
>@@ -188,7 +188,7 @@ public:
> 
>         // This works because it's illegal to call an entrypoint. Therefore, we can only
>         // call functions where we've already appended this struct as its final parameter.
>-        if (!callExpression.function()->isNativeFunctionDeclaration())
>+        if (!callExpression.function().isNativeFunctionDeclaration())
>             callExpression.arguments().append(makeStructVariableReference());
>     }
> 
>diff --git a/Source/WebCore/Modules/webgpu/WHLSL/WHLSLRecursionChecker.cpp b/Source/WebCore/Modules/webgpu/WHLSL/WHLSLRecursionChecker.cpp
>index 43cf9cbd5215b8bfb0db770063aff68aecb80eb9..cd0800d36192e48fc537723aa80a0ea9f632c5f6 100644
>--- a/Source/WebCore/Modules/webgpu/WHLSL/WHLSLRecursionChecker.cpp
>+++ b/Source/WebCore/Modules/webgpu/WHLSL/WHLSLRecursionChecker.cpp
>@@ -56,8 +56,7 @@ private:
> 
>     void visit(AST::CallExpression& callExpression) override
>     {
>-        ASSERT(callExpression.function());
>-        Visitor::visit(*callExpression.function());
>+        Visitor::visit(callExpression.function());
>     }
> 
>     HashSet<AST::FunctionDefinition*> m_visitingSet;
>diff --git a/Source/WebCore/Modules/webgpu/WHLSL/WHLSLStandardLibrary.txt b/Source/WebCore/Modules/webgpu/WHLSL/WHLSLStandardLibrary.txt
>index d2205d1844a1092e8d1a4cdd6a8629b59e9f0fbe..7c2454a21d47475ffe1e409448062a11aedf9f3a 100644
>--- a/Source/WebCore/Modules/webgpu/WHLSL/WHLSLStandardLibrary.txt
>+++ b/Source/WebCore/Modules/webgpu/WHLSL/WHLSLStandardLibrary.txt
>@@ -1,5 +1,9 @@
>-// https://github.com/gpuweb/WHLSL/blob/9528f19aaa71fd5c3c706d2873f4b8c8cce857b5/Spec/source/Generate_Standard_Library.js
>-// This was autogenerated from Generate_Standard_Library.js! Do not edit!!
>+// This was autogenerated from Generate_Standard_Library.js.
>+// This standard library has been processed such that functions which share a name are next to each other,
>+// and before each group of functions, there's a prefix that has to be in a particular form.
>+// The WebKit build process exploits this structure to build a map of which function name corresponds to which
>+// part of this file. Then, when we parse WHLSL programs, we can only parse the pieces of this standard library
>+// which correspond to functions that are actually used in the user program.
> 
> native typedef void;
> native typedef bool;
>@@ -253,672 +257,61956 @@ native typedef TextureDepth2D<float>;
> native typedef TextureDepth2DArray<float>;
> native typedef TextureDepthCube<float>;
> 
>-native operator uchar(ushort);
>-native operator uchar(uint);
>-native operator uchar(char);
>-native operator uchar(short);
>-native operator uchar(int);
>-native operator uchar(half);
>-native operator uchar(float);
>-native operator ushort(uchar);
>-native operator ushort(uint);
>-native operator ushort(char);
>-native operator ushort(short);
>-native operator ushort(int);
>-native operator ushort(half);
>-native operator ushort(float);
>-native operator uint(uchar);
>-native operator uint(ushort);
>-native operator uint(char);
>-native operator uint(short);
>-native operator uint(int);
>-native operator uint(half);
>-native operator uint(float);
>-native operator char(uchar);
>-native operator char(ushort);
>-native operator char(uint);
>-native operator char(short);
>-native operator char(int);
>-native operator char(half);
>-native operator char(float);
>-native operator short(uchar);
>-native operator short(ushort);
>-native operator short(uint);
>-native operator short(char);
>-native operator short(int);
>-native operator short(half);
>-native operator short(float);
>-native operator int(uchar);
>-native operator int(ushort);
>-native operator int(uint);
>-native operator int(char);
>-native operator int(short);
>-native operator int(half);
>-native operator int(float);
>-native operator half(uchar);
>-native operator half(ushort);
>-native operator half(uint);
>-native operator half(char);
>-native operator half(short);
>-native operator half(int);
>-native operator half(float);
>-native operator float(uchar);
>-native operator float(ushort);
>-native operator float(uint);
>-native operator float(char);
>-native operator float(short);
>-native operator float(int);
>-native operator float(half);
>-
>-// FIXME: These should be auto generated by the compiler.
>-// https://bugs.webkit.org/show_bug.cgi?id=198861
>-native bool operator==(thread int*, thread int*);
>-
>-native bool operator.x(bool2);
>-native bool operator.y(bool2);
>-native bool operator.x(bool3);
>-native bool operator.y(bool3);
>-native bool operator.z(bool3);
>-native bool operator.x(bool4);
>-native bool operator.y(bool4);
>-native bool operator.z(bool4);
>-native bool operator.w(bool4);
>-native bool2 operator.x=(bool2, bool);
>-native bool2 operator.y=(bool2, bool);
>-native bool3 operator.x=(bool3, bool);
>-native bool3 operator.y=(bool3, bool);
>-native bool3 operator.z=(bool3, bool);
>-native bool4 operator.x=(bool4, bool);
>-native bool4 operator.y=(bool4, bool);
>-native bool4 operator.z=(bool4, bool);
>-native bool4 operator.w=(bool4, bool);
>-native uchar operator.x(uchar2);
>-native uchar operator.y(uchar2);
>-native uchar operator.x(uchar3);
>-native uchar operator.y(uchar3);
>-native uchar operator.z(uchar3);
>-native uchar operator.x(uchar4);
>-native uchar operator.y(uchar4);
>-native uchar operator.z(uchar4);
>-native uchar operator.w(uchar4);
>-native uchar2 operator.x=(uchar2, uchar);
>-native uchar2 operator.y=(uchar2, uchar);
>-native uchar3 operator.x=(uchar3, uchar);
>-native uchar3 operator.y=(uchar3, uchar);
>-native uchar3 operator.z=(uchar3, uchar);
>-native uchar4 operator.x=(uchar4, uchar);
>-native uchar4 operator.y=(uchar4, uchar);
>-native uchar4 operator.z=(uchar4, uchar);
>-native uchar4 operator.w=(uchar4, uchar);
>-native ushort operator.x(ushort2);
>-native ushort operator.y(ushort2);
>-native ushort operator.x(ushort3);
>-native ushort operator.y(ushort3);
>-native ushort operator.z(ushort3);
>-native ushort operator.x(ushort4);
>-native ushort operator.y(ushort4);
>-native ushort operator.z(ushort4);
>-native ushort operator.w(ushort4);
>-native ushort2 operator.x=(ushort2, ushort);
>-native ushort2 operator.y=(ushort2, ushort);
>-native ushort3 operator.x=(ushort3, ushort);
>-native ushort3 operator.y=(ushort3, ushort);
>-native ushort3 operator.z=(ushort3, ushort);
>-native ushort4 operator.x=(ushort4, ushort);
>-native ushort4 operator.y=(ushort4, ushort);
>-native ushort4 operator.z=(ushort4, ushort);
>-native ushort4 operator.w=(ushort4, ushort);
>-native uint operator.x(uint2);
>-native uint operator.y(uint2);
>-native uint operator.x(uint3);
>-native uint operator.y(uint3);
>-native uint operator.z(uint3);
>-native uint operator.x(uint4);
>-native uint operator.y(uint4);
>-native uint operator.z(uint4);
>-native uint operator.w(uint4);
>-native uint2 operator.x=(uint2, uint);
>-native uint2 operator.y=(uint2, uint);
>-native uint3 operator.x=(uint3, uint);
>-native uint3 operator.y=(uint3, uint);
>-native uint3 operator.z=(uint3, uint);
>-native uint4 operator.x=(uint4, uint);
>-native uint4 operator.y=(uint4, uint);
>-native uint4 operator.z=(uint4, uint);
>-native uint4 operator.w=(uint4, uint);
>-native char operator.x(char2);
>-native char operator.y(char2);
>-native char operator.x(char3);
>-native char operator.y(char3);
>-native char operator.z(char3);
>-native char operator.x(char4);
>-native char operator.y(char4);
>-native char operator.z(char4);
>-native char operator.w(char4);
>-native char2 operator.x=(char2, char);
>-native char2 operator.y=(char2, char);
>-native char3 operator.x=(char3, char);
>-native char3 operator.y=(char3, char);
>-native char3 operator.z=(char3, char);
>-native char4 operator.x=(char4, char);
>-native char4 operator.y=(char4, char);
>-native char4 operator.z=(char4, char);
>-native char4 operator.w=(char4, char);
>-native short operator.x(short2);
>-native short operator.y(short2);
>-native short operator.x(short3);
>-native short operator.y(short3);
>-native short operator.z(short3);
>-native short operator.x(short4);
>-native short operator.y(short4);
>-native short operator.z(short4);
>-native short operator.w(short4);
>-native short2 operator.x=(short2, short);
>-native short2 operator.y=(short2, short);
>-native short3 operator.x=(short3, short);
>-native short3 operator.y=(short3, short);
>-native short3 operator.z=(short3, short);
>-native short4 operator.x=(short4, short);
>-native short4 operator.y=(short4, short);
>-native short4 operator.z=(short4, short);
>-native short4 operator.w=(short4, short);
>-native int operator.x(int2);
>-native int operator.y(int2);
>-native int operator.x(int3);
>-native int operator.y(int3);
>-native int operator.z(int3);
>-native int operator.x(int4);
>-native int operator.y(int4);
>-native int operator.z(int4);
>-native int operator.w(int4);
>-native int2 operator.x=(int2, int);
>-native int2 operator.y=(int2, int);
>-native int3 operator.x=(int3, int);
>-native int3 operator.y=(int3, int);
>-native int3 operator.z=(int3, int);
>-native int4 operator.x=(int4, int);
>-native int4 operator.y=(int4, int);
>-native int4 operator.z=(int4, int);
>-native int4 operator.w=(int4, int);
>-native half operator.x(half2);
>-native half operator.y(half2);
>-native half operator.x(half3);
>-native half operator.y(half3);
>-native half operator.z(half3);
>-native half operator.x(half4);
>-native half operator.y(half4);
>-native half operator.z(half4);
>-native half operator.w(half4);
>-native half2 operator.x=(half2, half);
>-native half2 operator.y=(half2, half);
>-native half3 operator.x=(half3, half);
>-native half3 operator.y=(half3, half);
>-native half3 operator.z=(half3, half);
>-native half4 operator.x=(half4, half);
>-native half4 operator.y=(half4, half);
>-native half4 operator.z=(half4, half);
>-native half4 operator.w=(half4, half);
>-native float operator.x(float2);
>-native float operator.y(float2);
>-native float operator.x(float3);
>-native float operator.y(float3);
>-native float operator.z(float3);
>-native float operator.x(float4);
>-native float operator.y(float4);
>-native float operator.z(float4);
>-native float operator.w(float4);
>-native float2 operator.x=(float2, float);
>-native float2 operator.y=(float2, float);
>-native float3 operator.x=(float3, float);
>-native float3 operator.y=(float3, float);
>-native float3 operator.z=(float3, float);
>-native float4 operator.x=(float4, float);
>-native float4 operator.y=(float4, float);
>-native float4 operator.z=(float4, float);
>-native float4 operator.w=(float4, float);
>+/* Functions named reversebits */
>+uchar reversebits(uchar x) {
>+    return uchar(((x & uchar(1 << 0)) << 7) |
>+           ((x & uchar(1 << 1)) << 5) |
>+           ((x & uchar(1 << 2)) << 3) |
>+           ((x & uchar(1 << 3)) << 1) |
>+           ((x & uchar(1 << 4)) >> 1) |
>+           ((x & uchar(1 << 5)) >> 3) |
>+           ((x & uchar(1 << 6)) >> 5) |
>+           ((x & uchar(1 << 7)) >> 7));
>+}
>+ushort reversebits(ushort x) {
>+    return ushort(((x & ushort(1 << 0)) << 15) |
>+           ((x & ushort(1 << 1)) << 13) |
>+           ((x & ushort(1 << 2)) << 11) |
>+           ((x & ushort(1 << 3)) << 9) |
>+           ((x & ushort(1 << 4)) << 7) |
>+           ((x & ushort(1 << 5)) << 5) |
>+           ((x & ushort(1 << 6)) << 3) |
>+           ((x & ushort(1 << 7)) << 1) |
>+           ((x & ushort(1 << 8)) >> 1) |
>+           ((x & ushort(1 << 9)) >> 3) |
>+           ((x & ushort(1 << 10)) >> 5) |
>+           ((x & ushort(1 << 11)) >> 7) |
>+           ((x & ushort(1 << 12)) >> 9) |
>+           ((x & ushort(1 << 13)) >> 11) |
>+           ((x & ushort(1 << 14)) >> 13) |
>+           ((x & ushort(1 << 15)) >> 15));
>+}
>+uint reversebits(uint x) {
>+    return uint(((x & uint(1 << 0)) << 31) |
>+           ((x & uint(1 << 1)) << 29) |
>+           ((x & uint(1 << 2)) << 27) |
>+           ((x & uint(1 << 3)) << 25) |
>+           ((x & uint(1 << 4)) << 23) |
>+           ((x & uint(1 << 5)) << 21) |
>+           ((x & uint(1 << 6)) << 19) |
>+           ((x & uint(1 << 7)) << 17) |
>+           ((x & uint(1 << 8)) << 15) |
>+           ((x & uint(1 << 9)) << 13) |
>+           ((x & uint(1 << 10)) << 11) |
>+           ((x & uint(1 << 11)) << 9) |
>+           ((x & uint(1 << 12)) << 7) |
>+           ((x & uint(1 << 13)) << 5) |
>+           ((x & uint(1 << 14)) << 3) |
>+           ((x & uint(1 << 15)) << 1) |
>+           ((x & uint(1 << 16)) >> 1) |
>+           ((x & uint(1 << 17)) >> 3) |
>+           ((x & uint(1 << 18)) >> 5) |
>+           ((x & uint(1 << 19)) >> 7) |
>+           ((x & uint(1 << 20)) >> 9) |
>+           ((x & uint(1 << 21)) >> 11) |
>+           ((x & uint(1 << 22)) >> 13) |
>+           ((x & uint(1 << 23)) >> 15) |
>+           ((x & uint(1 << 24)) >> 17) |
>+           ((x & uint(1 << 25)) >> 19) |
>+           ((x & uint(1 << 26)) >> 21) |
>+           ((x & uint(1 << 27)) >> 23) |
>+           ((x & uint(1 << 28)) >> 25) |
>+           ((x & uint(1 << 29)) >> 27) |
>+           ((x & uint(1 << 30)) >> 29) |
>+           ((x & uint(1 << 31)) >> 31));
>+}
>+uchar2 reversebits(uchar2 x) {
>+    uchar2 result;
>+    result[0] = reversebits(x[0]);
>+    result[1] = reversebits(x[1]);
>+    return result;
>+}
>+uchar3 reversebits(uchar3 x) {
>+    uchar3 result;
>+    result[0] = reversebits(x[0]);
>+    result[1] = reversebits(x[1]);
>+    result[2] = reversebits(x[2]);
>+    return result;
>+}
>+uchar4 reversebits(uchar4 x) {
>+    uchar4 result;
>+    result[0] = reversebits(x[0]);
>+    result[1] = reversebits(x[1]);
>+    result[2] = reversebits(x[2]);
>+    result[3] = reversebits(x[3]);
>+    return result;
>+}
>+ushort2 reversebits(ushort2 x) {
>+    ushort2 result;
>+    result[0] = reversebits(x[0]);
>+    result[1] = reversebits(x[1]);
>+    return result;
>+}
>+ushort3 reversebits(ushort3 x) {
>+    ushort3 result;
>+    result[0] = reversebits(x[0]);
>+    result[1] = reversebits(x[1]);
>+    result[2] = reversebits(x[2]);
>+    return result;
>+}
>+ushort4 reversebits(ushort4 x) {
>+    ushort4 result;
>+    result[0] = reversebits(x[0]);
>+    result[1] = reversebits(x[1]);
>+    result[2] = reversebits(x[2]);
>+    result[3] = reversebits(x[3]);
>+    return result;
>+}
>+uint2 reversebits(uint2 x) {
>+    uint2 result;
>+    result[0] = reversebits(x[0]);
>+    result[1] = reversebits(x[1]);
>+    return result;
>+}
>+uint3 reversebits(uint3 x) {
>+    uint3 result;
>+    result[0] = reversebits(x[0]);
>+    result[1] = reversebits(x[1]);
>+    result[2] = reversebits(x[2]);
>+    return result;
>+}
>+uint4 reversebits(uint4 x) {
>+    uint4 result;
>+    result[0] = reversebits(x[0]);
>+    result[1] = reversebits(x[1]);
>+    result[2] = reversebits(x[2]);
>+    result[3] = reversebits(x[3]);
>+    return result;
>+}
> 
>-native float ddx(float);
>-native float ddy(float);
>-native void AllMemoryBarrierWithGroupSync();
>-native void DeviceMemoryBarrierWithGroupSync();
>-native void GroupMemoryBarrierWithGroupSync();
> 
>-operator float4(float x, float y, float z, float w) {
>-    float4 result;
>-    result.x = x;
>-    result.y = y;
>-    result.z = z;
>-    result.w = w;
>+/* Functions named operator.yww */
>+bool3 operator.yww(bool4 v) {
>+    bool3 result;
>+    result.x = v.y;
>+    result.y = v.w;
>+    result.z = v.w;
>     return result;
> }
>-
>-native float3 operator[](float2x3, uint);
>-native float2x3 operator[]=(float2x3, uint, float3);
>-float operator[](float3 v, uint index) {
>-    switch (index) {
>-        case 0:
>-            return v.x;
>-        case 1:
>-            return v.y;
>-        case 2:
>-            return v.z;
>-        default:
>-            break;
>-    }
>-    return 0.0;
>+uchar3 operator.yww(uchar4 v) {
>+    uchar3 result;
>+    result.x = v.y;
>+    result.y = v.w;
>+    result.z = v.w;
>+    return result;
> }
>-float3 operator[]=(float3 v, uint index, float a) {
>-    switch (index) {
>-        case 0:
>-            v.x = a;
>-            break;
>-        case 1:
>-            v.y = a;
>-            break;
>-        case 2:
>-            v.z = a;
>-            break;
>-        default:
>-            break;
>-    }
>-    return v;
>+ushort3 operator.yww(ushort4 v) {
>+    ushort3 result;
>+    result.x = v.y;
>+    result.y = v.w;
>+    result.z = v.w;
>+    return result;
> }
>-float2x3 operator+(float2x3 a, float2x3 b) {
>-    float2x3 result;
>-    result[0][0] = a[0][0] + b[0][0];
>-    result[0][1] = a[0][1] + b[0][1];
>-    result[0][2] = a[0][2] + b[0][2];
>-    result[1][0] = a[1][0] + b[1][0];
>-    result[1][1] = a[1][1] + b[1][1];
>-    result[1][2] = a[1][2] + b[1][2];
>+uint3 operator.yww(uint4 v) {
>+    uint3 result;
>+    result.x = v.y;
>+    result.y = v.w;
>+    result.z = v.w;
>     return result;
> }
>-float2x3 operator*(float2x3 a, float b) {
>-    float2x3 result;
>-    result[0][0] = a[0][0] * b;
>-    result[0][1] = a[0][1] * b;
>-    result[0][2] = a[0][2] * b;
>-    result[1][0] = a[1][0] * b;
>-    result[1][1] = a[1][1] * b;
>-    result[1][2] = a[1][2] * b;
>+char3 operator.yww(char4 v) {
>+    char3 result;
>+    result.x = v.y;
>+    result.y = v.w;
>+    result.z = v.w;
>     return result;
> }
>-float2x3 operator+(float2x3 a, float b) {
>-    float2x3 result;
>-    result[0][0] = a[0][0] + b;
>-    result[0][1] = a[0][1] + b;
>-    result[0][2] = a[0][2] + b;
>-    result[1][0] = a[1][0] + b;
>-    result[1][1] = a[1][1] + b;
>-    result[1][2] = a[1][2] + b;
>+short3 operator.yww(short4 v) {
>+    short3 result;
>+    result.x = v.y;
>+    result.y = v.w;
>+    result.z = v.w;
>     return result;
> }
>-float2x3 operator-(float2x3 a, float b) {
>-    float2x3 result;
>-    result[0][0] = a[0][0] - b;
>-    result[0][1] = a[0][1] - b;
>-    result[0][2] = a[0][2] - b;
>-    result[1][0] = a[1][0] - b;
>-    result[1][1] = a[1][1] - b;
>-    result[1][2] = a[1][2] - b;
>+int3 operator.yww(int4 v) {
>+    int3 result;
>+    result.x = v.y;
>+    result.y = v.w;
>+    result.z = v.w;
>     return result;
> }
>-
>-typedef float4x4 = matrix<float, 4, 4>;
>-native float4 operator[](float4x4, uint);
>-native float4x4 operator[]=(float4x4, uint, float4);
>-
>-float operator[](float4 v, uint index) {
>-    switch (index) {
>-        case 0:
>-            return v.x;
>-        case 1:
>-            return v.y;
>-        case 2:
>-            return v.z;
>-        case 3:
>-            return v.w;
>-        default:
>-            break;
>-    }
>-    float result;
>+half3 operator.yww(half4 v) {
>+    half3 result;
>+    result.x = v.y;
>+    result.y = v.w;
>+    result.z = v.w;
>     return result;
> }
>-
>-float4 operator[]=(float4 v, uint index, float a) {
>-    switch (index) {
>-        case 0:
>-            v.x = a;
>-            break;
>-        case 1:
>-            v.y = a;
>-            break;
>-        case 2:
>-            v.z = a;
>-            break;
>-        case 3:
>-            v.w = a;
>-            break;
>-        default:
>-            break;
>-    }
>-    return v;
>+float3 operator.yww(float4 v) {
>+    float3 result;
>+    result.x = v.y;
>+    result.y = v.w;
>+    result.z = v.w;
>+    return result;
> }
> 
>-float4 mul(float4x4 x, float4 y) {
>+/* Functions named operator.yzzy */
>+bool4 operator.yzzy(bool3 v) {
>+    bool4 result;
>+    result.x = v.y;
>+    result.y = v.z;
>+    result.z = v.z;
>+    result.w = v.y;
>+    return result;
>+}
>+bool4 operator.yzzy(bool4 v) {
>+    bool4 result;
>+    result.x = v.y;
>+    result.y = v.z;
>+    result.z = v.z;
>+    result.w = v.y;
>+    return result;
>+}
>+uchar4 operator.yzzy(uchar3 v) {
>+    uchar4 result;
>+    result.x = v.y;
>+    result.y = v.z;
>+    result.z = v.z;
>+    result.w = v.y;
>+    return result;
>+}
>+uchar4 operator.yzzy(uchar4 v) {
>+    uchar4 result;
>+    result.x = v.y;
>+    result.y = v.z;
>+    result.z = v.z;
>+    result.w = v.y;
>+    return result;
>+}
>+ushort4 operator.yzzy(ushort3 v) {
>+    ushort4 result;
>+    result.x = v.y;
>+    result.y = v.z;
>+    result.z = v.z;
>+    result.w = v.y;
>+    return result;
>+}
>+ushort4 operator.yzzy(ushort4 v) {
>+    ushort4 result;
>+    result.x = v.y;
>+    result.y = v.z;
>+    result.z = v.z;
>+    result.w = v.y;
>+    return result;
>+}
>+uint4 operator.yzzy(uint3 v) {
>+    uint4 result;
>+    result.x = v.y;
>+    result.y = v.z;
>+    result.z = v.z;
>+    result.w = v.y;
>+    return result;
>+}
>+uint4 operator.yzzy(uint4 v) {
>+    uint4 result;
>+    result.x = v.y;
>+    result.y = v.z;
>+    result.z = v.z;
>+    result.w = v.y;
>+    return result;
>+}
>+char4 operator.yzzy(char3 v) {
>+    char4 result;
>+    result.x = v.y;
>+    result.y = v.z;
>+    result.z = v.z;
>+    result.w = v.y;
>+    return result;
>+}
>+char4 operator.yzzy(char4 v) {
>+    char4 result;
>+    result.x = v.y;
>+    result.y = v.z;
>+    result.z = v.z;
>+    result.w = v.y;
>+    return result;
>+}
>+short4 operator.yzzy(short3 v) {
>+    short4 result;
>+    result.x = v.y;
>+    result.y = v.z;
>+    result.z = v.z;
>+    result.w = v.y;
>+    return result;
>+}
>+short4 operator.yzzy(short4 v) {
>+    short4 result;
>+    result.x = v.y;
>+    result.y = v.z;
>+    result.z = v.z;
>+    result.w = v.y;
>+    return result;
>+}
>+int4 operator.yzzy(int3 v) {
>+    int4 result;
>+    result.x = v.y;
>+    result.y = v.z;
>+    result.z = v.z;
>+    result.w = v.y;
>+    return result;
>+}
>+int4 operator.yzzy(int4 v) {
>+    int4 result;
>+    result.x = v.y;
>+    result.y = v.z;
>+    result.z = v.z;
>+    result.w = v.y;
>+    return result;
>+}
>+half4 operator.yzzy(half3 v) {
>+    half4 result;
>+    result.x = v.y;
>+    result.y = v.z;
>+    result.z = v.z;
>+    result.w = v.y;
>+    return result;
>+}
>+half4 operator.yzzy(half4 v) {
>+    half4 result;
>+    result.x = v.y;
>+    result.y = v.z;
>+    result.z = v.z;
>+    result.w = v.y;
>+    return result;
>+}
>+float4 operator.yzzy(float3 v) {
>     float4 result;
>-    result[0] = 0;
>-    result[0] += x[0][0] * y[0];
>-    result[0] += x[0][1] * y[1];
>-    result[0] += x[0][2] * y[2];
>-    result[0] += x[0][3] * y[3];
>-    result[1] = 0;
>-    result[1] += x[1][0] * y[0];
>-    result[1] += x[1][1] * y[1];
>-    result[1] += x[1][2] * y[2];
>-    result[1] += x[1][3] * y[3];
>-    result[2] = 0;
>-    result[2] += x[2][0] * y[0];
>-    result[2] += x[2][1] * y[1];
>-    result[2] += x[2][2] * y[2];
>-    result[2] += x[2][3] * y[3];
>-    result[3] = 0;
>-    result[3] += x[3][0] * y[0];
>-    result[3] += x[3][1] * y[1];
>-    result[3] += x[3][2] * y[2];
>-    result[3] += x[3][3] * y[3];
>+    result.x = v.y;
>+    result.y = v.z;
>+    result.z = v.z;
>+    result.w = v.y;
>     return result;
> }
>-
>-float4x4 mul(float4x4 x, float4x4 y) {
>-    float4x4 result;
>-    result[0][0] = 0;
>-    result[0][0] += x[0][0] * y[0][0];
>-    result[0][0] += x[0][1] * y[1][0];
>-    result[0][0] += x[0][2] * y[2][0];
>-    result[0][0] += x[0][3] * y[3][0];
>-    result[0][1] = 0;
>-    result[0][1] += x[0][0] * y[0][1];
>-    result[0][1] += x[0][1] * y[1][1];
>-    result[0][1] += x[0][2] * y[2][1];
>-    result[0][1] += x[0][3] * y[3][1];
>-    result[0][2] = 0;
>-    result[0][2] += x[0][0] * y[0][2];
>-    result[0][2] += x[0][1] * y[1][2];
>-    result[0][2] += x[0][2] * y[2][2];
>-    result[0][2] += x[0][3] * y[3][2];
>-    result[0][3] = 0;
>-    result[0][3] += x[0][0] * y[0][3];
>-    result[0][3] += x[0][1] * y[1][3];
>-    result[0][3] += x[0][2] * y[2][3];
>-    result[0][3] += x[0][3] * y[3][3];
>-    result[1][0] = 0;
>-    result[1][0] += x[1][0] * y[0][0];
>-    result[1][0] += x[1][1] * y[1][0];
>-    result[1][0] += x[1][2] * y[2][0];
>-    result[1][0] += x[1][3] * y[3][0];
>-    result[1][1] = 0;
>-    result[1][1] += x[1][0] * y[0][1];
>-    result[1][1] += x[1][1] * y[1][1];
>-    result[1][1] += x[1][2] * y[2][1];
>-    result[1][1] += x[1][3] * y[3][1];
>-    result[1][2] = 0;
>-    result[1][2] += x[1][0] * y[0][2];
>-    result[1][2] += x[1][1] * y[1][2];
>-    result[1][2] += x[1][2] * y[2][2];
>-    result[1][2] += x[1][3] * y[3][2];
>-    result[1][3] = 0;
>-    result[1][3] += x[1][0] * y[0][3];
>-    result[1][3] += x[1][1] * y[1][3];
>-    result[1][3] += x[1][2] * y[2][3];
>-    result[1][3] += x[1][3] * y[3][3];
>-    result[2][0] = 0;
>-    result[2][0] += x[2][0] * y[0][0];
>-    result[2][0] += x[2][1] * y[1][0];
>-    result[2][0] += x[2][2] * y[2][0];
>-    result[2][0] += x[2][3] * y[3][0];
>-    result[2][1] = 0;
>-    result[2][1] += x[2][0] * y[0][1];
>-    result[2][1] += x[2][1] * y[1][1];
>-    result[2][1] += x[2][2] * y[2][1];
>-    result[2][1] += x[2][3] * y[3][1];
>-    result[2][2] = 0;
>-    result[2][2] += x[2][0] * y[0][2];
>-    result[2][2] += x[2][1] * y[1][2];
>-    result[2][2] += x[2][2] * y[2][2];
>-    result[2][2] += x[2][3] * y[3][2];
>-    result[2][3] = 0;
>-    result[2][3] += x[2][0] * y[0][3];
>-    result[2][3] += x[2][1] * y[1][3];
>-    result[2][3] += x[2][2] * y[2][3];
>-    result[2][3] += x[2][3] * y[3][3];
>-    result[3][0] = 0;
>-    result[3][0] += x[3][0] * y[0][0];
>-    result[3][0] += x[3][1] * y[1][0];
>-    result[3][0] += x[3][2] * y[2][0];
>-    result[3][0] += x[3][3] * y[3][0];
>-    result[3][1] = 0;
>-    result[3][1] += x[3][0] * y[0][1];
>-    result[3][1] += x[3][1] * y[1][1];
>-    result[3][1] += x[3][2] * y[2][1];
>-    result[3][1] += x[3][3] * y[3][1];
>-    result[3][2] = 0;
>-    result[3][2] += x[3][0] * y[0][2];
>-    result[3][2] += x[3][1] * y[1][2];
>-    result[3][2] += x[3][2] * y[2][2];
>-    result[3][2] += x[3][3] * y[3][2];
>-    result[3][3] = 0;
>-    result[3][3] += x[3][0] * y[0][3];
>-    result[3][3] += x[3][1] * y[1][3];
>-    result[3][3] += x[3][2] * y[2][3];
>-    result[3][3] += x[3][3] * y[3][3];
>+float4 operator.yzzy(float4 v) {
>+    float4 result;
>+    result.x = v.y;
>+    result.y = v.z;
>+    result.z = v.z;
>+    result.w = v.y;
>     return result;
> }
> 
>-operator float2(float x, float y) {
>-    float2 result;
>-    result.x = x;
>-    result.y = y;
>+/* Functions named operator.zyxy */
>+bool4 operator.zyxy(bool3 v) {
>+    bool4 result;
>+    result.x = v.z;
>+    result.y = v.y;
>+    result.z = v.x;
>+    result.w = v.y;
>     return result;
> }
>-
>-operator int3(int x, int y, int z) {
>-    int3 result;
>-    result.x = x;
>-    result.y = y;
>-    result.z = z;
>+bool4 operator.zyxy(bool4 v) {
>+    bool4 result;
>+    result.x = v.z;
>+    result.y = v.y;
>+    result.z = v.x;
>+    result.w = v.y;
>     return result;
> }
>-
>-operator int2(int x, int y) {
>-    int2 result;
>-    result.x = x;
>-    result.y = y;
>+uchar4 operator.zyxy(uchar3 v) {
>+    uchar4 result;
>+    result.x = v.z;
>+    result.y = v.y;
>+    result.z = v.x;
>+    result.w = v.y;
>     return result;
> }
>-
>-operator uint2(uint x, uint y) {
>-    uint2 result;
>-    result.x = x;
>-    result.y = y;
>+uchar4 operator.zyxy(uchar4 v) {
>+    uchar4 result;
>+    result.x = v.z;
>+    result.y = v.y;
>+    result.z = v.x;
>+    result.w = v.y;
>+    return result;
>+}
>+ushort4 operator.zyxy(ushort3 v) {
>+    ushort4 result;
>+    result.x = v.z;
>+    result.y = v.y;
>+    result.z = v.x;
>+    result.w = v.y;
>+    return result;
>+}
>+ushort4 operator.zyxy(ushort4 v) {
>+    ushort4 result;
>+    result.x = v.z;
>+    result.y = v.y;
>+    result.z = v.x;
>+    result.w = v.y;
>+    return result;
>+}
>+uint4 operator.zyxy(uint3 v) {
>+    uint4 result;
>+    result.x = v.z;
>+    result.y = v.y;
>+    result.z = v.x;
>+    result.w = v.y;
>+    return result;
>+}
>+uint4 operator.zyxy(uint4 v) {
>+    uint4 result;
>+    result.x = v.z;
>+    result.y = v.y;
>+    result.z = v.x;
>+    result.w = v.y;
>+    return result;
>+}
>+char4 operator.zyxy(char3 v) {
>+    char4 result;
>+    result.x = v.z;
>+    result.y = v.y;
>+    result.z = v.x;
>+    result.w = v.y;
>+    return result;
>+}
>+char4 operator.zyxy(char4 v) {
>+    char4 result;
>+    result.x = v.z;
>+    result.y = v.y;
>+    result.z = v.x;
>+    result.w = v.y;
>+    return result;
>+}
>+short4 operator.zyxy(short3 v) {
>+    short4 result;
>+    result.x = v.z;
>+    result.y = v.y;
>+    result.z = v.x;
>+    result.w = v.y;
>+    return result;
>+}
>+short4 operator.zyxy(short4 v) {
>+    short4 result;
>+    result.x = v.z;
>+    result.y = v.y;
>+    result.z = v.x;
>+    result.w = v.y;
>+    return result;
>+}
>+int4 operator.zyxy(int3 v) {
>+    int4 result;
>+    result.x = v.z;
>+    result.y = v.y;
>+    result.z = v.x;
>+    result.w = v.y;
>+    return result;
>+}
>+int4 operator.zyxy(int4 v) {
>+    int4 result;
>+    result.x = v.z;
>+    result.y = v.y;
>+    result.z = v.x;
>+    result.w = v.y;
>+    return result;
>+}
>+half4 operator.zyxy(half3 v) {
>+    half4 result;
>+    result.x = v.z;
>+    result.y = v.y;
>+    result.z = v.x;
>+    result.w = v.y;
>+    return result;
>+}
>+half4 operator.zyxy(half4 v) {
>+    half4 result;
>+    result.x = v.z;
>+    result.y = v.y;
>+    result.z = v.x;
>+    result.w = v.y;
>+    return result;
>+}
>+float4 operator.zyxy(float3 v) {
>+    float4 result;
>+    result.x = v.z;
>+    result.y = v.y;
>+    result.z = v.x;
>+    result.w = v.y;
>+    return result;
>+}
>+float4 operator.zyxy(float4 v) {
>+    float4 result;
>+    result.x = v.z;
>+    result.y = v.y;
>+    result.z = v.x;
>+    result.w = v.y;
>     return result;
> }
> 
>-native int operator+(int, int);
>-native int operator-(int, int);
>-native int operator*(int, int);
>-native int operator/(int, int);
>-native bool operator==(int, int);
>-native bool operator<(int, int);
>-native bool operator<=(int, int);
>-native bool operator>(int, int);
>-native bool operator>=(int, int);
>-native uint operator+(uint, uint);
>-native uint operator-(uint, uint);
>-native uint operator*(uint, uint);
>-native uint operator/(uint, uint);
>-native bool operator==(uint, uint);
>-native bool operator<(uint, uint);
>-native bool operator<=(uint, uint);
>-native bool operator>(uint, uint);
>-native bool operator>=(uint, uint);
>-
>-native float operator+(float, float);
>-native float operator-(float, float);
>-native float operator*(float, float);
>-native float operator/(float, float);
>-native bool operator==(float, float);
>-native bool operator<(float, float);
>-native bool operator<=(float, float);
>-native bool operator>(float, float);
>-native bool operator>=(float, float);
>+/* Functions named operator.wxzy */
>+bool4 operator.wxzy(bool4 v) {
>+    bool4 result;
>+    result.x = v.w;
>+    result.y = v.x;
>+    result.z = v.z;
>+    result.w = v.y;
>+    return result;
>+}
>+uchar4 operator.wxzy(uchar4 v) {
>+    uchar4 result;
>+    result.x = v.w;
>+    result.y = v.x;
>+    result.z = v.z;
>+    result.w = v.y;
>+    return result;
>+}
>+ushort4 operator.wxzy(ushort4 v) {
>+    ushort4 result;
>+    result.x = v.w;
>+    result.y = v.x;
>+    result.z = v.z;
>+    result.w = v.y;
>+    return result;
>+}
>+uint4 operator.wxzy(uint4 v) {
>+    uint4 result;
>+    result.x = v.w;
>+    result.y = v.x;
>+    result.z = v.z;
>+    result.w = v.y;
>+    return result;
>+}
>+char4 operator.wxzy(char4 v) {
>+    char4 result;
>+    result.x = v.w;
>+    result.y = v.x;
>+    result.z = v.z;
>+    result.w = v.y;
>+    return result;
>+}
>+short4 operator.wxzy(short4 v) {
>+    short4 result;
>+    result.x = v.w;
>+    result.y = v.x;
>+    result.z = v.z;
>+    result.w = v.y;
>+    return result;
>+}
>+int4 operator.wxzy(int4 v) {
>+    int4 result;
>+    result.x = v.w;
>+    result.y = v.x;
>+    result.z = v.z;
>+    result.w = v.y;
>+    return result;
>+}
>+half4 operator.wxzy(half4 v) {
>+    half4 result;
>+    result.x = v.w;
>+    result.y = v.x;
>+    result.z = v.z;
>+    result.w = v.y;
>+    return result;
>+}
>+float4 operator.wxzy(float4 v) {
>+    float4 result;
>+    result.x = v.w;
>+    result.y = v.x;
>+    result.z = v.z;
>+    result.w = v.y;
>+    return result;
>+}
> 
>-native int operator&(int, int);
>-native int operator|(int, int);
>-native int operator^(int, int);
>-native int operator~(int);
>-native int operator<<(int, uint);
>-native int operator>>(int, uint);
>-native uint operator&(uint, uint);
>-native uint operator|(uint, uint);
>-native uint operator^(uint, uint);
>-native uint operator~(uint);
>-native uint operator<<(uint, uint);
>-native uint operator>>(uint, uint);
>+/* Functions named operator.yxxz */
>+bool4 operator.yxxz(bool3 v) {
>+    bool4 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.x;
>+    result.w = v.z;
>+    return result;
>+}
>+bool4 operator.yxxz(bool4 v) {
>+    bool4 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.x;
>+    result.w = v.z;
>+    return result;
>+}
>+uchar4 operator.yxxz(uchar3 v) {
>+    uchar4 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.x;
>+    result.w = v.z;
>+    return result;
>+}
>+uchar4 operator.yxxz(uchar4 v) {
>+    uchar4 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.x;
>+    result.w = v.z;
>+    return result;
>+}
>+ushort4 operator.yxxz(ushort3 v) {
>+    ushort4 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.x;
>+    result.w = v.z;
>+    return result;
>+}
>+ushort4 operator.yxxz(ushort4 v) {
>+    ushort4 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.x;
>+    result.w = v.z;
>+    return result;
>+}
>+uint4 operator.yxxz(uint3 v) {
>+    uint4 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.x;
>+    result.w = v.z;
>+    return result;
>+}
>+uint4 operator.yxxz(uint4 v) {
>+    uint4 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.x;
>+    result.w = v.z;
>+    return result;
>+}
>+char4 operator.yxxz(char3 v) {
>+    char4 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.x;
>+    result.w = v.z;
>+    return result;
>+}
>+char4 operator.yxxz(char4 v) {
>+    char4 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.x;
>+    result.w = v.z;
>+    return result;
>+}
>+short4 operator.yxxz(short3 v) {
>+    short4 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.x;
>+    result.w = v.z;
>+    return result;
>+}
>+short4 operator.yxxz(short4 v) {
>+    short4 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.x;
>+    result.w = v.z;
>+    return result;
>+}
>+int4 operator.yxxz(int3 v) {
>+    int4 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.x;
>+    result.w = v.z;
>+    return result;
>+}
>+int4 operator.yxxz(int4 v) {
>+    int4 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.x;
>+    result.w = v.z;
>+    return result;
>+}
>+half4 operator.yxxz(half3 v) {
>+    half4 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.x;
>+    result.w = v.z;
>+    return result;
>+}
>+half4 operator.yxxz(half4 v) {
>+    half4 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.x;
>+    result.w = v.z;
>+    return result;
>+}
>+float4 operator.yxxz(float3 v) {
>+    float4 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.x;
>+    result.w = v.z;
>+    return result;
>+}
>+float4 operator.yxxz(float4 v) {
>+    float4 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.x;
>+    result.w = v.z;
>+    return result;
>+}
> 
>-int operator++(int value) {
>-    return value + 1;
>+/* Functions named operator.zxwy= */
>+bool4 operator.zxwy=(bool4 v, bool4 c) {
>+    bool4 result = v;
>+    result.z = c.x;
>+    result.x = c.y;
>+    result.w = c.z;
>+    result.y = c.w;
>+    return result;
> }
>-int operator--(int value) {
>-    return value - 1;
>+uchar4 operator.zxwy=(uchar4 v, uchar4 c) {
>+    uchar4 result = v;
>+    result.z = c.x;
>+    result.x = c.y;
>+    result.w = c.z;
>+    result.y = c.w;
>+    return result;
> }
>-uint operator++(uint value) {
>-    return value + 1;
>+ushort4 operator.zxwy=(ushort4 v, ushort4 c) {
>+    ushort4 result = v;
>+    result.z = c.x;
>+    result.x = c.y;
>+    result.w = c.z;
>+    result.y = c.w;
>+    return result;
> }
>-uint operator--(uint value) {
>-    return value - 1;
>+uint4 operator.zxwy=(uint4 v, uint4 c) {
>+    uint4 result = v;
>+    result.z = c.x;
>+    result.x = c.y;
>+    result.w = c.z;
>+    result.y = c.w;
>+    return result;
>+}
>+char4 operator.zxwy=(char4 v, char4 c) {
>+    char4 result = v;
>+    result.z = c.x;
>+    result.x = c.y;
>+    result.w = c.z;
>+    result.y = c.w;
>+    return result;
>+}
>+short4 operator.zxwy=(short4 v, short4 c) {
>+    short4 result = v;
>+    result.z = c.x;
>+    result.x = c.y;
>+    result.w = c.z;
>+    result.y = c.w;
>+    return result;
>+}
>+int4 operator.zxwy=(int4 v, int4 c) {
>+    int4 result = v;
>+    result.z = c.x;
>+    result.x = c.y;
>+    result.w = c.z;
>+    result.y = c.w;
>+    return result;
>+}
>+half4 operator.zxwy=(half4 v, half4 c) {
>+    half4 result = v;
>+    result.z = c.x;
>+    result.x = c.y;
>+    result.w = c.z;
>+    result.y = c.w;
>+    return result;
>+}
>+float4 operator.zxwy=(float4 v, float4 c) {
>+    float4 result = v;
>+    result.z = c.x;
>+    result.x = c.y;
>+    result.w = c.z;
>+    result.y = c.w;
>+    return result;
> }
> 
>-native ushort Sample(Texture1D<ushort>, sampler, float location);
>-native ushort Sample(Texture1DArray<ushort>, sampler, float2 location);
>-native ushort Sample(Texture2D<ushort>, sampler, float2 location);
>-native ushort Sample(Texture2D<ushort>, sampler, float2 location, int2 offset);
>-native ushort Sample(Texture2DArray<ushort>, sampler, float3 location);
>-native ushort Sample(Texture2DArray<ushort>, sampler, float3 location, int2 offset);
>-native ushort Sample(Texture3D<ushort>, sampler, float3 location);
>-native ushort Sample(Texture3D<ushort>, sampler, float3 location, int3 offset);
>-native ushort Sample(TextureCube<ushort>, sampler, float3 location);
>-native ushort2 Sample(Texture1D<ushort2>, sampler, float location);
>-native ushort2 Sample(Texture1DArray<ushort2>, sampler, float2 location);
>-native ushort2 Sample(Texture2D<ushort2>, sampler, float2 location);
>-native ushort2 Sample(Texture2D<ushort2>, sampler, float2 location, int2 offset);
>-native ushort2 Sample(Texture2DArray<ushort2>, sampler, float3 location);
>-native ushort2 Sample(Texture2DArray<ushort2>, sampler, float3 location, int2 offset);
>-native ushort2 Sample(Texture3D<ushort2>, sampler, float3 location);
>-native ushort2 Sample(Texture3D<ushort2>, sampler, float3 location, int3 offset);
>-native ushort2 Sample(TextureCube<ushort2>, sampler, float3 location);
>-native ushort3 Sample(Texture1D<ushort3>, sampler, float location);
>-native ushort3 Sample(Texture1DArray<ushort3>, sampler, float2 location);
>-native ushort3 Sample(Texture2D<ushort3>, sampler, float2 location);
>-native ushort3 Sample(Texture2D<ushort3>, sampler, float2 location, int2 offset);
>-native ushort3 Sample(Texture2DArray<ushort3>, sampler, float3 location);
>-native ushort3 Sample(Texture2DArray<ushort3>, sampler, float3 location, int2 offset);
>-native ushort3 Sample(Texture3D<ushort3>, sampler, float3 location);
>-native ushort3 Sample(Texture3D<ushort3>, sampler, float3 location, int3 offset);
>-native ushort3 Sample(TextureCube<ushort3>, sampler, float3 location);
>-native ushort4 Sample(Texture1D<ushort4>, sampler, float location);
>-native ushort4 Sample(Texture1DArray<ushort4>, sampler, float2 location);
>-native ushort4 Sample(Texture2D<ushort4>, sampler, float2 location);
>-native ushort4 Sample(Texture2D<ushort4>, sampler, float2 location, int2 offset);
>-native ushort4 Sample(Texture2DArray<ushort4>, sampler, float3 location);
>-native ushort4 Sample(Texture2DArray<ushort4>, sampler, float3 location, int2 offset);
>-native ushort4 Sample(Texture3D<ushort4>, sampler, float3 location);
>-native ushort4 Sample(Texture3D<ushort4>, sampler, float3 location, int3 offset);
>-native ushort4 Sample(TextureCube<ushort4>, sampler, float3 location);
>-native uint Sample(Texture1D<uint>, sampler, float location);
>-native uint Sample(Texture1DArray<uint>, sampler, float2 location);
>-native uint Sample(Texture2D<uint>, sampler, float2 location);
>-native uint Sample(Texture2D<uint>, sampler, float2 location, int2 offset);
>-native uint Sample(Texture2DArray<uint>, sampler, float3 location);
>-native uint Sample(Texture2DArray<uint>, sampler, float3 location, int2 offset);
>-native uint Sample(Texture3D<uint>, sampler, float3 location);
>-native uint Sample(Texture3D<uint>, sampler, float3 location, int3 offset);
>-native uint Sample(TextureCube<uint>, sampler, float3 location);
>-native uint2 Sample(Texture1D<uint2>, sampler, float location);
>-native uint2 Sample(Texture1DArray<uint2>, sampler, float2 location);
>-native uint2 Sample(Texture2D<uint2>, sampler, float2 location);
>-native uint2 Sample(Texture2D<uint2>, sampler, float2 location, int2 offset);
>-native uint2 Sample(Texture2DArray<uint2>, sampler, float3 location);
>-native uint2 Sample(Texture2DArray<uint2>, sampler, float3 location, int2 offset);
>-native uint2 Sample(Texture3D<uint2>, sampler, float3 location);
>-native uint2 Sample(Texture3D<uint2>, sampler, float3 location, int3 offset);
>-native uint2 Sample(TextureCube<uint2>, sampler, float3 location);
>-native uint3 Sample(Texture1D<uint3>, sampler, float location);
>-native uint3 Sample(Texture1DArray<uint3>, sampler, float2 location);
>-native uint3 Sample(Texture2D<uint3>, sampler, float2 location);
>-native uint3 Sample(Texture2D<uint3>, sampler, float2 location, int2 offset);
>-native uint3 Sample(Texture2DArray<uint3>, sampler, float3 location);
>-native uint3 Sample(Texture2DArray<uint3>, sampler, float3 location, int2 offset);
>-native uint3 Sample(Texture3D<uint3>, sampler, float3 location);
>-native uint3 Sample(Texture3D<uint3>, sampler, float3 location, int3 offset);
>-native uint3 Sample(TextureCube<uint3>, sampler, float3 location);
>-native uint4 Sample(Texture1D<uint4>, sampler, float location);
>-native uint4 Sample(Texture1DArray<uint4>, sampler, float2 location);
>-native uint4 Sample(Texture2D<uint4>, sampler, float2 location);
>-native uint4 Sample(Texture2D<uint4>, sampler, float2 location, int2 offset);
>-native uint4 Sample(Texture2DArray<uint4>, sampler, float3 location);
>-native uint4 Sample(Texture2DArray<uint4>, sampler, float3 location, int2 offset);
>-native uint4 Sample(Texture3D<uint4>, sampler, float3 location);
>-native uint4 Sample(Texture3D<uint4>, sampler, float3 location, int3 offset);
>-native uint4 Sample(TextureCube<uint4>, sampler, float3 location);
>-native short Sample(Texture1D<short>, sampler, float location);
>-native short Sample(Texture1DArray<short>, sampler, float2 location);
>-native short Sample(Texture2D<short>, sampler, float2 location);
>-native short Sample(Texture2D<short>, sampler, float2 location, int2 offset);
>-native short Sample(Texture2DArray<short>, sampler, float3 location);
>-native short Sample(Texture2DArray<short>, sampler, float3 location, int2 offset);
>-native short Sample(Texture3D<short>, sampler, float3 location);
>-native short Sample(Texture3D<short>, sampler, float3 location, int3 offset);
>-native short Sample(TextureCube<short>, sampler, float3 location);
>-native short2 Sample(Texture1D<short2>, sampler, float location);
>-native short2 Sample(Texture1DArray<short2>, sampler, float2 location);
>-native short2 Sample(Texture2D<short2>, sampler, float2 location);
>-native short2 Sample(Texture2D<short2>, sampler, float2 location, int2 offset);
>-native short2 Sample(Texture2DArray<short2>, sampler, float3 location);
>-native short2 Sample(Texture2DArray<short2>, sampler, float3 location, int2 offset);
>-native short2 Sample(Texture3D<short2>, sampler, float3 location);
>-native short2 Sample(Texture3D<short2>, sampler, float3 location, int3 offset);
>-native short2 Sample(TextureCube<short2>, sampler, float3 location);
>-native short3 Sample(Texture1D<short3>, sampler, float location);
>-native short3 Sample(Texture1DArray<short3>, sampler, float2 location);
>-native short3 Sample(Texture2D<short3>, sampler, float2 location);
>-native short3 Sample(Texture2D<short3>, sampler, float2 location, int2 offset);
>-native short3 Sample(Texture2DArray<short3>, sampler, float3 location);
>-native short3 Sample(Texture2DArray<short3>, sampler, float3 location, int2 offset);
>-native short3 Sample(Texture3D<short3>, sampler, float3 location);
>-native short3 Sample(Texture3D<short3>, sampler, float3 location, int3 offset);
>-native short3 Sample(TextureCube<short3>, sampler, float3 location);
>-native short4 Sample(Texture1D<short4>, sampler, float location);
>-native short4 Sample(Texture1DArray<short4>, sampler, float2 location);
>-native short4 Sample(Texture2D<short4>, sampler, float2 location);
>-native short4 Sample(Texture2D<short4>, sampler, float2 location, int2 offset);
>-native short4 Sample(Texture2DArray<short4>, sampler, float3 location);
>-native short4 Sample(Texture2DArray<short4>, sampler, float3 location, int2 offset);
>-native short4 Sample(Texture3D<short4>, sampler, float3 location);
>-native short4 Sample(Texture3D<short4>, sampler, float3 location, int3 offset);
>-native short4 Sample(TextureCube<short4>, sampler, float3 location);
>-native int Sample(Texture1D<int>, sampler, float location);
>-native int Sample(Texture1DArray<int>, sampler, float2 location);
>-native int Sample(Texture2D<int>, sampler, float2 location);
>-native int Sample(Texture2D<int>, sampler, float2 location, int2 offset);
>-native int Sample(Texture2DArray<int>, sampler, float3 location);
>-native int Sample(Texture2DArray<int>, sampler, float3 location, int2 offset);
>-native int Sample(Texture3D<int>, sampler, float3 location);
>-native int Sample(Texture3D<int>, sampler, float3 location, int3 offset);
>-native int Sample(TextureCube<int>, sampler, float3 location);
>-native int2 Sample(Texture1D<int2>, sampler, float location);
>-native int2 Sample(Texture1DArray<int2>, sampler, float2 location);
>-native int2 Sample(Texture2D<int2>, sampler, float2 location);
>+/* Functions named operator.xwww */
>+bool4 operator.xwww(bool4 v) {
>+    bool4 result;
>+    result.x = v.x;
>+    result.y = v.w;
>+    result.z = v.w;
>+    result.w = v.w;
>+    return result;
>+}
>+uchar4 operator.xwww(uchar4 v) {
>+    uchar4 result;
>+    result.x = v.x;
>+    result.y = v.w;
>+    result.z = v.w;
>+    result.w = v.w;
>+    return result;
>+}
>+ushort4 operator.xwww(ushort4 v) {
>+    ushort4 result;
>+    result.x = v.x;
>+    result.y = v.w;
>+    result.z = v.w;
>+    result.w = v.w;
>+    return result;
>+}
>+uint4 operator.xwww(uint4 v) {
>+    uint4 result;
>+    result.x = v.x;
>+    result.y = v.w;
>+    result.z = v.w;
>+    result.w = v.w;
>+    return result;
>+}
>+char4 operator.xwww(char4 v) {
>+    char4 result;
>+    result.x = v.x;
>+    result.y = v.w;
>+    result.z = v.w;
>+    result.w = v.w;
>+    return result;
>+}
>+short4 operator.xwww(short4 v) {
>+    short4 result;
>+    result.x = v.x;
>+    result.y = v.w;
>+    result.z = v.w;
>+    result.w = v.w;
>+    return result;
>+}
>+int4 operator.xwww(int4 v) {
>+    int4 result;
>+    result.x = v.x;
>+    result.y = v.w;
>+    result.z = v.w;
>+    result.w = v.w;
>+    return result;
>+}
>+half4 operator.xwww(half4 v) {
>+    half4 result;
>+    result.x = v.x;
>+    result.y = v.w;
>+    result.z = v.w;
>+    result.w = v.w;
>+    return result;
>+}
>+float4 operator.xwww(float4 v) {
>+    float4 result;
>+    result.x = v.x;
>+    result.y = v.w;
>+    result.z = v.w;
>+    result.w = v.w;
>+    return result;
>+}
>+
>+/* Functions named operator.zwyz */
>+bool4 operator.zwyz(bool4 v) {
>+    bool4 result;
>+    result.x = v.z;
>+    result.y = v.w;
>+    result.z = v.y;
>+    result.w = v.z;
>+    return result;
>+}
>+uchar4 operator.zwyz(uchar4 v) {
>+    uchar4 result;
>+    result.x = v.z;
>+    result.y = v.w;
>+    result.z = v.y;
>+    result.w = v.z;
>+    return result;
>+}
>+ushort4 operator.zwyz(ushort4 v) {
>+    ushort4 result;
>+    result.x = v.z;
>+    result.y = v.w;
>+    result.z = v.y;
>+    result.w = v.z;
>+    return result;
>+}
>+uint4 operator.zwyz(uint4 v) {
>+    uint4 result;
>+    result.x = v.z;
>+    result.y = v.w;
>+    result.z = v.y;
>+    result.w = v.z;
>+    return result;
>+}
>+char4 operator.zwyz(char4 v) {
>+    char4 result;
>+    result.x = v.z;
>+    result.y = v.w;
>+    result.z = v.y;
>+    result.w = v.z;
>+    return result;
>+}
>+short4 operator.zwyz(short4 v) {
>+    short4 result;
>+    result.x = v.z;
>+    result.y = v.w;
>+    result.z = v.y;
>+    result.w = v.z;
>+    return result;
>+}
>+int4 operator.zwyz(int4 v) {
>+    int4 result;
>+    result.x = v.z;
>+    result.y = v.w;
>+    result.z = v.y;
>+    result.w = v.z;
>+    return result;
>+}
>+half4 operator.zwyz(half4 v) {
>+    half4 result;
>+    result.x = v.z;
>+    result.y = v.w;
>+    result.z = v.y;
>+    result.w = v.z;
>+    return result;
>+}
>+float4 operator.zwyz(float4 v) {
>+    float4 result;
>+    result.x = v.z;
>+    result.y = v.w;
>+    result.z = v.y;
>+    result.w = v.z;
>+    return result;
>+}
>+
>+/* Functions named isordered */
>+bool isordered(half x, half y) {
>+    return (x == x) && (y == y);
>+}
>+bool2 isordered(half2 x, half2 y) {
>+    bool2 result;
>+    result[0] = isordered(x[0], y[0]);
>+    result[1] = isordered(x[1], y[1]);
>+    return result;
>+}
>+bool3 isordered(half3 x, half3 y) {
>+    bool3 result;
>+    result[0] = isordered(x[0], y[0]);
>+    result[1] = isordered(x[1], y[1]);
>+    result[2] = isordered(x[2], y[2]);
>+    return result;
>+}
>+bool4 isordered(half4 x, half4 y) {
>+    bool4 result;
>+    result[0] = isordered(x[0], y[0]);
>+    result[1] = isordered(x[1], y[1]);
>+    result[2] = isordered(x[2], y[2]);
>+    result[3] = isordered(x[3], y[3]);
>+    return result;
>+}
>+bool isordered(float x, float y) {
>+    return (x == x) && (y == y);
>+}
>+bool2 isordered(float2 x, float2 y) {
>+    bool2 result;
>+    result[0] = isordered(x[0], y[0]);
>+    result[1] = isordered(x[1], y[1]);
>+    return result;
>+}
>+bool3 isordered(float3 x, float3 y) {
>+    bool3 result;
>+    result[0] = isordered(x[0], y[0]);
>+    result[1] = isordered(x[1], y[1]);
>+    result[2] = isordered(x[2], y[2]);
>+    return result;
>+}
>+bool4 isordered(float4 x, float4 y) {
>+    bool4 result;
>+    result[0] = isordered(x[0], y[0]);
>+    result[1] = isordered(x[1], y[1]);
>+    result[2] = isordered(x[2], y[2]);
>+    result[3] = isordered(x[3], y[3]);
>+    return result;
>+}
>+
>+/* Functions named operator.x */
>+native bool operator.x(bool2);
>+native bool operator.x(bool3);
>+native bool operator.x(bool4);
>+native uchar operator.x(uchar2);
>+native uchar operator.x(uchar3);
>+native uchar operator.x(uchar4);
>+native ushort operator.x(ushort2);
>+native ushort operator.x(ushort3);
>+native ushort operator.x(ushort4);
>+native uint operator.x(uint2);
>+native uint operator.x(uint3);
>+native uint operator.x(uint4);
>+native char operator.x(char2);
>+native char operator.x(char3);
>+native char operator.x(char4);
>+native short operator.x(short2);
>+native short operator.x(short3);
>+native short operator.x(short4);
>+native int operator.x(int2);
>+native int operator.x(int3);
>+native int operator.x(int4);
>+native half operator.x(half2);
>+native half operator.x(half3);
>+native half operator.x(half4);
>+native float operator.x(float2);
>+native float operator.x(float3);
>+native float operator.x(float4);
>+
>+/* Functions named operator.xywx */
>+bool4 operator.xywx(bool4 v) {
>+    bool4 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.w;
>+    result.w = v.x;
>+    return result;
>+}
>+uchar4 operator.xywx(uchar4 v) {
>+    uchar4 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.w;
>+    result.w = v.x;
>+    return result;
>+}
>+ushort4 operator.xywx(ushort4 v) {
>+    ushort4 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.w;
>+    result.w = v.x;
>+    return result;
>+}
>+uint4 operator.xywx(uint4 v) {
>+    uint4 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.w;
>+    result.w = v.x;
>+    return result;
>+}
>+char4 operator.xywx(char4 v) {
>+    char4 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.w;
>+    result.w = v.x;
>+    return result;
>+}
>+short4 operator.xywx(short4 v) {
>+    short4 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.w;
>+    result.w = v.x;
>+    return result;
>+}
>+int4 operator.xywx(int4 v) {
>+    int4 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.w;
>+    result.w = v.x;
>+    return result;
>+}
>+half4 operator.xywx(half4 v) {
>+    half4 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.w;
>+    result.w = v.x;
>+    return result;
>+}
>+float4 operator.xywx(float4 v) {
>+    float4 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.w;
>+    result.w = v.x;
>+    return result;
>+}
>+
>+/* Functions named operator.wyxy */
>+bool4 operator.wyxy(bool4 v) {
>+    bool4 result;
>+    result.x = v.w;
>+    result.y = v.y;
>+    result.z = v.x;
>+    result.w = v.y;
>+    return result;
>+}
>+uchar4 operator.wyxy(uchar4 v) {
>+    uchar4 result;
>+    result.x = v.w;
>+    result.y = v.y;
>+    result.z = v.x;
>+    result.w = v.y;
>+    return result;
>+}
>+ushort4 operator.wyxy(ushort4 v) {
>+    ushort4 result;
>+    result.x = v.w;
>+    result.y = v.y;
>+    result.z = v.x;
>+    result.w = v.y;
>+    return result;
>+}
>+uint4 operator.wyxy(uint4 v) {
>+    uint4 result;
>+    result.x = v.w;
>+    result.y = v.y;
>+    result.z = v.x;
>+    result.w = v.y;
>+    return result;
>+}
>+char4 operator.wyxy(char4 v) {
>+    char4 result;
>+    result.x = v.w;
>+    result.y = v.y;
>+    result.z = v.x;
>+    result.w = v.y;
>+    return result;
>+}
>+short4 operator.wyxy(short4 v) {
>+    short4 result;
>+    result.x = v.w;
>+    result.y = v.y;
>+    result.z = v.x;
>+    result.w = v.y;
>+    return result;
>+}
>+int4 operator.wyxy(int4 v) {
>+    int4 result;
>+    result.x = v.w;
>+    result.y = v.y;
>+    result.z = v.x;
>+    result.w = v.y;
>+    return result;
>+}
>+half4 operator.wyxy(half4 v) {
>+    half4 result;
>+    result.x = v.w;
>+    result.y = v.y;
>+    result.z = v.x;
>+    result.w = v.y;
>+    return result;
>+}
>+float4 operator.wyxy(float4 v) {
>+    float4 result;
>+    result.x = v.w;
>+    result.y = v.y;
>+    result.z = v.x;
>+    result.w = v.y;
>+    return result;
>+}
>+
>+/* Functions named transpose */
>+half transpose(half x) {
>+    return x;
>+}
>+half2x2 transpose(half2x2 x) {
>+    half2x2 result;
>+    result[0][0] = x[0][0];
>+    result[0][1] = x[1][0];
>+    result[1][0] = x[0][1];
>+    result[1][1] = x[1][1];
>+    return result;
>+}
>+half2x3 transpose(half3x2 x) {
>+    half2x3 result;
>+    result[0][0] = x[0][0];
>+    result[0][1] = x[1][0];
>+    result[0][2] = x[2][0];
>+    result[1][0] = x[0][1];
>+    result[1][1] = x[1][1];
>+    result[1][2] = x[2][1];
>+    return result;
>+}
>+half2x4 transpose(half4x2 x) {
>+    half2x4 result;
>+    result[0][0] = x[0][0];
>+    result[0][1] = x[1][0];
>+    result[0][2] = x[2][0];
>+    result[0][3] = x[3][0];
>+    result[1][0] = x[0][1];
>+    result[1][1] = x[1][1];
>+    result[1][2] = x[2][1];
>+    result[1][3] = x[3][1];
>+    return result;
>+}
>+half3x2 transpose(half2x3 x) {
>+    half3x2 result;
>+    result[0][0] = x[0][0];
>+    result[0][1] = x[1][0];
>+    result[1][0] = x[0][1];
>+    result[1][1] = x[1][1];
>+    result[2][0] = x[0][2];
>+    result[2][1] = x[1][2];
>+    return result;
>+}
>+half3x3 transpose(half3x3 x) {
>+    half3x3 result;
>+    result[0][0] = x[0][0];
>+    result[0][1] = x[1][0];
>+    result[0][2] = x[2][0];
>+    result[1][0] = x[0][1];
>+    result[1][1] = x[1][1];
>+    result[1][2] = x[2][1];
>+    result[2][0] = x[0][2];
>+    result[2][1] = x[1][2];
>+    result[2][2] = x[2][2];
>+    return result;
>+}
>+half3x4 transpose(half4x3 x) {
>+    half3x4 result;
>+    result[0][0] = x[0][0];
>+    result[0][1] = x[1][0];
>+    result[0][2] = x[2][0];
>+    result[0][3] = x[3][0];
>+    result[1][0] = x[0][1];
>+    result[1][1] = x[1][1];
>+    result[1][2] = x[2][1];
>+    result[1][3] = x[3][1];
>+    result[2][0] = x[0][2];
>+    result[2][1] = x[1][2];
>+    result[2][2] = x[2][2];
>+    result[2][3] = x[3][2];
>+    return result;
>+}
>+half4x2 transpose(half2x4 x) {
>+    half4x2 result;
>+    result[0][0] = x[0][0];
>+    result[0][1] = x[1][0];
>+    result[1][0] = x[0][1];
>+    result[1][1] = x[1][1];
>+    result[2][0] = x[0][2];
>+    result[2][1] = x[1][2];
>+    result[3][0] = x[0][3];
>+    result[3][1] = x[1][3];
>+    return result;
>+}
>+half4x3 transpose(half3x4 x) {
>+    half4x3 result;
>+    result[0][0] = x[0][0];
>+    result[0][1] = x[1][0];
>+    result[0][2] = x[2][0];
>+    result[1][0] = x[0][1];
>+    result[1][1] = x[1][1];
>+    result[1][2] = x[2][1];
>+    result[2][0] = x[0][2];
>+    result[2][1] = x[1][2];
>+    result[2][2] = x[2][2];
>+    result[3][0] = x[0][3];
>+    result[3][1] = x[1][3];
>+    result[3][2] = x[2][3];
>+    return result;
>+}
>+half4x4 transpose(half4x4 x) {
>+    half4x4 result;
>+    result[0][0] = x[0][0];
>+    result[0][1] = x[1][0];
>+    result[0][2] = x[2][0];
>+    result[0][3] = x[3][0];
>+    result[1][0] = x[0][1];
>+    result[1][1] = x[1][1];
>+    result[1][2] = x[2][1];
>+    result[1][3] = x[3][1];
>+    result[2][0] = x[0][2];
>+    result[2][1] = x[1][2];
>+    result[2][2] = x[2][2];
>+    result[2][3] = x[3][2];
>+    result[3][0] = x[0][3];
>+    result[3][1] = x[1][3];
>+    result[3][2] = x[2][3];
>+    result[3][3] = x[3][3];
>+    return result;
>+}
>+float transpose(float x) {
>+    return x;
>+}
>+float2x2 transpose(float2x2 x) {
>+    float2x2 result;
>+    result[0][0] = x[0][0];
>+    result[0][1] = x[1][0];
>+    result[1][0] = x[0][1];
>+    result[1][1] = x[1][1];
>+    return result;
>+}
>+float2x3 transpose(float3x2 x) {
>+    float2x3 result;
>+    result[0][0] = x[0][0];
>+    result[0][1] = x[1][0];
>+    result[0][2] = x[2][0];
>+    result[1][0] = x[0][1];
>+    result[1][1] = x[1][1];
>+    result[1][2] = x[2][1];
>+    return result;
>+}
>+float2x4 transpose(float4x2 x) {
>+    float2x4 result;
>+    result[0][0] = x[0][0];
>+    result[0][1] = x[1][0];
>+    result[0][2] = x[2][0];
>+    result[0][3] = x[3][0];
>+    result[1][0] = x[0][1];
>+    result[1][1] = x[1][1];
>+    result[1][2] = x[2][1];
>+    result[1][3] = x[3][1];
>+    return result;
>+}
>+float3x2 transpose(float2x3 x) {
>+    float3x2 result;
>+    result[0][0] = x[0][0];
>+    result[0][1] = x[1][0];
>+    result[1][0] = x[0][1];
>+    result[1][1] = x[1][1];
>+    result[2][0] = x[0][2];
>+    result[2][1] = x[1][2];
>+    return result;
>+}
>+float3x3 transpose(float3x3 x) {
>+    float3x3 result;
>+    result[0][0] = x[0][0];
>+    result[0][1] = x[1][0];
>+    result[0][2] = x[2][0];
>+    result[1][0] = x[0][1];
>+    result[1][1] = x[1][1];
>+    result[1][2] = x[2][1];
>+    result[2][0] = x[0][2];
>+    result[2][1] = x[1][2];
>+    result[2][2] = x[2][2];
>+    return result;
>+}
>+float3x4 transpose(float4x3 x) {
>+    float3x4 result;
>+    result[0][0] = x[0][0];
>+    result[0][1] = x[1][0];
>+    result[0][2] = x[2][0];
>+    result[0][3] = x[3][0];
>+    result[1][0] = x[0][1];
>+    result[1][1] = x[1][1];
>+    result[1][2] = x[2][1];
>+    result[1][3] = x[3][1];
>+    result[2][0] = x[0][2];
>+    result[2][1] = x[1][2];
>+    result[2][2] = x[2][2];
>+    result[2][3] = x[3][2];
>+    return result;
>+}
>+float4x2 transpose(float2x4 x) {
>+    float4x2 result;
>+    result[0][0] = x[0][0];
>+    result[0][1] = x[1][0];
>+    result[1][0] = x[0][1];
>+    result[1][1] = x[1][1];
>+    result[2][0] = x[0][2];
>+    result[2][1] = x[1][2];
>+    result[3][0] = x[0][3];
>+    result[3][1] = x[1][3];
>+    return result;
>+}
>+float4x3 transpose(float3x4 x) {
>+    float4x3 result;
>+    result[0][0] = x[0][0];
>+    result[0][1] = x[1][0];
>+    result[0][2] = x[2][0];
>+    result[1][0] = x[0][1];
>+    result[1][1] = x[1][1];
>+    result[1][2] = x[2][1];
>+    result[2][0] = x[0][2];
>+    result[2][1] = x[1][2];
>+    result[2][2] = x[2][2];
>+    result[3][0] = x[0][3];
>+    result[3][1] = x[1][3];
>+    result[3][2] = x[2][3];
>+    return result;
>+}
>+float4x4 transpose(float4x4 x) {
>+    float4x4 result;
>+    result[0][0] = x[0][0];
>+    result[0][1] = x[1][0];
>+    result[0][2] = x[2][0];
>+    result[0][3] = x[3][0];
>+    result[1][0] = x[0][1];
>+    result[1][1] = x[1][1];
>+    result[1][2] = x[2][1];
>+    result[1][3] = x[3][1];
>+    result[2][0] = x[0][2];
>+    result[2][1] = x[1][2];
>+    result[2][2] = x[2][2];
>+    result[2][3] = x[3][2];
>+    result[3][0] = x[0][3];
>+    result[3][1] = x[1][3];
>+    result[3][2] = x[2][3];
>+    result[3][3] = x[3][3];
>+    return result;
>+}
>+
>+
>+/* Functions named operator.wyxz= */
>+bool4 operator.wyxz=(bool4 v, bool4 c) {
>+    bool4 result = v;
>+    result.w = c.x;
>+    result.y = c.y;
>+    result.x = c.z;
>+    result.z = c.w;
>+    return result;
>+}
>+uchar4 operator.wyxz=(uchar4 v, uchar4 c) {
>+    uchar4 result = v;
>+    result.w = c.x;
>+    result.y = c.y;
>+    result.x = c.z;
>+    result.z = c.w;
>+    return result;
>+}
>+ushort4 operator.wyxz=(ushort4 v, ushort4 c) {
>+    ushort4 result = v;
>+    result.w = c.x;
>+    result.y = c.y;
>+    result.x = c.z;
>+    result.z = c.w;
>+    return result;
>+}
>+uint4 operator.wyxz=(uint4 v, uint4 c) {
>+    uint4 result = v;
>+    result.w = c.x;
>+    result.y = c.y;
>+    result.x = c.z;
>+    result.z = c.w;
>+    return result;
>+}
>+char4 operator.wyxz=(char4 v, char4 c) {
>+    char4 result = v;
>+    result.w = c.x;
>+    result.y = c.y;
>+    result.x = c.z;
>+    result.z = c.w;
>+    return result;
>+}
>+short4 operator.wyxz=(short4 v, short4 c) {
>+    short4 result = v;
>+    result.w = c.x;
>+    result.y = c.y;
>+    result.x = c.z;
>+    result.z = c.w;
>+    return result;
>+}
>+int4 operator.wyxz=(int4 v, int4 c) {
>+    int4 result = v;
>+    result.w = c.x;
>+    result.y = c.y;
>+    result.x = c.z;
>+    result.z = c.w;
>+    return result;
>+}
>+half4 operator.wyxz=(half4 v, half4 c) {
>+    half4 result = v;
>+    result.w = c.x;
>+    result.y = c.y;
>+    result.x = c.z;
>+    result.z = c.w;
>+    return result;
>+}
>+float4 operator.wyxz=(float4 v, float4 c) {
>+    float4 result = v;
>+    result.w = c.x;
>+    result.y = c.y;
>+    result.x = c.z;
>+    result.z = c.w;
>+    return result;
>+}
>+
>+/* Functions named operator.yyxz */
>+bool4 operator.yyxz(bool3 v) {
>+    bool4 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.x;
>+    result.w = v.z;
>+    return result;
>+}
>+bool4 operator.yyxz(bool4 v) {
>+    bool4 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.x;
>+    result.w = v.z;
>+    return result;
>+}
>+uchar4 operator.yyxz(uchar3 v) {
>+    uchar4 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.x;
>+    result.w = v.z;
>+    return result;
>+}
>+uchar4 operator.yyxz(uchar4 v) {
>+    uchar4 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.x;
>+    result.w = v.z;
>+    return result;
>+}
>+ushort4 operator.yyxz(ushort3 v) {
>+    ushort4 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.x;
>+    result.w = v.z;
>+    return result;
>+}
>+ushort4 operator.yyxz(ushort4 v) {
>+    ushort4 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.x;
>+    result.w = v.z;
>+    return result;
>+}
>+uint4 operator.yyxz(uint3 v) {
>+    uint4 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.x;
>+    result.w = v.z;
>+    return result;
>+}
>+uint4 operator.yyxz(uint4 v) {
>+    uint4 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.x;
>+    result.w = v.z;
>+    return result;
>+}
>+char4 operator.yyxz(char3 v) {
>+    char4 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.x;
>+    result.w = v.z;
>+    return result;
>+}
>+char4 operator.yyxz(char4 v) {
>+    char4 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.x;
>+    result.w = v.z;
>+    return result;
>+}
>+short4 operator.yyxz(short3 v) {
>+    short4 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.x;
>+    result.w = v.z;
>+    return result;
>+}
>+short4 operator.yyxz(short4 v) {
>+    short4 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.x;
>+    result.w = v.z;
>+    return result;
>+}
>+int4 operator.yyxz(int3 v) {
>+    int4 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.x;
>+    result.w = v.z;
>+    return result;
>+}
>+int4 operator.yyxz(int4 v) {
>+    int4 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.x;
>+    result.w = v.z;
>+    return result;
>+}
>+half4 operator.yyxz(half3 v) {
>+    half4 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.x;
>+    result.w = v.z;
>+    return result;
>+}
>+half4 operator.yyxz(half4 v) {
>+    half4 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.x;
>+    result.w = v.z;
>+    return result;
>+}
>+float4 operator.yyxz(float3 v) {
>+    float4 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.x;
>+    result.w = v.z;
>+    return result;
>+}
>+float4 operator.yyxz(float4 v) {
>+    float4 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.x;
>+    result.w = v.z;
>+    return result;
>+}
>+
>+/* Functions named operator.zx */
>+bool2 operator.zx(bool3 v) {
>+    bool2 result;
>+    result.x = v.z;
>+    result.y = v.x;
>+    return result;
>+}
>+bool2 operator.zx(bool4 v) {
>+    bool2 result;
>+    result.x = v.z;
>+    result.y = v.x;
>+    return result;
>+}
>+uchar2 operator.zx(uchar3 v) {
>+    uchar2 result;
>+    result.x = v.z;
>+    result.y = v.x;
>+    return result;
>+}
>+uchar2 operator.zx(uchar4 v) {
>+    uchar2 result;
>+    result.x = v.z;
>+    result.y = v.x;
>+    return result;
>+}
>+ushort2 operator.zx(ushort3 v) {
>+    ushort2 result;
>+    result.x = v.z;
>+    result.y = v.x;
>+    return result;
>+}
>+ushort2 operator.zx(ushort4 v) {
>+    ushort2 result;
>+    result.x = v.z;
>+    result.y = v.x;
>+    return result;
>+}
>+uint2 operator.zx(uint3 v) {
>+    uint2 result;
>+    result.x = v.z;
>+    result.y = v.x;
>+    return result;
>+}
>+uint2 operator.zx(uint4 v) {
>+    uint2 result;
>+    result.x = v.z;
>+    result.y = v.x;
>+    return result;
>+}
>+char2 operator.zx(char3 v) {
>+    char2 result;
>+    result.x = v.z;
>+    result.y = v.x;
>+    return result;
>+}
>+char2 operator.zx(char4 v) {
>+    char2 result;
>+    result.x = v.z;
>+    result.y = v.x;
>+    return result;
>+}
>+short2 operator.zx(short3 v) {
>+    short2 result;
>+    result.x = v.z;
>+    result.y = v.x;
>+    return result;
>+}
>+short2 operator.zx(short4 v) {
>+    short2 result;
>+    result.x = v.z;
>+    result.y = v.x;
>+    return result;
>+}
>+int2 operator.zx(int3 v) {
>+    int2 result;
>+    result.x = v.z;
>+    result.y = v.x;
>+    return result;
>+}
>+int2 operator.zx(int4 v) {
>+    int2 result;
>+    result.x = v.z;
>+    result.y = v.x;
>+    return result;
>+}
>+half2 operator.zx(half3 v) {
>+    half2 result;
>+    result.x = v.z;
>+    result.y = v.x;
>+    return result;
>+}
>+half2 operator.zx(half4 v) {
>+    half2 result;
>+    result.x = v.z;
>+    result.y = v.x;
>+    return result;
>+}
>+float2 operator.zx(float3 v) {
>+    float2 result;
>+    result.x = v.z;
>+    result.y = v.x;
>+    return result;
>+}
>+float2 operator.zx(float4 v) {
>+    float2 result;
>+    result.x = v.z;
>+    result.y = v.x;
>+    return result;
>+}
>+
>+/* Functions named InterlockedAdd */
>+native void InterlockedAdd(device atomic_uint*, uint, thread uint*);
>+native void InterlockedAdd(device atomic_int*, int, thread int*);
>+native void InterlockedAdd(device atomic_uint*, uint, device uint*);
>+native void InterlockedAdd(device atomic_int*, int, device int*);
>+native void InterlockedAdd(device atomic_uint*, uint, threadgroup uint*);
>+native void InterlockedAdd(device atomic_int*, int, threadgroup int*);
>+native void InterlockedAdd(threadgroup atomic_uint*, uint, thread uint*);
>+native void InterlockedAdd(threadgroup atomic_int*, int, thread int*);
>+native void InterlockedAdd(threadgroup atomic_uint*, uint, device uint*);
>+native void InterlockedAdd(threadgroup atomic_int*, int, device int*);
>+native void InterlockedAdd(threadgroup atomic_uint*, uint, threadgroup uint*);
>+native void InterlockedAdd(threadgroup atomic_int*, int, threadgroup int*);
>+
>+/* Functions named operator.xzyx */
>+bool4 operator.xzyx(bool3 v) {
>+    bool4 result;
>+    result.x = v.x;
>+    result.y = v.z;
>+    result.z = v.y;
>+    result.w = v.x;
>+    return result;
>+}
>+bool4 operator.xzyx(bool4 v) {
>+    bool4 result;
>+    result.x = v.x;
>+    result.y = v.z;
>+    result.z = v.y;
>+    result.w = v.x;
>+    return result;
>+}
>+uchar4 operator.xzyx(uchar3 v) {
>+    uchar4 result;
>+    result.x = v.x;
>+    result.y = v.z;
>+    result.z = v.y;
>+    result.w = v.x;
>+    return result;
>+}
>+uchar4 operator.xzyx(uchar4 v) {
>+    uchar4 result;
>+    result.x = v.x;
>+    result.y = v.z;
>+    result.z = v.y;
>+    result.w = v.x;
>+    return result;
>+}
>+ushort4 operator.xzyx(ushort3 v) {
>+    ushort4 result;
>+    result.x = v.x;
>+    result.y = v.z;
>+    result.z = v.y;
>+    result.w = v.x;
>+    return result;
>+}
>+ushort4 operator.xzyx(ushort4 v) {
>+    ushort4 result;
>+    result.x = v.x;
>+    result.y = v.z;
>+    result.z = v.y;
>+    result.w = v.x;
>+    return result;
>+}
>+uint4 operator.xzyx(uint3 v) {
>+    uint4 result;
>+    result.x = v.x;
>+    result.y = v.z;
>+    result.z = v.y;
>+    result.w = v.x;
>+    return result;
>+}
>+uint4 operator.xzyx(uint4 v) {
>+    uint4 result;
>+    result.x = v.x;
>+    result.y = v.z;
>+    result.z = v.y;
>+    result.w = v.x;
>+    return result;
>+}
>+char4 operator.xzyx(char3 v) {
>+    char4 result;
>+    result.x = v.x;
>+    result.y = v.z;
>+    result.z = v.y;
>+    result.w = v.x;
>+    return result;
>+}
>+char4 operator.xzyx(char4 v) {
>+    char4 result;
>+    result.x = v.x;
>+    result.y = v.z;
>+    result.z = v.y;
>+    result.w = v.x;
>+    return result;
>+}
>+short4 operator.xzyx(short3 v) {
>+    short4 result;
>+    result.x = v.x;
>+    result.y = v.z;
>+    result.z = v.y;
>+    result.w = v.x;
>+    return result;
>+}
>+short4 operator.xzyx(short4 v) {
>+    short4 result;
>+    result.x = v.x;
>+    result.y = v.z;
>+    result.z = v.y;
>+    result.w = v.x;
>+    return result;
>+}
>+int4 operator.xzyx(int3 v) {
>+    int4 result;
>+    result.x = v.x;
>+    result.y = v.z;
>+    result.z = v.y;
>+    result.w = v.x;
>+    return result;
>+}
>+int4 operator.xzyx(int4 v) {
>+    int4 result;
>+    result.x = v.x;
>+    result.y = v.z;
>+    result.z = v.y;
>+    result.w = v.x;
>+    return result;
>+}
>+half4 operator.xzyx(half3 v) {
>+    half4 result;
>+    result.x = v.x;
>+    result.y = v.z;
>+    result.z = v.y;
>+    result.w = v.x;
>+    return result;
>+}
>+half4 operator.xzyx(half4 v) {
>+    half4 result;
>+    result.x = v.x;
>+    result.y = v.z;
>+    result.z = v.y;
>+    result.w = v.x;
>+    return result;
>+}
>+float4 operator.xzyx(float3 v) {
>+    float4 result;
>+    result.x = v.x;
>+    result.y = v.z;
>+    result.z = v.y;
>+    result.w = v.x;
>+    return result;
>+}
>+float4 operator.xzyx(float4 v) {
>+    float4 result;
>+    result.x = v.x;
>+    result.y = v.z;
>+    result.z = v.y;
>+    result.w = v.x;
>+    return result;
>+}
>+
>+/* Functions named operator.wwzw */
>+bool4 operator.wwzw(bool4 v) {
>+    bool4 result;
>+    result.x = v.w;
>+    result.y = v.w;
>+    result.z = v.z;
>+    result.w = v.w;
>+    return result;
>+}
>+uchar4 operator.wwzw(uchar4 v) {
>+    uchar4 result;
>+    result.x = v.w;
>+    result.y = v.w;
>+    result.z = v.z;
>+    result.w = v.w;
>+    return result;
>+}
>+ushort4 operator.wwzw(ushort4 v) {
>+    ushort4 result;
>+    result.x = v.w;
>+    result.y = v.w;
>+    result.z = v.z;
>+    result.w = v.w;
>+    return result;
>+}
>+uint4 operator.wwzw(uint4 v) {
>+    uint4 result;
>+    result.x = v.w;
>+    result.y = v.w;
>+    result.z = v.z;
>+    result.w = v.w;
>+    return result;
>+}
>+char4 operator.wwzw(char4 v) {
>+    char4 result;
>+    result.x = v.w;
>+    result.y = v.w;
>+    result.z = v.z;
>+    result.w = v.w;
>+    return result;
>+}
>+short4 operator.wwzw(short4 v) {
>+    short4 result;
>+    result.x = v.w;
>+    result.y = v.w;
>+    result.z = v.z;
>+    result.w = v.w;
>+    return result;
>+}
>+int4 operator.wwzw(int4 v) {
>+    int4 result;
>+    result.x = v.w;
>+    result.y = v.w;
>+    result.z = v.z;
>+    result.w = v.w;
>+    return result;
>+}
>+half4 operator.wwzw(half4 v) {
>+    half4 result;
>+    result.x = v.w;
>+    result.y = v.w;
>+    result.z = v.z;
>+    result.w = v.w;
>+    return result;
>+}
>+float4 operator.wwzw(float4 v) {
>+    float4 result;
>+    result.x = v.w;
>+    result.y = v.w;
>+    result.z = v.z;
>+    result.w = v.w;
>+    return result;
>+}
>+
>+/* Functions named operator.ywwy */
>+bool4 operator.ywwy(bool4 v) {
>+    bool4 result;
>+    result.x = v.y;
>+    result.y = v.w;
>+    result.z = v.w;
>+    result.w = v.y;
>+    return result;
>+}
>+uchar4 operator.ywwy(uchar4 v) {
>+    uchar4 result;
>+    result.x = v.y;
>+    result.y = v.w;
>+    result.z = v.w;
>+    result.w = v.y;
>+    return result;
>+}
>+ushort4 operator.ywwy(ushort4 v) {
>+    ushort4 result;
>+    result.x = v.y;
>+    result.y = v.w;
>+    result.z = v.w;
>+    result.w = v.y;
>+    return result;
>+}
>+uint4 operator.ywwy(uint4 v) {
>+    uint4 result;
>+    result.x = v.y;
>+    result.y = v.w;
>+    result.z = v.w;
>+    result.w = v.y;
>+    return result;
>+}
>+char4 operator.ywwy(char4 v) {
>+    char4 result;
>+    result.x = v.y;
>+    result.y = v.w;
>+    result.z = v.w;
>+    result.w = v.y;
>+    return result;
>+}
>+short4 operator.ywwy(short4 v) {
>+    short4 result;
>+    result.x = v.y;
>+    result.y = v.w;
>+    result.z = v.w;
>+    result.w = v.y;
>+    return result;
>+}
>+int4 operator.ywwy(int4 v) {
>+    int4 result;
>+    result.x = v.y;
>+    result.y = v.w;
>+    result.z = v.w;
>+    result.w = v.y;
>+    return result;
>+}
>+half4 operator.ywwy(half4 v) {
>+    half4 result;
>+    result.x = v.y;
>+    result.y = v.w;
>+    result.z = v.w;
>+    result.w = v.y;
>+    return result;
>+}
>+float4 operator.ywwy(float4 v) {
>+    float4 result;
>+    result.x = v.y;
>+    result.y = v.w;
>+    result.z = v.w;
>+    result.w = v.y;
>+    return result;
>+}
>+
>+/* Functions named operator.xzwx */
>+bool4 operator.xzwx(bool4 v) {
>+    bool4 result;
>+    result.x = v.x;
>+    result.y = v.z;
>+    result.z = v.w;
>+    result.w = v.x;
>+    return result;
>+}
>+uchar4 operator.xzwx(uchar4 v) {
>+    uchar4 result;
>+    result.x = v.x;
>+    result.y = v.z;
>+    result.z = v.w;
>+    result.w = v.x;
>+    return result;
>+}
>+ushort4 operator.xzwx(ushort4 v) {
>+    ushort4 result;
>+    result.x = v.x;
>+    result.y = v.z;
>+    result.z = v.w;
>+    result.w = v.x;
>+    return result;
>+}
>+uint4 operator.xzwx(uint4 v) {
>+    uint4 result;
>+    result.x = v.x;
>+    result.y = v.z;
>+    result.z = v.w;
>+    result.w = v.x;
>+    return result;
>+}
>+char4 operator.xzwx(char4 v) {
>+    char4 result;
>+    result.x = v.x;
>+    result.y = v.z;
>+    result.z = v.w;
>+    result.w = v.x;
>+    return result;
>+}
>+short4 operator.xzwx(short4 v) {
>+    short4 result;
>+    result.x = v.x;
>+    result.y = v.z;
>+    result.z = v.w;
>+    result.w = v.x;
>+    return result;
>+}
>+int4 operator.xzwx(int4 v) {
>+    int4 result;
>+    result.x = v.x;
>+    result.y = v.z;
>+    result.z = v.w;
>+    result.w = v.x;
>+    return result;
>+}
>+half4 operator.xzwx(half4 v) {
>+    half4 result;
>+    result.x = v.x;
>+    result.y = v.z;
>+    result.z = v.w;
>+    result.w = v.x;
>+    return result;
>+}
>+float4 operator.xzwx(float4 v) {
>+    float4 result;
>+    result.x = v.x;
>+    result.y = v.z;
>+    result.z = v.w;
>+    result.w = v.x;
>+    return result;
>+}
>+
>+/* Functions named saturate */
>+half saturate(half x) {
>+    return clamp(x, 0, 1);
>+}
>+half2 saturate(half2 x) {
>+    half2 result;
>+    result[0] = saturate(x[0]);
>+    result[1] = saturate(x[1]);
>+    return result;
>+}
>+half3 saturate(half3 x) {
>+    half3 result;
>+    result[0] = saturate(x[0]);
>+    result[1] = saturate(x[1]);
>+    result[2] = saturate(x[2]);
>+    return result;
>+}
>+half4 saturate(half4 x) {
>+    half4 result;
>+    result[0] = saturate(x[0]);
>+    result[1] = saturate(x[1]);
>+    result[2] = saturate(x[2]);
>+    result[3] = saturate(x[3]);
>+    return result;
>+}
>+half2x2 saturate(half2x2 x) {
>+    half2x2 result;
>+    result[0][0] = saturate(x[0][0]);
>+    result[0][1] = saturate(x[0][1]);
>+    result[1][0] = saturate(x[1][0]);
>+    result[1][1] = saturate(x[1][1]);
>+    return result;
>+}
>+half2x3 saturate(half2x3 x) {
>+    half2x3 result;
>+    result[0][0] = saturate(x[0][0]);
>+    result[0][1] = saturate(x[0][1]);
>+    result[0][2] = saturate(x[0][2]);
>+    result[1][0] = saturate(x[1][0]);
>+    result[1][1] = saturate(x[1][1]);
>+    result[1][2] = saturate(x[1][2]);
>+    return result;
>+}
>+half2x4 saturate(half2x4 x) {
>+    half2x4 result;
>+    result[0][0] = saturate(x[0][0]);
>+    result[0][1] = saturate(x[0][1]);
>+    result[0][2] = saturate(x[0][2]);
>+    result[0][3] = saturate(x[0][3]);
>+    result[1][0] = saturate(x[1][0]);
>+    result[1][1] = saturate(x[1][1]);
>+    result[1][2] = saturate(x[1][2]);
>+    result[1][3] = saturate(x[1][3]);
>+    return result;
>+}
>+half3x2 saturate(half3x2 x) {
>+    half3x2 result;
>+    result[0][0] = saturate(x[0][0]);
>+    result[0][1] = saturate(x[0][1]);
>+    result[1][0] = saturate(x[1][0]);
>+    result[1][1] = saturate(x[1][1]);
>+    result[2][0] = saturate(x[2][0]);
>+    result[2][1] = saturate(x[2][1]);
>+    return result;
>+}
>+half3x3 saturate(half3x3 x) {
>+    half3x3 result;
>+    result[0][0] = saturate(x[0][0]);
>+    result[0][1] = saturate(x[0][1]);
>+    result[0][2] = saturate(x[0][2]);
>+    result[1][0] = saturate(x[1][0]);
>+    result[1][1] = saturate(x[1][1]);
>+    result[1][2] = saturate(x[1][2]);
>+    result[2][0] = saturate(x[2][0]);
>+    result[2][1] = saturate(x[2][1]);
>+    result[2][2] = saturate(x[2][2]);
>+    return result;
>+}
>+half3x4 saturate(half3x4 x) {
>+    half3x4 result;
>+    result[0][0] = saturate(x[0][0]);
>+    result[0][1] = saturate(x[0][1]);
>+    result[0][2] = saturate(x[0][2]);
>+    result[0][3] = saturate(x[0][3]);
>+    result[1][0] = saturate(x[1][0]);
>+    result[1][1] = saturate(x[1][1]);
>+    result[1][2] = saturate(x[1][2]);
>+    result[1][3] = saturate(x[1][3]);
>+    result[2][0] = saturate(x[2][0]);
>+    result[2][1] = saturate(x[2][1]);
>+    result[2][2] = saturate(x[2][2]);
>+    result[2][3] = saturate(x[2][3]);
>+    return result;
>+}
>+half4x2 saturate(half4x2 x) {
>+    half4x2 result;
>+    result[0][0] = saturate(x[0][0]);
>+    result[0][1] = saturate(x[0][1]);
>+    result[1][0] = saturate(x[1][0]);
>+    result[1][1] = saturate(x[1][1]);
>+    result[2][0] = saturate(x[2][0]);
>+    result[2][1] = saturate(x[2][1]);
>+    result[3][0] = saturate(x[3][0]);
>+    result[3][1] = saturate(x[3][1]);
>+    return result;
>+}
>+half4x3 saturate(half4x3 x) {
>+    half4x3 result;
>+    result[0][0] = saturate(x[0][0]);
>+    result[0][1] = saturate(x[0][1]);
>+    result[0][2] = saturate(x[0][2]);
>+    result[1][0] = saturate(x[1][0]);
>+    result[1][1] = saturate(x[1][1]);
>+    result[1][2] = saturate(x[1][2]);
>+    result[2][0] = saturate(x[2][0]);
>+    result[2][1] = saturate(x[2][1]);
>+    result[2][2] = saturate(x[2][2]);
>+    result[3][0] = saturate(x[3][0]);
>+    result[3][1] = saturate(x[3][1]);
>+    result[3][2] = saturate(x[3][2]);
>+    return result;
>+}
>+half4x4 saturate(half4x4 x) {
>+    half4x4 result;
>+    result[0][0] = saturate(x[0][0]);
>+    result[0][1] = saturate(x[0][1]);
>+    result[0][2] = saturate(x[0][2]);
>+    result[0][3] = saturate(x[0][3]);
>+    result[1][0] = saturate(x[1][0]);
>+    result[1][1] = saturate(x[1][1]);
>+    result[1][2] = saturate(x[1][2]);
>+    result[1][3] = saturate(x[1][3]);
>+    result[2][0] = saturate(x[2][0]);
>+    result[2][1] = saturate(x[2][1]);
>+    result[2][2] = saturate(x[2][2]);
>+    result[2][3] = saturate(x[2][3]);
>+    result[3][0] = saturate(x[3][0]);
>+    result[3][1] = saturate(x[3][1]);
>+    result[3][2] = saturate(x[3][2]);
>+    result[3][3] = saturate(x[3][3]);
>+    return result;
>+}
>+float saturate(float x) {
>+    return clamp(x, 0, 1);
>+}
>+float2 saturate(float2 x) {
>+    float2 result;
>+    result[0] = saturate(x[0]);
>+    result[1] = saturate(x[1]);
>+    return result;
>+}
>+float3 saturate(float3 x) {
>+    float3 result;
>+    result[0] = saturate(x[0]);
>+    result[1] = saturate(x[1]);
>+    result[2] = saturate(x[2]);
>+    return result;
>+}
>+float4 saturate(float4 x) {
>+    float4 result;
>+    result[0] = saturate(x[0]);
>+    result[1] = saturate(x[1]);
>+    result[2] = saturate(x[2]);
>+    result[3] = saturate(x[3]);
>+    return result;
>+}
>+float2x2 saturate(float2x2 x) {
>+    float2x2 result;
>+    result[0][0] = saturate(x[0][0]);
>+    result[0][1] = saturate(x[0][1]);
>+    result[1][0] = saturate(x[1][0]);
>+    result[1][1] = saturate(x[1][1]);
>+    return result;
>+}
>+float2x3 saturate(float2x3 x) {
>+    float2x3 result;
>+    result[0][0] = saturate(x[0][0]);
>+    result[0][1] = saturate(x[0][1]);
>+    result[0][2] = saturate(x[0][2]);
>+    result[1][0] = saturate(x[1][0]);
>+    result[1][1] = saturate(x[1][1]);
>+    result[1][2] = saturate(x[1][2]);
>+    return result;
>+}
>+float2x4 saturate(float2x4 x) {
>+    float2x4 result;
>+    result[0][0] = saturate(x[0][0]);
>+    result[0][1] = saturate(x[0][1]);
>+    result[0][2] = saturate(x[0][2]);
>+    result[0][3] = saturate(x[0][3]);
>+    result[1][0] = saturate(x[1][0]);
>+    result[1][1] = saturate(x[1][1]);
>+    result[1][2] = saturate(x[1][2]);
>+    result[1][3] = saturate(x[1][3]);
>+    return result;
>+}
>+float3x2 saturate(float3x2 x) {
>+    float3x2 result;
>+    result[0][0] = saturate(x[0][0]);
>+    result[0][1] = saturate(x[0][1]);
>+    result[1][0] = saturate(x[1][0]);
>+    result[1][1] = saturate(x[1][1]);
>+    result[2][0] = saturate(x[2][0]);
>+    result[2][1] = saturate(x[2][1]);
>+    return result;
>+}
>+float3x3 saturate(float3x3 x) {
>+    float3x3 result;
>+    result[0][0] = saturate(x[0][0]);
>+    result[0][1] = saturate(x[0][1]);
>+    result[0][2] = saturate(x[0][2]);
>+    result[1][0] = saturate(x[1][0]);
>+    result[1][1] = saturate(x[1][1]);
>+    result[1][2] = saturate(x[1][2]);
>+    result[2][0] = saturate(x[2][0]);
>+    result[2][1] = saturate(x[2][1]);
>+    result[2][2] = saturate(x[2][2]);
>+    return result;
>+}
>+float3x4 saturate(float3x4 x) {
>+    float3x4 result;
>+    result[0][0] = saturate(x[0][0]);
>+    result[0][1] = saturate(x[0][1]);
>+    result[0][2] = saturate(x[0][2]);
>+    result[0][3] = saturate(x[0][3]);
>+    result[1][0] = saturate(x[1][0]);
>+    result[1][1] = saturate(x[1][1]);
>+    result[1][2] = saturate(x[1][2]);
>+    result[1][3] = saturate(x[1][3]);
>+    result[2][0] = saturate(x[2][0]);
>+    result[2][1] = saturate(x[2][1]);
>+    result[2][2] = saturate(x[2][2]);
>+    result[2][3] = saturate(x[2][3]);
>+    return result;
>+}
>+float4x2 saturate(float4x2 x) {
>+    float4x2 result;
>+    result[0][0] = saturate(x[0][0]);
>+    result[0][1] = saturate(x[0][1]);
>+    result[1][0] = saturate(x[1][0]);
>+    result[1][1] = saturate(x[1][1]);
>+    result[2][0] = saturate(x[2][0]);
>+    result[2][1] = saturate(x[2][1]);
>+    result[3][0] = saturate(x[3][0]);
>+    result[3][1] = saturate(x[3][1]);
>+    return result;
>+}
>+float4x3 saturate(float4x3 x) {
>+    float4x3 result;
>+    result[0][0] = saturate(x[0][0]);
>+    result[0][1] = saturate(x[0][1]);
>+    result[0][2] = saturate(x[0][2]);
>+    result[1][0] = saturate(x[1][0]);
>+    result[1][1] = saturate(x[1][1]);
>+    result[1][2] = saturate(x[1][2]);
>+    result[2][0] = saturate(x[2][0]);
>+    result[2][1] = saturate(x[2][1]);
>+    result[2][2] = saturate(x[2][2]);
>+    result[3][0] = saturate(x[3][0]);
>+    result[3][1] = saturate(x[3][1]);
>+    result[3][2] = saturate(x[3][2]);
>+    return result;
>+}
>+float4x4 saturate(float4x4 x) {
>+    float4x4 result;
>+    result[0][0] = saturate(x[0][0]);
>+    result[0][1] = saturate(x[0][1]);
>+    result[0][2] = saturate(x[0][2]);
>+    result[0][3] = saturate(x[0][3]);
>+    result[1][0] = saturate(x[1][0]);
>+    result[1][1] = saturate(x[1][1]);
>+    result[1][2] = saturate(x[1][2]);
>+    result[1][3] = saturate(x[1][3]);
>+    result[2][0] = saturate(x[2][0]);
>+    result[2][1] = saturate(x[2][1]);
>+    result[2][2] = saturate(x[2][2]);
>+    result[2][3] = saturate(x[2][3]);
>+    result[3][0] = saturate(x[3][0]);
>+    result[3][1] = saturate(x[3][1]);
>+    result[3][2] = saturate(x[3][2]);
>+    result[3][3] = saturate(x[3][3]);
>+    return result;
>+}
>+
>+/* Functions named mad */
>+half mad(half x, half y, half z) {
>+    return x * y + z;
>+}
>+half2 mad(half2 x, half2 y, half2 z) {
>+    half2 result;
>+    result[0] = mad(x[0], y[0], z[0]);
>+    result[1] = mad(x[1], y[1], z[1]);
>+    return result;
>+}
>+half3 mad(half3 x, half3 y, half3 z) {
>+    half3 result;
>+    result[0] = mad(x[0], y[0], z[0]);
>+    result[1] = mad(x[1], y[1], z[1]);
>+    result[2] = mad(x[2], y[2], z[2]);
>+    return result;
>+}
>+half4 mad(half4 x, half4 y, half4 z) {
>+    half4 result;
>+    result[0] = mad(x[0], y[0], z[0]);
>+    result[1] = mad(x[1], y[1], z[1]);
>+    result[2] = mad(x[2], y[2], z[2]);
>+    result[3] = mad(x[3], y[3], z[3]);
>+    return result;
>+}
>+half2x2 mad(half2x2 x, half2x2 y, half2x2 z) {
>+    half2x2 result;
>+    result[0][0] = mad(x[0][0], y[0][0], z[0][0]);
>+    result[0][1] = mad(x[0][1], y[0][1], z[0][1]);
>+    result[1][0] = mad(x[1][0], y[1][0], z[1][0]);
>+    result[1][1] = mad(x[1][1], y[1][1], z[1][1]);
>+    return result;
>+}
>+half2x3 mad(half2x3 x, half2x3 y, half2x3 z) {
>+    half2x3 result;
>+    result[0][0] = mad(x[0][0], y[0][0], z[0][0]);
>+    result[0][1] = mad(x[0][1], y[0][1], z[0][1]);
>+    result[0][2] = mad(x[0][2], y[0][2], z[0][2]);
>+    result[1][0] = mad(x[1][0], y[1][0], z[1][0]);
>+    result[1][1] = mad(x[1][1], y[1][1], z[1][1]);
>+    result[1][2] = mad(x[1][2], y[1][2], z[1][2]);
>+    return result;
>+}
>+half2x4 mad(half2x4 x, half2x4 y, half2x4 z) {
>+    half2x4 result;
>+    result[0][0] = mad(x[0][0], y[0][0], z[0][0]);
>+    result[0][1] = mad(x[0][1], y[0][1], z[0][1]);
>+    result[0][2] = mad(x[0][2], y[0][2], z[0][2]);
>+    result[0][3] = mad(x[0][3], y[0][3], z[0][3]);
>+    result[1][0] = mad(x[1][0], y[1][0], z[1][0]);
>+    result[1][1] = mad(x[1][1], y[1][1], z[1][1]);
>+    result[1][2] = mad(x[1][2], y[1][2], z[1][2]);
>+    result[1][3] = mad(x[1][3], y[1][3], z[1][3]);
>+    return result;
>+}
>+half3x2 mad(half3x2 x, half3x2 y, half3x2 z) {
>+    half3x2 result;
>+    result[0][0] = mad(x[0][0], y[0][0], z[0][0]);
>+    result[0][1] = mad(x[0][1], y[0][1], z[0][1]);
>+    result[1][0] = mad(x[1][0], y[1][0], z[1][0]);
>+    result[1][1] = mad(x[1][1], y[1][1], z[1][1]);
>+    result[2][0] = mad(x[2][0], y[2][0], z[2][0]);
>+    result[2][1] = mad(x[2][1], y[2][1], z[2][1]);
>+    return result;
>+}
>+half3x3 mad(half3x3 x, half3x3 y, half3x3 z) {
>+    half3x3 result;
>+    result[0][0] = mad(x[0][0], y[0][0], z[0][0]);
>+    result[0][1] = mad(x[0][1], y[0][1], z[0][1]);
>+    result[0][2] = mad(x[0][2], y[0][2], z[0][2]);
>+    result[1][0] = mad(x[1][0], y[1][0], z[1][0]);
>+    result[1][1] = mad(x[1][1], y[1][1], z[1][1]);
>+    result[1][2] = mad(x[1][2], y[1][2], z[1][2]);
>+    result[2][0] = mad(x[2][0], y[2][0], z[2][0]);
>+    result[2][1] = mad(x[2][1], y[2][1], z[2][1]);
>+    result[2][2] = mad(x[2][2], y[2][2], z[2][2]);
>+    return result;
>+}
>+half3x4 mad(half3x4 x, half3x4 y, half3x4 z) {
>+    half3x4 result;
>+    result[0][0] = mad(x[0][0], y[0][0], z[0][0]);
>+    result[0][1] = mad(x[0][1], y[0][1], z[0][1]);
>+    result[0][2] = mad(x[0][2], y[0][2], z[0][2]);
>+    result[0][3] = mad(x[0][3], y[0][3], z[0][3]);
>+    result[1][0] = mad(x[1][0], y[1][0], z[1][0]);
>+    result[1][1] = mad(x[1][1], y[1][1], z[1][1]);
>+    result[1][2] = mad(x[1][2], y[1][2], z[1][2]);
>+    result[1][3] = mad(x[1][3], y[1][3], z[1][3]);
>+    result[2][0] = mad(x[2][0], y[2][0], z[2][0]);
>+    result[2][1] = mad(x[2][1], y[2][1], z[2][1]);
>+    result[2][2] = mad(x[2][2], y[2][2], z[2][2]);
>+    result[2][3] = mad(x[2][3], y[2][3], z[2][3]);
>+    return result;
>+}
>+half4x2 mad(half4x2 x, half4x2 y, half4x2 z) {
>+    half4x2 result;
>+    result[0][0] = mad(x[0][0], y[0][0], z[0][0]);
>+    result[0][1] = mad(x[0][1], y[0][1], z[0][1]);
>+    result[1][0] = mad(x[1][0], y[1][0], z[1][0]);
>+    result[1][1] = mad(x[1][1], y[1][1], z[1][1]);
>+    result[2][0] = mad(x[2][0], y[2][0], z[2][0]);
>+    result[2][1] = mad(x[2][1], y[2][1], z[2][1]);
>+    result[3][0] = mad(x[3][0], y[3][0], z[3][0]);
>+    result[3][1] = mad(x[3][1], y[3][1], z[3][1]);
>+    return result;
>+}
>+half4x3 mad(half4x3 x, half4x3 y, half4x3 z) {
>+    half4x3 result;
>+    result[0][0] = mad(x[0][0], y[0][0], z[0][0]);
>+    result[0][1] = mad(x[0][1], y[0][1], z[0][1]);
>+    result[0][2] = mad(x[0][2], y[0][2], z[0][2]);
>+    result[1][0] = mad(x[1][0], y[1][0], z[1][0]);
>+    result[1][1] = mad(x[1][1], y[1][1], z[1][1]);
>+    result[1][2] = mad(x[1][2], y[1][2], z[1][2]);
>+    result[2][0] = mad(x[2][0], y[2][0], z[2][0]);
>+    result[2][1] = mad(x[2][1], y[2][1], z[2][1]);
>+    result[2][2] = mad(x[2][2], y[2][2], z[2][2]);
>+    result[3][0] = mad(x[3][0], y[3][0], z[3][0]);
>+    result[3][1] = mad(x[3][1], y[3][1], z[3][1]);
>+    result[3][2] = mad(x[3][2], y[3][2], z[3][2]);
>+    return result;
>+}
>+half4x4 mad(half4x4 x, half4x4 y, half4x4 z) {
>+    half4x4 result;
>+    result[0][0] = mad(x[0][0], y[0][0], z[0][0]);
>+    result[0][1] = mad(x[0][1], y[0][1], z[0][1]);
>+    result[0][2] = mad(x[0][2], y[0][2], z[0][2]);
>+    result[0][3] = mad(x[0][3], y[0][3], z[0][3]);
>+    result[1][0] = mad(x[1][0], y[1][0], z[1][0]);
>+    result[1][1] = mad(x[1][1], y[1][1], z[1][1]);
>+    result[1][2] = mad(x[1][2], y[1][2], z[1][2]);
>+    result[1][3] = mad(x[1][3], y[1][3], z[1][3]);
>+    result[2][0] = mad(x[2][0], y[2][0], z[2][0]);
>+    result[2][1] = mad(x[2][1], y[2][1], z[2][1]);
>+    result[2][2] = mad(x[2][2], y[2][2], z[2][2]);
>+    result[2][3] = mad(x[2][3], y[2][3], z[2][3]);
>+    result[3][0] = mad(x[3][0], y[3][0], z[3][0]);
>+    result[3][1] = mad(x[3][1], y[3][1], z[3][1]);
>+    result[3][2] = mad(x[3][2], y[3][2], z[3][2]);
>+    result[3][3] = mad(x[3][3], y[3][3], z[3][3]);
>+    return result;
>+}
>+
>+float mad(float x, float y, float z) {
>+    return x * y + z;
>+}
>+float2 mad(float2 x, float2 y, float2 z) {
>+    float2 result;
>+    result[0] = mad(x[0], y[0], z[0]);
>+    result[1] = mad(x[1], y[1], z[1]);
>+    return result;
>+}
>+float3 mad(float3 x, float3 y, float3 z) {
>+    float3 result;
>+    result[0] = mad(x[0], y[0], z[0]);
>+    result[1] = mad(x[1], y[1], z[1]);
>+    result[2] = mad(x[2], y[2], z[2]);
>+    return result;
>+}
>+float4 mad(float4 x, float4 y, float4 z) {
>+    float4 result;
>+    result[0] = mad(x[0], y[0], z[0]);
>+    result[1] = mad(x[1], y[1], z[1]);
>+    result[2] = mad(x[2], y[2], z[2]);
>+    result[3] = mad(x[3], y[3], z[3]);
>+    return result;
>+}
>+float2x2 mad(float2x2 x, float2x2 y, float2x2 z) {
>+    float2x2 result;
>+    result[0][0] = mad(x[0][0], y[0][0], z[0][0]);
>+    result[0][1] = mad(x[0][1], y[0][1], z[0][1]);
>+    result[1][0] = mad(x[1][0], y[1][0], z[1][0]);
>+    result[1][1] = mad(x[1][1], y[1][1], z[1][1]);
>+    return result;
>+}
>+float2x3 mad(float2x3 x, float2x3 y, float2x3 z) {
>+    float2x3 result;
>+    result[0][0] = mad(x[0][0], y[0][0], z[0][0]);
>+    result[0][1] = mad(x[0][1], y[0][1], z[0][1]);
>+    result[0][2] = mad(x[0][2], y[0][2], z[0][2]);
>+    result[1][0] = mad(x[1][0], y[1][0], z[1][0]);
>+    result[1][1] = mad(x[1][1], y[1][1], z[1][1]);
>+    result[1][2] = mad(x[1][2], y[1][2], z[1][2]);
>+    return result;
>+}
>+float2x4 mad(float2x4 x, float2x4 y, float2x4 z) {
>+    float2x4 result;
>+    result[0][0] = mad(x[0][0], y[0][0], z[0][0]);
>+    result[0][1] = mad(x[0][1], y[0][1], z[0][1]);
>+    result[0][2] = mad(x[0][2], y[0][2], z[0][2]);
>+    result[0][3] = mad(x[0][3], y[0][3], z[0][3]);
>+    result[1][0] = mad(x[1][0], y[1][0], z[1][0]);
>+    result[1][1] = mad(x[1][1], y[1][1], z[1][1]);
>+    result[1][2] = mad(x[1][2], y[1][2], z[1][2]);
>+    result[1][3] = mad(x[1][3], y[1][3], z[1][3]);
>+    return result;
>+}
>+float3x2 mad(float3x2 x, float3x2 y, float3x2 z) {
>+    float3x2 result;
>+    result[0][0] = mad(x[0][0], y[0][0], z[0][0]);
>+    result[0][1] = mad(x[0][1], y[0][1], z[0][1]);
>+    result[1][0] = mad(x[1][0], y[1][0], z[1][0]);
>+    result[1][1] = mad(x[1][1], y[1][1], z[1][1]);
>+    result[2][0] = mad(x[2][0], y[2][0], z[2][0]);
>+    result[2][1] = mad(x[2][1], y[2][1], z[2][1]);
>+    return result;
>+}
>+float3x3 mad(float3x3 x, float3x3 y, float3x3 z) {
>+    float3x3 result;
>+    result[0][0] = mad(x[0][0], y[0][0], z[0][0]);
>+    result[0][1] = mad(x[0][1], y[0][1], z[0][1]);
>+    result[0][2] = mad(x[0][2], y[0][2], z[0][2]);
>+    result[1][0] = mad(x[1][0], y[1][0], z[1][0]);
>+    result[1][1] = mad(x[1][1], y[1][1], z[1][1]);
>+    result[1][2] = mad(x[1][2], y[1][2], z[1][2]);
>+    result[2][0] = mad(x[2][0], y[2][0], z[2][0]);
>+    result[2][1] = mad(x[2][1], y[2][1], z[2][1]);
>+    result[2][2] = mad(x[2][2], y[2][2], z[2][2]);
>+    return result;
>+}
>+float3x4 mad(float3x4 x, float3x4 y, float3x4 z) {
>+    float3x4 result;
>+    result[0][0] = mad(x[0][0], y[0][0], z[0][0]);
>+    result[0][1] = mad(x[0][1], y[0][1], z[0][1]);
>+    result[0][2] = mad(x[0][2], y[0][2], z[0][2]);
>+    result[0][3] = mad(x[0][3], y[0][3], z[0][3]);
>+    result[1][0] = mad(x[1][0], y[1][0], z[1][0]);
>+    result[1][1] = mad(x[1][1], y[1][1], z[1][1]);
>+    result[1][2] = mad(x[1][2], y[1][2], z[1][2]);
>+    result[1][3] = mad(x[1][3], y[1][3], z[1][3]);
>+    result[2][0] = mad(x[2][0], y[2][0], z[2][0]);
>+    result[2][1] = mad(x[2][1], y[2][1], z[2][1]);
>+    result[2][2] = mad(x[2][2], y[2][2], z[2][2]);
>+    result[2][3] = mad(x[2][3], y[2][3], z[2][3]);
>+    return result;
>+}
>+float4x2 mad(float4x2 x, float4x2 y, float4x2 z) {
>+    float4x2 result;
>+    result[0][0] = mad(x[0][0], y[0][0], z[0][0]);
>+    result[0][1] = mad(x[0][1], y[0][1], z[0][1]);
>+    result[1][0] = mad(x[1][0], y[1][0], z[1][0]);
>+    result[1][1] = mad(x[1][1], y[1][1], z[1][1]);
>+    result[2][0] = mad(x[2][0], y[2][0], z[2][0]);
>+    result[2][1] = mad(x[2][1], y[2][1], z[2][1]);
>+    result[3][0] = mad(x[3][0], y[3][0], z[3][0]);
>+    result[3][1] = mad(x[3][1], y[3][1], z[3][1]);
>+    return result;
>+}
>+float4x3 mad(float4x3 x, float4x3 y, float4x3 z) {
>+    float4x3 result;
>+    result[0][0] = mad(x[0][0], y[0][0], z[0][0]);
>+    result[0][1] = mad(x[0][1], y[0][1], z[0][1]);
>+    result[0][2] = mad(x[0][2], y[0][2], z[0][2]);
>+    result[1][0] = mad(x[1][0], y[1][0], z[1][0]);
>+    result[1][1] = mad(x[1][1], y[1][1], z[1][1]);
>+    result[1][2] = mad(x[1][2], y[1][2], z[1][2]);
>+    result[2][0] = mad(x[2][0], y[2][0], z[2][0]);
>+    result[2][1] = mad(x[2][1], y[2][1], z[2][1]);
>+    result[2][2] = mad(x[2][2], y[2][2], z[2][2]);
>+    result[3][0] = mad(x[3][0], y[3][0], z[3][0]);
>+    result[3][1] = mad(x[3][1], y[3][1], z[3][1]);
>+    result[3][2] = mad(x[3][2], y[3][2], z[3][2]);
>+    return result;
>+}
>+float4x4 mad(float4x4 x, float4x4 y, float4x4 z) {
>+    float4x4 result;
>+    result[0][0] = mad(x[0][0], y[0][0], z[0][0]);
>+    result[0][1] = mad(x[0][1], y[0][1], z[0][1]);
>+    result[0][2] = mad(x[0][2], y[0][2], z[0][2]);
>+    result[0][3] = mad(x[0][3], y[0][3], z[0][3]);
>+    result[1][0] = mad(x[1][0], y[1][0], z[1][0]);
>+    result[1][1] = mad(x[1][1], y[1][1], z[1][1]);
>+    result[1][2] = mad(x[1][2], y[1][2], z[1][2]);
>+    result[1][3] = mad(x[1][3], y[1][3], z[1][3]);
>+    result[2][0] = mad(x[2][0], y[2][0], z[2][0]);
>+    result[2][1] = mad(x[2][1], y[2][1], z[2][1]);
>+    result[2][2] = mad(x[2][2], y[2][2], z[2][2]);
>+    result[2][3] = mad(x[2][3], y[2][3], z[2][3]);
>+    result[3][0] = mad(x[3][0], y[3][0], z[3][0]);
>+    result[3][1] = mad(x[3][1], y[3][1], z[3][1]);
>+    result[3][2] = mad(x[3][2], y[3][2], z[3][2]);
>+    result[3][3] = mad(x[3][3], y[3][3], z[3][3]);
>+    return result;
>+}
>+
>+
>+/* Functions named modf */
>+half modf(half x, thread half* ip) {
>+    uint result = uint(x);
>+    if (ip != null)
>+        *ip = x - half(result);
>+    return half(result);
>+}
>+half2 modf(half2 x, thread half2* y) {
>+    half2 result;
>+    half buffer;
>+    result[0] = modf(x[0], &buffer);
>+    if (y != null)
>+        (*y)[0] = buffer;
>+    result[1] = modf(x[1], &buffer);
>+    if (y != null)
>+        (*y)[1] = buffer;
>+    return result;
>+}
>+half3 modf(half3 x, thread half3* y) {
>+    half3 result;
>+    half buffer;
>+    result[0] = modf(x[0], &buffer);
>+    if (y != null)
>+        (*y)[0] = buffer;
>+    result[1] = modf(x[1], &buffer);
>+    if (y != null)
>+        (*y)[1] = buffer;
>+    result[2] = modf(x[2], &buffer);
>+    if (y != null)
>+        (*y)[2] = buffer;
>+    return result;
>+}
>+half4 modf(half4 x, thread half4* y) {
>+    half4 result;
>+    half buffer;
>+    result[0] = modf(x[0], &buffer);
>+    if (y != null)
>+        (*y)[0] = buffer;
>+    result[1] = modf(x[1], &buffer);
>+    if (y != null)
>+        (*y)[1] = buffer;
>+    result[2] = modf(x[2], &buffer);
>+    if (y != null)
>+        (*y)[2] = buffer;
>+    result[3] = modf(x[3], &buffer);
>+    if (y != null)
>+        (*y)[3] = buffer;
>+    return result;
>+}
>+half2x2 modf(half2x2 x, thread half2x2* y) {
>+    half2x2 result;
>+    half buffer;
>+    result[0][0] = modf(x[0][0], &buffer);
>+    if (y != null)
>+        (*y)[0][0] = buffer;
>+    result[0][1] = modf(x[0][1], &buffer);
>+    if (y != null)
>+        (*y)[0][1] = buffer;
>+    result[1][0] = modf(x[1][0], &buffer);
>+    if (y != null)
>+        (*y)[1][0] = buffer;
>+    result[1][1] = modf(x[1][1], &buffer);
>+    if (y != null)
>+        (*y)[1][1] = buffer;
>+    return result;
>+}
>+half2x3 modf(half2x3 x, thread half2x3* y) {
>+    half2x3 result;
>+    half buffer;
>+    result[0][0] = modf(x[0][0], &buffer);
>+    if (y != null)
>+        (*y)[0][0] = buffer;
>+    result[0][1] = modf(x[0][1], &buffer);
>+    if (y != null)
>+        (*y)[0][1] = buffer;
>+    result[0][2] = modf(x[0][2], &buffer);
>+    if (y != null)
>+        (*y)[0][2] = buffer;
>+    result[1][0] = modf(x[1][0], &buffer);
>+    if (y != null)
>+        (*y)[1][0] = buffer;
>+    result[1][1] = modf(x[1][1], &buffer);
>+    if (y != null)
>+        (*y)[1][1] = buffer;
>+    result[1][2] = modf(x[1][2], &buffer);
>+    if (y != null)
>+        (*y)[1][2] = buffer;
>+    return result;
>+}
>+half2x4 modf(half2x4 x, thread half2x4* y) {
>+    half2x4 result;
>+    half buffer;
>+    result[0][0] = modf(x[0][0], &buffer);
>+    if (y != null)
>+        (*y)[0][0] = buffer;
>+    result[0][1] = modf(x[0][1], &buffer);
>+    if (y != null)
>+        (*y)[0][1] = buffer;
>+    result[0][2] = modf(x[0][2], &buffer);
>+    if (y != null)
>+        (*y)[0][2] = buffer;
>+    result[0][3] = modf(x[0][3], &buffer);
>+    if (y != null)
>+        (*y)[0][3] = buffer;
>+    result[1][0] = modf(x[1][0], &buffer);
>+    if (y != null)
>+        (*y)[1][0] = buffer;
>+    result[1][1] = modf(x[1][1], &buffer);
>+    if (y != null)
>+        (*y)[1][1] = buffer;
>+    result[1][2] = modf(x[1][2], &buffer);
>+    if (y != null)
>+        (*y)[1][2] = buffer;
>+    result[1][3] = modf(x[1][3], &buffer);
>+    if (y != null)
>+        (*y)[1][3] = buffer;
>+    return result;
>+}
>+half3x2 modf(half3x2 x, thread half3x2* y) {
>+    half3x2 result;
>+    half buffer;
>+    result[0][0] = modf(x[0][0], &buffer);
>+    if (y != null)
>+        (*y)[0][0] = buffer;
>+    result[0][1] = modf(x[0][1], &buffer);
>+    if (y != null)
>+        (*y)[0][1] = buffer;
>+    result[1][0] = modf(x[1][0], &buffer);
>+    if (y != null)
>+        (*y)[1][0] = buffer;
>+    result[1][1] = modf(x[1][1], &buffer);
>+    if (y != null)
>+        (*y)[1][1] = buffer;
>+    result[2][0] = modf(x[2][0], &buffer);
>+    if (y != null)
>+        (*y)[2][0] = buffer;
>+    result[2][1] = modf(x[2][1], &buffer);
>+    if (y != null)
>+        (*y)[2][1] = buffer;
>+    return result;
>+}
>+half3x3 modf(half3x3 x, thread half3x3* y) {
>+    half3x3 result;
>+    half buffer;
>+    result[0][0] = modf(x[0][0], &buffer);
>+    if (y != null)
>+        (*y)[0][0] = buffer;
>+    result[0][1] = modf(x[0][1], &buffer);
>+    if (y != null)
>+        (*y)[0][1] = buffer;
>+    result[0][2] = modf(x[0][2], &buffer);
>+    if (y != null)
>+        (*y)[0][2] = buffer;
>+    result[1][0] = modf(x[1][0], &buffer);
>+    if (y != null)
>+        (*y)[1][0] = buffer;
>+    result[1][1] = modf(x[1][1], &buffer);
>+    if (y != null)
>+        (*y)[1][1] = buffer;
>+    result[1][2] = modf(x[1][2], &buffer);
>+    if (y != null)
>+        (*y)[1][2] = buffer;
>+    result[2][0] = modf(x[2][0], &buffer);
>+    if (y != null)
>+        (*y)[2][0] = buffer;
>+    result[2][1] = modf(x[2][1], &buffer);
>+    if (y != null)
>+        (*y)[2][1] = buffer;
>+    result[2][2] = modf(x[2][2], &buffer);
>+    if (y != null)
>+        (*y)[2][2] = buffer;
>+    return result;
>+}
>+half3x4 modf(half3x4 x, thread half3x4* y) {
>+    half3x4 result;
>+    half buffer;
>+    result[0][0] = modf(x[0][0], &buffer);
>+    if (y != null)
>+        (*y)[0][0] = buffer;
>+    result[0][1] = modf(x[0][1], &buffer);
>+    if (y != null)
>+        (*y)[0][1] = buffer;
>+    result[0][2] = modf(x[0][2], &buffer);
>+    if (y != null)
>+        (*y)[0][2] = buffer;
>+    result[0][3] = modf(x[0][3], &buffer);
>+    if (y != null)
>+        (*y)[0][3] = buffer;
>+    result[1][0] = modf(x[1][0], &buffer);
>+    if (y != null)
>+        (*y)[1][0] = buffer;
>+    result[1][1] = modf(x[1][1], &buffer);
>+    if (y != null)
>+        (*y)[1][1] = buffer;
>+    result[1][2] = modf(x[1][2], &buffer);
>+    if (y != null)
>+        (*y)[1][2] = buffer;
>+    result[1][3] = modf(x[1][3], &buffer);
>+    if (y != null)
>+        (*y)[1][3] = buffer;
>+    result[2][0] = modf(x[2][0], &buffer);
>+    if (y != null)
>+        (*y)[2][0] = buffer;
>+    result[2][1] = modf(x[2][1], &buffer);
>+    if (y != null)
>+        (*y)[2][1] = buffer;
>+    result[2][2] = modf(x[2][2], &buffer);
>+    if (y != null)
>+        (*y)[2][2] = buffer;
>+    result[2][3] = modf(x[2][3], &buffer);
>+    if (y != null)
>+        (*y)[2][3] = buffer;
>+    return result;
>+}
>+half4x2 modf(half4x2 x, thread half4x2* y) {
>+    half4x2 result;
>+    half buffer;
>+    result[0][0] = modf(x[0][0], &buffer);
>+    if (y != null)
>+        (*y)[0][0] = buffer;
>+    result[0][1] = modf(x[0][1], &buffer);
>+    if (y != null)
>+        (*y)[0][1] = buffer;
>+    result[1][0] = modf(x[1][0], &buffer);
>+    if (y != null)
>+        (*y)[1][0] = buffer;
>+    result[1][1] = modf(x[1][1], &buffer);
>+    if (y != null)
>+        (*y)[1][1] = buffer;
>+    result[2][0] = modf(x[2][0], &buffer);
>+    if (y != null)
>+        (*y)[2][0] = buffer;
>+    result[2][1] = modf(x[2][1], &buffer);
>+    if (y != null)
>+        (*y)[2][1] = buffer;
>+    result[3][0] = modf(x[3][0], &buffer);
>+    if (y != null)
>+        (*y)[3][0] = buffer;
>+    result[3][1] = modf(x[3][1], &buffer);
>+    if (y != null)
>+        (*y)[3][1] = buffer;
>+    return result;
>+}
>+half4x3 modf(half4x3 x, thread half4x3* y) {
>+    half4x3 result;
>+    half buffer;
>+    result[0][0] = modf(x[0][0], &buffer);
>+    if (y != null)
>+        (*y)[0][0] = buffer;
>+    result[0][1] = modf(x[0][1], &buffer);
>+    if (y != null)
>+        (*y)[0][1] = buffer;
>+    result[0][2] = modf(x[0][2], &buffer);
>+    if (y != null)
>+        (*y)[0][2] = buffer;
>+    result[1][0] = modf(x[1][0], &buffer);
>+    if (y != null)
>+        (*y)[1][0] = buffer;
>+    result[1][1] = modf(x[1][1], &buffer);
>+    if (y != null)
>+        (*y)[1][1] = buffer;
>+    result[1][2] = modf(x[1][2], &buffer);
>+    if (y != null)
>+        (*y)[1][2] = buffer;
>+    result[2][0] = modf(x[2][0], &buffer);
>+    if (y != null)
>+        (*y)[2][0] = buffer;
>+    result[2][1] = modf(x[2][1], &buffer);
>+    if (y != null)
>+        (*y)[2][1] = buffer;
>+    result[2][2] = modf(x[2][2], &buffer);
>+    if (y != null)
>+        (*y)[2][2] = buffer;
>+    result[3][0] = modf(x[3][0], &buffer);
>+    if (y != null)
>+        (*y)[3][0] = buffer;
>+    result[3][1] = modf(x[3][1], &buffer);
>+    if (y != null)
>+        (*y)[3][1] = buffer;
>+    result[3][2] = modf(x[3][2], &buffer);
>+    if (y != null)
>+        (*y)[3][2] = buffer;
>+    return result;
>+}
>+half4x4 modf(half4x4 x, thread half4x4* y) {
>+    half4x4 result;
>+    half buffer;
>+    result[0][0] = modf(x[0][0], &buffer);
>+    if (y != null)
>+        (*y)[0][0] = buffer;
>+    result[0][1] = modf(x[0][1], &buffer);
>+    if (y != null)
>+        (*y)[0][1] = buffer;
>+    result[0][2] = modf(x[0][2], &buffer);
>+    if (y != null)
>+        (*y)[0][2] = buffer;
>+    result[0][3] = modf(x[0][3], &buffer);
>+    if (y != null)
>+        (*y)[0][3] = buffer;
>+    result[1][0] = modf(x[1][0], &buffer);
>+    if (y != null)
>+        (*y)[1][0] = buffer;
>+    result[1][1] = modf(x[1][1], &buffer);
>+    if (y != null)
>+        (*y)[1][1] = buffer;
>+    result[1][2] = modf(x[1][2], &buffer);
>+    if (y != null)
>+        (*y)[1][2] = buffer;
>+    result[1][3] = modf(x[1][3], &buffer);
>+    if (y != null)
>+        (*y)[1][3] = buffer;
>+    result[2][0] = modf(x[2][0], &buffer);
>+    if (y != null)
>+        (*y)[2][0] = buffer;
>+    result[2][1] = modf(x[2][1], &buffer);
>+    if (y != null)
>+        (*y)[2][1] = buffer;
>+    result[2][2] = modf(x[2][2], &buffer);
>+    if (y != null)
>+        (*y)[2][2] = buffer;
>+    result[2][3] = modf(x[2][3], &buffer);
>+    if (y != null)
>+        (*y)[2][3] = buffer;
>+    result[3][0] = modf(x[3][0], &buffer);
>+    if (y != null)
>+        (*y)[3][0] = buffer;
>+    result[3][1] = modf(x[3][1], &buffer);
>+    if (y != null)
>+        (*y)[3][1] = buffer;
>+    result[3][2] = modf(x[3][2], &buffer);
>+    if (y != null)
>+        (*y)[3][2] = buffer;
>+    result[3][3] = modf(x[3][3], &buffer);
>+    if (y != null)
>+        (*y)[3][3] = buffer;
>+    return result;
>+}
>+
>+float modf(float x, thread float* ip) {
>+    uint result = uint(x);
>+    if (ip != null)
>+        *ip = x - float(result);
>+    return float(result);
>+}
>+float2 modf(float2 x, thread float2* y) {
>+    float2 result;
>+    float buffer;
>+    result[0] = modf(x[0], &buffer);
>+    if (y != null)
>+        (*y)[0] = buffer;
>+    result[1] = modf(x[1], &buffer);
>+    if (y != null)
>+        (*y)[1] = buffer;
>+    return result;
>+}
>+float3 modf(float3 x, thread float3* y) {
>+    float3 result;
>+    float buffer;
>+    result[0] = modf(x[0], &buffer);
>+    if (y != null)
>+        (*y)[0] = buffer;
>+    result[1] = modf(x[1], &buffer);
>+    if (y != null)
>+        (*y)[1] = buffer;
>+    result[2] = modf(x[2], &buffer);
>+    if (y != null)
>+        (*y)[2] = buffer;
>+    return result;
>+}
>+float4 modf(float4 x, thread float4* y) {
>+    float4 result;
>+    float buffer;
>+    result[0] = modf(x[0], &buffer);
>+    if (y != null)
>+        (*y)[0] = buffer;
>+    result[1] = modf(x[1], &buffer);
>+    if (y != null)
>+        (*y)[1] = buffer;
>+    result[2] = modf(x[2], &buffer);
>+    if (y != null)
>+        (*y)[2] = buffer;
>+    result[3] = modf(x[3], &buffer);
>+    if (y != null)
>+        (*y)[3] = buffer;
>+    return result;
>+}
>+float2x2 modf(float2x2 x, thread float2x2* y) {
>+    float2x2 result;
>+    float buffer;
>+    result[0][0] = modf(x[0][0], &buffer);
>+    if (y != null)
>+        (*y)[0][0] = buffer;
>+    result[0][1] = modf(x[0][1], &buffer);
>+    if (y != null)
>+        (*y)[0][1] = buffer;
>+    result[1][0] = modf(x[1][0], &buffer);
>+    if (y != null)
>+        (*y)[1][0] = buffer;
>+    result[1][1] = modf(x[1][1], &buffer);
>+    if (y != null)
>+        (*y)[1][1] = buffer;
>+    return result;
>+}
>+float2x3 modf(float2x3 x, thread float2x3* y) {
>+    float2x3 result;
>+    float buffer;
>+    result[0][0] = modf(x[0][0], &buffer);
>+    if (y != null)
>+        (*y)[0][0] = buffer;
>+    result[0][1] = modf(x[0][1], &buffer);
>+    if (y != null)
>+        (*y)[0][1] = buffer;
>+    result[0][2] = modf(x[0][2], &buffer);
>+    if (y != null)
>+        (*y)[0][2] = buffer;
>+    result[1][0] = modf(x[1][0], &buffer);
>+    if (y != null)
>+        (*y)[1][0] = buffer;
>+    result[1][1] = modf(x[1][1], &buffer);
>+    if (y != null)
>+        (*y)[1][1] = buffer;
>+    result[1][2] = modf(x[1][2], &buffer);
>+    if (y != null)
>+        (*y)[1][2] = buffer;
>+    return result;
>+}
>+float2x4 modf(float2x4 x, thread float2x4* y) {
>+    float2x4 result;
>+    float buffer;
>+    result[0][0] = modf(x[0][0], &buffer);
>+    if (y != null)
>+        (*y)[0][0] = buffer;
>+    result[0][1] = modf(x[0][1], &buffer);
>+    if (y != null)
>+        (*y)[0][1] = buffer;
>+    result[0][2] = modf(x[0][2], &buffer);
>+    if (y != null)
>+        (*y)[0][2] = buffer;
>+    result[0][3] = modf(x[0][3], &buffer);
>+    if (y != null)
>+        (*y)[0][3] = buffer;
>+    result[1][0] = modf(x[1][0], &buffer);
>+    if (y != null)
>+        (*y)[1][0] = buffer;
>+    result[1][1] = modf(x[1][1], &buffer);
>+    if (y != null)
>+        (*y)[1][1] = buffer;
>+    result[1][2] = modf(x[1][2], &buffer);
>+    if (y != null)
>+        (*y)[1][2] = buffer;
>+    result[1][3] = modf(x[1][3], &buffer);
>+    if (y != null)
>+        (*y)[1][3] = buffer;
>+    return result;
>+}
>+float3x2 modf(float3x2 x, thread float3x2* y) {
>+    float3x2 result;
>+    float buffer;
>+    result[0][0] = modf(x[0][0], &buffer);
>+    if (y != null)
>+        (*y)[0][0] = buffer;
>+    result[0][1] = modf(x[0][1], &buffer);
>+    if (y != null)
>+        (*y)[0][1] = buffer;
>+    result[1][0] = modf(x[1][0], &buffer);
>+    if (y != null)
>+        (*y)[1][0] = buffer;
>+    result[1][1] = modf(x[1][1], &buffer);
>+    if (y != null)
>+        (*y)[1][1] = buffer;
>+    result[2][0] = modf(x[2][0], &buffer);
>+    if (y != null)
>+        (*y)[2][0] = buffer;
>+    result[2][1] = modf(x[2][1], &buffer);
>+    if (y != null)
>+        (*y)[2][1] = buffer;
>+    return result;
>+}
>+float3x3 modf(float3x3 x, thread float3x3* y) {
>+    float3x3 result;
>+    float buffer;
>+    result[0][0] = modf(x[0][0], &buffer);
>+    if (y != null)
>+        (*y)[0][0] = buffer;
>+    result[0][1] = modf(x[0][1], &buffer);
>+    if (y != null)
>+        (*y)[0][1] = buffer;
>+    result[0][2] = modf(x[0][2], &buffer);
>+    if (y != null)
>+        (*y)[0][2] = buffer;
>+    result[1][0] = modf(x[1][0], &buffer);
>+    if (y != null)
>+        (*y)[1][0] = buffer;
>+    result[1][1] = modf(x[1][1], &buffer);
>+    if (y != null)
>+        (*y)[1][1] = buffer;
>+    result[1][2] = modf(x[1][2], &buffer);
>+    if (y != null)
>+        (*y)[1][2] = buffer;
>+    result[2][0] = modf(x[2][0], &buffer);
>+    if (y != null)
>+        (*y)[2][0] = buffer;
>+    result[2][1] = modf(x[2][1], &buffer);
>+    if (y != null)
>+        (*y)[2][1] = buffer;
>+    result[2][2] = modf(x[2][2], &buffer);
>+    if (y != null)
>+        (*y)[2][2] = buffer;
>+    return result;
>+}
>+float3x4 modf(float3x4 x, thread float3x4* y) {
>+    float3x4 result;
>+    float buffer;
>+    result[0][0] = modf(x[0][0], &buffer);
>+    if (y != null)
>+        (*y)[0][0] = buffer;
>+    result[0][1] = modf(x[0][1], &buffer);
>+    if (y != null)
>+        (*y)[0][1] = buffer;
>+    result[0][2] = modf(x[0][2], &buffer);
>+    if (y != null)
>+        (*y)[0][2] = buffer;
>+    result[0][3] = modf(x[0][3], &buffer);
>+    if (y != null)
>+        (*y)[0][3] = buffer;
>+    result[1][0] = modf(x[1][0], &buffer);
>+    if (y != null)
>+        (*y)[1][0] = buffer;
>+    result[1][1] = modf(x[1][1], &buffer);
>+    if (y != null)
>+        (*y)[1][1] = buffer;
>+    result[1][2] = modf(x[1][2], &buffer);
>+    if (y != null)
>+        (*y)[1][2] = buffer;
>+    result[1][3] = modf(x[1][3], &buffer);
>+    if (y != null)
>+        (*y)[1][3] = buffer;
>+    result[2][0] = modf(x[2][0], &buffer);
>+    if (y != null)
>+        (*y)[2][0] = buffer;
>+    result[2][1] = modf(x[2][1], &buffer);
>+    if (y != null)
>+        (*y)[2][1] = buffer;
>+    result[2][2] = modf(x[2][2], &buffer);
>+    if (y != null)
>+        (*y)[2][2] = buffer;
>+    result[2][3] = modf(x[2][3], &buffer);
>+    if (y != null)
>+        (*y)[2][3] = buffer;
>+    return result;
>+}
>+float4x2 modf(float4x2 x, thread float4x2* y) {
>+    float4x2 result;
>+    float buffer;
>+    result[0][0] = modf(x[0][0], &buffer);
>+    if (y != null)
>+        (*y)[0][0] = buffer;
>+    result[0][1] = modf(x[0][1], &buffer);
>+    if (y != null)
>+        (*y)[0][1] = buffer;
>+    result[1][0] = modf(x[1][0], &buffer);
>+    if (y != null)
>+        (*y)[1][0] = buffer;
>+    result[1][1] = modf(x[1][1], &buffer);
>+    if (y != null)
>+        (*y)[1][1] = buffer;
>+    result[2][0] = modf(x[2][0], &buffer);
>+    if (y != null)
>+        (*y)[2][0] = buffer;
>+    result[2][1] = modf(x[2][1], &buffer);
>+    if (y != null)
>+        (*y)[2][1] = buffer;
>+    result[3][0] = modf(x[3][0], &buffer);
>+    if (y != null)
>+        (*y)[3][0] = buffer;
>+    result[3][1] = modf(x[3][1], &buffer);
>+    if (y != null)
>+        (*y)[3][1] = buffer;
>+    return result;
>+}
>+float4x3 modf(float4x3 x, thread float4x3* y) {
>+    float4x3 result;
>+    float buffer;
>+    result[0][0] = modf(x[0][0], &buffer);
>+    if (y != null)
>+        (*y)[0][0] = buffer;
>+    result[0][1] = modf(x[0][1], &buffer);
>+    if (y != null)
>+        (*y)[0][1] = buffer;
>+    result[0][2] = modf(x[0][2], &buffer);
>+    if (y != null)
>+        (*y)[0][2] = buffer;
>+    result[1][0] = modf(x[1][0], &buffer);
>+    if (y != null)
>+        (*y)[1][0] = buffer;
>+    result[1][1] = modf(x[1][1], &buffer);
>+    if (y != null)
>+        (*y)[1][1] = buffer;
>+    result[1][2] = modf(x[1][2], &buffer);
>+    if (y != null)
>+        (*y)[1][2] = buffer;
>+    result[2][0] = modf(x[2][0], &buffer);
>+    if (y != null)
>+        (*y)[2][0] = buffer;
>+    result[2][1] = modf(x[2][1], &buffer);
>+    if (y != null)
>+        (*y)[2][1] = buffer;
>+    result[2][2] = modf(x[2][2], &buffer);
>+    if (y != null)
>+        (*y)[2][2] = buffer;
>+    result[3][0] = modf(x[3][0], &buffer);
>+    if (y != null)
>+        (*y)[3][0] = buffer;
>+    result[3][1] = modf(x[3][1], &buffer);
>+    if (y != null)
>+        (*y)[3][1] = buffer;
>+    result[3][2] = modf(x[3][2], &buffer);
>+    if (y != null)
>+        (*y)[3][2] = buffer;
>+    return result;
>+}
>+float4x4 modf(float4x4 x, thread float4x4* y) {
>+    float4x4 result;
>+    float buffer;
>+    result[0][0] = modf(x[0][0], &buffer);
>+    if (y != null)
>+        (*y)[0][0] = buffer;
>+    result[0][1] = modf(x[0][1], &buffer);
>+    if (y != null)
>+        (*y)[0][1] = buffer;
>+    result[0][2] = modf(x[0][2], &buffer);
>+    if (y != null)
>+        (*y)[0][2] = buffer;
>+    result[0][3] = modf(x[0][3], &buffer);
>+    if (y != null)
>+        (*y)[0][3] = buffer;
>+    result[1][0] = modf(x[1][0], &buffer);
>+    if (y != null)
>+        (*y)[1][0] = buffer;
>+    result[1][1] = modf(x[1][1], &buffer);
>+    if (y != null)
>+        (*y)[1][1] = buffer;
>+    result[1][2] = modf(x[1][2], &buffer);
>+    if (y != null)
>+        (*y)[1][2] = buffer;
>+    result[1][3] = modf(x[1][3], &buffer);
>+    if (y != null)
>+        (*y)[1][3] = buffer;
>+    result[2][0] = modf(x[2][0], &buffer);
>+    if (y != null)
>+        (*y)[2][0] = buffer;
>+    result[2][1] = modf(x[2][1], &buffer);
>+    if (y != null)
>+        (*y)[2][1] = buffer;
>+    result[2][2] = modf(x[2][2], &buffer);
>+    if (y != null)
>+        (*y)[2][2] = buffer;
>+    result[2][3] = modf(x[2][3], &buffer);
>+    if (y != null)
>+        (*y)[2][3] = buffer;
>+    result[3][0] = modf(x[3][0], &buffer);
>+    if (y != null)
>+        (*y)[3][0] = buffer;
>+    result[3][1] = modf(x[3][1], &buffer);
>+    if (y != null)
>+        (*y)[3][1] = buffer;
>+    result[3][2] = modf(x[3][2], &buffer);
>+    if (y != null)
>+        (*y)[3][2] = buffer;
>+    result[3][3] = modf(x[3][3], &buffer);
>+    if (y != null)
>+        (*y)[3][3] = buffer;
>+    return result;
>+}
>+
>+half modf(half x, device half* ip) {
>+    uint result = uint(x);
>+    if (ip != null)
>+        *ip = x - half(result);
>+    return half(result);
>+}
>+half2 modf(half2 x, device half2* y) {
>+    half2 result;
>+    half buffer;
>+    result[0] = modf(x[0], &buffer);
>+    if (y != null)
>+        (*y)[0] = buffer;
>+    result[1] = modf(x[1], &buffer);
>+    if (y != null)
>+        (*y)[1] = buffer;
>+    return result;
>+}
>+half3 modf(half3 x, device half3* y) {
>+    half3 result;
>+    half buffer;
>+    result[0] = modf(x[0], &buffer);
>+    if (y != null)
>+        (*y)[0] = buffer;
>+    result[1] = modf(x[1], &buffer);
>+    if (y != null)
>+        (*y)[1] = buffer;
>+    result[2] = modf(x[2], &buffer);
>+    if (y != null)
>+        (*y)[2] = buffer;
>+    return result;
>+}
>+half4 modf(half4 x, device half4* y) {
>+    half4 result;
>+    half buffer;
>+    result[0] = modf(x[0], &buffer);
>+    if (y != null)
>+        (*y)[0] = buffer;
>+    result[1] = modf(x[1], &buffer);
>+    if (y != null)
>+        (*y)[1] = buffer;
>+    result[2] = modf(x[2], &buffer);
>+    if (y != null)
>+        (*y)[2] = buffer;
>+    result[3] = modf(x[3], &buffer);
>+    if (y != null)
>+        (*y)[3] = buffer;
>+    return result;
>+}
>+half2x2 modf(half2x2 x, device half2x2* y) {
>+    half2x2 result;
>+    half buffer;
>+    result[0][0] = modf(x[0][0], &buffer);
>+    if (y != null)
>+        (*y)[0][0] = buffer;
>+    result[0][1] = modf(x[0][1], &buffer);
>+    if (y != null)
>+        (*y)[0][1] = buffer;
>+    result[1][0] = modf(x[1][0], &buffer);
>+    if (y != null)
>+        (*y)[1][0] = buffer;
>+    result[1][1] = modf(x[1][1], &buffer);
>+    if (y != null)
>+        (*y)[1][1] = buffer;
>+    return result;
>+}
>+half2x3 modf(half2x3 x, device half2x3* y) {
>+    half2x3 result;
>+    half buffer;
>+    result[0][0] = modf(x[0][0], &buffer);
>+    if (y != null)
>+        (*y)[0][0] = buffer;
>+    result[0][1] = modf(x[0][1], &buffer);
>+    if (y != null)
>+        (*y)[0][1] = buffer;
>+    result[0][2] = modf(x[0][2], &buffer);
>+    if (y != null)
>+        (*y)[0][2] = buffer;
>+    result[1][0] = modf(x[1][0], &buffer);
>+    if (y != null)
>+        (*y)[1][0] = buffer;
>+    result[1][1] = modf(x[1][1], &buffer);
>+    if (y != null)
>+        (*y)[1][1] = buffer;
>+    result[1][2] = modf(x[1][2], &buffer);
>+    if (y != null)
>+        (*y)[1][2] = buffer;
>+    return result;
>+}
>+half2x4 modf(half2x4 x, device half2x4* y) {
>+    half2x4 result;
>+    half buffer;
>+    result[0][0] = modf(x[0][0], &buffer);
>+    if (y != null)
>+        (*y)[0][0] = buffer;
>+    result[0][1] = modf(x[0][1], &buffer);
>+    if (y != null)
>+        (*y)[0][1] = buffer;
>+    result[0][2] = modf(x[0][2], &buffer);
>+    if (y != null)
>+        (*y)[0][2] = buffer;
>+    result[0][3] = modf(x[0][3], &buffer);
>+    if (y != null)
>+        (*y)[0][3] = buffer;
>+    result[1][0] = modf(x[1][0], &buffer);
>+    if (y != null)
>+        (*y)[1][0] = buffer;
>+    result[1][1] = modf(x[1][1], &buffer);
>+    if (y != null)
>+        (*y)[1][1] = buffer;
>+    result[1][2] = modf(x[1][2], &buffer);
>+    if (y != null)
>+        (*y)[1][2] = buffer;
>+    result[1][3] = modf(x[1][3], &buffer);
>+    if (y != null)
>+        (*y)[1][3] = buffer;
>+    return result;
>+}
>+half3x2 modf(half3x2 x, device half3x2* y) {
>+    half3x2 result;
>+    half buffer;
>+    result[0][0] = modf(x[0][0], &buffer);
>+    if (y != null)
>+        (*y)[0][0] = buffer;
>+    result[0][1] = modf(x[0][1], &buffer);
>+    if (y != null)
>+        (*y)[0][1] = buffer;
>+    result[1][0] = modf(x[1][0], &buffer);
>+    if (y != null)
>+        (*y)[1][0] = buffer;
>+    result[1][1] = modf(x[1][1], &buffer);
>+    if (y != null)
>+        (*y)[1][1] = buffer;
>+    result[2][0] = modf(x[2][0], &buffer);
>+    if (y != null)
>+        (*y)[2][0] = buffer;
>+    result[2][1] = modf(x[2][1], &buffer);
>+    if (y != null)
>+        (*y)[2][1] = buffer;
>+    return result;
>+}
>+half3x3 modf(half3x3 x, device half3x3* y) {
>+    half3x3 result;
>+    half buffer;
>+    result[0][0] = modf(x[0][0], &buffer);
>+    if (y != null)
>+        (*y)[0][0] = buffer;
>+    result[0][1] = modf(x[0][1], &buffer);
>+    if (y != null)
>+        (*y)[0][1] = buffer;
>+    result[0][2] = modf(x[0][2], &buffer);
>+    if (y != null)
>+        (*y)[0][2] = buffer;
>+    result[1][0] = modf(x[1][0], &buffer);
>+    if (y != null)
>+        (*y)[1][0] = buffer;
>+    result[1][1] = modf(x[1][1], &buffer);
>+    if (y != null)
>+        (*y)[1][1] = buffer;
>+    result[1][2] = modf(x[1][2], &buffer);
>+    if (y != null)
>+        (*y)[1][2] = buffer;
>+    result[2][0] = modf(x[2][0], &buffer);
>+    if (y != null)
>+        (*y)[2][0] = buffer;
>+    result[2][1] = modf(x[2][1], &buffer);
>+    if (y != null)
>+        (*y)[2][1] = buffer;
>+    result[2][2] = modf(x[2][2], &buffer);
>+    if (y != null)
>+        (*y)[2][2] = buffer;
>+    return result;
>+}
>+half3x4 modf(half3x4 x, device half3x4* y) {
>+    half3x4 result;
>+    half buffer;
>+    result[0][0] = modf(x[0][0], &buffer);
>+    if (y != null)
>+        (*y)[0][0] = buffer;
>+    result[0][1] = modf(x[0][1], &buffer);
>+    if (y != null)
>+        (*y)[0][1] = buffer;
>+    result[0][2] = modf(x[0][2], &buffer);
>+    if (y != null)
>+        (*y)[0][2] = buffer;
>+    result[0][3] = modf(x[0][3], &buffer);
>+    if (y != null)
>+        (*y)[0][3] = buffer;
>+    result[1][0] = modf(x[1][0], &buffer);
>+    if (y != null)
>+        (*y)[1][0] = buffer;
>+    result[1][1] = modf(x[1][1], &buffer);
>+    if (y != null)
>+        (*y)[1][1] = buffer;
>+    result[1][2] = modf(x[1][2], &buffer);
>+    if (y != null)
>+        (*y)[1][2] = buffer;
>+    result[1][3] = modf(x[1][3], &buffer);
>+    if (y != null)
>+        (*y)[1][3] = buffer;
>+    result[2][0] = modf(x[2][0], &buffer);
>+    if (y != null)
>+        (*y)[2][0] = buffer;
>+    result[2][1] = modf(x[2][1], &buffer);
>+    if (y != null)
>+        (*y)[2][1] = buffer;
>+    result[2][2] = modf(x[2][2], &buffer);
>+    if (y != null)
>+        (*y)[2][2] = buffer;
>+    result[2][3] = modf(x[2][3], &buffer);
>+    if (y != null)
>+        (*y)[2][3] = buffer;
>+    return result;
>+}
>+half4x2 modf(half4x2 x, device half4x2* y) {
>+    half4x2 result;
>+    half buffer;
>+    result[0][0] = modf(x[0][0], &buffer);
>+    if (y != null)
>+        (*y)[0][0] = buffer;
>+    result[0][1] = modf(x[0][1], &buffer);
>+    if (y != null)
>+        (*y)[0][1] = buffer;
>+    result[1][0] = modf(x[1][0], &buffer);
>+    if (y != null)
>+        (*y)[1][0] = buffer;
>+    result[1][1] = modf(x[1][1], &buffer);
>+    if (y != null)
>+        (*y)[1][1] = buffer;
>+    result[2][0] = modf(x[2][0], &buffer);
>+    if (y != null)
>+        (*y)[2][0] = buffer;
>+    result[2][1] = modf(x[2][1], &buffer);
>+    if (y != null)
>+        (*y)[2][1] = buffer;
>+    result[3][0] = modf(x[3][0], &buffer);
>+    if (y != null)
>+        (*y)[3][0] = buffer;
>+    result[3][1] = modf(x[3][1], &buffer);
>+    if (y != null)
>+        (*y)[3][1] = buffer;
>+    return result;
>+}
>+half4x3 modf(half4x3 x, device half4x3* y) {
>+    half4x3 result;
>+    half buffer;
>+    result[0][0] = modf(x[0][0], &buffer);
>+    if (y != null)
>+        (*y)[0][0] = buffer;
>+    result[0][1] = modf(x[0][1], &buffer);
>+    if (y != null)
>+        (*y)[0][1] = buffer;
>+    result[0][2] = modf(x[0][2], &buffer);
>+    if (y != null)
>+        (*y)[0][2] = buffer;
>+    result[1][0] = modf(x[1][0], &buffer);
>+    if (y != null)
>+        (*y)[1][0] = buffer;
>+    result[1][1] = modf(x[1][1], &buffer);
>+    if (y != null)
>+        (*y)[1][1] = buffer;
>+    result[1][2] = modf(x[1][2], &buffer);
>+    if (y != null)
>+        (*y)[1][2] = buffer;
>+    result[2][0] = modf(x[2][0], &buffer);
>+    if (y != null)
>+        (*y)[2][0] = buffer;
>+    result[2][1] = modf(x[2][1], &buffer);
>+    if (y != null)
>+        (*y)[2][1] = buffer;
>+    result[2][2] = modf(x[2][2], &buffer);
>+    if (y != null)
>+        (*y)[2][2] = buffer;
>+    result[3][0] = modf(x[3][0], &buffer);
>+    if (y != null)
>+        (*y)[3][0] = buffer;
>+    result[3][1] = modf(x[3][1], &buffer);
>+    if (y != null)
>+        (*y)[3][1] = buffer;
>+    result[3][2] = modf(x[3][2], &buffer);
>+    if (y != null)
>+        (*y)[3][2] = buffer;
>+    return result;
>+}
>+half4x4 modf(half4x4 x, device half4x4* y) {
>+    half4x4 result;
>+    half buffer;
>+    result[0][0] = modf(x[0][0], &buffer);
>+    if (y != null)
>+        (*y)[0][0] = buffer;
>+    result[0][1] = modf(x[0][1], &buffer);
>+    if (y != null)
>+        (*y)[0][1] = buffer;
>+    result[0][2] = modf(x[0][2], &buffer);
>+    if (y != null)
>+        (*y)[0][2] = buffer;
>+    result[0][3] = modf(x[0][3], &buffer);
>+    if (y != null)
>+        (*y)[0][3] = buffer;
>+    result[1][0] = modf(x[1][0], &buffer);
>+    if (y != null)
>+        (*y)[1][0] = buffer;
>+    result[1][1] = modf(x[1][1], &buffer);
>+    if (y != null)
>+        (*y)[1][1] = buffer;
>+    result[1][2] = modf(x[1][2], &buffer);
>+    if (y != null)
>+        (*y)[1][2] = buffer;
>+    result[1][3] = modf(x[1][3], &buffer);
>+    if (y != null)
>+        (*y)[1][3] = buffer;
>+    result[2][0] = modf(x[2][0], &buffer);
>+    if (y != null)
>+        (*y)[2][0] = buffer;
>+    result[2][1] = modf(x[2][1], &buffer);
>+    if (y != null)
>+        (*y)[2][1] = buffer;
>+    result[2][2] = modf(x[2][2], &buffer);
>+    if (y != null)
>+        (*y)[2][2] = buffer;
>+    result[2][3] = modf(x[2][3], &buffer);
>+    if (y != null)
>+        (*y)[2][3] = buffer;
>+    result[3][0] = modf(x[3][0], &buffer);
>+    if (y != null)
>+        (*y)[3][0] = buffer;
>+    result[3][1] = modf(x[3][1], &buffer);
>+    if (y != null)
>+        (*y)[3][1] = buffer;
>+    result[3][2] = modf(x[3][2], &buffer);
>+    if (y != null)
>+        (*y)[3][2] = buffer;
>+    result[3][3] = modf(x[3][3], &buffer);
>+    if (y != null)
>+        (*y)[3][3] = buffer;
>+    return result;
>+}
>+
>+float modf(float x, device float* ip) {
>+    uint result = uint(x);
>+    if (ip != null)
>+        *ip = x - float(result);
>+    return float(result);
>+}
>+float2 modf(float2 x, device float2* y) {
>+    float2 result;
>+    float buffer;
>+    result[0] = modf(x[0], &buffer);
>+    if (y != null)
>+        (*y)[0] = buffer;
>+    result[1] = modf(x[1], &buffer);
>+    if (y != null)
>+        (*y)[1] = buffer;
>+    return result;
>+}
>+float3 modf(float3 x, device float3* y) {
>+    float3 result;
>+    float buffer;
>+    result[0] = modf(x[0], &buffer);
>+    if (y != null)
>+        (*y)[0] = buffer;
>+    result[1] = modf(x[1], &buffer);
>+    if (y != null)
>+        (*y)[1] = buffer;
>+    result[2] = modf(x[2], &buffer);
>+    if (y != null)
>+        (*y)[2] = buffer;
>+    return result;
>+}
>+float4 modf(float4 x, device float4* y) {
>+    float4 result;
>+    float buffer;
>+    result[0] = modf(x[0], &buffer);
>+    if (y != null)
>+        (*y)[0] = buffer;
>+    result[1] = modf(x[1], &buffer);
>+    if (y != null)
>+        (*y)[1] = buffer;
>+    result[2] = modf(x[2], &buffer);
>+    if (y != null)
>+        (*y)[2] = buffer;
>+    result[3] = modf(x[3], &buffer);
>+    if (y != null)
>+        (*y)[3] = buffer;
>+    return result;
>+}
>+float2x2 modf(float2x2 x, device float2x2* y) {
>+    float2x2 result;
>+    float buffer;
>+    result[0][0] = modf(x[0][0], &buffer);
>+    if (y != null)
>+        (*y)[0][0] = buffer;
>+    result[0][1] = modf(x[0][1], &buffer);
>+    if (y != null)
>+        (*y)[0][1] = buffer;
>+    result[1][0] = modf(x[1][0], &buffer);
>+    if (y != null)
>+        (*y)[1][0] = buffer;
>+    result[1][1] = modf(x[1][1], &buffer);
>+    if (y != null)
>+        (*y)[1][1] = buffer;
>+    return result;
>+}
>+float2x3 modf(float2x3 x, device float2x3* y) {
>+    float2x3 result;
>+    float buffer;
>+    result[0][0] = modf(x[0][0], &buffer);
>+    if (y != null)
>+        (*y)[0][0] = buffer;
>+    result[0][1] = modf(x[0][1], &buffer);
>+    if (y != null)
>+        (*y)[0][1] = buffer;
>+    result[0][2] = modf(x[0][2], &buffer);
>+    if (y != null)
>+        (*y)[0][2] = buffer;
>+    result[1][0] = modf(x[1][0], &buffer);
>+    if (y != null)
>+        (*y)[1][0] = buffer;
>+    result[1][1] = modf(x[1][1], &buffer);
>+    if (y != null)
>+        (*y)[1][1] = buffer;
>+    result[1][2] = modf(x[1][2], &buffer);
>+    if (y != null)
>+        (*y)[1][2] = buffer;
>+    return result;
>+}
>+float2x4 modf(float2x4 x, device float2x4* y) {
>+    float2x4 result;
>+    float buffer;
>+    result[0][0] = modf(x[0][0], &buffer);
>+    if (y != null)
>+        (*y)[0][0] = buffer;
>+    result[0][1] = modf(x[0][1], &buffer);
>+    if (y != null)
>+        (*y)[0][1] = buffer;
>+    result[0][2] = modf(x[0][2], &buffer);
>+    if (y != null)
>+        (*y)[0][2] = buffer;
>+    result[0][3] = modf(x[0][3], &buffer);
>+    if (y != null)
>+        (*y)[0][3] = buffer;
>+    result[1][0] = modf(x[1][0], &buffer);
>+    if (y != null)
>+        (*y)[1][0] = buffer;
>+    result[1][1] = modf(x[1][1], &buffer);
>+    if (y != null)
>+        (*y)[1][1] = buffer;
>+    result[1][2] = modf(x[1][2], &buffer);
>+    if (y != null)
>+        (*y)[1][2] = buffer;
>+    result[1][3] = modf(x[1][3], &buffer);
>+    if (y != null)
>+        (*y)[1][3] = buffer;
>+    return result;
>+}
>+float3x2 modf(float3x2 x, device float3x2* y) {
>+    float3x2 result;
>+    float buffer;
>+    result[0][0] = modf(x[0][0], &buffer);
>+    if (y != null)
>+        (*y)[0][0] = buffer;
>+    result[0][1] = modf(x[0][1], &buffer);
>+    if (y != null)
>+        (*y)[0][1] = buffer;
>+    result[1][0] = modf(x[1][0], &buffer);
>+    if (y != null)
>+        (*y)[1][0] = buffer;
>+    result[1][1] = modf(x[1][1], &buffer);
>+    if (y != null)
>+        (*y)[1][1] = buffer;
>+    result[2][0] = modf(x[2][0], &buffer);
>+    if (y != null)
>+        (*y)[2][0] = buffer;
>+    result[2][1] = modf(x[2][1], &buffer);
>+    if (y != null)
>+        (*y)[2][1] = buffer;
>+    return result;
>+}
>+float3x3 modf(float3x3 x, device float3x3* y) {
>+    float3x3 result;
>+    float buffer;
>+    result[0][0] = modf(x[0][0], &buffer);
>+    if (y != null)
>+        (*y)[0][0] = buffer;
>+    result[0][1] = modf(x[0][1], &buffer);
>+    if (y != null)
>+        (*y)[0][1] = buffer;
>+    result[0][2] = modf(x[0][2], &buffer);
>+    if (y != null)
>+        (*y)[0][2] = buffer;
>+    result[1][0] = modf(x[1][0], &buffer);
>+    if (y != null)
>+        (*y)[1][0] = buffer;
>+    result[1][1] = modf(x[1][1], &buffer);
>+    if (y != null)
>+        (*y)[1][1] = buffer;
>+    result[1][2] = modf(x[1][2], &buffer);
>+    if (y != null)
>+        (*y)[1][2] = buffer;
>+    result[2][0] = modf(x[2][0], &buffer);
>+    if (y != null)
>+        (*y)[2][0] = buffer;
>+    result[2][1] = modf(x[2][1], &buffer);
>+    if (y != null)
>+        (*y)[2][1] = buffer;
>+    result[2][2] = modf(x[2][2], &buffer);
>+    if (y != null)
>+        (*y)[2][2] = buffer;
>+    return result;
>+}
>+float3x4 modf(float3x4 x, device float3x4* y) {
>+    float3x4 result;
>+    float buffer;
>+    result[0][0] = modf(x[0][0], &buffer);
>+    if (y != null)
>+        (*y)[0][0] = buffer;
>+    result[0][1] = modf(x[0][1], &buffer);
>+    if (y != null)
>+        (*y)[0][1] = buffer;
>+    result[0][2] = modf(x[0][2], &buffer);
>+    if (y != null)
>+        (*y)[0][2] = buffer;
>+    result[0][3] = modf(x[0][3], &buffer);
>+    if (y != null)
>+        (*y)[0][3] = buffer;
>+    result[1][0] = modf(x[1][0], &buffer);
>+    if (y != null)
>+        (*y)[1][0] = buffer;
>+    result[1][1] = modf(x[1][1], &buffer);
>+    if (y != null)
>+        (*y)[1][1] = buffer;
>+    result[1][2] = modf(x[1][2], &buffer);
>+    if (y != null)
>+        (*y)[1][2] = buffer;
>+    result[1][3] = modf(x[1][3], &buffer);
>+    if (y != null)
>+        (*y)[1][3] = buffer;
>+    result[2][0] = modf(x[2][0], &buffer);
>+    if (y != null)
>+        (*y)[2][0] = buffer;
>+    result[2][1] = modf(x[2][1], &buffer);
>+    if (y != null)
>+        (*y)[2][1] = buffer;
>+    result[2][2] = modf(x[2][2], &buffer);
>+    if (y != null)
>+        (*y)[2][2] = buffer;
>+    result[2][3] = modf(x[2][3], &buffer);
>+    if (y != null)
>+        (*y)[2][3] = buffer;
>+    return result;
>+}
>+float4x2 modf(float4x2 x, device float4x2* y) {
>+    float4x2 result;
>+    float buffer;
>+    result[0][0] = modf(x[0][0], &buffer);
>+    if (y != null)
>+        (*y)[0][0] = buffer;
>+    result[0][1] = modf(x[0][1], &buffer);
>+    if (y != null)
>+        (*y)[0][1] = buffer;
>+    result[1][0] = modf(x[1][0], &buffer);
>+    if (y != null)
>+        (*y)[1][0] = buffer;
>+    result[1][1] = modf(x[1][1], &buffer);
>+    if (y != null)
>+        (*y)[1][1] = buffer;
>+    result[2][0] = modf(x[2][0], &buffer);
>+    if (y != null)
>+        (*y)[2][0] = buffer;
>+    result[2][1] = modf(x[2][1], &buffer);
>+    if (y != null)
>+        (*y)[2][1] = buffer;
>+    result[3][0] = modf(x[3][0], &buffer);
>+    if (y != null)
>+        (*y)[3][0] = buffer;
>+    result[3][1] = modf(x[3][1], &buffer);
>+    if (y != null)
>+        (*y)[3][1] = buffer;
>+    return result;
>+}
>+float4x3 modf(float4x3 x, device float4x3* y) {
>+    float4x3 result;
>+    float buffer;
>+    result[0][0] = modf(x[0][0], &buffer);
>+    if (y != null)
>+        (*y)[0][0] = buffer;
>+    result[0][1] = modf(x[0][1], &buffer);
>+    if (y != null)
>+        (*y)[0][1] = buffer;
>+    result[0][2] = modf(x[0][2], &buffer);
>+    if (y != null)
>+        (*y)[0][2] = buffer;
>+    result[1][0] = modf(x[1][0], &buffer);
>+    if (y != null)
>+        (*y)[1][0] = buffer;
>+    result[1][1] = modf(x[1][1], &buffer);
>+    if (y != null)
>+        (*y)[1][1] = buffer;
>+    result[1][2] = modf(x[1][2], &buffer);
>+    if (y != null)
>+        (*y)[1][2] = buffer;
>+    result[2][0] = modf(x[2][0], &buffer);
>+    if (y != null)
>+        (*y)[2][0] = buffer;
>+    result[2][1] = modf(x[2][1], &buffer);
>+    if (y != null)
>+        (*y)[2][1] = buffer;
>+    result[2][2] = modf(x[2][2], &buffer);
>+    if (y != null)
>+        (*y)[2][2] = buffer;
>+    result[3][0] = modf(x[3][0], &buffer);
>+    if (y != null)
>+        (*y)[3][0] = buffer;
>+    result[3][1] = modf(x[3][1], &buffer);
>+    if (y != null)
>+        (*y)[3][1] = buffer;
>+    result[3][2] = modf(x[3][2], &buffer);
>+    if (y != null)
>+        (*y)[3][2] = buffer;
>+    return result;
>+}
>+float4x4 modf(float4x4 x, device float4x4* y) {
>+    float4x4 result;
>+    float buffer;
>+    result[0][0] = modf(x[0][0], &buffer);
>+    if (y != null)
>+        (*y)[0][0] = buffer;
>+    result[0][1] = modf(x[0][1], &buffer);
>+    if (y != null)
>+        (*y)[0][1] = buffer;
>+    result[0][2] = modf(x[0][2], &buffer);
>+    if (y != null)
>+        (*y)[0][2] = buffer;
>+    result[0][3] = modf(x[0][3], &buffer);
>+    if (y != null)
>+        (*y)[0][3] = buffer;
>+    result[1][0] = modf(x[1][0], &buffer);
>+    if (y != null)
>+        (*y)[1][0] = buffer;
>+    result[1][1] = modf(x[1][1], &buffer);
>+    if (y != null)
>+        (*y)[1][1] = buffer;
>+    result[1][2] = modf(x[1][2], &buffer);
>+    if (y != null)
>+        (*y)[1][2] = buffer;
>+    result[1][3] = modf(x[1][3], &buffer);
>+    if (y != null)
>+        (*y)[1][3] = buffer;
>+    result[2][0] = modf(x[2][0], &buffer);
>+    if (y != null)
>+        (*y)[2][0] = buffer;
>+    result[2][1] = modf(x[2][1], &buffer);
>+    if (y != null)
>+        (*y)[2][1] = buffer;
>+    result[2][2] = modf(x[2][2], &buffer);
>+    if (y != null)
>+        (*y)[2][2] = buffer;
>+    result[2][3] = modf(x[2][3], &buffer);
>+    if (y != null)
>+        (*y)[2][3] = buffer;
>+    result[3][0] = modf(x[3][0], &buffer);
>+    if (y != null)
>+        (*y)[3][0] = buffer;
>+    result[3][1] = modf(x[3][1], &buffer);
>+    if (y != null)
>+        (*y)[3][1] = buffer;
>+    result[3][2] = modf(x[3][2], &buffer);
>+    if (y != null)
>+        (*y)[3][2] = buffer;
>+    result[3][3] = modf(x[3][3], &buffer);
>+    if (y != null)
>+        (*y)[3][3] = buffer;
>+    return result;
>+}
>+
>+half modf(half x, threadgroup half* ip) {
>+    uint result = uint(x);
>+    if (ip != null)
>+        *ip = x - half(result);
>+    return half(result);
>+}
>+half2 modf(half2 x, threadgroup half2* y) {
>+    half2 result;
>+    half buffer;
>+    result[0] = modf(x[0], &buffer);
>+    if (y != null)
>+        (*y)[0] = buffer;
>+    result[1] = modf(x[1], &buffer);
>+    if (y != null)
>+        (*y)[1] = buffer;
>+    return result;
>+}
>+half3 modf(half3 x, threadgroup half3* y) {
>+    half3 result;
>+    half buffer;
>+    result[0] = modf(x[0], &buffer);
>+    if (y != null)
>+        (*y)[0] = buffer;
>+    result[1] = modf(x[1], &buffer);
>+    if (y != null)
>+        (*y)[1] = buffer;
>+    result[2] = modf(x[2], &buffer);
>+    if (y != null)
>+        (*y)[2] = buffer;
>+    return result;
>+}
>+half4 modf(half4 x, threadgroup half4* y) {
>+    half4 result;
>+    half buffer;
>+    result[0] = modf(x[0], &buffer);
>+    if (y != null)
>+        (*y)[0] = buffer;
>+    result[1] = modf(x[1], &buffer);
>+    if (y != null)
>+        (*y)[1] = buffer;
>+    result[2] = modf(x[2], &buffer);
>+    if (y != null)
>+        (*y)[2] = buffer;
>+    result[3] = modf(x[3], &buffer);
>+    if (y != null)
>+        (*y)[3] = buffer;
>+    return result;
>+}
>+half2x2 modf(half2x2 x, threadgroup half2x2* y) {
>+    half2x2 result;
>+    half buffer;
>+    result[0][0] = modf(x[0][0], &buffer);
>+    if (y != null)
>+        (*y)[0][0] = buffer;
>+    result[0][1] = modf(x[0][1], &buffer);
>+    if (y != null)
>+        (*y)[0][1] = buffer;
>+    result[1][0] = modf(x[1][0], &buffer);
>+    if (y != null)
>+        (*y)[1][0] = buffer;
>+    result[1][1] = modf(x[1][1], &buffer);
>+    if (y != null)
>+        (*y)[1][1] = buffer;
>+    return result;
>+}
>+half2x3 modf(half2x3 x, threadgroup half2x3* y) {
>+    half2x3 result;
>+    half buffer;
>+    result[0][0] = modf(x[0][0], &buffer);
>+    if (y != null)
>+        (*y)[0][0] = buffer;
>+    result[0][1] = modf(x[0][1], &buffer);
>+    if (y != null)
>+        (*y)[0][1] = buffer;
>+    result[0][2] = modf(x[0][2], &buffer);
>+    if (y != null)
>+        (*y)[0][2] = buffer;
>+    result[1][0] = modf(x[1][0], &buffer);
>+    if (y != null)
>+        (*y)[1][0] = buffer;
>+    result[1][1] = modf(x[1][1], &buffer);
>+    if (y != null)
>+        (*y)[1][1] = buffer;
>+    result[1][2] = modf(x[1][2], &buffer);
>+    if (y != null)
>+        (*y)[1][2] = buffer;
>+    return result;
>+}
>+half2x4 modf(half2x4 x, threadgroup half2x4* y) {
>+    half2x4 result;
>+    half buffer;
>+    result[0][0] = modf(x[0][0], &buffer);
>+    if (y != null)
>+        (*y)[0][0] = buffer;
>+    result[0][1] = modf(x[0][1], &buffer);
>+    if (y != null)
>+        (*y)[0][1] = buffer;
>+    result[0][2] = modf(x[0][2], &buffer);
>+    if (y != null)
>+        (*y)[0][2] = buffer;
>+    result[0][3] = modf(x[0][3], &buffer);
>+    if (y != null)
>+        (*y)[0][3] = buffer;
>+    result[1][0] = modf(x[1][0], &buffer);
>+    if (y != null)
>+        (*y)[1][0] = buffer;
>+    result[1][1] = modf(x[1][1], &buffer);
>+    if (y != null)
>+        (*y)[1][1] = buffer;
>+    result[1][2] = modf(x[1][2], &buffer);
>+    if (y != null)
>+        (*y)[1][2] = buffer;
>+    result[1][3] = modf(x[1][3], &buffer);
>+    if (y != null)
>+        (*y)[1][3] = buffer;
>+    return result;
>+}
>+half3x2 modf(half3x2 x, threadgroup half3x2* y) {
>+    half3x2 result;
>+    half buffer;
>+    result[0][0] = modf(x[0][0], &buffer);
>+    if (y != null)
>+        (*y)[0][0] = buffer;
>+    result[0][1] = modf(x[0][1], &buffer);
>+    if (y != null)
>+        (*y)[0][1] = buffer;
>+    result[1][0] = modf(x[1][0], &buffer);
>+    if (y != null)
>+        (*y)[1][0] = buffer;
>+    result[1][1] = modf(x[1][1], &buffer);
>+    if (y != null)
>+        (*y)[1][1] = buffer;
>+    result[2][0] = modf(x[2][0], &buffer);
>+    if (y != null)
>+        (*y)[2][0] = buffer;
>+    result[2][1] = modf(x[2][1], &buffer);
>+    if (y != null)
>+        (*y)[2][1] = buffer;
>+    return result;
>+}
>+half3x3 modf(half3x3 x, threadgroup half3x3* y) {
>+    half3x3 result;
>+    half buffer;
>+    result[0][0] = modf(x[0][0], &buffer);
>+    if (y != null)
>+        (*y)[0][0] = buffer;
>+    result[0][1] = modf(x[0][1], &buffer);
>+    if (y != null)
>+        (*y)[0][1] = buffer;
>+    result[0][2] = modf(x[0][2], &buffer);
>+    if (y != null)
>+        (*y)[0][2] = buffer;
>+    result[1][0] = modf(x[1][0], &buffer);
>+    if (y != null)
>+        (*y)[1][0] = buffer;
>+    result[1][1] = modf(x[1][1], &buffer);
>+    if (y != null)
>+        (*y)[1][1] = buffer;
>+    result[1][2] = modf(x[1][2], &buffer);
>+    if (y != null)
>+        (*y)[1][2] = buffer;
>+    result[2][0] = modf(x[2][0], &buffer);
>+    if (y != null)
>+        (*y)[2][0] = buffer;
>+    result[2][1] = modf(x[2][1], &buffer);
>+    if (y != null)
>+        (*y)[2][1] = buffer;
>+    result[2][2] = modf(x[2][2], &buffer);
>+    if (y != null)
>+        (*y)[2][2] = buffer;
>+    return result;
>+}
>+half3x4 modf(half3x4 x, threadgroup half3x4* y) {
>+    half3x4 result;
>+    half buffer;
>+    result[0][0] = modf(x[0][0], &buffer);
>+    if (y != null)
>+        (*y)[0][0] = buffer;
>+    result[0][1] = modf(x[0][1], &buffer);
>+    if (y != null)
>+        (*y)[0][1] = buffer;
>+    result[0][2] = modf(x[0][2], &buffer);
>+    if (y != null)
>+        (*y)[0][2] = buffer;
>+    result[0][3] = modf(x[0][3], &buffer);
>+    if (y != null)
>+        (*y)[0][3] = buffer;
>+    result[1][0] = modf(x[1][0], &buffer);
>+    if (y != null)
>+        (*y)[1][0] = buffer;
>+    result[1][1] = modf(x[1][1], &buffer);
>+    if (y != null)
>+        (*y)[1][1] = buffer;
>+    result[1][2] = modf(x[1][2], &buffer);
>+    if (y != null)
>+        (*y)[1][2] = buffer;
>+    result[1][3] = modf(x[1][3], &buffer);
>+    if (y != null)
>+        (*y)[1][3] = buffer;
>+    result[2][0] = modf(x[2][0], &buffer);
>+    if (y != null)
>+        (*y)[2][0] = buffer;
>+    result[2][1] = modf(x[2][1], &buffer);
>+    if (y != null)
>+        (*y)[2][1] = buffer;
>+    result[2][2] = modf(x[2][2], &buffer);
>+    if (y != null)
>+        (*y)[2][2] = buffer;
>+    result[2][3] = modf(x[2][3], &buffer);
>+    if (y != null)
>+        (*y)[2][3] = buffer;
>+    return result;
>+}
>+half4x2 modf(half4x2 x, threadgroup half4x2* y) {
>+    half4x2 result;
>+    half buffer;
>+    result[0][0] = modf(x[0][0], &buffer);
>+    if (y != null)
>+        (*y)[0][0] = buffer;
>+    result[0][1] = modf(x[0][1], &buffer);
>+    if (y != null)
>+        (*y)[0][1] = buffer;
>+    result[1][0] = modf(x[1][0], &buffer);
>+    if (y != null)
>+        (*y)[1][0] = buffer;
>+    result[1][1] = modf(x[1][1], &buffer);
>+    if (y != null)
>+        (*y)[1][1] = buffer;
>+    result[2][0] = modf(x[2][0], &buffer);
>+    if (y != null)
>+        (*y)[2][0] = buffer;
>+    result[2][1] = modf(x[2][1], &buffer);
>+    if (y != null)
>+        (*y)[2][1] = buffer;
>+    result[3][0] = modf(x[3][0], &buffer);
>+    if (y != null)
>+        (*y)[3][0] = buffer;
>+    result[3][1] = modf(x[3][1], &buffer);
>+    if (y != null)
>+        (*y)[3][1] = buffer;
>+    return result;
>+}
>+half4x3 modf(half4x3 x, threadgroup half4x3* y) {
>+    half4x3 result;
>+    half buffer;
>+    result[0][0] = modf(x[0][0], &buffer);
>+    if (y != null)
>+        (*y)[0][0] = buffer;
>+    result[0][1] = modf(x[0][1], &buffer);
>+    if (y != null)
>+        (*y)[0][1] = buffer;
>+    result[0][2] = modf(x[0][2], &buffer);
>+    if (y != null)
>+        (*y)[0][2] = buffer;
>+    result[1][0] = modf(x[1][0], &buffer);
>+    if (y != null)
>+        (*y)[1][0] = buffer;
>+    result[1][1] = modf(x[1][1], &buffer);
>+    if (y != null)
>+        (*y)[1][1] = buffer;
>+    result[1][2] = modf(x[1][2], &buffer);
>+    if (y != null)
>+        (*y)[1][2] = buffer;
>+    result[2][0] = modf(x[2][0], &buffer);
>+    if (y != null)
>+        (*y)[2][0] = buffer;
>+    result[2][1] = modf(x[2][1], &buffer);
>+    if (y != null)
>+        (*y)[2][1] = buffer;
>+    result[2][2] = modf(x[2][2], &buffer);
>+    if (y != null)
>+        (*y)[2][2] = buffer;
>+    result[3][0] = modf(x[3][0], &buffer);
>+    if (y != null)
>+        (*y)[3][0] = buffer;
>+    result[3][1] = modf(x[3][1], &buffer);
>+    if (y != null)
>+        (*y)[3][1] = buffer;
>+    result[3][2] = modf(x[3][2], &buffer);
>+    if (y != null)
>+        (*y)[3][2] = buffer;
>+    return result;
>+}
>+half4x4 modf(half4x4 x, threadgroup half4x4* y) {
>+    half4x4 result;
>+    half buffer;
>+    result[0][0] = modf(x[0][0], &buffer);
>+    if (y != null)
>+        (*y)[0][0] = buffer;
>+    result[0][1] = modf(x[0][1], &buffer);
>+    if (y != null)
>+        (*y)[0][1] = buffer;
>+    result[0][2] = modf(x[0][2], &buffer);
>+    if (y != null)
>+        (*y)[0][2] = buffer;
>+    result[0][3] = modf(x[0][3], &buffer);
>+    if (y != null)
>+        (*y)[0][3] = buffer;
>+    result[1][0] = modf(x[1][0], &buffer);
>+    if (y != null)
>+        (*y)[1][0] = buffer;
>+    result[1][1] = modf(x[1][1], &buffer);
>+    if (y != null)
>+        (*y)[1][1] = buffer;
>+    result[1][2] = modf(x[1][2], &buffer);
>+    if (y != null)
>+        (*y)[1][2] = buffer;
>+    result[1][3] = modf(x[1][3], &buffer);
>+    if (y != null)
>+        (*y)[1][3] = buffer;
>+    result[2][0] = modf(x[2][0], &buffer);
>+    if (y != null)
>+        (*y)[2][0] = buffer;
>+    result[2][1] = modf(x[2][1], &buffer);
>+    if (y != null)
>+        (*y)[2][1] = buffer;
>+    result[2][2] = modf(x[2][2], &buffer);
>+    if (y != null)
>+        (*y)[2][2] = buffer;
>+    result[2][3] = modf(x[2][3], &buffer);
>+    if (y != null)
>+        (*y)[2][3] = buffer;
>+    result[3][0] = modf(x[3][0], &buffer);
>+    if (y != null)
>+        (*y)[3][0] = buffer;
>+    result[3][1] = modf(x[3][1], &buffer);
>+    if (y != null)
>+        (*y)[3][1] = buffer;
>+    result[3][2] = modf(x[3][2], &buffer);
>+    if (y != null)
>+        (*y)[3][2] = buffer;
>+    result[3][3] = modf(x[3][3], &buffer);
>+    if (y != null)
>+        (*y)[3][3] = buffer;
>+    return result;
>+}
>+
>+float modf(float x, threadgroup float* ip) {
>+    uint result = uint(x);
>+    if (ip != null)
>+        *ip = x - float(result);
>+    return float(result);
>+}
>+float2 modf(float2 x, threadgroup float2* y) {
>+    float2 result;
>+    float buffer;
>+    result[0] = modf(x[0], &buffer);
>+    if (y != null)
>+        (*y)[0] = buffer;
>+    result[1] = modf(x[1], &buffer);
>+    if (y != null)
>+        (*y)[1] = buffer;
>+    return result;
>+}
>+float3 modf(float3 x, threadgroup float3* y) {
>+    float3 result;
>+    float buffer;
>+    result[0] = modf(x[0], &buffer);
>+    if (y != null)
>+        (*y)[0] = buffer;
>+    result[1] = modf(x[1], &buffer);
>+    if (y != null)
>+        (*y)[1] = buffer;
>+    result[2] = modf(x[2], &buffer);
>+    if (y != null)
>+        (*y)[2] = buffer;
>+    return result;
>+}
>+float4 modf(float4 x, threadgroup float4* y) {
>+    float4 result;
>+    float buffer;
>+    result[0] = modf(x[0], &buffer);
>+    if (y != null)
>+        (*y)[0] = buffer;
>+    result[1] = modf(x[1], &buffer);
>+    if (y != null)
>+        (*y)[1] = buffer;
>+    result[2] = modf(x[2], &buffer);
>+    if (y != null)
>+        (*y)[2] = buffer;
>+    result[3] = modf(x[3], &buffer);
>+    if (y != null)
>+        (*y)[3] = buffer;
>+    return result;
>+}
>+float2x2 modf(float2x2 x, threadgroup float2x2* y) {
>+    float2x2 result;
>+    float buffer;
>+    result[0][0] = modf(x[0][0], &buffer);
>+    if (y != null)
>+        (*y)[0][0] = buffer;
>+    result[0][1] = modf(x[0][1], &buffer);
>+    if (y != null)
>+        (*y)[0][1] = buffer;
>+    result[1][0] = modf(x[1][0], &buffer);
>+    if (y != null)
>+        (*y)[1][0] = buffer;
>+    result[1][1] = modf(x[1][1], &buffer);
>+    if (y != null)
>+        (*y)[1][1] = buffer;
>+    return result;
>+}
>+float2x3 modf(float2x3 x, threadgroup float2x3* y) {
>+    float2x3 result;
>+    float buffer;
>+    result[0][0] = modf(x[0][0], &buffer);
>+    if (y != null)
>+        (*y)[0][0] = buffer;
>+    result[0][1] = modf(x[0][1], &buffer);
>+    if (y != null)
>+        (*y)[0][1] = buffer;
>+    result[0][2] = modf(x[0][2], &buffer);
>+    if (y != null)
>+        (*y)[0][2] = buffer;
>+    result[1][0] = modf(x[1][0], &buffer);
>+    if (y != null)
>+        (*y)[1][0] = buffer;
>+    result[1][1] = modf(x[1][1], &buffer);
>+    if (y != null)
>+        (*y)[1][1] = buffer;
>+    result[1][2] = modf(x[1][2], &buffer);
>+    if (y != null)
>+        (*y)[1][2] = buffer;
>+    return result;
>+}
>+float2x4 modf(float2x4 x, threadgroup float2x4* y) {
>+    float2x4 result;
>+    float buffer;
>+    result[0][0] = modf(x[0][0], &buffer);
>+    if (y != null)
>+        (*y)[0][0] = buffer;
>+    result[0][1] = modf(x[0][1], &buffer);
>+    if (y != null)
>+        (*y)[0][1] = buffer;
>+    result[0][2] = modf(x[0][2], &buffer);
>+    if (y != null)
>+        (*y)[0][2] = buffer;
>+    result[0][3] = modf(x[0][3], &buffer);
>+    if (y != null)
>+        (*y)[0][3] = buffer;
>+    result[1][0] = modf(x[1][0], &buffer);
>+    if (y != null)
>+        (*y)[1][0] = buffer;
>+    result[1][1] = modf(x[1][1], &buffer);
>+    if (y != null)
>+        (*y)[1][1] = buffer;
>+    result[1][2] = modf(x[1][2], &buffer);
>+    if (y != null)
>+        (*y)[1][2] = buffer;
>+    result[1][3] = modf(x[1][3], &buffer);
>+    if (y != null)
>+        (*y)[1][3] = buffer;
>+    return result;
>+}
>+float3x2 modf(float3x2 x, threadgroup float3x2* y) {
>+    float3x2 result;
>+    float buffer;
>+    result[0][0] = modf(x[0][0], &buffer);
>+    if (y != null)
>+        (*y)[0][0] = buffer;
>+    result[0][1] = modf(x[0][1], &buffer);
>+    if (y != null)
>+        (*y)[0][1] = buffer;
>+    result[1][0] = modf(x[1][0], &buffer);
>+    if (y != null)
>+        (*y)[1][0] = buffer;
>+    result[1][1] = modf(x[1][1], &buffer);
>+    if (y != null)
>+        (*y)[1][1] = buffer;
>+    result[2][0] = modf(x[2][0], &buffer);
>+    if (y != null)
>+        (*y)[2][0] = buffer;
>+    result[2][1] = modf(x[2][1], &buffer);
>+    if (y != null)
>+        (*y)[2][1] = buffer;
>+    return result;
>+}
>+float3x3 modf(float3x3 x, threadgroup float3x3* y) {
>+    float3x3 result;
>+    float buffer;
>+    result[0][0] = modf(x[0][0], &buffer);
>+    if (y != null)
>+        (*y)[0][0] = buffer;
>+    result[0][1] = modf(x[0][1], &buffer);
>+    if (y != null)
>+        (*y)[0][1] = buffer;
>+    result[0][2] = modf(x[0][2], &buffer);
>+    if (y != null)
>+        (*y)[0][2] = buffer;
>+    result[1][0] = modf(x[1][0], &buffer);
>+    if (y != null)
>+        (*y)[1][0] = buffer;
>+    result[1][1] = modf(x[1][1], &buffer);
>+    if (y != null)
>+        (*y)[1][1] = buffer;
>+    result[1][2] = modf(x[1][2], &buffer);
>+    if (y != null)
>+        (*y)[1][2] = buffer;
>+    result[2][0] = modf(x[2][0], &buffer);
>+    if (y != null)
>+        (*y)[2][0] = buffer;
>+    result[2][1] = modf(x[2][1], &buffer);
>+    if (y != null)
>+        (*y)[2][1] = buffer;
>+    result[2][2] = modf(x[2][2], &buffer);
>+    if (y != null)
>+        (*y)[2][2] = buffer;
>+    return result;
>+}
>+float3x4 modf(float3x4 x, threadgroup float3x4* y) {
>+    float3x4 result;
>+    float buffer;
>+    result[0][0] = modf(x[0][0], &buffer);
>+    if (y != null)
>+        (*y)[0][0] = buffer;
>+    result[0][1] = modf(x[0][1], &buffer);
>+    if (y != null)
>+        (*y)[0][1] = buffer;
>+    result[0][2] = modf(x[0][2], &buffer);
>+    if (y != null)
>+        (*y)[0][2] = buffer;
>+    result[0][3] = modf(x[0][3], &buffer);
>+    if (y != null)
>+        (*y)[0][3] = buffer;
>+    result[1][0] = modf(x[1][0], &buffer);
>+    if (y != null)
>+        (*y)[1][0] = buffer;
>+    result[1][1] = modf(x[1][1], &buffer);
>+    if (y != null)
>+        (*y)[1][1] = buffer;
>+    result[1][2] = modf(x[1][2], &buffer);
>+    if (y != null)
>+        (*y)[1][2] = buffer;
>+    result[1][3] = modf(x[1][3], &buffer);
>+    if (y != null)
>+        (*y)[1][3] = buffer;
>+    result[2][0] = modf(x[2][0], &buffer);
>+    if (y != null)
>+        (*y)[2][0] = buffer;
>+    result[2][1] = modf(x[2][1], &buffer);
>+    if (y != null)
>+        (*y)[2][1] = buffer;
>+    result[2][2] = modf(x[2][2], &buffer);
>+    if (y != null)
>+        (*y)[2][2] = buffer;
>+    result[2][3] = modf(x[2][3], &buffer);
>+    if (y != null)
>+        (*y)[2][3] = buffer;
>+    return result;
>+}
>+float4x2 modf(float4x2 x, threadgroup float4x2* y) {
>+    float4x2 result;
>+    float buffer;
>+    result[0][0] = modf(x[0][0], &buffer);
>+    if (y != null)
>+        (*y)[0][0] = buffer;
>+    result[0][1] = modf(x[0][1], &buffer);
>+    if (y != null)
>+        (*y)[0][1] = buffer;
>+    result[1][0] = modf(x[1][0], &buffer);
>+    if (y != null)
>+        (*y)[1][0] = buffer;
>+    result[1][1] = modf(x[1][1], &buffer);
>+    if (y != null)
>+        (*y)[1][1] = buffer;
>+    result[2][0] = modf(x[2][0], &buffer);
>+    if (y != null)
>+        (*y)[2][0] = buffer;
>+    result[2][1] = modf(x[2][1], &buffer);
>+    if (y != null)
>+        (*y)[2][1] = buffer;
>+    result[3][0] = modf(x[3][0], &buffer);
>+    if (y != null)
>+        (*y)[3][0] = buffer;
>+    result[3][1] = modf(x[3][1], &buffer);
>+    if (y != null)
>+        (*y)[3][1] = buffer;
>+    return result;
>+}
>+float4x3 modf(float4x3 x, threadgroup float4x3* y) {
>+    float4x3 result;
>+    float buffer;
>+    result[0][0] = modf(x[0][0], &buffer);
>+    if (y != null)
>+        (*y)[0][0] = buffer;
>+    result[0][1] = modf(x[0][1], &buffer);
>+    if (y != null)
>+        (*y)[0][1] = buffer;
>+    result[0][2] = modf(x[0][2], &buffer);
>+    if (y != null)
>+        (*y)[0][2] = buffer;
>+    result[1][0] = modf(x[1][0], &buffer);
>+    if (y != null)
>+        (*y)[1][0] = buffer;
>+    result[1][1] = modf(x[1][1], &buffer);
>+    if (y != null)
>+        (*y)[1][1] = buffer;
>+    result[1][2] = modf(x[1][2], &buffer);
>+    if (y != null)
>+        (*y)[1][2] = buffer;
>+    result[2][0] = modf(x[2][0], &buffer);
>+    if (y != null)
>+        (*y)[2][0] = buffer;
>+    result[2][1] = modf(x[2][1], &buffer);
>+    if (y != null)
>+        (*y)[2][1] = buffer;
>+    result[2][2] = modf(x[2][2], &buffer);
>+    if (y != null)
>+        (*y)[2][2] = buffer;
>+    result[3][0] = modf(x[3][0], &buffer);
>+    if (y != null)
>+        (*y)[3][0] = buffer;
>+    result[3][1] = modf(x[3][1], &buffer);
>+    if (y != null)
>+        (*y)[3][1] = buffer;
>+    result[3][2] = modf(x[3][2], &buffer);
>+    if (y != null)
>+        (*y)[3][2] = buffer;
>+    return result;
>+}
>+float4x4 modf(float4x4 x, threadgroup float4x4* y) {
>+    float4x4 result;
>+    float buffer;
>+    result[0][0] = modf(x[0][0], &buffer);
>+    if (y != null)
>+        (*y)[0][0] = buffer;
>+    result[0][1] = modf(x[0][1], &buffer);
>+    if (y != null)
>+        (*y)[0][1] = buffer;
>+    result[0][2] = modf(x[0][2], &buffer);
>+    if (y != null)
>+        (*y)[0][2] = buffer;
>+    result[0][3] = modf(x[0][3], &buffer);
>+    if (y != null)
>+        (*y)[0][3] = buffer;
>+    result[1][0] = modf(x[1][0], &buffer);
>+    if (y != null)
>+        (*y)[1][0] = buffer;
>+    result[1][1] = modf(x[1][1], &buffer);
>+    if (y != null)
>+        (*y)[1][1] = buffer;
>+    result[1][2] = modf(x[1][2], &buffer);
>+    if (y != null)
>+        (*y)[1][2] = buffer;
>+    result[1][3] = modf(x[1][3], &buffer);
>+    if (y != null)
>+        (*y)[1][3] = buffer;
>+    result[2][0] = modf(x[2][0], &buffer);
>+    if (y != null)
>+        (*y)[2][0] = buffer;
>+    result[2][1] = modf(x[2][1], &buffer);
>+    if (y != null)
>+        (*y)[2][1] = buffer;
>+    result[2][2] = modf(x[2][2], &buffer);
>+    if (y != null)
>+        (*y)[2][2] = buffer;
>+    result[2][3] = modf(x[2][3], &buffer);
>+    if (y != null)
>+        (*y)[2][3] = buffer;
>+    result[3][0] = modf(x[3][0], &buffer);
>+    if (y != null)
>+        (*y)[3][0] = buffer;
>+    result[3][1] = modf(x[3][1], &buffer);
>+    if (y != null)
>+        (*y)[3][1] = buffer;
>+    result[3][2] = modf(x[3][2], &buffer);
>+    if (y != null)
>+        (*y)[3][2] = buffer;
>+    result[3][3] = modf(x[3][3], &buffer);
>+    if (y != null)
>+        (*y)[3][3] = buffer;
>+    return result;
>+}
>+
>+
>+/* Functions named operator.wy= */
>+bool4 operator.wy=(bool4 v, bool2 c) {
>+    bool4 result = v;
>+    result.w = c.x;
>+    result.y = c.y;
>+    return result;
>+}
>+uchar4 operator.wy=(uchar4 v, uchar2 c) {
>+    uchar4 result = v;
>+    result.w = c.x;
>+    result.y = c.y;
>+    return result;
>+}
>+ushort4 operator.wy=(ushort4 v, ushort2 c) {
>+    ushort4 result = v;
>+    result.w = c.x;
>+    result.y = c.y;
>+    return result;
>+}
>+uint4 operator.wy=(uint4 v, uint2 c) {
>+    uint4 result = v;
>+    result.w = c.x;
>+    result.y = c.y;
>+    return result;
>+}
>+char4 operator.wy=(char4 v, char2 c) {
>+    char4 result = v;
>+    result.w = c.x;
>+    result.y = c.y;
>+    return result;
>+}
>+short4 operator.wy=(short4 v, short2 c) {
>+    short4 result = v;
>+    result.w = c.x;
>+    result.y = c.y;
>+    return result;
>+}
>+int4 operator.wy=(int4 v, int2 c) {
>+    int4 result = v;
>+    result.w = c.x;
>+    result.y = c.y;
>+    return result;
>+}
>+half4 operator.wy=(half4 v, half2 c) {
>+    half4 result = v;
>+    result.w = c.x;
>+    result.y = c.y;
>+    return result;
>+}
>+float4 operator.wy=(float4 v, float2 c) {
>+    float4 result = v;
>+    result.w = c.x;
>+    result.y = c.y;
>+    return result;
>+}
>+
>+/* Functions named operator[]= */
>+bool2 operator[]=(bool2 v, uint index, bool a) {
>+    switch (index) {
>+        case 0:
>+            v.x = a;
>+            break;
>+        case 1:
>+            v.y = a;
>+            break;
>+        default:
>+            break;
>+    }
>+    return v;
>+}
>+bool3 operator[]=(bool3 v, uint index, bool a) {
>+    switch (index) {
>+        case 0:
>+            v.x = a;
>+            break;
>+        case 1:
>+            v.y = a;
>+            break;
>+        case 2:
>+            v.z = a;
>+            break;
>+        default:
>+            break;
>+    }
>+    return v;
>+}
>+bool4 operator[]=(bool4 v, uint index, bool a) {
>+    switch (index) {
>+        case 0:
>+            v.x = a;
>+            break;
>+        case 1:
>+            v.y = a;
>+            break;
>+        case 2:
>+            v.z = a;
>+            break;
>+        case 3:
>+            v.w = a;
>+            break;
>+        default:
>+            break;
>+    }
>+    return v;
>+}
>+uchar2 operator[]=(uchar2 v, uint index, uchar a) {
>+    switch (index) {
>+        case 0:
>+            v.x = a;
>+            break;
>+        case 1:
>+            v.y = a;
>+            break;
>+        default:
>+            break;
>+    }
>+    return v;
>+}
>+uchar3 operator[]=(uchar3 v, uint index, uchar a) {
>+    switch (index) {
>+        case 0:
>+            v.x = a;
>+            break;
>+        case 1:
>+            v.y = a;
>+            break;
>+        case 2:
>+            v.z = a;
>+            break;
>+        default:
>+            break;
>+    }
>+    return v;
>+}
>+uchar4 operator[]=(uchar4 v, uint index, uchar a) {
>+    switch (index) {
>+        case 0:
>+            v.x = a;
>+            break;
>+        case 1:
>+            v.y = a;
>+            break;
>+        case 2:
>+            v.z = a;
>+            break;
>+        case 3:
>+            v.w = a;
>+            break;
>+        default:
>+            break;
>+    }
>+    return v;
>+}
>+ushort2 operator[]=(ushort2 v, uint index, ushort a) {
>+    switch (index) {
>+        case 0:
>+            v.x = a;
>+            break;
>+        case 1:
>+            v.y = a;
>+            break;
>+        default:
>+            break;
>+    }
>+    return v;
>+}
>+ushort3 operator[]=(ushort3 v, uint index, ushort a) {
>+    switch (index) {
>+        case 0:
>+            v.x = a;
>+            break;
>+        case 1:
>+            v.y = a;
>+            break;
>+        case 2:
>+            v.z = a;
>+            break;
>+        default:
>+            break;
>+    }
>+    return v;
>+}
>+ushort4 operator[]=(ushort4 v, uint index, ushort a) {
>+    switch (index) {
>+        case 0:
>+            v.x = a;
>+            break;
>+        case 1:
>+            v.y = a;
>+            break;
>+        case 2:
>+            v.z = a;
>+            break;
>+        case 3:
>+            v.w = a;
>+            break;
>+        default:
>+            break;
>+    }
>+    return v;
>+}
>+uint2 operator[]=(uint2 v, uint index, uint a) {
>+    switch (index) {
>+        case 0:
>+            v.x = a;
>+            break;
>+        case 1:
>+            v.y = a;
>+            break;
>+        default:
>+            break;
>+    }
>+    return v;
>+}
>+uint3 operator[]=(uint3 v, uint index, uint a) {
>+    switch (index) {
>+        case 0:
>+            v.x = a;
>+            break;
>+        case 1:
>+            v.y = a;
>+            break;
>+        case 2:
>+            v.z = a;
>+            break;
>+        default:
>+            break;
>+    }
>+    return v;
>+}
>+uint4 operator[]=(uint4 v, uint index, uint a) {
>+    switch (index) {
>+        case 0:
>+            v.x = a;
>+            break;
>+        case 1:
>+            v.y = a;
>+            break;
>+        case 2:
>+            v.z = a;
>+            break;
>+        case 3:
>+            v.w = a;
>+            break;
>+        default:
>+            break;
>+    }
>+    return v;
>+}
>+char2 operator[]=(char2 v, uint index, char a) {
>+    switch (index) {
>+        case 0:
>+            v.x = a;
>+            break;
>+        case 1:
>+            v.y = a;
>+            break;
>+        default:
>+            break;
>+    }
>+    return v;
>+}
>+char3 operator[]=(char3 v, uint index, char a) {
>+    switch (index) {
>+        case 0:
>+            v.x = a;
>+            break;
>+        case 1:
>+            v.y = a;
>+            break;
>+        case 2:
>+            v.z = a;
>+            break;
>+        default:
>+            break;
>+    }
>+    return v;
>+}
>+char4 operator[]=(char4 v, uint index, char a) {
>+    switch (index) {
>+        case 0:
>+            v.x = a;
>+            break;
>+        case 1:
>+            v.y = a;
>+            break;
>+        case 2:
>+            v.z = a;
>+            break;
>+        case 3:
>+            v.w = a;
>+            break;
>+        default:
>+            break;
>+    }
>+    return v;
>+}
>+short2 operator[]=(short2 v, uint index, short a) {
>+    switch (index) {
>+        case 0:
>+            v.x = a;
>+            break;
>+        case 1:
>+            v.y = a;
>+            break;
>+        default:
>+            break;
>+    }
>+    return v;
>+}
>+short3 operator[]=(short3 v, uint index, short a) {
>+    switch (index) {
>+        case 0:
>+            v.x = a;
>+            break;
>+        case 1:
>+            v.y = a;
>+            break;
>+        case 2:
>+            v.z = a;
>+            break;
>+        default:
>+            break;
>+    }
>+    return v;
>+}
>+short4 operator[]=(short4 v, uint index, short a) {
>+    switch (index) {
>+        case 0:
>+            v.x = a;
>+            break;
>+        case 1:
>+            v.y = a;
>+            break;
>+        case 2:
>+            v.z = a;
>+            break;
>+        case 3:
>+            v.w = a;
>+            break;
>+        default:
>+            break;
>+    }
>+    return v;
>+}
>+int2 operator[]=(int2 v, uint index, int a) {
>+    switch (index) {
>+        case 0:
>+            v.x = a;
>+            break;
>+        case 1:
>+            v.y = a;
>+            break;
>+        default:
>+            break;
>+    }
>+    return v;
>+}
>+int3 operator[]=(int3 v, uint index, int a) {
>+    switch (index) {
>+        case 0:
>+            v.x = a;
>+            break;
>+        case 1:
>+            v.y = a;
>+            break;
>+        case 2:
>+            v.z = a;
>+            break;
>+        default:
>+            break;
>+    }
>+    return v;
>+}
>+int4 operator[]=(int4 v, uint index, int a) {
>+    switch (index) {
>+        case 0:
>+            v.x = a;
>+            break;
>+        case 1:
>+            v.y = a;
>+            break;
>+        case 2:
>+            v.z = a;
>+            break;
>+        case 3:
>+            v.w = a;
>+            break;
>+        default:
>+            break;
>+    }
>+    return v;
>+}
>+half2 operator[]=(half2 v, uint index, half a) {
>+    switch (index) {
>+        case 0:
>+            v.x = a;
>+            break;
>+        case 1:
>+            v.y = a;
>+            break;
>+        default:
>+            break;
>+    }
>+    return v;
>+}
>+half3 operator[]=(half3 v, uint index, half a) {
>+    switch (index) {
>+        case 0:
>+            v.x = a;
>+            break;
>+        case 1:
>+            v.y = a;
>+            break;
>+        case 2:
>+            v.z = a;
>+            break;
>+        default:
>+            break;
>+    }
>+    return v;
>+}
>+half4 operator[]=(half4 v, uint index, half a) {
>+    switch (index) {
>+        case 0:
>+            v.x = a;
>+            break;
>+        case 1:
>+            v.y = a;
>+            break;
>+        case 2:
>+            v.z = a;
>+            break;
>+        case 3:
>+            v.w = a;
>+            break;
>+        default:
>+            break;
>+    }
>+    return v;
>+}
>+float2 operator[]=(float2 v, uint index, float a) {
>+    switch (index) {
>+        case 0:
>+            v.x = a;
>+            break;
>+        case 1:
>+            v.y = a;
>+            break;
>+        default:
>+            break;
>+    }
>+    return v;
>+}
>+float3 operator[]=(float3 v, uint index, float a) {
>+    switch (index) {
>+        case 0:
>+            v.x = a;
>+            break;
>+        case 1:
>+            v.y = a;
>+            break;
>+        case 2:
>+            v.z = a;
>+            break;
>+        default:
>+            break;
>+    }
>+    return v;
>+}
>+float4 operator[]=(float4 v, uint index, float a) {
>+    switch (index) {
>+        case 0:
>+            v.x = a;
>+            break;
>+        case 1:
>+            v.y = a;
>+            break;
>+        case 2:
>+            v.z = a;
>+            break;
>+        case 3:
>+            v.w = a;
>+            break;
>+        default:
>+            break;
>+    }
>+    return v;
>+}
>+
>+native half2x2 operator[]=(half2x2, uint, half2);
>+native half2x3 operator[]=(half2x3, uint, half3);
>+native half2x4 operator[]=(half2x4, uint, half4);
>+native half3x2 operator[]=(half3x2, uint, half2);
>+native half3x3 operator[]=(half3x3, uint, half3);
>+native half3x4 operator[]=(half3x4, uint, half4);
>+native half4x2 operator[]=(half4x2, uint, half2);
>+native half4x3 operator[]=(half4x3, uint, half3);
>+native half4x4 operator[]=(half4x4, uint, half4);
>+native float2x2 operator[]=(float2x2, uint, float2);
>+native float2x3 operator[]=(float2x3, uint, float3);
>+native float2x4 operator[]=(float2x4, uint, float4);
>+native float3x2 operator[]=(float3x2, uint, float2);
>+native float3x3 operator[]=(float3x3, uint, float3);
>+native float3x4 operator[]=(float3x4, uint, float4);
>+native float4x2 operator[]=(float4x2, uint, float2);
>+native float4x3 operator[]=(float4x3, uint, float3);
>+native float4x4 operator[]=(float4x4, uint, float4);
>+
>+
>+/* Functions named operator.yxyx */
>+bool4 operator.yxyx(bool2 v) {
>+    bool4 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.y;
>+    result.w = v.x;
>+    return result;
>+}
>+bool4 operator.yxyx(bool3 v) {
>+    bool4 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.y;
>+    result.w = v.x;
>+    return result;
>+}
>+bool4 operator.yxyx(bool4 v) {
>+    bool4 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.y;
>+    result.w = v.x;
>+    return result;
>+}
>+uchar4 operator.yxyx(uchar2 v) {
>+    uchar4 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.y;
>+    result.w = v.x;
>+    return result;
>+}
>+uchar4 operator.yxyx(uchar3 v) {
>+    uchar4 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.y;
>+    result.w = v.x;
>+    return result;
>+}
>+uchar4 operator.yxyx(uchar4 v) {
>+    uchar4 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.y;
>+    result.w = v.x;
>+    return result;
>+}
>+ushort4 operator.yxyx(ushort2 v) {
>+    ushort4 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.y;
>+    result.w = v.x;
>+    return result;
>+}
>+ushort4 operator.yxyx(ushort3 v) {
>+    ushort4 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.y;
>+    result.w = v.x;
>+    return result;
>+}
>+ushort4 operator.yxyx(ushort4 v) {
>+    ushort4 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.y;
>+    result.w = v.x;
>+    return result;
>+}
>+uint4 operator.yxyx(uint2 v) {
>+    uint4 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.y;
>+    result.w = v.x;
>+    return result;
>+}
>+uint4 operator.yxyx(uint3 v) {
>+    uint4 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.y;
>+    result.w = v.x;
>+    return result;
>+}
>+uint4 operator.yxyx(uint4 v) {
>+    uint4 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.y;
>+    result.w = v.x;
>+    return result;
>+}
>+char4 operator.yxyx(char2 v) {
>+    char4 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.y;
>+    result.w = v.x;
>+    return result;
>+}
>+char4 operator.yxyx(char3 v) {
>+    char4 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.y;
>+    result.w = v.x;
>+    return result;
>+}
>+char4 operator.yxyx(char4 v) {
>+    char4 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.y;
>+    result.w = v.x;
>+    return result;
>+}
>+short4 operator.yxyx(short2 v) {
>+    short4 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.y;
>+    result.w = v.x;
>+    return result;
>+}
>+short4 operator.yxyx(short3 v) {
>+    short4 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.y;
>+    result.w = v.x;
>+    return result;
>+}
>+short4 operator.yxyx(short4 v) {
>+    short4 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.y;
>+    result.w = v.x;
>+    return result;
>+}
>+int4 operator.yxyx(int2 v) {
>+    int4 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.y;
>+    result.w = v.x;
>+    return result;
>+}
>+int4 operator.yxyx(int3 v) {
>+    int4 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.y;
>+    result.w = v.x;
>+    return result;
>+}
>+int4 operator.yxyx(int4 v) {
>+    int4 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.y;
>+    result.w = v.x;
>+    return result;
>+}
>+half4 operator.yxyx(half2 v) {
>+    half4 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.y;
>+    result.w = v.x;
>+    return result;
>+}
>+half4 operator.yxyx(half3 v) {
>+    half4 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.y;
>+    result.w = v.x;
>+    return result;
>+}
>+half4 operator.yxyx(half4 v) {
>+    half4 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.y;
>+    result.w = v.x;
>+    return result;
>+}
>+float4 operator.yxyx(float2 v) {
>+    float4 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.y;
>+    result.w = v.x;
>+    return result;
>+}
>+float4 operator.yxyx(float3 v) {
>+    float4 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.y;
>+    result.w = v.x;
>+    return result;
>+}
>+float4 operator.yxyx(float4 v) {
>+    float4 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.y;
>+    result.w = v.x;
>+    return result;
>+}
>+
>+/* Functions named operator.zwxy */
>+bool4 operator.zwxy(bool4 v) {
>+    bool4 result;
>+    result.x = v.z;
>+    result.y = v.w;
>+    result.z = v.x;
>+    result.w = v.y;
>+    return result;
>+}
>+uchar4 operator.zwxy(uchar4 v) {
>+    uchar4 result;
>+    result.x = v.z;
>+    result.y = v.w;
>+    result.z = v.x;
>+    result.w = v.y;
>+    return result;
>+}
>+ushort4 operator.zwxy(ushort4 v) {
>+    ushort4 result;
>+    result.x = v.z;
>+    result.y = v.w;
>+    result.z = v.x;
>+    result.w = v.y;
>+    return result;
>+}
>+uint4 operator.zwxy(uint4 v) {
>+    uint4 result;
>+    result.x = v.z;
>+    result.y = v.w;
>+    result.z = v.x;
>+    result.w = v.y;
>+    return result;
>+}
>+char4 operator.zwxy(char4 v) {
>+    char4 result;
>+    result.x = v.z;
>+    result.y = v.w;
>+    result.z = v.x;
>+    result.w = v.y;
>+    return result;
>+}
>+short4 operator.zwxy(short4 v) {
>+    short4 result;
>+    result.x = v.z;
>+    result.y = v.w;
>+    result.z = v.x;
>+    result.w = v.y;
>+    return result;
>+}
>+int4 operator.zwxy(int4 v) {
>+    int4 result;
>+    result.x = v.z;
>+    result.y = v.w;
>+    result.z = v.x;
>+    result.w = v.y;
>+    return result;
>+}
>+half4 operator.zwxy(half4 v) {
>+    half4 result;
>+    result.x = v.z;
>+    result.y = v.w;
>+    result.z = v.x;
>+    result.w = v.y;
>+    return result;
>+}
>+float4 operator.zwxy(float4 v) {
>+    float4 result;
>+    result.x = v.z;
>+    result.y = v.w;
>+    result.z = v.x;
>+    result.w = v.y;
>+    return result;
>+}
>+
>+/* Functions named operator.wyyw */
>+bool4 operator.wyyw(bool4 v) {
>+    bool4 result;
>+    result.x = v.w;
>+    result.y = v.y;
>+    result.z = v.y;
>+    result.w = v.w;
>+    return result;
>+}
>+uchar4 operator.wyyw(uchar4 v) {
>+    uchar4 result;
>+    result.x = v.w;
>+    result.y = v.y;
>+    result.z = v.y;
>+    result.w = v.w;
>+    return result;
>+}
>+ushort4 operator.wyyw(ushort4 v) {
>+    ushort4 result;
>+    result.x = v.w;
>+    result.y = v.y;
>+    result.z = v.y;
>+    result.w = v.w;
>+    return result;
>+}
>+uint4 operator.wyyw(uint4 v) {
>+    uint4 result;
>+    result.x = v.w;
>+    result.y = v.y;
>+    result.z = v.y;
>+    result.w = v.w;
>+    return result;
>+}
>+char4 operator.wyyw(char4 v) {
>+    char4 result;
>+    result.x = v.w;
>+    result.y = v.y;
>+    result.z = v.y;
>+    result.w = v.w;
>+    return result;
>+}
>+short4 operator.wyyw(short4 v) {
>+    short4 result;
>+    result.x = v.w;
>+    result.y = v.y;
>+    result.z = v.y;
>+    result.w = v.w;
>+    return result;
>+}
>+int4 operator.wyyw(int4 v) {
>+    int4 result;
>+    result.x = v.w;
>+    result.y = v.y;
>+    result.z = v.y;
>+    result.w = v.w;
>+    return result;
>+}
>+half4 operator.wyyw(half4 v) {
>+    half4 result;
>+    result.x = v.w;
>+    result.y = v.y;
>+    result.z = v.y;
>+    result.w = v.w;
>+    return result;
>+}
>+float4 operator.wyyw(float4 v) {
>+    float4 result;
>+    result.x = v.w;
>+    result.y = v.y;
>+    result.z = v.y;
>+    result.w = v.w;
>+    return result;
>+}
>+
>+/* Functions named operator.xxxw */
>+bool4 operator.xxxw(bool4 v) {
>+    bool4 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.x;
>+    result.w = v.w;
>+    return result;
>+}
>+uchar4 operator.xxxw(uchar4 v) {
>+    uchar4 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.x;
>+    result.w = v.w;
>+    return result;
>+}
>+ushort4 operator.xxxw(ushort4 v) {
>+    ushort4 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.x;
>+    result.w = v.w;
>+    return result;
>+}
>+uint4 operator.xxxw(uint4 v) {
>+    uint4 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.x;
>+    result.w = v.w;
>+    return result;
>+}
>+char4 operator.xxxw(char4 v) {
>+    char4 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.x;
>+    result.w = v.w;
>+    return result;
>+}
>+short4 operator.xxxw(short4 v) {
>+    short4 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.x;
>+    result.w = v.w;
>+    return result;
>+}
>+int4 operator.xxxw(int4 v) {
>+    int4 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.x;
>+    result.w = v.w;
>+    return result;
>+}
>+half4 operator.xxxw(half4 v) {
>+    half4 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.x;
>+    result.w = v.w;
>+    return result;
>+}
>+float4 operator.xxxw(float4 v) {
>+    float4 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.x;
>+    result.w = v.w;
>+    return result;
>+}
>+
>+/* Functions named operator.ywy */
>+bool3 operator.ywy(bool4 v) {
>+    bool3 result;
>+    result.x = v.y;
>+    result.y = v.w;
>+    result.z = v.y;
>+    return result;
>+}
>+uchar3 operator.ywy(uchar4 v) {
>+    uchar3 result;
>+    result.x = v.y;
>+    result.y = v.w;
>+    result.z = v.y;
>+    return result;
>+}
>+ushort3 operator.ywy(ushort4 v) {
>+    ushort3 result;
>+    result.x = v.y;
>+    result.y = v.w;
>+    result.z = v.y;
>+    return result;
>+}
>+uint3 operator.ywy(uint4 v) {
>+    uint3 result;
>+    result.x = v.y;
>+    result.y = v.w;
>+    result.z = v.y;
>+    return result;
>+}
>+char3 operator.ywy(char4 v) {
>+    char3 result;
>+    result.x = v.y;
>+    result.y = v.w;
>+    result.z = v.y;
>+    return result;
>+}
>+short3 operator.ywy(short4 v) {
>+    short3 result;
>+    result.x = v.y;
>+    result.y = v.w;
>+    result.z = v.y;
>+    return result;
>+}
>+int3 operator.ywy(int4 v) {
>+    int3 result;
>+    result.x = v.y;
>+    result.y = v.w;
>+    result.z = v.y;
>+    return result;
>+}
>+half3 operator.ywy(half4 v) {
>+    half3 result;
>+    result.x = v.y;
>+    result.y = v.w;
>+    result.z = v.y;
>+    return result;
>+}
>+float3 operator.ywy(float4 v) {
>+    float3 result;
>+    result.x = v.y;
>+    result.y = v.w;
>+    result.z = v.y;
>+    return result;
>+}
>+
>+/* Functions named operator.xyzw= */
>+bool4 operator.xyzw=(bool4 v, bool4 c) {
>+    bool4 result = v;
>+    result.x = c.x;
>+    result.y = c.y;
>+    result.z = c.z;
>+    result.w = c.w;
>+    return result;
>+}
>+uchar4 operator.xyzw=(uchar4 v, uchar4 c) {
>+    uchar4 result = v;
>+    result.x = c.x;
>+    result.y = c.y;
>+    result.z = c.z;
>+    result.w = c.w;
>+    return result;
>+}
>+ushort4 operator.xyzw=(ushort4 v, ushort4 c) {
>+    ushort4 result = v;
>+    result.x = c.x;
>+    result.y = c.y;
>+    result.z = c.z;
>+    result.w = c.w;
>+    return result;
>+}
>+uint4 operator.xyzw=(uint4 v, uint4 c) {
>+    uint4 result = v;
>+    result.x = c.x;
>+    result.y = c.y;
>+    result.z = c.z;
>+    result.w = c.w;
>+    return result;
>+}
>+char4 operator.xyzw=(char4 v, char4 c) {
>+    char4 result = v;
>+    result.x = c.x;
>+    result.y = c.y;
>+    result.z = c.z;
>+    result.w = c.w;
>+    return result;
>+}
>+short4 operator.xyzw=(short4 v, short4 c) {
>+    short4 result = v;
>+    result.x = c.x;
>+    result.y = c.y;
>+    result.z = c.z;
>+    result.w = c.w;
>+    return result;
>+}
>+int4 operator.xyzw=(int4 v, int4 c) {
>+    int4 result = v;
>+    result.x = c.x;
>+    result.y = c.y;
>+    result.z = c.z;
>+    result.w = c.w;
>+    return result;
>+}
>+half4 operator.xyzw=(half4 v, half4 c) {
>+    half4 result = v;
>+    result.x = c.x;
>+    result.y = c.y;
>+    result.z = c.z;
>+    result.w = c.w;
>+    return result;
>+}
>+float4 operator.xyzw=(float4 v, float4 c) {
>+    float4 result = v;
>+    result.x = c.x;
>+    result.y = c.y;
>+    result.z = c.z;
>+    result.w = c.w;
>+    return result;
>+}
>+
>+/* Functions named operator.xzww */
>+bool4 operator.xzww(bool4 v) {
>+    bool4 result;
>+    result.x = v.x;
>+    result.y = v.z;
>+    result.z = v.w;
>+    result.w = v.w;
>+    return result;
>+}
>+uchar4 operator.xzww(uchar4 v) {
>+    uchar4 result;
>+    result.x = v.x;
>+    result.y = v.z;
>+    result.z = v.w;
>+    result.w = v.w;
>+    return result;
>+}
>+ushort4 operator.xzww(ushort4 v) {
>+    ushort4 result;
>+    result.x = v.x;
>+    result.y = v.z;
>+    result.z = v.w;
>+    result.w = v.w;
>+    return result;
>+}
>+uint4 operator.xzww(uint4 v) {
>+    uint4 result;
>+    result.x = v.x;
>+    result.y = v.z;
>+    result.z = v.w;
>+    result.w = v.w;
>+    return result;
>+}
>+char4 operator.xzww(char4 v) {
>+    char4 result;
>+    result.x = v.x;
>+    result.y = v.z;
>+    result.z = v.w;
>+    result.w = v.w;
>+    return result;
>+}
>+short4 operator.xzww(short4 v) {
>+    short4 result;
>+    result.x = v.x;
>+    result.y = v.z;
>+    result.z = v.w;
>+    result.w = v.w;
>+    return result;
>+}
>+int4 operator.xzww(int4 v) {
>+    int4 result;
>+    result.x = v.x;
>+    result.y = v.z;
>+    result.z = v.w;
>+    result.w = v.w;
>+    return result;
>+}
>+half4 operator.xzww(half4 v) {
>+    half4 result;
>+    result.x = v.x;
>+    result.y = v.z;
>+    result.z = v.w;
>+    result.w = v.w;
>+    return result;
>+}
>+float4 operator.xzww(float4 v) {
>+    float4 result;
>+    result.x = v.x;
>+    result.y = v.z;
>+    result.z = v.w;
>+    result.w = v.w;
>+    return result;
>+}
>+
>+/* Functions named operator.xzwy */
>+bool4 operator.xzwy(bool4 v) {
>+    bool4 result;
>+    result.x = v.x;
>+    result.y = v.z;
>+    result.z = v.w;
>+    result.w = v.y;
>+    return result;
>+}
>+uchar4 operator.xzwy(uchar4 v) {
>+    uchar4 result;
>+    result.x = v.x;
>+    result.y = v.z;
>+    result.z = v.w;
>+    result.w = v.y;
>+    return result;
>+}
>+ushort4 operator.xzwy(ushort4 v) {
>+    ushort4 result;
>+    result.x = v.x;
>+    result.y = v.z;
>+    result.z = v.w;
>+    result.w = v.y;
>+    return result;
>+}
>+uint4 operator.xzwy(uint4 v) {
>+    uint4 result;
>+    result.x = v.x;
>+    result.y = v.z;
>+    result.z = v.w;
>+    result.w = v.y;
>+    return result;
>+}
>+char4 operator.xzwy(char4 v) {
>+    char4 result;
>+    result.x = v.x;
>+    result.y = v.z;
>+    result.z = v.w;
>+    result.w = v.y;
>+    return result;
>+}
>+short4 operator.xzwy(short4 v) {
>+    short4 result;
>+    result.x = v.x;
>+    result.y = v.z;
>+    result.z = v.w;
>+    result.w = v.y;
>+    return result;
>+}
>+int4 operator.xzwy(int4 v) {
>+    int4 result;
>+    result.x = v.x;
>+    result.y = v.z;
>+    result.z = v.w;
>+    result.w = v.y;
>+    return result;
>+}
>+half4 operator.xzwy(half4 v) {
>+    half4 result;
>+    result.x = v.x;
>+    result.y = v.z;
>+    result.z = v.w;
>+    result.w = v.y;
>+    return result;
>+}
>+float4 operator.xzwy(float4 v) {
>+    float4 result;
>+    result.x = v.x;
>+    result.y = v.z;
>+    result.z = v.w;
>+    result.w = v.y;
>+    return result;
>+}
>+
>+/* Functions named operator.wwwz */
>+bool4 operator.wwwz(bool4 v) {
>+    bool4 result;
>+    result.x = v.w;
>+    result.y = v.w;
>+    result.z = v.w;
>+    result.w = v.z;
>+    return result;
>+}
>+uchar4 operator.wwwz(uchar4 v) {
>+    uchar4 result;
>+    result.x = v.w;
>+    result.y = v.w;
>+    result.z = v.w;
>+    result.w = v.z;
>+    return result;
>+}
>+ushort4 operator.wwwz(ushort4 v) {
>+    ushort4 result;
>+    result.x = v.w;
>+    result.y = v.w;
>+    result.z = v.w;
>+    result.w = v.z;
>+    return result;
>+}
>+uint4 operator.wwwz(uint4 v) {
>+    uint4 result;
>+    result.x = v.w;
>+    result.y = v.w;
>+    result.z = v.w;
>+    result.w = v.z;
>+    return result;
>+}
>+char4 operator.wwwz(char4 v) {
>+    char4 result;
>+    result.x = v.w;
>+    result.y = v.w;
>+    result.z = v.w;
>+    result.w = v.z;
>+    return result;
>+}
>+short4 operator.wwwz(short4 v) {
>+    short4 result;
>+    result.x = v.w;
>+    result.y = v.w;
>+    result.z = v.w;
>+    result.w = v.z;
>+    return result;
>+}
>+int4 operator.wwwz(int4 v) {
>+    int4 result;
>+    result.x = v.w;
>+    result.y = v.w;
>+    result.z = v.w;
>+    result.w = v.z;
>+    return result;
>+}
>+half4 operator.wwwz(half4 v) {
>+    half4 result;
>+    result.x = v.w;
>+    result.y = v.w;
>+    result.z = v.w;
>+    result.w = v.z;
>+    return result;
>+}
>+float4 operator.wwwz(float4 v) {
>+    float4 result;
>+    result.x = v.w;
>+    result.y = v.w;
>+    result.z = v.w;
>+    result.w = v.z;
>+    return result;
>+}
>+
>+/* Functions named operator.zxzx */
>+bool4 operator.zxzx(bool3 v) {
>+    bool4 result;
>+    result.x = v.z;
>+    result.y = v.x;
>+    result.z = v.z;
>+    result.w = v.x;
>+    return result;
>+}
>+bool4 operator.zxzx(bool4 v) {
>+    bool4 result;
>+    result.x = v.z;
>+    result.y = v.x;
>+    result.z = v.z;
>+    result.w = v.x;
>+    return result;
>+}
>+uchar4 operator.zxzx(uchar3 v) {
>+    uchar4 result;
>+    result.x = v.z;
>+    result.y = v.x;
>+    result.z = v.z;
>+    result.w = v.x;
>+    return result;
>+}
>+uchar4 operator.zxzx(uchar4 v) {
>+    uchar4 result;
>+    result.x = v.z;
>+    result.y = v.x;
>+    result.z = v.z;
>+    result.w = v.x;
>+    return result;
>+}
>+ushort4 operator.zxzx(ushort3 v) {
>+    ushort4 result;
>+    result.x = v.z;
>+    result.y = v.x;
>+    result.z = v.z;
>+    result.w = v.x;
>+    return result;
>+}
>+ushort4 operator.zxzx(ushort4 v) {
>+    ushort4 result;
>+    result.x = v.z;
>+    result.y = v.x;
>+    result.z = v.z;
>+    result.w = v.x;
>+    return result;
>+}
>+uint4 operator.zxzx(uint3 v) {
>+    uint4 result;
>+    result.x = v.z;
>+    result.y = v.x;
>+    result.z = v.z;
>+    result.w = v.x;
>+    return result;
>+}
>+uint4 operator.zxzx(uint4 v) {
>+    uint4 result;
>+    result.x = v.z;
>+    result.y = v.x;
>+    result.z = v.z;
>+    result.w = v.x;
>+    return result;
>+}
>+char4 operator.zxzx(char3 v) {
>+    char4 result;
>+    result.x = v.z;
>+    result.y = v.x;
>+    result.z = v.z;
>+    result.w = v.x;
>+    return result;
>+}
>+char4 operator.zxzx(char4 v) {
>+    char4 result;
>+    result.x = v.z;
>+    result.y = v.x;
>+    result.z = v.z;
>+    result.w = v.x;
>+    return result;
>+}
>+short4 operator.zxzx(short3 v) {
>+    short4 result;
>+    result.x = v.z;
>+    result.y = v.x;
>+    result.z = v.z;
>+    result.w = v.x;
>+    return result;
>+}
>+short4 operator.zxzx(short4 v) {
>+    short4 result;
>+    result.x = v.z;
>+    result.y = v.x;
>+    result.z = v.z;
>+    result.w = v.x;
>+    return result;
>+}
>+int4 operator.zxzx(int3 v) {
>+    int4 result;
>+    result.x = v.z;
>+    result.y = v.x;
>+    result.z = v.z;
>+    result.w = v.x;
>+    return result;
>+}
>+int4 operator.zxzx(int4 v) {
>+    int4 result;
>+    result.x = v.z;
>+    result.y = v.x;
>+    result.z = v.z;
>+    result.w = v.x;
>+    return result;
>+}
>+half4 operator.zxzx(half3 v) {
>+    half4 result;
>+    result.x = v.z;
>+    result.y = v.x;
>+    result.z = v.z;
>+    result.w = v.x;
>+    return result;
>+}
>+half4 operator.zxzx(half4 v) {
>+    half4 result;
>+    result.x = v.z;
>+    result.y = v.x;
>+    result.z = v.z;
>+    result.w = v.x;
>+    return result;
>+}
>+float4 operator.zxzx(float3 v) {
>+    float4 result;
>+    result.x = v.z;
>+    result.y = v.x;
>+    result.z = v.z;
>+    result.w = v.x;
>+    return result;
>+}
>+float4 operator.zxzx(float4 v) {
>+    float4 result;
>+    result.x = v.z;
>+    result.y = v.x;
>+    result.z = v.z;
>+    result.w = v.x;
>+    return result;
>+}
>+
>+/* Functions named operator.zyx= */
>+bool3 operator.zyx=(bool3 v, bool3 c) {
>+    bool3 result = v;
>+    result.z = c.x;
>+    result.y = c.y;
>+    result.x = c.z;
>+    return result;
>+}
>+bool4 operator.zyx=(bool4 v, bool3 c) {
>+    bool4 result = v;
>+    result.z = c.x;
>+    result.y = c.y;
>+    result.x = c.z;
>+    return result;
>+}
>+uchar3 operator.zyx=(uchar3 v, uchar3 c) {
>+    uchar3 result = v;
>+    result.z = c.x;
>+    result.y = c.y;
>+    result.x = c.z;
>+    return result;
>+}
>+uchar4 operator.zyx=(uchar4 v, uchar3 c) {
>+    uchar4 result = v;
>+    result.z = c.x;
>+    result.y = c.y;
>+    result.x = c.z;
>+    return result;
>+}
>+ushort3 operator.zyx=(ushort3 v, ushort3 c) {
>+    ushort3 result = v;
>+    result.z = c.x;
>+    result.y = c.y;
>+    result.x = c.z;
>+    return result;
>+}
>+ushort4 operator.zyx=(ushort4 v, ushort3 c) {
>+    ushort4 result = v;
>+    result.z = c.x;
>+    result.y = c.y;
>+    result.x = c.z;
>+    return result;
>+}
>+uint3 operator.zyx=(uint3 v, uint3 c) {
>+    uint3 result = v;
>+    result.z = c.x;
>+    result.y = c.y;
>+    result.x = c.z;
>+    return result;
>+}
>+uint4 operator.zyx=(uint4 v, uint3 c) {
>+    uint4 result = v;
>+    result.z = c.x;
>+    result.y = c.y;
>+    result.x = c.z;
>+    return result;
>+}
>+char3 operator.zyx=(char3 v, char3 c) {
>+    char3 result = v;
>+    result.z = c.x;
>+    result.y = c.y;
>+    result.x = c.z;
>+    return result;
>+}
>+char4 operator.zyx=(char4 v, char3 c) {
>+    char4 result = v;
>+    result.z = c.x;
>+    result.y = c.y;
>+    result.x = c.z;
>+    return result;
>+}
>+short3 operator.zyx=(short3 v, short3 c) {
>+    short3 result = v;
>+    result.z = c.x;
>+    result.y = c.y;
>+    result.x = c.z;
>+    return result;
>+}
>+short4 operator.zyx=(short4 v, short3 c) {
>+    short4 result = v;
>+    result.z = c.x;
>+    result.y = c.y;
>+    result.x = c.z;
>+    return result;
>+}
>+int3 operator.zyx=(int3 v, int3 c) {
>+    int3 result = v;
>+    result.z = c.x;
>+    result.y = c.y;
>+    result.x = c.z;
>+    return result;
>+}
>+int4 operator.zyx=(int4 v, int3 c) {
>+    int4 result = v;
>+    result.z = c.x;
>+    result.y = c.y;
>+    result.x = c.z;
>+    return result;
>+}
>+half3 operator.zyx=(half3 v, half3 c) {
>+    half3 result = v;
>+    result.z = c.x;
>+    result.y = c.y;
>+    result.x = c.z;
>+    return result;
>+}
>+half4 operator.zyx=(half4 v, half3 c) {
>+    half4 result = v;
>+    result.z = c.x;
>+    result.y = c.y;
>+    result.x = c.z;
>+    return result;
>+}
>+float3 operator.zyx=(float3 v, float3 c) {
>+    float3 result = v;
>+    result.z = c.x;
>+    result.y = c.y;
>+    result.x = c.z;
>+    return result;
>+}
>+float4 operator.zyx=(float4 v, float3 c) {
>+    float4 result = v;
>+    result.z = c.x;
>+    result.y = c.y;
>+    result.x = c.z;
>+    return result;
>+}
>+
>+/* Functions named InterlockedMin */
>+native void InterlockedMin(device atomic_uint*, uint, thread uint*);
>+native void InterlockedMin(device atomic_int*, int, thread int*);
>+native void InterlockedMin(device atomic_uint*, uint, device uint*);
>+native void InterlockedMin(device atomic_int*, int, device int*);
>+native void InterlockedMin(device atomic_uint*, uint, threadgroup uint*);
>+native void InterlockedMin(device atomic_int*, int, threadgroup int*);
>+native void InterlockedMin(threadgroup atomic_uint*, uint, thread uint*);
>+native void InterlockedMin(threadgroup atomic_int*, int, thread int*);
>+native void InterlockedMin(threadgroup atomic_uint*, uint, device uint*);
>+native void InterlockedMin(threadgroup atomic_int*, int, device int*);
>+native void InterlockedMin(threadgroup atomic_uint*, uint, threadgroup uint*);
>+native void InterlockedMin(threadgroup atomic_int*, int, threadgroup int*);
>+
>+/* Functions named length */
>+half length(half x) {
>+    return sqrt(dot(x, x));
>+}
>+half length(half2 x) {
>+    return sqrt(dot(x, x));
>+}
>+half length(half3 x) {
>+    return sqrt(dot(x, x));
>+}
>+half length(half4 x) {
>+    return sqrt(dot(x, x));
>+}
>+float length(float x) {
>+    return sqrt(dot(x, x));
>+}
>+float length(float2 x) {
>+    return sqrt(dot(x, x));
>+}
>+float length(float3 x) {
>+    return sqrt(dot(x, x));
>+}
>+float length(float4 x) {
>+    return sqrt(dot(x, x));
>+}
>+
>+
>+/* Functions named operator.xwzy */
>+bool4 operator.xwzy(bool4 v) {
>+    bool4 result;
>+    result.x = v.x;
>+    result.y = v.w;
>+    result.z = v.z;
>+    result.w = v.y;
>+    return result;
>+}
>+uchar4 operator.xwzy(uchar4 v) {
>+    uchar4 result;
>+    result.x = v.x;
>+    result.y = v.w;
>+    result.z = v.z;
>+    result.w = v.y;
>+    return result;
>+}
>+ushort4 operator.xwzy(ushort4 v) {
>+    ushort4 result;
>+    result.x = v.x;
>+    result.y = v.w;
>+    result.z = v.z;
>+    result.w = v.y;
>+    return result;
>+}
>+uint4 operator.xwzy(uint4 v) {
>+    uint4 result;
>+    result.x = v.x;
>+    result.y = v.w;
>+    result.z = v.z;
>+    result.w = v.y;
>+    return result;
>+}
>+char4 operator.xwzy(char4 v) {
>+    char4 result;
>+    result.x = v.x;
>+    result.y = v.w;
>+    result.z = v.z;
>+    result.w = v.y;
>+    return result;
>+}
>+short4 operator.xwzy(short4 v) {
>+    short4 result;
>+    result.x = v.x;
>+    result.y = v.w;
>+    result.z = v.z;
>+    result.w = v.y;
>+    return result;
>+}
>+int4 operator.xwzy(int4 v) {
>+    int4 result;
>+    result.x = v.x;
>+    result.y = v.w;
>+    result.z = v.z;
>+    result.w = v.y;
>+    return result;
>+}
>+half4 operator.xwzy(half4 v) {
>+    half4 result;
>+    result.x = v.x;
>+    result.y = v.w;
>+    result.z = v.z;
>+    result.w = v.y;
>+    return result;
>+}
>+float4 operator.xwzy(float4 v) {
>+    float4 result;
>+    result.x = v.x;
>+    result.y = v.w;
>+    result.z = v.z;
>+    result.w = v.y;
>+    return result;
>+}
>+
>+/* Functions named operator-- */
>+uchar operator--(uchar value) {
>+    return value - 1;
>+}
>+ushort operator--(ushort value) {
>+    return value - 1;
>+}
>+uint operator--(uint value) {
>+    return value - 1;
>+}
>+char operator--(char value) {
>+    return value - 1;
>+}
>+short operator--(short value) {
>+    return value - 1;
>+}
>+int operator--(int value) {
>+    return value - 1;
>+}
>+half operator--(half value) {
>+    return value - 1;
>+}
>+float operator--(float value) {
>+    return value - 1;
>+}
>+
>+/* Functions named operator<< */
>+native int operator<<(int, uint);
>+native uint operator<<(uint, uint);
>+uchar operator<<(uchar a, uint b) {
>+    return uchar(uint(a) << (b & 255));
>+}
>+ushort operator<<(ushort a, uint b) {
>+    return ushort(uint(a) << (b & 65535));
>+}
>+char operator<<(char a, uint b) {
>+    return char(int(a) << (b & 255));
>+}
>+short operator<<(short a, uint b) {
>+    return short(int(a) << (b & 65535));
>+}
>+
>+/* Functions named operator.wwyz */
>+bool4 operator.wwyz(bool4 v) {
>+    bool4 result;
>+    result.x = v.w;
>+    result.y = v.w;
>+    result.z = v.y;
>+    result.w = v.z;
>+    return result;
>+}
>+uchar4 operator.wwyz(uchar4 v) {
>+    uchar4 result;
>+    result.x = v.w;
>+    result.y = v.w;
>+    result.z = v.y;
>+    result.w = v.z;
>+    return result;
>+}
>+ushort4 operator.wwyz(ushort4 v) {
>+    ushort4 result;
>+    result.x = v.w;
>+    result.y = v.w;
>+    result.z = v.y;
>+    result.w = v.z;
>+    return result;
>+}
>+uint4 operator.wwyz(uint4 v) {
>+    uint4 result;
>+    result.x = v.w;
>+    result.y = v.w;
>+    result.z = v.y;
>+    result.w = v.z;
>+    return result;
>+}
>+char4 operator.wwyz(char4 v) {
>+    char4 result;
>+    result.x = v.w;
>+    result.y = v.w;
>+    result.z = v.y;
>+    result.w = v.z;
>+    return result;
>+}
>+short4 operator.wwyz(short4 v) {
>+    short4 result;
>+    result.x = v.w;
>+    result.y = v.w;
>+    result.z = v.y;
>+    result.w = v.z;
>+    return result;
>+}
>+int4 operator.wwyz(int4 v) {
>+    int4 result;
>+    result.x = v.w;
>+    result.y = v.w;
>+    result.z = v.y;
>+    result.w = v.z;
>+    return result;
>+}
>+half4 operator.wwyz(half4 v) {
>+    half4 result;
>+    result.x = v.w;
>+    result.y = v.w;
>+    result.z = v.y;
>+    result.w = v.z;
>+    return result;
>+}
>+float4 operator.wwyz(float4 v) {
>+    float4 result;
>+    result.x = v.w;
>+    result.y = v.w;
>+    result.z = v.y;
>+    result.w = v.z;
>+    return result;
>+}
>+
>+/* Functions named operator.xxy */
>+bool3 operator.xxy(bool2 v) {
>+    bool3 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.y;
>+    return result;
>+}
>+bool3 operator.xxy(bool3 v) {
>+    bool3 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.y;
>+    return result;
>+}
>+bool3 operator.xxy(bool4 v) {
>+    bool3 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.y;
>+    return result;
>+}
>+uchar3 operator.xxy(uchar2 v) {
>+    uchar3 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.y;
>+    return result;
>+}
>+uchar3 operator.xxy(uchar3 v) {
>+    uchar3 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.y;
>+    return result;
>+}
>+uchar3 operator.xxy(uchar4 v) {
>+    uchar3 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.y;
>+    return result;
>+}
>+ushort3 operator.xxy(ushort2 v) {
>+    ushort3 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.y;
>+    return result;
>+}
>+ushort3 operator.xxy(ushort3 v) {
>+    ushort3 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.y;
>+    return result;
>+}
>+ushort3 operator.xxy(ushort4 v) {
>+    ushort3 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.y;
>+    return result;
>+}
>+uint3 operator.xxy(uint2 v) {
>+    uint3 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.y;
>+    return result;
>+}
>+uint3 operator.xxy(uint3 v) {
>+    uint3 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.y;
>+    return result;
>+}
>+uint3 operator.xxy(uint4 v) {
>+    uint3 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.y;
>+    return result;
>+}
>+char3 operator.xxy(char2 v) {
>+    char3 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.y;
>+    return result;
>+}
>+char3 operator.xxy(char3 v) {
>+    char3 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.y;
>+    return result;
>+}
>+char3 operator.xxy(char4 v) {
>+    char3 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.y;
>+    return result;
>+}
>+short3 operator.xxy(short2 v) {
>+    short3 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.y;
>+    return result;
>+}
>+short3 operator.xxy(short3 v) {
>+    short3 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.y;
>+    return result;
>+}
>+short3 operator.xxy(short4 v) {
>+    short3 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.y;
>+    return result;
>+}
>+int3 operator.xxy(int2 v) {
>+    int3 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.y;
>+    return result;
>+}
>+int3 operator.xxy(int3 v) {
>+    int3 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.y;
>+    return result;
>+}
>+int3 operator.xxy(int4 v) {
>+    int3 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.y;
>+    return result;
>+}
>+half3 operator.xxy(half2 v) {
>+    half3 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.y;
>+    return result;
>+}
>+half3 operator.xxy(half3 v) {
>+    half3 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.y;
>+    return result;
>+}
>+half3 operator.xxy(half4 v) {
>+    half3 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.y;
>+    return result;
>+}
>+float3 operator.xxy(float2 v) {
>+    float3 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.y;
>+    return result;
>+}
>+float3 operator.xxy(float3 v) {
>+    float3 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.y;
>+    return result;
>+}
>+float3 operator.xxy(float4 v) {
>+    float3 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.y;
>+    return result;
>+}
>+
>+/* Functions named operator.xww */
>+bool3 operator.xww(bool4 v) {
>+    bool3 result;
>+    result.x = v.x;
>+    result.y = v.w;
>+    result.z = v.w;
>+    return result;
>+}
>+uchar3 operator.xww(uchar4 v) {
>+    uchar3 result;
>+    result.x = v.x;
>+    result.y = v.w;
>+    result.z = v.w;
>+    return result;
>+}
>+ushort3 operator.xww(ushort4 v) {
>+    ushort3 result;
>+    result.x = v.x;
>+    result.y = v.w;
>+    result.z = v.w;
>+    return result;
>+}
>+uint3 operator.xww(uint4 v) {
>+    uint3 result;
>+    result.x = v.x;
>+    result.y = v.w;
>+    result.z = v.w;
>+    return result;
>+}
>+char3 operator.xww(char4 v) {
>+    char3 result;
>+    result.x = v.x;
>+    result.y = v.w;
>+    result.z = v.w;
>+    return result;
>+}
>+short3 operator.xww(short4 v) {
>+    short3 result;
>+    result.x = v.x;
>+    result.y = v.w;
>+    result.z = v.w;
>+    return result;
>+}
>+int3 operator.xww(int4 v) {
>+    int3 result;
>+    result.x = v.x;
>+    result.y = v.w;
>+    result.z = v.w;
>+    return result;
>+}
>+half3 operator.xww(half4 v) {
>+    half3 result;
>+    result.x = v.x;
>+    result.y = v.w;
>+    result.z = v.w;
>+    return result;
>+}
>+float3 operator.xww(float4 v) {
>+    float3 result;
>+    result.x = v.x;
>+    result.y = v.w;
>+    result.z = v.w;
>+    return result;
>+}
>+
>+/* Functions named operator.zyxw= */
>+bool4 operator.zyxw=(bool4 v, bool4 c) {
>+    bool4 result = v;
>+    result.z = c.x;
>+    result.y = c.y;
>+    result.x = c.z;
>+    result.w = c.w;
>+    return result;
>+}
>+uchar4 operator.zyxw=(uchar4 v, uchar4 c) {
>+    uchar4 result = v;
>+    result.z = c.x;
>+    result.y = c.y;
>+    result.x = c.z;
>+    result.w = c.w;
>+    return result;
>+}
>+ushort4 operator.zyxw=(ushort4 v, ushort4 c) {
>+    ushort4 result = v;
>+    result.z = c.x;
>+    result.y = c.y;
>+    result.x = c.z;
>+    result.w = c.w;
>+    return result;
>+}
>+uint4 operator.zyxw=(uint4 v, uint4 c) {
>+    uint4 result = v;
>+    result.z = c.x;
>+    result.y = c.y;
>+    result.x = c.z;
>+    result.w = c.w;
>+    return result;
>+}
>+char4 operator.zyxw=(char4 v, char4 c) {
>+    char4 result = v;
>+    result.z = c.x;
>+    result.y = c.y;
>+    result.x = c.z;
>+    result.w = c.w;
>+    return result;
>+}
>+short4 operator.zyxw=(short4 v, short4 c) {
>+    short4 result = v;
>+    result.z = c.x;
>+    result.y = c.y;
>+    result.x = c.z;
>+    result.w = c.w;
>+    return result;
>+}
>+int4 operator.zyxw=(int4 v, int4 c) {
>+    int4 result = v;
>+    result.z = c.x;
>+    result.y = c.y;
>+    result.x = c.z;
>+    result.w = c.w;
>+    return result;
>+}
>+half4 operator.zyxw=(half4 v, half4 c) {
>+    half4 result = v;
>+    result.z = c.x;
>+    result.y = c.y;
>+    result.x = c.z;
>+    result.w = c.w;
>+    return result;
>+}
>+float4 operator.zyxw=(float4 v, float4 c) {
>+    float4 result = v;
>+    result.z = c.x;
>+    result.y = c.y;
>+    result.x = c.z;
>+    result.w = c.w;
>+    return result;
>+}
>+
>+/* Functions named operator.ywwz */
>+bool4 operator.ywwz(bool4 v) {
>+    bool4 result;
>+    result.x = v.y;
>+    result.y = v.w;
>+    result.z = v.w;
>+    result.w = v.z;
>+    return result;
>+}
>+uchar4 operator.ywwz(uchar4 v) {
>+    uchar4 result;
>+    result.x = v.y;
>+    result.y = v.w;
>+    result.z = v.w;
>+    result.w = v.z;
>+    return result;
>+}
>+ushort4 operator.ywwz(ushort4 v) {
>+    ushort4 result;
>+    result.x = v.y;
>+    result.y = v.w;
>+    result.z = v.w;
>+    result.w = v.z;
>+    return result;
>+}
>+uint4 operator.ywwz(uint4 v) {
>+    uint4 result;
>+    result.x = v.y;
>+    result.y = v.w;
>+    result.z = v.w;
>+    result.w = v.z;
>+    return result;
>+}
>+char4 operator.ywwz(char4 v) {
>+    char4 result;
>+    result.x = v.y;
>+    result.y = v.w;
>+    result.z = v.w;
>+    result.w = v.z;
>+    return result;
>+}
>+short4 operator.ywwz(short4 v) {
>+    short4 result;
>+    result.x = v.y;
>+    result.y = v.w;
>+    result.z = v.w;
>+    result.w = v.z;
>+    return result;
>+}
>+int4 operator.ywwz(int4 v) {
>+    int4 result;
>+    result.x = v.y;
>+    result.y = v.w;
>+    result.z = v.w;
>+    result.w = v.z;
>+    return result;
>+}
>+half4 operator.ywwz(half4 v) {
>+    half4 result;
>+    result.x = v.y;
>+    result.y = v.w;
>+    result.z = v.w;
>+    result.w = v.z;
>+    return result;
>+}
>+float4 operator.ywwz(float4 v) {
>+    float4 result;
>+    result.x = v.y;
>+    result.y = v.w;
>+    result.z = v.w;
>+    result.w = v.z;
>+    return result;
>+}
>+
>+/* Functions named operator.wyzz */
>+bool4 operator.wyzz(bool4 v) {
>+    bool4 result;
>+    result.x = v.w;
>+    result.y = v.y;
>+    result.z = v.z;
>+    result.w = v.z;
>+    return result;
>+}
>+uchar4 operator.wyzz(uchar4 v) {
>+    uchar4 result;
>+    result.x = v.w;
>+    result.y = v.y;
>+    result.z = v.z;
>+    result.w = v.z;
>+    return result;
>+}
>+ushort4 operator.wyzz(ushort4 v) {
>+    ushort4 result;
>+    result.x = v.w;
>+    result.y = v.y;
>+    result.z = v.z;
>+    result.w = v.z;
>+    return result;
>+}
>+uint4 operator.wyzz(uint4 v) {
>+    uint4 result;
>+    result.x = v.w;
>+    result.y = v.y;
>+    result.z = v.z;
>+    result.w = v.z;
>+    return result;
>+}
>+char4 operator.wyzz(char4 v) {
>+    char4 result;
>+    result.x = v.w;
>+    result.y = v.y;
>+    result.z = v.z;
>+    result.w = v.z;
>+    return result;
>+}
>+short4 operator.wyzz(short4 v) {
>+    short4 result;
>+    result.x = v.w;
>+    result.y = v.y;
>+    result.z = v.z;
>+    result.w = v.z;
>+    return result;
>+}
>+int4 operator.wyzz(int4 v) {
>+    int4 result;
>+    result.x = v.w;
>+    result.y = v.y;
>+    result.z = v.z;
>+    result.w = v.z;
>+    return result;
>+}
>+half4 operator.wyzz(half4 v) {
>+    half4 result;
>+    result.x = v.w;
>+    result.y = v.y;
>+    result.z = v.z;
>+    result.w = v.z;
>+    return result;
>+}
>+float4 operator.wyzz(float4 v) {
>+    float4 result;
>+    result.x = v.w;
>+    result.y = v.y;
>+    result.z = v.z;
>+    result.w = v.z;
>+    return result;
>+}
>+
>+/* Functions named exp2 */
>+half exp2(half x) {
>+    return exp(x * log(half(2)));
>+}
>+half2 exp2(half2 x) {
>+    half2 result;
>+    result[0] = exp2(x[0]);
>+    result[1] = exp2(x[1]);
>+    return result;
>+}
>+half3 exp2(half3 x) {
>+    half3 result;
>+    result[0] = exp2(x[0]);
>+    result[1] = exp2(x[1]);
>+    result[2] = exp2(x[2]);
>+    return result;
>+}
>+half4 exp2(half4 x) {
>+    half4 result;
>+    result[0] = exp2(x[0]);
>+    result[1] = exp2(x[1]);
>+    result[2] = exp2(x[2]);
>+    result[3] = exp2(x[3]);
>+    return result;
>+}
>+half2x2 exp2(half2x2 x) {
>+    half2x2 result;
>+    result[0][0] = exp2(x[0][0]);
>+    result[0][1] = exp2(x[0][1]);
>+    result[1][0] = exp2(x[1][0]);
>+    result[1][1] = exp2(x[1][1]);
>+    return result;
>+}
>+half2x3 exp2(half2x3 x) {
>+    half2x3 result;
>+    result[0][0] = exp2(x[0][0]);
>+    result[0][1] = exp2(x[0][1]);
>+    result[0][2] = exp2(x[0][2]);
>+    result[1][0] = exp2(x[1][0]);
>+    result[1][1] = exp2(x[1][1]);
>+    result[1][2] = exp2(x[1][2]);
>+    return result;
>+}
>+half2x4 exp2(half2x4 x) {
>+    half2x4 result;
>+    result[0][0] = exp2(x[0][0]);
>+    result[0][1] = exp2(x[0][1]);
>+    result[0][2] = exp2(x[0][2]);
>+    result[0][3] = exp2(x[0][3]);
>+    result[1][0] = exp2(x[1][0]);
>+    result[1][1] = exp2(x[1][1]);
>+    result[1][2] = exp2(x[1][2]);
>+    result[1][3] = exp2(x[1][3]);
>+    return result;
>+}
>+half3x2 exp2(half3x2 x) {
>+    half3x2 result;
>+    result[0][0] = exp2(x[0][0]);
>+    result[0][1] = exp2(x[0][1]);
>+    result[1][0] = exp2(x[1][0]);
>+    result[1][1] = exp2(x[1][1]);
>+    result[2][0] = exp2(x[2][0]);
>+    result[2][1] = exp2(x[2][1]);
>+    return result;
>+}
>+half3x3 exp2(half3x3 x) {
>+    half3x3 result;
>+    result[0][0] = exp2(x[0][0]);
>+    result[0][1] = exp2(x[0][1]);
>+    result[0][2] = exp2(x[0][2]);
>+    result[1][0] = exp2(x[1][0]);
>+    result[1][1] = exp2(x[1][1]);
>+    result[1][2] = exp2(x[1][2]);
>+    result[2][0] = exp2(x[2][0]);
>+    result[2][1] = exp2(x[2][1]);
>+    result[2][2] = exp2(x[2][2]);
>+    return result;
>+}
>+half3x4 exp2(half3x4 x) {
>+    half3x4 result;
>+    result[0][0] = exp2(x[0][0]);
>+    result[0][1] = exp2(x[0][1]);
>+    result[0][2] = exp2(x[0][2]);
>+    result[0][3] = exp2(x[0][3]);
>+    result[1][0] = exp2(x[1][0]);
>+    result[1][1] = exp2(x[1][1]);
>+    result[1][2] = exp2(x[1][2]);
>+    result[1][3] = exp2(x[1][3]);
>+    result[2][0] = exp2(x[2][0]);
>+    result[2][1] = exp2(x[2][1]);
>+    result[2][2] = exp2(x[2][2]);
>+    result[2][3] = exp2(x[2][3]);
>+    return result;
>+}
>+half4x2 exp2(half4x2 x) {
>+    half4x2 result;
>+    result[0][0] = exp2(x[0][0]);
>+    result[0][1] = exp2(x[0][1]);
>+    result[1][0] = exp2(x[1][0]);
>+    result[1][1] = exp2(x[1][1]);
>+    result[2][0] = exp2(x[2][0]);
>+    result[2][1] = exp2(x[2][1]);
>+    result[3][0] = exp2(x[3][0]);
>+    result[3][1] = exp2(x[3][1]);
>+    return result;
>+}
>+half4x3 exp2(half4x3 x) {
>+    half4x3 result;
>+    result[0][0] = exp2(x[0][0]);
>+    result[0][1] = exp2(x[0][1]);
>+    result[0][2] = exp2(x[0][2]);
>+    result[1][0] = exp2(x[1][0]);
>+    result[1][1] = exp2(x[1][1]);
>+    result[1][2] = exp2(x[1][2]);
>+    result[2][0] = exp2(x[2][0]);
>+    result[2][1] = exp2(x[2][1]);
>+    result[2][2] = exp2(x[2][2]);
>+    result[3][0] = exp2(x[3][0]);
>+    result[3][1] = exp2(x[3][1]);
>+    result[3][2] = exp2(x[3][2]);
>+    return result;
>+}
>+half4x4 exp2(half4x4 x) {
>+    half4x4 result;
>+    result[0][0] = exp2(x[0][0]);
>+    result[0][1] = exp2(x[0][1]);
>+    result[0][2] = exp2(x[0][2]);
>+    result[0][3] = exp2(x[0][3]);
>+    result[1][0] = exp2(x[1][0]);
>+    result[1][1] = exp2(x[1][1]);
>+    result[1][2] = exp2(x[1][2]);
>+    result[1][3] = exp2(x[1][3]);
>+    result[2][0] = exp2(x[2][0]);
>+    result[2][1] = exp2(x[2][1]);
>+    result[2][2] = exp2(x[2][2]);
>+    result[2][3] = exp2(x[2][3]);
>+    result[3][0] = exp2(x[3][0]);
>+    result[3][1] = exp2(x[3][1]);
>+    result[3][2] = exp2(x[3][2]);
>+    result[3][3] = exp2(x[3][3]);
>+    return result;
>+}
>+float exp2(float x) {
>+    return exp(x * log(float(2)));
>+}
>+float2 exp2(float2 x) {
>+    float2 result;
>+    result[0] = exp2(x[0]);
>+    result[1] = exp2(x[1]);
>+    return result;
>+}
>+float3 exp2(float3 x) {
>+    float3 result;
>+    result[0] = exp2(x[0]);
>+    result[1] = exp2(x[1]);
>+    result[2] = exp2(x[2]);
>+    return result;
>+}
>+float4 exp2(float4 x) {
>+    float4 result;
>+    result[0] = exp2(x[0]);
>+    result[1] = exp2(x[1]);
>+    result[2] = exp2(x[2]);
>+    result[3] = exp2(x[3]);
>+    return result;
>+}
>+float2x2 exp2(float2x2 x) {
>+    float2x2 result;
>+    result[0][0] = exp2(x[0][0]);
>+    result[0][1] = exp2(x[0][1]);
>+    result[1][0] = exp2(x[1][0]);
>+    result[1][1] = exp2(x[1][1]);
>+    return result;
>+}
>+float2x3 exp2(float2x3 x) {
>+    float2x3 result;
>+    result[0][0] = exp2(x[0][0]);
>+    result[0][1] = exp2(x[0][1]);
>+    result[0][2] = exp2(x[0][2]);
>+    result[1][0] = exp2(x[1][0]);
>+    result[1][1] = exp2(x[1][1]);
>+    result[1][2] = exp2(x[1][2]);
>+    return result;
>+}
>+float2x4 exp2(float2x4 x) {
>+    float2x4 result;
>+    result[0][0] = exp2(x[0][0]);
>+    result[0][1] = exp2(x[0][1]);
>+    result[0][2] = exp2(x[0][2]);
>+    result[0][3] = exp2(x[0][3]);
>+    result[1][0] = exp2(x[1][0]);
>+    result[1][1] = exp2(x[1][1]);
>+    result[1][2] = exp2(x[1][2]);
>+    result[1][3] = exp2(x[1][3]);
>+    return result;
>+}
>+float3x2 exp2(float3x2 x) {
>+    float3x2 result;
>+    result[0][0] = exp2(x[0][0]);
>+    result[0][1] = exp2(x[0][1]);
>+    result[1][0] = exp2(x[1][0]);
>+    result[1][1] = exp2(x[1][1]);
>+    result[2][0] = exp2(x[2][0]);
>+    result[2][1] = exp2(x[2][1]);
>+    return result;
>+}
>+float3x3 exp2(float3x3 x) {
>+    float3x3 result;
>+    result[0][0] = exp2(x[0][0]);
>+    result[0][1] = exp2(x[0][1]);
>+    result[0][2] = exp2(x[0][2]);
>+    result[1][0] = exp2(x[1][0]);
>+    result[1][1] = exp2(x[1][1]);
>+    result[1][2] = exp2(x[1][2]);
>+    result[2][0] = exp2(x[2][0]);
>+    result[2][1] = exp2(x[2][1]);
>+    result[2][2] = exp2(x[2][2]);
>+    return result;
>+}
>+float3x4 exp2(float3x4 x) {
>+    float3x4 result;
>+    result[0][0] = exp2(x[0][0]);
>+    result[0][1] = exp2(x[0][1]);
>+    result[0][2] = exp2(x[0][2]);
>+    result[0][3] = exp2(x[0][3]);
>+    result[1][0] = exp2(x[1][0]);
>+    result[1][1] = exp2(x[1][1]);
>+    result[1][2] = exp2(x[1][2]);
>+    result[1][3] = exp2(x[1][3]);
>+    result[2][0] = exp2(x[2][0]);
>+    result[2][1] = exp2(x[2][1]);
>+    result[2][2] = exp2(x[2][2]);
>+    result[2][3] = exp2(x[2][3]);
>+    return result;
>+}
>+float4x2 exp2(float4x2 x) {
>+    float4x2 result;
>+    result[0][0] = exp2(x[0][0]);
>+    result[0][1] = exp2(x[0][1]);
>+    result[1][0] = exp2(x[1][0]);
>+    result[1][1] = exp2(x[1][1]);
>+    result[2][0] = exp2(x[2][0]);
>+    result[2][1] = exp2(x[2][1]);
>+    result[3][0] = exp2(x[3][0]);
>+    result[3][1] = exp2(x[3][1]);
>+    return result;
>+}
>+float4x3 exp2(float4x3 x) {
>+    float4x3 result;
>+    result[0][0] = exp2(x[0][0]);
>+    result[0][1] = exp2(x[0][1]);
>+    result[0][2] = exp2(x[0][2]);
>+    result[1][0] = exp2(x[1][0]);
>+    result[1][1] = exp2(x[1][1]);
>+    result[1][2] = exp2(x[1][2]);
>+    result[2][0] = exp2(x[2][0]);
>+    result[2][1] = exp2(x[2][1]);
>+    result[2][2] = exp2(x[2][2]);
>+    result[3][0] = exp2(x[3][0]);
>+    result[3][1] = exp2(x[3][1]);
>+    result[3][2] = exp2(x[3][2]);
>+    return result;
>+}
>+float4x4 exp2(float4x4 x) {
>+    float4x4 result;
>+    result[0][0] = exp2(x[0][0]);
>+    result[0][1] = exp2(x[0][1]);
>+    result[0][2] = exp2(x[0][2]);
>+    result[0][3] = exp2(x[0][3]);
>+    result[1][0] = exp2(x[1][0]);
>+    result[1][1] = exp2(x[1][1]);
>+    result[1][2] = exp2(x[1][2]);
>+    result[1][3] = exp2(x[1][3]);
>+    result[2][0] = exp2(x[2][0]);
>+    result[2][1] = exp2(x[2][1]);
>+    result[2][2] = exp2(x[2][2]);
>+    result[2][3] = exp2(x[2][3]);
>+    result[3][0] = exp2(x[3][0]);
>+    result[3][1] = exp2(x[3][1]);
>+    result[3][2] = exp2(x[3][2]);
>+    result[3][3] = exp2(x[3][3]);
>+    return result;
>+}
>+
>+/* Functions named operator.zyx */
>+bool3 operator.zyx(bool3 v) {
>+    bool3 result;
>+    result.x = v.z;
>+    result.y = v.y;
>+    result.z = v.x;
>+    return result;
>+}
>+bool3 operator.zyx(bool4 v) {
>+    bool3 result;
>+    result.x = v.z;
>+    result.y = v.y;
>+    result.z = v.x;
>+    return result;
>+}
>+uchar3 operator.zyx(uchar3 v) {
>+    uchar3 result;
>+    result.x = v.z;
>+    result.y = v.y;
>+    result.z = v.x;
>+    return result;
>+}
>+uchar3 operator.zyx(uchar4 v) {
>+    uchar3 result;
>+    result.x = v.z;
>+    result.y = v.y;
>+    result.z = v.x;
>+    return result;
>+}
>+ushort3 operator.zyx(ushort3 v) {
>+    ushort3 result;
>+    result.x = v.z;
>+    result.y = v.y;
>+    result.z = v.x;
>+    return result;
>+}
>+ushort3 operator.zyx(ushort4 v) {
>+    ushort3 result;
>+    result.x = v.z;
>+    result.y = v.y;
>+    result.z = v.x;
>+    return result;
>+}
>+uint3 operator.zyx(uint3 v) {
>+    uint3 result;
>+    result.x = v.z;
>+    result.y = v.y;
>+    result.z = v.x;
>+    return result;
>+}
>+uint3 operator.zyx(uint4 v) {
>+    uint3 result;
>+    result.x = v.z;
>+    result.y = v.y;
>+    result.z = v.x;
>+    return result;
>+}
>+char3 operator.zyx(char3 v) {
>+    char3 result;
>+    result.x = v.z;
>+    result.y = v.y;
>+    result.z = v.x;
>+    return result;
>+}
>+char3 operator.zyx(char4 v) {
>+    char3 result;
>+    result.x = v.z;
>+    result.y = v.y;
>+    result.z = v.x;
>+    return result;
>+}
>+short3 operator.zyx(short3 v) {
>+    short3 result;
>+    result.x = v.z;
>+    result.y = v.y;
>+    result.z = v.x;
>+    return result;
>+}
>+short3 operator.zyx(short4 v) {
>+    short3 result;
>+    result.x = v.z;
>+    result.y = v.y;
>+    result.z = v.x;
>+    return result;
>+}
>+int3 operator.zyx(int3 v) {
>+    int3 result;
>+    result.x = v.z;
>+    result.y = v.y;
>+    result.z = v.x;
>+    return result;
>+}
>+int3 operator.zyx(int4 v) {
>+    int3 result;
>+    result.x = v.z;
>+    result.y = v.y;
>+    result.z = v.x;
>+    return result;
>+}
>+half3 operator.zyx(half3 v) {
>+    half3 result;
>+    result.x = v.z;
>+    result.y = v.y;
>+    result.z = v.x;
>+    return result;
>+}
>+half3 operator.zyx(half4 v) {
>+    half3 result;
>+    result.x = v.z;
>+    result.y = v.y;
>+    result.z = v.x;
>+    return result;
>+}
>+float3 operator.zyx(float3 v) {
>+    float3 result;
>+    result.x = v.z;
>+    result.y = v.y;
>+    result.z = v.x;
>+    return result;
>+}
>+float3 operator.zyx(float4 v) {
>+    float3 result;
>+    result.x = v.z;
>+    result.y = v.y;
>+    result.z = v.x;
>+    return result;
>+}
>+
>+/* Functions named operator.wwww */
>+bool4 operator.wwww(bool4 v) {
>+    bool4 result;
>+    result.x = v.w;
>+    result.y = v.w;
>+    result.z = v.w;
>+    result.w = v.w;
>+    return result;
>+}
>+uchar4 operator.wwww(uchar4 v) {
>+    uchar4 result;
>+    result.x = v.w;
>+    result.y = v.w;
>+    result.z = v.w;
>+    result.w = v.w;
>+    return result;
>+}
>+ushort4 operator.wwww(ushort4 v) {
>+    ushort4 result;
>+    result.x = v.w;
>+    result.y = v.w;
>+    result.z = v.w;
>+    result.w = v.w;
>+    return result;
>+}
>+uint4 operator.wwww(uint4 v) {
>+    uint4 result;
>+    result.x = v.w;
>+    result.y = v.w;
>+    result.z = v.w;
>+    result.w = v.w;
>+    return result;
>+}
>+char4 operator.wwww(char4 v) {
>+    char4 result;
>+    result.x = v.w;
>+    result.y = v.w;
>+    result.z = v.w;
>+    result.w = v.w;
>+    return result;
>+}
>+short4 operator.wwww(short4 v) {
>+    short4 result;
>+    result.x = v.w;
>+    result.y = v.w;
>+    result.z = v.w;
>+    result.w = v.w;
>+    return result;
>+}
>+int4 operator.wwww(int4 v) {
>+    int4 result;
>+    result.x = v.w;
>+    result.y = v.w;
>+    result.z = v.w;
>+    result.w = v.w;
>+    return result;
>+}
>+half4 operator.wwww(half4 v) {
>+    half4 result;
>+    result.x = v.w;
>+    result.y = v.w;
>+    result.z = v.w;
>+    result.w = v.w;
>+    return result;
>+}
>+float4 operator.wwww(float4 v) {
>+    float4 result;
>+    result.x = v.w;
>+    result.y = v.w;
>+    result.z = v.w;
>+    result.w = v.w;
>+    return result;
>+}
>+
>+/* Functions named operator.wyzw */
>+bool4 operator.wyzw(bool4 v) {
>+    bool4 result;
>+    result.x = v.w;
>+    result.y = v.y;
>+    result.z = v.z;
>+    result.w = v.w;
>+    return result;
>+}
>+uchar4 operator.wyzw(uchar4 v) {
>+    uchar4 result;
>+    result.x = v.w;
>+    result.y = v.y;
>+    result.z = v.z;
>+    result.w = v.w;
>+    return result;
>+}
>+ushort4 operator.wyzw(ushort4 v) {
>+    ushort4 result;
>+    result.x = v.w;
>+    result.y = v.y;
>+    result.z = v.z;
>+    result.w = v.w;
>+    return result;
>+}
>+uint4 operator.wyzw(uint4 v) {
>+    uint4 result;
>+    result.x = v.w;
>+    result.y = v.y;
>+    result.z = v.z;
>+    result.w = v.w;
>+    return result;
>+}
>+char4 operator.wyzw(char4 v) {
>+    char4 result;
>+    result.x = v.w;
>+    result.y = v.y;
>+    result.z = v.z;
>+    result.w = v.w;
>+    return result;
>+}
>+short4 operator.wyzw(short4 v) {
>+    short4 result;
>+    result.x = v.w;
>+    result.y = v.y;
>+    result.z = v.z;
>+    result.w = v.w;
>+    return result;
>+}
>+int4 operator.wyzw(int4 v) {
>+    int4 result;
>+    result.x = v.w;
>+    result.y = v.y;
>+    result.z = v.z;
>+    result.w = v.w;
>+    return result;
>+}
>+half4 operator.wyzw(half4 v) {
>+    half4 result;
>+    result.x = v.w;
>+    result.y = v.y;
>+    result.z = v.z;
>+    result.w = v.w;
>+    return result;
>+}
>+float4 operator.wyzw(float4 v) {
>+    float4 result;
>+    result.x = v.w;
>+    result.y = v.y;
>+    result.z = v.z;
>+    result.w = v.w;
>+    return result;
>+}
>+
>+/* Functions named operator.yzzw */
>+bool4 operator.yzzw(bool4 v) {
>+    bool4 result;
>+    result.x = v.y;
>+    result.y = v.z;
>+    result.z = v.z;
>+    result.w = v.w;
>+    return result;
>+}
>+uchar4 operator.yzzw(uchar4 v) {
>+    uchar4 result;
>+    result.x = v.y;
>+    result.y = v.z;
>+    result.z = v.z;
>+    result.w = v.w;
>+    return result;
>+}
>+ushort4 operator.yzzw(ushort4 v) {
>+    ushort4 result;
>+    result.x = v.y;
>+    result.y = v.z;
>+    result.z = v.z;
>+    result.w = v.w;
>+    return result;
>+}
>+uint4 operator.yzzw(uint4 v) {
>+    uint4 result;
>+    result.x = v.y;
>+    result.y = v.z;
>+    result.z = v.z;
>+    result.w = v.w;
>+    return result;
>+}
>+char4 operator.yzzw(char4 v) {
>+    char4 result;
>+    result.x = v.y;
>+    result.y = v.z;
>+    result.z = v.z;
>+    result.w = v.w;
>+    return result;
>+}
>+short4 operator.yzzw(short4 v) {
>+    short4 result;
>+    result.x = v.y;
>+    result.y = v.z;
>+    result.z = v.z;
>+    result.w = v.w;
>+    return result;
>+}
>+int4 operator.yzzw(int4 v) {
>+    int4 result;
>+    result.x = v.y;
>+    result.y = v.z;
>+    result.z = v.z;
>+    result.w = v.w;
>+    return result;
>+}
>+half4 operator.yzzw(half4 v) {
>+    half4 result;
>+    result.x = v.y;
>+    result.y = v.z;
>+    result.z = v.z;
>+    result.w = v.w;
>+    return result;
>+}
>+float4 operator.yzzw(float4 v) {
>+    float4 result;
>+    result.x = v.y;
>+    result.y = v.z;
>+    result.z = v.z;
>+    result.w = v.w;
>+    return result;
>+}
>+
>+/* Functions named operator.wwy */
>+bool3 operator.wwy(bool4 v) {
>+    bool3 result;
>+    result.x = v.w;
>+    result.y = v.w;
>+    result.z = v.y;
>+    return result;
>+}
>+uchar3 operator.wwy(uchar4 v) {
>+    uchar3 result;
>+    result.x = v.w;
>+    result.y = v.w;
>+    result.z = v.y;
>+    return result;
>+}
>+ushort3 operator.wwy(ushort4 v) {
>+    ushort3 result;
>+    result.x = v.w;
>+    result.y = v.w;
>+    result.z = v.y;
>+    return result;
>+}
>+uint3 operator.wwy(uint4 v) {
>+    uint3 result;
>+    result.x = v.w;
>+    result.y = v.w;
>+    result.z = v.y;
>+    return result;
>+}
>+char3 operator.wwy(char4 v) {
>+    char3 result;
>+    result.x = v.w;
>+    result.y = v.w;
>+    result.z = v.y;
>+    return result;
>+}
>+short3 operator.wwy(short4 v) {
>+    short3 result;
>+    result.x = v.w;
>+    result.y = v.w;
>+    result.z = v.y;
>+    return result;
>+}
>+int3 operator.wwy(int4 v) {
>+    int3 result;
>+    result.x = v.w;
>+    result.y = v.w;
>+    result.z = v.y;
>+    return result;
>+}
>+half3 operator.wwy(half4 v) {
>+    half3 result;
>+    result.x = v.w;
>+    result.y = v.w;
>+    result.z = v.y;
>+    return result;
>+}
>+float3 operator.wwy(float4 v) {
>+    float3 result;
>+    result.x = v.w;
>+    result.y = v.w;
>+    result.z = v.y;
>+    return result;
>+}
>+
>+/* Functions named operator.wz */
>+bool2 operator.wz(bool4 v) {
>+    bool2 result;
>+    result.x = v.w;
>+    result.y = v.z;
>+    return result;
>+}
>+uchar2 operator.wz(uchar4 v) {
>+    uchar2 result;
>+    result.x = v.w;
>+    result.y = v.z;
>+    return result;
>+}
>+ushort2 operator.wz(ushort4 v) {
>+    ushort2 result;
>+    result.x = v.w;
>+    result.y = v.z;
>+    return result;
>+}
>+uint2 operator.wz(uint4 v) {
>+    uint2 result;
>+    result.x = v.w;
>+    result.y = v.z;
>+    return result;
>+}
>+char2 operator.wz(char4 v) {
>+    char2 result;
>+    result.x = v.w;
>+    result.y = v.z;
>+    return result;
>+}
>+short2 operator.wz(short4 v) {
>+    short2 result;
>+    result.x = v.w;
>+    result.y = v.z;
>+    return result;
>+}
>+int2 operator.wz(int4 v) {
>+    int2 result;
>+    result.x = v.w;
>+    result.y = v.z;
>+    return result;
>+}
>+half2 operator.wz(half4 v) {
>+    half2 result;
>+    result.x = v.w;
>+    result.y = v.z;
>+    return result;
>+}
>+float2 operator.wz(float4 v) {
>+    float2 result;
>+    result.x = v.w;
>+    result.y = v.z;
>+    return result;
>+}
>+
>+/* Functions named operator.zx= */
>+bool3 operator.zx=(bool3 v, bool2 c) {
>+    bool3 result = v;
>+    result.z = c.x;
>+    result.x = c.y;
>+    return result;
>+}
>+bool4 operator.zx=(bool4 v, bool2 c) {
>+    bool4 result = v;
>+    result.z = c.x;
>+    result.x = c.y;
>+    return result;
>+}
>+uchar3 operator.zx=(uchar3 v, uchar2 c) {
>+    uchar3 result = v;
>+    result.z = c.x;
>+    result.x = c.y;
>+    return result;
>+}
>+uchar4 operator.zx=(uchar4 v, uchar2 c) {
>+    uchar4 result = v;
>+    result.z = c.x;
>+    result.x = c.y;
>+    return result;
>+}
>+ushort3 operator.zx=(ushort3 v, ushort2 c) {
>+    ushort3 result = v;
>+    result.z = c.x;
>+    result.x = c.y;
>+    return result;
>+}
>+ushort4 operator.zx=(ushort4 v, ushort2 c) {
>+    ushort4 result = v;
>+    result.z = c.x;
>+    result.x = c.y;
>+    return result;
>+}
>+uint3 operator.zx=(uint3 v, uint2 c) {
>+    uint3 result = v;
>+    result.z = c.x;
>+    result.x = c.y;
>+    return result;
>+}
>+uint4 operator.zx=(uint4 v, uint2 c) {
>+    uint4 result = v;
>+    result.z = c.x;
>+    result.x = c.y;
>+    return result;
>+}
>+char3 operator.zx=(char3 v, char2 c) {
>+    char3 result = v;
>+    result.z = c.x;
>+    result.x = c.y;
>+    return result;
>+}
>+char4 operator.zx=(char4 v, char2 c) {
>+    char4 result = v;
>+    result.z = c.x;
>+    result.x = c.y;
>+    return result;
>+}
>+short3 operator.zx=(short3 v, short2 c) {
>+    short3 result = v;
>+    result.z = c.x;
>+    result.x = c.y;
>+    return result;
>+}
>+short4 operator.zx=(short4 v, short2 c) {
>+    short4 result = v;
>+    result.z = c.x;
>+    result.x = c.y;
>+    return result;
>+}
>+int3 operator.zx=(int3 v, int2 c) {
>+    int3 result = v;
>+    result.z = c.x;
>+    result.x = c.y;
>+    return result;
>+}
>+int4 operator.zx=(int4 v, int2 c) {
>+    int4 result = v;
>+    result.z = c.x;
>+    result.x = c.y;
>+    return result;
>+}
>+half3 operator.zx=(half3 v, half2 c) {
>+    half3 result = v;
>+    result.z = c.x;
>+    result.x = c.y;
>+    return result;
>+}
>+half4 operator.zx=(half4 v, half2 c) {
>+    half4 result = v;
>+    result.z = c.x;
>+    result.x = c.y;
>+    return result;
>+}
>+float3 operator.zx=(float3 v, float2 c) {
>+    float3 result = v;
>+    result.z = c.x;
>+    result.x = c.y;
>+    return result;
>+}
>+float4 operator.zx=(float4 v, float2 c) {
>+    float4 result = v;
>+    result.z = c.x;
>+    result.x = c.y;
>+    return result;
>+}
>+
>+/* Functions named operator.yxyy */
>+bool4 operator.yxyy(bool2 v) {
>+    bool4 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.y;
>+    result.w = v.y;
>+    return result;
>+}
>+bool4 operator.yxyy(bool3 v) {
>+    bool4 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.y;
>+    result.w = v.y;
>+    return result;
>+}
>+bool4 operator.yxyy(bool4 v) {
>+    bool4 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.y;
>+    result.w = v.y;
>+    return result;
>+}
>+uchar4 operator.yxyy(uchar2 v) {
>+    uchar4 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.y;
>+    result.w = v.y;
>+    return result;
>+}
>+uchar4 operator.yxyy(uchar3 v) {
>+    uchar4 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.y;
>+    result.w = v.y;
>+    return result;
>+}
>+uchar4 operator.yxyy(uchar4 v) {
>+    uchar4 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.y;
>+    result.w = v.y;
>+    return result;
>+}
>+ushort4 operator.yxyy(ushort2 v) {
>+    ushort4 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.y;
>+    result.w = v.y;
>+    return result;
>+}
>+ushort4 operator.yxyy(ushort3 v) {
>+    ushort4 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.y;
>+    result.w = v.y;
>+    return result;
>+}
>+ushort4 operator.yxyy(ushort4 v) {
>+    ushort4 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.y;
>+    result.w = v.y;
>+    return result;
>+}
>+uint4 operator.yxyy(uint2 v) {
>+    uint4 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.y;
>+    result.w = v.y;
>+    return result;
>+}
>+uint4 operator.yxyy(uint3 v) {
>+    uint4 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.y;
>+    result.w = v.y;
>+    return result;
>+}
>+uint4 operator.yxyy(uint4 v) {
>+    uint4 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.y;
>+    result.w = v.y;
>+    return result;
>+}
>+char4 operator.yxyy(char2 v) {
>+    char4 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.y;
>+    result.w = v.y;
>+    return result;
>+}
>+char4 operator.yxyy(char3 v) {
>+    char4 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.y;
>+    result.w = v.y;
>+    return result;
>+}
>+char4 operator.yxyy(char4 v) {
>+    char4 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.y;
>+    result.w = v.y;
>+    return result;
>+}
>+short4 operator.yxyy(short2 v) {
>+    short4 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.y;
>+    result.w = v.y;
>+    return result;
>+}
>+short4 operator.yxyy(short3 v) {
>+    short4 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.y;
>+    result.w = v.y;
>+    return result;
>+}
>+short4 operator.yxyy(short4 v) {
>+    short4 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.y;
>+    result.w = v.y;
>+    return result;
>+}
>+int4 operator.yxyy(int2 v) {
>+    int4 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.y;
>+    result.w = v.y;
>+    return result;
>+}
>+int4 operator.yxyy(int3 v) {
>+    int4 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.y;
>+    result.w = v.y;
>+    return result;
>+}
>+int4 operator.yxyy(int4 v) {
>+    int4 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.y;
>+    result.w = v.y;
>+    return result;
>+}
>+half4 operator.yxyy(half2 v) {
>+    half4 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.y;
>+    result.w = v.y;
>+    return result;
>+}
>+half4 operator.yxyy(half3 v) {
>+    half4 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.y;
>+    result.w = v.y;
>+    return result;
>+}
>+half4 operator.yxyy(half4 v) {
>+    half4 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.y;
>+    result.w = v.y;
>+    return result;
>+}
>+float4 operator.yxyy(float2 v) {
>+    float4 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.y;
>+    result.w = v.y;
>+    return result;
>+}
>+float4 operator.yxyy(float3 v) {
>+    float4 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.y;
>+    result.w = v.y;
>+    return result;
>+}
>+float4 operator.yxyy(float4 v) {
>+    float4 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.y;
>+    result.w = v.y;
>+    return result;
>+}
>+
>+/* Functions named operator.wyyx */
>+bool4 operator.wyyx(bool4 v) {
>+    bool4 result;
>+    result.x = v.w;
>+    result.y = v.y;
>+    result.z = v.y;
>+    result.w = v.x;
>+    return result;
>+}
>+uchar4 operator.wyyx(uchar4 v) {
>+    uchar4 result;
>+    result.x = v.w;
>+    result.y = v.y;
>+    result.z = v.y;
>+    result.w = v.x;
>+    return result;
>+}
>+ushort4 operator.wyyx(ushort4 v) {
>+    ushort4 result;
>+    result.x = v.w;
>+    result.y = v.y;
>+    result.z = v.y;
>+    result.w = v.x;
>+    return result;
>+}
>+uint4 operator.wyyx(uint4 v) {
>+    uint4 result;
>+    result.x = v.w;
>+    result.y = v.y;
>+    result.z = v.y;
>+    result.w = v.x;
>+    return result;
>+}
>+char4 operator.wyyx(char4 v) {
>+    char4 result;
>+    result.x = v.w;
>+    result.y = v.y;
>+    result.z = v.y;
>+    result.w = v.x;
>+    return result;
>+}
>+short4 operator.wyyx(short4 v) {
>+    short4 result;
>+    result.x = v.w;
>+    result.y = v.y;
>+    result.z = v.y;
>+    result.w = v.x;
>+    return result;
>+}
>+int4 operator.wyyx(int4 v) {
>+    int4 result;
>+    result.x = v.w;
>+    result.y = v.y;
>+    result.z = v.y;
>+    result.w = v.x;
>+    return result;
>+}
>+half4 operator.wyyx(half4 v) {
>+    half4 result;
>+    result.x = v.w;
>+    result.y = v.y;
>+    result.z = v.y;
>+    result.w = v.x;
>+    return result;
>+}
>+float4 operator.wyyx(float4 v) {
>+    float4 result;
>+    result.x = v.w;
>+    result.y = v.y;
>+    result.z = v.y;
>+    result.w = v.x;
>+    return result;
>+}
>+
>+/* Functions named operator.y */
>+native bool operator.y(bool2);
>+native bool operator.y(bool3);
>+native bool operator.y(bool4);
>+native uchar operator.y(uchar2);
>+native uchar operator.y(uchar3);
>+native uchar operator.y(uchar4);
>+native ushort operator.y(ushort2);
>+native ushort operator.y(ushort3);
>+native ushort operator.y(ushort4);
>+native uint operator.y(uint2);
>+native uint operator.y(uint3);
>+native uint operator.y(uint4);
>+native char operator.y(char2);
>+native char operator.y(char3);
>+native char operator.y(char4);
>+native short operator.y(short2);
>+native short operator.y(short3);
>+native short operator.y(short4);
>+native int operator.y(int2);
>+native int operator.y(int3);
>+native int operator.y(int4);
>+native half operator.y(half2);
>+native half operator.y(half3);
>+native half operator.y(half4);
>+native float operator.y(float2);
>+native float operator.y(float3);
>+native float operator.y(float4);
>+
>+/* Functions named operator.wwzx */
>+bool4 operator.wwzx(bool4 v) {
>+    bool4 result;
>+    result.x = v.w;
>+    result.y = v.w;
>+    result.z = v.z;
>+    result.w = v.x;
>+    return result;
>+}
>+uchar4 operator.wwzx(uchar4 v) {
>+    uchar4 result;
>+    result.x = v.w;
>+    result.y = v.w;
>+    result.z = v.z;
>+    result.w = v.x;
>+    return result;
>+}
>+ushort4 operator.wwzx(ushort4 v) {
>+    ushort4 result;
>+    result.x = v.w;
>+    result.y = v.w;
>+    result.z = v.z;
>+    result.w = v.x;
>+    return result;
>+}
>+uint4 operator.wwzx(uint4 v) {
>+    uint4 result;
>+    result.x = v.w;
>+    result.y = v.w;
>+    result.z = v.z;
>+    result.w = v.x;
>+    return result;
>+}
>+char4 operator.wwzx(char4 v) {
>+    char4 result;
>+    result.x = v.w;
>+    result.y = v.w;
>+    result.z = v.z;
>+    result.w = v.x;
>+    return result;
>+}
>+short4 operator.wwzx(short4 v) {
>+    short4 result;
>+    result.x = v.w;
>+    result.y = v.w;
>+    result.z = v.z;
>+    result.w = v.x;
>+    return result;
>+}
>+int4 operator.wwzx(int4 v) {
>+    int4 result;
>+    result.x = v.w;
>+    result.y = v.w;
>+    result.z = v.z;
>+    result.w = v.x;
>+    return result;
>+}
>+half4 operator.wwzx(half4 v) {
>+    half4 result;
>+    result.x = v.w;
>+    result.y = v.w;
>+    result.z = v.z;
>+    result.w = v.x;
>+    return result;
>+}
>+float4 operator.wwzx(float4 v) {
>+    float4 result;
>+    result.x = v.w;
>+    result.y = v.w;
>+    result.z = v.z;
>+    result.w = v.x;
>+    return result;
>+}
>+
>+/* Functions named operator.yxzz */
>+bool4 operator.yxzz(bool3 v) {
>+    bool4 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.z;
>+    result.w = v.z;
>+    return result;
>+}
>+bool4 operator.yxzz(bool4 v) {
>+    bool4 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.z;
>+    result.w = v.z;
>+    return result;
>+}
>+uchar4 operator.yxzz(uchar3 v) {
>+    uchar4 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.z;
>+    result.w = v.z;
>+    return result;
>+}
>+uchar4 operator.yxzz(uchar4 v) {
>+    uchar4 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.z;
>+    result.w = v.z;
>+    return result;
>+}
>+ushort4 operator.yxzz(ushort3 v) {
>+    ushort4 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.z;
>+    result.w = v.z;
>+    return result;
>+}
>+ushort4 operator.yxzz(ushort4 v) {
>+    ushort4 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.z;
>+    result.w = v.z;
>+    return result;
>+}
>+uint4 operator.yxzz(uint3 v) {
>+    uint4 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.z;
>+    result.w = v.z;
>+    return result;
>+}
>+uint4 operator.yxzz(uint4 v) {
>+    uint4 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.z;
>+    result.w = v.z;
>+    return result;
>+}
>+char4 operator.yxzz(char3 v) {
>+    char4 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.z;
>+    result.w = v.z;
>+    return result;
>+}
>+char4 operator.yxzz(char4 v) {
>+    char4 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.z;
>+    result.w = v.z;
>+    return result;
>+}
>+short4 operator.yxzz(short3 v) {
>+    short4 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.z;
>+    result.w = v.z;
>+    return result;
>+}
>+short4 operator.yxzz(short4 v) {
>+    short4 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.z;
>+    result.w = v.z;
>+    return result;
>+}
>+int4 operator.yxzz(int3 v) {
>+    int4 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.z;
>+    result.w = v.z;
>+    return result;
>+}
>+int4 operator.yxzz(int4 v) {
>+    int4 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.z;
>+    result.w = v.z;
>+    return result;
>+}
>+half4 operator.yxzz(half3 v) {
>+    half4 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.z;
>+    result.w = v.z;
>+    return result;
>+}
>+half4 operator.yxzz(half4 v) {
>+    half4 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.z;
>+    result.w = v.z;
>+    return result;
>+}
>+float4 operator.yxzz(float3 v) {
>+    float4 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.z;
>+    result.w = v.z;
>+    return result;
>+}
>+float4 operator.yxzz(float4 v) {
>+    float4 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.z;
>+    result.w = v.z;
>+    return result;
>+}
>+
>+/* Functions named operator.wxzw */
>+bool4 operator.wxzw(bool4 v) {
>+    bool4 result;
>+    result.x = v.w;
>+    result.y = v.x;
>+    result.z = v.z;
>+    result.w = v.w;
>+    return result;
>+}
>+uchar4 operator.wxzw(uchar4 v) {
>+    uchar4 result;
>+    result.x = v.w;
>+    result.y = v.x;
>+    result.z = v.z;
>+    result.w = v.w;
>+    return result;
>+}
>+ushort4 operator.wxzw(ushort4 v) {
>+    ushort4 result;
>+    result.x = v.w;
>+    result.y = v.x;
>+    result.z = v.z;
>+    result.w = v.w;
>+    return result;
>+}
>+uint4 operator.wxzw(uint4 v) {
>+    uint4 result;
>+    result.x = v.w;
>+    result.y = v.x;
>+    result.z = v.z;
>+    result.w = v.w;
>+    return result;
>+}
>+char4 operator.wxzw(char4 v) {
>+    char4 result;
>+    result.x = v.w;
>+    result.y = v.x;
>+    result.z = v.z;
>+    result.w = v.w;
>+    return result;
>+}
>+short4 operator.wxzw(short4 v) {
>+    short4 result;
>+    result.x = v.w;
>+    result.y = v.x;
>+    result.z = v.z;
>+    result.w = v.w;
>+    return result;
>+}
>+int4 operator.wxzw(int4 v) {
>+    int4 result;
>+    result.x = v.w;
>+    result.y = v.x;
>+    result.z = v.z;
>+    result.w = v.w;
>+    return result;
>+}
>+half4 operator.wxzw(half4 v) {
>+    half4 result;
>+    result.x = v.w;
>+    result.y = v.x;
>+    result.z = v.z;
>+    result.w = v.w;
>+    return result;
>+}
>+float4 operator.wxzw(float4 v) {
>+    float4 result;
>+    result.x = v.w;
>+    result.y = v.x;
>+    result.z = v.z;
>+    result.w = v.w;
>+    return result;
>+}
>+
>+/* Functions named operator.zxyx */
>+bool4 operator.zxyx(bool3 v) {
>+    bool4 result;
>+    result.x = v.z;
>+    result.y = v.x;
>+    result.z = v.y;
>+    result.w = v.x;
>+    return result;
>+}
>+bool4 operator.zxyx(bool4 v) {
>+    bool4 result;
>+    result.x = v.z;
>+    result.y = v.x;
>+    result.z = v.y;
>+    result.w = v.x;
>+    return result;
>+}
>+uchar4 operator.zxyx(uchar3 v) {
>+    uchar4 result;
>+    result.x = v.z;
>+    result.y = v.x;
>+    result.z = v.y;
>+    result.w = v.x;
>+    return result;
>+}
>+uchar4 operator.zxyx(uchar4 v) {
>+    uchar4 result;
>+    result.x = v.z;
>+    result.y = v.x;
>+    result.z = v.y;
>+    result.w = v.x;
>+    return result;
>+}
>+ushort4 operator.zxyx(ushort3 v) {
>+    ushort4 result;
>+    result.x = v.z;
>+    result.y = v.x;
>+    result.z = v.y;
>+    result.w = v.x;
>+    return result;
>+}
>+ushort4 operator.zxyx(ushort4 v) {
>+    ushort4 result;
>+    result.x = v.z;
>+    result.y = v.x;
>+    result.z = v.y;
>+    result.w = v.x;
>+    return result;
>+}
>+uint4 operator.zxyx(uint3 v) {
>+    uint4 result;
>+    result.x = v.z;
>+    result.y = v.x;
>+    result.z = v.y;
>+    result.w = v.x;
>+    return result;
>+}
>+uint4 operator.zxyx(uint4 v) {
>+    uint4 result;
>+    result.x = v.z;
>+    result.y = v.x;
>+    result.z = v.y;
>+    result.w = v.x;
>+    return result;
>+}
>+char4 operator.zxyx(char3 v) {
>+    char4 result;
>+    result.x = v.z;
>+    result.y = v.x;
>+    result.z = v.y;
>+    result.w = v.x;
>+    return result;
>+}
>+char4 operator.zxyx(char4 v) {
>+    char4 result;
>+    result.x = v.z;
>+    result.y = v.x;
>+    result.z = v.y;
>+    result.w = v.x;
>+    return result;
>+}
>+short4 operator.zxyx(short3 v) {
>+    short4 result;
>+    result.x = v.z;
>+    result.y = v.x;
>+    result.z = v.y;
>+    result.w = v.x;
>+    return result;
>+}
>+short4 operator.zxyx(short4 v) {
>+    short4 result;
>+    result.x = v.z;
>+    result.y = v.x;
>+    result.z = v.y;
>+    result.w = v.x;
>+    return result;
>+}
>+int4 operator.zxyx(int3 v) {
>+    int4 result;
>+    result.x = v.z;
>+    result.y = v.x;
>+    result.z = v.y;
>+    result.w = v.x;
>+    return result;
>+}
>+int4 operator.zxyx(int4 v) {
>+    int4 result;
>+    result.x = v.z;
>+    result.y = v.x;
>+    result.z = v.y;
>+    result.w = v.x;
>+    return result;
>+}
>+half4 operator.zxyx(half3 v) {
>+    half4 result;
>+    result.x = v.z;
>+    result.y = v.x;
>+    result.z = v.y;
>+    result.w = v.x;
>+    return result;
>+}
>+half4 operator.zxyx(half4 v) {
>+    half4 result;
>+    result.x = v.z;
>+    result.y = v.x;
>+    result.z = v.y;
>+    result.w = v.x;
>+    return result;
>+}
>+float4 operator.zxyx(float3 v) {
>+    float4 result;
>+    result.x = v.z;
>+    result.y = v.x;
>+    result.z = v.y;
>+    result.w = v.x;
>+    return result;
>+}
>+float4 operator.zxyx(float4 v) {
>+    float4 result;
>+    result.x = v.z;
>+    result.y = v.x;
>+    result.z = v.y;
>+    result.w = v.x;
>+    return result;
>+}
>+
>+/* Functions named operator.wxyz= */
>+bool4 operator.wxyz=(bool4 v, bool4 c) {
>+    bool4 result = v;
>+    result.w = c.x;
>+    result.x = c.y;
>+    result.y = c.z;
>+    result.z = c.w;
>+    return result;
>+}
>+uchar4 operator.wxyz=(uchar4 v, uchar4 c) {
>+    uchar4 result = v;
>+    result.w = c.x;
>+    result.x = c.y;
>+    result.y = c.z;
>+    result.z = c.w;
>+    return result;
>+}
>+ushort4 operator.wxyz=(ushort4 v, ushort4 c) {
>+    ushort4 result = v;
>+    result.w = c.x;
>+    result.x = c.y;
>+    result.y = c.z;
>+    result.z = c.w;
>+    return result;
>+}
>+uint4 operator.wxyz=(uint4 v, uint4 c) {
>+    uint4 result = v;
>+    result.w = c.x;
>+    result.x = c.y;
>+    result.y = c.z;
>+    result.z = c.w;
>+    return result;
>+}
>+char4 operator.wxyz=(char4 v, char4 c) {
>+    char4 result = v;
>+    result.w = c.x;
>+    result.x = c.y;
>+    result.y = c.z;
>+    result.z = c.w;
>+    return result;
>+}
>+short4 operator.wxyz=(short4 v, short4 c) {
>+    short4 result = v;
>+    result.w = c.x;
>+    result.x = c.y;
>+    result.y = c.z;
>+    result.z = c.w;
>+    return result;
>+}
>+int4 operator.wxyz=(int4 v, int4 c) {
>+    int4 result = v;
>+    result.w = c.x;
>+    result.x = c.y;
>+    result.y = c.z;
>+    result.z = c.w;
>+    return result;
>+}
>+half4 operator.wxyz=(half4 v, half4 c) {
>+    half4 result = v;
>+    result.w = c.x;
>+    result.x = c.y;
>+    result.y = c.z;
>+    result.z = c.w;
>+    return result;
>+}
>+float4 operator.wxyz=(float4 v, float4 c) {
>+    float4 result = v;
>+    result.w = c.x;
>+    result.x = c.y;
>+    result.y = c.z;
>+    result.z = c.w;
>+    return result;
>+}
>+
>+/* Functions named operator.yyxy */
>+bool4 operator.yyxy(bool2 v) {
>+    bool4 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.x;
>+    result.w = v.y;
>+    return result;
>+}
>+bool4 operator.yyxy(bool3 v) {
>+    bool4 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.x;
>+    result.w = v.y;
>+    return result;
>+}
>+bool4 operator.yyxy(bool4 v) {
>+    bool4 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.x;
>+    result.w = v.y;
>+    return result;
>+}
>+uchar4 operator.yyxy(uchar2 v) {
>+    uchar4 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.x;
>+    result.w = v.y;
>+    return result;
>+}
>+uchar4 operator.yyxy(uchar3 v) {
>+    uchar4 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.x;
>+    result.w = v.y;
>+    return result;
>+}
>+uchar4 operator.yyxy(uchar4 v) {
>+    uchar4 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.x;
>+    result.w = v.y;
>+    return result;
>+}
>+ushort4 operator.yyxy(ushort2 v) {
>+    ushort4 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.x;
>+    result.w = v.y;
>+    return result;
>+}
>+ushort4 operator.yyxy(ushort3 v) {
>+    ushort4 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.x;
>+    result.w = v.y;
>+    return result;
>+}
>+ushort4 operator.yyxy(ushort4 v) {
>+    ushort4 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.x;
>+    result.w = v.y;
>+    return result;
>+}
>+uint4 operator.yyxy(uint2 v) {
>+    uint4 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.x;
>+    result.w = v.y;
>+    return result;
>+}
>+uint4 operator.yyxy(uint3 v) {
>+    uint4 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.x;
>+    result.w = v.y;
>+    return result;
>+}
>+uint4 operator.yyxy(uint4 v) {
>+    uint4 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.x;
>+    result.w = v.y;
>+    return result;
>+}
>+char4 operator.yyxy(char2 v) {
>+    char4 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.x;
>+    result.w = v.y;
>+    return result;
>+}
>+char4 operator.yyxy(char3 v) {
>+    char4 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.x;
>+    result.w = v.y;
>+    return result;
>+}
>+char4 operator.yyxy(char4 v) {
>+    char4 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.x;
>+    result.w = v.y;
>+    return result;
>+}
>+short4 operator.yyxy(short2 v) {
>+    short4 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.x;
>+    result.w = v.y;
>+    return result;
>+}
>+short4 operator.yyxy(short3 v) {
>+    short4 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.x;
>+    result.w = v.y;
>+    return result;
>+}
>+short4 operator.yyxy(short4 v) {
>+    short4 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.x;
>+    result.w = v.y;
>+    return result;
>+}
>+int4 operator.yyxy(int2 v) {
>+    int4 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.x;
>+    result.w = v.y;
>+    return result;
>+}
>+int4 operator.yyxy(int3 v) {
>+    int4 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.x;
>+    result.w = v.y;
>+    return result;
>+}
>+int4 operator.yyxy(int4 v) {
>+    int4 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.x;
>+    result.w = v.y;
>+    return result;
>+}
>+half4 operator.yyxy(half2 v) {
>+    half4 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.x;
>+    result.w = v.y;
>+    return result;
>+}
>+half4 operator.yyxy(half3 v) {
>+    half4 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.x;
>+    result.w = v.y;
>+    return result;
>+}
>+half4 operator.yyxy(half4 v) {
>+    half4 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.x;
>+    result.w = v.y;
>+    return result;
>+}
>+float4 operator.yyxy(float2 v) {
>+    float4 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.x;
>+    result.w = v.y;
>+    return result;
>+}
>+float4 operator.yyxy(float3 v) {
>+    float4 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.x;
>+    result.w = v.y;
>+    return result;
>+}
>+float4 operator.yyxy(float4 v) {
>+    float4 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.x;
>+    result.w = v.y;
>+    return result;
>+}
>+
>+/* Functions named operator.xz */
>+bool2 operator.xz(bool3 v) {
>+    bool2 result;
>+    result.x = v.x;
>+    result.y = v.z;
>+    return result;
>+}
>+bool2 operator.xz(bool4 v) {
>+    bool2 result;
>+    result.x = v.x;
>+    result.y = v.z;
>+    return result;
>+}
>+uchar2 operator.xz(uchar3 v) {
>+    uchar2 result;
>+    result.x = v.x;
>+    result.y = v.z;
>+    return result;
>+}
>+uchar2 operator.xz(uchar4 v) {
>+    uchar2 result;
>+    result.x = v.x;
>+    result.y = v.z;
>+    return result;
>+}
>+ushort2 operator.xz(ushort3 v) {
>+    ushort2 result;
>+    result.x = v.x;
>+    result.y = v.z;
>+    return result;
>+}
>+ushort2 operator.xz(ushort4 v) {
>+    ushort2 result;
>+    result.x = v.x;
>+    result.y = v.z;
>+    return result;
>+}
>+uint2 operator.xz(uint3 v) {
>+    uint2 result;
>+    result.x = v.x;
>+    result.y = v.z;
>+    return result;
>+}
>+uint2 operator.xz(uint4 v) {
>+    uint2 result;
>+    result.x = v.x;
>+    result.y = v.z;
>+    return result;
>+}
>+char2 operator.xz(char3 v) {
>+    char2 result;
>+    result.x = v.x;
>+    result.y = v.z;
>+    return result;
>+}
>+char2 operator.xz(char4 v) {
>+    char2 result;
>+    result.x = v.x;
>+    result.y = v.z;
>+    return result;
>+}
>+short2 operator.xz(short3 v) {
>+    short2 result;
>+    result.x = v.x;
>+    result.y = v.z;
>+    return result;
>+}
>+short2 operator.xz(short4 v) {
>+    short2 result;
>+    result.x = v.x;
>+    result.y = v.z;
>+    return result;
>+}
>+int2 operator.xz(int3 v) {
>+    int2 result;
>+    result.x = v.x;
>+    result.y = v.z;
>+    return result;
>+}
>+int2 operator.xz(int4 v) {
>+    int2 result;
>+    result.x = v.x;
>+    result.y = v.z;
>+    return result;
>+}
>+half2 operator.xz(half3 v) {
>+    half2 result;
>+    result.x = v.x;
>+    result.y = v.z;
>+    return result;
>+}
>+half2 operator.xz(half4 v) {
>+    half2 result;
>+    result.x = v.x;
>+    result.y = v.z;
>+    return result;
>+}
>+float2 operator.xz(float3 v) {
>+    float2 result;
>+    result.x = v.x;
>+    result.y = v.z;
>+    return result;
>+}
>+float2 operator.xz(float4 v) {
>+    float2 result;
>+    result.x = v.x;
>+    result.y = v.z;
>+    return result;
>+}
>+
>+/* Functions named operator.ywyw */
>+bool4 operator.ywyw(bool4 v) {
>+    bool4 result;
>+    result.x = v.y;
>+    result.y = v.w;
>+    result.z = v.y;
>+    result.w = v.w;
>+    return result;
>+}
>+uchar4 operator.ywyw(uchar4 v) {
>+    uchar4 result;
>+    result.x = v.y;
>+    result.y = v.w;
>+    result.z = v.y;
>+    result.w = v.w;
>+    return result;
>+}
>+ushort4 operator.ywyw(ushort4 v) {
>+    ushort4 result;
>+    result.x = v.y;
>+    result.y = v.w;
>+    result.z = v.y;
>+    result.w = v.w;
>+    return result;
>+}
>+uint4 operator.ywyw(uint4 v) {
>+    uint4 result;
>+    result.x = v.y;
>+    result.y = v.w;
>+    result.z = v.y;
>+    result.w = v.w;
>+    return result;
>+}
>+char4 operator.ywyw(char4 v) {
>+    char4 result;
>+    result.x = v.y;
>+    result.y = v.w;
>+    result.z = v.y;
>+    result.w = v.w;
>+    return result;
>+}
>+short4 operator.ywyw(short4 v) {
>+    short4 result;
>+    result.x = v.y;
>+    result.y = v.w;
>+    result.z = v.y;
>+    result.w = v.w;
>+    return result;
>+}
>+int4 operator.ywyw(int4 v) {
>+    int4 result;
>+    result.x = v.y;
>+    result.y = v.w;
>+    result.z = v.y;
>+    result.w = v.w;
>+    return result;
>+}
>+half4 operator.ywyw(half4 v) {
>+    half4 result;
>+    result.x = v.y;
>+    result.y = v.w;
>+    result.z = v.y;
>+    result.w = v.w;
>+    return result;
>+}
>+float4 operator.ywyw(float4 v) {
>+    float4 result;
>+    result.x = v.y;
>+    result.y = v.w;
>+    result.z = v.y;
>+    result.w = v.w;
>+    return result;
>+}
>+
>+/* Functions named operator.wzzz */
>+bool4 operator.wzzz(bool4 v) {
>+    bool4 result;
>+    result.x = v.w;
>+    result.y = v.z;
>+    result.z = v.z;
>+    result.w = v.z;
>+    return result;
>+}
>+uchar4 operator.wzzz(uchar4 v) {
>+    uchar4 result;
>+    result.x = v.w;
>+    result.y = v.z;
>+    result.z = v.z;
>+    result.w = v.z;
>+    return result;
>+}
>+ushort4 operator.wzzz(ushort4 v) {
>+    ushort4 result;
>+    result.x = v.w;
>+    result.y = v.z;
>+    result.z = v.z;
>+    result.w = v.z;
>+    return result;
>+}
>+uint4 operator.wzzz(uint4 v) {
>+    uint4 result;
>+    result.x = v.w;
>+    result.y = v.z;
>+    result.z = v.z;
>+    result.w = v.z;
>+    return result;
>+}
>+char4 operator.wzzz(char4 v) {
>+    char4 result;
>+    result.x = v.w;
>+    result.y = v.z;
>+    result.z = v.z;
>+    result.w = v.z;
>+    return result;
>+}
>+short4 operator.wzzz(short4 v) {
>+    short4 result;
>+    result.x = v.w;
>+    result.y = v.z;
>+    result.z = v.z;
>+    result.w = v.z;
>+    return result;
>+}
>+int4 operator.wzzz(int4 v) {
>+    int4 result;
>+    result.x = v.w;
>+    result.y = v.z;
>+    result.z = v.z;
>+    result.w = v.z;
>+    return result;
>+}
>+half4 operator.wzzz(half4 v) {
>+    half4 result;
>+    result.x = v.w;
>+    result.y = v.z;
>+    result.z = v.z;
>+    result.w = v.z;
>+    return result;
>+}
>+float4 operator.wzzz(float4 v) {
>+    float4 result;
>+    result.x = v.w;
>+    result.y = v.z;
>+    result.z = v.z;
>+    result.w = v.z;
>+    return result;
>+}
>+
>+/* Functions named isunordered */
>+bool isunordered(half x, half y) {
>+    return isnan(x) || isnan(y);
>+}
>+bool2 isunordered(half2 x, half2 y) {
>+    bool2 result;
>+    result[0] = isunordered(x[0], y[0]);
>+    result[1] = isunordered(x[1], y[1]);
>+    return result;
>+}
>+bool3 isunordered(half3 x, half3 y) {
>+    bool3 result;
>+    result[0] = isunordered(x[0], y[0]);
>+    result[1] = isunordered(x[1], y[1]);
>+    result[2] = isunordered(x[2], y[2]);
>+    return result;
>+}
>+bool4 isunordered(half4 x, half4 y) {
>+    bool4 result;
>+    result[0] = isunordered(x[0], y[0]);
>+    result[1] = isunordered(x[1], y[1]);
>+    result[2] = isunordered(x[2], y[2]);
>+    result[3] = isunordered(x[3], y[3]);
>+    return result;
>+}
>+
>+bool isunordered(float x, float y) {
>+    return isnan(x) || isnan(y);
>+}
>+bool2 isunordered(float2 x, float2 y) {
>+    bool2 result;
>+    result[0] = isunordered(x[0], y[0]);
>+    result[1] = isunordered(x[1], y[1]);
>+    return result;
>+}
>+bool3 isunordered(float3 x, float3 y) {
>+    bool3 result;
>+    result[0] = isunordered(x[0], y[0]);
>+    result[1] = isunordered(x[1], y[1]);
>+    result[2] = isunordered(x[2], y[2]);
>+    return result;
>+}
>+bool4 isunordered(float4 x, float4 y) {
>+    bool4 result;
>+    result[0] = isunordered(x[0], y[0]);
>+    result[1] = isunordered(x[1], y[1]);
>+    result[2] = isunordered(x[2], y[2]);
>+    result[3] = isunordered(x[3], y[3]);
>+    return result;
>+}
>+
>+
>+/* Functions named operator.zwwy */
>+bool4 operator.zwwy(bool4 v) {
>+    bool4 result;
>+    result.x = v.z;
>+    result.y = v.w;
>+    result.z = v.w;
>+    result.w = v.y;
>+    return result;
>+}
>+uchar4 operator.zwwy(uchar4 v) {
>+    uchar4 result;
>+    result.x = v.z;
>+    result.y = v.w;
>+    result.z = v.w;
>+    result.w = v.y;
>+    return result;
>+}
>+ushort4 operator.zwwy(ushort4 v) {
>+    ushort4 result;
>+    result.x = v.z;
>+    result.y = v.w;
>+    result.z = v.w;
>+    result.w = v.y;
>+    return result;
>+}
>+uint4 operator.zwwy(uint4 v) {
>+    uint4 result;
>+    result.x = v.z;
>+    result.y = v.w;
>+    result.z = v.w;
>+    result.w = v.y;
>+    return result;
>+}
>+char4 operator.zwwy(char4 v) {
>+    char4 result;
>+    result.x = v.z;
>+    result.y = v.w;
>+    result.z = v.w;
>+    result.w = v.y;
>+    return result;
>+}
>+short4 operator.zwwy(short4 v) {
>+    short4 result;
>+    result.x = v.z;
>+    result.y = v.w;
>+    result.z = v.w;
>+    result.w = v.y;
>+    return result;
>+}
>+int4 operator.zwwy(int4 v) {
>+    int4 result;
>+    result.x = v.z;
>+    result.y = v.w;
>+    result.z = v.w;
>+    result.w = v.y;
>+    return result;
>+}
>+half4 operator.zwwy(half4 v) {
>+    half4 result;
>+    result.x = v.z;
>+    result.y = v.w;
>+    result.z = v.w;
>+    result.w = v.y;
>+    return result;
>+}
>+float4 operator.zwwy(float4 v) {
>+    float4 result;
>+    result.x = v.z;
>+    result.y = v.w;
>+    result.z = v.w;
>+    result.w = v.y;
>+    return result;
>+}
>+
>+/* Functions named operator.zzxz */
>+bool4 operator.zzxz(bool3 v) {
>+    bool4 result;
>+    result.x = v.z;
>+    result.y = v.z;
>+    result.z = v.x;
>+    result.w = v.z;
>+    return result;
>+}
>+bool4 operator.zzxz(bool4 v) {
>+    bool4 result;
>+    result.x = v.z;
>+    result.y = v.z;
>+    result.z = v.x;
>+    result.w = v.z;
>+    return result;
>+}
>+uchar4 operator.zzxz(uchar3 v) {
>+    uchar4 result;
>+    result.x = v.z;
>+    result.y = v.z;
>+    result.z = v.x;
>+    result.w = v.z;
>+    return result;
>+}
>+uchar4 operator.zzxz(uchar4 v) {
>+    uchar4 result;
>+    result.x = v.z;
>+    result.y = v.z;
>+    result.z = v.x;
>+    result.w = v.z;
>+    return result;
>+}
>+ushort4 operator.zzxz(ushort3 v) {
>+    ushort4 result;
>+    result.x = v.z;
>+    result.y = v.z;
>+    result.z = v.x;
>+    result.w = v.z;
>+    return result;
>+}
>+ushort4 operator.zzxz(ushort4 v) {
>+    ushort4 result;
>+    result.x = v.z;
>+    result.y = v.z;
>+    result.z = v.x;
>+    result.w = v.z;
>+    return result;
>+}
>+uint4 operator.zzxz(uint3 v) {
>+    uint4 result;
>+    result.x = v.z;
>+    result.y = v.z;
>+    result.z = v.x;
>+    result.w = v.z;
>+    return result;
>+}
>+uint4 operator.zzxz(uint4 v) {
>+    uint4 result;
>+    result.x = v.z;
>+    result.y = v.z;
>+    result.z = v.x;
>+    result.w = v.z;
>+    return result;
>+}
>+char4 operator.zzxz(char3 v) {
>+    char4 result;
>+    result.x = v.z;
>+    result.y = v.z;
>+    result.z = v.x;
>+    result.w = v.z;
>+    return result;
>+}
>+char4 operator.zzxz(char4 v) {
>+    char4 result;
>+    result.x = v.z;
>+    result.y = v.z;
>+    result.z = v.x;
>+    result.w = v.z;
>+    return result;
>+}
>+short4 operator.zzxz(short3 v) {
>+    short4 result;
>+    result.x = v.z;
>+    result.y = v.z;
>+    result.z = v.x;
>+    result.w = v.z;
>+    return result;
>+}
>+short4 operator.zzxz(short4 v) {
>+    short4 result;
>+    result.x = v.z;
>+    result.y = v.z;
>+    result.z = v.x;
>+    result.w = v.z;
>+    return result;
>+}
>+int4 operator.zzxz(int3 v) {
>+    int4 result;
>+    result.x = v.z;
>+    result.y = v.z;
>+    result.z = v.x;
>+    result.w = v.z;
>+    return result;
>+}
>+int4 operator.zzxz(int4 v) {
>+    int4 result;
>+    result.x = v.z;
>+    result.y = v.z;
>+    result.z = v.x;
>+    result.w = v.z;
>+    return result;
>+}
>+half4 operator.zzxz(half3 v) {
>+    half4 result;
>+    result.x = v.z;
>+    result.y = v.z;
>+    result.z = v.x;
>+    result.w = v.z;
>+    return result;
>+}
>+half4 operator.zzxz(half4 v) {
>+    half4 result;
>+    result.x = v.z;
>+    result.y = v.z;
>+    result.z = v.x;
>+    result.w = v.z;
>+    return result;
>+}
>+float4 operator.zzxz(float3 v) {
>+    float4 result;
>+    result.x = v.z;
>+    result.y = v.z;
>+    result.z = v.x;
>+    result.w = v.z;
>+    return result;
>+}
>+float4 operator.zzxz(float4 v) {
>+    float4 result;
>+    result.x = v.z;
>+    result.y = v.z;
>+    result.z = v.x;
>+    result.w = v.z;
>+    return result;
>+}
>+
>+/* Functions named atan */
>+native float atan(float);
>+half atan(half x) {
>+    return half(atan(float(x)));
>+}
>+half2 atan(half2 x) {
>+    half2 result;
>+    result[0] = atan(x[0]);
>+    result[1] = atan(x[1]);
>+    return result;
>+}
>+half3 atan(half3 x) {
>+    half3 result;
>+    result[0] = atan(x[0]);
>+    result[1] = atan(x[1]);
>+    result[2] = atan(x[2]);
>+    return result;
>+}
>+half4 atan(half4 x) {
>+    half4 result;
>+    result[0] = atan(x[0]);
>+    result[1] = atan(x[1]);
>+    result[2] = atan(x[2]);
>+    result[3] = atan(x[3]);
>+    return result;
>+}
>+half2x2 atan(half2x2 x) {
>+    half2x2 result;
>+    result[0][0] = atan(x[0][0]);
>+    result[0][1] = atan(x[0][1]);
>+    result[1][0] = atan(x[1][0]);
>+    result[1][1] = atan(x[1][1]);
>+    return result;
>+}
>+half2x3 atan(half2x3 x) {
>+    half2x3 result;
>+    result[0][0] = atan(x[0][0]);
>+    result[0][1] = atan(x[0][1]);
>+    result[0][2] = atan(x[0][2]);
>+    result[1][0] = atan(x[1][0]);
>+    result[1][1] = atan(x[1][1]);
>+    result[1][2] = atan(x[1][2]);
>+    return result;
>+}
>+half2x4 atan(half2x4 x) {
>+    half2x4 result;
>+    result[0][0] = atan(x[0][0]);
>+    result[0][1] = atan(x[0][1]);
>+    result[0][2] = atan(x[0][2]);
>+    result[0][3] = atan(x[0][3]);
>+    result[1][0] = atan(x[1][0]);
>+    result[1][1] = atan(x[1][1]);
>+    result[1][2] = atan(x[1][2]);
>+    result[1][3] = atan(x[1][3]);
>+    return result;
>+}
>+half3x2 atan(half3x2 x) {
>+    half3x2 result;
>+    result[0][0] = atan(x[0][0]);
>+    result[0][1] = atan(x[0][1]);
>+    result[1][0] = atan(x[1][0]);
>+    result[1][1] = atan(x[1][1]);
>+    result[2][0] = atan(x[2][0]);
>+    result[2][1] = atan(x[2][1]);
>+    return result;
>+}
>+half3x3 atan(half3x3 x) {
>+    half3x3 result;
>+    result[0][0] = atan(x[0][0]);
>+    result[0][1] = atan(x[0][1]);
>+    result[0][2] = atan(x[0][2]);
>+    result[1][0] = atan(x[1][0]);
>+    result[1][1] = atan(x[1][1]);
>+    result[1][2] = atan(x[1][2]);
>+    result[2][0] = atan(x[2][0]);
>+    result[2][1] = atan(x[2][1]);
>+    result[2][2] = atan(x[2][2]);
>+    return result;
>+}
>+half3x4 atan(half3x4 x) {
>+    half3x4 result;
>+    result[0][0] = atan(x[0][0]);
>+    result[0][1] = atan(x[0][1]);
>+    result[0][2] = atan(x[0][2]);
>+    result[0][3] = atan(x[0][3]);
>+    result[1][0] = atan(x[1][0]);
>+    result[1][1] = atan(x[1][1]);
>+    result[1][2] = atan(x[1][2]);
>+    result[1][3] = atan(x[1][3]);
>+    result[2][0] = atan(x[2][0]);
>+    result[2][1] = atan(x[2][1]);
>+    result[2][2] = atan(x[2][2]);
>+    result[2][3] = atan(x[2][3]);
>+    return result;
>+}
>+half4x2 atan(half4x2 x) {
>+    half4x2 result;
>+    result[0][0] = atan(x[0][0]);
>+    result[0][1] = atan(x[0][1]);
>+    result[1][0] = atan(x[1][0]);
>+    result[1][1] = atan(x[1][1]);
>+    result[2][0] = atan(x[2][0]);
>+    result[2][1] = atan(x[2][1]);
>+    result[3][0] = atan(x[3][0]);
>+    result[3][1] = atan(x[3][1]);
>+    return result;
>+}
>+half4x3 atan(half4x3 x) {
>+    half4x3 result;
>+    result[0][0] = atan(x[0][0]);
>+    result[0][1] = atan(x[0][1]);
>+    result[0][2] = atan(x[0][2]);
>+    result[1][0] = atan(x[1][0]);
>+    result[1][1] = atan(x[1][1]);
>+    result[1][2] = atan(x[1][2]);
>+    result[2][0] = atan(x[2][0]);
>+    result[2][1] = atan(x[2][1]);
>+    result[2][2] = atan(x[2][2]);
>+    result[3][0] = atan(x[3][0]);
>+    result[3][1] = atan(x[3][1]);
>+    result[3][2] = atan(x[3][2]);
>+    return result;
>+}
>+half4x4 atan(half4x4 x) {
>+    half4x4 result;
>+    result[0][0] = atan(x[0][0]);
>+    result[0][1] = atan(x[0][1]);
>+    result[0][2] = atan(x[0][2]);
>+    result[0][3] = atan(x[0][3]);
>+    result[1][0] = atan(x[1][0]);
>+    result[1][1] = atan(x[1][1]);
>+    result[1][2] = atan(x[1][2]);
>+    result[1][3] = atan(x[1][3]);
>+    result[2][0] = atan(x[2][0]);
>+    result[2][1] = atan(x[2][1]);
>+    result[2][2] = atan(x[2][2]);
>+    result[2][3] = atan(x[2][3]);
>+    result[3][0] = atan(x[3][0]);
>+    result[3][1] = atan(x[3][1]);
>+    result[3][2] = atan(x[3][2]);
>+    result[3][3] = atan(x[3][3]);
>+    return result;
>+}
>+float2 atan(float2 x) {
>+    float2 result;
>+    result[0] = atan(x[0]);
>+    result[1] = atan(x[1]);
>+    return result;
>+}
>+float3 atan(float3 x) {
>+    float3 result;
>+    result[0] = atan(x[0]);
>+    result[1] = atan(x[1]);
>+    result[2] = atan(x[2]);
>+    return result;
>+}
>+float4 atan(float4 x) {
>+    float4 result;
>+    result[0] = atan(x[0]);
>+    result[1] = atan(x[1]);
>+    result[2] = atan(x[2]);
>+    result[3] = atan(x[3]);
>+    return result;
>+}
>+float2x2 atan(float2x2 x) {
>+    float2x2 result;
>+    result[0][0] = atan(x[0][0]);
>+    result[0][1] = atan(x[0][1]);
>+    result[1][0] = atan(x[1][0]);
>+    result[1][1] = atan(x[1][1]);
>+    return result;
>+}
>+float2x3 atan(float2x3 x) {
>+    float2x3 result;
>+    result[0][0] = atan(x[0][0]);
>+    result[0][1] = atan(x[0][1]);
>+    result[0][2] = atan(x[0][2]);
>+    result[1][0] = atan(x[1][0]);
>+    result[1][1] = atan(x[1][1]);
>+    result[1][2] = atan(x[1][2]);
>+    return result;
>+}
>+float2x4 atan(float2x4 x) {
>+    float2x4 result;
>+    result[0][0] = atan(x[0][0]);
>+    result[0][1] = atan(x[0][1]);
>+    result[0][2] = atan(x[0][2]);
>+    result[0][3] = atan(x[0][3]);
>+    result[1][0] = atan(x[1][0]);
>+    result[1][1] = atan(x[1][1]);
>+    result[1][2] = atan(x[1][2]);
>+    result[1][3] = atan(x[1][3]);
>+    return result;
>+}
>+float3x2 atan(float3x2 x) {
>+    float3x2 result;
>+    result[0][0] = atan(x[0][0]);
>+    result[0][1] = atan(x[0][1]);
>+    result[1][0] = atan(x[1][0]);
>+    result[1][1] = atan(x[1][1]);
>+    result[2][0] = atan(x[2][0]);
>+    result[2][1] = atan(x[2][1]);
>+    return result;
>+}
>+float3x3 atan(float3x3 x) {
>+    float3x3 result;
>+    result[0][0] = atan(x[0][0]);
>+    result[0][1] = atan(x[0][1]);
>+    result[0][2] = atan(x[0][2]);
>+    result[1][0] = atan(x[1][0]);
>+    result[1][1] = atan(x[1][1]);
>+    result[1][2] = atan(x[1][2]);
>+    result[2][0] = atan(x[2][0]);
>+    result[2][1] = atan(x[2][1]);
>+    result[2][2] = atan(x[2][2]);
>+    return result;
>+}
>+float3x4 atan(float3x4 x) {
>+    float3x4 result;
>+    result[0][0] = atan(x[0][0]);
>+    result[0][1] = atan(x[0][1]);
>+    result[0][2] = atan(x[0][2]);
>+    result[0][3] = atan(x[0][3]);
>+    result[1][0] = atan(x[1][0]);
>+    result[1][1] = atan(x[1][1]);
>+    result[1][2] = atan(x[1][2]);
>+    result[1][3] = atan(x[1][3]);
>+    result[2][0] = atan(x[2][0]);
>+    result[2][1] = atan(x[2][1]);
>+    result[2][2] = atan(x[2][2]);
>+    result[2][3] = atan(x[2][3]);
>+    return result;
>+}
>+float4x2 atan(float4x2 x) {
>+    float4x2 result;
>+    result[0][0] = atan(x[0][0]);
>+    result[0][1] = atan(x[0][1]);
>+    result[1][0] = atan(x[1][0]);
>+    result[1][1] = atan(x[1][1]);
>+    result[2][0] = atan(x[2][0]);
>+    result[2][1] = atan(x[2][1]);
>+    result[3][0] = atan(x[3][0]);
>+    result[3][1] = atan(x[3][1]);
>+    return result;
>+}
>+float4x3 atan(float4x3 x) {
>+    float4x3 result;
>+    result[0][0] = atan(x[0][0]);
>+    result[0][1] = atan(x[0][1]);
>+    result[0][2] = atan(x[0][2]);
>+    result[1][0] = atan(x[1][0]);
>+    result[1][1] = atan(x[1][1]);
>+    result[1][2] = atan(x[1][2]);
>+    result[2][0] = atan(x[2][0]);
>+    result[2][1] = atan(x[2][1]);
>+    result[2][2] = atan(x[2][2]);
>+    result[3][0] = atan(x[3][0]);
>+    result[3][1] = atan(x[3][1]);
>+    result[3][2] = atan(x[3][2]);
>+    return result;
>+}
>+float4x4 atan(float4x4 x) {
>+    float4x4 result;
>+    result[0][0] = atan(x[0][0]);
>+    result[0][1] = atan(x[0][1]);
>+    result[0][2] = atan(x[0][2]);
>+    result[0][3] = atan(x[0][3]);
>+    result[1][0] = atan(x[1][0]);
>+    result[1][1] = atan(x[1][1]);
>+    result[1][2] = atan(x[1][2]);
>+    result[1][3] = atan(x[1][3]);
>+    result[2][0] = atan(x[2][0]);
>+    result[2][1] = atan(x[2][1]);
>+    result[2][2] = atan(x[2][2]);
>+    result[2][3] = atan(x[2][3]);
>+    result[3][0] = atan(x[3][0]);
>+    result[3][1] = atan(x[3][1]);
>+    result[3][2] = atan(x[3][2]);
>+    result[3][3] = atan(x[3][3]);
>+    return result;
>+}
>+
>+/* Functions named operator.xxyz */
>+bool4 operator.xxyz(bool3 v) {
>+    bool4 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.y;
>+    result.w = v.z;
>+    return result;
>+}
>+bool4 operator.xxyz(bool4 v) {
>+    bool4 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.y;
>+    result.w = v.z;
>+    return result;
>+}
>+uchar4 operator.xxyz(uchar3 v) {
>+    uchar4 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.y;
>+    result.w = v.z;
>+    return result;
>+}
>+uchar4 operator.xxyz(uchar4 v) {
>+    uchar4 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.y;
>+    result.w = v.z;
>+    return result;
>+}
>+ushort4 operator.xxyz(ushort3 v) {
>+    ushort4 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.y;
>+    result.w = v.z;
>+    return result;
>+}
>+ushort4 operator.xxyz(ushort4 v) {
>+    ushort4 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.y;
>+    result.w = v.z;
>+    return result;
>+}
>+uint4 operator.xxyz(uint3 v) {
>+    uint4 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.y;
>+    result.w = v.z;
>+    return result;
>+}
>+uint4 operator.xxyz(uint4 v) {
>+    uint4 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.y;
>+    result.w = v.z;
>+    return result;
>+}
>+char4 operator.xxyz(char3 v) {
>+    char4 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.y;
>+    result.w = v.z;
>+    return result;
>+}
>+char4 operator.xxyz(char4 v) {
>+    char4 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.y;
>+    result.w = v.z;
>+    return result;
>+}
>+short4 operator.xxyz(short3 v) {
>+    short4 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.y;
>+    result.w = v.z;
>+    return result;
>+}
>+short4 operator.xxyz(short4 v) {
>+    short4 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.y;
>+    result.w = v.z;
>+    return result;
>+}
>+int4 operator.xxyz(int3 v) {
>+    int4 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.y;
>+    result.w = v.z;
>+    return result;
>+}
>+int4 operator.xxyz(int4 v) {
>+    int4 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.y;
>+    result.w = v.z;
>+    return result;
>+}
>+half4 operator.xxyz(half3 v) {
>+    half4 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.y;
>+    result.w = v.z;
>+    return result;
>+}
>+half4 operator.xxyz(half4 v) {
>+    half4 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.y;
>+    result.w = v.z;
>+    return result;
>+}
>+float4 operator.xxyz(float3 v) {
>+    float4 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.y;
>+    result.w = v.z;
>+    return result;
>+}
>+float4 operator.xxyz(float4 v) {
>+    float4 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.y;
>+    result.w = v.z;
>+    return result;
>+}
>+
>+/* Functions named operator.xywy */
>+bool4 operator.xywy(bool4 v) {
>+    bool4 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.w;
>+    result.w = v.y;
>+    return result;
>+}
>+uchar4 operator.xywy(uchar4 v) {
>+    uchar4 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.w;
>+    result.w = v.y;
>+    return result;
>+}
>+ushort4 operator.xywy(ushort4 v) {
>+    ushort4 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.w;
>+    result.w = v.y;
>+    return result;
>+}
>+uint4 operator.xywy(uint4 v) {
>+    uint4 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.w;
>+    result.w = v.y;
>+    return result;
>+}
>+char4 operator.xywy(char4 v) {
>+    char4 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.w;
>+    result.w = v.y;
>+    return result;
>+}
>+short4 operator.xywy(short4 v) {
>+    short4 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.w;
>+    result.w = v.y;
>+    return result;
>+}
>+int4 operator.xywy(int4 v) {
>+    int4 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.w;
>+    result.w = v.y;
>+    return result;
>+}
>+half4 operator.xywy(half4 v) {
>+    half4 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.w;
>+    result.w = v.y;
>+    return result;
>+}
>+float4 operator.xywy(float4 v) {
>+    float4 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.w;
>+    result.w = v.y;
>+    return result;
>+}
>+
>+/* Functions named log */
>+native float log(float);
>+half log(half x) {
>+    return half(log(float(x)));
>+}
>+half2 log(half2 x) {
>+    half2 result;
>+    result[0] = log(x[0]);
>+    result[1] = log(x[1]);
>+    return result;
>+}
>+half3 log(half3 x) {
>+    half3 result;
>+    result[0] = log(x[0]);
>+    result[1] = log(x[1]);
>+    result[2] = log(x[2]);
>+    return result;
>+}
>+half4 log(half4 x) {
>+    half4 result;
>+    result[0] = log(x[0]);
>+    result[1] = log(x[1]);
>+    result[2] = log(x[2]);
>+    result[3] = log(x[3]);
>+    return result;
>+}
>+half2x2 log(half2x2 x) {
>+    half2x2 result;
>+    result[0][0] = log(x[0][0]);
>+    result[0][1] = log(x[0][1]);
>+    result[1][0] = log(x[1][0]);
>+    result[1][1] = log(x[1][1]);
>+    return result;
>+}
>+half2x3 log(half2x3 x) {
>+    half2x3 result;
>+    result[0][0] = log(x[0][0]);
>+    result[0][1] = log(x[0][1]);
>+    result[0][2] = log(x[0][2]);
>+    result[1][0] = log(x[1][0]);
>+    result[1][1] = log(x[1][1]);
>+    result[1][2] = log(x[1][2]);
>+    return result;
>+}
>+half2x4 log(half2x4 x) {
>+    half2x4 result;
>+    result[0][0] = log(x[0][0]);
>+    result[0][1] = log(x[0][1]);
>+    result[0][2] = log(x[0][2]);
>+    result[0][3] = log(x[0][3]);
>+    result[1][0] = log(x[1][0]);
>+    result[1][1] = log(x[1][1]);
>+    result[1][2] = log(x[1][2]);
>+    result[1][3] = log(x[1][3]);
>+    return result;
>+}
>+half3x2 log(half3x2 x) {
>+    half3x2 result;
>+    result[0][0] = log(x[0][0]);
>+    result[0][1] = log(x[0][1]);
>+    result[1][0] = log(x[1][0]);
>+    result[1][1] = log(x[1][1]);
>+    result[2][0] = log(x[2][0]);
>+    result[2][1] = log(x[2][1]);
>+    return result;
>+}
>+half3x3 log(half3x3 x) {
>+    half3x3 result;
>+    result[0][0] = log(x[0][0]);
>+    result[0][1] = log(x[0][1]);
>+    result[0][2] = log(x[0][2]);
>+    result[1][0] = log(x[1][0]);
>+    result[1][1] = log(x[1][1]);
>+    result[1][2] = log(x[1][2]);
>+    result[2][0] = log(x[2][0]);
>+    result[2][1] = log(x[2][1]);
>+    result[2][2] = log(x[2][2]);
>+    return result;
>+}
>+half3x4 log(half3x4 x) {
>+    half3x4 result;
>+    result[0][0] = log(x[0][0]);
>+    result[0][1] = log(x[0][1]);
>+    result[0][2] = log(x[0][2]);
>+    result[0][3] = log(x[0][3]);
>+    result[1][0] = log(x[1][0]);
>+    result[1][1] = log(x[1][1]);
>+    result[1][2] = log(x[1][2]);
>+    result[1][3] = log(x[1][3]);
>+    result[2][0] = log(x[2][0]);
>+    result[2][1] = log(x[2][1]);
>+    result[2][2] = log(x[2][2]);
>+    result[2][3] = log(x[2][3]);
>+    return result;
>+}
>+half4x2 log(half4x2 x) {
>+    half4x2 result;
>+    result[0][0] = log(x[0][0]);
>+    result[0][1] = log(x[0][1]);
>+    result[1][0] = log(x[1][0]);
>+    result[1][1] = log(x[1][1]);
>+    result[2][0] = log(x[2][0]);
>+    result[2][1] = log(x[2][1]);
>+    result[3][0] = log(x[3][0]);
>+    result[3][1] = log(x[3][1]);
>+    return result;
>+}
>+half4x3 log(half4x3 x) {
>+    half4x3 result;
>+    result[0][0] = log(x[0][0]);
>+    result[0][1] = log(x[0][1]);
>+    result[0][2] = log(x[0][2]);
>+    result[1][0] = log(x[1][0]);
>+    result[1][1] = log(x[1][1]);
>+    result[1][2] = log(x[1][2]);
>+    result[2][0] = log(x[2][0]);
>+    result[2][1] = log(x[2][1]);
>+    result[2][2] = log(x[2][2]);
>+    result[3][0] = log(x[3][0]);
>+    result[3][1] = log(x[3][1]);
>+    result[3][2] = log(x[3][2]);
>+    return result;
>+}
>+half4x4 log(half4x4 x) {
>+    half4x4 result;
>+    result[0][0] = log(x[0][0]);
>+    result[0][1] = log(x[0][1]);
>+    result[0][2] = log(x[0][2]);
>+    result[0][3] = log(x[0][3]);
>+    result[1][0] = log(x[1][0]);
>+    result[1][1] = log(x[1][1]);
>+    result[1][2] = log(x[1][2]);
>+    result[1][3] = log(x[1][3]);
>+    result[2][0] = log(x[2][0]);
>+    result[2][1] = log(x[2][1]);
>+    result[2][2] = log(x[2][2]);
>+    result[2][3] = log(x[2][3]);
>+    result[3][0] = log(x[3][0]);
>+    result[3][1] = log(x[3][1]);
>+    result[3][2] = log(x[3][2]);
>+    result[3][3] = log(x[3][3]);
>+    return result;
>+}
>+float2 log(float2 x) {
>+    float2 result;
>+    result[0] = log(x[0]);
>+    result[1] = log(x[1]);
>+    return result;
>+}
>+float3 log(float3 x) {
>+    float3 result;
>+    result[0] = log(x[0]);
>+    result[1] = log(x[1]);
>+    result[2] = log(x[2]);
>+    return result;
>+}
>+float4 log(float4 x) {
>+    float4 result;
>+    result[0] = log(x[0]);
>+    result[1] = log(x[1]);
>+    result[2] = log(x[2]);
>+    result[3] = log(x[3]);
>+    return result;
>+}
>+float2x2 log(float2x2 x) {
>+    float2x2 result;
>+    result[0][0] = log(x[0][0]);
>+    result[0][1] = log(x[0][1]);
>+    result[1][0] = log(x[1][0]);
>+    result[1][1] = log(x[1][1]);
>+    return result;
>+}
>+float2x3 log(float2x3 x) {
>+    float2x3 result;
>+    result[0][0] = log(x[0][0]);
>+    result[0][1] = log(x[0][1]);
>+    result[0][2] = log(x[0][2]);
>+    result[1][0] = log(x[1][0]);
>+    result[1][1] = log(x[1][1]);
>+    result[1][2] = log(x[1][2]);
>+    return result;
>+}
>+float2x4 log(float2x4 x) {
>+    float2x4 result;
>+    result[0][0] = log(x[0][0]);
>+    result[0][1] = log(x[0][1]);
>+    result[0][2] = log(x[0][2]);
>+    result[0][3] = log(x[0][3]);
>+    result[1][0] = log(x[1][0]);
>+    result[1][1] = log(x[1][1]);
>+    result[1][2] = log(x[1][2]);
>+    result[1][3] = log(x[1][3]);
>+    return result;
>+}
>+float3x2 log(float3x2 x) {
>+    float3x2 result;
>+    result[0][0] = log(x[0][0]);
>+    result[0][1] = log(x[0][1]);
>+    result[1][0] = log(x[1][0]);
>+    result[1][1] = log(x[1][1]);
>+    result[2][0] = log(x[2][0]);
>+    result[2][1] = log(x[2][1]);
>+    return result;
>+}
>+float3x3 log(float3x3 x) {
>+    float3x3 result;
>+    result[0][0] = log(x[0][0]);
>+    result[0][1] = log(x[0][1]);
>+    result[0][2] = log(x[0][2]);
>+    result[1][0] = log(x[1][0]);
>+    result[1][1] = log(x[1][1]);
>+    result[1][2] = log(x[1][2]);
>+    result[2][0] = log(x[2][0]);
>+    result[2][1] = log(x[2][1]);
>+    result[2][2] = log(x[2][2]);
>+    return result;
>+}
>+float3x4 log(float3x4 x) {
>+    float3x4 result;
>+    result[0][0] = log(x[0][0]);
>+    result[0][1] = log(x[0][1]);
>+    result[0][2] = log(x[0][2]);
>+    result[0][3] = log(x[0][3]);
>+    result[1][0] = log(x[1][0]);
>+    result[1][1] = log(x[1][1]);
>+    result[1][2] = log(x[1][2]);
>+    result[1][3] = log(x[1][3]);
>+    result[2][0] = log(x[2][0]);
>+    result[2][1] = log(x[2][1]);
>+    result[2][2] = log(x[2][2]);
>+    result[2][3] = log(x[2][3]);
>+    return result;
>+}
>+float4x2 log(float4x2 x) {
>+    float4x2 result;
>+    result[0][0] = log(x[0][0]);
>+    result[0][1] = log(x[0][1]);
>+    result[1][0] = log(x[1][0]);
>+    result[1][1] = log(x[1][1]);
>+    result[2][0] = log(x[2][0]);
>+    result[2][1] = log(x[2][1]);
>+    result[3][0] = log(x[3][0]);
>+    result[3][1] = log(x[3][1]);
>+    return result;
>+}
>+float4x3 log(float4x3 x) {
>+    float4x3 result;
>+    result[0][0] = log(x[0][0]);
>+    result[0][1] = log(x[0][1]);
>+    result[0][2] = log(x[0][2]);
>+    result[1][0] = log(x[1][0]);
>+    result[1][1] = log(x[1][1]);
>+    result[1][2] = log(x[1][2]);
>+    result[2][0] = log(x[2][0]);
>+    result[2][1] = log(x[2][1]);
>+    result[2][2] = log(x[2][2]);
>+    result[3][0] = log(x[3][0]);
>+    result[3][1] = log(x[3][1]);
>+    result[3][2] = log(x[3][2]);
>+    return result;
>+}
>+float4x4 log(float4x4 x) {
>+    float4x4 result;
>+    result[0][0] = log(x[0][0]);
>+    result[0][1] = log(x[0][1]);
>+    result[0][2] = log(x[0][2]);
>+    result[0][3] = log(x[0][3]);
>+    result[1][0] = log(x[1][0]);
>+    result[1][1] = log(x[1][1]);
>+    result[1][2] = log(x[1][2]);
>+    result[1][3] = log(x[1][3]);
>+    result[2][0] = log(x[2][0]);
>+    result[2][1] = log(x[2][1]);
>+    result[2][2] = log(x[2][2]);
>+    result[2][3] = log(x[2][3]);
>+    result[3][0] = log(x[3][0]);
>+    result[3][1] = log(x[3][1]);
>+    result[3][2] = log(x[3][2]);
>+    result[3][3] = log(x[3][3]);
>+    return result;
>+}
>+
>+/* Functions named operator.wxwx */
>+bool4 operator.wxwx(bool4 v) {
>+    bool4 result;
>+    result.x = v.w;
>+    result.y = v.x;
>+    result.z = v.w;
>+    result.w = v.x;
>+    return result;
>+}
>+uchar4 operator.wxwx(uchar4 v) {
>+    uchar4 result;
>+    result.x = v.w;
>+    result.y = v.x;
>+    result.z = v.w;
>+    result.w = v.x;
>+    return result;
>+}
>+ushort4 operator.wxwx(ushort4 v) {
>+    ushort4 result;
>+    result.x = v.w;
>+    result.y = v.x;
>+    result.z = v.w;
>+    result.w = v.x;
>+    return result;
>+}
>+uint4 operator.wxwx(uint4 v) {
>+    uint4 result;
>+    result.x = v.w;
>+    result.y = v.x;
>+    result.z = v.w;
>+    result.w = v.x;
>+    return result;
>+}
>+char4 operator.wxwx(char4 v) {
>+    char4 result;
>+    result.x = v.w;
>+    result.y = v.x;
>+    result.z = v.w;
>+    result.w = v.x;
>+    return result;
>+}
>+short4 operator.wxwx(short4 v) {
>+    short4 result;
>+    result.x = v.w;
>+    result.y = v.x;
>+    result.z = v.w;
>+    result.w = v.x;
>+    return result;
>+}
>+int4 operator.wxwx(int4 v) {
>+    int4 result;
>+    result.x = v.w;
>+    result.y = v.x;
>+    result.z = v.w;
>+    result.w = v.x;
>+    return result;
>+}
>+half4 operator.wxwx(half4 v) {
>+    half4 result;
>+    result.x = v.w;
>+    result.y = v.x;
>+    result.z = v.w;
>+    result.w = v.x;
>+    return result;
>+}
>+float4 operator.wxwx(float4 v) {
>+    float4 result;
>+    result.x = v.w;
>+    result.y = v.x;
>+    result.z = v.w;
>+    result.w = v.x;
>+    return result;
>+}
>+
>+/* Functions named operator.yxzw */
>+bool4 operator.yxzw(bool4 v) {
>+    bool4 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.z;
>+    result.w = v.w;
>+    return result;
>+}
>+uchar4 operator.yxzw(uchar4 v) {
>+    uchar4 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.z;
>+    result.w = v.w;
>+    return result;
>+}
>+ushort4 operator.yxzw(ushort4 v) {
>+    ushort4 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.z;
>+    result.w = v.w;
>+    return result;
>+}
>+uint4 operator.yxzw(uint4 v) {
>+    uint4 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.z;
>+    result.w = v.w;
>+    return result;
>+}
>+char4 operator.yxzw(char4 v) {
>+    char4 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.z;
>+    result.w = v.w;
>+    return result;
>+}
>+short4 operator.yxzw(short4 v) {
>+    short4 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.z;
>+    result.w = v.w;
>+    return result;
>+}
>+int4 operator.yxzw(int4 v) {
>+    int4 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.z;
>+    result.w = v.w;
>+    return result;
>+}
>+half4 operator.yxzw(half4 v) {
>+    half4 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.z;
>+    result.w = v.w;
>+    return result;
>+}
>+float4 operator.yxzw(float4 v) {
>+    float4 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.z;
>+    result.w = v.w;
>+    return result;
>+}
>+
>+/* Functions named Load */
>+native ushort Load(Texture1D<ushort>, int location);
>+native ushort Load(Texture1DArray<ushort>, int2 location);
>+native ushort Load(Texture2D<ushort>, int2 location);
>+native ushort Load(Texture2DArray<ushort>, int3 location);
>+native ushort Load(Texture3D<ushort>, int3 location);
>+native ushort2 Load(Texture1D<ushort2>, int location);
>+native ushort2 Load(Texture1DArray<ushort2>, int2 location);
>+native ushort2 Load(Texture2D<ushort2>, int2 location);
>+native ushort2 Load(Texture2DArray<ushort2>, int3 location);
>+native ushort2 Load(Texture3D<ushort2>, int3 location);
>+native ushort3 Load(Texture1D<ushort3>, int location);
>+native ushort3 Load(Texture1DArray<ushort3>, int2 location);
>+native ushort3 Load(Texture2D<ushort3>, int2 location);
>+native ushort3 Load(Texture2DArray<ushort3>, int3 location);
>+native ushort3 Load(Texture3D<ushort3>, int3 location);
>+native ushort4 Load(Texture1D<ushort4>, int location);
>+native ushort4 Load(Texture1DArray<ushort4>, int2 location);
>+native ushort4 Load(Texture2D<ushort4>, int2 location);
>+native ushort4 Load(Texture2DArray<ushort4>, int3 location);
>+native ushort4 Load(Texture3D<ushort4>, int3 location);
>+native uint Load(Texture1D<uint>, int location);
>+native uint Load(Texture1DArray<uint>, int2 location);
>+native uint Load(Texture2D<uint>, int2 location);
>+native uint Load(Texture2DArray<uint>, int3 location);
>+native uint Load(Texture3D<uint>, int3 location);
>+native uint2 Load(Texture1D<uint2>, int location);
>+native uint2 Load(Texture1DArray<uint2>, int2 location);
>+native uint2 Load(Texture2D<uint2>, int2 location);
>+native uint2 Load(Texture2DArray<uint2>, int3 location);
>+native uint2 Load(Texture3D<uint2>, int3 location);
>+native uint3 Load(Texture1D<uint3>, int location);
>+native uint3 Load(Texture1DArray<uint3>, int2 location);
>+native uint3 Load(Texture2D<uint3>, int2 location);
>+native uint3 Load(Texture2DArray<uint3>, int3 location);
>+native uint3 Load(Texture3D<uint3>, int3 location);
>+native uint4 Load(Texture1D<uint4>, int location);
>+native uint4 Load(Texture1DArray<uint4>, int2 location);
>+native uint4 Load(Texture2D<uint4>, int2 location);
>+native uint4 Load(Texture2DArray<uint4>, int3 location);
>+native uint4 Load(Texture3D<uint4>, int3 location);
>+native short Load(Texture1D<short>, int location);
>+native short Load(Texture1DArray<short>, int2 location);
>+native short Load(Texture2D<short>, int2 location);
>+native short Load(Texture2DArray<short>, int3 location);
>+native short Load(Texture3D<short>, int3 location);
>+native short2 Load(Texture1D<short2>, int location);
>+native short2 Load(Texture1DArray<short2>, int2 location);
>+native short2 Load(Texture2D<short2>, int2 location);
>+native short2 Load(Texture2DArray<short2>, int3 location);
>+native short2 Load(Texture3D<short2>, int3 location);
>+native short3 Load(Texture1D<short3>, int location);
>+native short3 Load(Texture1DArray<short3>, int2 location);
>+native short3 Load(Texture2D<short3>, int2 location);
>+native short3 Load(Texture2DArray<short3>, int3 location);
>+native short3 Load(Texture3D<short3>, int3 location);
>+native short4 Load(Texture1D<short4>, int location);
>+native short4 Load(Texture1DArray<short4>, int2 location);
>+native short4 Load(Texture2D<short4>, int2 location);
>+native short4 Load(Texture2DArray<short4>, int3 location);
>+native short4 Load(Texture3D<short4>, int3 location);
>+native int Load(Texture1D<int>, int location);
>+native int Load(Texture1DArray<int>, int2 location);
>+native int Load(Texture2D<int>, int2 location);
>+native int Load(Texture2DArray<int>, int3 location);
>+native int Load(Texture3D<int>, int3 location);
>+native int2 Load(Texture1D<int2>, int location);
>+native int2 Load(Texture1DArray<int2>, int2 location);
>+native int2 Load(Texture2D<int2>, int2 location);
>+native int2 Load(Texture2DArray<int2>, int3 location);
>+native int2 Load(Texture3D<int2>, int3 location);
>+native int3 Load(Texture1D<int3>, int location);
>+native int3 Load(Texture1DArray<int3>, int2 location);
>+native int3 Load(Texture2D<int3>, int2 location);
>+native int3 Load(Texture2DArray<int3>, int3 location);
>+native int3 Load(Texture3D<int3>, int3 location);
>+native int4 Load(Texture1D<int4>, int location);
>+native int4 Load(Texture1DArray<int4>, int2 location);
>+native int4 Load(Texture2D<int4>, int2 location);
>+native int4 Load(Texture2DArray<int4>, int3 location);
>+native int4 Load(Texture3D<int4>, int3 location);
>+native half Load(Texture1D<half>, int location);
>+native half Load(Texture1DArray<half>, int2 location);
>+native half Load(Texture2D<half>, int2 location);
>+native half Load(Texture2DArray<half>, int3 location);
>+native half Load(Texture3D<half>, int3 location);
>+native half2 Load(Texture1D<half2>, int location);
>+native half2 Load(Texture1DArray<half2>, int2 location);
>+native half2 Load(Texture2D<half2>, int2 location);
>+native half2 Load(Texture2DArray<half2>, int3 location);
>+native half2 Load(Texture3D<half2>, int3 location);
>+native half3 Load(Texture1D<half3>, int location);
>+native half3 Load(Texture1DArray<half3>, int2 location);
>+native half3 Load(Texture2D<half3>, int2 location);
>+native half3 Load(Texture2DArray<half3>, int3 location);
>+native half3 Load(Texture3D<half3>, int3 location);
>+native half4 Load(Texture1D<half4>, int location);
>+native half4 Load(Texture1DArray<half4>, int2 location);
>+native half4 Load(Texture2D<half4>, int2 location);
>+native half4 Load(Texture2DArray<half4>, int3 location);
>+native half4 Load(Texture3D<half4>, int3 location);
>+native float Load(Texture1D<float>, int location);
>+native float Load(Texture1DArray<float>, int2 location);
>+native float Load(Texture2D<float>, int2 location);
>+native float Load(Texture2DArray<float>, int3 location);
>+native float Load(Texture3D<float>, int3 location);
>+native float2 Load(Texture1D<float2>, int location);
>+native float2 Load(Texture1DArray<float2>, int2 location);
>+native float2 Load(Texture2D<float2>, int2 location);
>+native float2 Load(Texture2DArray<float2>, int3 location);
>+native float2 Load(Texture3D<float2>, int3 location);
>+native float3 Load(Texture1D<float3>, int location);
>+native float3 Load(Texture1DArray<float3>, int2 location);
>+native float3 Load(Texture2D<float3>, int2 location);
>+native float3 Load(Texture2DArray<float3>, int3 location);
>+native float3 Load(Texture3D<float3>, int3 location);
>+native float4 Load(Texture1D<float4>, int location);
>+native float4 Load(Texture1DArray<float4>, int2 location);
>+native float4 Load(Texture2D<float4>, int2 location);
>+native float4 Load(Texture2DArray<float4>, int3 location);
>+native float4 Load(Texture3D<float4>, int3 location);
>+native float Load(TextureDepth2D<float>, int2 location);
>+native float Load(TextureDepth2DArray<float>, int3 location);
>+
>+/* Functions named operator.wwyx */
>+bool4 operator.wwyx(bool4 v) {
>+    bool4 result;
>+    result.x = v.w;
>+    result.y = v.w;
>+    result.z = v.y;
>+    result.w = v.x;
>+    return result;
>+}
>+uchar4 operator.wwyx(uchar4 v) {
>+    uchar4 result;
>+    result.x = v.w;
>+    result.y = v.w;
>+    result.z = v.y;
>+    result.w = v.x;
>+    return result;
>+}
>+ushort4 operator.wwyx(ushort4 v) {
>+    ushort4 result;
>+    result.x = v.w;
>+    result.y = v.w;
>+    result.z = v.y;
>+    result.w = v.x;
>+    return result;
>+}
>+uint4 operator.wwyx(uint4 v) {
>+    uint4 result;
>+    result.x = v.w;
>+    result.y = v.w;
>+    result.z = v.y;
>+    result.w = v.x;
>+    return result;
>+}
>+char4 operator.wwyx(char4 v) {
>+    char4 result;
>+    result.x = v.w;
>+    result.y = v.w;
>+    result.z = v.y;
>+    result.w = v.x;
>+    return result;
>+}
>+short4 operator.wwyx(short4 v) {
>+    short4 result;
>+    result.x = v.w;
>+    result.y = v.w;
>+    result.z = v.y;
>+    result.w = v.x;
>+    return result;
>+}
>+int4 operator.wwyx(int4 v) {
>+    int4 result;
>+    result.x = v.w;
>+    result.y = v.w;
>+    result.z = v.y;
>+    result.w = v.x;
>+    return result;
>+}
>+half4 operator.wwyx(half4 v) {
>+    half4 result;
>+    result.x = v.w;
>+    result.y = v.w;
>+    result.z = v.y;
>+    result.w = v.x;
>+    return result;
>+}
>+float4 operator.wwyx(float4 v) {
>+    float4 result;
>+    result.x = v.w;
>+    result.y = v.w;
>+    result.z = v.y;
>+    result.w = v.x;
>+    return result;
>+}
>+
>+/* Functions named operator.yzw= */
>+bool4 operator.yzw=(bool4 v, bool3 c) {
>+    bool4 result = v;
>+    result.y = c.x;
>+    result.z = c.y;
>+    result.w = c.z;
>+    return result;
>+}
>+uchar4 operator.yzw=(uchar4 v, uchar3 c) {
>+    uchar4 result = v;
>+    result.y = c.x;
>+    result.z = c.y;
>+    result.w = c.z;
>+    return result;
>+}
>+ushort4 operator.yzw=(ushort4 v, ushort3 c) {
>+    ushort4 result = v;
>+    result.y = c.x;
>+    result.z = c.y;
>+    result.w = c.z;
>+    return result;
>+}
>+uint4 operator.yzw=(uint4 v, uint3 c) {
>+    uint4 result = v;
>+    result.y = c.x;
>+    result.z = c.y;
>+    result.w = c.z;
>+    return result;
>+}
>+char4 operator.yzw=(char4 v, char3 c) {
>+    char4 result = v;
>+    result.y = c.x;
>+    result.z = c.y;
>+    result.w = c.z;
>+    return result;
>+}
>+short4 operator.yzw=(short4 v, short3 c) {
>+    short4 result = v;
>+    result.y = c.x;
>+    result.z = c.y;
>+    result.w = c.z;
>+    return result;
>+}
>+int4 operator.yzw=(int4 v, int3 c) {
>+    int4 result = v;
>+    result.y = c.x;
>+    result.z = c.y;
>+    result.w = c.z;
>+    return result;
>+}
>+half4 operator.yzw=(half4 v, half3 c) {
>+    half4 result = v;
>+    result.y = c.x;
>+    result.z = c.y;
>+    result.w = c.z;
>+    return result;
>+}
>+float4 operator.yzw=(float4 v, float3 c) {
>+    float4 result = v;
>+    result.y = c.x;
>+    result.z = c.y;
>+    result.w = c.z;
>+    return result;
>+}
>+
>+/* Functions named operator.yzw */
>+bool3 operator.yzw(bool4 v) {
>+    bool3 result;
>+    result.x = v.y;
>+    result.y = v.z;
>+    result.z = v.w;
>+    return result;
>+}
>+uchar3 operator.yzw(uchar4 v) {
>+    uchar3 result;
>+    result.x = v.y;
>+    result.y = v.z;
>+    result.z = v.w;
>+    return result;
>+}
>+ushort3 operator.yzw(ushort4 v) {
>+    ushort3 result;
>+    result.x = v.y;
>+    result.y = v.z;
>+    result.z = v.w;
>+    return result;
>+}
>+uint3 operator.yzw(uint4 v) {
>+    uint3 result;
>+    result.x = v.y;
>+    result.y = v.z;
>+    result.z = v.w;
>+    return result;
>+}
>+char3 operator.yzw(char4 v) {
>+    char3 result;
>+    result.x = v.y;
>+    result.y = v.z;
>+    result.z = v.w;
>+    return result;
>+}
>+short3 operator.yzw(short4 v) {
>+    short3 result;
>+    result.x = v.y;
>+    result.y = v.z;
>+    result.z = v.w;
>+    return result;
>+}
>+int3 operator.yzw(int4 v) {
>+    int3 result;
>+    result.x = v.y;
>+    result.y = v.z;
>+    result.z = v.w;
>+    return result;
>+}
>+half3 operator.yzw(half4 v) {
>+    half3 result;
>+    result.x = v.y;
>+    result.y = v.z;
>+    result.z = v.w;
>+    return result;
>+}
>+float3 operator.yzw(float4 v) {
>+    float3 result;
>+    result.x = v.y;
>+    result.y = v.z;
>+    result.z = v.w;
>+    return result;
>+}
>+
>+/* Functions named operator.yzx= */
>+bool3 operator.yzx=(bool3 v, bool3 c) {
>+    bool3 result = v;
>+    result.y = c.x;
>+    result.z = c.y;
>+    result.x = c.z;
>+    return result;
>+}
>+bool4 operator.yzx=(bool4 v, bool3 c) {
>+    bool4 result = v;
>+    result.y = c.x;
>+    result.z = c.y;
>+    result.x = c.z;
>+    return result;
>+}
>+uchar3 operator.yzx=(uchar3 v, uchar3 c) {
>+    uchar3 result = v;
>+    result.y = c.x;
>+    result.z = c.y;
>+    result.x = c.z;
>+    return result;
>+}
>+uchar4 operator.yzx=(uchar4 v, uchar3 c) {
>+    uchar4 result = v;
>+    result.y = c.x;
>+    result.z = c.y;
>+    result.x = c.z;
>+    return result;
>+}
>+ushort3 operator.yzx=(ushort3 v, ushort3 c) {
>+    ushort3 result = v;
>+    result.y = c.x;
>+    result.z = c.y;
>+    result.x = c.z;
>+    return result;
>+}
>+ushort4 operator.yzx=(ushort4 v, ushort3 c) {
>+    ushort4 result = v;
>+    result.y = c.x;
>+    result.z = c.y;
>+    result.x = c.z;
>+    return result;
>+}
>+uint3 operator.yzx=(uint3 v, uint3 c) {
>+    uint3 result = v;
>+    result.y = c.x;
>+    result.z = c.y;
>+    result.x = c.z;
>+    return result;
>+}
>+uint4 operator.yzx=(uint4 v, uint3 c) {
>+    uint4 result = v;
>+    result.y = c.x;
>+    result.z = c.y;
>+    result.x = c.z;
>+    return result;
>+}
>+char3 operator.yzx=(char3 v, char3 c) {
>+    char3 result = v;
>+    result.y = c.x;
>+    result.z = c.y;
>+    result.x = c.z;
>+    return result;
>+}
>+char4 operator.yzx=(char4 v, char3 c) {
>+    char4 result = v;
>+    result.y = c.x;
>+    result.z = c.y;
>+    result.x = c.z;
>+    return result;
>+}
>+short3 operator.yzx=(short3 v, short3 c) {
>+    short3 result = v;
>+    result.y = c.x;
>+    result.z = c.y;
>+    result.x = c.z;
>+    return result;
>+}
>+short4 operator.yzx=(short4 v, short3 c) {
>+    short4 result = v;
>+    result.y = c.x;
>+    result.z = c.y;
>+    result.x = c.z;
>+    return result;
>+}
>+int3 operator.yzx=(int3 v, int3 c) {
>+    int3 result = v;
>+    result.y = c.x;
>+    result.z = c.y;
>+    result.x = c.z;
>+    return result;
>+}
>+int4 operator.yzx=(int4 v, int3 c) {
>+    int4 result = v;
>+    result.y = c.x;
>+    result.z = c.y;
>+    result.x = c.z;
>+    return result;
>+}
>+half3 operator.yzx=(half3 v, half3 c) {
>+    half3 result = v;
>+    result.y = c.x;
>+    result.z = c.y;
>+    result.x = c.z;
>+    return result;
>+}
>+half4 operator.yzx=(half4 v, half3 c) {
>+    half4 result = v;
>+    result.y = c.x;
>+    result.z = c.y;
>+    result.x = c.z;
>+    return result;
>+}
>+float3 operator.yzx=(float3 v, float3 c) {
>+    float3 result = v;
>+    result.y = c.x;
>+    result.z = c.y;
>+    result.x = c.z;
>+    return result;
>+}
>+float4 operator.yzx=(float4 v, float3 c) {
>+    float4 result = v;
>+    result.y = c.x;
>+    result.z = c.y;
>+    result.x = c.z;
>+    return result;
>+}
>+
>+/* Functions named operator.xxwz */
>+bool4 operator.xxwz(bool4 v) {
>+    bool4 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.w;
>+    result.w = v.z;
>+    return result;
>+}
>+uchar4 operator.xxwz(uchar4 v) {
>+    uchar4 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.w;
>+    result.w = v.z;
>+    return result;
>+}
>+ushort4 operator.xxwz(ushort4 v) {
>+    ushort4 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.w;
>+    result.w = v.z;
>+    return result;
>+}
>+uint4 operator.xxwz(uint4 v) {
>+    uint4 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.w;
>+    result.w = v.z;
>+    return result;
>+}
>+char4 operator.xxwz(char4 v) {
>+    char4 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.w;
>+    result.w = v.z;
>+    return result;
>+}
>+short4 operator.xxwz(short4 v) {
>+    short4 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.w;
>+    result.w = v.z;
>+    return result;
>+}
>+int4 operator.xxwz(int4 v) {
>+    int4 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.w;
>+    result.w = v.z;
>+    return result;
>+}
>+half4 operator.xxwz(half4 v) {
>+    half4 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.w;
>+    result.w = v.z;
>+    return result;
>+}
>+float4 operator.xxwz(float4 v) {
>+    float4 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.w;
>+    result.w = v.z;
>+    return result;
>+}
>+
>+/* Functions named operator.yzyz */
>+bool4 operator.yzyz(bool3 v) {
>+    bool4 result;
>+    result.x = v.y;
>+    result.y = v.z;
>+    result.z = v.y;
>+    result.w = v.z;
>+    return result;
>+}
>+bool4 operator.yzyz(bool4 v) {
>+    bool4 result;
>+    result.x = v.y;
>+    result.y = v.z;
>+    result.z = v.y;
>+    result.w = v.z;
>+    return result;
>+}
>+uchar4 operator.yzyz(uchar3 v) {
>+    uchar4 result;
>+    result.x = v.y;
>+    result.y = v.z;
>+    result.z = v.y;
>+    result.w = v.z;
>+    return result;
>+}
>+uchar4 operator.yzyz(uchar4 v) {
>+    uchar4 result;
>+    result.x = v.y;
>+    result.y = v.z;
>+    result.z = v.y;
>+    result.w = v.z;
>+    return result;
>+}
>+ushort4 operator.yzyz(ushort3 v) {
>+    ushort4 result;
>+    result.x = v.y;
>+    result.y = v.z;
>+    result.z = v.y;
>+    result.w = v.z;
>+    return result;
>+}
>+ushort4 operator.yzyz(ushort4 v) {
>+    ushort4 result;
>+    result.x = v.y;
>+    result.y = v.z;
>+    result.z = v.y;
>+    result.w = v.z;
>+    return result;
>+}
>+uint4 operator.yzyz(uint3 v) {
>+    uint4 result;
>+    result.x = v.y;
>+    result.y = v.z;
>+    result.z = v.y;
>+    result.w = v.z;
>+    return result;
>+}
>+uint4 operator.yzyz(uint4 v) {
>+    uint4 result;
>+    result.x = v.y;
>+    result.y = v.z;
>+    result.z = v.y;
>+    result.w = v.z;
>+    return result;
>+}
>+char4 operator.yzyz(char3 v) {
>+    char4 result;
>+    result.x = v.y;
>+    result.y = v.z;
>+    result.z = v.y;
>+    result.w = v.z;
>+    return result;
>+}
>+char4 operator.yzyz(char4 v) {
>+    char4 result;
>+    result.x = v.y;
>+    result.y = v.z;
>+    result.z = v.y;
>+    result.w = v.z;
>+    return result;
>+}
>+short4 operator.yzyz(short3 v) {
>+    short4 result;
>+    result.x = v.y;
>+    result.y = v.z;
>+    result.z = v.y;
>+    result.w = v.z;
>+    return result;
>+}
>+short4 operator.yzyz(short4 v) {
>+    short4 result;
>+    result.x = v.y;
>+    result.y = v.z;
>+    result.z = v.y;
>+    result.w = v.z;
>+    return result;
>+}
>+int4 operator.yzyz(int3 v) {
>+    int4 result;
>+    result.x = v.y;
>+    result.y = v.z;
>+    result.z = v.y;
>+    result.w = v.z;
>+    return result;
>+}
>+int4 operator.yzyz(int4 v) {
>+    int4 result;
>+    result.x = v.y;
>+    result.y = v.z;
>+    result.z = v.y;
>+    result.w = v.z;
>+    return result;
>+}
>+half4 operator.yzyz(half3 v) {
>+    half4 result;
>+    result.x = v.y;
>+    result.y = v.z;
>+    result.z = v.y;
>+    result.w = v.z;
>+    return result;
>+}
>+half4 operator.yzyz(half4 v) {
>+    half4 result;
>+    result.x = v.y;
>+    result.y = v.z;
>+    result.z = v.y;
>+    result.w = v.z;
>+    return result;
>+}
>+float4 operator.yzyz(float3 v) {
>+    float4 result;
>+    result.x = v.y;
>+    result.y = v.z;
>+    result.z = v.y;
>+    result.w = v.z;
>+    return result;
>+}
>+float4 operator.yzyz(float4 v) {
>+    float4 result;
>+    result.x = v.y;
>+    result.y = v.z;
>+    result.z = v.y;
>+    result.w = v.z;
>+    return result;
>+}
>+
>+/* Functions named operator.yzxw */
>+bool4 operator.yzxw(bool4 v) {
>+    bool4 result;
>+    result.x = v.y;
>+    result.y = v.z;
>+    result.z = v.x;
>+    result.w = v.w;
>+    return result;
>+}
>+uchar4 operator.yzxw(uchar4 v) {
>+    uchar4 result;
>+    result.x = v.y;
>+    result.y = v.z;
>+    result.z = v.x;
>+    result.w = v.w;
>+    return result;
>+}
>+ushort4 operator.yzxw(ushort4 v) {
>+    ushort4 result;
>+    result.x = v.y;
>+    result.y = v.z;
>+    result.z = v.x;
>+    result.w = v.w;
>+    return result;
>+}
>+uint4 operator.yzxw(uint4 v) {
>+    uint4 result;
>+    result.x = v.y;
>+    result.y = v.z;
>+    result.z = v.x;
>+    result.w = v.w;
>+    return result;
>+}
>+char4 operator.yzxw(char4 v) {
>+    char4 result;
>+    result.x = v.y;
>+    result.y = v.z;
>+    result.z = v.x;
>+    result.w = v.w;
>+    return result;
>+}
>+short4 operator.yzxw(short4 v) {
>+    short4 result;
>+    result.x = v.y;
>+    result.y = v.z;
>+    result.z = v.x;
>+    result.w = v.w;
>+    return result;
>+}
>+int4 operator.yzxw(int4 v) {
>+    int4 result;
>+    result.x = v.y;
>+    result.y = v.z;
>+    result.z = v.x;
>+    result.w = v.w;
>+    return result;
>+}
>+half4 operator.yzxw(half4 v) {
>+    half4 result;
>+    result.x = v.y;
>+    result.y = v.z;
>+    result.z = v.x;
>+    result.w = v.w;
>+    return result;
>+}
>+float4 operator.yzxw(float4 v) {
>+    float4 result;
>+    result.x = v.y;
>+    result.y = v.z;
>+    result.z = v.x;
>+    result.w = v.w;
>+    return result;
>+}
>+
>+/* Functions named operator.zywx */
>+bool4 operator.zywx(bool4 v) {
>+    bool4 result;
>+    result.x = v.z;
>+    result.y = v.y;
>+    result.z = v.w;
>+    result.w = v.x;
>+    return result;
>+}
>+uchar4 operator.zywx(uchar4 v) {
>+    uchar4 result;
>+    result.x = v.z;
>+    result.y = v.y;
>+    result.z = v.w;
>+    result.w = v.x;
>+    return result;
>+}
>+ushort4 operator.zywx(ushort4 v) {
>+    ushort4 result;
>+    result.x = v.z;
>+    result.y = v.y;
>+    result.z = v.w;
>+    result.w = v.x;
>+    return result;
>+}
>+uint4 operator.zywx(uint4 v) {
>+    uint4 result;
>+    result.x = v.z;
>+    result.y = v.y;
>+    result.z = v.w;
>+    result.w = v.x;
>+    return result;
>+}
>+char4 operator.zywx(char4 v) {
>+    char4 result;
>+    result.x = v.z;
>+    result.y = v.y;
>+    result.z = v.w;
>+    result.w = v.x;
>+    return result;
>+}
>+short4 operator.zywx(short4 v) {
>+    short4 result;
>+    result.x = v.z;
>+    result.y = v.y;
>+    result.z = v.w;
>+    result.w = v.x;
>+    return result;
>+}
>+int4 operator.zywx(int4 v) {
>+    int4 result;
>+    result.x = v.z;
>+    result.y = v.y;
>+    result.z = v.w;
>+    result.w = v.x;
>+    return result;
>+}
>+half4 operator.zywx(half4 v) {
>+    half4 result;
>+    result.x = v.z;
>+    result.y = v.y;
>+    result.z = v.w;
>+    result.w = v.x;
>+    return result;
>+}
>+float4 operator.zywx(float4 v) {
>+    float4 result;
>+    result.x = v.z;
>+    result.y = v.y;
>+    result.z = v.w;
>+    result.w = v.x;
>+    return result;
>+}
>+
>+/* Functions named sin */
>+native float sin(float);
>+half sin(half x) {
>+    return half(sin(float(x)));
>+}
>+half2 sin(half2 x) {
>+    half2 result;
>+    result[0] = sin(x[0]);
>+    result[1] = sin(x[1]);
>+    return result;
>+}
>+half3 sin(half3 x) {
>+    half3 result;
>+    result[0] = sin(x[0]);
>+    result[1] = sin(x[1]);
>+    result[2] = sin(x[2]);
>+    return result;
>+}
>+half4 sin(half4 x) {
>+    half4 result;
>+    result[0] = sin(x[0]);
>+    result[1] = sin(x[1]);
>+    result[2] = sin(x[2]);
>+    result[3] = sin(x[3]);
>+    return result;
>+}
>+half2x2 sin(half2x2 x) {
>+    half2x2 result;
>+    result[0][0] = sin(x[0][0]);
>+    result[0][1] = sin(x[0][1]);
>+    result[1][0] = sin(x[1][0]);
>+    result[1][1] = sin(x[1][1]);
>+    return result;
>+}
>+half2x3 sin(half2x3 x) {
>+    half2x3 result;
>+    result[0][0] = sin(x[0][0]);
>+    result[0][1] = sin(x[0][1]);
>+    result[0][2] = sin(x[0][2]);
>+    result[1][0] = sin(x[1][0]);
>+    result[1][1] = sin(x[1][1]);
>+    result[1][2] = sin(x[1][2]);
>+    return result;
>+}
>+half2x4 sin(half2x4 x) {
>+    half2x4 result;
>+    result[0][0] = sin(x[0][0]);
>+    result[0][1] = sin(x[0][1]);
>+    result[0][2] = sin(x[0][2]);
>+    result[0][3] = sin(x[0][3]);
>+    result[1][0] = sin(x[1][0]);
>+    result[1][1] = sin(x[1][1]);
>+    result[1][2] = sin(x[1][2]);
>+    result[1][3] = sin(x[1][3]);
>+    return result;
>+}
>+half3x2 sin(half3x2 x) {
>+    half3x2 result;
>+    result[0][0] = sin(x[0][0]);
>+    result[0][1] = sin(x[0][1]);
>+    result[1][0] = sin(x[1][0]);
>+    result[1][1] = sin(x[1][1]);
>+    result[2][0] = sin(x[2][0]);
>+    result[2][1] = sin(x[2][1]);
>+    return result;
>+}
>+half3x3 sin(half3x3 x) {
>+    half3x3 result;
>+    result[0][0] = sin(x[0][0]);
>+    result[0][1] = sin(x[0][1]);
>+    result[0][2] = sin(x[0][2]);
>+    result[1][0] = sin(x[1][0]);
>+    result[1][1] = sin(x[1][1]);
>+    result[1][2] = sin(x[1][2]);
>+    result[2][0] = sin(x[2][0]);
>+    result[2][1] = sin(x[2][1]);
>+    result[2][2] = sin(x[2][2]);
>+    return result;
>+}
>+half3x4 sin(half3x4 x) {
>+    half3x4 result;
>+    result[0][0] = sin(x[0][0]);
>+    result[0][1] = sin(x[0][1]);
>+    result[0][2] = sin(x[0][2]);
>+    result[0][3] = sin(x[0][3]);
>+    result[1][0] = sin(x[1][0]);
>+    result[1][1] = sin(x[1][1]);
>+    result[1][2] = sin(x[1][2]);
>+    result[1][3] = sin(x[1][3]);
>+    result[2][0] = sin(x[2][0]);
>+    result[2][1] = sin(x[2][1]);
>+    result[2][2] = sin(x[2][2]);
>+    result[2][3] = sin(x[2][3]);
>+    return result;
>+}
>+half4x2 sin(half4x2 x) {
>+    half4x2 result;
>+    result[0][0] = sin(x[0][0]);
>+    result[0][1] = sin(x[0][1]);
>+    result[1][0] = sin(x[1][0]);
>+    result[1][1] = sin(x[1][1]);
>+    result[2][0] = sin(x[2][0]);
>+    result[2][1] = sin(x[2][1]);
>+    result[3][0] = sin(x[3][0]);
>+    result[3][1] = sin(x[3][1]);
>+    return result;
>+}
>+half4x3 sin(half4x3 x) {
>+    half4x3 result;
>+    result[0][0] = sin(x[0][0]);
>+    result[0][1] = sin(x[0][1]);
>+    result[0][2] = sin(x[0][2]);
>+    result[1][0] = sin(x[1][0]);
>+    result[1][1] = sin(x[1][1]);
>+    result[1][2] = sin(x[1][2]);
>+    result[2][0] = sin(x[2][0]);
>+    result[2][1] = sin(x[2][1]);
>+    result[2][2] = sin(x[2][2]);
>+    result[3][0] = sin(x[3][0]);
>+    result[3][1] = sin(x[3][1]);
>+    result[3][2] = sin(x[3][2]);
>+    return result;
>+}
>+half4x4 sin(half4x4 x) {
>+    half4x4 result;
>+    result[0][0] = sin(x[0][0]);
>+    result[0][1] = sin(x[0][1]);
>+    result[0][2] = sin(x[0][2]);
>+    result[0][3] = sin(x[0][3]);
>+    result[1][0] = sin(x[1][0]);
>+    result[1][1] = sin(x[1][1]);
>+    result[1][2] = sin(x[1][2]);
>+    result[1][3] = sin(x[1][3]);
>+    result[2][0] = sin(x[2][0]);
>+    result[2][1] = sin(x[2][1]);
>+    result[2][2] = sin(x[2][2]);
>+    result[2][3] = sin(x[2][3]);
>+    result[3][0] = sin(x[3][0]);
>+    result[3][1] = sin(x[3][1]);
>+    result[3][2] = sin(x[3][2]);
>+    result[3][3] = sin(x[3][3]);
>+    return result;
>+}
>+float2 sin(float2 x) {
>+    float2 result;
>+    result[0] = sin(x[0]);
>+    result[1] = sin(x[1]);
>+    return result;
>+}
>+float3 sin(float3 x) {
>+    float3 result;
>+    result[0] = sin(x[0]);
>+    result[1] = sin(x[1]);
>+    result[2] = sin(x[2]);
>+    return result;
>+}
>+float4 sin(float4 x) {
>+    float4 result;
>+    result[0] = sin(x[0]);
>+    result[1] = sin(x[1]);
>+    result[2] = sin(x[2]);
>+    result[3] = sin(x[3]);
>+    return result;
>+}
>+float2x2 sin(float2x2 x) {
>+    float2x2 result;
>+    result[0][0] = sin(x[0][0]);
>+    result[0][1] = sin(x[0][1]);
>+    result[1][0] = sin(x[1][0]);
>+    result[1][1] = sin(x[1][1]);
>+    return result;
>+}
>+float2x3 sin(float2x3 x) {
>+    float2x3 result;
>+    result[0][0] = sin(x[0][0]);
>+    result[0][1] = sin(x[0][1]);
>+    result[0][2] = sin(x[0][2]);
>+    result[1][0] = sin(x[1][0]);
>+    result[1][1] = sin(x[1][1]);
>+    result[1][2] = sin(x[1][2]);
>+    return result;
>+}
>+float2x4 sin(float2x4 x) {
>+    float2x4 result;
>+    result[0][0] = sin(x[0][0]);
>+    result[0][1] = sin(x[0][1]);
>+    result[0][2] = sin(x[0][2]);
>+    result[0][3] = sin(x[0][3]);
>+    result[1][0] = sin(x[1][0]);
>+    result[1][1] = sin(x[1][1]);
>+    result[1][2] = sin(x[1][2]);
>+    result[1][3] = sin(x[1][3]);
>+    return result;
>+}
>+float3x2 sin(float3x2 x) {
>+    float3x2 result;
>+    result[0][0] = sin(x[0][0]);
>+    result[0][1] = sin(x[0][1]);
>+    result[1][0] = sin(x[1][0]);
>+    result[1][1] = sin(x[1][1]);
>+    result[2][0] = sin(x[2][0]);
>+    result[2][1] = sin(x[2][1]);
>+    return result;
>+}
>+float3x3 sin(float3x3 x) {
>+    float3x3 result;
>+    result[0][0] = sin(x[0][0]);
>+    result[0][1] = sin(x[0][1]);
>+    result[0][2] = sin(x[0][2]);
>+    result[1][0] = sin(x[1][0]);
>+    result[1][1] = sin(x[1][1]);
>+    result[1][2] = sin(x[1][2]);
>+    result[2][0] = sin(x[2][0]);
>+    result[2][1] = sin(x[2][1]);
>+    result[2][2] = sin(x[2][2]);
>+    return result;
>+}
>+float3x4 sin(float3x4 x) {
>+    float3x4 result;
>+    result[0][0] = sin(x[0][0]);
>+    result[0][1] = sin(x[0][1]);
>+    result[0][2] = sin(x[0][2]);
>+    result[0][3] = sin(x[0][3]);
>+    result[1][0] = sin(x[1][0]);
>+    result[1][1] = sin(x[1][1]);
>+    result[1][2] = sin(x[1][2]);
>+    result[1][3] = sin(x[1][3]);
>+    result[2][0] = sin(x[2][0]);
>+    result[2][1] = sin(x[2][1]);
>+    result[2][2] = sin(x[2][2]);
>+    result[2][3] = sin(x[2][3]);
>+    return result;
>+}
>+float4x2 sin(float4x2 x) {
>+    float4x2 result;
>+    result[0][0] = sin(x[0][0]);
>+    result[0][1] = sin(x[0][1]);
>+    result[1][0] = sin(x[1][0]);
>+    result[1][1] = sin(x[1][1]);
>+    result[2][0] = sin(x[2][0]);
>+    result[2][1] = sin(x[2][1]);
>+    result[3][0] = sin(x[3][0]);
>+    result[3][1] = sin(x[3][1]);
>+    return result;
>+}
>+float4x3 sin(float4x3 x) {
>+    float4x3 result;
>+    result[0][0] = sin(x[0][0]);
>+    result[0][1] = sin(x[0][1]);
>+    result[0][2] = sin(x[0][2]);
>+    result[1][0] = sin(x[1][0]);
>+    result[1][1] = sin(x[1][1]);
>+    result[1][2] = sin(x[1][2]);
>+    result[2][0] = sin(x[2][0]);
>+    result[2][1] = sin(x[2][1]);
>+    result[2][2] = sin(x[2][2]);
>+    result[3][0] = sin(x[3][0]);
>+    result[3][1] = sin(x[3][1]);
>+    result[3][2] = sin(x[3][2]);
>+    return result;
>+}
>+float4x4 sin(float4x4 x) {
>+    float4x4 result;
>+    result[0][0] = sin(x[0][0]);
>+    result[0][1] = sin(x[0][1]);
>+    result[0][2] = sin(x[0][2]);
>+    result[0][3] = sin(x[0][3]);
>+    result[1][0] = sin(x[1][0]);
>+    result[1][1] = sin(x[1][1]);
>+    result[1][2] = sin(x[1][2]);
>+    result[1][3] = sin(x[1][3]);
>+    result[2][0] = sin(x[2][0]);
>+    result[2][1] = sin(x[2][1]);
>+    result[2][2] = sin(x[2][2]);
>+    result[2][3] = sin(x[2][3]);
>+    result[3][0] = sin(x[3][0]);
>+    result[3][1] = sin(x[3][1]);
>+    result[3][2] = sin(x[3][2]);
>+    result[3][3] = sin(x[3][3]);
>+    return result;
>+}
>+
>+/* Functions named operator.ywzy */
>+bool4 operator.ywzy(bool4 v) {
>+    bool4 result;
>+    result.x = v.y;
>+    result.y = v.w;
>+    result.z = v.z;
>+    result.w = v.y;
>+    return result;
>+}
>+uchar4 operator.ywzy(uchar4 v) {
>+    uchar4 result;
>+    result.x = v.y;
>+    result.y = v.w;
>+    result.z = v.z;
>+    result.w = v.y;
>+    return result;
>+}
>+ushort4 operator.ywzy(ushort4 v) {
>+    ushort4 result;
>+    result.x = v.y;
>+    result.y = v.w;
>+    result.z = v.z;
>+    result.w = v.y;
>+    return result;
>+}
>+uint4 operator.ywzy(uint4 v) {
>+    uint4 result;
>+    result.x = v.y;
>+    result.y = v.w;
>+    result.z = v.z;
>+    result.w = v.y;
>+    return result;
>+}
>+char4 operator.ywzy(char4 v) {
>+    char4 result;
>+    result.x = v.y;
>+    result.y = v.w;
>+    result.z = v.z;
>+    result.w = v.y;
>+    return result;
>+}
>+short4 operator.ywzy(short4 v) {
>+    short4 result;
>+    result.x = v.y;
>+    result.y = v.w;
>+    result.z = v.z;
>+    result.w = v.y;
>+    return result;
>+}
>+int4 operator.ywzy(int4 v) {
>+    int4 result;
>+    result.x = v.y;
>+    result.y = v.w;
>+    result.z = v.z;
>+    result.w = v.y;
>+    return result;
>+}
>+half4 operator.ywzy(half4 v) {
>+    half4 result;
>+    result.x = v.y;
>+    result.y = v.w;
>+    result.z = v.z;
>+    result.w = v.y;
>+    return result;
>+}
>+float4 operator.ywzy(float4 v) {
>+    float4 result;
>+    result.x = v.y;
>+    result.y = v.w;
>+    result.z = v.z;
>+    result.w = v.y;
>+    return result;
>+}
>+
>+/* Functions named operator.zyy */
>+bool3 operator.zyy(bool3 v) {
>+    bool3 result;
>+    result.x = v.z;
>+    result.y = v.y;
>+    result.z = v.y;
>+    return result;
>+}
>+bool3 operator.zyy(bool4 v) {
>+    bool3 result;
>+    result.x = v.z;
>+    result.y = v.y;
>+    result.z = v.y;
>+    return result;
>+}
>+uchar3 operator.zyy(uchar3 v) {
>+    uchar3 result;
>+    result.x = v.z;
>+    result.y = v.y;
>+    result.z = v.y;
>+    return result;
>+}
>+uchar3 operator.zyy(uchar4 v) {
>+    uchar3 result;
>+    result.x = v.z;
>+    result.y = v.y;
>+    result.z = v.y;
>+    return result;
>+}
>+ushort3 operator.zyy(ushort3 v) {
>+    ushort3 result;
>+    result.x = v.z;
>+    result.y = v.y;
>+    result.z = v.y;
>+    return result;
>+}
>+ushort3 operator.zyy(ushort4 v) {
>+    ushort3 result;
>+    result.x = v.z;
>+    result.y = v.y;
>+    result.z = v.y;
>+    return result;
>+}
>+uint3 operator.zyy(uint3 v) {
>+    uint3 result;
>+    result.x = v.z;
>+    result.y = v.y;
>+    result.z = v.y;
>+    return result;
>+}
>+uint3 operator.zyy(uint4 v) {
>+    uint3 result;
>+    result.x = v.z;
>+    result.y = v.y;
>+    result.z = v.y;
>+    return result;
>+}
>+char3 operator.zyy(char3 v) {
>+    char3 result;
>+    result.x = v.z;
>+    result.y = v.y;
>+    result.z = v.y;
>+    return result;
>+}
>+char3 operator.zyy(char4 v) {
>+    char3 result;
>+    result.x = v.z;
>+    result.y = v.y;
>+    result.z = v.y;
>+    return result;
>+}
>+short3 operator.zyy(short3 v) {
>+    short3 result;
>+    result.x = v.z;
>+    result.y = v.y;
>+    result.z = v.y;
>+    return result;
>+}
>+short3 operator.zyy(short4 v) {
>+    short3 result;
>+    result.x = v.z;
>+    result.y = v.y;
>+    result.z = v.y;
>+    return result;
>+}
>+int3 operator.zyy(int3 v) {
>+    int3 result;
>+    result.x = v.z;
>+    result.y = v.y;
>+    result.z = v.y;
>+    return result;
>+}
>+int3 operator.zyy(int4 v) {
>+    int3 result;
>+    result.x = v.z;
>+    result.y = v.y;
>+    result.z = v.y;
>+    return result;
>+}
>+half3 operator.zyy(half3 v) {
>+    half3 result;
>+    result.x = v.z;
>+    result.y = v.y;
>+    result.z = v.y;
>+    return result;
>+}
>+half3 operator.zyy(half4 v) {
>+    half3 result;
>+    result.x = v.z;
>+    result.y = v.y;
>+    result.z = v.y;
>+    return result;
>+}
>+float3 operator.zyy(float3 v) {
>+    float3 result;
>+    result.x = v.z;
>+    result.y = v.y;
>+    result.z = v.y;
>+    return result;
>+}
>+float3 operator.zyy(float4 v) {
>+    float3 result;
>+    result.x = v.z;
>+    result.y = v.y;
>+    result.z = v.y;
>+    return result;
>+}
>+
>+/* Functions named operator.wxwz */
>+bool4 operator.wxwz(bool4 v) {
>+    bool4 result;
>+    result.x = v.w;
>+    result.y = v.x;
>+    result.z = v.w;
>+    result.w = v.z;
>+    return result;
>+}
>+uchar4 operator.wxwz(uchar4 v) {
>+    uchar4 result;
>+    result.x = v.w;
>+    result.y = v.x;
>+    result.z = v.w;
>+    result.w = v.z;
>+    return result;
>+}
>+ushort4 operator.wxwz(ushort4 v) {
>+    ushort4 result;
>+    result.x = v.w;
>+    result.y = v.x;
>+    result.z = v.w;
>+    result.w = v.z;
>+    return result;
>+}
>+uint4 operator.wxwz(uint4 v) {
>+    uint4 result;
>+    result.x = v.w;
>+    result.y = v.x;
>+    result.z = v.w;
>+    result.w = v.z;
>+    return result;
>+}
>+char4 operator.wxwz(char4 v) {
>+    char4 result;
>+    result.x = v.w;
>+    result.y = v.x;
>+    result.z = v.w;
>+    result.w = v.z;
>+    return result;
>+}
>+short4 operator.wxwz(short4 v) {
>+    short4 result;
>+    result.x = v.w;
>+    result.y = v.x;
>+    result.z = v.w;
>+    result.w = v.z;
>+    return result;
>+}
>+int4 operator.wxwz(int4 v) {
>+    int4 result;
>+    result.x = v.w;
>+    result.y = v.x;
>+    result.z = v.w;
>+    result.w = v.z;
>+    return result;
>+}
>+half4 operator.wxwz(half4 v) {
>+    half4 result;
>+    result.x = v.w;
>+    result.y = v.x;
>+    result.z = v.w;
>+    result.w = v.z;
>+    return result;
>+}
>+float4 operator.wxwz(float4 v) {
>+    float4 result;
>+    result.x = v.w;
>+    result.y = v.x;
>+    result.z = v.w;
>+    result.w = v.z;
>+    return result;
>+}
>+
>+/* Functions named operator.zwxw */
>+bool4 operator.zwxw(bool4 v) {
>+    bool4 result;
>+    result.x = v.z;
>+    result.y = v.w;
>+    result.z = v.x;
>+    result.w = v.w;
>+    return result;
>+}
>+uchar4 operator.zwxw(uchar4 v) {
>+    uchar4 result;
>+    result.x = v.z;
>+    result.y = v.w;
>+    result.z = v.x;
>+    result.w = v.w;
>+    return result;
>+}
>+ushort4 operator.zwxw(ushort4 v) {
>+    ushort4 result;
>+    result.x = v.z;
>+    result.y = v.w;
>+    result.z = v.x;
>+    result.w = v.w;
>+    return result;
>+}
>+uint4 operator.zwxw(uint4 v) {
>+    uint4 result;
>+    result.x = v.z;
>+    result.y = v.w;
>+    result.z = v.x;
>+    result.w = v.w;
>+    return result;
>+}
>+char4 operator.zwxw(char4 v) {
>+    char4 result;
>+    result.x = v.z;
>+    result.y = v.w;
>+    result.z = v.x;
>+    result.w = v.w;
>+    return result;
>+}
>+short4 operator.zwxw(short4 v) {
>+    short4 result;
>+    result.x = v.z;
>+    result.y = v.w;
>+    result.z = v.x;
>+    result.w = v.w;
>+    return result;
>+}
>+int4 operator.zwxw(int4 v) {
>+    int4 result;
>+    result.x = v.z;
>+    result.y = v.w;
>+    result.z = v.x;
>+    result.w = v.w;
>+    return result;
>+}
>+half4 operator.zwxw(half4 v) {
>+    half4 result;
>+    result.x = v.z;
>+    result.y = v.w;
>+    result.z = v.x;
>+    result.w = v.w;
>+    return result;
>+}
>+float4 operator.zwxw(float4 v) {
>+    float4 result;
>+    result.x = v.z;
>+    result.y = v.w;
>+    result.z = v.x;
>+    result.w = v.w;
>+    return result;
>+}
>+
>+/* Functions named operator.zwyy */
>+bool4 operator.zwyy(bool4 v) {
>+    bool4 result;
>+    result.x = v.z;
>+    result.y = v.w;
>+    result.z = v.y;
>+    result.w = v.y;
>+    return result;
>+}
>+uchar4 operator.zwyy(uchar4 v) {
>+    uchar4 result;
>+    result.x = v.z;
>+    result.y = v.w;
>+    result.z = v.y;
>+    result.w = v.y;
>+    return result;
>+}
>+ushort4 operator.zwyy(ushort4 v) {
>+    ushort4 result;
>+    result.x = v.z;
>+    result.y = v.w;
>+    result.z = v.y;
>+    result.w = v.y;
>+    return result;
>+}
>+uint4 operator.zwyy(uint4 v) {
>+    uint4 result;
>+    result.x = v.z;
>+    result.y = v.w;
>+    result.z = v.y;
>+    result.w = v.y;
>+    return result;
>+}
>+char4 operator.zwyy(char4 v) {
>+    char4 result;
>+    result.x = v.z;
>+    result.y = v.w;
>+    result.z = v.y;
>+    result.w = v.y;
>+    return result;
>+}
>+short4 operator.zwyy(short4 v) {
>+    short4 result;
>+    result.x = v.z;
>+    result.y = v.w;
>+    result.z = v.y;
>+    result.w = v.y;
>+    return result;
>+}
>+int4 operator.zwyy(int4 v) {
>+    int4 result;
>+    result.x = v.z;
>+    result.y = v.w;
>+    result.z = v.y;
>+    result.w = v.y;
>+    return result;
>+}
>+half4 operator.zwyy(half4 v) {
>+    half4 result;
>+    result.x = v.z;
>+    result.y = v.w;
>+    result.z = v.y;
>+    result.w = v.y;
>+    return result;
>+}
>+float4 operator.zwyy(float4 v) {
>+    float4 result;
>+    result.x = v.z;
>+    result.y = v.w;
>+    result.z = v.y;
>+    result.w = v.y;
>+    return result;
>+}
>+
>+/* Functions named operator.wxy= */
>+bool4 operator.wxy=(bool4 v, bool3 c) {
>+    bool4 result = v;
>+    result.w = c.x;
>+    result.x = c.y;
>+    result.y = c.z;
>+    return result;
>+}
>+uchar4 operator.wxy=(uchar4 v, uchar3 c) {
>+    uchar4 result = v;
>+    result.w = c.x;
>+    result.x = c.y;
>+    result.y = c.z;
>+    return result;
>+}
>+ushort4 operator.wxy=(ushort4 v, ushort3 c) {
>+    ushort4 result = v;
>+    result.w = c.x;
>+    result.x = c.y;
>+    result.y = c.z;
>+    return result;
>+}
>+uint4 operator.wxy=(uint4 v, uint3 c) {
>+    uint4 result = v;
>+    result.w = c.x;
>+    result.x = c.y;
>+    result.y = c.z;
>+    return result;
>+}
>+char4 operator.wxy=(char4 v, char3 c) {
>+    char4 result = v;
>+    result.w = c.x;
>+    result.x = c.y;
>+    result.y = c.z;
>+    return result;
>+}
>+short4 operator.wxy=(short4 v, short3 c) {
>+    short4 result = v;
>+    result.w = c.x;
>+    result.x = c.y;
>+    result.y = c.z;
>+    return result;
>+}
>+int4 operator.wxy=(int4 v, int3 c) {
>+    int4 result = v;
>+    result.w = c.x;
>+    result.x = c.y;
>+    result.y = c.z;
>+    return result;
>+}
>+half4 operator.wxy=(half4 v, half3 c) {
>+    half4 result = v;
>+    result.w = c.x;
>+    result.x = c.y;
>+    result.y = c.z;
>+    return result;
>+}
>+float4 operator.wxy=(float4 v, float3 c) {
>+    float4 result = v;
>+    result.w = c.x;
>+    result.x = c.y;
>+    result.y = c.z;
>+    return result;
>+}
>+
>+/* Functions named operator.xyyy */
>+bool4 operator.xyyy(bool2 v) {
>+    bool4 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.y;
>+    result.w = v.y;
>+    return result;
>+}
>+bool4 operator.xyyy(bool3 v) {
>+    bool4 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.y;
>+    result.w = v.y;
>+    return result;
>+}
>+bool4 operator.xyyy(bool4 v) {
>+    bool4 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.y;
>+    result.w = v.y;
>+    return result;
>+}
>+uchar4 operator.xyyy(uchar2 v) {
>+    uchar4 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.y;
>+    result.w = v.y;
>+    return result;
>+}
>+uchar4 operator.xyyy(uchar3 v) {
>+    uchar4 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.y;
>+    result.w = v.y;
>+    return result;
>+}
>+uchar4 operator.xyyy(uchar4 v) {
>+    uchar4 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.y;
>+    result.w = v.y;
>+    return result;
>+}
>+ushort4 operator.xyyy(ushort2 v) {
>+    ushort4 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.y;
>+    result.w = v.y;
>+    return result;
>+}
>+ushort4 operator.xyyy(ushort3 v) {
>+    ushort4 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.y;
>+    result.w = v.y;
>+    return result;
>+}
>+ushort4 operator.xyyy(ushort4 v) {
>+    ushort4 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.y;
>+    result.w = v.y;
>+    return result;
>+}
>+uint4 operator.xyyy(uint2 v) {
>+    uint4 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.y;
>+    result.w = v.y;
>+    return result;
>+}
>+uint4 operator.xyyy(uint3 v) {
>+    uint4 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.y;
>+    result.w = v.y;
>+    return result;
>+}
>+uint4 operator.xyyy(uint4 v) {
>+    uint4 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.y;
>+    result.w = v.y;
>+    return result;
>+}
>+char4 operator.xyyy(char2 v) {
>+    char4 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.y;
>+    result.w = v.y;
>+    return result;
>+}
>+char4 operator.xyyy(char3 v) {
>+    char4 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.y;
>+    result.w = v.y;
>+    return result;
>+}
>+char4 operator.xyyy(char4 v) {
>+    char4 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.y;
>+    result.w = v.y;
>+    return result;
>+}
>+short4 operator.xyyy(short2 v) {
>+    short4 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.y;
>+    result.w = v.y;
>+    return result;
>+}
>+short4 operator.xyyy(short3 v) {
>+    short4 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.y;
>+    result.w = v.y;
>+    return result;
>+}
>+short4 operator.xyyy(short4 v) {
>+    short4 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.y;
>+    result.w = v.y;
>+    return result;
>+}
>+int4 operator.xyyy(int2 v) {
>+    int4 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.y;
>+    result.w = v.y;
>+    return result;
>+}
>+int4 operator.xyyy(int3 v) {
>+    int4 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.y;
>+    result.w = v.y;
>+    return result;
>+}
>+int4 operator.xyyy(int4 v) {
>+    int4 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.y;
>+    result.w = v.y;
>+    return result;
>+}
>+half4 operator.xyyy(half2 v) {
>+    half4 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.y;
>+    result.w = v.y;
>+    return result;
>+}
>+half4 operator.xyyy(half3 v) {
>+    half4 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.y;
>+    result.w = v.y;
>+    return result;
>+}
>+half4 operator.xyyy(half4 v) {
>+    half4 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.y;
>+    result.w = v.y;
>+    return result;
>+}
>+float4 operator.xyyy(float2 v) {
>+    float4 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.y;
>+    result.w = v.y;
>+    return result;
>+}
>+float4 operator.xyyy(float3 v) {
>+    float4 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.y;
>+    result.w = v.y;
>+    return result;
>+}
>+float4 operator.xyyy(float4 v) {
>+    float4 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.y;
>+    result.w = v.y;
>+    return result;
>+}
>+
>+/* Functions named operator.yxzx */
>+bool4 operator.yxzx(bool3 v) {
>+    bool4 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.z;
>+    result.w = v.x;
>+    return result;
>+}
>+bool4 operator.yxzx(bool4 v) {
>+    bool4 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.z;
>+    result.w = v.x;
>+    return result;
>+}
>+uchar4 operator.yxzx(uchar3 v) {
>+    uchar4 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.z;
>+    result.w = v.x;
>+    return result;
>+}
>+uchar4 operator.yxzx(uchar4 v) {
>+    uchar4 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.z;
>+    result.w = v.x;
>+    return result;
>+}
>+ushort4 operator.yxzx(ushort3 v) {
>+    ushort4 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.z;
>+    result.w = v.x;
>+    return result;
>+}
>+ushort4 operator.yxzx(ushort4 v) {
>+    ushort4 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.z;
>+    result.w = v.x;
>+    return result;
>+}
>+uint4 operator.yxzx(uint3 v) {
>+    uint4 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.z;
>+    result.w = v.x;
>+    return result;
>+}
>+uint4 operator.yxzx(uint4 v) {
>+    uint4 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.z;
>+    result.w = v.x;
>+    return result;
>+}
>+char4 operator.yxzx(char3 v) {
>+    char4 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.z;
>+    result.w = v.x;
>+    return result;
>+}
>+char4 operator.yxzx(char4 v) {
>+    char4 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.z;
>+    result.w = v.x;
>+    return result;
>+}
>+short4 operator.yxzx(short3 v) {
>+    short4 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.z;
>+    result.w = v.x;
>+    return result;
>+}
>+short4 operator.yxzx(short4 v) {
>+    short4 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.z;
>+    result.w = v.x;
>+    return result;
>+}
>+int4 operator.yxzx(int3 v) {
>+    int4 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.z;
>+    result.w = v.x;
>+    return result;
>+}
>+int4 operator.yxzx(int4 v) {
>+    int4 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.z;
>+    result.w = v.x;
>+    return result;
>+}
>+half4 operator.yxzx(half3 v) {
>+    half4 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.z;
>+    result.w = v.x;
>+    return result;
>+}
>+half4 operator.yxzx(half4 v) {
>+    half4 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.z;
>+    result.w = v.x;
>+    return result;
>+}
>+float4 operator.yxzx(float3 v) {
>+    float4 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.z;
>+    result.w = v.x;
>+    return result;
>+}
>+float4 operator.yxzx(float4 v) {
>+    float4 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.z;
>+    result.w = v.x;
>+    return result;
>+}
>+
>+/* Functions named operator.yy */
>+bool2 operator.yy(bool2 v) {
>+    bool2 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    return result;
>+}
>+bool2 operator.yy(bool3 v) {
>+    bool2 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    return result;
>+}
>+bool2 operator.yy(bool4 v) {
>+    bool2 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    return result;
>+}
>+uchar2 operator.yy(uchar2 v) {
>+    uchar2 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    return result;
>+}
>+uchar2 operator.yy(uchar3 v) {
>+    uchar2 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    return result;
>+}
>+uchar2 operator.yy(uchar4 v) {
>+    uchar2 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    return result;
>+}
>+ushort2 operator.yy(ushort2 v) {
>+    ushort2 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    return result;
>+}
>+ushort2 operator.yy(ushort3 v) {
>+    ushort2 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    return result;
>+}
>+ushort2 operator.yy(ushort4 v) {
>+    ushort2 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    return result;
>+}
>+uint2 operator.yy(uint2 v) {
>+    uint2 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    return result;
>+}
>+uint2 operator.yy(uint3 v) {
>+    uint2 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    return result;
>+}
>+uint2 operator.yy(uint4 v) {
>+    uint2 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    return result;
>+}
>+char2 operator.yy(char2 v) {
>+    char2 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    return result;
>+}
>+char2 operator.yy(char3 v) {
>+    char2 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    return result;
>+}
>+char2 operator.yy(char4 v) {
>+    char2 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    return result;
>+}
>+short2 operator.yy(short2 v) {
>+    short2 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    return result;
>+}
>+short2 operator.yy(short3 v) {
>+    short2 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    return result;
>+}
>+short2 operator.yy(short4 v) {
>+    short2 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    return result;
>+}
>+int2 operator.yy(int2 v) {
>+    int2 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    return result;
>+}
>+int2 operator.yy(int3 v) {
>+    int2 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    return result;
>+}
>+int2 operator.yy(int4 v) {
>+    int2 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    return result;
>+}
>+half2 operator.yy(half2 v) {
>+    half2 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    return result;
>+}
>+half2 operator.yy(half3 v) {
>+    half2 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    return result;
>+}
>+half2 operator.yy(half4 v) {
>+    half2 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    return result;
>+}
>+float2 operator.yy(float2 v) {
>+    float2 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    return result;
>+}
>+float2 operator.yy(float3 v) {
>+    float2 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    return result;
>+}
>+float2 operator.yy(float4 v) {
>+    float2 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    return result;
>+}
>+
>+/* Functions named operator.wzx */
>+bool3 operator.wzx(bool4 v) {
>+    bool3 result;
>+    result.x = v.w;
>+    result.y = v.z;
>+    result.z = v.x;
>+    return result;
>+}
>+uchar3 operator.wzx(uchar4 v) {
>+    uchar3 result;
>+    result.x = v.w;
>+    result.y = v.z;
>+    result.z = v.x;
>+    return result;
>+}
>+ushort3 operator.wzx(ushort4 v) {
>+    ushort3 result;
>+    result.x = v.w;
>+    result.y = v.z;
>+    result.z = v.x;
>+    return result;
>+}
>+uint3 operator.wzx(uint4 v) {
>+    uint3 result;
>+    result.x = v.w;
>+    result.y = v.z;
>+    result.z = v.x;
>+    return result;
>+}
>+char3 operator.wzx(char4 v) {
>+    char3 result;
>+    result.x = v.w;
>+    result.y = v.z;
>+    result.z = v.x;
>+    return result;
>+}
>+short3 operator.wzx(short4 v) {
>+    short3 result;
>+    result.x = v.w;
>+    result.y = v.z;
>+    result.z = v.x;
>+    return result;
>+}
>+int3 operator.wzx(int4 v) {
>+    int3 result;
>+    result.x = v.w;
>+    result.y = v.z;
>+    result.z = v.x;
>+    return result;
>+}
>+half3 operator.wzx(half4 v) {
>+    half3 result;
>+    result.x = v.w;
>+    result.y = v.z;
>+    result.z = v.x;
>+    return result;
>+}
>+float3 operator.wzx(float4 v) {
>+    float3 result;
>+    result.x = v.w;
>+    result.y = v.z;
>+    result.z = v.x;
>+    return result;
>+}
>+
>+/* Functions named operator.yyzx */
>+bool4 operator.yyzx(bool3 v) {
>+    bool4 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.z;
>+    result.w = v.x;
>+    return result;
>+}
>+bool4 operator.yyzx(bool4 v) {
>+    bool4 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.z;
>+    result.w = v.x;
>+    return result;
>+}
>+uchar4 operator.yyzx(uchar3 v) {
>+    uchar4 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.z;
>+    result.w = v.x;
>+    return result;
>+}
>+uchar4 operator.yyzx(uchar4 v) {
>+    uchar4 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.z;
>+    result.w = v.x;
>+    return result;
>+}
>+ushort4 operator.yyzx(ushort3 v) {
>+    ushort4 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.z;
>+    result.w = v.x;
>+    return result;
>+}
>+ushort4 operator.yyzx(ushort4 v) {
>+    ushort4 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.z;
>+    result.w = v.x;
>+    return result;
>+}
>+uint4 operator.yyzx(uint3 v) {
>+    uint4 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.z;
>+    result.w = v.x;
>+    return result;
>+}
>+uint4 operator.yyzx(uint4 v) {
>+    uint4 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.z;
>+    result.w = v.x;
>+    return result;
>+}
>+char4 operator.yyzx(char3 v) {
>+    char4 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.z;
>+    result.w = v.x;
>+    return result;
>+}
>+char4 operator.yyzx(char4 v) {
>+    char4 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.z;
>+    result.w = v.x;
>+    return result;
>+}
>+short4 operator.yyzx(short3 v) {
>+    short4 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.z;
>+    result.w = v.x;
>+    return result;
>+}
>+short4 operator.yyzx(short4 v) {
>+    short4 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.z;
>+    result.w = v.x;
>+    return result;
>+}
>+int4 operator.yyzx(int3 v) {
>+    int4 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.z;
>+    result.w = v.x;
>+    return result;
>+}
>+int4 operator.yyzx(int4 v) {
>+    int4 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.z;
>+    result.w = v.x;
>+    return result;
>+}
>+half4 operator.yyzx(half3 v) {
>+    half4 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.z;
>+    result.w = v.x;
>+    return result;
>+}
>+half4 operator.yyzx(half4 v) {
>+    half4 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.z;
>+    result.w = v.x;
>+    return result;
>+}
>+float4 operator.yyzx(float3 v) {
>+    float4 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.z;
>+    result.w = v.x;
>+    return result;
>+}
>+float4 operator.yyzx(float4 v) {
>+    float4 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.z;
>+    result.w = v.x;
>+    return result;
>+}
>+
>+/* Functions named sincos */
>+void sincos(half x, thread half* y, thread half* z) {
>+    if (y != null)
>+        *y = sin(x);
>+    if (z != null)
>+        *z = cos(x);
>+}
>+void sincos(half2 x, thread half2* y, thread half2* z) {
>+    half sinResult;
>+    half cosResult;
>+    sincos(x[0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0] = sinResult;
>+    if (z != null)
>+        (*z)[0] = cosResult;
>+    sincos(x[1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1] = sinResult;
>+    if (z != null)
>+        (*z)[1] = cosResult;
>+}
>+void sincos(half3 x, thread half3* y, thread half3* z) {
>+    half sinResult;
>+    half cosResult;
>+    sincos(x[0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0] = sinResult;
>+    if (z != null)
>+        (*z)[0] = cosResult;
>+    sincos(x[1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1] = sinResult;
>+    if (z != null)
>+        (*z)[1] = cosResult;
>+    sincos(x[2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2] = sinResult;
>+    if (z != null)
>+        (*z)[2] = cosResult;
>+}
>+void sincos(half4 x, thread half4* y, thread half4* z) {
>+    half sinResult;
>+    half cosResult;
>+    sincos(x[0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0] = sinResult;
>+    if (z != null)
>+        (*z)[0] = cosResult;
>+    sincos(x[1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1] = sinResult;
>+    if (z != null)
>+        (*z)[1] = cosResult;
>+    sincos(x[2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2] = sinResult;
>+    if (z != null)
>+        (*z)[2] = cosResult;
>+    sincos(x[3], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[3] = sinResult;
>+    if (z != null)
>+        (*z)[3] = cosResult;
>+}
>+void sincos(half2x2 x, thread half2x2* y, thread half2x2* z) {
>+    half sinResult;
>+    half cosResult;
>+    sincos(x[0][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][0] = sinResult;
>+    if (z != null)
>+        (*z)[0][0] = cosResult;
>+    sincos(x[0][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][1] = sinResult;
>+    if (z != null)
>+        (*z)[0][1] = cosResult;
>+    sincos(x[1][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][0] = sinResult;
>+    if (z != null)
>+        (*z)[1][0] = cosResult;
>+    sincos(x[1][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][1] = sinResult;
>+    if (z != null)
>+        (*z)[1][1] = cosResult;
>+}
>+void sincos(half2x3 x, thread half2x3* y, thread half2x3* z) {
>+    half sinResult;
>+    half cosResult;
>+    sincos(x[0][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][0] = sinResult;
>+    if (z != null)
>+        (*z)[0][0] = cosResult;
>+    sincos(x[0][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][1] = sinResult;
>+    if (z != null)
>+        (*z)[0][1] = cosResult;
>+    sincos(x[0][2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][2] = sinResult;
>+    if (z != null)
>+        (*z)[0][2] = cosResult;
>+    sincos(x[1][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][0] = sinResult;
>+    if (z != null)
>+        (*z)[1][0] = cosResult;
>+    sincos(x[1][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][1] = sinResult;
>+    if (z != null)
>+        (*z)[1][1] = cosResult;
>+    sincos(x[1][2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][2] = sinResult;
>+    if (z != null)
>+        (*z)[1][2] = cosResult;
>+}
>+void sincos(half2x4 x, thread half2x4* y, thread half2x4* z) {
>+    half sinResult;
>+    half cosResult;
>+    sincos(x[0][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][0] = sinResult;
>+    if (z != null)
>+        (*z)[0][0] = cosResult;
>+    sincos(x[0][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][1] = sinResult;
>+    if (z != null)
>+        (*z)[0][1] = cosResult;
>+    sincos(x[0][2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][2] = sinResult;
>+    if (z != null)
>+        (*z)[0][2] = cosResult;
>+    sincos(x[0][3], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][3] = sinResult;
>+    if (z != null)
>+        (*z)[0][3] = cosResult;
>+    sincos(x[1][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][0] = sinResult;
>+    if (z != null)
>+        (*z)[1][0] = cosResult;
>+    sincos(x[1][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][1] = sinResult;
>+    if (z != null)
>+        (*z)[1][1] = cosResult;
>+    sincos(x[1][2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][2] = sinResult;
>+    if (z != null)
>+        (*z)[1][2] = cosResult;
>+    sincos(x[1][3], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][3] = sinResult;
>+    if (z != null)
>+        (*z)[1][3] = cosResult;
>+}
>+void sincos(half3x2 x, thread half3x2* y, thread half3x2* z) {
>+    half sinResult;
>+    half cosResult;
>+    sincos(x[0][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][0] = sinResult;
>+    if (z != null)
>+        (*z)[0][0] = cosResult;
>+    sincos(x[0][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][1] = sinResult;
>+    if (z != null)
>+        (*z)[0][1] = cosResult;
>+    sincos(x[1][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][0] = sinResult;
>+    if (z != null)
>+        (*z)[1][0] = cosResult;
>+    sincos(x[1][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][1] = sinResult;
>+    if (z != null)
>+        (*z)[1][1] = cosResult;
>+    sincos(x[2][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2][0] = sinResult;
>+    if (z != null)
>+        (*z)[2][0] = cosResult;
>+    sincos(x[2][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2][1] = sinResult;
>+    if (z != null)
>+        (*z)[2][1] = cosResult;
>+}
>+void sincos(half3x3 x, thread half3x3* y, thread half3x3* z) {
>+    half sinResult;
>+    half cosResult;
>+    sincos(x[0][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][0] = sinResult;
>+    if (z != null)
>+        (*z)[0][0] = cosResult;
>+    sincos(x[0][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][1] = sinResult;
>+    if (z != null)
>+        (*z)[0][1] = cosResult;
>+    sincos(x[0][2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][2] = sinResult;
>+    if (z != null)
>+        (*z)[0][2] = cosResult;
>+    sincos(x[1][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][0] = sinResult;
>+    if (z != null)
>+        (*z)[1][0] = cosResult;
>+    sincos(x[1][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][1] = sinResult;
>+    if (z != null)
>+        (*z)[1][1] = cosResult;
>+    sincos(x[1][2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][2] = sinResult;
>+    if (z != null)
>+        (*z)[1][2] = cosResult;
>+    sincos(x[2][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2][0] = sinResult;
>+    if (z != null)
>+        (*z)[2][0] = cosResult;
>+    sincos(x[2][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2][1] = sinResult;
>+    if (z != null)
>+        (*z)[2][1] = cosResult;
>+    sincos(x[2][2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2][2] = sinResult;
>+    if (z != null)
>+        (*z)[2][2] = cosResult;
>+}
>+void sincos(half3x4 x, thread half3x4* y, thread half3x4* z) {
>+    half sinResult;
>+    half cosResult;
>+    sincos(x[0][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][0] = sinResult;
>+    if (z != null)
>+        (*z)[0][0] = cosResult;
>+    sincos(x[0][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][1] = sinResult;
>+    if (z != null)
>+        (*z)[0][1] = cosResult;
>+    sincos(x[0][2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][2] = sinResult;
>+    if (z != null)
>+        (*z)[0][2] = cosResult;
>+    sincos(x[0][3], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][3] = sinResult;
>+    if (z != null)
>+        (*z)[0][3] = cosResult;
>+    sincos(x[1][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][0] = sinResult;
>+    if (z != null)
>+        (*z)[1][0] = cosResult;
>+    sincos(x[1][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][1] = sinResult;
>+    if (z != null)
>+        (*z)[1][1] = cosResult;
>+    sincos(x[1][2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][2] = sinResult;
>+    if (z != null)
>+        (*z)[1][2] = cosResult;
>+    sincos(x[1][3], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][3] = sinResult;
>+    if (z != null)
>+        (*z)[1][3] = cosResult;
>+    sincos(x[2][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2][0] = sinResult;
>+    if (z != null)
>+        (*z)[2][0] = cosResult;
>+    sincos(x[2][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2][1] = sinResult;
>+    if (z != null)
>+        (*z)[2][1] = cosResult;
>+    sincos(x[2][2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2][2] = sinResult;
>+    if (z != null)
>+        (*z)[2][2] = cosResult;
>+    sincos(x[2][3], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2][3] = sinResult;
>+    if (z != null)
>+        (*z)[2][3] = cosResult;
>+}
>+void sincos(half4x2 x, thread half4x2* y, thread half4x2* z) {
>+    half sinResult;
>+    half cosResult;
>+    sincos(x[0][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][0] = sinResult;
>+    if (z != null)
>+        (*z)[0][0] = cosResult;
>+    sincos(x[0][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][1] = sinResult;
>+    if (z != null)
>+        (*z)[0][1] = cosResult;
>+    sincos(x[1][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][0] = sinResult;
>+    if (z != null)
>+        (*z)[1][0] = cosResult;
>+    sincos(x[1][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][1] = sinResult;
>+    if (z != null)
>+        (*z)[1][1] = cosResult;
>+    sincos(x[2][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2][0] = sinResult;
>+    if (z != null)
>+        (*z)[2][0] = cosResult;
>+    sincos(x[2][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2][1] = sinResult;
>+    if (z != null)
>+        (*z)[2][1] = cosResult;
>+    sincos(x[3][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[3][0] = sinResult;
>+    if (z != null)
>+        (*z)[3][0] = cosResult;
>+    sincos(x[3][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[3][1] = sinResult;
>+    if (z != null)
>+        (*z)[3][1] = cosResult;
>+}
>+void sincos(half4x3 x, thread half4x3* y, thread half4x3* z) {
>+    half sinResult;
>+    half cosResult;
>+    sincos(x[0][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][0] = sinResult;
>+    if (z != null)
>+        (*z)[0][0] = cosResult;
>+    sincos(x[0][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][1] = sinResult;
>+    if (z != null)
>+        (*z)[0][1] = cosResult;
>+    sincos(x[0][2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][2] = sinResult;
>+    if (z != null)
>+        (*z)[0][2] = cosResult;
>+    sincos(x[1][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][0] = sinResult;
>+    if (z != null)
>+        (*z)[1][0] = cosResult;
>+    sincos(x[1][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][1] = sinResult;
>+    if (z != null)
>+        (*z)[1][1] = cosResult;
>+    sincos(x[1][2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][2] = sinResult;
>+    if (z != null)
>+        (*z)[1][2] = cosResult;
>+    sincos(x[2][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2][0] = sinResult;
>+    if (z != null)
>+        (*z)[2][0] = cosResult;
>+    sincos(x[2][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2][1] = sinResult;
>+    if (z != null)
>+        (*z)[2][1] = cosResult;
>+    sincos(x[2][2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2][2] = sinResult;
>+    if (z != null)
>+        (*z)[2][2] = cosResult;
>+    sincos(x[3][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[3][0] = sinResult;
>+    if (z != null)
>+        (*z)[3][0] = cosResult;
>+    sincos(x[3][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[3][1] = sinResult;
>+    if (z != null)
>+        (*z)[3][1] = cosResult;
>+    sincos(x[3][2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[3][2] = sinResult;
>+    if (z != null)
>+        (*z)[3][2] = cosResult;
>+}
>+void sincos(half4x4 x, thread half4x4* y, thread half4x4* z) {
>+    half sinResult;
>+    half cosResult;
>+    sincos(x[0][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][0] = sinResult;
>+    if (z != null)
>+        (*z)[0][0] = cosResult;
>+    sincos(x[0][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][1] = sinResult;
>+    if (z != null)
>+        (*z)[0][1] = cosResult;
>+    sincos(x[0][2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][2] = sinResult;
>+    if (z != null)
>+        (*z)[0][2] = cosResult;
>+    sincos(x[0][3], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][3] = sinResult;
>+    if (z != null)
>+        (*z)[0][3] = cosResult;
>+    sincos(x[1][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][0] = sinResult;
>+    if (z != null)
>+        (*z)[1][0] = cosResult;
>+    sincos(x[1][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][1] = sinResult;
>+    if (z != null)
>+        (*z)[1][1] = cosResult;
>+    sincos(x[1][2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][2] = sinResult;
>+    if (z != null)
>+        (*z)[1][2] = cosResult;
>+    sincos(x[1][3], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][3] = sinResult;
>+    if (z != null)
>+        (*z)[1][3] = cosResult;
>+    sincos(x[2][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2][0] = sinResult;
>+    if (z != null)
>+        (*z)[2][0] = cosResult;
>+    sincos(x[2][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2][1] = sinResult;
>+    if (z != null)
>+        (*z)[2][1] = cosResult;
>+    sincos(x[2][2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2][2] = sinResult;
>+    if (z != null)
>+        (*z)[2][2] = cosResult;
>+    sincos(x[2][3], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2][3] = sinResult;
>+    if (z != null)
>+        (*z)[2][3] = cosResult;
>+    sincos(x[3][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[3][0] = sinResult;
>+    if (z != null)
>+        (*z)[3][0] = cosResult;
>+    sincos(x[3][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[3][1] = sinResult;
>+    if (z != null)
>+        (*z)[3][1] = cosResult;
>+    sincos(x[3][2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[3][2] = sinResult;
>+    if (z != null)
>+        (*z)[3][2] = cosResult;
>+    sincos(x[3][3], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[3][3] = sinResult;
>+    if (z != null)
>+        (*z)[3][3] = cosResult;
>+}
>+void sincos(float x, thread float* y, thread float* z) {
>+    if (y != null)
>+        *y = sin(x);
>+    if (z != null)
>+        *z = cos(x);
>+}
>+void sincos(float2 x, thread float2* y, thread float2* z) {
>+    float sinResult;
>+    float cosResult;
>+    sincos(x[0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0] = sinResult;
>+    if (z != null)
>+        (*z)[0] = cosResult;
>+    sincos(x[1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1] = sinResult;
>+    if (z != null)
>+        (*z)[1] = cosResult;
>+}
>+void sincos(float3 x, thread float3* y, thread float3* z) {
>+    float sinResult;
>+    float cosResult;
>+    sincos(x[0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0] = sinResult;
>+    if (z != null)
>+        (*z)[0] = cosResult;
>+    sincos(x[1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1] = sinResult;
>+    if (z != null)
>+        (*z)[1] = cosResult;
>+    sincos(x[2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2] = sinResult;
>+    if (z != null)
>+        (*z)[2] = cosResult;
>+}
>+void sincos(float4 x, thread float4* y, thread float4* z) {
>+    float sinResult;
>+    float cosResult;
>+    sincos(x[0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0] = sinResult;
>+    if (z != null)
>+        (*z)[0] = cosResult;
>+    sincos(x[1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1] = sinResult;
>+    if (z != null)
>+        (*z)[1] = cosResult;
>+    sincos(x[2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2] = sinResult;
>+    if (z != null)
>+        (*z)[2] = cosResult;
>+    sincos(x[3], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[3] = sinResult;
>+    if (z != null)
>+        (*z)[3] = cosResult;
>+}
>+void sincos(float2x2 x, thread float2x2* y, thread float2x2* z) {
>+    float sinResult;
>+    float cosResult;
>+    sincos(x[0][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][0] = sinResult;
>+    if (z != null)
>+        (*z)[0][0] = cosResult;
>+    sincos(x[0][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][1] = sinResult;
>+    if (z != null)
>+        (*z)[0][1] = cosResult;
>+    sincos(x[1][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][0] = sinResult;
>+    if (z != null)
>+        (*z)[1][0] = cosResult;
>+    sincos(x[1][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][1] = sinResult;
>+    if (z != null)
>+        (*z)[1][1] = cosResult;
>+}
>+void sincos(float2x3 x, thread float2x3* y, thread float2x3* z) {
>+    float sinResult;
>+    float cosResult;
>+    sincos(x[0][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][0] = sinResult;
>+    if (z != null)
>+        (*z)[0][0] = cosResult;
>+    sincos(x[0][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][1] = sinResult;
>+    if (z != null)
>+        (*z)[0][1] = cosResult;
>+    sincos(x[0][2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][2] = sinResult;
>+    if (z != null)
>+        (*z)[0][2] = cosResult;
>+    sincos(x[1][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][0] = sinResult;
>+    if (z != null)
>+        (*z)[1][0] = cosResult;
>+    sincos(x[1][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][1] = sinResult;
>+    if (z != null)
>+        (*z)[1][1] = cosResult;
>+    sincos(x[1][2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][2] = sinResult;
>+    if (z != null)
>+        (*z)[1][2] = cosResult;
>+}
>+void sincos(float2x4 x, thread float2x4* y, thread float2x4* z) {
>+    float sinResult;
>+    float cosResult;
>+    sincos(x[0][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][0] = sinResult;
>+    if (z != null)
>+        (*z)[0][0] = cosResult;
>+    sincos(x[0][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][1] = sinResult;
>+    if (z != null)
>+        (*z)[0][1] = cosResult;
>+    sincos(x[0][2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][2] = sinResult;
>+    if (z != null)
>+        (*z)[0][2] = cosResult;
>+    sincos(x[0][3], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][3] = sinResult;
>+    if (z != null)
>+        (*z)[0][3] = cosResult;
>+    sincos(x[1][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][0] = sinResult;
>+    if (z != null)
>+        (*z)[1][0] = cosResult;
>+    sincos(x[1][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][1] = sinResult;
>+    if (z != null)
>+        (*z)[1][1] = cosResult;
>+    sincos(x[1][2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][2] = sinResult;
>+    if (z != null)
>+        (*z)[1][2] = cosResult;
>+    sincos(x[1][3], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][3] = sinResult;
>+    if (z != null)
>+        (*z)[1][3] = cosResult;
>+}
>+void sincos(float3x2 x, thread float3x2* y, thread float3x2* z) {
>+    float sinResult;
>+    float cosResult;
>+    sincos(x[0][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][0] = sinResult;
>+    if (z != null)
>+        (*z)[0][0] = cosResult;
>+    sincos(x[0][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][1] = sinResult;
>+    if (z != null)
>+        (*z)[0][1] = cosResult;
>+    sincos(x[1][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][0] = sinResult;
>+    if (z != null)
>+        (*z)[1][0] = cosResult;
>+    sincos(x[1][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][1] = sinResult;
>+    if (z != null)
>+        (*z)[1][1] = cosResult;
>+    sincos(x[2][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2][0] = sinResult;
>+    if (z != null)
>+        (*z)[2][0] = cosResult;
>+    sincos(x[2][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2][1] = sinResult;
>+    if (z != null)
>+        (*z)[2][1] = cosResult;
>+}
>+void sincos(float3x3 x, thread float3x3* y, thread float3x3* z) {
>+    float sinResult;
>+    float cosResult;
>+    sincos(x[0][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][0] = sinResult;
>+    if (z != null)
>+        (*z)[0][0] = cosResult;
>+    sincos(x[0][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][1] = sinResult;
>+    if (z != null)
>+        (*z)[0][1] = cosResult;
>+    sincos(x[0][2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][2] = sinResult;
>+    if (z != null)
>+        (*z)[0][2] = cosResult;
>+    sincos(x[1][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][0] = sinResult;
>+    if (z != null)
>+        (*z)[1][0] = cosResult;
>+    sincos(x[1][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][1] = sinResult;
>+    if (z != null)
>+        (*z)[1][1] = cosResult;
>+    sincos(x[1][2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][2] = sinResult;
>+    if (z != null)
>+        (*z)[1][2] = cosResult;
>+    sincos(x[2][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2][0] = sinResult;
>+    if (z != null)
>+        (*z)[2][0] = cosResult;
>+    sincos(x[2][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2][1] = sinResult;
>+    if (z != null)
>+        (*z)[2][1] = cosResult;
>+    sincos(x[2][2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2][2] = sinResult;
>+    if (z != null)
>+        (*z)[2][2] = cosResult;
>+}
>+void sincos(float3x4 x, thread float3x4* y, thread float3x4* z) {
>+    float sinResult;
>+    float cosResult;
>+    sincos(x[0][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][0] = sinResult;
>+    if (z != null)
>+        (*z)[0][0] = cosResult;
>+    sincos(x[0][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][1] = sinResult;
>+    if (z != null)
>+        (*z)[0][1] = cosResult;
>+    sincos(x[0][2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][2] = sinResult;
>+    if (z != null)
>+        (*z)[0][2] = cosResult;
>+    sincos(x[0][3], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][3] = sinResult;
>+    if (z != null)
>+        (*z)[0][3] = cosResult;
>+    sincos(x[1][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][0] = sinResult;
>+    if (z != null)
>+        (*z)[1][0] = cosResult;
>+    sincos(x[1][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][1] = sinResult;
>+    if (z != null)
>+        (*z)[1][1] = cosResult;
>+    sincos(x[1][2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][2] = sinResult;
>+    if (z != null)
>+        (*z)[1][2] = cosResult;
>+    sincos(x[1][3], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][3] = sinResult;
>+    if (z != null)
>+        (*z)[1][3] = cosResult;
>+    sincos(x[2][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2][0] = sinResult;
>+    if (z != null)
>+        (*z)[2][0] = cosResult;
>+    sincos(x[2][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2][1] = sinResult;
>+    if (z != null)
>+        (*z)[2][1] = cosResult;
>+    sincos(x[2][2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2][2] = sinResult;
>+    if (z != null)
>+        (*z)[2][2] = cosResult;
>+    sincos(x[2][3], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2][3] = sinResult;
>+    if (z != null)
>+        (*z)[2][3] = cosResult;
>+}
>+void sincos(float4x2 x, thread float4x2* y, thread float4x2* z) {
>+    float sinResult;
>+    float cosResult;
>+    sincos(x[0][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][0] = sinResult;
>+    if (z != null)
>+        (*z)[0][0] = cosResult;
>+    sincos(x[0][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][1] = sinResult;
>+    if (z != null)
>+        (*z)[0][1] = cosResult;
>+    sincos(x[1][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][0] = sinResult;
>+    if (z != null)
>+        (*z)[1][0] = cosResult;
>+    sincos(x[1][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][1] = sinResult;
>+    if (z != null)
>+        (*z)[1][1] = cosResult;
>+    sincos(x[2][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2][0] = sinResult;
>+    if (z != null)
>+        (*z)[2][0] = cosResult;
>+    sincos(x[2][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2][1] = sinResult;
>+    if (z != null)
>+        (*z)[2][1] = cosResult;
>+    sincos(x[3][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[3][0] = sinResult;
>+    if (z != null)
>+        (*z)[3][0] = cosResult;
>+    sincos(x[3][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[3][1] = sinResult;
>+    if (z != null)
>+        (*z)[3][1] = cosResult;
>+}
>+void sincos(float4x3 x, thread float4x3* y, thread float4x3* z) {
>+    float sinResult;
>+    float cosResult;
>+    sincos(x[0][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][0] = sinResult;
>+    if (z != null)
>+        (*z)[0][0] = cosResult;
>+    sincos(x[0][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][1] = sinResult;
>+    if (z != null)
>+        (*z)[0][1] = cosResult;
>+    sincos(x[0][2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][2] = sinResult;
>+    if (z != null)
>+        (*z)[0][2] = cosResult;
>+    sincos(x[1][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][0] = sinResult;
>+    if (z != null)
>+        (*z)[1][0] = cosResult;
>+    sincos(x[1][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][1] = sinResult;
>+    if (z != null)
>+        (*z)[1][1] = cosResult;
>+    sincos(x[1][2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][2] = sinResult;
>+    if (z != null)
>+        (*z)[1][2] = cosResult;
>+    sincos(x[2][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2][0] = sinResult;
>+    if (z != null)
>+        (*z)[2][0] = cosResult;
>+    sincos(x[2][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2][1] = sinResult;
>+    if (z != null)
>+        (*z)[2][1] = cosResult;
>+    sincos(x[2][2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2][2] = sinResult;
>+    if (z != null)
>+        (*z)[2][2] = cosResult;
>+    sincos(x[3][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[3][0] = sinResult;
>+    if (z != null)
>+        (*z)[3][0] = cosResult;
>+    sincos(x[3][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[3][1] = sinResult;
>+    if (z != null)
>+        (*z)[3][1] = cosResult;
>+    sincos(x[3][2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[3][2] = sinResult;
>+    if (z != null)
>+        (*z)[3][2] = cosResult;
>+}
>+void sincos(float4x4 x, thread float4x4* y, thread float4x4* z) {
>+    float sinResult;
>+    float cosResult;
>+    sincos(x[0][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][0] = sinResult;
>+    if (z != null)
>+        (*z)[0][0] = cosResult;
>+    sincos(x[0][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][1] = sinResult;
>+    if (z != null)
>+        (*z)[0][1] = cosResult;
>+    sincos(x[0][2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][2] = sinResult;
>+    if (z != null)
>+        (*z)[0][2] = cosResult;
>+    sincos(x[0][3], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][3] = sinResult;
>+    if (z != null)
>+        (*z)[0][3] = cosResult;
>+    sincos(x[1][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][0] = sinResult;
>+    if (z != null)
>+        (*z)[1][0] = cosResult;
>+    sincos(x[1][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][1] = sinResult;
>+    if (z != null)
>+        (*z)[1][1] = cosResult;
>+    sincos(x[1][2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][2] = sinResult;
>+    if (z != null)
>+        (*z)[1][2] = cosResult;
>+    sincos(x[1][3], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][3] = sinResult;
>+    if (z != null)
>+        (*z)[1][3] = cosResult;
>+    sincos(x[2][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2][0] = sinResult;
>+    if (z != null)
>+        (*z)[2][0] = cosResult;
>+    sincos(x[2][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2][1] = sinResult;
>+    if (z != null)
>+        (*z)[2][1] = cosResult;
>+    sincos(x[2][2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2][2] = sinResult;
>+    if (z != null)
>+        (*z)[2][2] = cosResult;
>+    sincos(x[2][3], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2][3] = sinResult;
>+    if (z != null)
>+        (*z)[2][3] = cosResult;
>+    sincos(x[3][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[3][0] = sinResult;
>+    if (z != null)
>+        (*z)[3][0] = cosResult;
>+    sincos(x[3][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[3][1] = sinResult;
>+    if (z != null)
>+        (*z)[3][1] = cosResult;
>+    sincos(x[3][2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[3][2] = sinResult;
>+    if (z != null)
>+        (*z)[3][2] = cosResult;
>+    sincos(x[3][3], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[3][3] = sinResult;
>+    if (z != null)
>+        (*z)[3][3] = cosResult;
>+}
>+void sincos(half x, thread half* y, device half* z) {
>+    if (y != null)
>+        *y = sin(x);
>+    if (z != null)
>+        *z = cos(x);
>+}
>+void sincos(half2 x, thread half2* y, device half2* z) {
>+    half sinResult;
>+    half cosResult;
>+    sincos(x[0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0] = sinResult;
>+    if (z != null)
>+        (*z)[0] = cosResult;
>+    sincos(x[1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1] = sinResult;
>+    if (z != null)
>+        (*z)[1] = cosResult;
>+}
>+void sincos(half3 x, thread half3* y, device half3* z) {
>+    half sinResult;
>+    half cosResult;
>+    sincos(x[0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0] = sinResult;
>+    if (z != null)
>+        (*z)[0] = cosResult;
>+    sincos(x[1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1] = sinResult;
>+    if (z != null)
>+        (*z)[1] = cosResult;
>+    sincos(x[2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2] = sinResult;
>+    if (z != null)
>+        (*z)[2] = cosResult;
>+}
>+void sincos(half4 x, thread half4* y, device half4* z) {
>+    half sinResult;
>+    half cosResult;
>+    sincos(x[0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0] = sinResult;
>+    if (z != null)
>+        (*z)[0] = cosResult;
>+    sincos(x[1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1] = sinResult;
>+    if (z != null)
>+        (*z)[1] = cosResult;
>+    sincos(x[2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2] = sinResult;
>+    if (z != null)
>+        (*z)[2] = cosResult;
>+    sincos(x[3], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[3] = sinResult;
>+    if (z != null)
>+        (*z)[3] = cosResult;
>+}
>+void sincos(half2x2 x, thread half2x2* y, device half2x2* z) {
>+    half sinResult;
>+    half cosResult;
>+    sincos(x[0][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][0] = sinResult;
>+    if (z != null)
>+        (*z)[0][0] = cosResult;
>+    sincos(x[0][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][1] = sinResult;
>+    if (z != null)
>+        (*z)[0][1] = cosResult;
>+    sincos(x[1][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][0] = sinResult;
>+    if (z != null)
>+        (*z)[1][0] = cosResult;
>+    sincos(x[1][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][1] = sinResult;
>+    if (z != null)
>+        (*z)[1][1] = cosResult;
>+}
>+void sincos(half2x3 x, thread half2x3* y, device half2x3* z) {
>+    half sinResult;
>+    half cosResult;
>+    sincos(x[0][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][0] = sinResult;
>+    if (z != null)
>+        (*z)[0][0] = cosResult;
>+    sincos(x[0][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][1] = sinResult;
>+    if (z != null)
>+        (*z)[0][1] = cosResult;
>+    sincos(x[0][2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][2] = sinResult;
>+    if (z != null)
>+        (*z)[0][2] = cosResult;
>+    sincos(x[1][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][0] = sinResult;
>+    if (z != null)
>+        (*z)[1][0] = cosResult;
>+    sincos(x[1][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][1] = sinResult;
>+    if (z != null)
>+        (*z)[1][1] = cosResult;
>+    sincos(x[1][2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][2] = sinResult;
>+    if (z != null)
>+        (*z)[1][2] = cosResult;
>+}
>+void sincos(half2x4 x, thread half2x4* y, device half2x4* z) {
>+    half sinResult;
>+    half cosResult;
>+    sincos(x[0][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][0] = sinResult;
>+    if (z != null)
>+        (*z)[0][0] = cosResult;
>+    sincos(x[0][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][1] = sinResult;
>+    if (z != null)
>+        (*z)[0][1] = cosResult;
>+    sincos(x[0][2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][2] = sinResult;
>+    if (z != null)
>+        (*z)[0][2] = cosResult;
>+    sincos(x[0][3], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][3] = sinResult;
>+    if (z != null)
>+        (*z)[0][3] = cosResult;
>+    sincos(x[1][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][0] = sinResult;
>+    if (z != null)
>+        (*z)[1][0] = cosResult;
>+    sincos(x[1][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][1] = sinResult;
>+    if (z != null)
>+        (*z)[1][1] = cosResult;
>+    sincos(x[1][2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][2] = sinResult;
>+    if (z != null)
>+        (*z)[1][2] = cosResult;
>+    sincos(x[1][3], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][3] = sinResult;
>+    if (z != null)
>+        (*z)[1][3] = cosResult;
>+}
>+void sincos(half3x2 x, thread half3x2* y, device half3x2* z) {
>+    half sinResult;
>+    half cosResult;
>+    sincos(x[0][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][0] = sinResult;
>+    if (z != null)
>+        (*z)[0][0] = cosResult;
>+    sincos(x[0][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][1] = sinResult;
>+    if (z != null)
>+        (*z)[0][1] = cosResult;
>+    sincos(x[1][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][0] = sinResult;
>+    if (z != null)
>+        (*z)[1][0] = cosResult;
>+    sincos(x[1][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][1] = sinResult;
>+    if (z != null)
>+        (*z)[1][1] = cosResult;
>+    sincos(x[2][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2][0] = sinResult;
>+    if (z != null)
>+        (*z)[2][0] = cosResult;
>+    sincos(x[2][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2][1] = sinResult;
>+    if (z != null)
>+        (*z)[2][1] = cosResult;
>+}
>+void sincos(half3x3 x, thread half3x3* y, device half3x3* z) {
>+    half sinResult;
>+    half cosResult;
>+    sincos(x[0][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][0] = sinResult;
>+    if (z != null)
>+        (*z)[0][0] = cosResult;
>+    sincos(x[0][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][1] = sinResult;
>+    if (z != null)
>+        (*z)[0][1] = cosResult;
>+    sincos(x[0][2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][2] = sinResult;
>+    if (z != null)
>+        (*z)[0][2] = cosResult;
>+    sincos(x[1][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][0] = sinResult;
>+    if (z != null)
>+        (*z)[1][0] = cosResult;
>+    sincos(x[1][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][1] = sinResult;
>+    if (z != null)
>+        (*z)[1][1] = cosResult;
>+    sincos(x[1][2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][2] = sinResult;
>+    if (z != null)
>+        (*z)[1][2] = cosResult;
>+    sincos(x[2][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2][0] = sinResult;
>+    if (z != null)
>+        (*z)[2][0] = cosResult;
>+    sincos(x[2][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2][1] = sinResult;
>+    if (z != null)
>+        (*z)[2][1] = cosResult;
>+    sincos(x[2][2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2][2] = sinResult;
>+    if (z != null)
>+        (*z)[2][2] = cosResult;
>+}
>+void sincos(half3x4 x, thread half3x4* y, device half3x4* z) {
>+    half sinResult;
>+    half cosResult;
>+    sincos(x[0][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][0] = sinResult;
>+    if (z != null)
>+        (*z)[0][0] = cosResult;
>+    sincos(x[0][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][1] = sinResult;
>+    if (z != null)
>+        (*z)[0][1] = cosResult;
>+    sincos(x[0][2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][2] = sinResult;
>+    if (z != null)
>+        (*z)[0][2] = cosResult;
>+    sincos(x[0][3], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][3] = sinResult;
>+    if (z != null)
>+        (*z)[0][3] = cosResult;
>+    sincos(x[1][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][0] = sinResult;
>+    if (z != null)
>+        (*z)[1][0] = cosResult;
>+    sincos(x[1][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][1] = sinResult;
>+    if (z != null)
>+        (*z)[1][1] = cosResult;
>+    sincos(x[1][2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][2] = sinResult;
>+    if (z != null)
>+        (*z)[1][2] = cosResult;
>+    sincos(x[1][3], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][3] = sinResult;
>+    if (z != null)
>+        (*z)[1][3] = cosResult;
>+    sincos(x[2][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2][0] = sinResult;
>+    if (z != null)
>+        (*z)[2][0] = cosResult;
>+    sincos(x[2][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2][1] = sinResult;
>+    if (z != null)
>+        (*z)[2][1] = cosResult;
>+    sincos(x[2][2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2][2] = sinResult;
>+    if (z != null)
>+        (*z)[2][2] = cosResult;
>+    sincos(x[2][3], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2][3] = sinResult;
>+    if (z != null)
>+        (*z)[2][3] = cosResult;
>+}
>+void sincos(half4x2 x, thread half4x2* y, device half4x2* z) {
>+    half sinResult;
>+    half cosResult;
>+    sincos(x[0][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][0] = sinResult;
>+    if (z != null)
>+        (*z)[0][0] = cosResult;
>+    sincos(x[0][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][1] = sinResult;
>+    if (z != null)
>+        (*z)[0][1] = cosResult;
>+    sincos(x[1][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][0] = sinResult;
>+    if (z != null)
>+        (*z)[1][0] = cosResult;
>+    sincos(x[1][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][1] = sinResult;
>+    if (z != null)
>+        (*z)[1][1] = cosResult;
>+    sincos(x[2][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2][0] = sinResult;
>+    if (z != null)
>+        (*z)[2][0] = cosResult;
>+    sincos(x[2][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2][1] = sinResult;
>+    if (z != null)
>+        (*z)[2][1] = cosResult;
>+    sincos(x[3][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[3][0] = sinResult;
>+    if (z != null)
>+        (*z)[3][0] = cosResult;
>+    sincos(x[3][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[3][1] = sinResult;
>+    if (z != null)
>+        (*z)[3][1] = cosResult;
>+}
>+void sincos(half4x3 x, thread half4x3* y, device half4x3* z) {
>+    half sinResult;
>+    half cosResult;
>+    sincos(x[0][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][0] = sinResult;
>+    if (z != null)
>+        (*z)[0][0] = cosResult;
>+    sincos(x[0][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][1] = sinResult;
>+    if (z != null)
>+        (*z)[0][1] = cosResult;
>+    sincos(x[0][2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][2] = sinResult;
>+    if (z != null)
>+        (*z)[0][2] = cosResult;
>+    sincos(x[1][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][0] = sinResult;
>+    if (z != null)
>+        (*z)[1][0] = cosResult;
>+    sincos(x[1][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][1] = sinResult;
>+    if (z != null)
>+        (*z)[1][1] = cosResult;
>+    sincos(x[1][2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][2] = sinResult;
>+    if (z != null)
>+        (*z)[1][2] = cosResult;
>+    sincos(x[2][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2][0] = sinResult;
>+    if (z != null)
>+        (*z)[2][0] = cosResult;
>+    sincos(x[2][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2][1] = sinResult;
>+    if (z != null)
>+        (*z)[2][1] = cosResult;
>+    sincos(x[2][2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2][2] = sinResult;
>+    if (z != null)
>+        (*z)[2][2] = cosResult;
>+    sincos(x[3][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[3][0] = sinResult;
>+    if (z != null)
>+        (*z)[3][0] = cosResult;
>+    sincos(x[3][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[3][1] = sinResult;
>+    if (z != null)
>+        (*z)[3][1] = cosResult;
>+    sincos(x[3][2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[3][2] = sinResult;
>+    if (z != null)
>+        (*z)[3][2] = cosResult;
>+}
>+void sincos(half4x4 x, thread half4x4* y, device half4x4* z) {
>+    half sinResult;
>+    half cosResult;
>+    sincos(x[0][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][0] = sinResult;
>+    if (z != null)
>+        (*z)[0][0] = cosResult;
>+    sincos(x[0][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][1] = sinResult;
>+    if (z != null)
>+        (*z)[0][1] = cosResult;
>+    sincos(x[0][2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][2] = sinResult;
>+    if (z != null)
>+        (*z)[0][2] = cosResult;
>+    sincos(x[0][3], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][3] = sinResult;
>+    if (z != null)
>+        (*z)[0][3] = cosResult;
>+    sincos(x[1][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][0] = sinResult;
>+    if (z != null)
>+        (*z)[1][0] = cosResult;
>+    sincos(x[1][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][1] = sinResult;
>+    if (z != null)
>+        (*z)[1][1] = cosResult;
>+    sincos(x[1][2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][2] = sinResult;
>+    if (z != null)
>+        (*z)[1][2] = cosResult;
>+    sincos(x[1][3], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][3] = sinResult;
>+    if (z != null)
>+        (*z)[1][3] = cosResult;
>+    sincos(x[2][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2][0] = sinResult;
>+    if (z != null)
>+        (*z)[2][0] = cosResult;
>+    sincos(x[2][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2][1] = sinResult;
>+    if (z != null)
>+        (*z)[2][1] = cosResult;
>+    sincos(x[2][2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2][2] = sinResult;
>+    if (z != null)
>+        (*z)[2][2] = cosResult;
>+    sincos(x[2][3], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2][3] = sinResult;
>+    if (z != null)
>+        (*z)[2][3] = cosResult;
>+    sincos(x[3][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[3][0] = sinResult;
>+    if (z != null)
>+        (*z)[3][0] = cosResult;
>+    sincos(x[3][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[3][1] = sinResult;
>+    if (z != null)
>+        (*z)[3][1] = cosResult;
>+    sincos(x[3][2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[3][2] = sinResult;
>+    if (z != null)
>+        (*z)[3][2] = cosResult;
>+    sincos(x[3][3], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[3][3] = sinResult;
>+    if (z != null)
>+        (*z)[3][3] = cosResult;
>+}
>+void sincos(float x, thread float* y, device float* z) {
>+    if (y != null)
>+        *y = sin(x);
>+    if (z != null)
>+        *z = cos(x);
>+}
>+void sincos(float2 x, thread float2* y, device float2* z) {
>+    float sinResult;
>+    float cosResult;
>+    sincos(x[0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0] = sinResult;
>+    if (z != null)
>+        (*z)[0] = cosResult;
>+    sincos(x[1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1] = sinResult;
>+    if (z != null)
>+        (*z)[1] = cosResult;
>+}
>+void sincos(float3 x, thread float3* y, device float3* z) {
>+    float sinResult;
>+    float cosResult;
>+    sincos(x[0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0] = sinResult;
>+    if (z != null)
>+        (*z)[0] = cosResult;
>+    sincos(x[1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1] = sinResult;
>+    if (z != null)
>+        (*z)[1] = cosResult;
>+    sincos(x[2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2] = sinResult;
>+    if (z != null)
>+        (*z)[2] = cosResult;
>+}
>+void sincos(float4 x, thread float4* y, device float4* z) {
>+    float sinResult;
>+    float cosResult;
>+    sincos(x[0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0] = sinResult;
>+    if (z != null)
>+        (*z)[0] = cosResult;
>+    sincos(x[1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1] = sinResult;
>+    if (z != null)
>+        (*z)[1] = cosResult;
>+    sincos(x[2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2] = sinResult;
>+    if (z != null)
>+        (*z)[2] = cosResult;
>+    sincos(x[3], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[3] = sinResult;
>+    if (z != null)
>+        (*z)[3] = cosResult;
>+}
>+void sincos(float2x2 x, thread float2x2* y, device float2x2* z) {
>+    float sinResult;
>+    float cosResult;
>+    sincos(x[0][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][0] = sinResult;
>+    if (z != null)
>+        (*z)[0][0] = cosResult;
>+    sincos(x[0][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][1] = sinResult;
>+    if (z != null)
>+        (*z)[0][1] = cosResult;
>+    sincos(x[1][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][0] = sinResult;
>+    if (z != null)
>+        (*z)[1][0] = cosResult;
>+    sincos(x[1][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][1] = sinResult;
>+    if (z != null)
>+        (*z)[1][1] = cosResult;
>+}
>+void sincos(float2x3 x, thread float2x3* y, device float2x3* z) {
>+    float sinResult;
>+    float cosResult;
>+    sincos(x[0][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][0] = sinResult;
>+    if (z != null)
>+        (*z)[0][0] = cosResult;
>+    sincos(x[0][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][1] = sinResult;
>+    if (z != null)
>+        (*z)[0][1] = cosResult;
>+    sincos(x[0][2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][2] = sinResult;
>+    if (z != null)
>+        (*z)[0][2] = cosResult;
>+    sincos(x[1][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][0] = sinResult;
>+    if (z != null)
>+        (*z)[1][0] = cosResult;
>+    sincos(x[1][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][1] = sinResult;
>+    if (z != null)
>+        (*z)[1][1] = cosResult;
>+    sincos(x[1][2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][2] = sinResult;
>+    if (z != null)
>+        (*z)[1][2] = cosResult;
>+}
>+void sincos(float2x4 x, thread float2x4* y, device float2x4* z) {
>+    float sinResult;
>+    float cosResult;
>+    sincos(x[0][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][0] = sinResult;
>+    if (z != null)
>+        (*z)[0][0] = cosResult;
>+    sincos(x[0][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][1] = sinResult;
>+    if (z != null)
>+        (*z)[0][1] = cosResult;
>+    sincos(x[0][2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][2] = sinResult;
>+    if (z != null)
>+        (*z)[0][2] = cosResult;
>+    sincos(x[0][3], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][3] = sinResult;
>+    if (z != null)
>+        (*z)[0][3] = cosResult;
>+    sincos(x[1][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][0] = sinResult;
>+    if (z != null)
>+        (*z)[1][0] = cosResult;
>+    sincos(x[1][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][1] = sinResult;
>+    if (z != null)
>+        (*z)[1][1] = cosResult;
>+    sincos(x[1][2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][2] = sinResult;
>+    if (z != null)
>+        (*z)[1][2] = cosResult;
>+    sincos(x[1][3], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][3] = sinResult;
>+    if (z != null)
>+        (*z)[1][3] = cosResult;
>+}
>+void sincos(float3x2 x, thread float3x2* y, device float3x2* z) {
>+    float sinResult;
>+    float cosResult;
>+    sincos(x[0][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][0] = sinResult;
>+    if (z != null)
>+        (*z)[0][0] = cosResult;
>+    sincos(x[0][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][1] = sinResult;
>+    if (z != null)
>+        (*z)[0][1] = cosResult;
>+    sincos(x[1][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][0] = sinResult;
>+    if (z != null)
>+        (*z)[1][0] = cosResult;
>+    sincos(x[1][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][1] = sinResult;
>+    if (z != null)
>+        (*z)[1][1] = cosResult;
>+    sincos(x[2][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2][0] = sinResult;
>+    if (z != null)
>+        (*z)[2][0] = cosResult;
>+    sincos(x[2][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2][1] = sinResult;
>+    if (z != null)
>+        (*z)[2][1] = cosResult;
>+}
>+void sincos(float3x3 x, thread float3x3* y, device float3x3* z) {
>+    float sinResult;
>+    float cosResult;
>+    sincos(x[0][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][0] = sinResult;
>+    if (z != null)
>+        (*z)[0][0] = cosResult;
>+    sincos(x[0][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][1] = sinResult;
>+    if (z != null)
>+        (*z)[0][1] = cosResult;
>+    sincos(x[0][2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][2] = sinResult;
>+    if (z != null)
>+        (*z)[0][2] = cosResult;
>+    sincos(x[1][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][0] = sinResult;
>+    if (z != null)
>+        (*z)[1][0] = cosResult;
>+    sincos(x[1][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][1] = sinResult;
>+    if (z != null)
>+        (*z)[1][1] = cosResult;
>+    sincos(x[1][2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][2] = sinResult;
>+    if (z != null)
>+        (*z)[1][2] = cosResult;
>+    sincos(x[2][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2][0] = sinResult;
>+    if (z != null)
>+        (*z)[2][0] = cosResult;
>+    sincos(x[2][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2][1] = sinResult;
>+    if (z != null)
>+        (*z)[2][1] = cosResult;
>+    sincos(x[2][2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2][2] = sinResult;
>+    if (z != null)
>+        (*z)[2][2] = cosResult;
>+}
>+void sincos(float3x4 x, thread float3x4* y, device float3x4* z) {
>+    float sinResult;
>+    float cosResult;
>+    sincos(x[0][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][0] = sinResult;
>+    if (z != null)
>+        (*z)[0][0] = cosResult;
>+    sincos(x[0][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][1] = sinResult;
>+    if (z != null)
>+        (*z)[0][1] = cosResult;
>+    sincos(x[0][2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][2] = sinResult;
>+    if (z != null)
>+        (*z)[0][2] = cosResult;
>+    sincos(x[0][3], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][3] = sinResult;
>+    if (z != null)
>+        (*z)[0][3] = cosResult;
>+    sincos(x[1][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][0] = sinResult;
>+    if (z != null)
>+        (*z)[1][0] = cosResult;
>+    sincos(x[1][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][1] = sinResult;
>+    if (z != null)
>+        (*z)[1][1] = cosResult;
>+    sincos(x[1][2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][2] = sinResult;
>+    if (z != null)
>+        (*z)[1][2] = cosResult;
>+    sincos(x[1][3], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][3] = sinResult;
>+    if (z != null)
>+        (*z)[1][3] = cosResult;
>+    sincos(x[2][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2][0] = sinResult;
>+    if (z != null)
>+        (*z)[2][0] = cosResult;
>+    sincos(x[2][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2][1] = sinResult;
>+    if (z != null)
>+        (*z)[2][1] = cosResult;
>+    sincos(x[2][2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2][2] = sinResult;
>+    if (z != null)
>+        (*z)[2][2] = cosResult;
>+    sincos(x[2][3], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2][3] = sinResult;
>+    if (z != null)
>+        (*z)[2][3] = cosResult;
>+}
>+void sincos(float4x2 x, thread float4x2* y, device float4x2* z) {
>+    float sinResult;
>+    float cosResult;
>+    sincos(x[0][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][0] = sinResult;
>+    if (z != null)
>+        (*z)[0][0] = cosResult;
>+    sincos(x[0][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][1] = sinResult;
>+    if (z != null)
>+        (*z)[0][1] = cosResult;
>+    sincos(x[1][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][0] = sinResult;
>+    if (z != null)
>+        (*z)[1][0] = cosResult;
>+    sincos(x[1][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][1] = sinResult;
>+    if (z != null)
>+        (*z)[1][1] = cosResult;
>+    sincos(x[2][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2][0] = sinResult;
>+    if (z != null)
>+        (*z)[2][0] = cosResult;
>+    sincos(x[2][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2][1] = sinResult;
>+    if (z != null)
>+        (*z)[2][1] = cosResult;
>+    sincos(x[3][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[3][0] = sinResult;
>+    if (z != null)
>+        (*z)[3][0] = cosResult;
>+    sincos(x[3][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[3][1] = sinResult;
>+    if (z != null)
>+        (*z)[3][1] = cosResult;
>+}
>+void sincos(float4x3 x, thread float4x3* y, device float4x3* z) {
>+    float sinResult;
>+    float cosResult;
>+    sincos(x[0][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][0] = sinResult;
>+    if (z != null)
>+        (*z)[0][0] = cosResult;
>+    sincos(x[0][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][1] = sinResult;
>+    if (z != null)
>+        (*z)[0][1] = cosResult;
>+    sincos(x[0][2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][2] = sinResult;
>+    if (z != null)
>+        (*z)[0][2] = cosResult;
>+    sincos(x[1][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][0] = sinResult;
>+    if (z != null)
>+        (*z)[1][0] = cosResult;
>+    sincos(x[1][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][1] = sinResult;
>+    if (z != null)
>+        (*z)[1][1] = cosResult;
>+    sincos(x[1][2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][2] = sinResult;
>+    if (z != null)
>+        (*z)[1][2] = cosResult;
>+    sincos(x[2][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2][0] = sinResult;
>+    if (z != null)
>+        (*z)[2][0] = cosResult;
>+    sincos(x[2][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2][1] = sinResult;
>+    if (z != null)
>+        (*z)[2][1] = cosResult;
>+    sincos(x[2][2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2][2] = sinResult;
>+    if (z != null)
>+        (*z)[2][2] = cosResult;
>+    sincos(x[3][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[3][0] = sinResult;
>+    if (z != null)
>+        (*z)[3][0] = cosResult;
>+    sincos(x[3][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[3][1] = sinResult;
>+    if (z != null)
>+        (*z)[3][1] = cosResult;
>+    sincos(x[3][2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[3][2] = sinResult;
>+    if (z != null)
>+        (*z)[3][2] = cosResult;
>+}
>+void sincos(float4x4 x, thread float4x4* y, device float4x4* z) {
>+    float sinResult;
>+    float cosResult;
>+    sincos(x[0][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][0] = sinResult;
>+    if (z != null)
>+        (*z)[0][0] = cosResult;
>+    sincos(x[0][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][1] = sinResult;
>+    if (z != null)
>+        (*z)[0][1] = cosResult;
>+    sincos(x[0][2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][2] = sinResult;
>+    if (z != null)
>+        (*z)[0][2] = cosResult;
>+    sincos(x[0][3], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][3] = sinResult;
>+    if (z != null)
>+        (*z)[0][3] = cosResult;
>+    sincos(x[1][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][0] = sinResult;
>+    if (z != null)
>+        (*z)[1][0] = cosResult;
>+    sincos(x[1][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][1] = sinResult;
>+    if (z != null)
>+        (*z)[1][1] = cosResult;
>+    sincos(x[1][2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][2] = sinResult;
>+    if (z != null)
>+        (*z)[1][2] = cosResult;
>+    sincos(x[1][3], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][3] = sinResult;
>+    if (z != null)
>+        (*z)[1][3] = cosResult;
>+    sincos(x[2][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2][0] = sinResult;
>+    if (z != null)
>+        (*z)[2][0] = cosResult;
>+    sincos(x[2][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2][1] = sinResult;
>+    if (z != null)
>+        (*z)[2][1] = cosResult;
>+    sincos(x[2][2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2][2] = sinResult;
>+    if (z != null)
>+        (*z)[2][2] = cosResult;
>+    sincos(x[2][3], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2][3] = sinResult;
>+    if (z != null)
>+        (*z)[2][3] = cosResult;
>+    sincos(x[3][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[3][0] = sinResult;
>+    if (z != null)
>+        (*z)[3][0] = cosResult;
>+    sincos(x[3][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[3][1] = sinResult;
>+    if (z != null)
>+        (*z)[3][1] = cosResult;
>+    sincos(x[3][2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[3][2] = sinResult;
>+    if (z != null)
>+        (*z)[3][2] = cosResult;
>+    sincos(x[3][3], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[3][3] = sinResult;
>+    if (z != null)
>+        (*z)[3][3] = cosResult;
>+}
>+void sincos(half x, thread half* y, threadgroup half* z) {
>+    if (y != null)
>+        *y = sin(x);
>+    if (z != null)
>+        *z = cos(x);
>+}
>+void sincos(half2 x, thread half2* y, threadgroup half2* z) {
>+    half sinResult;
>+    half cosResult;
>+    sincos(x[0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0] = sinResult;
>+    if (z != null)
>+        (*z)[0] = cosResult;
>+    sincos(x[1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1] = sinResult;
>+    if (z != null)
>+        (*z)[1] = cosResult;
>+}
>+void sincos(half3 x, thread half3* y, threadgroup half3* z) {
>+    half sinResult;
>+    half cosResult;
>+    sincos(x[0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0] = sinResult;
>+    if (z != null)
>+        (*z)[0] = cosResult;
>+    sincos(x[1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1] = sinResult;
>+    if (z != null)
>+        (*z)[1] = cosResult;
>+    sincos(x[2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2] = sinResult;
>+    if (z != null)
>+        (*z)[2] = cosResult;
>+}
>+void sincos(half4 x, thread half4* y, threadgroup half4* z) {
>+    half sinResult;
>+    half cosResult;
>+    sincos(x[0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0] = sinResult;
>+    if (z != null)
>+        (*z)[0] = cosResult;
>+    sincos(x[1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1] = sinResult;
>+    if (z != null)
>+        (*z)[1] = cosResult;
>+    sincos(x[2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2] = sinResult;
>+    if (z != null)
>+        (*z)[2] = cosResult;
>+    sincos(x[3], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[3] = sinResult;
>+    if (z != null)
>+        (*z)[3] = cosResult;
>+}
>+void sincos(half2x2 x, thread half2x2* y, threadgroup half2x2* z) {
>+    half sinResult;
>+    half cosResult;
>+    sincos(x[0][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][0] = sinResult;
>+    if (z != null)
>+        (*z)[0][0] = cosResult;
>+    sincos(x[0][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][1] = sinResult;
>+    if (z != null)
>+        (*z)[0][1] = cosResult;
>+    sincos(x[1][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][0] = sinResult;
>+    if (z != null)
>+        (*z)[1][0] = cosResult;
>+    sincos(x[1][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][1] = sinResult;
>+    if (z != null)
>+        (*z)[1][1] = cosResult;
>+}
>+void sincos(half2x3 x, thread half2x3* y, threadgroup half2x3* z) {
>+    half sinResult;
>+    half cosResult;
>+    sincos(x[0][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][0] = sinResult;
>+    if (z != null)
>+        (*z)[0][0] = cosResult;
>+    sincos(x[0][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][1] = sinResult;
>+    if (z != null)
>+        (*z)[0][1] = cosResult;
>+    sincos(x[0][2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][2] = sinResult;
>+    if (z != null)
>+        (*z)[0][2] = cosResult;
>+    sincos(x[1][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][0] = sinResult;
>+    if (z != null)
>+        (*z)[1][0] = cosResult;
>+    sincos(x[1][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][1] = sinResult;
>+    if (z != null)
>+        (*z)[1][1] = cosResult;
>+    sincos(x[1][2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][2] = sinResult;
>+    if (z != null)
>+        (*z)[1][2] = cosResult;
>+}
>+void sincos(half2x4 x, thread half2x4* y, threadgroup half2x4* z) {
>+    half sinResult;
>+    half cosResult;
>+    sincos(x[0][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][0] = sinResult;
>+    if (z != null)
>+        (*z)[0][0] = cosResult;
>+    sincos(x[0][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][1] = sinResult;
>+    if (z != null)
>+        (*z)[0][1] = cosResult;
>+    sincos(x[0][2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][2] = sinResult;
>+    if (z != null)
>+        (*z)[0][2] = cosResult;
>+    sincos(x[0][3], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][3] = sinResult;
>+    if (z != null)
>+        (*z)[0][3] = cosResult;
>+    sincos(x[1][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][0] = sinResult;
>+    if (z != null)
>+        (*z)[1][0] = cosResult;
>+    sincos(x[1][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][1] = sinResult;
>+    if (z != null)
>+        (*z)[1][1] = cosResult;
>+    sincos(x[1][2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][2] = sinResult;
>+    if (z != null)
>+        (*z)[1][2] = cosResult;
>+    sincos(x[1][3], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][3] = sinResult;
>+    if (z != null)
>+        (*z)[1][3] = cosResult;
>+}
>+void sincos(half3x2 x, thread half3x2* y, threadgroup half3x2* z) {
>+    half sinResult;
>+    half cosResult;
>+    sincos(x[0][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][0] = sinResult;
>+    if (z != null)
>+        (*z)[0][0] = cosResult;
>+    sincos(x[0][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][1] = sinResult;
>+    if (z != null)
>+        (*z)[0][1] = cosResult;
>+    sincos(x[1][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][0] = sinResult;
>+    if (z != null)
>+        (*z)[1][0] = cosResult;
>+    sincos(x[1][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][1] = sinResult;
>+    if (z != null)
>+        (*z)[1][1] = cosResult;
>+    sincos(x[2][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2][0] = sinResult;
>+    if (z != null)
>+        (*z)[2][0] = cosResult;
>+    sincos(x[2][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2][1] = sinResult;
>+    if (z != null)
>+        (*z)[2][1] = cosResult;
>+}
>+void sincos(half3x3 x, thread half3x3* y, threadgroup half3x3* z) {
>+    half sinResult;
>+    half cosResult;
>+    sincos(x[0][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][0] = sinResult;
>+    if (z != null)
>+        (*z)[0][0] = cosResult;
>+    sincos(x[0][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][1] = sinResult;
>+    if (z != null)
>+        (*z)[0][1] = cosResult;
>+    sincos(x[0][2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][2] = sinResult;
>+    if (z != null)
>+        (*z)[0][2] = cosResult;
>+    sincos(x[1][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][0] = sinResult;
>+    if (z != null)
>+        (*z)[1][0] = cosResult;
>+    sincos(x[1][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][1] = sinResult;
>+    if (z != null)
>+        (*z)[1][1] = cosResult;
>+    sincos(x[1][2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][2] = sinResult;
>+    if (z != null)
>+        (*z)[1][2] = cosResult;
>+    sincos(x[2][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2][0] = sinResult;
>+    if (z != null)
>+        (*z)[2][0] = cosResult;
>+    sincos(x[2][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2][1] = sinResult;
>+    if (z != null)
>+        (*z)[2][1] = cosResult;
>+    sincos(x[2][2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2][2] = sinResult;
>+    if (z != null)
>+        (*z)[2][2] = cosResult;
>+}
>+void sincos(half3x4 x, thread half3x4* y, threadgroup half3x4* z) {
>+    half sinResult;
>+    half cosResult;
>+    sincos(x[0][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][0] = sinResult;
>+    if (z != null)
>+        (*z)[0][0] = cosResult;
>+    sincos(x[0][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][1] = sinResult;
>+    if (z != null)
>+        (*z)[0][1] = cosResult;
>+    sincos(x[0][2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][2] = sinResult;
>+    if (z != null)
>+        (*z)[0][2] = cosResult;
>+    sincos(x[0][3], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][3] = sinResult;
>+    if (z != null)
>+        (*z)[0][3] = cosResult;
>+    sincos(x[1][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][0] = sinResult;
>+    if (z != null)
>+        (*z)[1][0] = cosResult;
>+    sincos(x[1][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][1] = sinResult;
>+    if (z != null)
>+        (*z)[1][1] = cosResult;
>+    sincos(x[1][2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][2] = sinResult;
>+    if (z != null)
>+        (*z)[1][2] = cosResult;
>+    sincos(x[1][3], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][3] = sinResult;
>+    if (z != null)
>+        (*z)[1][3] = cosResult;
>+    sincos(x[2][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2][0] = sinResult;
>+    if (z != null)
>+        (*z)[2][0] = cosResult;
>+    sincos(x[2][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2][1] = sinResult;
>+    if (z != null)
>+        (*z)[2][1] = cosResult;
>+    sincos(x[2][2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2][2] = sinResult;
>+    if (z != null)
>+        (*z)[2][2] = cosResult;
>+    sincos(x[2][3], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2][3] = sinResult;
>+    if (z != null)
>+        (*z)[2][3] = cosResult;
>+}
>+void sincos(half4x2 x, thread half4x2* y, threadgroup half4x2* z) {
>+    half sinResult;
>+    half cosResult;
>+    sincos(x[0][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][0] = sinResult;
>+    if (z != null)
>+        (*z)[0][0] = cosResult;
>+    sincos(x[0][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][1] = sinResult;
>+    if (z != null)
>+        (*z)[0][1] = cosResult;
>+    sincos(x[1][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][0] = sinResult;
>+    if (z != null)
>+        (*z)[1][0] = cosResult;
>+    sincos(x[1][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][1] = sinResult;
>+    if (z != null)
>+        (*z)[1][1] = cosResult;
>+    sincos(x[2][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2][0] = sinResult;
>+    if (z != null)
>+        (*z)[2][0] = cosResult;
>+    sincos(x[2][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2][1] = sinResult;
>+    if (z != null)
>+        (*z)[2][1] = cosResult;
>+    sincos(x[3][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[3][0] = sinResult;
>+    if (z != null)
>+        (*z)[3][0] = cosResult;
>+    sincos(x[3][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[3][1] = sinResult;
>+    if (z != null)
>+        (*z)[3][1] = cosResult;
>+}
>+void sincos(half4x3 x, thread half4x3* y, threadgroup half4x3* z) {
>+    half sinResult;
>+    half cosResult;
>+    sincos(x[0][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][0] = sinResult;
>+    if (z != null)
>+        (*z)[0][0] = cosResult;
>+    sincos(x[0][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][1] = sinResult;
>+    if (z != null)
>+        (*z)[0][1] = cosResult;
>+    sincos(x[0][2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][2] = sinResult;
>+    if (z != null)
>+        (*z)[0][2] = cosResult;
>+    sincos(x[1][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][0] = sinResult;
>+    if (z != null)
>+        (*z)[1][0] = cosResult;
>+    sincos(x[1][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][1] = sinResult;
>+    if (z != null)
>+        (*z)[1][1] = cosResult;
>+    sincos(x[1][2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][2] = sinResult;
>+    if (z != null)
>+        (*z)[1][2] = cosResult;
>+    sincos(x[2][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2][0] = sinResult;
>+    if (z != null)
>+        (*z)[2][0] = cosResult;
>+    sincos(x[2][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2][1] = sinResult;
>+    if (z != null)
>+        (*z)[2][1] = cosResult;
>+    sincos(x[2][2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2][2] = sinResult;
>+    if (z != null)
>+        (*z)[2][2] = cosResult;
>+    sincos(x[3][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[3][0] = sinResult;
>+    if (z != null)
>+        (*z)[3][0] = cosResult;
>+    sincos(x[3][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[3][1] = sinResult;
>+    if (z != null)
>+        (*z)[3][1] = cosResult;
>+    sincos(x[3][2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[3][2] = sinResult;
>+    if (z != null)
>+        (*z)[3][2] = cosResult;
>+}
>+void sincos(half4x4 x, thread half4x4* y, threadgroup half4x4* z) {
>+    half sinResult;
>+    half cosResult;
>+    sincos(x[0][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][0] = sinResult;
>+    if (z != null)
>+        (*z)[0][0] = cosResult;
>+    sincos(x[0][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][1] = sinResult;
>+    if (z != null)
>+        (*z)[0][1] = cosResult;
>+    sincos(x[0][2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][2] = sinResult;
>+    if (z != null)
>+        (*z)[0][2] = cosResult;
>+    sincos(x[0][3], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][3] = sinResult;
>+    if (z != null)
>+        (*z)[0][3] = cosResult;
>+    sincos(x[1][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][0] = sinResult;
>+    if (z != null)
>+        (*z)[1][0] = cosResult;
>+    sincos(x[1][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][1] = sinResult;
>+    if (z != null)
>+        (*z)[1][1] = cosResult;
>+    sincos(x[1][2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][2] = sinResult;
>+    if (z != null)
>+        (*z)[1][2] = cosResult;
>+    sincos(x[1][3], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][3] = sinResult;
>+    if (z != null)
>+        (*z)[1][3] = cosResult;
>+    sincos(x[2][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2][0] = sinResult;
>+    if (z != null)
>+        (*z)[2][0] = cosResult;
>+    sincos(x[2][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2][1] = sinResult;
>+    if (z != null)
>+        (*z)[2][1] = cosResult;
>+    sincos(x[2][2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2][2] = sinResult;
>+    if (z != null)
>+        (*z)[2][2] = cosResult;
>+    sincos(x[2][3], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2][3] = sinResult;
>+    if (z != null)
>+        (*z)[2][3] = cosResult;
>+    sincos(x[3][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[3][0] = sinResult;
>+    if (z != null)
>+        (*z)[3][0] = cosResult;
>+    sincos(x[3][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[3][1] = sinResult;
>+    if (z != null)
>+        (*z)[3][1] = cosResult;
>+    sincos(x[3][2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[3][2] = sinResult;
>+    if (z != null)
>+        (*z)[3][2] = cosResult;
>+    sincos(x[3][3], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[3][3] = sinResult;
>+    if (z != null)
>+        (*z)[3][3] = cosResult;
>+}
>+void sincos(float x, thread float* y, threadgroup float* z) {
>+    if (y != null)
>+        *y = sin(x);
>+    if (z != null)
>+        *z = cos(x);
>+}
>+void sincos(float2 x, thread float2* y, threadgroup float2* z) {
>+    float sinResult;
>+    float cosResult;
>+    sincos(x[0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0] = sinResult;
>+    if (z != null)
>+        (*z)[0] = cosResult;
>+    sincos(x[1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1] = sinResult;
>+    if (z != null)
>+        (*z)[1] = cosResult;
>+}
>+void sincos(float3 x, thread float3* y, threadgroup float3* z) {
>+    float sinResult;
>+    float cosResult;
>+    sincos(x[0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0] = sinResult;
>+    if (z != null)
>+        (*z)[0] = cosResult;
>+    sincos(x[1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1] = sinResult;
>+    if (z != null)
>+        (*z)[1] = cosResult;
>+    sincos(x[2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2] = sinResult;
>+    if (z != null)
>+        (*z)[2] = cosResult;
>+}
>+void sincos(float4 x, thread float4* y, threadgroup float4* z) {
>+    float sinResult;
>+    float cosResult;
>+    sincos(x[0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0] = sinResult;
>+    if (z != null)
>+        (*z)[0] = cosResult;
>+    sincos(x[1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1] = sinResult;
>+    if (z != null)
>+        (*z)[1] = cosResult;
>+    sincos(x[2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2] = sinResult;
>+    if (z != null)
>+        (*z)[2] = cosResult;
>+    sincos(x[3], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[3] = sinResult;
>+    if (z != null)
>+        (*z)[3] = cosResult;
>+}
>+void sincos(float2x2 x, thread float2x2* y, threadgroup float2x2* z) {
>+    float sinResult;
>+    float cosResult;
>+    sincos(x[0][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][0] = sinResult;
>+    if (z != null)
>+        (*z)[0][0] = cosResult;
>+    sincos(x[0][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][1] = sinResult;
>+    if (z != null)
>+        (*z)[0][1] = cosResult;
>+    sincos(x[1][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][0] = sinResult;
>+    if (z != null)
>+        (*z)[1][0] = cosResult;
>+    sincos(x[1][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][1] = sinResult;
>+    if (z != null)
>+        (*z)[1][1] = cosResult;
>+}
>+void sincos(float2x3 x, thread float2x3* y, threadgroup float2x3* z) {
>+    float sinResult;
>+    float cosResult;
>+    sincos(x[0][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][0] = sinResult;
>+    if (z != null)
>+        (*z)[0][0] = cosResult;
>+    sincos(x[0][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][1] = sinResult;
>+    if (z != null)
>+        (*z)[0][1] = cosResult;
>+    sincos(x[0][2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][2] = sinResult;
>+    if (z != null)
>+        (*z)[0][2] = cosResult;
>+    sincos(x[1][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][0] = sinResult;
>+    if (z != null)
>+        (*z)[1][0] = cosResult;
>+    sincos(x[1][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][1] = sinResult;
>+    if (z != null)
>+        (*z)[1][1] = cosResult;
>+    sincos(x[1][2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][2] = sinResult;
>+    if (z != null)
>+        (*z)[1][2] = cosResult;
>+}
>+void sincos(float2x4 x, thread float2x4* y, threadgroup float2x4* z) {
>+    float sinResult;
>+    float cosResult;
>+    sincos(x[0][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][0] = sinResult;
>+    if (z != null)
>+        (*z)[0][0] = cosResult;
>+    sincos(x[0][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][1] = sinResult;
>+    if (z != null)
>+        (*z)[0][1] = cosResult;
>+    sincos(x[0][2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][2] = sinResult;
>+    if (z != null)
>+        (*z)[0][2] = cosResult;
>+    sincos(x[0][3], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][3] = sinResult;
>+    if (z != null)
>+        (*z)[0][3] = cosResult;
>+    sincos(x[1][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][0] = sinResult;
>+    if (z != null)
>+        (*z)[1][0] = cosResult;
>+    sincos(x[1][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][1] = sinResult;
>+    if (z != null)
>+        (*z)[1][1] = cosResult;
>+    sincos(x[1][2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][2] = sinResult;
>+    if (z != null)
>+        (*z)[1][2] = cosResult;
>+    sincos(x[1][3], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][3] = sinResult;
>+    if (z != null)
>+        (*z)[1][3] = cosResult;
>+}
>+void sincos(float3x2 x, thread float3x2* y, threadgroup float3x2* z) {
>+    float sinResult;
>+    float cosResult;
>+    sincos(x[0][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][0] = sinResult;
>+    if (z != null)
>+        (*z)[0][0] = cosResult;
>+    sincos(x[0][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][1] = sinResult;
>+    if (z != null)
>+        (*z)[0][1] = cosResult;
>+    sincos(x[1][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][0] = sinResult;
>+    if (z != null)
>+        (*z)[1][0] = cosResult;
>+    sincos(x[1][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][1] = sinResult;
>+    if (z != null)
>+        (*z)[1][1] = cosResult;
>+    sincos(x[2][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2][0] = sinResult;
>+    if (z != null)
>+        (*z)[2][0] = cosResult;
>+    sincos(x[2][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2][1] = sinResult;
>+    if (z != null)
>+        (*z)[2][1] = cosResult;
>+}
>+void sincos(float3x3 x, thread float3x3* y, threadgroup float3x3* z) {
>+    float sinResult;
>+    float cosResult;
>+    sincos(x[0][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][0] = sinResult;
>+    if (z != null)
>+        (*z)[0][0] = cosResult;
>+    sincos(x[0][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][1] = sinResult;
>+    if (z != null)
>+        (*z)[0][1] = cosResult;
>+    sincos(x[0][2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][2] = sinResult;
>+    if (z != null)
>+        (*z)[0][2] = cosResult;
>+    sincos(x[1][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][0] = sinResult;
>+    if (z != null)
>+        (*z)[1][0] = cosResult;
>+    sincos(x[1][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][1] = sinResult;
>+    if (z != null)
>+        (*z)[1][1] = cosResult;
>+    sincos(x[1][2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][2] = sinResult;
>+    if (z != null)
>+        (*z)[1][2] = cosResult;
>+    sincos(x[2][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2][0] = sinResult;
>+    if (z != null)
>+        (*z)[2][0] = cosResult;
>+    sincos(x[2][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2][1] = sinResult;
>+    if (z != null)
>+        (*z)[2][1] = cosResult;
>+    sincos(x[2][2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2][2] = sinResult;
>+    if (z != null)
>+        (*z)[2][2] = cosResult;
>+}
>+void sincos(float3x4 x, thread float3x4* y, threadgroup float3x4* z) {
>+    float sinResult;
>+    float cosResult;
>+    sincos(x[0][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][0] = sinResult;
>+    if (z != null)
>+        (*z)[0][0] = cosResult;
>+    sincos(x[0][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][1] = sinResult;
>+    if (z != null)
>+        (*z)[0][1] = cosResult;
>+    sincos(x[0][2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][2] = sinResult;
>+    if (z != null)
>+        (*z)[0][2] = cosResult;
>+    sincos(x[0][3], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][3] = sinResult;
>+    if (z != null)
>+        (*z)[0][3] = cosResult;
>+    sincos(x[1][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][0] = sinResult;
>+    if (z != null)
>+        (*z)[1][0] = cosResult;
>+    sincos(x[1][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][1] = sinResult;
>+    if (z != null)
>+        (*z)[1][1] = cosResult;
>+    sincos(x[1][2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][2] = sinResult;
>+    if (z != null)
>+        (*z)[1][2] = cosResult;
>+    sincos(x[1][3], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][3] = sinResult;
>+    if (z != null)
>+        (*z)[1][3] = cosResult;
>+    sincos(x[2][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2][0] = sinResult;
>+    if (z != null)
>+        (*z)[2][0] = cosResult;
>+    sincos(x[2][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2][1] = sinResult;
>+    if (z != null)
>+        (*z)[2][1] = cosResult;
>+    sincos(x[2][2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2][2] = sinResult;
>+    if (z != null)
>+        (*z)[2][2] = cosResult;
>+    sincos(x[2][3], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2][3] = sinResult;
>+    if (z != null)
>+        (*z)[2][3] = cosResult;
>+}
>+void sincos(float4x2 x, thread float4x2* y, threadgroup float4x2* z) {
>+    float sinResult;
>+    float cosResult;
>+    sincos(x[0][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][0] = sinResult;
>+    if (z != null)
>+        (*z)[0][0] = cosResult;
>+    sincos(x[0][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][1] = sinResult;
>+    if (z != null)
>+        (*z)[0][1] = cosResult;
>+    sincos(x[1][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][0] = sinResult;
>+    if (z != null)
>+        (*z)[1][0] = cosResult;
>+    sincos(x[1][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][1] = sinResult;
>+    if (z != null)
>+        (*z)[1][1] = cosResult;
>+    sincos(x[2][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2][0] = sinResult;
>+    if (z != null)
>+        (*z)[2][0] = cosResult;
>+    sincos(x[2][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2][1] = sinResult;
>+    if (z != null)
>+        (*z)[2][1] = cosResult;
>+    sincos(x[3][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[3][0] = sinResult;
>+    if (z != null)
>+        (*z)[3][0] = cosResult;
>+    sincos(x[3][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[3][1] = sinResult;
>+    if (z != null)
>+        (*z)[3][1] = cosResult;
>+}
>+void sincos(float4x3 x, thread float4x3* y, threadgroup float4x3* z) {
>+    float sinResult;
>+    float cosResult;
>+    sincos(x[0][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][0] = sinResult;
>+    if (z != null)
>+        (*z)[0][0] = cosResult;
>+    sincos(x[0][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][1] = sinResult;
>+    if (z != null)
>+        (*z)[0][1] = cosResult;
>+    sincos(x[0][2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][2] = sinResult;
>+    if (z != null)
>+        (*z)[0][2] = cosResult;
>+    sincos(x[1][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][0] = sinResult;
>+    if (z != null)
>+        (*z)[1][0] = cosResult;
>+    sincos(x[1][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][1] = sinResult;
>+    if (z != null)
>+        (*z)[1][1] = cosResult;
>+    sincos(x[1][2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][2] = sinResult;
>+    if (z != null)
>+        (*z)[1][2] = cosResult;
>+    sincos(x[2][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2][0] = sinResult;
>+    if (z != null)
>+        (*z)[2][0] = cosResult;
>+    sincos(x[2][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2][1] = sinResult;
>+    if (z != null)
>+        (*z)[2][1] = cosResult;
>+    sincos(x[2][2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2][2] = sinResult;
>+    if (z != null)
>+        (*z)[2][2] = cosResult;
>+    sincos(x[3][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[3][0] = sinResult;
>+    if (z != null)
>+        (*z)[3][0] = cosResult;
>+    sincos(x[3][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[3][1] = sinResult;
>+    if (z != null)
>+        (*z)[3][1] = cosResult;
>+    sincos(x[3][2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[3][2] = sinResult;
>+    if (z != null)
>+        (*z)[3][2] = cosResult;
>+}
>+void sincos(float4x4 x, thread float4x4* y, threadgroup float4x4* z) {
>+    float sinResult;
>+    float cosResult;
>+    sincos(x[0][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][0] = sinResult;
>+    if (z != null)
>+        (*z)[0][0] = cosResult;
>+    sincos(x[0][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][1] = sinResult;
>+    if (z != null)
>+        (*z)[0][1] = cosResult;
>+    sincos(x[0][2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][2] = sinResult;
>+    if (z != null)
>+        (*z)[0][2] = cosResult;
>+    sincos(x[0][3], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][3] = sinResult;
>+    if (z != null)
>+        (*z)[0][3] = cosResult;
>+    sincos(x[1][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][0] = sinResult;
>+    if (z != null)
>+        (*z)[1][0] = cosResult;
>+    sincos(x[1][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][1] = sinResult;
>+    if (z != null)
>+        (*z)[1][1] = cosResult;
>+    sincos(x[1][2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][2] = sinResult;
>+    if (z != null)
>+        (*z)[1][2] = cosResult;
>+    sincos(x[1][3], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][3] = sinResult;
>+    if (z != null)
>+        (*z)[1][3] = cosResult;
>+    sincos(x[2][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2][0] = sinResult;
>+    if (z != null)
>+        (*z)[2][0] = cosResult;
>+    sincos(x[2][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2][1] = sinResult;
>+    if (z != null)
>+        (*z)[2][1] = cosResult;
>+    sincos(x[2][2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2][2] = sinResult;
>+    if (z != null)
>+        (*z)[2][2] = cosResult;
>+    sincos(x[2][3], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2][3] = sinResult;
>+    if (z != null)
>+        (*z)[2][3] = cosResult;
>+    sincos(x[3][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[3][0] = sinResult;
>+    if (z != null)
>+        (*z)[3][0] = cosResult;
>+    sincos(x[3][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[3][1] = sinResult;
>+    if (z != null)
>+        (*z)[3][1] = cosResult;
>+    sincos(x[3][2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[3][2] = sinResult;
>+    if (z != null)
>+        (*z)[3][2] = cosResult;
>+    sincos(x[3][3], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[3][3] = sinResult;
>+    if (z != null)
>+        (*z)[3][3] = cosResult;
>+}
>+void sincos(half x, device half* y, thread half* z) {
>+    if (y != null)
>+        *y = sin(x);
>+    if (z != null)
>+        *z = cos(x);
>+}
>+void sincos(half2 x, device half2* y, thread half2* z) {
>+    half sinResult;
>+    half cosResult;
>+    sincos(x[0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0] = sinResult;
>+    if (z != null)
>+        (*z)[0] = cosResult;
>+    sincos(x[1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1] = sinResult;
>+    if (z != null)
>+        (*z)[1] = cosResult;
>+}
>+void sincos(half3 x, device half3* y, thread half3* z) {
>+    half sinResult;
>+    half cosResult;
>+    sincos(x[0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0] = sinResult;
>+    if (z != null)
>+        (*z)[0] = cosResult;
>+    sincos(x[1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1] = sinResult;
>+    if (z != null)
>+        (*z)[1] = cosResult;
>+    sincos(x[2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2] = sinResult;
>+    if (z != null)
>+        (*z)[2] = cosResult;
>+}
>+void sincos(half4 x, device half4* y, thread half4* z) {
>+    half sinResult;
>+    half cosResult;
>+    sincos(x[0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0] = sinResult;
>+    if (z != null)
>+        (*z)[0] = cosResult;
>+    sincos(x[1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1] = sinResult;
>+    if (z != null)
>+        (*z)[1] = cosResult;
>+    sincos(x[2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2] = sinResult;
>+    if (z != null)
>+        (*z)[2] = cosResult;
>+    sincos(x[3], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[3] = sinResult;
>+    if (z != null)
>+        (*z)[3] = cosResult;
>+}
>+void sincos(half2x2 x, device half2x2* y, thread half2x2* z) {
>+    half sinResult;
>+    half cosResult;
>+    sincos(x[0][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][0] = sinResult;
>+    if (z != null)
>+        (*z)[0][0] = cosResult;
>+    sincos(x[0][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][1] = sinResult;
>+    if (z != null)
>+        (*z)[0][1] = cosResult;
>+    sincos(x[1][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][0] = sinResult;
>+    if (z != null)
>+        (*z)[1][0] = cosResult;
>+    sincos(x[1][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][1] = sinResult;
>+    if (z != null)
>+        (*z)[1][1] = cosResult;
>+}
>+void sincos(half2x3 x, device half2x3* y, thread half2x3* z) {
>+    half sinResult;
>+    half cosResult;
>+    sincos(x[0][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][0] = sinResult;
>+    if (z != null)
>+        (*z)[0][0] = cosResult;
>+    sincos(x[0][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][1] = sinResult;
>+    if (z != null)
>+        (*z)[0][1] = cosResult;
>+    sincos(x[0][2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][2] = sinResult;
>+    if (z != null)
>+        (*z)[0][2] = cosResult;
>+    sincos(x[1][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][0] = sinResult;
>+    if (z != null)
>+        (*z)[1][0] = cosResult;
>+    sincos(x[1][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][1] = sinResult;
>+    if (z != null)
>+        (*z)[1][1] = cosResult;
>+    sincos(x[1][2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][2] = sinResult;
>+    if (z != null)
>+        (*z)[1][2] = cosResult;
>+}
>+void sincos(half2x4 x, device half2x4* y, thread half2x4* z) {
>+    half sinResult;
>+    half cosResult;
>+    sincos(x[0][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][0] = sinResult;
>+    if (z != null)
>+        (*z)[0][0] = cosResult;
>+    sincos(x[0][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][1] = sinResult;
>+    if (z != null)
>+        (*z)[0][1] = cosResult;
>+    sincos(x[0][2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][2] = sinResult;
>+    if (z != null)
>+        (*z)[0][2] = cosResult;
>+    sincos(x[0][3], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][3] = sinResult;
>+    if (z != null)
>+        (*z)[0][3] = cosResult;
>+    sincos(x[1][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][0] = sinResult;
>+    if (z != null)
>+        (*z)[1][0] = cosResult;
>+    sincos(x[1][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][1] = sinResult;
>+    if (z != null)
>+        (*z)[1][1] = cosResult;
>+    sincos(x[1][2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][2] = sinResult;
>+    if (z != null)
>+        (*z)[1][2] = cosResult;
>+    sincos(x[1][3], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][3] = sinResult;
>+    if (z != null)
>+        (*z)[1][3] = cosResult;
>+}
>+void sincos(half3x2 x, device half3x2* y, thread half3x2* z) {
>+    half sinResult;
>+    half cosResult;
>+    sincos(x[0][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][0] = sinResult;
>+    if (z != null)
>+        (*z)[0][0] = cosResult;
>+    sincos(x[0][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][1] = sinResult;
>+    if (z != null)
>+        (*z)[0][1] = cosResult;
>+    sincos(x[1][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][0] = sinResult;
>+    if (z != null)
>+        (*z)[1][0] = cosResult;
>+    sincos(x[1][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][1] = sinResult;
>+    if (z != null)
>+        (*z)[1][1] = cosResult;
>+    sincos(x[2][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2][0] = sinResult;
>+    if (z != null)
>+        (*z)[2][0] = cosResult;
>+    sincos(x[2][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2][1] = sinResult;
>+    if (z != null)
>+        (*z)[2][1] = cosResult;
>+}
>+void sincos(half3x3 x, device half3x3* y, thread half3x3* z) {
>+    half sinResult;
>+    half cosResult;
>+    sincos(x[0][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][0] = sinResult;
>+    if (z != null)
>+        (*z)[0][0] = cosResult;
>+    sincos(x[0][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][1] = sinResult;
>+    if (z != null)
>+        (*z)[0][1] = cosResult;
>+    sincos(x[0][2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][2] = sinResult;
>+    if (z != null)
>+        (*z)[0][2] = cosResult;
>+    sincos(x[1][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][0] = sinResult;
>+    if (z != null)
>+        (*z)[1][0] = cosResult;
>+    sincos(x[1][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][1] = sinResult;
>+    if (z != null)
>+        (*z)[1][1] = cosResult;
>+    sincos(x[1][2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][2] = sinResult;
>+    if (z != null)
>+        (*z)[1][2] = cosResult;
>+    sincos(x[2][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2][0] = sinResult;
>+    if (z != null)
>+        (*z)[2][0] = cosResult;
>+    sincos(x[2][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2][1] = sinResult;
>+    if (z != null)
>+        (*z)[2][1] = cosResult;
>+    sincos(x[2][2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2][2] = sinResult;
>+    if (z != null)
>+        (*z)[2][2] = cosResult;
>+}
>+void sincos(half3x4 x, device half3x4* y, thread half3x4* z) {
>+    half sinResult;
>+    half cosResult;
>+    sincos(x[0][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][0] = sinResult;
>+    if (z != null)
>+        (*z)[0][0] = cosResult;
>+    sincos(x[0][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][1] = sinResult;
>+    if (z != null)
>+        (*z)[0][1] = cosResult;
>+    sincos(x[0][2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][2] = sinResult;
>+    if (z != null)
>+        (*z)[0][2] = cosResult;
>+    sincos(x[0][3], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][3] = sinResult;
>+    if (z != null)
>+        (*z)[0][3] = cosResult;
>+    sincos(x[1][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][0] = sinResult;
>+    if (z != null)
>+        (*z)[1][0] = cosResult;
>+    sincos(x[1][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][1] = sinResult;
>+    if (z != null)
>+        (*z)[1][1] = cosResult;
>+    sincos(x[1][2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][2] = sinResult;
>+    if (z != null)
>+        (*z)[1][2] = cosResult;
>+    sincos(x[1][3], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][3] = sinResult;
>+    if (z != null)
>+        (*z)[1][3] = cosResult;
>+    sincos(x[2][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2][0] = sinResult;
>+    if (z != null)
>+        (*z)[2][0] = cosResult;
>+    sincos(x[2][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2][1] = sinResult;
>+    if (z != null)
>+        (*z)[2][1] = cosResult;
>+    sincos(x[2][2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2][2] = sinResult;
>+    if (z != null)
>+        (*z)[2][2] = cosResult;
>+    sincos(x[2][3], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2][3] = sinResult;
>+    if (z != null)
>+        (*z)[2][3] = cosResult;
>+}
>+void sincos(half4x2 x, device half4x2* y, thread half4x2* z) {
>+    half sinResult;
>+    half cosResult;
>+    sincos(x[0][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][0] = sinResult;
>+    if (z != null)
>+        (*z)[0][0] = cosResult;
>+    sincos(x[0][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][1] = sinResult;
>+    if (z != null)
>+        (*z)[0][1] = cosResult;
>+    sincos(x[1][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][0] = sinResult;
>+    if (z != null)
>+        (*z)[1][0] = cosResult;
>+    sincos(x[1][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][1] = sinResult;
>+    if (z != null)
>+        (*z)[1][1] = cosResult;
>+    sincos(x[2][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2][0] = sinResult;
>+    if (z != null)
>+        (*z)[2][0] = cosResult;
>+    sincos(x[2][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2][1] = sinResult;
>+    if (z != null)
>+        (*z)[2][1] = cosResult;
>+    sincos(x[3][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[3][0] = sinResult;
>+    if (z != null)
>+        (*z)[3][0] = cosResult;
>+    sincos(x[3][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[3][1] = sinResult;
>+    if (z != null)
>+        (*z)[3][1] = cosResult;
>+}
>+void sincos(half4x3 x, device half4x3* y, thread half4x3* z) {
>+    half sinResult;
>+    half cosResult;
>+    sincos(x[0][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][0] = sinResult;
>+    if (z != null)
>+        (*z)[0][0] = cosResult;
>+    sincos(x[0][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][1] = sinResult;
>+    if (z != null)
>+        (*z)[0][1] = cosResult;
>+    sincos(x[0][2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][2] = sinResult;
>+    if (z != null)
>+        (*z)[0][2] = cosResult;
>+    sincos(x[1][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][0] = sinResult;
>+    if (z != null)
>+        (*z)[1][0] = cosResult;
>+    sincos(x[1][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][1] = sinResult;
>+    if (z != null)
>+        (*z)[1][1] = cosResult;
>+    sincos(x[1][2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][2] = sinResult;
>+    if (z != null)
>+        (*z)[1][2] = cosResult;
>+    sincos(x[2][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2][0] = sinResult;
>+    if (z != null)
>+        (*z)[2][0] = cosResult;
>+    sincos(x[2][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2][1] = sinResult;
>+    if (z != null)
>+        (*z)[2][1] = cosResult;
>+    sincos(x[2][2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2][2] = sinResult;
>+    if (z != null)
>+        (*z)[2][2] = cosResult;
>+    sincos(x[3][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[3][0] = sinResult;
>+    if (z != null)
>+        (*z)[3][0] = cosResult;
>+    sincos(x[3][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[3][1] = sinResult;
>+    if (z != null)
>+        (*z)[3][1] = cosResult;
>+    sincos(x[3][2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[3][2] = sinResult;
>+    if (z != null)
>+        (*z)[3][2] = cosResult;
>+}
>+void sincos(half4x4 x, device half4x4* y, thread half4x4* z) {
>+    half sinResult;
>+    half cosResult;
>+    sincos(x[0][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][0] = sinResult;
>+    if (z != null)
>+        (*z)[0][0] = cosResult;
>+    sincos(x[0][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][1] = sinResult;
>+    if (z != null)
>+        (*z)[0][1] = cosResult;
>+    sincos(x[0][2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][2] = sinResult;
>+    if (z != null)
>+        (*z)[0][2] = cosResult;
>+    sincos(x[0][3], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][3] = sinResult;
>+    if (z != null)
>+        (*z)[0][3] = cosResult;
>+    sincos(x[1][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][0] = sinResult;
>+    if (z != null)
>+        (*z)[1][0] = cosResult;
>+    sincos(x[1][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][1] = sinResult;
>+    if (z != null)
>+        (*z)[1][1] = cosResult;
>+    sincos(x[1][2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][2] = sinResult;
>+    if (z != null)
>+        (*z)[1][2] = cosResult;
>+    sincos(x[1][3], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][3] = sinResult;
>+    if (z != null)
>+        (*z)[1][3] = cosResult;
>+    sincos(x[2][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2][0] = sinResult;
>+    if (z != null)
>+        (*z)[2][0] = cosResult;
>+    sincos(x[2][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2][1] = sinResult;
>+    if (z != null)
>+        (*z)[2][1] = cosResult;
>+    sincos(x[2][2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2][2] = sinResult;
>+    if (z != null)
>+        (*z)[2][2] = cosResult;
>+    sincos(x[2][3], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2][3] = sinResult;
>+    if (z != null)
>+        (*z)[2][3] = cosResult;
>+    sincos(x[3][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[3][0] = sinResult;
>+    if (z != null)
>+        (*z)[3][0] = cosResult;
>+    sincos(x[3][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[3][1] = sinResult;
>+    if (z != null)
>+        (*z)[3][1] = cosResult;
>+    sincos(x[3][2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[3][2] = sinResult;
>+    if (z != null)
>+        (*z)[3][2] = cosResult;
>+    sincos(x[3][3], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[3][3] = sinResult;
>+    if (z != null)
>+        (*z)[3][3] = cosResult;
>+}
>+void sincos(float x, device float* y, thread float* z) {
>+    if (y != null)
>+        *y = sin(x);
>+    if (z != null)
>+        *z = cos(x);
>+}
>+void sincos(float2 x, device float2* y, thread float2* z) {
>+    float sinResult;
>+    float cosResult;
>+    sincos(x[0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0] = sinResult;
>+    if (z != null)
>+        (*z)[0] = cosResult;
>+    sincos(x[1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1] = sinResult;
>+    if (z != null)
>+        (*z)[1] = cosResult;
>+}
>+void sincos(float3 x, device float3* y, thread float3* z) {
>+    float sinResult;
>+    float cosResult;
>+    sincos(x[0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0] = sinResult;
>+    if (z != null)
>+        (*z)[0] = cosResult;
>+    sincos(x[1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1] = sinResult;
>+    if (z != null)
>+        (*z)[1] = cosResult;
>+    sincos(x[2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2] = sinResult;
>+    if (z != null)
>+        (*z)[2] = cosResult;
>+}
>+void sincos(float4 x, device float4* y, thread float4* z) {
>+    float sinResult;
>+    float cosResult;
>+    sincos(x[0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0] = sinResult;
>+    if (z != null)
>+        (*z)[0] = cosResult;
>+    sincos(x[1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1] = sinResult;
>+    if (z != null)
>+        (*z)[1] = cosResult;
>+    sincos(x[2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2] = sinResult;
>+    if (z != null)
>+        (*z)[2] = cosResult;
>+    sincos(x[3], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[3] = sinResult;
>+    if (z != null)
>+        (*z)[3] = cosResult;
>+}
>+void sincos(float2x2 x, device float2x2* y, thread float2x2* z) {
>+    float sinResult;
>+    float cosResult;
>+    sincos(x[0][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][0] = sinResult;
>+    if (z != null)
>+        (*z)[0][0] = cosResult;
>+    sincos(x[0][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][1] = sinResult;
>+    if (z != null)
>+        (*z)[0][1] = cosResult;
>+    sincos(x[1][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][0] = sinResult;
>+    if (z != null)
>+        (*z)[1][0] = cosResult;
>+    sincos(x[1][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][1] = sinResult;
>+    if (z != null)
>+        (*z)[1][1] = cosResult;
>+}
>+void sincos(float2x3 x, device float2x3* y, thread float2x3* z) {
>+    float sinResult;
>+    float cosResult;
>+    sincos(x[0][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][0] = sinResult;
>+    if (z != null)
>+        (*z)[0][0] = cosResult;
>+    sincos(x[0][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][1] = sinResult;
>+    if (z != null)
>+        (*z)[0][1] = cosResult;
>+    sincos(x[0][2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][2] = sinResult;
>+    if (z != null)
>+        (*z)[0][2] = cosResult;
>+    sincos(x[1][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][0] = sinResult;
>+    if (z != null)
>+        (*z)[1][0] = cosResult;
>+    sincos(x[1][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][1] = sinResult;
>+    if (z != null)
>+        (*z)[1][1] = cosResult;
>+    sincos(x[1][2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][2] = sinResult;
>+    if (z != null)
>+        (*z)[1][2] = cosResult;
>+}
>+void sincos(float2x4 x, device float2x4* y, thread float2x4* z) {
>+    float sinResult;
>+    float cosResult;
>+    sincos(x[0][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][0] = sinResult;
>+    if (z != null)
>+        (*z)[0][0] = cosResult;
>+    sincos(x[0][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][1] = sinResult;
>+    if (z != null)
>+        (*z)[0][1] = cosResult;
>+    sincos(x[0][2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][2] = sinResult;
>+    if (z != null)
>+        (*z)[0][2] = cosResult;
>+    sincos(x[0][3], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][3] = sinResult;
>+    if (z != null)
>+        (*z)[0][3] = cosResult;
>+    sincos(x[1][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][0] = sinResult;
>+    if (z != null)
>+        (*z)[1][0] = cosResult;
>+    sincos(x[1][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][1] = sinResult;
>+    if (z != null)
>+        (*z)[1][1] = cosResult;
>+    sincos(x[1][2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][2] = sinResult;
>+    if (z != null)
>+        (*z)[1][2] = cosResult;
>+    sincos(x[1][3], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][3] = sinResult;
>+    if (z != null)
>+        (*z)[1][3] = cosResult;
>+}
>+void sincos(float3x2 x, device float3x2* y, thread float3x2* z) {
>+    float sinResult;
>+    float cosResult;
>+    sincos(x[0][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][0] = sinResult;
>+    if (z != null)
>+        (*z)[0][0] = cosResult;
>+    sincos(x[0][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][1] = sinResult;
>+    if (z != null)
>+        (*z)[0][1] = cosResult;
>+    sincos(x[1][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][0] = sinResult;
>+    if (z != null)
>+        (*z)[1][0] = cosResult;
>+    sincos(x[1][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][1] = sinResult;
>+    if (z != null)
>+        (*z)[1][1] = cosResult;
>+    sincos(x[2][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2][0] = sinResult;
>+    if (z != null)
>+        (*z)[2][0] = cosResult;
>+    sincos(x[2][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2][1] = sinResult;
>+    if (z != null)
>+        (*z)[2][1] = cosResult;
>+}
>+void sincos(float3x3 x, device float3x3* y, thread float3x3* z) {
>+    float sinResult;
>+    float cosResult;
>+    sincos(x[0][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][0] = sinResult;
>+    if (z != null)
>+        (*z)[0][0] = cosResult;
>+    sincos(x[0][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][1] = sinResult;
>+    if (z != null)
>+        (*z)[0][1] = cosResult;
>+    sincos(x[0][2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][2] = sinResult;
>+    if (z != null)
>+        (*z)[0][2] = cosResult;
>+    sincos(x[1][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][0] = sinResult;
>+    if (z != null)
>+        (*z)[1][0] = cosResult;
>+    sincos(x[1][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][1] = sinResult;
>+    if (z != null)
>+        (*z)[1][1] = cosResult;
>+    sincos(x[1][2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][2] = sinResult;
>+    if (z != null)
>+        (*z)[1][2] = cosResult;
>+    sincos(x[2][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2][0] = sinResult;
>+    if (z != null)
>+        (*z)[2][0] = cosResult;
>+    sincos(x[2][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2][1] = sinResult;
>+    if (z != null)
>+        (*z)[2][1] = cosResult;
>+    sincos(x[2][2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2][2] = sinResult;
>+    if (z != null)
>+        (*z)[2][2] = cosResult;
>+}
>+void sincos(float3x4 x, device float3x4* y, thread float3x4* z) {
>+    float sinResult;
>+    float cosResult;
>+    sincos(x[0][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][0] = sinResult;
>+    if (z != null)
>+        (*z)[0][0] = cosResult;
>+    sincos(x[0][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][1] = sinResult;
>+    if (z != null)
>+        (*z)[0][1] = cosResult;
>+    sincos(x[0][2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][2] = sinResult;
>+    if (z != null)
>+        (*z)[0][2] = cosResult;
>+    sincos(x[0][3], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][3] = sinResult;
>+    if (z != null)
>+        (*z)[0][3] = cosResult;
>+    sincos(x[1][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][0] = sinResult;
>+    if (z != null)
>+        (*z)[1][0] = cosResult;
>+    sincos(x[1][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][1] = sinResult;
>+    if (z != null)
>+        (*z)[1][1] = cosResult;
>+    sincos(x[1][2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][2] = sinResult;
>+    if (z != null)
>+        (*z)[1][2] = cosResult;
>+    sincos(x[1][3], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][3] = sinResult;
>+    if (z != null)
>+        (*z)[1][3] = cosResult;
>+    sincos(x[2][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2][0] = sinResult;
>+    if (z != null)
>+        (*z)[2][0] = cosResult;
>+    sincos(x[2][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2][1] = sinResult;
>+    if (z != null)
>+        (*z)[2][1] = cosResult;
>+    sincos(x[2][2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2][2] = sinResult;
>+    if (z != null)
>+        (*z)[2][2] = cosResult;
>+    sincos(x[2][3], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2][3] = sinResult;
>+    if (z != null)
>+        (*z)[2][3] = cosResult;
>+}
>+void sincos(float4x2 x, device float4x2* y, thread float4x2* z) {
>+    float sinResult;
>+    float cosResult;
>+    sincos(x[0][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][0] = sinResult;
>+    if (z != null)
>+        (*z)[0][0] = cosResult;
>+    sincos(x[0][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][1] = sinResult;
>+    if (z != null)
>+        (*z)[0][1] = cosResult;
>+    sincos(x[1][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][0] = sinResult;
>+    if (z != null)
>+        (*z)[1][0] = cosResult;
>+    sincos(x[1][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][1] = sinResult;
>+    if (z != null)
>+        (*z)[1][1] = cosResult;
>+    sincos(x[2][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2][0] = sinResult;
>+    if (z != null)
>+        (*z)[2][0] = cosResult;
>+    sincos(x[2][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2][1] = sinResult;
>+    if (z != null)
>+        (*z)[2][1] = cosResult;
>+    sincos(x[3][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[3][0] = sinResult;
>+    if (z != null)
>+        (*z)[3][0] = cosResult;
>+    sincos(x[3][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[3][1] = sinResult;
>+    if (z != null)
>+        (*z)[3][1] = cosResult;
>+}
>+void sincos(float4x3 x, device float4x3* y, thread float4x3* z) {
>+    float sinResult;
>+    float cosResult;
>+    sincos(x[0][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][0] = sinResult;
>+    if (z != null)
>+        (*z)[0][0] = cosResult;
>+    sincos(x[0][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][1] = sinResult;
>+    if (z != null)
>+        (*z)[0][1] = cosResult;
>+    sincos(x[0][2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][2] = sinResult;
>+    if (z != null)
>+        (*z)[0][2] = cosResult;
>+    sincos(x[1][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][0] = sinResult;
>+    if (z != null)
>+        (*z)[1][0] = cosResult;
>+    sincos(x[1][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][1] = sinResult;
>+    if (z != null)
>+        (*z)[1][1] = cosResult;
>+    sincos(x[1][2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][2] = sinResult;
>+    if (z != null)
>+        (*z)[1][2] = cosResult;
>+    sincos(x[2][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2][0] = sinResult;
>+    if (z != null)
>+        (*z)[2][0] = cosResult;
>+    sincos(x[2][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2][1] = sinResult;
>+    if (z != null)
>+        (*z)[2][1] = cosResult;
>+    sincos(x[2][2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2][2] = sinResult;
>+    if (z != null)
>+        (*z)[2][2] = cosResult;
>+    sincos(x[3][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[3][0] = sinResult;
>+    if (z != null)
>+        (*z)[3][0] = cosResult;
>+    sincos(x[3][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[3][1] = sinResult;
>+    if (z != null)
>+        (*z)[3][1] = cosResult;
>+    sincos(x[3][2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[3][2] = sinResult;
>+    if (z != null)
>+        (*z)[3][2] = cosResult;
>+}
>+void sincos(float4x4 x, device float4x4* y, thread float4x4* z) {
>+    float sinResult;
>+    float cosResult;
>+    sincos(x[0][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][0] = sinResult;
>+    if (z != null)
>+        (*z)[0][0] = cosResult;
>+    sincos(x[0][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][1] = sinResult;
>+    if (z != null)
>+        (*z)[0][1] = cosResult;
>+    sincos(x[0][2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][2] = sinResult;
>+    if (z != null)
>+        (*z)[0][2] = cosResult;
>+    sincos(x[0][3], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][3] = sinResult;
>+    if (z != null)
>+        (*z)[0][3] = cosResult;
>+    sincos(x[1][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][0] = sinResult;
>+    if (z != null)
>+        (*z)[1][0] = cosResult;
>+    sincos(x[1][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][1] = sinResult;
>+    if (z != null)
>+        (*z)[1][1] = cosResult;
>+    sincos(x[1][2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][2] = sinResult;
>+    if (z != null)
>+        (*z)[1][2] = cosResult;
>+    sincos(x[1][3], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][3] = sinResult;
>+    if (z != null)
>+        (*z)[1][3] = cosResult;
>+    sincos(x[2][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2][0] = sinResult;
>+    if (z != null)
>+        (*z)[2][0] = cosResult;
>+    sincos(x[2][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2][1] = sinResult;
>+    if (z != null)
>+        (*z)[2][1] = cosResult;
>+    sincos(x[2][2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2][2] = sinResult;
>+    if (z != null)
>+        (*z)[2][2] = cosResult;
>+    sincos(x[2][3], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2][3] = sinResult;
>+    if (z != null)
>+        (*z)[2][3] = cosResult;
>+    sincos(x[3][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[3][0] = sinResult;
>+    if (z != null)
>+        (*z)[3][0] = cosResult;
>+    sincos(x[3][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[3][1] = sinResult;
>+    if (z != null)
>+        (*z)[3][1] = cosResult;
>+    sincos(x[3][2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[3][2] = sinResult;
>+    if (z != null)
>+        (*z)[3][2] = cosResult;
>+    sincos(x[3][3], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[3][3] = sinResult;
>+    if (z != null)
>+        (*z)[3][3] = cosResult;
>+}
>+void sincos(half x, device half* y, device half* z) {
>+    if (y != null)
>+        *y = sin(x);
>+    if (z != null)
>+        *z = cos(x);
>+}
>+void sincos(half2 x, device half2* y, device half2* z) {
>+    half sinResult;
>+    half cosResult;
>+    sincos(x[0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0] = sinResult;
>+    if (z != null)
>+        (*z)[0] = cosResult;
>+    sincos(x[1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1] = sinResult;
>+    if (z != null)
>+        (*z)[1] = cosResult;
>+}
>+void sincos(half3 x, device half3* y, device half3* z) {
>+    half sinResult;
>+    half cosResult;
>+    sincos(x[0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0] = sinResult;
>+    if (z != null)
>+        (*z)[0] = cosResult;
>+    sincos(x[1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1] = sinResult;
>+    if (z != null)
>+        (*z)[1] = cosResult;
>+    sincos(x[2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2] = sinResult;
>+    if (z != null)
>+        (*z)[2] = cosResult;
>+}
>+void sincos(half4 x, device half4* y, device half4* z) {
>+    half sinResult;
>+    half cosResult;
>+    sincos(x[0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0] = sinResult;
>+    if (z != null)
>+        (*z)[0] = cosResult;
>+    sincos(x[1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1] = sinResult;
>+    if (z != null)
>+        (*z)[1] = cosResult;
>+    sincos(x[2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2] = sinResult;
>+    if (z != null)
>+        (*z)[2] = cosResult;
>+    sincos(x[3], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[3] = sinResult;
>+    if (z != null)
>+        (*z)[3] = cosResult;
>+}
>+void sincos(half2x2 x, device half2x2* y, device half2x2* z) {
>+    half sinResult;
>+    half cosResult;
>+    sincos(x[0][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][0] = sinResult;
>+    if (z != null)
>+        (*z)[0][0] = cosResult;
>+    sincos(x[0][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][1] = sinResult;
>+    if (z != null)
>+        (*z)[0][1] = cosResult;
>+    sincos(x[1][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][0] = sinResult;
>+    if (z != null)
>+        (*z)[1][0] = cosResult;
>+    sincos(x[1][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][1] = sinResult;
>+    if (z != null)
>+        (*z)[1][1] = cosResult;
>+}
>+void sincos(half2x3 x, device half2x3* y, device half2x3* z) {
>+    half sinResult;
>+    half cosResult;
>+    sincos(x[0][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][0] = sinResult;
>+    if (z != null)
>+        (*z)[0][0] = cosResult;
>+    sincos(x[0][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][1] = sinResult;
>+    if (z != null)
>+        (*z)[0][1] = cosResult;
>+    sincos(x[0][2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][2] = sinResult;
>+    if (z != null)
>+        (*z)[0][2] = cosResult;
>+    sincos(x[1][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][0] = sinResult;
>+    if (z != null)
>+        (*z)[1][0] = cosResult;
>+    sincos(x[1][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][1] = sinResult;
>+    if (z != null)
>+        (*z)[1][1] = cosResult;
>+    sincos(x[1][2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][2] = sinResult;
>+    if (z != null)
>+        (*z)[1][2] = cosResult;
>+}
>+void sincos(half2x4 x, device half2x4* y, device half2x4* z) {
>+    half sinResult;
>+    half cosResult;
>+    sincos(x[0][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][0] = sinResult;
>+    if (z != null)
>+        (*z)[0][0] = cosResult;
>+    sincos(x[0][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][1] = sinResult;
>+    if (z != null)
>+        (*z)[0][1] = cosResult;
>+    sincos(x[0][2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][2] = sinResult;
>+    if (z != null)
>+        (*z)[0][2] = cosResult;
>+    sincos(x[0][3], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][3] = sinResult;
>+    if (z != null)
>+        (*z)[0][3] = cosResult;
>+    sincos(x[1][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][0] = sinResult;
>+    if (z != null)
>+        (*z)[1][0] = cosResult;
>+    sincos(x[1][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][1] = sinResult;
>+    if (z != null)
>+        (*z)[1][1] = cosResult;
>+    sincos(x[1][2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][2] = sinResult;
>+    if (z != null)
>+        (*z)[1][2] = cosResult;
>+    sincos(x[1][3], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][3] = sinResult;
>+    if (z != null)
>+        (*z)[1][3] = cosResult;
>+}
>+void sincos(half3x2 x, device half3x2* y, device half3x2* z) {
>+    half sinResult;
>+    half cosResult;
>+    sincos(x[0][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][0] = sinResult;
>+    if (z != null)
>+        (*z)[0][0] = cosResult;
>+    sincos(x[0][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][1] = sinResult;
>+    if (z != null)
>+        (*z)[0][1] = cosResult;
>+    sincos(x[1][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][0] = sinResult;
>+    if (z != null)
>+        (*z)[1][0] = cosResult;
>+    sincos(x[1][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][1] = sinResult;
>+    if (z != null)
>+        (*z)[1][1] = cosResult;
>+    sincos(x[2][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2][0] = sinResult;
>+    if (z != null)
>+        (*z)[2][0] = cosResult;
>+    sincos(x[2][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2][1] = sinResult;
>+    if (z != null)
>+        (*z)[2][1] = cosResult;
>+}
>+void sincos(half3x3 x, device half3x3* y, device half3x3* z) {
>+    half sinResult;
>+    half cosResult;
>+    sincos(x[0][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][0] = sinResult;
>+    if (z != null)
>+        (*z)[0][0] = cosResult;
>+    sincos(x[0][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][1] = sinResult;
>+    if (z != null)
>+        (*z)[0][1] = cosResult;
>+    sincos(x[0][2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][2] = sinResult;
>+    if (z != null)
>+        (*z)[0][2] = cosResult;
>+    sincos(x[1][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][0] = sinResult;
>+    if (z != null)
>+        (*z)[1][0] = cosResult;
>+    sincos(x[1][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][1] = sinResult;
>+    if (z != null)
>+        (*z)[1][1] = cosResult;
>+    sincos(x[1][2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][2] = sinResult;
>+    if (z != null)
>+        (*z)[1][2] = cosResult;
>+    sincos(x[2][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2][0] = sinResult;
>+    if (z != null)
>+        (*z)[2][0] = cosResult;
>+    sincos(x[2][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2][1] = sinResult;
>+    if (z != null)
>+        (*z)[2][1] = cosResult;
>+    sincos(x[2][2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2][2] = sinResult;
>+    if (z != null)
>+        (*z)[2][2] = cosResult;
>+}
>+void sincos(half3x4 x, device half3x4* y, device half3x4* z) {
>+    half sinResult;
>+    half cosResult;
>+    sincos(x[0][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][0] = sinResult;
>+    if (z != null)
>+        (*z)[0][0] = cosResult;
>+    sincos(x[0][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][1] = sinResult;
>+    if (z != null)
>+        (*z)[0][1] = cosResult;
>+    sincos(x[0][2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][2] = sinResult;
>+    if (z != null)
>+        (*z)[0][2] = cosResult;
>+    sincos(x[0][3], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][3] = sinResult;
>+    if (z != null)
>+        (*z)[0][3] = cosResult;
>+    sincos(x[1][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][0] = sinResult;
>+    if (z != null)
>+        (*z)[1][0] = cosResult;
>+    sincos(x[1][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][1] = sinResult;
>+    if (z != null)
>+        (*z)[1][1] = cosResult;
>+    sincos(x[1][2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][2] = sinResult;
>+    if (z != null)
>+        (*z)[1][2] = cosResult;
>+    sincos(x[1][3], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][3] = sinResult;
>+    if (z != null)
>+        (*z)[1][3] = cosResult;
>+    sincos(x[2][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2][0] = sinResult;
>+    if (z != null)
>+        (*z)[2][0] = cosResult;
>+    sincos(x[2][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2][1] = sinResult;
>+    if (z != null)
>+        (*z)[2][1] = cosResult;
>+    sincos(x[2][2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2][2] = sinResult;
>+    if (z != null)
>+        (*z)[2][2] = cosResult;
>+    sincos(x[2][3], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2][3] = sinResult;
>+    if (z != null)
>+        (*z)[2][3] = cosResult;
>+}
>+void sincos(half4x2 x, device half4x2* y, device half4x2* z) {
>+    half sinResult;
>+    half cosResult;
>+    sincos(x[0][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][0] = sinResult;
>+    if (z != null)
>+        (*z)[0][0] = cosResult;
>+    sincos(x[0][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][1] = sinResult;
>+    if (z != null)
>+        (*z)[0][1] = cosResult;
>+    sincos(x[1][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][0] = sinResult;
>+    if (z != null)
>+        (*z)[1][0] = cosResult;
>+    sincos(x[1][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][1] = sinResult;
>+    if (z != null)
>+        (*z)[1][1] = cosResult;
>+    sincos(x[2][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2][0] = sinResult;
>+    if (z != null)
>+        (*z)[2][0] = cosResult;
>+    sincos(x[2][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2][1] = sinResult;
>+    if (z != null)
>+        (*z)[2][1] = cosResult;
>+    sincos(x[3][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[3][0] = sinResult;
>+    if (z != null)
>+        (*z)[3][0] = cosResult;
>+    sincos(x[3][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[3][1] = sinResult;
>+    if (z != null)
>+        (*z)[3][1] = cosResult;
>+}
>+void sincos(half4x3 x, device half4x3* y, device half4x3* z) {
>+    half sinResult;
>+    half cosResult;
>+    sincos(x[0][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][0] = sinResult;
>+    if (z != null)
>+        (*z)[0][0] = cosResult;
>+    sincos(x[0][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][1] = sinResult;
>+    if (z != null)
>+        (*z)[0][1] = cosResult;
>+    sincos(x[0][2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][2] = sinResult;
>+    if (z != null)
>+        (*z)[0][2] = cosResult;
>+    sincos(x[1][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][0] = sinResult;
>+    if (z != null)
>+        (*z)[1][0] = cosResult;
>+    sincos(x[1][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][1] = sinResult;
>+    if (z != null)
>+        (*z)[1][1] = cosResult;
>+    sincos(x[1][2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][2] = sinResult;
>+    if (z != null)
>+        (*z)[1][2] = cosResult;
>+    sincos(x[2][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2][0] = sinResult;
>+    if (z != null)
>+        (*z)[2][0] = cosResult;
>+    sincos(x[2][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2][1] = sinResult;
>+    if (z != null)
>+        (*z)[2][1] = cosResult;
>+    sincos(x[2][2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2][2] = sinResult;
>+    if (z != null)
>+        (*z)[2][2] = cosResult;
>+    sincos(x[3][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[3][0] = sinResult;
>+    if (z != null)
>+        (*z)[3][0] = cosResult;
>+    sincos(x[3][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[3][1] = sinResult;
>+    if (z != null)
>+        (*z)[3][1] = cosResult;
>+    sincos(x[3][2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[3][2] = sinResult;
>+    if (z != null)
>+        (*z)[3][2] = cosResult;
>+}
>+void sincos(half4x4 x, device half4x4* y, device half4x4* z) {
>+    half sinResult;
>+    half cosResult;
>+    sincos(x[0][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][0] = sinResult;
>+    if (z != null)
>+        (*z)[0][0] = cosResult;
>+    sincos(x[0][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][1] = sinResult;
>+    if (z != null)
>+        (*z)[0][1] = cosResult;
>+    sincos(x[0][2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][2] = sinResult;
>+    if (z != null)
>+        (*z)[0][2] = cosResult;
>+    sincos(x[0][3], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][3] = sinResult;
>+    if (z != null)
>+        (*z)[0][3] = cosResult;
>+    sincos(x[1][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][0] = sinResult;
>+    if (z != null)
>+        (*z)[1][0] = cosResult;
>+    sincos(x[1][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][1] = sinResult;
>+    if (z != null)
>+        (*z)[1][1] = cosResult;
>+    sincos(x[1][2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][2] = sinResult;
>+    if (z != null)
>+        (*z)[1][2] = cosResult;
>+    sincos(x[1][3], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][3] = sinResult;
>+    if (z != null)
>+        (*z)[1][3] = cosResult;
>+    sincos(x[2][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2][0] = sinResult;
>+    if (z != null)
>+        (*z)[2][0] = cosResult;
>+    sincos(x[2][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2][1] = sinResult;
>+    if (z != null)
>+        (*z)[2][1] = cosResult;
>+    sincos(x[2][2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2][2] = sinResult;
>+    if (z != null)
>+        (*z)[2][2] = cosResult;
>+    sincos(x[2][3], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2][3] = sinResult;
>+    if (z != null)
>+        (*z)[2][3] = cosResult;
>+    sincos(x[3][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[3][0] = sinResult;
>+    if (z != null)
>+        (*z)[3][0] = cosResult;
>+    sincos(x[3][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[3][1] = sinResult;
>+    if (z != null)
>+        (*z)[3][1] = cosResult;
>+    sincos(x[3][2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[3][2] = sinResult;
>+    if (z != null)
>+        (*z)[3][2] = cosResult;
>+    sincos(x[3][3], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[3][3] = sinResult;
>+    if (z != null)
>+        (*z)[3][3] = cosResult;
>+}
>+void sincos(float x, device float* y, device float* z) {
>+    if (y != null)
>+        *y = sin(x);
>+    if (z != null)
>+        *z = cos(x);
>+}
>+void sincos(float2 x, device float2* y, device float2* z) {
>+    float sinResult;
>+    float cosResult;
>+    sincos(x[0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0] = sinResult;
>+    if (z != null)
>+        (*z)[0] = cosResult;
>+    sincos(x[1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1] = sinResult;
>+    if (z != null)
>+        (*z)[1] = cosResult;
>+}
>+void sincos(float3 x, device float3* y, device float3* z) {
>+    float sinResult;
>+    float cosResult;
>+    sincos(x[0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0] = sinResult;
>+    if (z != null)
>+        (*z)[0] = cosResult;
>+    sincos(x[1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1] = sinResult;
>+    if (z != null)
>+        (*z)[1] = cosResult;
>+    sincos(x[2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2] = sinResult;
>+    if (z != null)
>+        (*z)[2] = cosResult;
>+}
>+void sincos(float4 x, device float4* y, device float4* z) {
>+    float sinResult;
>+    float cosResult;
>+    sincos(x[0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0] = sinResult;
>+    if (z != null)
>+        (*z)[0] = cosResult;
>+    sincos(x[1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1] = sinResult;
>+    if (z != null)
>+        (*z)[1] = cosResult;
>+    sincos(x[2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2] = sinResult;
>+    if (z != null)
>+        (*z)[2] = cosResult;
>+    sincos(x[3], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[3] = sinResult;
>+    if (z != null)
>+        (*z)[3] = cosResult;
>+}
>+void sincos(float2x2 x, device float2x2* y, device float2x2* z) {
>+    float sinResult;
>+    float cosResult;
>+    sincos(x[0][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][0] = sinResult;
>+    if (z != null)
>+        (*z)[0][0] = cosResult;
>+    sincos(x[0][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][1] = sinResult;
>+    if (z != null)
>+        (*z)[0][1] = cosResult;
>+    sincos(x[1][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][0] = sinResult;
>+    if (z != null)
>+        (*z)[1][0] = cosResult;
>+    sincos(x[1][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][1] = sinResult;
>+    if (z != null)
>+        (*z)[1][1] = cosResult;
>+}
>+void sincos(float2x3 x, device float2x3* y, device float2x3* z) {
>+    float sinResult;
>+    float cosResult;
>+    sincos(x[0][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][0] = sinResult;
>+    if (z != null)
>+        (*z)[0][0] = cosResult;
>+    sincos(x[0][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][1] = sinResult;
>+    if (z != null)
>+        (*z)[0][1] = cosResult;
>+    sincos(x[0][2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][2] = sinResult;
>+    if (z != null)
>+        (*z)[0][2] = cosResult;
>+    sincos(x[1][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][0] = sinResult;
>+    if (z != null)
>+        (*z)[1][0] = cosResult;
>+    sincos(x[1][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][1] = sinResult;
>+    if (z != null)
>+        (*z)[1][1] = cosResult;
>+    sincos(x[1][2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][2] = sinResult;
>+    if (z != null)
>+        (*z)[1][2] = cosResult;
>+}
>+void sincos(float2x4 x, device float2x4* y, device float2x4* z) {
>+    float sinResult;
>+    float cosResult;
>+    sincos(x[0][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][0] = sinResult;
>+    if (z != null)
>+        (*z)[0][0] = cosResult;
>+    sincos(x[0][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][1] = sinResult;
>+    if (z != null)
>+        (*z)[0][1] = cosResult;
>+    sincos(x[0][2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][2] = sinResult;
>+    if (z != null)
>+        (*z)[0][2] = cosResult;
>+    sincos(x[0][3], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][3] = sinResult;
>+    if (z != null)
>+        (*z)[0][3] = cosResult;
>+    sincos(x[1][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][0] = sinResult;
>+    if (z != null)
>+        (*z)[1][0] = cosResult;
>+    sincos(x[1][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][1] = sinResult;
>+    if (z != null)
>+        (*z)[1][1] = cosResult;
>+    sincos(x[1][2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][2] = sinResult;
>+    if (z != null)
>+        (*z)[1][2] = cosResult;
>+    sincos(x[1][3], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][3] = sinResult;
>+    if (z != null)
>+        (*z)[1][3] = cosResult;
>+}
>+void sincos(float3x2 x, device float3x2* y, device float3x2* z) {
>+    float sinResult;
>+    float cosResult;
>+    sincos(x[0][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][0] = sinResult;
>+    if (z != null)
>+        (*z)[0][0] = cosResult;
>+    sincos(x[0][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][1] = sinResult;
>+    if (z != null)
>+        (*z)[0][1] = cosResult;
>+    sincos(x[1][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][0] = sinResult;
>+    if (z != null)
>+        (*z)[1][0] = cosResult;
>+    sincos(x[1][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][1] = sinResult;
>+    if (z != null)
>+        (*z)[1][1] = cosResult;
>+    sincos(x[2][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2][0] = sinResult;
>+    if (z != null)
>+        (*z)[2][0] = cosResult;
>+    sincos(x[2][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2][1] = sinResult;
>+    if (z != null)
>+        (*z)[2][1] = cosResult;
>+}
>+void sincos(float3x3 x, device float3x3* y, device float3x3* z) {
>+    float sinResult;
>+    float cosResult;
>+    sincos(x[0][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][0] = sinResult;
>+    if (z != null)
>+        (*z)[0][0] = cosResult;
>+    sincos(x[0][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][1] = sinResult;
>+    if (z != null)
>+        (*z)[0][1] = cosResult;
>+    sincos(x[0][2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][2] = sinResult;
>+    if (z != null)
>+        (*z)[0][2] = cosResult;
>+    sincos(x[1][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][0] = sinResult;
>+    if (z != null)
>+        (*z)[1][0] = cosResult;
>+    sincos(x[1][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][1] = sinResult;
>+    if (z != null)
>+        (*z)[1][1] = cosResult;
>+    sincos(x[1][2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][2] = sinResult;
>+    if (z != null)
>+        (*z)[1][2] = cosResult;
>+    sincos(x[2][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2][0] = sinResult;
>+    if (z != null)
>+        (*z)[2][0] = cosResult;
>+    sincos(x[2][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2][1] = sinResult;
>+    if (z != null)
>+        (*z)[2][1] = cosResult;
>+    sincos(x[2][2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2][2] = sinResult;
>+    if (z != null)
>+        (*z)[2][2] = cosResult;
>+}
>+void sincos(float3x4 x, device float3x4* y, device float3x4* z) {
>+    float sinResult;
>+    float cosResult;
>+    sincos(x[0][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][0] = sinResult;
>+    if (z != null)
>+        (*z)[0][0] = cosResult;
>+    sincos(x[0][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][1] = sinResult;
>+    if (z != null)
>+        (*z)[0][1] = cosResult;
>+    sincos(x[0][2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][2] = sinResult;
>+    if (z != null)
>+        (*z)[0][2] = cosResult;
>+    sincos(x[0][3], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][3] = sinResult;
>+    if (z != null)
>+        (*z)[0][3] = cosResult;
>+    sincos(x[1][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][0] = sinResult;
>+    if (z != null)
>+        (*z)[1][0] = cosResult;
>+    sincos(x[1][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][1] = sinResult;
>+    if (z != null)
>+        (*z)[1][1] = cosResult;
>+    sincos(x[1][2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][2] = sinResult;
>+    if (z != null)
>+        (*z)[1][2] = cosResult;
>+    sincos(x[1][3], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][3] = sinResult;
>+    if (z != null)
>+        (*z)[1][3] = cosResult;
>+    sincos(x[2][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2][0] = sinResult;
>+    if (z != null)
>+        (*z)[2][0] = cosResult;
>+    sincos(x[2][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2][1] = sinResult;
>+    if (z != null)
>+        (*z)[2][1] = cosResult;
>+    sincos(x[2][2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2][2] = sinResult;
>+    if (z != null)
>+        (*z)[2][2] = cosResult;
>+    sincos(x[2][3], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2][3] = sinResult;
>+    if (z != null)
>+        (*z)[2][3] = cosResult;
>+}
>+void sincos(float4x2 x, device float4x2* y, device float4x2* z) {
>+    float sinResult;
>+    float cosResult;
>+    sincos(x[0][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][0] = sinResult;
>+    if (z != null)
>+        (*z)[0][0] = cosResult;
>+    sincos(x[0][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][1] = sinResult;
>+    if (z != null)
>+        (*z)[0][1] = cosResult;
>+    sincos(x[1][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][0] = sinResult;
>+    if (z != null)
>+        (*z)[1][0] = cosResult;
>+    sincos(x[1][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][1] = sinResult;
>+    if (z != null)
>+        (*z)[1][1] = cosResult;
>+    sincos(x[2][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2][0] = sinResult;
>+    if (z != null)
>+        (*z)[2][0] = cosResult;
>+    sincos(x[2][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2][1] = sinResult;
>+    if (z != null)
>+        (*z)[2][1] = cosResult;
>+    sincos(x[3][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[3][0] = sinResult;
>+    if (z != null)
>+        (*z)[3][0] = cosResult;
>+    sincos(x[3][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[3][1] = sinResult;
>+    if (z != null)
>+        (*z)[3][1] = cosResult;
>+}
>+void sincos(float4x3 x, device float4x3* y, device float4x3* z) {
>+    float sinResult;
>+    float cosResult;
>+    sincos(x[0][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][0] = sinResult;
>+    if (z != null)
>+        (*z)[0][0] = cosResult;
>+    sincos(x[0][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][1] = sinResult;
>+    if (z != null)
>+        (*z)[0][1] = cosResult;
>+    sincos(x[0][2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][2] = sinResult;
>+    if (z != null)
>+        (*z)[0][2] = cosResult;
>+    sincos(x[1][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][0] = sinResult;
>+    if (z != null)
>+        (*z)[1][0] = cosResult;
>+    sincos(x[1][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][1] = sinResult;
>+    if (z != null)
>+        (*z)[1][1] = cosResult;
>+    sincos(x[1][2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][2] = sinResult;
>+    if (z != null)
>+        (*z)[1][2] = cosResult;
>+    sincos(x[2][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2][0] = sinResult;
>+    if (z != null)
>+        (*z)[2][0] = cosResult;
>+    sincos(x[2][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2][1] = sinResult;
>+    if (z != null)
>+        (*z)[2][1] = cosResult;
>+    sincos(x[2][2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2][2] = sinResult;
>+    if (z != null)
>+        (*z)[2][2] = cosResult;
>+    sincos(x[3][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[3][0] = sinResult;
>+    if (z != null)
>+        (*z)[3][0] = cosResult;
>+    sincos(x[3][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[3][1] = sinResult;
>+    if (z != null)
>+        (*z)[3][1] = cosResult;
>+    sincos(x[3][2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[3][2] = sinResult;
>+    if (z != null)
>+        (*z)[3][2] = cosResult;
>+}
>+void sincos(float4x4 x, device float4x4* y, device float4x4* z) {
>+    float sinResult;
>+    float cosResult;
>+    sincos(x[0][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][0] = sinResult;
>+    if (z != null)
>+        (*z)[0][0] = cosResult;
>+    sincos(x[0][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][1] = sinResult;
>+    if (z != null)
>+        (*z)[0][1] = cosResult;
>+    sincos(x[0][2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][2] = sinResult;
>+    if (z != null)
>+        (*z)[0][2] = cosResult;
>+    sincos(x[0][3], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][3] = sinResult;
>+    if (z != null)
>+        (*z)[0][3] = cosResult;
>+    sincos(x[1][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][0] = sinResult;
>+    if (z != null)
>+        (*z)[1][0] = cosResult;
>+    sincos(x[1][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][1] = sinResult;
>+    if (z != null)
>+        (*z)[1][1] = cosResult;
>+    sincos(x[1][2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][2] = sinResult;
>+    if (z != null)
>+        (*z)[1][2] = cosResult;
>+    sincos(x[1][3], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][3] = sinResult;
>+    if (z != null)
>+        (*z)[1][3] = cosResult;
>+    sincos(x[2][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2][0] = sinResult;
>+    if (z != null)
>+        (*z)[2][0] = cosResult;
>+    sincos(x[2][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2][1] = sinResult;
>+    if (z != null)
>+        (*z)[2][1] = cosResult;
>+    sincos(x[2][2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2][2] = sinResult;
>+    if (z != null)
>+        (*z)[2][2] = cosResult;
>+    sincos(x[2][3], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2][3] = sinResult;
>+    if (z != null)
>+        (*z)[2][3] = cosResult;
>+    sincos(x[3][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[3][0] = sinResult;
>+    if (z != null)
>+        (*z)[3][0] = cosResult;
>+    sincos(x[3][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[3][1] = sinResult;
>+    if (z != null)
>+        (*z)[3][1] = cosResult;
>+    sincos(x[3][2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[3][2] = sinResult;
>+    if (z != null)
>+        (*z)[3][2] = cosResult;
>+    sincos(x[3][3], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[3][3] = sinResult;
>+    if (z != null)
>+        (*z)[3][3] = cosResult;
>+}
>+void sincos(half x, device half* y, threadgroup half* z) {
>+    if (y != null)
>+        *y = sin(x);
>+    if (z != null)
>+        *z = cos(x);
>+}
>+void sincos(half2 x, device half2* y, threadgroup half2* z) {
>+    half sinResult;
>+    half cosResult;
>+    sincos(x[0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0] = sinResult;
>+    if (z != null)
>+        (*z)[0] = cosResult;
>+    sincos(x[1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1] = sinResult;
>+    if (z != null)
>+        (*z)[1] = cosResult;
>+}
>+void sincos(half3 x, device half3* y, threadgroup half3* z) {
>+    half sinResult;
>+    half cosResult;
>+    sincos(x[0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0] = sinResult;
>+    if (z != null)
>+        (*z)[0] = cosResult;
>+    sincos(x[1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1] = sinResult;
>+    if (z != null)
>+        (*z)[1] = cosResult;
>+    sincos(x[2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2] = sinResult;
>+    if (z != null)
>+        (*z)[2] = cosResult;
>+}
>+void sincos(half4 x, device half4* y, threadgroup half4* z) {
>+    half sinResult;
>+    half cosResult;
>+    sincos(x[0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0] = sinResult;
>+    if (z != null)
>+        (*z)[0] = cosResult;
>+    sincos(x[1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1] = sinResult;
>+    if (z != null)
>+        (*z)[1] = cosResult;
>+    sincos(x[2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2] = sinResult;
>+    if (z != null)
>+        (*z)[2] = cosResult;
>+    sincos(x[3], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[3] = sinResult;
>+    if (z != null)
>+        (*z)[3] = cosResult;
>+}
>+void sincos(half2x2 x, device half2x2* y, threadgroup half2x2* z) {
>+    half sinResult;
>+    half cosResult;
>+    sincos(x[0][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][0] = sinResult;
>+    if (z != null)
>+        (*z)[0][0] = cosResult;
>+    sincos(x[0][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][1] = sinResult;
>+    if (z != null)
>+        (*z)[0][1] = cosResult;
>+    sincos(x[1][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][0] = sinResult;
>+    if (z != null)
>+        (*z)[1][0] = cosResult;
>+    sincos(x[1][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][1] = sinResult;
>+    if (z != null)
>+        (*z)[1][1] = cosResult;
>+}
>+void sincos(half2x3 x, device half2x3* y, threadgroup half2x3* z) {
>+    half sinResult;
>+    half cosResult;
>+    sincos(x[0][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][0] = sinResult;
>+    if (z != null)
>+        (*z)[0][0] = cosResult;
>+    sincos(x[0][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][1] = sinResult;
>+    if (z != null)
>+        (*z)[0][1] = cosResult;
>+    sincos(x[0][2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][2] = sinResult;
>+    if (z != null)
>+        (*z)[0][2] = cosResult;
>+    sincos(x[1][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][0] = sinResult;
>+    if (z != null)
>+        (*z)[1][0] = cosResult;
>+    sincos(x[1][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][1] = sinResult;
>+    if (z != null)
>+        (*z)[1][1] = cosResult;
>+    sincos(x[1][2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][2] = sinResult;
>+    if (z != null)
>+        (*z)[1][2] = cosResult;
>+}
>+void sincos(half2x4 x, device half2x4* y, threadgroup half2x4* z) {
>+    half sinResult;
>+    half cosResult;
>+    sincos(x[0][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][0] = sinResult;
>+    if (z != null)
>+        (*z)[0][0] = cosResult;
>+    sincos(x[0][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][1] = sinResult;
>+    if (z != null)
>+        (*z)[0][1] = cosResult;
>+    sincos(x[0][2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][2] = sinResult;
>+    if (z != null)
>+        (*z)[0][2] = cosResult;
>+    sincos(x[0][3], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][3] = sinResult;
>+    if (z != null)
>+        (*z)[0][3] = cosResult;
>+    sincos(x[1][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][0] = sinResult;
>+    if (z != null)
>+        (*z)[1][0] = cosResult;
>+    sincos(x[1][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][1] = sinResult;
>+    if (z != null)
>+        (*z)[1][1] = cosResult;
>+    sincos(x[1][2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][2] = sinResult;
>+    if (z != null)
>+        (*z)[1][2] = cosResult;
>+    sincos(x[1][3], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][3] = sinResult;
>+    if (z != null)
>+        (*z)[1][3] = cosResult;
>+}
>+void sincos(half3x2 x, device half3x2* y, threadgroup half3x2* z) {
>+    half sinResult;
>+    half cosResult;
>+    sincos(x[0][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][0] = sinResult;
>+    if (z != null)
>+        (*z)[0][0] = cosResult;
>+    sincos(x[0][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][1] = sinResult;
>+    if (z != null)
>+        (*z)[0][1] = cosResult;
>+    sincos(x[1][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][0] = sinResult;
>+    if (z != null)
>+        (*z)[1][0] = cosResult;
>+    sincos(x[1][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][1] = sinResult;
>+    if (z != null)
>+        (*z)[1][1] = cosResult;
>+    sincos(x[2][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2][0] = sinResult;
>+    if (z != null)
>+        (*z)[2][0] = cosResult;
>+    sincos(x[2][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2][1] = sinResult;
>+    if (z != null)
>+        (*z)[2][1] = cosResult;
>+}
>+void sincos(half3x3 x, device half3x3* y, threadgroup half3x3* z) {
>+    half sinResult;
>+    half cosResult;
>+    sincos(x[0][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][0] = sinResult;
>+    if (z != null)
>+        (*z)[0][0] = cosResult;
>+    sincos(x[0][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][1] = sinResult;
>+    if (z != null)
>+        (*z)[0][1] = cosResult;
>+    sincos(x[0][2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][2] = sinResult;
>+    if (z != null)
>+        (*z)[0][2] = cosResult;
>+    sincos(x[1][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][0] = sinResult;
>+    if (z != null)
>+        (*z)[1][0] = cosResult;
>+    sincos(x[1][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][1] = sinResult;
>+    if (z != null)
>+        (*z)[1][1] = cosResult;
>+    sincos(x[1][2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][2] = sinResult;
>+    if (z != null)
>+        (*z)[1][2] = cosResult;
>+    sincos(x[2][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2][0] = sinResult;
>+    if (z != null)
>+        (*z)[2][0] = cosResult;
>+    sincos(x[2][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2][1] = sinResult;
>+    if (z != null)
>+        (*z)[2][1] = cosResult;
>+    sincos(x[2][2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2][2] = sinResult;
>+    if (z != null)
>+        (*z)[2][2] = cosResult;
>+}
>+void sincos(half3x4 x, device half3x4* y, threadgroup half3x4* z) {
>+    half sinResult;
>+    half cosResult;
>+    sincos(x[0][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][0] = sinResult;
>+    if (z != null)
>+        (*z)[0][0] = cosResult;
>+    sincos(x[0][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][1] = sinResult;
>+    if (z != null)
>+        (*z)[0][1] = cosResult;
>+    sincos(x[0][2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][2] = sinResult;
>+    if (z != null)
>+        (*z)[0][2] = cosResult;
>+    sincos(x[0][3], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][3] = sinResult;
>+    if (z != null)
>+        (*z)[0][3] = cosResult;
>+    sincos(x[1][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][0] = sinResult;
>+    if (z != null)
>+        (*z)[1][0] = cosResult;
>+    sincos(x[1][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][1] = sinResult;
>+    if (z != null)
>+        (*z)[1][1] = cosResult;
>+    sincos(x[1][2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][2] = sinResult;
>+    if (z != null)
>+        (*z)[1][2] = cosResult;
>+    sincos(x[1][3], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][3] = sinResult;
>+    if (z != null)
>+        (*z)[1][3] = cosResult;
>+    sincos(x[2][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2][0] = sinResult;
>+    if (z != null)
>+        (*z)[2][0] = cosResult;
>+    sincos(x[2][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2][1] = sinResult;
>+    if (z != null)
>+        (*z)[2][1] = cosResult;
>+    sincos(x[2][2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2][2] = sinResult;
>+    if (z != null)
>+        (*z)[2][2] = cosResult;
>+    sincos(x[2][3], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2][3] = sinResult;
>+    if (z != null)
>+        (*z)[2][3] = cosResult;
>+}
>+void sincos(half4x2 x, device half4x2* y, threadgroup half4x2* z) {
>+    half sinResult;
>+    half cosResult;
>+    sincos(x[0][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][0] = sinResult;
>+    if (z != null)
>+        (*z)[0][0] = cosResult;
>+    sincos(x[0][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][1] = sinResult;
>+    if (z != null)
>+        (*z)[0][1] = cosResult;
>+    sincos(x[1][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][0] = sinResult;
>+    if (z != null)
>+        (*z)[1][0] = cosResult;
>+    sincos(x[1][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][1] = sinResult;
>+    if (z != null)
>+        (*z)[1][1] = cosResult;
>+    sincos(x[2][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2][0] = sinResult;
>+    if (z != null)
>+        (*z)[2][0] = cosResult;
>+    sincos(x[2][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2][1] = sinResult;
>+    if (z != null)
>+        (*z)[2][1] = cosResult;
>+    sincos(x[3][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[3][0] = sinResult;
>+    if (z != null)
>+        (*z)[3][0] = cosResult;
>+    sincos(x[3][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[3][1] = sinResult;
>+    if (z != null)
>+        (*z)[3][1] = cosResult;
>+}
>+void sincos(half4x3 x, device half4x3* y, threadgroup half4x3* z) {
>+    half sinResult;
>+    half cosResult;
>+    sincos(x[0][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][0] = sinResult;
>+    if (z != null)
>+        (*z)[0][0] = cosResult;
>+    sincos(x[0][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][1] = sinResult;
>+    if (z != null)
>+        (*z)[0][1] = cosResult;
>+    sincos(x[0][2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][2] = sinResult;
>+    if (z != null)
>+        (*z)[0][2] = cosResult;
>+    sincos(x[1][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][0] = sinResult;
>+    if (z != null)
>+        (*z)[1][0] = cosResult;
>+    sincos(x[1][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][1] = sinResult;
>+    if (z != null)
>+        (*z)[1][1] = cosResult;
>+    sincos(x[1][2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][2] = sinResult;
>+    if (z != null)
>+        (*z)[1][2] = cosResult;
>+    sincos(x[2][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2][0] = sinResult;
>+    if (z != null)
>+        (*z)[2][0] = cosResult;
>+    sincos(x[2][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2][1] = sinResult;
>+    if (z != null)
>+        (*z)[2][1] = cosResult;
>+    sincos(x[2][2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2][2] = sinResult;
>+    if (z != null)
>+        (*z)[2][2] = cosResult;
>+    sincos(x[3][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[3][0] = sinResult;
>+    if (z != null)
>+        (*z)[3][0] = cosResult;
>+    sincos(x[3][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[3][1] = sinResult;
>+    if (z != null)
>+        (*z)[3][1] = cosResult;
>+    sincos(x[3][2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[3][2] = sinResult;
>+    if (z != null)
>+        (*z)[3][2] = cosResult;
>+}
>+void sincos(half4x4 x, device half4x4* y, threadgroup half4x4* z) {
>+    half sinResult;
>+    half cosResult;
>+    sincos(x[0][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][0] = sinResult;
>+    if (z != null)
>+        (*z)[0][0] = cosResult;
>+    sincos(x[0][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][1] = sinResult;
>+    if (z != null)
>+        (*z)[0][1] = cosResult;
>+    sincos(x[0][2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][2] = sinResult;
>+    if (z != null)
>+        (*z)[0][2] = cosResult;
>+    sincos(x[0][3], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][3] = sinResult;
>+    if (z != null)
>+        (*z)[0][3] = cosResult;
>+    sincos(x[1][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][0] = sinResult;
>+    if (z != null)
>+        (*z)[1][0] = cosResult;
>+    sincos(x[1][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][1] = sinResult;
>+    if (z != null)
>+        (*z)[1][1] = cosResult;
>+    sincos(x[1][2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][2] = sinResult;
>+    if (z != null)
>+        (*z)[1][2] = cosResult;
>+    sincos(x[1][3], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][3] = sinResult;
>+    if (z != null)
>+        (*z)[1][3] = cosResult;
>+    sincos(x[2][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2][0] = sinResult;
>+    if (z != null)
>+        (*z)[2][0] = cosResult;
>+    sincos(x[2][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2][1] = sinResult;
>+    if (z != null)
>+        (*z)[2][1] = cosResult;
>+    sincos(x[2][2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2][2] = sinResult;
>+    if (z != null)
>+        (*z)[2][2] = cosResult;
>+    sincos(x[2][3], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2][3] = sinResult;
>+    if (z != null)
>+        (*z)[2][3] = cosResult;
>+    sincos(x[3][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[3][0] = sinResult;
>+    if (z != null)
>+        (*z)[3][0] = cosResult;
>+    sincos(x[3][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[3][1] = sinResult;
>+    if (z != null)
>+        (*z)[3][1] = cosResult;
>+    sincos(x[3][2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[3][2] = sinResult;
>+    if (z != null)
>+        (*z)[3][2] = cosResult;
>+    sincos(x[3][3], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[3][3] = sinResult;
>+    if (z != null)
>+        (*z)[3][3] = cosResult;
>+}
>+void sincos(float x, device float* y, threadgroup float* z) {
>+    if (y != null)
>+        *y = sin(x);
>+    if (z != null)
>+        *z = cos(x);
>+}
>+void sincos(float2 x, device float2* y, threadgroup float2* z) {
>+    float sinResult;
>+    float cosResult;
>+    sincos(x[0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0] = sinResult;
>+    if (z != null)
>+        (*z)[0] = cosResult;
>+    sincos(x[1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1] = sinResult;
>+    if (z != null)
>+        (*z)[1] = cosResult;
>+}
>+void sincos(float3 x, device float3* y, threadgroup float3* z) {
>+    float sinResult;
>+    float cosResult;
>+    sincos(x[0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0] = sinResult;
>+    if (z != null)
>+        (*z)[0] = cosResult;
>+    sincos(x[1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1] = sinResult;
>+    if (z != null)
>+        (*z)[1] = cosResult;
>+    sincos(x[2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2] = sinResult;
>+    if (z != null)
>+        (*z)[2] = cosResult;
>+}
>+void sincos(float4 x, device float4* y, threadgroup float4* z) {
>+    float sinResult;
>+    float cosResult;
>+    sincos(x[0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0] = sinResult;
>+    if (z != null)
>+        (*z)[0] = cosResult;
>+    sincos(x[1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1] = sinResult;
>+    if (z != null)
>+        (*z)[1] = cosResult;
>+    sincos(x[2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2] = sinResult;
>+    if (z != null)
>+        (*z)[2] = cosResult;
>+    sincos(x[3], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[3] = sinResult;
>+    if (z != null)
>+        (*z)[3] = cosResult;
>+}
>+void sincos(float2x2 x, device float2x2* y, threadgroup float2x2* z) {
>+    float sinResult;
>+    float cosResult;
>+    sincos(x[0][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][0] = sinResult;
>+    if (z != null)
>+        (*z)[0][0] = cosResult;
>+    sincos(x[0][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][1] = sinResult;
>+    if (z != null)
>+        (*z)[0][1] = cosResult;
>+    sincos(x[1][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][0] = sinResult;
>+    if (z != null)
>+        (*z)[1][0] = cosResult;
>+    sincos(x[1][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][1] = sinResult;
>+    if (z != null)
>+        (*z)[1][1] = cosResult;
>+}
>+void sincos(float2x3 x, device float2x3* y, threadgroup float2x3* z) {
>+    float sinResult;
>+    float cosResult;
>+    sincos(x[0][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][0] = sinResult;
>+    if (z != null)
>+        (*z)[0][0] = cosResult;
>+    sincos(x[0][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][1] = sinResult;
>+    if (z != null)
>+        (*z)[0][1] = cosResult;
>+    sincos(x[0][2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][2] = sinResult;
>+    if (z != null)
>+        (*z)[0][2] = cosResult;
>+    sincos(x[1][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][0] = sinResult;
>+    if (z != null)
>+        (*z)[1][0] = cosResult;
>+    sincos(x[1][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][1] = sinResult;
>+    if (z != null)
>+        (*z)[1][1] = cosResult;
>+    sincos(x[1][2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][2] = sinResult;
>+    if (z != null)
>+        (*z)[1][2] = cosResult;
>+}
>+void sincos(float2x4 x, device float2x4* y, threadgroup float2x4* z) {
>+    float sinResult;
>+    float cosResult;
>+    sincos(x[0][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][0] = sinResult;
>+    if (z != null)
>+        (*z)[0][0] = cosResult;
>+    sincos(x[0][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][1] = sinResult;
>+    if (z != null)
>+        (*z)[0][1] = cosResult;
>+    sincos(x[0][2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][2] = sinResult;
>+    if (z != null)
>+        (*z)[0][2] = cosResult;
>+    sincos(x[0][3], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][3] = sinResult;
>+    if (z != null)
>+        (*z)[0][3] = cosResult;
>+    sincos(x[1][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][0] = sinResult;
>+    if (z != null)
>+        (*z)[1][0] = cosResult;
>+    sincos(x[1][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][1] = sinResult;
>+    if (z != null)
>+        (*z)[1][1] = cosResult;
>+    sincos(x[1][2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][2] = sinResult;
>+    if (z != null)
>+        (*z)[1][2] = cosResult;
>+    sincos(x[1][3], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][3] = sinResult;
>+    if (z != null)
>+        (*z)[1][3] = cosResult;
>+}
>+void sincos(float3x2 x, device float3x2* y, threadgroup float3x2* z) {
>+    float sinResult;
>+    float cosResult;
>+    sincos(x[0][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][0] = sinResult;
>+    if (z != null)
>+        (*z)[0][0] = cosResult;
>+    sincos(x[0][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][1] = sinResult;
>+    if (z != null)
>+        (*z)[0][1] = cosResult;
>+    sincos(x[1][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][0] = sinResult;
>+    if (z != null)
>+        (*z)[1][0] = cosResult;
>+    sincos(x[1][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][1] = sinResult;
>+    if (z != null)
>+        (*z)[1][1] = cosResult;
>+    sincos(x[2][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2][0] = sinResult;
>+    if (z != null)
>+        (*z)[2][0] = cosResult;
>+    sincos(x[2][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2][1] = sinResult;
>+    if (z != null)
>+        (*z)[2][1] = cosResult;
>+}
>+void sincos(float3x3 x, device float3x3* y, threadgroup float3x3* z) {
>+    float sinResult;
>+    float cosResult;
>+    sincos(x[0][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][0] = sinResult;
>+    if (z != null)
>+        (*z)[0][0] = cosResult;
>+    sincos(x[0][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][1] = sinResult;
>+    if (z != null)
>+        (*z)[0][1] = cosResult;
>+    sincos(x[0][2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][2] = sinResult;
>+    if (z != null)
>+        (*z)[0][2] = cosResult;
>+    sincos(x[1][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][0] = sinResult;
>+    if (z != null)
>+        (*z)[1][0] = cosResult;
>+    sincos(x[1][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][1] = sinResult;
>+    if (z != null)
>+        (*z)[1][1] = cosResult;
>+    sincos(x[1][2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][2] = sinResult;
>+    if (z != null)
>+        (*z)[1][2] = cosResult;
>+    sincos(x[2][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2][0] = sinResult;
>+    if (z != null)
>+        (*z)[2][0] = cosResult;
>+    sincos(x[2][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2][1] = sinResult;
>+    if (z != null)
>+        (*z)[2][1] = cosResult;
>+    sincos(x[2][2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2][2] = sinResult;
>+    if (z != null)
>+        (*z)[2][2] = cosResult;
>+}
>+void sincos(float3x4 x, device float3x4* y, threadgroup float3x4* z) {
>+    float sinResult;
>+    float cosResult;
>+    sincos(x[0][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][0] = sinResult;
>+    if (z != null)
>+        (*z)[0][0] = cosResult;
>+    sincos(x[0][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][1] = sinResult;
>+    if (z != null)
>+        (*z)[0][1] = cosResult;
>+    sincos(x[0][2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][2] = sinResult;
>+    if (z != null)
>+        (*z)[0][2] = cosResult;
>+    sincos(x[0][3], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][3] = sinResult;
>+    if (z != null)
>+        (*z)[0][3] = cosResult;
>+    sincos(x[1][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][0] = sinResult;
>+    if (z != null)
>+        (*z)[1][0] = cosResult;
>+    sincos(x[1][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][1] = sinResult;
>+    if (z != null)
>+        (*z)[1][1] = cosResult;
>+    sincos(x[1][2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][2] = sinResult;
>+    if (z != null)
>+        (*z)[1][2] = cosResult;
>+    sincos(x[1][3], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][3] = sinResult;
>+    if (z != null)
>+        (*z)[1][3] = cosResult;
>+    sincos(x[2][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2][0] = sinResult;
>+    if (z != null)
>+        (*z)[2][0] = cosResult;
>+    sincos(x[2][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2][1] = sinResult;
>+    if (z != null)
>+        (*z)[2][1] = cosResult;
>+    sincos(x[2][2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2][2] = sinResult;
>+    if (z != null)
>+        (*z)[2][2] = cosResult;
>+    sincos(x[2][3], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2][3] = sinResult;
>+    if (z != null)
>+        (*z)[2][3] = cosResult;
>+}
>+void sincos(float4x2 x, device float4x2* y, threadgroup float4x2* z) {
>+    float sinResult;
>+    float cosResult;
>+    sincos(x[0][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][0] = sinResult;
>+    if (z != null)
>+        (*z)[0][0] = cosResult;
>+    sincos(x[0][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][1] = sinResult;
>+    if (z != null)
>+        (*z)[0][1] = cosResult;
>+    sincos(x[1][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][0] = sinResult;
>+    if (z != null)
>+        (*z)[1][0] = cosResult;
>+    sincos(x[1][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][1] = sinResult;
>+    if (z != null)
>+        (*z)[1][1] = cosResult;
>+    sincos(x[2][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2][0] = sinResult;
>+    if (z != null)
>+        (*z)[2][0] = cosResult;
>+    sincos(x[2][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2][1] = sinResult;
>+    if (z != null)
>+        (*z)[2][1] = cosResult;
>+    sincos(x[3][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[3][0] = sinResult;
>+    if (z != null)
>+        (*z)[3][0] = cosResult;
>+    sincos(x[3][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[3][1] = sinResult;
>+    if (z != null)
>+        (*z)[3][1] = cosResult;
>+}
>+void sincos(float4x3 x, device float4x3* y, threadgroup float4x3* z) {
>+    float sinResult;
>+    float cosResult;
>+    sincos(x[0][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][0] = sinResult;
>+    if (z != null)
>+        (*z)[0][0] = cosResult;
>+    sincos(x[0][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][1] = sinResult;
>+    if (z != null)
>+        (*z)[0][1] = cosResult;
>+    sincos(x[0][2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][2] = sinResult;
>+    if (z != null)
>+        (*z)[0][2] = cosResult;
>+    sincos(x[1][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][0] = sinResult;
>+    if (z != null)
>+        (*z)[1][0] = cosResult;
>+    sincos(x[1][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][1] = sinResult;
>+    if (z != null)
>+        (*z)[1][1] = cosResult;
>+    sincos(x[1][2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][2] = sinResult;
>+    if (z != null)
>+        (*z)[1][2] = cosResult;
>+    sincos(x[2][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2][0] = sinResult;
>+    if (z != null)
>+        (*z)[2][0] = cosResult;
>+    sincos(x[2][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2][1] = sinResult;
>+    if (z != null)
>+        (*z)[2][1] = cosResult;
>+    sincos(x[2][2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2][2] = sinResult;
>+    if (z != null)
>+        (*z)[2][2] = cosResult;
>+    sincos(x[3][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[3][0] = sinResult;
>+    if (z != null)
>+        (*z)[3][0] = cosResult;
>+    sincos(x[3][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[3][1] = sinResult;
>+    if (z != null)
>+        (*z)[3][1] = cosResult;
>+    sincos(x[3][2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[3][2] = sinResult;
>+    if (z != null)
>+        (*z)[3][2] = cosResult;
>+}
>+void sincos(float4x4 x, device float4x4* y, threadgroup float4x4* z) {
>+    float sinResult;
>+    float cosResult;
>+    sincos(x[0][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][0] = sinResult;
>+    if (z != null)
>+        (*z)[0][0] = cosResult;
>+    sincos(x[0][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][1] = sinResult;
>+    if (z != null)
>+        (*z)[0][1] = cosResult;
>+    sincos(x[0][2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][2] = sinResult;
>+    if (z != null)
>+        (*z)[0][2] = cosResult;
>+    sincos(x[0][3], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][3] = sinResult;
>+    if (z != null)
>+        (*z)[0][3] = cosResult;
>+    sincos(x[1][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][0] = sinResult;
>+    if (z != null)
>+        (*z)[1][0] = cosResult;
>+    sincos(x[1][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][1] = sinResult;
>+    if (z != null)
>+        (*z)[1][1] = cosResult;
>+    sincos(x[1][2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][2] = sinResult;
>+    if (z != null)
>+        (*z)[1][2] = cosResult;
>+    sincos(x[1][3], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][3] = sinResult;
>+    if (z != null)
>+        (*z)[1][3] = cosResult;
>+    sincos(x[2][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2][0] = sinResult;
>+    if (z != null)
>+        (*z)[2][0] = cosResult;
>+    sincos(x[2][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2][1] = sinResult;
>+    if (z != null)
>+        (*z)[2][1] = cosResult;
>+    sincos(x[2][2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2][2] = sinResult;
>+    if (z != null)
>+        (*z)[2][2] = cosResult;
>+    sincos(x[2][3], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2][3] = sinResult;
>+    if (z != null)
>+        (*z)[2][3] = cosResult;
>+    sincos(x[3][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[3][0] = sinResult;
>+    if (z != null)
>+        (*z)[3][0] = cosResult;
>+    sincos(x[3][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[3][1] = sinResult;
>+    if (z != null)
>+        (*z)[3][1] = cosResult;
>+    sincos(x[3][2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[3][2] = sinResult;
>+    if (z != null)
>+        (*z)[3][2] = cosResult;
>+    sincos(x[3][3], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[3][3] = sinResult;
>+    if (z != null)
>+        (*z)[3][3] = cosResult;
>+}
>+void sincos(half x, threadgroup half* y, thread half* z) {
>+    if (y != null)
>+        *y = sin(x);
>+    if (z != null)
>+        *z = cos(x);
>+}
>+void sincos(half2 x, threadgroup half2* y, thread half2* z) {
>+    half sinResult;
>+    half cosResult;
>+    sincos(x[0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0] = sinResult;
>+    if (z != null)
>+        (*z)[0] = cosResult;
>+    sincos(x[1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1] = sinResult;
>+    if (z != null)
>+        (*z)[1] = cosResult;
>+}
>+void sincos(half3 x, threadgroup half3* y, thread half3* z) {
>+    half sinResult;
>+    half cosResult;
>+    sincos(x[0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0] = sinResult;
>+    if (z != null)
>+        (*z)[0] = cosResult;
>+    sincos(x[1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1] = sinResult;
>+    if (z != null)
>+        (*z)[1] = cosResult;
>+    sincos(x[2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2] = sinResult;
>+    if (z != null)
>+        (*z)[2] = cosResult;
>+}
>+void sincos(half4 x, threadgroup half4* y, thread half4* z) {
>+    half sinResult;
>+    half cosResult;
>+    sincos(x[0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0] = sinResult;
>+    if (z != null)
>+        (*z)[0] = cosResult;
>+    sincos(x[1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1] = sinResult;
>+    if (z != null)
>+        (*z)[1] = cosResult;
>+    sincos(x[2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2] = sinResult;
>+    if (z != null)
>+        (*z)[2] = cosResult;
>+    sincos(x[3], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[3] = sinResult;
>+    if (z != null)
>+        (*z)[3] = cosResult;
>+}
>+void sincos(half2x2 x, threadgroup half2x2* y, thread half2x2* z) {
>+    half sinResult;
>+    half cosResult;
>+    sincos(x[0][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][0] = sinResult;
>+    if (z != null)
>+        (*z)[0][0] = cosResult;
>+    sincos(x[0][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][1] = sinResult;
>+    if (z != null)
>+        (*z)[0][1] = cosResult;
>+    sincos(x[1][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][0] = sinResult;
>+    if (z != null)
>+        (*z)[1][0] = cosResult;
>+    sincos(x[1][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][1] = sinResult;
>+    if (z != null)
>+        (*z)[1][1] = cosResult;
>+}
>+void sincos(half2x3 x, threadgroup half2x3* y, thread half2x3* z) {
>+    half sinResult;
>+    half cosResult;
>+    sincos(x[0][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][0] = sinResult;
>+    if (z != null)
>+        (*z)[0][0] = cosResult;
>+    sincos(x[0][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][1] = sinResult;
>+    if (z != null)
>+        (*z)[0][1] = cosResult;
>+    sincos(x[0][2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][2] = sinResult;
>+    if (z != null)
>+        (*z)[0][2] = cosResult;
>+    sincos(x[1][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][0] = sinResult;
>+    if (z != null)
>+        (*z)[1][0] = cosResult;
>+    sincos(x[1][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][1] = sinResult;
>+    if (z != null)
>+        (*z)[1][1] = cosResult;
>+    sincos(x[1][2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][2] = sinResult;
>+    if (z != null)
>+        (*z)[1][2] = cosResult;
>+}
>+void sincos(half2x4 x, threadgroup half2x4* y, thread half2x4* z) {
>+    half sinResult;
>+    half cosResult;
>+    sincos(x[0][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][0] = sinResult;
>+    if (z != null)
>+        (*z)[0][0] = cosResult;
>+    sincos(x[0][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][1] = sinResult;
>+    if (z != null)
>+        (*z)[0][1] = cosResult;
>+    sincos(x[0][2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][2] = sinResult;
>+    if (z != null)
>+        (*z)[0][2] = cosResult;
>+    sincos(x[0][3], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][3] = sinResult;
>+    if (z != null)
>+        (*z)[0][3] = cosResult;
>+    sincos(x[1][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][0] = sinResult;
>+    if (z != null)
>+        (*z)[1][0] = cosResult;
>+    sincos(x[1][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][1] = sinResult;
>+    if (z != null)
>+        (*z)[1][1] = cosResult;
>+    sincos(x[1][2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][2] = sinResult;
>+    if (z != null)
>+        (*z)[1][2] = cosResult;
>+    sincos(x[1][3], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][3] = sinResult;
>+    if (z != null)
>+        (*z)[1][3] = cosResult;
>+}
>+void sincos(half3x2 x, threadgroup half3x2* y, thread half3x2* z) {
>+    half sinResult;
>+    half cosResult;
>+    sincos(x[0][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][0] = sinResult;
>+    if (z != null)
>+        (*z)[0][0] = cosResult;
>+    sincos(x[0][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][1] = sinResult;
>+    if (z != null)
>+        (*z)[0][1] = cosResult;
>+    sincos(x[1][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][0] = sinResult;
>+    if (z != null)
>+        (*z)[1][0] = cosResult;
>+    sincos(x[1][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][1] = sinResult;
>+    if (z != null)
>+        (*z)[1][1] = cosResult;
>+    sincos(x[2][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2][0] = sinResult;
>+    if (z != null)
>+        (*z)[2][0] = cosResult;
>+    sincos(x[2][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2][1] = sinResult;
>+    if (z != null)
>+        (*z)[2][1] = cosResult;
>+}
>+void sincos(half3x3 x, threadgroup half3x3* y, thread half3x3* z) {
>+    half sinResult;
>+    half cosResult;
>+    sincos(x[0][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][0] = sinResult;
>+    if (z != null)
>+        (*z)[0][0] = cosResult;
>+    sincos(x[0][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][1] = sinResult;
>+    if (z != null)
>+        (*z)[0][1] = cosResult;
>+    sincos(x[0][2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][2] = sinResult;
>+    if (z != null)
>+        (*z)[0][2] = cosResult;
>+    sincos(x[1][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][0] = sinResult;
>+    if (z != null)
>+        (*z)[1][0] = cosResult;
>+    sincos(x[1][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][1] = sinResult;
>+    if (z != null)
>+        (*z)[1][1] = cosResult;
>+    sincos(x[1][2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][2] = sinResult;
>+    if (z != null)
>+        (*z)[1][2] = cosResult;
>+    sincos(x[2][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2][0] = sinResult;
>+    if (z != null)
>+        (*z)[2][0] = cosResult;
>+    sincos(x[2][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2][1] = sinResult;
>+    if (z != null)
>+        (*z)[2][1] = cosResult;
>+    sincos(x[2][2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2][2] = sinResult;
>+    if (z != null)
>+        (*z)[2][2] = cosResult;
>+}
>+void sincos(half3x4 x, threadgroup half3x4* y, thread half3x4* z) {
>+    half sinResult;
>+    half cosResult;
>+    sincos(x[0][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][0] = sinResult;
>+    if (z != null)
>+        (*z)[0][0] = cosResult;
>+    sincos(x[0][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][1] = sinResult;
>+    if (z != null)
>+        (*z)[0][1] = cosResult;
>+    sincos(x[0][2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][2] = sinResult;
>+    if (z != null)
>+        (*z)[0][2] = cosResult;
>+    sincos(x[0][3], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][3] = sinResult;
>+    if (z != null)
>+        (*z)[0][3] = cosResult;
>+    sincos(x[1][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][0] = sinResult;
>+    if (z != null)
>+        (*z)[1][0] = cosResult;
>+    sincos(x[1][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][1] = sinResult;
>+    if (z != null)
>+        (*z)[1][1] = cosResult;
>+    sincos(x[1][2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][2] = sinResult;
>+    if (z != null)
>+        (*z)[1][2] = cosResult;
>+    sincos(x[1][3], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][3] = sinResult;
>+    if (z != null)
>+        (*z)[1][3] = cosResult;
>+    sincos(x[2][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2][0] = sinResult;
>+    if (z != null)
>+        (*z)[2][0] = cosResult;
>+    sincos(x[2][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2][1] = sinResult;
>+    if (z != null)
>+        (*z)[2][1] = cosResult;
>+    sincos(x[2][2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2][2] = sinResult;
>+    if (z != null)
>+        (*z)[2][2] = cosResult;
>+    sincos(x[2][3], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2][3] = sinResult;
>+    if (z != null)
>+        (*z)[2][3] = cosResult;
>+}
>+void sincos(half4x2 x, threadgroup half4x2* y, thread half4x2* z) {
>+    half sinResult;
>+    half cosResult;
>+    sincos(x[0][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][0] = sinResult;
>+    if (z != null)
>+        (*z)[0][0] = cosResult;
>+    sincos(x[0][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][1] = sinResult;
>+    if (z != null)
>+        (*z)[0][1] = cosResult;
>+    sincos(x[1][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][0] = sinResult;
>+    if (z != null)
>+        (*z)[1][0] = cosResult;
>+    sincos(x[1][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][1] = sinResult;
>+    if (z != null)
>+        (*z)[1][1] = cosResult;
>+    sincos(x[2][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2][0] = sinResult;
>+    if (z != null)
>+        (*z)[2][0] = cosResult;
>+    sincos(x[2][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2][1] = sinResult;
>+    if (z != null)
>+        (*z)[2][1] = cosResult;
>+    sincos(x[3][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[3][0] = sinResult;
>+    if (z != null)
>+        (*z)[3][0] = cosResult;
>+    sincos(x[3][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[3][1] = sinResult;
>+    if (z != null)
>+        (*z)[3][1] = cosResult;
>+}
>+void sincos(half4x3 x, threadgroup half4x3* y, thread half4x3* z) {
>+    half sinResult;
>+    half cosResult;
>+    sincos(x[0][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][0] = sinResult;
>+    if (z != null)
>+        (*z)[0][0] = cosResult;
>+    sincos(x[0][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][1] = sinResult;
>+    if (z != null)
>+        (*z)[0][1] = cosResult;
>+    sincos(x[0][2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][2] = sinResult;
>+    if (z != null)
>+        (*z)[0][2] = cosResult;
>+    sincos(x[1][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][0] = sinResult;
>+    if (z != null)
>+        (*z)[1][0] = cosResult;
>+    sincos(x[1][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][1] = sinResult;
>+    if (z != null)
>+        (*z)[1][1] = cosResult;
>+    sincos(x[1][2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][2] = sinResult;
>+    if (z != null)
>+        (*z)[1][2] = cosResult;
>+    sincos(x[2][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2][0] = sinResult;
>+    if (z != null)
>+        (*z)[2][0] = cosResult;
>+    sincos(x[2][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2][1] = sinResult;
>+    if (z != null)
>+        (*z)[2][1] = cosResult;
>+    sincos(x[2][2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2][2] = sinResult;
>+    if (z != null)
>+        (*z)[2][2] = cosResult;
>+    sincos(x[3][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[3][0] = sinResult;
>+    if (z != null)
>+        (*z)[3][0] = cosResult;
>+    sincos(x[3][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[3][1] = sinResult;
>+    if (z != null)
>+        (*z)[3][1] = cosResult;
>+    sincos(x[3][2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[3][2] = sinResult;
>+    if (z != null)
>+        (*z)[3][2] = cosResult;
>+}
>+void sincos(half4x4 x, threadgroup half4x4* y, thread half4x4* z) {
>+    half sinResult;
>+    half cosResult;
>+    sincos(x[0][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][0] = sinResult;
>+    if (z != null)
>+        (*z)[0][0] = cosResult;
>+    sincos(x[0][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][1] = sinResult;
>+    if (z != null)
>+        (*z)[0][1] = cosResult;
>+    sincos(x[0][2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][2] = sinResult;
>+    if (z != null)
>+        (*z)[0][2] = cosResult;
>+    sincos(x[0][3], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][3] = sinResult;
>+    if (z != null)
>+        (*z)[0][3] = cosResult;
>+    sincos(x[1][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][0] = sinResult;
>+    if (z != null)
>+        (*z)[1][0] = cosResult;
>+    sincos(x[1][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][1] = sinResult;
>+    if (z != null)
>+        (*z)[1][1] = cosResult;
>+    sincos(x[1][2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][2] = sinResult;
>+    if (z != null)
>+        (*z)[1][2] = cosResult;
>+    sincos(x[1][3], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][3] = sinResult;
>+    if (z != null)
>+        (*z)[1][3] = cosResult;
>+    sincos(x[2][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2][0] = sinResult;
>+    if (z != null)
>+        (*z)[2][0] = cosResult;
>+    sincos(x[2][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2][1] = sinResult;
>+    if (z != null)
>+        (*z)[2][1] = cosResult;
>+    sincos(x[2][2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2][2] = sinResult;
>+    if (z != null)
>+        (*z)[2][2] = cosResult;
>+    sincos(x[2][3], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2][3] = sinResult;
>+    if (z != null)
>+        (*z)[2][3] = cosResult;
>+    sincos(x[3][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[3][0] = sinResult;
>+    if (z != null)
>+        (*z)[3][0] = cosResult;
>+    sincos(x[3][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[3][1] = sinResult;
>+    if (z != null)
>+        (*z)[3][1] = cosResult;
>+    sincos(x[3][2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[3][2] = sinResult;
>+    if (z != null)
>+        (*z)[3][2] = cosResult;
>+    sincos(x[3][3], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[3][3] = sinResult;
>+    if (z != null)
>+        (*z)[3][3] = cosResult;
>+}
>+void sincos(float x, threadgroup float* y, thread float* z) {
>+    if (y != null)
>+        *y = sin(x);
>+    if (z != null)
>+        *z = cos(x);
>+}
>+void sincos(float2 x, threadgroup float2* y, thread float2* z) {
>+    float sinResult;
>+    float cosResult;
>+    sincos(x[0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0] = sinResult;
>+    if (z != null)
>+        (*z)[0] = cosResult;
>+    sincos(x[1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1] = sinResult;
>+    if (z != null)
>+        (*z)[1] = cosResult;
>+}
>+void sincos(float3 x, threadgroup float3* y, thread float3* z) {
>+    float sinResult;
>+    float cosResult;
>+    sincos(x[0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0] = sinResult;
>+    if (z != null)
>+        (*z)[0] = cosResult;
>+    sincos(x[1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1] = sinResult;
>+    if (z != null)
>+        (*z)[1] = cosResult;
>+    sincos(x[2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2] = sinResult;
>+    if (z != null)
>+        (*z)[2] = cosResult;
>+}
>+void sincos(float4 x, threadgroup float4* y, thread float4* z) {
>+    float sinResult;
>+    float cosResult;
>+    sincos(x[0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0] = sinResult;
>+    if (z != null)
>+        (*z)[0] = cosResult;
>+    sincos(x[1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1] = sinResult;
>+    if (z != null)
>+        (*z)[1] = cosResult;
>+    sincos(x[2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2] = sinResult;
>+    if (z != null)
>+        (*z)[2] = cosResult;
>+    sincos(x[3], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[3] = sinResult;
>+    if (z != null)
>+        (*z)[3] = cosResult;
>+}
>+void sincos(float2x2 x, threadgroup float2x2* y, thread float2x2* z) {
>+    float sinResult;
>+    float cosResult;
>+    sincos(x[0][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][0] = sinResult;
>+    if (z != null)
>+        (*z)[0][0] = cosResult;
>+    sincos(x[0][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][1] = sinResult;
>+    if (z != null)
>+        (*z)[0][1] = cosResult;
>+    sincos(x[1][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][0] = sinResult;
>+    if (z != null)
>+        (*z)[1][0] = cosResult;
>+    sincos(x[1][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][1] = sinResult;
>+    if (z != null)
>+        (*z)[1][1] = cosResult;
>+}
>+void sincos(float2x3 x, threadgroup float2x3* y, thread float2x3* z) {
>+    float sinResult;
>+    float cosResult;
>+    sincos(x[0][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][0] = sinResult;
>+    if (z != null)
>+        (*z)[0][0] = cosResult;
>+    sincos(x[0][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][1] = sinResult;
>+    if (z != null)
>+        (*z)[0][1] = cosResult;
>+    sincos(x[0][2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][2] = sinResult;
>+    if (z != null)
>+        (*z)[0][2] = cosResult;
>+    sincos(x[1][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][0] = sinResult;
>+    if (z != null)
>+        (*z)[1][0] = cosResult;
>+    sincos(x[1][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][1] = sinResult;
>+    if (z != null)
>+        (*z)[1][1] = cosResult;
>+    sincos(x[1][2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][2] = sinResult;
>+    if (z != null)
>+        (*z)[1][2] = cosResult;
>+}
>+void sincos(float2x4 x, threadgroup float2x4* y, thread float2x4* z) {
>+    float sinResult;
>+    float cosResult;
>+    sincos(x[0][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][0] = sinResult;
>+    if (z != null)
>+        (*z)[0][0] = cosResult;
>+    sincos(x[0][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][1] = sinResult;
>+    if (z != null)
>+        (*z)[0][1] = cosResult;
>+    sincos(x[0][2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][2] = sinResult;
>+    if (z != null)
>+        (*z)[0][2] = cosResult;
>+    sincos(x[0][3], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][3] = sinResult;
>+    if (z != null)
>+        (*z)[0][3] = cosResult;
>+    sincos(x[1][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][0] = sinResult;
>+    if (z != null)
>+        (*z)[1][0] = cosResult;
>+    sincos(x[1][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][1] = sinResult;
>+    if (z != null)
>+        (*z)[1][1] = cosResult;
>+    sincos(x[1][2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][2] = sinResult;
>+    if (z != null)
>+        (*z)[1][2] = cosResult;
>+    sincos(x[1][3], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][3] = sinResult;
>+    if (z != null)
>+        (*z)[1][3] = cosResult;
>+}
>+void sincos(float3x2 x, threadgroup float3x2* y, thread float3x2* z) {
>+    float sinResult;
>+    float cosResult;
>+    sincos(x[0][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][0] = sinResult;
>+    if (z != null)
>+        (*z)[0][0] = cosResult;
>+    sincos(x[0][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][1] = sinResult;
>+    if (z != null)
>+        (*z)[0][1] = cosResult;
>+    sincos(x[1][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][0] = sinResult;
>+    if (z != null)
>+        (*z)[1][0] = cosResult;
>+    sincos(x[1][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][1] = sinResult;
>+    if (z != null)
>+        (*z)[1][1] = cosResult;
>+    sincos(x[2][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2][0] = sinResult;
>+    if (z != null)
>+        (*z)[2][0] = cosResult;
>+    sincos(x[2][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2][1] = sinResult;
>+    if (z != null)
>+        (*z)[2][1] = cosResult;
>+}
>+void sincos(float3x3 x, threadgroup float3x3* y, thread float3x3* z) {
>+    float sinResult;
>+    float cosResult;
>+    sincos(x[0][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][0] = sinResult;
>+    if (z != null)
>+        (*z)[0][0] = cosResult;
>+    sincos(x[0][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][1] = sinResult;
>+    if (z != null)
>+        (*z)[0][1] = cosResult;
>+    sincos(x[0][2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][2] = sinResult;
>+    if (z != null)
>+        (*z)[0][2] = cosResult;
>+    sincos(x[1][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][0] = sinResult;
>+    if (z != null)
>+        (*z)[1][0] = cosResult;
>+    sincos(x[1][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][1] = sinResult;
>+    if (z != null)
>+        (*z)[1][1] = cosResult;
>+    sincos(x[1][2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][2] = sinResult;
>+    if (z != null)
>+        (*z)[1][2] = cosResult;
>+    sincos(x[2][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2][0] = sinResult;
>+    if (z != null)
>+        (*z)[2][0] = cosResult;
>+    sincos(x[2][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2][1] = sinResult;
>+    if (z != null)
>+        (*z)[2][1] = cosResult;
>+    sincos(x[2][2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2][2] = sinResult;
>+    if (z != null)
>+        (*z)[2][2] = cosResult;
>+}
>+void sincos(float3x4 x, threadgroup float3x4* y, thread float3x4* z) {
>+    float sinResult;
>+    float cosResult;
>+    sincos(x[0][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][0] = sinResult;
>+    if (z != null)
>+        (*z)[0][0] = cosResult;
>+    sincos(x[0][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][1] = sinResult;
>+    if (z != null)
>+        (*z)[0][1] = cosResult;
>+    sincos(x[0][2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][2] = sinResult;
>+    if (z != null)
>+        (*z)[0][2] = cosResult;
>+    sincos(x[0][3], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][3] = sinResult;
>+    if (z != null)
>+        (*z)[0][3] = cosResult;
>+    sincos(x[1][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][0] = sinResult;
>+    if (z != null)
>+        (*z)[1][0] = cosResult;
>+    sincos(x[1][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][1] = sinResult;
>+    if (z != null)
>+        (*z)[1][1] = cosResult;
>+    sincos(x[1][2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][2] = sinResult;
>+    if (z != null)
>+        (*z)[1][2] = cosResult;
>+    sincos(x[1][3], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][3] = sinResult;
>+    if (z != null)
>+        (*z)[1][3] = cosResult;
>+    sincos(x[2][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2][0] = sinResult;
>+    if (z != null)
>+        (*z)[2][0] = cosResult;
>+    sincos(x[2][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2][1] = sinResult;
>+    if (z != null)
>+        (*z)[2][1] = cosResult;
>+    sincos(x[2][2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2][2] = sinResult;
>+    if (z != null)
>+        (*z)[2][2] = cosResult;
>+    sincos(x[2][3], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2][3] = sinResult;
>+    if (z != null)
>+        (*z)[2][3] = cosResult;
>+}
>+void sincos(float4x2 x, threadgroup float4x2* y, thread float4x2* z) {
>+    float sinResult;
>+    float cosResult;
>+    sincos(x[0][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][0] = sinResult;
>+    if (z != null)
>+        (*z)[0][0] = cosResult;
>+    sincos(x[0][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][1] = sinResult;
>+    if (z != null)
>+        (*z)[0][1] = cosResult;
>+    sincos(x[1][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][0] = sinResult;
>+    if (z != null)
>+        (*z)[1][0] = cosResult;
>+    sincos(x[1][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][1] = sinResult;
>+    if (z != null)
>+        (*z)[1][1] = cosResult;
>+    sincos(x[2][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2][0] = sinResult;
>+    if (z != null)
>+        (*z)[2][0] = cosResult;
>+    sincos(x[2][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2][1] = sinResult;
>+    if (z != null)
>+        (*z)[2][1] = cosResult;
>+    sincos(x[3][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[3][0] = sinResult;
>+    if (z != null)
>+        (*z)[3][0] = cosResult;
>+    sincos(x[3][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[3][1] = sinResult;
>+    if (z != null)
>+        (*z)[3][1] = cosResult;
>+}
>+void sincos(float4x3 x, threadgroup float4x3* y, thread float4x3* z) {
>+    float sinResult;
>+    float cosResult;
>+    sincos(x[0][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][0] = sinResult;
>+    if (z != null)
>+        (*z)[0][0] = cosResult;
>+    sincos(x[0][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][1] = sinResult;
>+    if (z != null)
>+        (*z)[0][1] = cosResult;
>+    sincos(x[0][2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][2] = sinResult;
>+    if (z != null)
>+        (*z)[0][2] = cosResult;
>+    sincos(x[1][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][0] = sinResult;
>+    if (z != null)
>+        (*z)[1][0] = cosResult;
>+    sincos(x[1][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][1] = sinResult;
>+    if (z != null)
>+        (*z)[1][1] = cosResult;
>+    sincos(x[1][2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][2] = sinResult;
>+    if (z != null)
>+        (*z)[1][2] = cosResult;
>+    sincos(x[2][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2][0] = sinResult;
>+    if (z != null)
>+        (*z)[2][0] = cosResult;
>+    sincos(x[2][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2][1] = sinResult;
>+    if (z != null)
>+        (*z)[2][1] = cosResult;
>+    sincos(x[2][2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2][2] = sinResult;
>+    if (z != null)
>+        (*z)[2][2] = cosResult;
>+    sincos(x[3][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[3][0] = sinResult;
>+    if (z != null)
>+        (*z)[3][0] = cosResult;
>+    sincos(x[3][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[3][1] = sinResult;
>+    if (z != null)
>+        (*z)[3][1] = cosResult;
>+    sincos(x[3][2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[3][2] = sinResult;
>+    if (z != null)
>+        (*z)[3][2] = cosResult;
>+}
>+void sincos(float4x4 x, threadgroup float4x4* y, thread float4x4* z) {
>+    float sinResult;
>+    float cosResult;
>+    sincos(x[0][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][0] = sinResult;
>+    if (z != null)
>+        (*z)[0][0] = cosResult;
>+    sincos(x[0][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][1] = sinResult;
>+    if (z != null)
>+        (*z)[0][1] = cosResult;
>+    sincos(x[0][2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][2] = sinResult;
>+    if (z != null)
>+        (*z)[0][2] = cosResult;
>+    sincos(x[0][3], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][3] = sinResult;
>+    if (z != null)
>+        (*z)[0][3] = cosResult;
>+    sincos(x[1][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][0] = sinResult;
>+    if (z != null)
>+        (*z)[1][0] = cosResult;
>+    sincos(x[1][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][1] = sinResult;
>+    if (z != null)
>+        (*z)[1][1] = cosResult;
>+    sincos(x[1][2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][2] = sinResult;
>+    if (z != null)
>+        (*z)[1][2] = cosResult;
>+    sincos(x[1][3], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][3] = sinResult;
>+    if (z != null)
>+        (*z)[1][3] = cosResult;
>+    sincos(x[2][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2][0] = sinResult;
>+    if (z != null)
>+        (*z)[2][0] = cosResult;
>+    sincos(x[2][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2][1] = sinResult;
>+    if (z != null)
>+        (*z)[2][1] = cosResult;
>+    sincos(x[2][2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2][2] = sinResult;
>+    if (z != null)
>+        (*z)[2][2] = cosResult;
>+    sincos(x[2][3], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2][3] = sinResult;
>+    if (z != null)
>+        (*z)[2][3] = cosResult;
>+    sincos(x[3][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[3][0] = sinResult;
>+    if (z != null)
>+        (*z)[3][0] = cosResult;
>+    sincos(x[3][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[3][1] = sinResult;
>+    if (z != null)
>+        (*z)[3][1] = cosResult;
>+    sincos(x[3][2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[3][2] = sinResult;
>+    if (z != null)
>+        (*z)[3][2] = cosResult;
>+    sincos(x[3][3], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[3][3] = sinResult;
>+    if (z != null)
>+        (*z)[3][3] = cosResult;
>+}
>+void sincos(half x, threadgroup half* y, device half* z) {
>+    if (y != null)
>+        *y = sin(x);
>+    if (z != null)
>+        *z = cos(x);
>+}
>+void sincos(half2 x, threadgroup half2* y, device half2* z) {
>+    half sinResult;
>+    half cosResult;
>+    sincos(x[0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0] = sinResult;
>+    if (z != null)
>+        (*z)[0] = cosResult;
>+    sincos(x[1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1] = sinResult;
>+    if (z != null)
>+        (*z)[1] = cosResult;
>+}
>+void sincos(half3 x, threadgroup half3* y, device half3* z) {
>+    half sinResult;
>+    half cosResult;
>+    sincos(x[0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0] = sinResult;
>+    if (z != null)
>+        (*z)[0] = cosResult;
>+    sincos(x[1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1] = sinResult;
>+    if (z != null)
>+        (*z)[1] = cosResult;
>+    sincos(x[2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2] = sinResult;
>+    if (z != null)
>+        (*z)[2] = cosResult;
>+}
>+void sincos(half4 x, threadgroup half4* y, device half4* z) {
>+    half sinResult;
>+    half cosResult;
>+    sincos(x[0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0] = sinResult;
>+    if (z != null)
>+        (*z)[0] = cosResult;
>+    sincos(x[1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1] = sinResult;
>+    if (z != null)
>+        (*z)[1] = cosResult;
>+    sincos(x[2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2] = sinResult;
>+    if (z != null)
>+        (*z)[2] = cosResult;
>+    sincos(x[3], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[3] = sinResult;
>+    if (z != null)
>+        (*z)[3] = cosResult;
>+}
>+void sincos(half2x2 x, threadgroup half2x2* y, device half2x2* z) {
>+    half sinResult;
>+    half cosResult;
>+    sincos(x[0][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][0] = sinResult;
>+    if (z != null)
>+        (*z)[0][0] = cosResult;
>+    sincos(x[0][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][1] = sinResult;
>+    if (z != null)
>+        (*z)[0][1] = cosResult;
>+    sincos(x[1][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][0] = sinResult;
>+    if (z != null)
>+        (*z)[1][0] = cosResult;
>+    sincos(x[1][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][1] = sinResult;
>+    if (z != null)
>+        (*z)[1][1] = cosResult;
>+}
>+void sincos(half2x3 x, threadgroup half2x3* y, device half2x3* z) {
>+    half sinResult;
>+    half cosResult;
>+    sincos(x[0][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][0] = sinResult;
>+    if (z != null)
>+        (*z)[0][0] = cosResult;
>+    sincos(x[0][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][1] = sinResult;
>+    if (z != null)
>+        (*z)[0][1] = cosResult;
>+    sincos(x[0][2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][2] = sinResult;
>+    if (z != null)
>+        (*z)[0][2] = cosResult;
>+    sincos(x[1][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][0] = sinResult;
>+    if (z != null)
>+        (*z)[1][0] = cosResult;
>+    sincos(x[1][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][1] = sinResult;
>+    if (z != null)
>+        (*z)[1][1] = cosResult;
>+    sincos(x[1][2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][2] = sinResult;
>+    if (z != null)
>+        (*z)[1][2] = cosResult;
>+}
>+void sincos(half2x4 x, threadgroup half2x4* y, device half2x4* z) {
>+    half sinResult;
>+    half cosResult;
>+    sincos(x[0][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][0] = sinResult;
>+    if (z != null)
>+        (*z)[0][0] = cosResult;
>+    sincos(x[0][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][1] = sinResult;
>+    if (z != null)
>+        (*z)[0][1] = cosResult;
>+    sincos(x[0][2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][2] = sinResult;
>+    if (z != null)
>+        (*z)[0][2] = cosResult;
>+    sincos(x[0][3], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][3] = sinResult;
>+    if (z != null)
>+        (*z)[0][3] = cosResult;
>+    sincos(x[1][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][0] = sinResult;
>+    if (z != null)
>+        (*z)[1][0] = cosResult;
>+    sincos(x[1][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][1] = sinResult;
>+    if (z != null)
>+        (*z)[1][1] = cosResult;
>+    sincos(x[1][2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][2] = sinResult;
>+    if (z != null)
>+        (*z)[1][2] = cosResult;
>+    sincos(x[1][3], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][3] = sinResult;
>+    if (z != null)
>+        (*z)[1][3] = cosResult;
>+}
>+void sincos(half3x2 x, threadgroup half3x2* y, device half3x2* z) {
>+    half sinResult;
>+    half cosResult;
>+    sincos(x[0][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][0] = sinResult;
>+    if (z != null)
>+        (*z)[0][0] = cosResult;
>+    sincos(x[0][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][1] = sinResult;
>+    if (z != null)
>+        (*z)[0][1] = cosResult;
>+    sincos(x[1][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][0] = sinResult;
>+    if (z != null)
>+        (*z)[1][0] = cosResult;
>+    sincos(x[1][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][1] = sinResult;
>+    if (z != null)
>+        (*z)[1][1] = cosResult;
>+    sincos(x[2][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2][0] = sinResult;
>+    if (z != null)
>+        (*z)[2][0] = cosResult;
>+    sincos(x[2][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2][1] = sinResult;
>+    if (z != null)
>+        (*z)[2][1] = cosResult;
>+}
>+void sincos(half3x3 x, threadgroup half3x3* y, device half3x3* z) {
>+    half sinResult;
>+    half cosResult;
>+    sincos(x[0][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][0] = sinResult;
>+    if (z != null)
>+        (*z)[0][0] = cosResult;
>+    sincos(x[0][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][1] = sinResult;
>+    if (z != null)
>+        (*z)[0][1] = cosResult;
>+    sincos(x[0][2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][2] = sinResult;
>+    if (z != null)
>+        (*z)[0][2] = cosResult;
>+    sincos(x[1][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][0] = sinResult;
>+    if (z != null)
>+        (*z)[1][0] = cosResult;
>+    sincos(x[1][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][1] = sinResult;
>+    if (z != null)
>+        (*z)[1][1] = cosResult;
>+    sincos(x[1][2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][2] = sinResult;
>+    if (z != null)
>+        (*z)[1][2] = cosResult;
>+    sincos(x[2][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2][0] = sinResult;
>+    if (z != null)
>+        (*z)[2][0] = cosResult;
>+    sincos(x[2][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2][1] = sinResult;
>+    if (z != null)
>+        (*z)[2][1] = cosResult;
>+    sincos(x[2][2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2][2] = sinResult;
>+    if (z != null)
>+        (*z)[2][2] = cosResult;
>+}
>+void sincos(half3x4 x, threadgroup half3x4* y, device half3x4* z) {
>+    half sinResult;
>+    half cosResult;
>+    sincos(x[0][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][0] = sinResult;
>+    if (z != null)
>+        (*z)[0][0] = cosResult;
>+    sincos(x[0][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][1] = sinResult;
>+    if (z != null)
>+        (*z)[0][1] = cosResult;
>+    sincos(x[0][2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][2] = sinResult;
>+    if (z != null)
>+        (*z)[0][2] = cosResult;
>+    sincos(x[0][3], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][3] = sinResult;
>+    if (z != null)
>+        (*z)[0][3] = cosResult;
>+    sincos(x[1][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][0] = sinResult;
>+    if (z != null)
>+        (*z)[1][0] = cosResult;
>+    sincos(x[1][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][1] = sinResult;
>+    if (z != null)
>+        (*z)[1][1] = cosResult;
>+    sincos(x[1][2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][2] = sinResult;
>+    if (z != null)
>+        (*z)[1][2] = cosResult;
>+    sincos(x[1][3], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][3] = sinResult;
>+    if (z != null)
>+        (*z)[1][3] = cosResult;
>+    sincos(x[2][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2][0] = sinResult;
>+    if (z != null)
>+        (*z)[2][0] = cosResult;
>+    sincos(x[2][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2][1] = sinResult;
>+    if (z != null)
>+        (*z)[2][1] = cosResult;
>+    sincos(x[2][2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2][2] = sinResult;
>+    if (z != null)
>+        (*z)[2][2] = cosResult;
>+    sincos(x[2][3], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2][3] = sinResult;
>+    if (z != null)
>+        (*z)[2][3] = cosResult;
>+}
>+void sincos(half4x2 x, threadgroup half4x2* y, device half4x2* z) {
>+    half sinResult;
>+    half cosResult;
>+    sincos(x[0][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][0] = sinResult;
>+    if (z != null)
>+        (*z)[0][0] = cosResult;
>+    sincos(x[0][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][1] = sinResult;
>+    if (z != null)
>+        (*z)[0][1] = cosResult;
>+    sincos(x[1][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][0] = sinResult;
>+    if (z != null)
>+        (*z)[1][0] = cosResult;
>+    sincos(x[1][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][1] = sinResult;
>+    if (z != null)
>+        (*z)[1][1] = cosResult;
>+    sincos(x[2][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2][0] = sinResult;
>+    if (z != null)
>+        (*z)[2][0] = cosResult;
>+    sincos(x[2][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2][1] = sinResult;
>+    if (z != null)
>+        (*z)[2][1] = cosResult;
>+    sincos(x[3][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[3][0] = sinResult;
>+    if (z != null)
>+        (*z)[3][0] = cosResult;
>+    sincos(x[3][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[3][1] = sinResult;
>+    if (z != null)
>+        (*z)[3][1] = cosResult;
>+}
>+void sincos(half4x3 x, threadgroup half4x3* y, device half4x3* z) {
>+    half sinResult;
>+    half cosResult;
>+    sincos(x[0][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][0] = sinResult;
>+    if (z != null)
>+        (*z)[0][0] = cosResult;
>+    sincos(x[0][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][1] = sinResult;
>+    if (z != null)
>+        (*z)[0][1] = cosResult;
>+    sincos(x[0][2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][2] = sinResult;
>+    if (z != null)
>+        (*z)[0][2] = cosResult;
>+    sincos(x[1][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][0] = sinResult;
>+    if (z != null)
>+        (*z)[1][0] = cosResult;
>+    sincos(x[1][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][1] = sinResult;
>+    if (z != null)
>+        (*z)[1][1] = cosResult;
>+    sincos(x[1][2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][2] = sinResult;
>+    if (z != null)
>+        (*z)[1][2] = cosResult;
>+    sincos(x[2][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2][0] = sinResult;
>+    if (z != null)
>+        (*z)[2][0] = cosResult;
>+    sincos(x[2][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2][1] = sinResult;
>+    if (z != null)
>+        (*z)[2][1] = cosResult;
>+    sincos(x[2][2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2][2] = sinResult;
>+    if (z != null)
>+        (*z)[2][2] = cosResult;
>+    sincos(x[3][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[3][0] = sinResult;
>+    if (z != null)
>+        (*z)[3][0] = cosResult;
>+    sincos(x[3][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[3][1] = sinResult;
>+    if (z != null)
>+        (*z)[3][1] = cosResult;
>+    sincos(x[3][2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[3][2] = sinResult;
>+    if (z != null)
>+        (*z)[3][2] = cosResult;
>+}
>+void sincos(half4x4 x, threadgroup half4x4* y, device half4x4* z) {
>+    half sinResult;
>+    half cosResult;
>+    sincos(x[0][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][0] = sinResult;
>+    if (z != null)
>+        (*z)[0][0] = cosResult;
>+    sincos(x[0][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][1] = sinResult;
>+    if (z != null)
>+        (*z)[0][1] = cosResult;
>+    sincos(x[0][2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][2] = sinResult;
>+    if (z != null)
>+        (*z)[0][2] = cosResult;
>+    sincos(x[0][3], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][3] = sinResult;
>+    if (z != null)
>+        (*z)[0][3] = cosResult;
>+    sincos(x[1][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][0] = sinResult;
>+    if (z != null)
>+        (*z)[1][0] = cosResult;
>+    sincos(x[1][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][1] = sinResult;
>+    if (z != null)
>+        (*z)[1][1] = cosResult;
>+    sincos(x[1][2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][2] = sinResult;
>+    if (z != null)
>+        (*z)[1][2] = cosResult;
>+    sincos(x[1][3], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][3] = sinResult;
>+    if (z != null)
>+        (*z)[1][3] = cosResult;
>+    sincos(x[2][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2][0] = sinResult;
>+    if (z != null)
>+        (*z)[2][0] = cosResult;
>+    sincos(x[2][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2][1] = sinResult;
>+    if (z != null)
>+        (*z)[2][1] = cosResult;
>+    sincos(x[2][2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2][2] = sinResult;
>+    if (z != null)
>+        (*z)[2][2] = cosResult;
>+    sincos(x[2][3], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2][3] = sinResult;
>+    if (z != null)
>+        (*z)[2][3] = cosResult;
>+    sincos(x[3][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[3][0] = sinResult;
>+    if (z != null)
>+        (*z)[3][0] = cosResult;
>+    sincos(x[3][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[3][1] = sinResult;
>+    if (z != null)
>+        (*z)[3][1] = cosResult;
>+    sincos(x[3][2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[3][2] = sinResult;
>+    if (z != null)
>+        (*z)[3][2] = cosResult;
>+    sincos(x[3][3], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[3][3] = sinResult;
>+    if (z != null)
>+        (*z)[3][3] = cosResult;
>+}
>+void sincos(float x, threadgroup float* y, device float* z) {
>+    if (y != null)
>+        *y = sin(x);
>+    if (z != null)
>+        *z = cos(x);
>+}
>+void sincos(float2 x, threadgroup float2* y, device float2* z) {
>+    float sinResult;
>+    float cosResult;
>+    sincos(x[0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0] = sinResult;
>+    if (z != null)
>+        (*z)[0] = cosResult;
>+    sincos(x[1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1] = sinResult;
>+    if (z != null)
>+        (*z)[1] = cosResult;
>+}
>+void sincos(float3 x, threadgroup float3* y, device float3* z) {
>+    float sinResult;
>+    float cosResult;
>+    sincos(x[0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0] = sinResult;
>+    if (z != null)
>+        (*z)[0] = cosResult;
>+    sincos(x[1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1] = sinResult;
>+    if (z != null)
>+        (*z)[1] = cosResult;
>+    sincos(x[2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2] = sinResult;
>+    if (z != null)
>+        (*z)[2] = cosResult;
>+}
>+void sincos(float4 x, threadgroup float4* y, device float4* z) {
>+    float sinResult;
>+    float cosResult;
>+    sincos(x[0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0] = sinResult;
>+    if (z != null)
>+        (*z)[0] = cosResult;
>+    sincos(x[1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1] = sinResult;
>+    if (z != null)
>+        (*z)[1] = cosResult;
>+    sincos(x[2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2] = sinResult;
>+    if (z != null)
>+        (*z)[2] = cosResult;
>+    sincos(x[3], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[3] = sinResult;
>+    if (z != null)
>+        (*z)[3] = cosResult;
>+}
>+void sincos(float2x2 x, threadgroup float2x2* y, device float2x2* z) {
>+    float sinResult;
>+    float cosResult;
>+    sincos(x[0][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][0] = sinResult;
>+    if (z != null)
>+        (*z)[0][0] = cosResult;
>+    sincos(x[0][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][1] = sinResult;
>+    if (z != null)
>+        (*z)[0][1] = cosResult;
>+    sincos(x[1][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][0] = sinResult;
>+    if (z != null)
>+        (*z)[1][0] = cosResult;
>+    sincos(x[1][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][1] = sinResult;
>+    if (z != null)
>+        (*z)[1][1] = cosResult;
>+}
>+void sincos(float2x3 x, threadgroup float2x3* y, device float2x3* z) {
>+    float sinResult;
>+    float cosResult;
>+    sincos(x[0][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][0] = sinResult;
>+    if (z != null)
>+        (*z)[0][0] = cosResult;
>+    sincos(x[0][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][1] = sinResult;
>+    if (z != null)
>+        (*z)[0][1] = cosResult;
>+    sincos(x[0][2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][2] = sinResult;
>+    if (z != null)
>+        (*z)[0][2] = cosResult;
>+    sincos(x[1][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][0] = sinResult;
>+    if (z != null)
>+        (*z)[1][0] = cosResult;
>+    sincos(x[1][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][1] = sinResult;
>+    if (z != null)
>+        (*z)[1][1] = cosResult;
>+    sincos(x[1][2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][2] = sinResult;
>+    if (z != null)
>+        (*z)[1][2] = cosResult;
>+}
>+void sincos(float2x4 x, threadgroup float2x4* y, device float2x4* z) {
>+    float sinResult;
>+    float cosResult;
>+    sincos(x[0][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][0] = sinResult;
>+    if (z != null)
>+        (*z)[0][0] = cosResult;
>+    sincos(x[0][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][1] = sinResult;
>+    if (z != null)
>+        (*z)[0][1] = cosResult;
>+    sincos(x[0][2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][2] = sinResult;
>+    if (z != null)
>+        (*z)[0][2] = cosResult;
>+    sincos(x[0][3], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][3] = sinResult;
>+    if (z != null)
>+        (*z)[0][3] = cosResult;
>+    sincos(x[1][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][0] = sinResult;
>+    if (z != null)
>+        (*z)[1][0] = cosResult;
>+    sincos(x[1][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][1] = sinResult;
>+    if (z != null)
>+        (*z)[1][1] = cosResult;
>+    sincos(x[1][2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][2] = sinResult;
>+    if (z != null)
>+        (*z)[1][2] = cosResult;
>+    sincos(x[1][3], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][3] = sinResult;
>+    if (z != null)
>+        (*z)[1][3] = cosResult;
>+}
>+void sincos(float3x2 x, threadgroup float3x2* y, device float3x2* z) {
>+    float sinResult;
>+    float cosResult;
>+    sincos(x[0][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][0] = sinResult;
>+    if (z != null)
>+        (*z)[0][0] = cosResult;
>+    sincos(x[0][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][1] = sinResult;
>+    if (z != null)
>+        (*z)[0][1] = cosResult;
>+    sincos(x[1][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][0] = sinResult;
>+    if (z != null)
>+        (*z)[1][0] = cosResult;
>+    sincos(x[1][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][1] = sinResult;
>+    if (z != null)
>+        (*z)[1][1] = cosResult;
>+    sincos(x[2][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2][0] = sinResult;
>+    if (z != null)
>+        (*z)[2][0] = cosResult;
>+    sincos(x[2][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2][1] = sinResult;
>+    if (z != null)
>+        (*z)[2][1] = cosResult;
>+}
>+void sincos(float3x3 x, threadgroup float3x3* y, device float3x3* z) {
>+    float sinResult;
>+    float cosResult;
>+    sincos(x[0][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][0] = sinResult;
>+    if (z != null)
>+        (*z)[0][0] = cosResult;
>+    sincos(x[0][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][1] = sinResult;
>+    if (z != null)
>+        (*z)[0][1] = cosResult;
>+    sincos(x[0][2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][2] = sinResult;
>+    if (z != null)
>+        (*z)[0][2] = cosResult;
>+    sincos(x[1][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][0] = sinResult;
>+    if (z != null)
>+        (*z)[1][0] = cosResult;
>+    sincos(x[1][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][1] = sinResult;
>+    if (z != null)
>+        (*z)[1][1] = cosResult;
>+    sincos(x[1][2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][2] = sinResult;
>+    if (z != null)
>+        (*z)[1][2] = cosResult;
>+    sincos(x[2][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2][0] = sinResult;
>+    if (z != null)
>+        (*z)[2][0] = cosResult;
>+    sincos(x[2][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2][1] = sinResult;
>+    if (z != null)
>+        (*z)[2][1] = cosResult;
>+    sincos(x[2][2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2][2] = sinResult;
>+    if (z != null)
>+        (*z)[2][2] = cosResult;
>+}
>+void sincos(float3x4 x, threadgroup float3x4* y, device float3x4* z) {
>+    float sinResult;
>+    float cosResult;
>+    sincos(x[0][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][0] = sinResult;
>+    if (z != null)
>+        (*z)[0][0] = cosResult;
>+    sincos(x[0][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][1] = sinResult;
>+    if (z != null)
>+        (*z)[0][1] = cosResult;
>+    sincos(x[0][2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][2] = sinResult;
>+    if (z != null)
>+        (*z)[0][2] = cosResult;
>+    sincos(x[0][3], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][3] = sinResult;
>+    if (z != null)
>+        (*z)[0][3] = cosResult;
>+    sincos(x[1][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][0] = sinResult;
>+    if (z != null)
>+        (*z)[1][0] = cosResult;
>+    sincos(x[1][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][1] = sinResult;
>+    if (z != null)
>+        (*z)[1][1] = cosResult;
>+    sincos(x[1][2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][2] = sinResult;
>+    if (z != null)
>+        (*z)[1][2] = cosResult;
>+    sincos(x[1][3], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][3] = sinResult;
>+    if (z != null)
>+        (*z)[1][3] = cosResult;
>+    sincos(x[2][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2][0] = sinResult;
>+    if (z != null)
>+        (*z)[2][0] = cosResult;
>+    sincos(x[2][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2][1] = sinResult;
>+    if (z != null)
>+        (*z)[2][1] = cosResult;
>+    sincos(x[2][2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2][2] = sinResult;
>+    if (z != null)
>+        (*z)[2][2] = cosResult;
>+    sincos(x[2][3], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2][3] = sinResult;
>+    if (z != null)
>+        (*z)[2][3] = cosResult;
>+}
>+void sincos(float4x2 x, threadgroup float4x2* y, device float4x2* z) {
>+    float sinResult;
>+    float cosResult;
>+    sincos(x[0][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][0] = sinResult;
>+    if (z != null)
>+        (*z)[0][0] = cosResult;
>+    sincos(x[0][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][1] = sinResult;
>+    if (z != null)
>+        (*z)[0][1] = cosResult;
>+    sincos(x[1][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][0] = sinResult;
>+    if (z != null)
>+        (*z)[1][0] = cosResult;
>+    sincos(x[1][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][1] = sinResult;
>+    if (z != null)
>+        (*z)[1][1] = cosResult;
>+    sincos(x[2][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2][0] = sinResult;
>+    if (z != null)
>+        (*z)[2][0] = cosResult;
>+    sincos(x[2][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2][1] = sinResult;
>+    if (z != null)
>+        (*z)[2][1] = cosResult;
>+    sincos(x[3][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[3][0] = sinResult;
>+    if (z != null)
>+        (*z)[3][0] = cosResult;
>+    sincos(x[3][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[3][1] = sinResult;
>+    if (z != null)
>+        (*z)[3][1] = cosResult;
>+}
>+void sincos(float4x3 x, threadgroup float4x3* y, device float4x3* z) {
>+    float sinResult;
>+    float cosResult;
>+    sincos(x[0][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][0] = sinResult;
>+    if (z != null)
>+        (*z)[0][0] = cosResult;
>+    sincos(x[0][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][1] = sinResult;
>+    if (z != null)
>+        (*z)[0][1] = cosResult;
>+    sincos(x[0][2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][2] = sinResult;
>+    if (z != null)
>+        (*z)[0][2] = cosResult;
>+    sincos(x[1][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][0] = sinResult;
>+    if (z != null)
>+        (*z)[1][0] = cosResult;
>+    sincos(x[1][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][1] = sinResult;
>+    if (z != null)
>+        (*z)[1][1] = cosResult;
>+    sincos(x[1][2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][2] = sinResult;
>+    if (z != null)
>+        (*z)[1][2] = cosResult;
>+    sincos(x[2][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2][0] = sinResult;
>+    if (z != null)
>+        (*z)[2][0] = cosResult;
>+    sincos(x[2][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2][1] = sinResult;
>+    if (z != null)
>+        (*z)[2][1] = cosResult;
>+    sincos(x[2][2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2][2] = sinResult;
>+    if (z != null)
>+        (*z)[2][2] = cosResult;
>+    sincos(x[3][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[3][0] = sinResult;
>+    if (z != null)
>+        (*z)[3][0] = cosResult;
>+    sincos(x[3][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[3][1] = sinResult;
>+    if (z != null)
>+        (*z)[3][1] = cosResult;
>+    sincos(x[3][2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[3][2] = sinResult;
>+    if (z != null)
>+        (*z)[3][2] = cosResult;
>+}
>+void sincos(float4x4 x, threadgroup float4x4* y, device float4x4* z) {
>+    float sinResult;
>+    float cosResult;
>+    sincos(x[0][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][0] = sinResult;
>+    if (z != null)
>+        (*z)[0][0] = cosResult;
>+    sincos(x[0][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][1] = sinResult;
>+    if (z != null)
>+        (*z)[0][1] = cosResult;
>+    sincos(x[0][2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][2] = sinResult;
>+    if (z != null)
>+        (*z)[0][2] = cosResult;
>+    sincos(x[0][3], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][3] = sinResult;
>+    if (z != null)
>+        (*z)[0][3] = cosResult;
>+    sincos(x[1][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][0] = sinResult;
>+    if (z != null)
>+        (*z)[1][0] = cosResult;
>+    sincos(x[1][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][1] = sinResult;
>+    if (z != null)
>+        (*z)[1][1] = cosResult;
>+    sincos(x[1][2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][2] = sinResult;
>+    if (z != null)
>+        (*z)[1][2] = cosResult;
>+    sincos(x[1][3], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][3] = sinResult;
>+    if (z != null)
>+        (*z)[1][3] = cosResult;
>+    sincos(x[2][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2][0] = sinResult;
>+    if (z != null)
>+        (*z)[2][0] = cosResult;
>+    sincos(x[2][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2][1] = sinResult;
>+    if (z != null)
>+        (*z)[2][1] = cosResult;
>+    sincos(x[2][2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2][2] = sinResult;
>+    if (z != null)
>+        (*z)[2][2] = cosResult;
>+    sincos(x[2][3], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2][3] = sinResult;
>+    if (z != null)
>+        (*z)[2][3] = cosResult;
>+    sincos(x[3][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[3][0] = sinResult;
>+    if (z != null)
>+        (*z)[3][0] = cosResult;
>+    sincos(x[3][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[3][1] = sinResult;
>+    if (z != null)
>+        (*z)[3][1] = cosResult;
>+    sincos(x[3][2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[3][2] = sinResult;
>+    if (z != null)
>+        (*z)[3][2] = cosResult;
>+    sincos(x[3][3], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[3][3] = sinResult;
>+    if (z != null)
>+        (*z)[3][3] = cosResult;
>+}
>+void sincos(half x, threadgroup half* y, threadgroup half* z) {
>+    if (y != null)
>+        *y = sin(x);
>+    if (z != null)
>+        *z = cos(x);
>+}
>+void sincos(half2 x, threadgroup half2* y, threadgroup half2* z) {
>+    half sinResult;
>+    half cosResult;
>+    sincos(x[0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0] = sinResult;
>+    if (z != null)
>+        (*z)[0] = cosResult;
>+    sincos(x[1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1] = sinResult;
>+    if (z != null)
>+        (*z)[1] = cosResult;
>+}
>+void sincos(half3 x, threadgroup half3* y, threadgroup half3* z) {
>+    half sinResult;
>+    half cosResult;
>+    sincos(x[0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0] = sinResult;
>+    if (z != null)
>+        (*z)[0] = cosResult;
>+    sincos(x[1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1] = sinResult;
>+    if (z != null)
>+        (*z)[1] = cosResult;
>+    sincos(x[2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2] = sinResult;
>+    if (z != null)
>+        (*z)[2] = cosResult;
>+}
>+void sincos(half4 x, threadgroup half4* y, threadgroup half4* z) {
>+    half sinResult;
>+    half cosResult;
>+    sincos(x[0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0] = sinResult;
>+    if (z != null)
>+        (*z)[0] = cosResult;
>+    sincos(x[1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1] = sinResult;
>+    if (z != null)
>+        (*z)[1] = cosResult;
>+    sincos(x[2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2] = sinResult;
>+    if (z != null)
>+        (*z)[2] = cosResult;
>+    sincos(x[3], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[3] = sinResult;
>+    if (z != null)
>+        (*z)[3] = cosResult;
>+}
>+void sincos(half2x2 x, threadgroup half2x2* y, threadgroup half2x2* z) {
>+    half sinResult;
>+    half cosResult;
>+    sincos(x[0][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][0] = sinResult;
>+    if (z != null)
>+        (*z)[0][0] = cosResult;
>+    sincos(x[0][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][1] = sinResult;
>+    if (z != null)
>+        (*z)[0][1] = cosResult;
>+    sincos(x[1][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][0] = sinResult;
>+    if (z != null)
>+        (*z)[1][0] = cosResult;
>+    sincos(x[1][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][1] = sinResult;
>+    if (z != null)
>+        (*z)[1][1] = cosResult;
>+}
>+void sincos(half2x3 x, threadgroup half2x3* y, threadgroup half2x3* z) {
>+    half sinResult;
>+    half cosResult;
>+    sincos(x[0][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][0] = sinResult;
>+    if (z != null)
>+        (*z)[0][0] = cosResult;
>+    sincos(x[0][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][1] = sinResult;
>+    if (z != null)
>+        (*z)[0][1] = cosResult;
>+    sincos(x[0][2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][2] = sinResult;
>+    if (z != null)
>+        (*z)[0][2] = cosResult;
>+    sincos(x[1][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][0] = sinResult;
>+    if (z != null)
>+        (*z)[1][0] = cosResult;
>+    sincos(x[1][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][1] = sinResult;
>+    if (z != null)
>+        (*z)[1][1] = cosResult;
>+    sincos(x[1][2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][2] = sinResult;
>+    if (z != null)
>+        (*z)[1][2] = cosResult;
>+}
>+void sincos(half2x4 x, threadgroup half2x4* y, threadgroup half2x4* z) {
>+    half sinResult;
>+    half cosResult;
>+    sincos(x[0][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][0] = sinResult;
>+    if (z != null)
>+        (*z)[0][0] = cosResult;
>+    sincos(x[0][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][1] = sinResult;
>+    if (z != null)
>+        (*z)[0][1] = cosResult;
>+    sincos(x[0][2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][2] = sinResult;
>+    if (z != null)
>+        (*z)[0][2] = cosResult;
>+    sincos(x[0][3], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][3] = sinResult;
>+    if (z != null)
>+        (*z)[0][3] = cosResult;
>+    sincos(x[1][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][0] = sinResult;
>+    if (z != null)
>+        (*z)[1][0] = cosResult;
>+    sincos(x[1][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][1] = sinResult;
>+    if (z != null)
>+        (*z)[1][1] = cosResult;
>+    sincos(x[1][2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][2] = sinResult;
>+    if (z != null)
>+        (*z)[1][2] = cosResult;
>+    sincos(x[1][3], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][3] = sinResult;
>+    if (z != null)
>+        (*z)[1][3] = cosResult;
>+}
>+void sincos(half3x2 x, threadgroup half3x2* y, threadgroup half3x2* z) {
>+    half sinResult;
>+    half cosResult;
>+    sincos(x[0][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][0] = sinResult;
>+    if (z != null)
>+        (*z)[0][0] = cosResult;
>+    sincos(x[0][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][1] = sinResult;
>+    if (z != null)
>+        (*z)[0][1] = cosResult;
>+    sincos(x[1][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][0] = sinResult;
>+    if (z != null)
>+        (*z)[1][0] = cosResult;
>+    sincos(x[1][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][1] = sinResult;
>+    if (z != null)
>+        (*z)[1][1] = cosResult;
>+    sincos(x[2][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2][0] = sinResult;
>+    if (z != null)
>+        (*z)[2][0] = cosResult;
>+    sincos(x[2][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2][1] = sinResult;
>+    if (z != null)
>+        (*z)[2][1] = cosResult;
>+}
>+void sincos(half3x3 x, threadgroup half3x3* y, threadgroup half3x3* z) {
>+    half sinResult;
>+    half cosResult;
>+    sincos(x[0][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][0] = sinResult;
>+    if (z != null)
>+        (*z)[0][0] = cosResult;
>+    sincos(x[0][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][1] = sinResult;
>+    if (z != null)
>+        (*z)[0][1] = cosResult;
>+    sincos(x[0][2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][2] = sinResult;
>+    if (z != null)
>+        (*z)[0][2] = cosResult;
>+    sincos(x[1][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][0] = sinResult;
>+    if (z != null)
>+        (*z)[1][0] = cosResult;
>+    sincos(x[1][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][1] = sinResult;
>+    if (z != null)
>+        (*z)[1][1] = cosResult;
>+    sincos(x[1][2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][2] = sinResult;
>+    if (z != null)
>+        (*z)[1][2] = cosResult;
>+    sincos(x[2][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2][0] = sinResult;
>+    if (z != null)
>+        (*z)[2][0] = cosResult;
>+    sincos(x[2][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2][1] = sinResult;
>+    if (z != null)
>+        (*z)[2][1] = cosResult;
>+    sincos(x[2][2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2][2] = sinResult;
>+    if (z != null)
>+        (*z)[2][2] = cosResult;
>+}
>+void sincos(half3x4 x, threadgroup half3x4* y, threadgroup half3x4* z) {
>+    half sinResult;
>+    half cosResult;
>+    sincos(x[0][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][0] = sinResult;
>+    if (z != null)
>+        (*z)[0][0] = cosResult;
>+    sincos(x[0][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][1] = sinResult;
>+    if (z != null)
>+        (*z)[0][1] = cosResult;
>+    sincos(x[0][2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][2] = sinResult;
>+    if (z != null)
>+        (*z)[0][2] = cosResult;
>+    sincos(x[0][3], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][3] = sinResult;
>+    if (z != null)
>+        (*z)[0][3] = cosResult;
>+    sincos(x[1][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][0] = sinResult;
>+    if (z != null)
>+        (*z)[1][0] = cosResult;
>+    sincos(x[1][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][1] = sinResult;
>+    if (z != null)
>+        (*z)[1][1] = cosResult;
>+    sincos(x[1][2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][2] = sinResult;
>+    if (z != null)
>+        (*z)[1][2] = cosResult;
>+    sincos(x[1][3], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][3] = sinResult;
>+    if (z != null)
>+        (*z)[1][3] = cosResult;
>+    sincos(x[2][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2][0] = sinResult;
>+    if (z != null)
>+        (*z)[2][0] = cosResult;
>+    sincos(x[2][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2][1] = sinResult;
>+    if (z != null)
>+        (*z)[2][1] = cosResult;
>+    sincos(x[2][2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2][2] = sinResult;
>+    if (z != null)
>+        (*z)[2][2] = cosResult;
>+    sincos(x[2][3], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2][3] = sinResult;
>+    if (z != null)
>+        (*z)[2][3] = cosResult;
>+}
>+void sincos(half4x2 x, threadgroup half4x2* y, threadgroup half4x2* z) {
>+    half sinResult;
>+    half cosResult;
>+    sincos(x[0][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][0] = sinResult;
>+    if (z != null)
>+        (*z)[0][0] = cosResult;
>+    sincos(x[0][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][1] = sinResult;
>+    if (z != null)
>+        (*z)[0][1] = cosResult;
>+    sincos(x[1][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][0] = sinResult;
>+    if (z != null)
>+        (*z)[1][0] = cosResult;
>+    sincos(x[1][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][1] = sinResult;
>+    if (z != null)
>+        (*z)[1][1] = cosResult;
>+    sincos(x[2][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2][0] = sinResult;
>+    if (z != null)
>+        (*z)[2][0] = cosResult;
>+    sincos(x[2][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2][1] = sinResult;
>+    if (z != null)
>+        (*z)[2][1] = cosResult;
>+    sincos(x[3][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[3][0] = sinResult;
>+    if (z != null)
>+        (*z)[3][0] = cosResult;
>+    sincos(x[3][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[3][1] = sinResult;
>+    if (z != null)
>+        (*z)[3][1] = cosResult;
>+}
>+void sincos(half4x3 x, threadgroup half4x3* y, threadgroup half4x3* z) {
>+    half sinResult;
>+    half cosResult;
>+    sincos(x[0][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][0] = sinResult;
>+    if (z != null)
>+        (*z)[0][0] = cosResult;
>+    sincos(x[0][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][1] = sinResult;
>+    if (z != null)
>+        (*z)[0][1] = cosResult;
>+    sincos(x[0][2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][2] = sinResult;
>+    if (z != null)
>+        (*z)[0][2] = cosResult;
>+    sincos(x[1][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][0] = sinResult;
>+    if (z != null)
>+        (*z)[1][0] = cosResult;
>+    sincos(x[1][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][1] = sinResult;
>+    if (z != null)
>+        (*z)[1][1] = cosResult;
>+    sincos(x[1][2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][2] = sinResult;
>+    if (z != null)
>+        (*z)[1][2] = cosResult;
>+    sincos(x[2][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2][0] = sinResult;
>+    if (z != null)
>+        (*z)[2][0] = cosResult;
>+    sincos(x[2][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2][1] = sinResult;
>+    if (z != null)
>+        (*z)[2][1] = cosResult;
>+    sincos(x[2][2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2][2] = sinResult;
>+    if (z != null)
>+        (*z)[2][2] = cosResult;
>+    sincos(x[3][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[3][0] = sinResult;
>+    if (z != null)
>+        (*z)[3][0] = cosResult;
>+    sincos(x[3][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[3][1] = sinResult;
>+    if (z != null)
>+        (*z)[3][1] = cosResult;
>+    sincos(x[3][2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[3][2] = sinResult;
>+    if (z != null)
>+        (*z)[3][2] = cosResult;
>+}
>+void sincos(half4x4 x, threadgroup half4x4* y, threadgroup half4x4* z) {
>+    half sinResult;
>+    half cosResult;
>+    sincos(x[0][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][0] = sinResult;
>+    if (z != null)
>+        (*z)[0][0] = cosResult;
>+    sincos(x[0][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][1] = sinResult;
>+    if (z != null)
>+        (*z)[0][1] = cosResult;
>+    sincos(x[0][2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][2] = sinResult;
>+    if (z != null)
>+        (*z)[0][2] = cosResult;
>+    sincos(x[0][3], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][3] = sinResult;
>+    if (z != null)
>+        (*z)[0][3] = cosResult;
>+    sincos(x[1][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][0] = sinResult;
>+    if (z != null)
>+        (*z)[1][0] = cosResult;
>+    sincos(x[1][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][1] = sinResult;
>+    if (z != null)
>+        (*z)[1][1] = cosResult;
>+    sincos(x[1][2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][2] = sinResult;
>+    if (z != null)
>+        (*z)[1][2] = cosResult;
>+    sincos(x[1][3], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][3] = sinResult;
>+    if (z != null)
>+        (*z)[1][3] = cosResult;
>+    sincos(x[2][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2][0] = sinResult;
>+    if (z != null)
>+        (*z)[2][0] = cosResult;
>+    sincos(x[2][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2][1] = sinResult;
>+    if (z != null)
>+        (*z)[2][1] = cosResult;
>+    sincos(x[2][2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2][2] = sinResult;
>+    if (z != null)
>+        (*z)[2][2] = cosResult;
>+    sincos(x[2][3], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2][3] = sinResult;
>+    if (z != null)
>+        (*z)[2][3] = cosResult;
>+    sincos(x[3][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[3][0] = sinResult;
>+    if (z != null)
>+        (*z)[3][0] = cosResult;
>+    sincos(x[3][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[3][1] = sinResult;
>+    if (z != null)
>+        (*z)[3][1] = cosResult;
>+    sincos(x[3][2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[3][2] = sinResult;
>+    if (z != null)
>+        (*z)[3][2] = cosResult;
>+    sincos(x[3][3], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[3][3] = sinResult;
>+    if (z != null)
>+        (*z)[3][3] = cosResult;
>+}
>+void sincos(float x, threadgroup float* y, threadgroup float* z) {
>+    if (y != null)
>+        *y = sin(x);
>+    if (z != null)
>+        *z = cos(x);
>+}
>+void sincos(float2 x, threadgroup float2* y, threadgroup float2* z) {
>+    float sinResult;
>+    float cosResult;
>+    sincos(x[0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0] = sinResult;
>+    if (z != null)
>+        (*z)[0] = cosResult;
>+    sincos(x[1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1] = sinResult;
>+    if (z != null)
>+        (*z)[1] = cosResult;
>+}
>+void sincos(float3 x, threadgroup float3* y, threadgroup float3* z) {
>+    float sinResult;
>+    float cosResult;
>+    sincos(x[0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0] = sinResult;
>+    if (z != null)
>+        (*z)[0] = cosResult;
>+    sincos(x[1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1] = sinResult;
>+    if (z != null)
>+        (*z)[1] = cosResult;
>+    sincos(x[2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2] = sinResult;
>+    if (z != null)
>+        (*z)[2] = cosResult;
>+}
>+void sincos(float4 x, threadgroup float4* y, threadgroup float4* z) {
>+    float sinResult;
>+    float cosResult;
>+    sincos(x[0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0] = sinResult;
>+    if (z != null)
>+        (*z)[0] = cosResult;
>+    sincos(x[1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1] = sinResult;
>+    if (z != null)
>+        (*z)[1] = cosResult;
>+    sincos(x[2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2] = sinResult;
>+    if (z != null)
>+        (*z)[2] = cosResult;
>+    sincos(x[3], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[3] = sinResult;
>+    if (z != null)
>+        (*z)[3] = cosResult;
>+}
>+void sincos(float2x2 x, threadgroup float2x2* y, threadgroup float2x2* z) {
>+    float sinResult;
>+    float cosResult;
>+    sincos(x[0][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][0] = sinResult;
>+    if (z != null)
>+        (*z)[0][0] = cosResult;
>+    sincos(x[0][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][1] = sinResult;
>+    if (z != null)
>+        (*z)[0][1] = cosResult;
>+    sincos(x[1][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][0] = sinResult;
>+    if (z != null)
>+        (*z)[1][0] = cosResult;
>+    sincos(x[1][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][1] = sinResult;
>+    if (z != null)
>+        (*z)[1][1] = cosResult;
>+}
>+void sincos(float2x3 x, threadgroup float2x3* y, threadgroup float2x3* z) {
>+    float sinResult;
>+    float cosResult;
>+    sincos(x[0][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][0] = sinResult;
>+    if (z != null)
>+        (*z)[0][0] = cosResult;
>+    sincos(x[0][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][1] = sinResult;
>+    if (z != null)
>+        (*z)[0][1] = cosResult;
>+    sincos(x[0][2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][2] = sinResult;
>+    if (z != null)
>+        (*z)[0][2] = cosResult;
>+    sincos(x[1][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][0] = sinResult;
>+    if (z != null)
>+        (*z)[1][0] = cosResult;
>+    sincos(x[1][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][1] = sinResult;
>+    if (z != null)
>+        (*z)[1][1] = cosResult;
>+    sincos(x[1][2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][2] = sinResult;
>+    if (z != null)
>+        (*z)[1][2] = cosResult;
>+}
>+void sincos(float2x4 x, threadgroup float2x4* y, threadgroup float2x4* z) {
>+    float sinResult;
>+    float cosResult;
>+    sincos(x[0][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][0] = sinResult;
>+    if (z != null)
>+        (*z)[0][0] = cosResult;
>+    sincos(x[0][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][1] = sinResult;
>+    if (z != null)
>+        (*z)[0][1] = cosResult;
>+    sincos(x[0][2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][2] = sinResult;
>+    if (z != null)
>+        (*z)[0][2] = cosResult;
>+    sincos(x[0][3], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][3] = sinResult;
>+    if (z != null)
>+        (*z)[0][3] = cosResult;
>+    sincos(x[1][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][0] = sinResult;
>+    if (z != null)
>+        (*z)[1][0] = cosResult;
>+    sincos(x[1][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][1] = sinResult;
>+    if (z != null)
>+        (*z)[1][1] = cosResult;
>+    sincos(x[1][2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][2] = sinResult;
>+    if (z != null)
>+        (*z)[1][2] = cosResult;
>+    sincos(x[1][3], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][3] = sinResult;
>+    if (z != null)
>+        (*z)[1][3] = cosResult;
>+}
>+void sincos(float3x2 x, threadgroup float3x2* y, threadgroup float3x2* z) {
>+    float sinResult;
>+    float cosResult;
>+    sincos(x[0][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][0] = sinResult;
>+    if (z != null)
>+        (*z)[0][0] = cosResult;
>+    sincos(x[0][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][1] = sinResult;
>+    if (z != null)
>+        (*z)[0][1] = cosResult;
>+    sincos(x[1][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][0] = sinResult;
>+    if (z != null)
>+        (*z)[1][0] = cosResult;
>+    sincos(x[1][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][1] = sinResult;
>+    if (z != null)
>+        (*z)[1][1] = cosResult;
>+    sincos(x[2][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2][0] = sinResult;
>+    if (z != null)
>+        (*z)[2][0] = cosResult;
>+    sincos(x[2][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2][1] = sinResult;
>+    if (z != null)
>+        (*z)[2][1] = cosResult;
>+}
>+void sincos(float3x3 x, threadgroup float3x3* y, threadgroup float3x3* z) {
>+    float sinResult;
>+    float cosResult;
>+    sincos(x[0][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][0] = sinResult;
>+    if (z != null)
>+        (*z)[0][0] = cosResult;
>+    sincos(x[0][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][1] = sinResult;
>+    if (z != null)
>+        (*z)[0][1] = cosResult;
>+    sincos(x[0][2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][2] = sinResult;
>+    if (z != null)
>+        (*z)[0][2] = cosResult;
>+    sincos(x[1][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][0] = sinResult;
>+    if (z != null)
>+        (*z)[1][0] = cosResult;
>+    sincos(x[1][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][1] = sinResult;
>+    if (z != null)
>+        (*z)[1][1] = cosResult;
>+    sincos(x[1][2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][2] = sinResult;
>+    if (z != null)
>+        (*z)[1][2] = cosResult;
>+    sincos(x[2][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2][0] = sinResult;
>+    if (z != null)
>+        (*z)[2][0] = cosResult;
>+    sincos(x[2][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2][1] = sinResult;
>+    if (z != null)
>+        (*z)[2][1] = cosResult;
>+    sincos(x[2][2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2][2] = sinResult;
>+    if (z != null)
>+        (*z)[2][2] = cosResult;
>+}
>+void sincos(float3x4 x, threadgroup float3x4* y, threadgroup float3x4* z) {
>+    float sinResult;
>+    float cosResult;
>+    sincos(x[0][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][0] = sinResult;
>+    if (z != null)
>+        (*z)[0][0] = cosResult;
>+    sincos(x[0][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][1] = sinResult;
>+    if (z != null)
>+        (*z)[0][1] = cosResult;
>+    sincos(x[0][2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][2] = sinResult;
>+    if (z != null)
>+        (*z)[0][2] = cosResult;
>+    sincos(x[0][3], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][3] = sinResult;
>+    if (z != null)
>+        (*z)[0][3] = cosResult;
>+    sincos(x[1][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][0] = sinResult;
>+    if (z != null)
>+        (*z)[1][0] = cosResult;
>+    sincos(x[1][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][1] = sinResult;
>+    if (z != null)
>+        (*z)[1][1] = cosResult;
>+    sincos(x[1][2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][2] = sinResult;
>+    if (z != null)
>+        (*z)[1][2] = cosResult;
>+    sincos(x[1][3], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][3] = sinResult;
>+    if (z != null)
>+        (*z)[1][3] = cosResult;
>+    sincos(x[2][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2][0] = sinResult;
>+    if (z != null)
>+        (*z)[2][0] = cosResult;
>+    sincos(x[2][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2][1] = sinResult;
>+    if (z != null)
>+        (*z)[2][1] = cosResult;
>+    sincos(x[2][2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2][2] = sinResult;
>+    if (z != null)
>+        (*z)[2][2] = cosResult;
>+    sincos(x[2][3], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2][3] = sinResult;
>+    if (z != null)
>+        (*z)[2][3] = cosResult;
>+}
>+void sincos(float4x2 x, threadgroup float4x2* y, threadgroup float4x2* z) {
>+    float sinResult;
>+    float cosResult;
>+    sincos(x[0][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][0] = sinResult;
>+    if (z != null)
>+        (*z)[0][0] = cosResult;
>+    sincos(x[0][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][1] = sinResult;
>+    if (z != null)
>+        (*z)[0][1] = cosResult;
>+    sincos(x[1][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][0] = sinResult;
>+    if (z != null)
>+        (*z)[1][0] = cosResult;
>+    sincos(x[1][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][1] = sinResult;
>+    if (z != null)
>+        (*z)[1][1] = cosResult;
>+    sincos(x[2][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2][0] = sinResult;
>+    if (z != null)
>+        (*z)[2][0] = cosResult;
>+    sincos(x[2][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2][1] = sinResult;
>+    if (z != null)
>+        (*z)[2][1] = cosResult;
>+    sincos(x[3][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[3][0] = sinResult;
>+    if (z != null)
>+        (*z)[3][0] = cosResult;
>+    sincos(x[3][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[3][1] = sinResult;
>+    if (z != null)
>+        (*z)[3][1] = cosResult;
>+}
>+void sincos(float4x3 x, threadgroup float4x3* y, threadgroup float4x3* z) {
>+    float sinResult;
>+    float cosResult;
>+    sincos(x[0][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][0] = sinResult;
>+    if (z != null)
>+        (*z)[0][0] = cosResult;
>+    sincos(x[0][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][1] = sinResult;
>+    if (z != null)
>+        (*z)[0][1] = cosResult;
>+    sincos(x[0][2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][2] = sinResult;
>+    if (z != null)
>+        (*z)[0][2] = cosResult;
>+    sincos(x[1][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][0] = sinResult;
>+    if (z != null)
>+        (*z)[1][0] = cosResult;
>+    sincos(x[1][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][1] = sinResult;
>+    if (z != null)
>+        (*z)[1][1] = cosResult;
>+    sincos(x[1][2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][2] = sinResult;
>+    if (z != null)
>+        (*z)[1][2] = cosResult;
>+    sincos(x[2][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2][0] = sinResult;
>+    if (z != null)
>+        (*z)[2][0] = cosResult;
>+    sincos(x[2][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2][1] = sinResult;
>+    if (z != null)
>+        (*z)[2][1] = cosResult;
>+    sincos(x[2][2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2][2] = sinResult;
>+    if (z != null)
>+        (*z)[2][2] = cosResult;
>+    sincos(x[3][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[3][0] = sinResult;
>+    if (z != null)
>+        (*z)[3][0] = cosResult;
>+    sincos(x[3][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[3][1] = sinResult;
>+    if (z != null)
>+        (*z)[3][1] = cosResult;
>+    sincos(x[3][2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[3][2] = sinResult;
>+    if (z != null)
>+        (*z)[3][2] = cosResult;
>+}
>+void sincos(float4x4 x, threadgroup float4x4* y, threadgroup float4x4* z) {
>+    float sinResult;
>+    float cosResult;
>+    sincos(x[0][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][0] = sinResult;
>+    if (z != null)
>+        (*z)[0][0] = cosResult;
>+    sincos(x[0][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][1] = sinResult;
>+    if (z != null)
>+        (*z)[0][1] = cosResult;
>+    sincos(x[0][2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][2] = sinResult;
>+    if (z != null)
>+        (*z)[0][2] = cosResult;
>+    sincos(x[0][3], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[0][3] = sinResult;
>+    if (z != null)
>+        (*z)[0][3] = cosResult;
>+    sincos(x[1][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][0] = sinResult;
>+    if (z != null)
>+        (*z)[1][0] = cosResult;
>+    sincos(x[1][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][1] = sinResult;
>+    if (z != null)
>+        (*z)[1][1] = cosResult;
>+    sincos(x[1][2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][2] = sinResult;
>+    if (z != null)
>+        (*z)[1][2] = cosResult;
>+    sincos(x[1][3], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[1][3] = sinResult;
>+    if (z != null)
>+        (*z)[1][3] = cosResult;
>+    sincos(x[2][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2][0] = sinResult;
>+    if (z != null)
>+        (*z)[2][0] = cosResult;
>+    sincos(x[2][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2][1] = sinResult;
>+    if (z != null)
>+        (*z)[2][1] = cosResult;
>+    sincos(x[2][2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2][2] = sinResult;
>+    if (z != null)
>+        (*z)[2][2] = cosResult;
>+    sincos(x[2][3], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[2][3] = sinResult;
>+    if (z != null)
>+        (*z)[2][3] = cosResult;
>+    sincos(x[3][0], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[3][0] = sinResult;
>+    if (z != null)
>+        (*z)[3][0] = cosResult;
>+    sincos(x[3][1], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[3][1] = sinResult;
>+    if (z != null)
>+        (*z)[3][1] = cosResult;
>+    sincos(x[3][2], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[3][2] = sinResult;
>+    if (z != null)
>+        (*z)[3][2] = cosResult;
>+    sincos(x[3][3], &sinResult, &cosResult);
>+    if (y != null)
>+        (*y)[3][3] = sinResult;
>+    if (z != null)
>+        (*z)[3][3] = cosResult;
>+}
>+
>+
>+/* Functions named InterlockedCompareExchange */
>+native void InterlockedCompareExchange(device atomic_uint*, uint, uint, thread uint*);
>+native void InterlockedCompareExchange(device atomic_int*, int, int, thread int*);
>+native void InterlockedCompareExchange(device atomic_uint*, uint, uint, device uint*);
>+native void InterlockedCompareExchange(device atomic_int*, int, int, device int*);
>+native void InterlockedCompareExchange(device atomic_uint*, uint, uint, threadgroup uint*);
>+native void InterlockedCompareExchange(device atomic_int*, int, int, threadgroup int*);
>+native void InterlockedCompareExchange(threadgroup atomic_uint*, uint, uint, thread uint*);
>+native void InterlockedCompareExchange(threadgroup atomic_int*, int, int, thread int*);
>+native void InterlockedCompareExchange(threadgroup atomic_uint*, uint, uint, device uint*);
>+native void InterlockedCompareExchange(threadgroup atomic_int*, int, int, device int*);
>+native void InterlockedCompareExchange(threadgroup atomic_uint*, uint, uint, threadgroup uint*);
>+native void InterlockedCompareExchange(threadgroup atomic_int*, int, int, threadgroup int*);
>+
>+
>+/* Functions named operator.xwz */
>+bool3 operator.xwz(bool4 v) {
>+    bool3 result;
>+    result.x = v.x;
>+    result.y = v.w;
>+    result.z = v.z;
>+    return result;
>+}
>+uchar3 operator.xwz(uchar4 v) {
>+    uchar3 result;
>+    result.x = v.x;
>+    result.y = v.w;
>+    result.z = v.z;
>+    return result;
>+}
>+ushort3 operator.xwz(ushort4 v) {
>+    ushort3 result;
>+    result.x = v.x;
>+    result.y = v.w;
>+    result.z = v.z;
>+    return result;
>+}
>+uint3 operator.xwz(uint4 v) {
>+    uint3 result;
>+    result.x = v.x;
>+    result.y = v.w;
>+    result.z = v.z;
>+    return result;
>+}
>+char3 operator.xwz(char4 v) {
>+    char3 result;
>+    result.x = v.x;
>+    result.y = v.w;
>+    result.z = v.z;
>+    return result;
>+}
>+short3 operator.xwz(short4 v) {
>+    short3 result;
>+    result.x = v.x;
>+    result.y = v.w;
>+    result.z = v.z;
>+    return result;
>+}
>+int3 operator.xwz(int4 v) {
>+    int3 result;
>+    result.x = v.x;
>+    result.y = v.w;
>+    result.z = v.z;
>+    return result;
>+}
>+half3 operator.xwz(half4 v) {
>+    half3 result;
>+    result.x = v.x;
>+    result.y = v.w;
>+    result.z = v.z;
>+    return result;
>+}
>+float3 operator.xwz(float4 v) {
>+    float3 result;
>+    result.x = v.x;
>+    result.y = v.w;
>+    result.z = v.z;
>+    return result;
>+}
>+
>+/* Functions named operator.wzxz */
>+bool4 operator.wzxz(bool4 v) {
>+    bool4 result;
>+    result.x = v.w;
>+    result.y = v.z;
>+    result.z = v.x;
>+    result.w = v.z;
>+    return result;
>+}
>+uchar4 operator.wzxz(uchar4 v) {
>+    uchar4 result;
>+    result.x = v.w;
>+    result.y = v.z;
>+    result.z = v.x;
>+    result.w = v.z;
>+    return result;
>+}
>+ushort4 operator.wzxz(ushort4 v) {
>+    ushort4 result;
>+    result.x = v.w;
>+    result.y = v.z;
>+    result.z = v.x;
>+    result.w = v.z;
>+    return result;
>+}
>+uint4 operator.wzxz(uint4 v) {
>+    uint4 result;
>+    result.x = v.w;
>+    result.y = v.z;
>+    result.z = v.x;
>+    result.w = v.z;
>+    return result;
>+}
>+char4 operator.wzxz(char4 v) {
>+    char4 result;
>+    result.x = v.w;
>+    result.y = v.z;
>+    result.z = v.x;
>+    result.w = v.z;
>+    return result;
>+}
>+short4 operator.wzxz(short4 v) {
>+    short4 result;
>+    result.x = v.w;
>+    result.y = v.z;
>+    result.z = v.x;
>+    result.w = v.z;
>+    return result;
>+}
>+int4 operator.wzxz(int4 v) {
>+    int4 result;
>+    result.x = v.w;
>+    result.y = v.z;
>+    result.z = v.x;
>+    result.w = v.z;
>+    return result;
>+}
>+half4 operator.wzxz(half4 v) {
>+    half4 result;
>+    result.x = v.w;
>+    result.y = v.z;
>+    result.z = v.x;
>+    result.w = v.z;
>+    return result;
>+}
>+float4 operator.wzxz(float4 v) {
>+    float4 result;
>+    result.x = v.w;
>+    result.y = v.z;
>+    result.z = v.x;
>+    result.w = v.z;
>+    return result;
>+}
>+
>+/* Functions named operator.zxwy */
>+bool4 operator.zxwy(bool4 v) {
>+    bool4 result;
>+    result.x = v.z;
>+    result.y = v.x;
>+    result.z = v.w;
>+    result.w = v.y;
>+    return result;
>+}
>+uchar4 operator.zxwy(uchar4 v) {
>+    uchar4 result;
>+    result.x = v.z;
>+    result.y = v.x;
>+    result.z = v.w;
>+    result.w = v.y;
>+    return result;
>+}
>+ushort4 operator.zxwy(ushort4 v) {
>+    ushort4 result;
>+    result.x = v.z;
>+    result.y = v.x;
>+    result.z = v.w;
>+    result.w = v.y;
>+    return result;
>+}
>+uint4 operator.zxwy(uint4 v) {
>+    uint4 result;
>+    result.x = v.z;
>+    result.y = v.x;
>+    result.z = v.w;
>+    result.w = v.y;
>+    return result;
>+}
>+char4 operator.zxwy(char4 v) {
>+    char4 result;
>+    result.x = v.z;
>+    result.y = v.x;
>+    result.z = v.w;
>+    result.w = v.y;
>+    return result;
>+}
>+short4 operator.zxwy(short4 v) {
>+    short4 result;
>+    result.x = v.z;
>+    result.y = v.x;
>+    result.z = v.w;
>+    result.w = v.y;
>+    return result;
>+}
>+int4 operator.zxwy(int4 v) {
>+    int4 result;
>+    result.x = v.z;
>+    result.y = v.x;
>+    result.z = v.w;
>+    result.w = v.y;
>+    return result;
>+}
>+half4 operator.zxwy(half4 v) {
>+    half4 result;
>+    result.x = v.z;
>+    result.y = v.x;
>+    result.z = v.w;
>+    result.w = v.y;
>+    return result;
>+}
>+float4 operator.zxwy(float4 v) {
>+    float4 result;
>+    result.x = v.z;
>+    result.y = v.x;
>+    result.z = v.w;
>+    result.w = v.y;
>+    return result;
>+}
>+
>+/* Functions named operator.wzxw */
>+bool4 operator.wzxw(bool4 v) {
>+    bool4 result;
>+    result.x = v.w;
>+    result.y = v.z;
>+    result.z = v.x;
>+    result.w = v.w;
>+    return result;
>+}
>+uchar4 operator.wzxw(uchar4 v) {
>+    uchar4 result;
>+    result.x = v.w;
>+    result.y = v.z;
>+    result.z = v.x;
>+    result.w = v.w;
>+    return result;
>+}
>+ushort4 operator.wzxw(ushort4 v) {
>+    ushort4 result;
>+    result.x = v.w;
>+    result.y = v.z;
>+    result.z = v.x;
>+    result.w = v.w;
>+    return result;
>+}
>+uint4 operator.wzxw(uint4 v) {
>+    uint4 result;
>+    result.x = v.w;
>+    result.y = v.z;
>+    result.z = v.x;
>+    result.w = v.w;
>+    return result;
>+}
>+char4 operator.wzxw(char4 v) {
>+    char4 result;
>+    result.x = v.w;
>+    result.y = v.z;
>+    result.z = v.x;
>+    result.w = v.w;
>+    return result;
>+}
>+short4 operator.wzxw(short4 v) {
>+    short4 result;
>+    result.x = v.w;
>+    result.y = v.z;
>+    result.z = v.x;
>+    result.w = v.w;
>+    return result;
>+}
>+int4 operator.wzxw(int4 v) {
>+    int4 result;
>+    result.x = v.w;
>+    result.y = v.z;
>+    result.z = v.x;
>+    result.w = v.w;
>+    return result;
>+}
>+half4 operator.wzxw(half4 v) {
>+    half4 result;
>+    result.x = v.w;
>+    result.y = v.z;
>+    result.z = v.x;
>+    result.w = v.w;
>+    return result;
>+}
>+float4 operator.wzxw(float4 v) {
>+    float4 result;
>+    result.x = v.w;
>+    result.y = v.z;
>+    result.z = v.x;
>+    result.w = v.w;
>+    return result;
>+}
>+
>+/* Functions named operator.zyz */
>+bool3 operator.zyz(bool3 v) {
>+    bool3 result;
>+    result.x = v.z;
>+    result.y = v.y;
>+    result.z = v.z;
>+    return result;
>+}
>+bool3 operator.zyz(bool4 v) {
>+    bool3 result;
>+    result.x = v.z;
>+    result.y = v.y;
>+    result.z = v.z;
>+    return result;
>+}
>+uchar3 operator.zyz(uchar3 v) {
>+    uchar3 result;
>+    result.x = v.z;
>+    result.y = v.y;
>+    result.z = v.z;
>+    return result;
>+}
>+uchar3 operator.zyz(uchar4 v) {
>+    uchar3 result;
>+    result.x = v.z;
>+    result.y = v.y;
>+    result.z = v.z;
>+    return result;
>+}
>+ushort3 operator.zyz(ushort3 v) {
>+    ushort3 result;
>+    result.x = v.z;
>+    result.y = v.y;
>+    result.z = v.z;
>+    return result;
>+}
>+ushort3 operator.zyz(ushort4 v) {
>+    ushort3 result;
>+    result.x = v.z;
>+    result.y = v.y;
>+    result.z = v.z;
>+    return result;
>+}
>+uint3 operator.zyz(uint3 v) {
>+    uint3 result;
>+    result.x = v.z;
>+    result.y = v.y;
>+    result.z = v.z;
>+    return result;
>+}
>+uint3 operator.zyz(uint4 v) {
>+    uint3 result;
>+    result.x = v.z;
>+    result.y = v.y;
>+    result.z = v.z;
>+    return result;
>+}
>+char3 operator.zyz(char3 v) {
>+    char3 result;
>+    result.x = v.z;
>+    result.y = v.y;
>+    result.z = v.z;
>+    return result;
>+}
>+char3 operator.zyz(char4 v) {
>+    char3 result;
>+    result.x = v.z;
>+    result.y = v.y;
>+    result.z = v.z;
>+    return result;
>+}
>+short3 operator.zyz(short3 v) {
>+    short3 result;
>+    result.x = v.z;
>+    result.y = v.y;
>+    result.z = v.z;
>+    return result;
>+}
>+short3 operator.zyz(short4 v) {
>+    short3 result;
>+    result.x = v.z;
>+    result.y = v.y;
>+    result.z = v.z;
>+    return result;
>+}
>+int3 operator.zyz(int3 v) {
>+    int3 result;
>+    result.x = v.z;
>+    result.y = v.y;
>+    result.z = v.z;
>+    return result;
>+}
>+int3 operator.zyz(int4 v) {
>+    int3 result;
>+    result.x = v.z;
>+    result.y = v.y;
>+    result.z = v.z;
>+    return result;
>+}
>+half3 operator.zyz(half3 v) {
>+    half3 result;
>+    result.x = v.z;
>+    result.y = v.y;
>+    result.z = v.z;
>+    return result;
>+}
>+half3 operator.zyz(half4 v) {
>+    half3 result;
>+    result.x = v.z;
>+    result.y = v.y;
>+    result.z = v.z;
>+    return result;
>+}
>+float3 operator.zyz(float3 v) {
>+    float3 result;
>+    result.x = v.z;
>+    result.y = v.y;
>+    result.z = v.z;
>+    return result;
>+}
>+float3 operator.zyz(float4 v) {
>+    float3 result;
>+    result.x = v.z;
>+    result.y = v.y;
>+    result.z = v.z;
>+    return result;
>+}
>+
>+/* Functions named operator.yyyz */
>+bool4 operator.yyyz(bool3 v) {
>+    bool4 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.y;
>+    result.w = v.z;
>+    return result;
>+}
>+bool4 operator.yyyz(bool4 v) {
>+    bool4 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.y;
>+    result.w = v.z;
>+    return result;
>+}
>+uchar4 operator.yyyz(uchar3 v) {
>+    uchar4 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.y;
>+    result.w = v.z;
>+    return result;
>+}
>+uchar4 operator.yyyz(uchar4 v) {
>+    uchar4 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.y;
>+    result.w = v.z;
>+    return result;
>+}
>+ushort4 operator.yyyz(ushort3 v) {
>+    ushort4 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.y;
>+    result.w = v.z;
>+    return result;
>+}
>+ushort4 operator.yyyz(ushort4 v) {
>+    ushort4 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.y;
>+    result.w = v.z;
>+    return result;
>+}
>+uint4 operator.yyyz(uint3 v) {
>+    uint4 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.y;
>+    result.w = v.z;
>+    return result;
>+}
>+uint4 operator.yyyz(uint4 v) {
>+    uint4 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.y;
>+    result.w = v.z;
>+    return result;
>+}
>+char4 operator.yyyz(char3 v) {
>+    char4 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.y;
>+    result.w = v.z;
>+    return result;
>+}
>+char4 operator.yyyz(char4 v) {
>+    char4 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.y;
>+    result.w = v.z;
>+    return result;
>+}
>+short4 operator.yyyz(short3 v) {
>+    short4 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.y;
>+    result.w = v.z;
>+    return result;
>+}
>+short4 operator.yyyz(short4 v) {
>+    short4 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.y;
>+    result.w = v.z;
>+    return result;
>+}
>+int4 operator.yyyz(int3 v) {
>+    int4 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.y;
>+    result.w = v.z;
>+    return result;
>+}
>+int4 operator.yyyz(int4 v) {
>+    int4 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.y;
>+    result.w = v.z;
>+    return result;
>+}
>+half4 operator.yyyz(half3 v) {
>+    half4 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.y;
>+    result.w = v.z;
>+    return result;
>+}
>+half4 operator.yyyz(half4 v) {
>+    half4 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.y;
>+    result.w = v.z;
>+    return result;
>+}
>+float4 operator.yyyz(float3 v) {
>+    float4 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.y;
>+    result.w = v.z;
>+    return result;
>+}
>+float4 operator.yyyz(float4 v) {
>+    float4 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.y;
>+    result.w = v.z;
>+    return result;
>+}
>+
>+/* Functions named operator.xzyw */
>+bool4 operator.xzyw(bool4 v) {
>+    bool4 result;
>+    result.x = v.x;
>+    result.y = v.z;
>+    result.z = v.y;
>+    result.w = v.w;
>+    return result;
>+}
>+uchar4 operator.xzyw(uchar4 v) {
>+    uchar4 result;
>+    result.x = v.x;
>+    result.y = v.z;
>+    result.z = v.y;
>+    result.w = v.w;
>+    return result;
>+}
>+ushort4 operator.xzyw(ushort4 v) {
>+    ushort4 result;
>+    result.x = v.x;
>+    result.y = v.z;
>+    result.z = v.y;
>+    result.w = v.w;
>+    return result;
>+}
>+uint4 operator.xzyw(uint4 v) {
>+    uint4 result;
>+    result.x = v.x;
>+    result.y = v.z;
>+    result.z = v.y;
>+    result.w = v.w;
>+    return result;
>+}
>+char4 operator.xzyw(char4 v) {
>+    char4 result;
>+    result.x = v.x;
>+    result.y = v.z;
>+    result.z = v.y;
>+    result.w = v.w;
>+    return result;
>+}
>+short4 operator.xzyw(short4 v) {
>+    short4 result;
>+    result.x = v.x;
>+    result.y = v.z;
>+    result.z = v.y;
>+    result.w = v.w;
>+    return result;
>+}
>+int4 operator.xzyw(int4 v) {
>+    int4 result;
>+    result.x = v.x;
>+    result.y = v.z;
>+    result.z = v.y;
>+    result.w = v.w;
>+    return result;
>+}
>+half4 operator.xzyw(half4 v) {
>+    half4 result;
>+    result.x = v.x;
>+    result.y = v.z;
>+    result.z = v.y;
>+    result.w = v.w;
>+    return result;
>+}
>+float4 operator.xzyw(float4 v) {
>+    float4 result;
>+    result.x = v.x;
>+    result.y = v.z;
>+    result.z = v.y;
>+    result.w = v.w;
>+    return result;
>+}
>+
>+/* Functions named smoothstep */
>+half smoothstep(half edge0, half edge1, half x) {
>+    half t = clamp((x - edge0) / (edge1 - edge0), 0, 1);
>+    return t * t * (3 - 2 * t);
>+}
>+half2 smoothstep(half2 x, half2 y, half2 z) {
>+    half2 result;
>+    result[0] = smoothstep(x[0], y[0], z[0]);
>+    result[1] = smoothstep(x[1], y[1], z[1]);
>+    return result;
>+}
>+half3 smoothstep(half3 x, half3 y, half3 z) {
>+    half3 result;
>+    result[0] = smoothstep(x[0], y[0], z[0]);
>+    result[1] = smoothstep(x[1], y[1], z[1]);
>+    result[2] = smoothstep(x[2], y[2], z[2]);
>+    return result;
>+}
>+half4 smoothstep(half4 x, half4 y, half4 z) {
>+    half4 result;
>+    result[0] = smoothstep(x[0], y[0], z[0]);
>+    result[1] = smoothstep(x[1], y[1], z[1]);
>+    result[2] = smoothstep(x[2], y[2], z[2]);
>+    result[3] = smoothstep(x[3], y[3], z[3]);
>+    return result;
>+}
>+half2x2 smoothstep(half2x2 x, half2x2 y, half2x2 z) {
>+    half2x2 result;
>+    result[0][0] = smoothstep(x[0][0], y[0][0], z[0][0]);
>+    result[0][1] = smoothstep(x[0][1], y[0][1], z[0][1]);
>+    result[1][0] = smoothstep(x[1][0], y[1][0], z[1][0]);
>+    result[1][1] = smoothstep(x[1][1], y[1][1], z[1][1]);
>+    return result;
>+}
>+half2x3 smoothstep(half2x3 x, half2x3 y, half2x3 z) {
>+    half2x3 result;
>+    result[0][0] = smoothstep(x[0][0], y[0][0], z[0][0]);
>+    result[0][1] = smoothstep(x[0][1], y[0][1], z[0][1]);
>+    result[0][2] = smoothstep(x[0][2], y[0][2], z[0][2]);
>+    result[1][0] = smoothstep(x[1][0], y[1][0], z[1][0]);
>+    result[1][1] = smoothstep(x[1][1], y[1][1], z[1][1]);
>+    result[1][2] = smoothstep(x[1][2], y[1][2], z[1][2]);
>+    return result;
>+}
>+half2x4 smoothstep(half2x4 x, half2x4 y, half2x4 z) {
>+    half2x4 result;
>+    result[0][0] = smoothstep(x[0][0], y[0][0], z[0][0]);
>+    result[0][1] = smoothstep(x[0][1], y[0][1], z[0][1]);
>+    result[0][2] = smoothstep(x[0][2], y[0][2], z[0][2]);
>+    result[0][3] = smoothstep(x[0][3], y[0][3], z[0][3]);
>+    result[1][0] = smoothstep(x[1][0], y[1][0], z[1][0]);
>+    result[1][1] = smoothstep(x[1][1], y[1][1], z[1][1]);
>+    result[1][2] = smoothstep(x[1][2], y[1][2], z[1][2]);
>+    result[1][3] = smoothstep(x[1][3], y[1][3], z[1][3]);
>+    return result;
>+}
>+half3x2 smoothstep(half3x2 x, half3x2 y, half3x2 z) {
>+    half3x2 result;
>+    result[0][0] = smoothstep(x[0][0], y[0][0], z[0][0]);
>+    result[0][1] = smoothstep(x[0][1], y[0][1], z[0][1]);
>+    result[1][0] = smoothstep(x[1][0], y[1][0], z[1][0]);
>+    result[1][1] = smoothstep(x[1][1], y[1][1], z[1][1]);
>+    result[2][0] = smoothstep(x[2][0], y[2][0], z[2][0]);
>+    result[2][1] = smoothstep(x[2][1], y[2][1], z[2][1]);
>+    return result;
>+}
>+half3x3 smoothstep(half3x3 x, half3x3 y, half3x3 z) {
>+    half3x3 result;
>+    result[0][0] = smoothstep(x[0][0], y[0][0], z[0][0]);
>+    result[0][1] = smoothstep(x[0][1], y[0][1], z[0][1]);
>+    result[0][2] = smoothstep(x[0][2], y[0][2], z[0][2]);
>+    result[1][0] = smoothstep(x[1][0], y[1][0], z[1][0]);
>+    result[1][1] = smoothstep(x[1][1], y[1][1], z[1][1]);
>+    result[1][2] = smoothstep(x[1][2], y[1][2], z[1][2]);
>+    result[2][0] = smoothstep(x[2][0], y[2][0], z[2][0]);
>+    result[2][1] = smoothstep(x[2][1], y[2][1], z[2][1]);
>+    result[2][2] = smoothstep(x[2][2], y[2][2], z[2][2]);
>+    return result;
>+}
>+half3x4 smoothstep(half3x4 x, half3x4 y, half3x4 z) {
>+    half3x4 result;
>+    result[0][0] = smoothstep(x[0][0], y[0][0], z[0][0]);
>+    result[0][1] = smoothstep(x[0][1], y[0][1], z[0][1]);
>+    result[0][2] = smoothstep(x[0][2], y[0][2], z[0][2]);
>+    result[0][3] = smoothstep(x[0][3], y[0][3], z[0][3]);
>+    result[1][0] = smoothstep(x[1][0], y[1][0], z[1][0]);
>+    result[1][1] = smoothstep(x[1][1], y[1][1], z[1][1]);
>+    result[1][2] = smoothstep(x[1][2], y[1][2], z[1][2]);
>+    result[1][3] = smoothstep(x[1][3], y[1][3], z[1][3]);
>+    result[2][0] = smoothstep(x[2][0], y[2][0], z[2][0]);
>+    result[2][1] = smoothstep(x[2][1], y[2][1], z[2][1]);
>+    result[2][2] = smoothstep(x[2][2], y[2][2], z[2][2]);
>+    result[2][3] = smoothstep(x[2][3], y[2][3], z[2][3]);
>+    return result;
>+}
>+half4x2 smoothstep(half4x2 x, half4x2 y, half4x2 z) {
>+    half4x2 result;
>+    result[0][0] = smoothstep(x[0][0], y[0][0], z[0][0]);
>+    result[0][1] = smoothstep(x[0][1], y[0][1], z[0][1]);
>+    result[1][0] = smoothstep(x[1][0], y[1][0], z[1][0]);
>+    result[1][1] = smoothstep(x[1][1], y[1][1], z[1][1]);
>+    result[2][0] = smoothstep(x[2][0], y[2][0], z[2][0]);
>+    result[2][1] = smoothstep(x[2][1], y[2][1], z[2][1]);
>+    result[3][0] = smoothstep(x[3][0], y[3][0], z[3][0]);
>+    result[3][1] = smoothstep(x[3][1], y[3][1], z[3][1]);
>+    return result;
>+}
>+half4x3 smoothstep(half4x3 x, half4x3 y, half4x3 z) {
>+    half4x3 result;
>+    result[0][0] = smoothstep(x[0][0], y[0][0], z[0][0]);
>+    result[0][1] = smoothstep(x[0][1], y[0][1], z[0][1]);
>+    result[0][2] = smoothstep(x[0][2], y[0][2], z[0][2]);
>+    result[1][0] = smoothstep(x[1][0], y[1][0], z[1][0]);
>+    result[1][1] = smoothstep(x[1][1], y[1][1], z[1][1]);
>+    result[1][2] = smoothstep(x[1][2], y[1][2], z[1][2]);
>+    result[2][0] = smoothstep(x[2][0], y[2][0], z[2][0]);
>+    result[2][1] = smoothstep(x[2][1], y[2][1], z[2][1]);
>+    result[2][2] = smoothstep(x[2][2], y[2][2], z[2][2]);
>+    result[3][0] = smoothstep(x[3][0], y[3][0], z[3][0]);
>+    result[3][1] = smoothstep(x[3][1], y[3][1], z[3][1]);
>+    result[3][2] = smoothstep(x[3][2], y[3][2], z[3][2]);
>+    return result;
>+}
>+half4x4 smoothstep(half4x4 x, half4x4 y, half4x4 z) {
>+    half4x4 result;
>+    result[0][0] = smoothstep(x[0][0], y[0][0], z[0][0]);
>+    result[0][1] = smoothstep(x[0][1], y[0][1], z[0][1]);
>+    result[0][2] = smoothstep(x[0][2], y[0][2], z[0][2]);
>+    result[0][3] = smoothstep(x[0][3], y[0][3], z[0][3]);
>+    result[1][0] = smoothstep(x[1][0], y[1][0], z[1][0]);
>+    result[1][1] = smoothstep(x[1][1], y[1][1], z[1][1]);
>+    result[1][2] = smoothstep(x[1][2], y[1][2], z[1][2]);
>+    result[1][3] = smoothstep(x[1][3], y[1][3], z[1][3]);
>+    result[2][0] = smoothstep(x[2][0], y[2][0], z[2][0]);
>+    result[2][1] = smoothstep(x[2][1], y[2][1], z[2][1]);
>+    result[2][2] = smoothstep(x[2][2], y[2][2], z[2][2]);
>+    result[2][3] = smoothstep(x[2][3], y[2][3], z[2][3]);
>+    result[3][0] = smoothstep(x[3][0], y[3][0], z[3][0]);
>+    result[3][1] = smoothstep(x[3][1], y[3][1], z[3][1]);
>+    result[3][2] = smoothstep(x[3][2], y[3][2], z[3][2]);
>+    result[3][3] = smoothstep(x[3][3], y[3][3], z[3][3]);
>+    return result;
>+}
>+float smoothstep(float edge0, float edge1, float x) {
>+    float t = clamp((x - edge0) / (edge1 - edge0), 0, 1);
>+    return t * t * (3 - 2 * t);
>+}
>+float2 smoothstep(float2 x, float2 y, float2 z) {
>+    float2 result;
>+    result[0] = smoothstep(x[0], y[0], z[0]);
>+    result[1] = smoothstep(x[1], y[1], z[1]);
>+    return result;
>+}
>+float3 smoothstep(float3 x, float3 y, float3 z) {
>+    float3 result;
>+    result[0] = smoothstep(x[0], y[0], z[0]);
>+    result[1] = smoothstep(x[1], y[1], z[1]);
>+    result[2] = smoothstep(x[2], y[2], z[2]);
>+    return result;
>+}
>+float4 smoothstep(float4 x, float4 y, float4 z) {
>+    float4 result;
>+    result[0] = smoothstep(x[0], y[0], z[0]);
>+    result[1] = smoothstep(x[1], y[1], z[1]);
>+    result[2] = smoothstep(x[2], y[2], z[2]);
>+    result[3] = smoothstep(x[3], y[3], z[3]);
>+    return result;
>+}
>+float2x2 smoothstep(float2x2 x, float2x2 y, float2x2 z) {
>+    float2x2 result;
>+    result[0][0] = smoothstep(x[0][0], y[0][0], z[0][0]);
>+    result[0][1] = smoothstep(x[0][1], y[0][1], z[0][1]);
>+    result[1][0] = smoothstep(x[1][0], y[1][0], z[1][0]);
>+    result[1][1] = smoothstep(x[1][1], y[1][1], z[1][1]);
>+    return result;
>+}
>+float2x3 smoothstep(float2x3 x, float2x3 y, float2x3 z) {
>+    float2x3 result;
>+    result[0][0] = smoothstep(x[0][0], y[0][0], z[0][0]);
>+    result[0][1] = smoothstep(x[0][1], y[0][1], z[0][1]);
>+    result[0][2] = smoothstep(x[0][2], y[0][2], z[0][2]);
>+    result[1][0] = smoothstep(x[1][0], y[1][0], z[1][0]);
>+    result[1][1] = smoothstep(x[1][1], y[1][1], z[1][1]);
>+    result[1][2] = smoothstep(x[1][2], y[1][2], z[1][2]);
>+    return result;
>+}
>+float2x4 smoothstep(float2x4 x, float2x4 y, float2x4 z) {
>+    float2x4 result;
>+    result[0][0] = smoothstep(x[0][0], y[0][0], z[0][0]);
>+    result[0][1] = smoothstep(x[0][1], y[0][1], z[0][1]);
>+    result[0][2] = smoothstep(x[0][2], y[0][2], z[0][2]);
>+    result[0][3] = smoothstep(x[0][3], y[0][3], z[0][3]);
>+    result[1][0] = smoothstep(x[1][0], y[1][0], z[1][0]);
>+    result[1][1] = smoothstep(x[1][1], y[1][1], z[1][1]);
>+    result[1][2] = smoothstep(x[1][2], y[1][2], z[1][2]);
>+    result[1][3] = smoothstep(x[1][3], y[1][3], z[1][3]);
>+    return result;
>+}
>+float3x2 smoothstep(float3x2 x, float3x2 y, float3x2 z) {
>+    float3x2 result;
>+    result[0][0] = smoothstep(x[0][0], y[0][0], z[0][0]);
>+    result[0][1] = smoothstep(x[0][1], y[0][1], z[0][1]);
>+    result[1][0] = smoothstep(x[1][0], y[1][0], z[1][0]);
>+    result[1][1] = smoothstep(x[1][1], y[1][1], z[1][1]);
>+    result[2][0] = smoothstep(x[2][0], y[2][0], z[2][0]);
>+    result[2][1] = smoothstep(x[2][1], y[2][1], z[2][1]);
>+    return result;
>+}
>+float3x3 smoothstep(float3x3 x, float3x3 y, float3x3 z) {
>+    float3x3 result;
>+    result[0][0] = smoothstep(x[0][0], y[0][0], z[0][0]);
>+    result[0][1] = smoothstep(x[0][1], y[0][1], z[0][1]);
>+    result[0][2] = smoothstep(x[0][2], y[0][2], z[0][2]);
>+    result[1][0] = smoothstep(x[1][0], y[1][0], z[1][0]);
>+    result[1][1] = smoothstep(x[1][1], y[1][1], z[1][1]);
>+    result[1][2] = smoothstep(x[1][2], y[1][2], z[1][2]);
>+    result[2][0] = smoothstep(x[2][0], y[2][0], z[2][0]);
>+    result[2][1] = smoothstep(x[2][1], y[2][1], z[2][1]);
>+    result[2][2] = smoothstep(x[2][2], y[2][2], z[2][2]);
>+    return result;
>+}
>+float3x4 smoothstep(float3x4 x, float3x4 y, float3x4 z) {
>+    float3x4 result;
>+    result[0][0] = smoothstep(x[0][0], y[0][0], z[0][0]);
>+    result[0][1] = smoothstep(x[0][1], y[0][1], z[0][1]);
>+    result[0][2] = smoothstep(x[0][2], y[0][2], z[0][2]);
>+    result[0][3] = smoothstep(x[0][3], y[0][3], z[0][3]);
>+    result[1][0] = smoothstep(x[1][0], y[1][0], z[1][0]);
>+    result[1][1] = smoothstep(x[1][1], y[1][1], z[1][1]);
>+    result[1][2] = smoothstep(x[1][2], y[1][2], z[1][2]);
>+    result[1][3] = smoothstep(x[1][3], y[1][3], z[1][3]);
>+    result[2][0] = smoothstep(x[2][0], y[2][0], z[2][0]);
>+    result[2][1] = smoothstep(x[2][1], y[2][1], z[2][1]);
>+    result[2][2] = smoothstep(x[2][2], y[2][2], z[2][2]);
>+    result[2][3] = smoothstep(x[2][3], y[2][3], z[2][3]);
>+    return result;
>+}
>+float4x2 smoothstep(float4x2 x, float4x2 y, float4x2 z) {
>+    float4x2 result;
>+    result[0][0] = smoothstep(x[0][0], y[0][0], z[0][0]);
>+    result[0][1] = smoothstep(x[0][1], y[0][1], z[0][1]);
>+    result[1][0] = smoothstep(x[1][0], y[1][0], z[1][0]);
>+    result[1][1] = smoothstep(x[1][1], y[1][1], z[1][1]);
>+    result[2][0] = smoothstep(x[2][0], y[2][0], z[2][0]);
>+    result[2][1] = smoothstep(x[2][1], y[2][1], z[2][1]);
>+    result[3][0] = smoothstep(x[3][0], y[3][0], z[3][0]);
>+    result[3][1] = smoothstep(x[3][1], y[3][1], z[3][1]);
>+    return result;
>+}
>+float4x3 smoothstep(float4x3 x, float4x3 y, float4x3 z) {
>+    float4x3 result;
>+    result[0][0] = smoothstep(x[0][0], y[0][0], z[0][0]);
>+    result[0][1] = smoothstep(x[0][1], y[0][1], z[0][1]);
>+    result[0][2] = smoothstep(x[0][2], y[0][2], z[0][2]);
>+    result[1][0] = smoothstep(x[1][0], y[1][0], z[1][0]);
>+    result[1][1] = smoothstep(x[1][1], y[1][1], z[1][1]);
>+    result[1][2] = smoothstep(x[1][2], y[1][2], z[1][2]);
>+    result[2][0] = smoothstep(x[2][0], y[2][0], z[2][0]);
>+    result[2][1] = smoothstep(x[2][1], y[2][1], z[2][1]);
>+    result[2][2] = smoothstep(x[2][2], y[2][2], z[2][2]);
>+    result[3][0] = smoothstep(x[3][0], y[3][0], z[3][0]);
>+    result[3][1] = smoothstep(x[3][1], y[3][1], z[3][1]);
>+    result[3][2] = smoothstep(x[3][2], y[3][2], z[3][2]);
>+    return result;
>+}
>+float4x4 smoothstep(float4x4 x, float4x4 y, float4x4 z) {
>+    float4x4 result;
>+    result[0][0] = smoothstep(x[0][0], y[0][0], z[0][0]);
>+    result[0][1] = smoothstep(x[0][1], y[0][1], z[0][1]);
>+    result[0][2] = smoothstep(x[0][2], y[0][2], z[0][2]);
>+    result[0][3] = smoothstep(x[0][3], y[0][3], z[0][3]);
>+    result[1][0] = smoothstep(x[1][0], y[1][0], z[1][0]);
>+    result[1][1] = smoothstep(x[1][1], y[1][1], z[1][1]);
>+    result[1][2] = smoothstep(x[1][2], y[1][2], z[1][2]);
>+    result[1][3] = smoothstep(x[1][3], y[1][3], z[1][3]);
>+    result[2][0] = smoothstep(x[2][0], y[2][0], z[2][0]);
>+    result[2][1] = smoothstep(x[2][1], y[2][1], z[2][1]);
>+    result[2][2] = smoothstep(x[2][2], y[2][2], z[2][2]);
>+    result[2][3] = smoothstep(x[2][3], y[2][3], z[2][3]);
>+    result[3][0] = smoothstep(x[3][0], y[3][0], z[3][0]);
>+    result[3][1] = smoothstep(x[3][1], y[3][1], z[3][1]);
>+    result[3][2] = smoothstep(x[3][2], y[3][2], z[3][2]);
>+    result[3][3] = smoothstep(x[3][3], y[3][3], z[3][3]);
>+    return result;
>+}
>+
>+/* Functions named operator.wyyz */
>+bool4 operator.wyyz(bool4 v) {
>+    bool4 result;
>+    result.x = v.w;
>+    result.y = v.y;
>+    result.z = v.y;
>+    result.w = v.z;
>+    return result;
>+}
>+uchar4 operator.wyyz(uchar4 v) {
>+    uchar4 result;
>+    result.x = v.w;
>+    result.y = v.y;
>+    result.z = v.y;
>+    result.w = v.z;
>+    return result;
>+}
>+ushort4 operator.wyyz(ushort4 v) {
>+    ushort4 result;
>+    result.x = v.w;
>+    result.y = v.y;
>+    result.z = v.y;
>+    result.w = v.z;
>+    return result;
>+}
>+uint4 operator.wyyz(uint4 v) {
>+    uint4 result;
>+    result.x = v.w;
>+    result.y = v.y;
>+    result.z = v.y;
>+    result.w = v.z;
>+    return result;
>+}
>+char4 operator.wyyz(char4 v) {
>+    char4 result;
>+    result.x = v.w;
>+    result.y = v.y;
>+    result.z = v.y;
>+    result.w = v.z;
>+    return result;
>+}
>+short4 operator.wyyz(short4 v) {
>+    short4 result;
>+    result.x = v.w;
>+    result.y = v.y;
>+    result.z = v.y;
>+    result.w = v.z;
>+    return result;
>+}
>+int4 operator.wyyz(int4 v) {
>+    int4 result;
>+    result.x = v.w;
>+    result.y = v.y;
>+    result.z = v.y;
>+    result.w = v.z;
>+    return result;
>+}
>+half4 operator.wyyz(half4 v) {
>+    half4 result;
>+    result.x = v.w;
>+    result.y = v.y;
>+    result.z = v.y;
>+    result.w = v.z;
>+    return result;
>+}
>+float4 operator.wyyz(float4 v) {
>+    float4 result;
>+    result.x = v.w;
>+    result.y = v.y;
>+    result.z = v.y;
>+    result.w = v.z;
>+    return result;
>+}
>+
>+/* Functions named operator.ww */
>+bool2 operator.ww(bool4 v) {
>+    bool2 result;
>+    result.x = v.w;
>+    result.y = v.w;
>+    return result;
>+}
>+uchar2 operator.ww(uchar4 v) {
>+    uchar2 result;
>+    result.x = v.w;
>+    result.y = v.w;
>+    return result;
>+}
>+ushort2 operator.ww(ushort4 v) {
>+    ushort2 result;
>+    result.x = v.w;
>+    result.y = v.w;
>+    return result;
>+}
>+uint2 operator.ww(uint4 v) {
>+    uint2 result;
>+    result.x = v.w;
>+    result.y = v.w;
>+    return result;
>+}
>+char2 operator.ww(char4 v) {
>+    char2 result;
>+    result.x = v.w;
>+    result.y = v.w;
>+    return result;
>+}
>+short2 operator.ww(short4 v) {
>+    short2 result;
>+    result.x = v.w;
>+    result.y = v.w;
>+    return result;
>+}
>+int2 operator.ww(int4 v) {
>+    int2 result;
>+    result.x = v.w;
>+    result.y = v.w;
>+    return result;
>+}
>+half2 operator.ww(half4 v) {
>+    half2 result;
>+    result.x = v.w;
>+    result.y = v.w;
>+    return result;
>+}
>+float2 operator.ww(float4 v) {
>+    float2 result;
>+    result.x = v.w;
>+    result.y = v.w;
>+    return result;
>+}
>+
>+/* Functions named operator[] */
>+bool operator[](bool2 v, uint index) {
>+    switch (index) {
>+        case 0:
>+            return v.x;
>+        case 1:
>+            return v.y;
>+        default:
>+            break;
>+    }
>+    bool result;
>+    return result;
>+}
>+bool operator[](bool3 v, uint index) {
>+    switch (index) {
>+        case 0:
>+            return v.x;
>+        case 1:
>+            return v.y;
>+        case 2:
>+            return v.z;
>+        default:
>+            break;
>+    }
>+    bool result;
>+    return result;
>+}
>+bool operator[](bool4 v, uint index) {
>+    switch (index) {
>+        case 0:
>+            return v.x;
>+        case 1:
>+            return v.y;
>+        case 2:
>+            return v.z;
>+        case 3:
>+            return v.w;
>+        default:
>+            break;
>+    }
>+    bool result;
>+    return result;
>+}
>+uchar operator[](uchar2 v, uint index) {
>+    switch (index) {
>+        case 0:
>+            return v.x;
>+        case 1:
>+            return v.y;
>+        default:
>+            break;
>+    }
>+    uchar result;
>+    return result;
>+}
>+uchar operator[](uchar3 v, uint index) {
>+    switch (index) {
>+        case 0:
>+            return v.x;
>+        case 1:
>+            return v.y;
>+        case 2:
>+            return v.z;
>+        default:
>+            break;
>+    }
>+    uchar result;
>+    return result;
>+}
>+uchar operator[](uchar4 v, uint index) {
>+    switch (index) {
>+        case 0:
>+            return v.x;
>+        case 1:
>+            return v.y;
>+        case 2:
>+            return v.z;
>+        case 3:
>+            return v.w;
>+        default:
>+            break;
>+    }
>+    uchar result;
>+    return result;
>+}
>+ushort operator[](ushort2 v, uint index) {
>+    switch (index) {
>+        case 0:
>+            return v.x;
>+        case 1:
>+            return v.y;
>+        default:
>+            break;
>+    }
>+    ushort result;
>+    return result;
>+}
>+ushort operator[](ushort3 v, uint index) {
>+    switch (index) {
>+        case 0:
>+            return v.x;
>+        case 1:
>+            return v.y;
>+        case 2:
>+            return v.z;
>+        default:
>+            break;
>+    }
>+    ushort result;
>+    return result;
>+}
>+ushort operator[](ushort4 v, uint index) {
>+    switch (index) {
>+        case 0:
>+            return v.x;
>+        case 1:
>+            return v.y;
>+        case 2:
>+            return v.z;
>+        case 3:
>+            return v.w;
>+        default:
>+            break;
>+    }
>+    ushort result;
>+    return result;
>+}
>+uint operator[](uint2 v, uint index) {
>+    switch (index) {
>+        case 0:
>+            return v.x;
>+        case 1:
>+            return v.y;
>+        default:
>+            break;
>+    }
>+    uint result;
>+    return result;
>+}
>+uint operator[](uint3 v, uint index) {
>+    switch (index) {
>+        case 0:
>+            return v.x;
>+        case 1:
>+            return v.y;
>+        case 2:
>+            return v.z;
>+        default:
>+            break;
>+    }
>+    uint result;
>+    return result;
>+}
>+uint operator[](uint4 v, uint index) {
>+    switch (index) {
>+        case 0:
>+            return v.x;
>+        case 1:
>+            return v.y;
>+        case 2:
>+            return v.z;
>+        case 3:
>+            return v.w;
>+        default:
>+            break;
>+    }
>+    uint result;
>+    return result;
>+}
>+char operator[](char2 v, uint index) {
>+    switch (index) {
>+        case 0:
>+            return v.x;
>+        case 1:
>+            return v.y;
>+        default:
>+            break;
>+    }
>+    char result;
>+    return result;
>+}
>+char operator[](char3 v, uint index) {
>+    switch (index) {
>+        case 0:
>+            return v.x;
>+        case 1:
>+            return v.y;
>+        case 2:
>+            return v.z;
>+        default:
>+            break;
>+    }
>+    char result;
>+    return result;
>+}
>+char operator[](char4 v, uint index) {
>+    switch (index) {
>+        case 0:
>+            return v.x;
>+        case 1:
>+            return v.y;
>+        case 2:
>+            return v.z;
>+        case 3:
>+            return v.w;
>+        default:
>+            break;
>+    }
>+    char result;
>+    return result;
>+}
>+short operator[](short2 v, uint index) {
>+    switch (index) {
>+        case 0:
>+            return v.x;
>+        case 1:
>+            return v.y;
>+        default:
>+            break;
>+    }
>+    short result;
>+    return result;
>+}
>+short operator[](short3 v, uint index) {
>+    switch (index) {
>+        case 0:
>+            return v.x;
>+        case 1:
>+            return v.y;
>+        case 2:
>+            return v.z;
>+        default:
>+            break;
>+    }
>+    short result;
>+    return result;
>+}
>+short operator[](short4 v, uint index) {
>+    switch (index) {
>+        case 0:
>+            return v.x;
>+        case 1:
>+            return v.y;
>+        case 2:
>+            return v.z;
>+        case 3:
>+            return v.w;
>+        default:
>+            break;
>+    }
>+    short result;
>+    return result;
>+}
>+int operator[](int2 v, uint index) {
>+    switch (index) {
>+        case 0:
>+            return v.x;
>+        case 1:
>+            return v.y;
>+        default:
>+            break;
>+    }
>+    int result;
>+    return result;
>+}
>+int operator[](int3 v, uint index) {
>+    switch (index) {
>+        case 0:
>+            return v.x;
>+        case 1:
>+            return v.y;
>+        case 2:
>+            return v.z;
>+        default:
>+            break;
>+    }
>+    int result;
>+    return result;
>+}
>+int operator[](int4 v, uint index) {
>+    switch (index) {
>+        case 0:
>+            return v.x;
>+        case 1:
>+            return v.y;
>+        case 2:
>+            return v.z;
>+        case 3:
>+            return v.w;
>+        default:
>+            break;
>+    }
>+    int result;
>+    return result;
>+}
>+half operator[](half2 v, uint index) {
>+    switch (index) {
>+        case 0:
>+            return v.x;
>+        case 1:
>+            return v.y;
>+        default:
>+            break;
>+    }
>+    half result;
>+    return result;
>+}
>+half operator[](half3 v, uint index) {
>+    switch (index) {
>+        case 0:
>+            return v.x;
>+        case 1:
>+            return v.y;
>+        case 2:
>+            return v.z;
>+        default:
>+            break;
>+    }
>+    half result;
>+    return result;
>+}
>+half operator[](half4 v, uint index) {
>+    switch (index) {
>+        case 0:
>+            return v.x;
>+        case 1:
>+            return v.y;
>+        case 2:
>+            return v.z;
>+        case 3:
>+            return v.w;
>+        default:
>+            break;
>+    }
>+    half result;
>+    return result;
>+}
>+float operator[](float2 v, uint index) {
>+    switch (index) {
>+        case 0:
>+            return v.x;
>+        case 1:
>+            return v.y;
>+        default:
>+            break;
>+    }
>+    float result;
>+    return result;
>+}
>+float operator[](float3 v, uint index) {
>+    switch (index) {
>+        case 0:
>+            return v.x;
>+        case 1:
>+            return v.y;
>+        case 2:
>+            return v.z;
>+        default:
>+            break;
>+    }
>+    float result;
>+    return result;
>+}
>+float operator[](float4 v, uint index) {
>+    switch (index) {
>+        case 0:
>+            return v.x;
>+        case 1:
>+            return v.y;
>+        case 2:
>+            return v.z;
>+        case 3:
>+            return v.w;
>+        default:
>+            break;
>+    }
>+    float result;
>+    return result;
>+}
>+native half2 operator[](half2x2, uint);
>+native half3 operator[](half2x3, uint);
>+native half4 operator[](half2x4, uint);
>+native half2 operator[](half3x2, uint);
>+native half3 operator[](half3x3, uint);
>+native half4 operator[](half3x4, uint);
>+native half2 operator[](half4x2, uint);
>+native half3 operator[](half4x3, uint);
>+native half4 operator[](half4x4, uint);
>+native float2 operator[](float2x2, uint);
>+native float3 operator[](float2x3, uint);
>+native float4 operator[](float2x4, uint);
>+native float2 operator[](float3x2, uint);
>+native float3 operator[](float3x3, uint);
>+native float4 operator[](float3x4, uint);
>+native float2 operator[](float4x2, uint);
>+native float3 operator[](float4x3, uint);
>+native float4 operator[](float4x4, uint);
>+
>+/* Functions named operator.yywz */
>+bool4 operator.yywz(bool4 v) {
>+    bool4 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.w;
>+    result.w = v.z;
>+    return result;
>+}
>+uchar4 operator.yywz(uchar4 v) {
>+    uchar4 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.w;
>+    result.w = v.z;
>+    return result;
>+}
>+ushort4 operator.yywz(ushort4 v) {
>+    ushort4 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.w;
>+    result.w = v.z;
>+    return result;
>+}
>+uint4 operator.yywz(uint4 v) {
>+    uint4 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.w;
>+    result.w = v.z;
>+    return result;
>+}
>+char4 operator.yywz(char4 v) {
>+    char4 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.w;
>+    result.w = v.z;
>+    return result;
>+}
>+short4 operator.yywz(short4 v) {
>+    short4 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.w;
>+    result.w = v.z;
>+    return result;
>+}
>+int4 operator.yywz(int4 v) {
>+    int4 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.w;
>+    result.w = v.z;
>+    return result;
>+}
>+half4 operator.yywz(half4 v) {
>+    half4 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.w;
>+    result.w = v.z;
>+    return result;
>+}
>+float4 operator.yywz(float4 v) {
>+    float4 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.w;
>+    result.w = v.z;
>+    return result;
>+}
>+
>+/* Functions named exp */
>+native float exp(float);
>+half exp(half x) {
>+    return half(exp(float(x)));
>+}
>+half2 exp(half2 x) {
>+    half2 result;
>+    result[0] = exp(x[0]);
>+    result[1] = exp(x[1]);
>+    return result;
>+}
>+half3 exp(half3 x) {
>+    half3 result;
>+    result[0] = exp(x[0]);
>+    result[1] = exp(x[1]);
>+    result[2] = exp(x[2]);
>+    return result;
>+}
>+half4 exp(half4 x) {
>+    half4 result;
>+    result[0] = exp(x[0]);
>+    result[1] = exp(x[1]);
>+    result[2] = exp(x[2]);
>+    result[3] = exp(x[3]);
>+    return result;
>+}
>+half2x2 exp(half2x2 x) {
>+    half2x2 result;
>+    result[0][0] = exp(x[0][0]);
>+    result[0][1] = exp(x[0][1]);
>+    result[1][0] = exp(x[1][0]);
>+    result[1][1] = exp(x[1][1]);
>+    return result;
>+}
>+half2x3 exp(half2x3 x) {
>+    half2x3 result;
>+    result[0][0] = exp(x[0][0]);
>+    result[0][1] = exp(x[0][1]);
>+    result[0][2] = exp(x[0][2]);
>+    result[1][0] = exp(x[1][0]);
>+    result[1][1] = exp(x[1][1]);
>+    result[1][2] = exp(x[1][2]);
>+    return result;
>+}
>+half2x4 exp(half2x4 x) {
>+    half2x4 result;
>+    result[0][0] = exp(x[0][0]);
>+    result[0][1] = exp(x[0][1]);
>+    result[0][2] = exp(x[0][2]);
>+    result[0][3] = exp(x[0][3]);
>+    result[1][0] = exp(x[1][0]);
>+    result[1][1] = exp(x[1][1]);
>+    result[1][2] = exp(x[1][2]);
>+    result[1][3] = exp(x[1][3]);
>+    return result;
>+}
>+half3x2 exp(half3x2 x) {
>+    half3x2 result;
>+    result[0][0] = exp(x[0][0]);
>+    result[0][1] = exp(x[0][1]);
>+    result[1][0] = exp(x[1][0]);
>+    result[1][1] = exp(x[1][1]);
>+    result[2][0] = exp(x[2][0]);
>+    result[2][1] = exp(x[2][1]);
>+    return result;
>+}
>+half3x3 exp(half3x3 x) {
>+    half3x3 result;
>+    result[0][0] = exp(x[0][0]);
>+    result[0][1] = exp(x[0][1]);
>+    result[0][2] = exp(x[0][2]);
>+    result[1][0] = exp(x[1][0]);
>+    result[1][1] = exp(x[1][1]);
>+    result[1][2] = exp(x[1][2]);
>+    result[2][0] = exp(x[2][0]);
>+    result[2][1] = exp(x[2][1]);
>+    result[2][2] = exp(x[2][2]);
>+    return result;
>+}
>+half3x4 exp(half3x4 x) {
>+    half3x4 result;
>+    result[0][0] = exp(x[0][0]);
>+    result[0][1] = exp(x[0][1]);
>+    result[0][2] = exp(x[0][2]);
>+    result[0][3] = exp(x[0][3]);
>+    result[1][0] = exp(x[1][0]);
>+    result[1][1] = exp(x[1][1]);
>+    result[1][2] = exp(x[1][2]);
>+    result[1][3] = exp(x[1][3]);
>+    result[2][0] = exp(x[2][0]);
>+    result[2][1] = exp(x[2][1]);
>+    result[2][2] = exp(x[2][2]);
>+    result[2][3] = exp(x[2][3]);
>+    return result;
>+}
>+half4x2 exp(half4x2 x) {
>+    half4x2 result;
>+    result[0][0] = exp(x[0][0]);
>+    result[0][1] = exp(x[0][1]);
>+    result[1][0] = exp(x[1][0]);
>+    result[1][1] = exp(x[1][1]);
>+    result[2][0] = exp(x[2][0]);
>+    result[2][1] = exp(x[2][1]);
>+    result[3][0] = exp(x[3][0]);
>+    result[3][1] = exp(x[3][1]);
>+    return result;
>+}
>+half4x3 exp(half4x3 x) {
>+    half4x3 result;
>+    result[0][0] = exp(x[0][0]);
>+    result[0][1] = exp(x[0][1]);
>+    result[0][2] = exp(x[0][2]);
>+    result[1][0] = exp(x[1][0]);
>+    result[1][1] = exp(x[1][1]);
>+    result[1][2] = exp(x[1][2]);
>+    result[2][0] = exp(x[2][0]);
>+    result[2][1] = exp(x[2][1]);
>+    result[2][2] = exp(x[2][2]);
>+    result[3][0] = exp(x[3][0]);
>+    result[3][1] = exp(x[3][1]);
>+    result[3][2] = exp(x[3][2]);
>+    return result;
>+}
>+half4x4 exp(half4x4 x) {
>+    half4x4 result;
>+    result[0][0] = exp(x[0][0]);
>+    result[0][1] = exp(x[0][1]);
>+    result[0][2] = exp(x[0][2]);
>+    result[0][3] = exp(x[0][3]);
>+    result[1][0] = exp(x[1][0]);
>+    result[1][1] = exp(x[1][1]);
>+    result[1][2] = exp(x[1][2]);
>+    result[1][3] = exp(x[1][3]);
>+    result[2][0] = exp(x[2][0]);
>+    result[2][1] = exp(x[2][1]);
>+    result[2][2] = exp(x[2][2]);
>+    result[2][3] = exp(x[2][3]);
>+    result[3][0] = exp(x[3][0]);
>+    result[3][1] = exp(x[3][1]);
>+    result[3][2] = exp(x[3][2]);
>+    result[3][3] = exp(x[3][3]);
>+    return result;
>+}
>+float2 exp(float2 x) {
>+    float2 result;
>+    result[0] = exp(x[0]);
>+    result[1] = exp(x[1]);
>+    return result;
>+}
>+float3 exp(float3 x) {
>+    float3 result;
>+    result[0] = exp(x[0]);
>+    result[1] = exp(x[1]);
>+    result[2] = exp(x[2]);
>+    return result;
>+}
>+float4 exp(float4 x) {
>+    float4 result;
>+    result[0] = exp(x[0]);
>+    result[1] = exp(x[1]);
>+    result[2] = exp(x[2]);
>+    result[3] = exp(x[3]);
>+    return result;
>+}
>+float2x2 exp(float2x2 x) {
>+    float2x2 result;
>+    result[0][0] = exp(x[0][0]);
>+    result[0][1] = exp(x[0][1]);
>+    result[1][0] = exp(x[1][0]);
>+    result[1][1] = exp(x[1][1]);
>+    return result;
>+}
>+float2x3 exp(float2x3 x) {
>+    float2x3 result;
>+    result[0][0] = exp(x[0][0]);
>+    result[0][1] = exp(x[0][1]);
>+    result[0][2] = exp(x[0][2]);
>+    result[1][0] = exp(x[1][0]);
>+    result[1][1] = exp(x[1][1]);
>+    result[1][2] = exp(x[1][2]);
>+    return result;
>+}
>+float2x4 exp(float2x4 x) {
>+    float2x4 result;
>+    result[0][0] = exp(x[0][0]);
>+    result[0][1] = exp(x[0][1]);
>+    result[0][2] = exp(x[0][2]);
>+    result[0][3] = exp(x[0][3]);
>+    result[1][0] = exp(x[1][0]);
>+    result[1][1] = exp(x[1][1]);
>+    result[1][2] = exp(x[1][2]);
>+    result[1][3] = exp(x[1][3]);
>+    return result;
>+}
>+float3x2 exp(float3x2 x) {
>+    float3x2 result;
>+    result[0][0] = exp(x[0][0]);
>+    result[0][1] = exp(x[0][1]);
>+    result[1][0] = exp(x[1][0]);
>+    result[1][1] = exp(x[1][1]);
>+    result[2][0] = exp(x[2][0]);
>+    result[2][1] = exp(x[2][1]);
>+    return result;
>+}
>+float3x3 exp(float3x3 x) {
>+    float3x3 result;
>+    result[0][0] = exp(x[0][0]);
>+    result[0][1] = exp(x[0][1]);
>+    result[0][2] = exp(x[0][2]);
>+    result[1][0] = exp(x[1][0]);
>+    result[1][1] = exp(x[1][1]);
>+    result[1][2] = exp(x[1][2]);
>+    result[2][0] = exp(x[2][0]);
>+    result[2][1] = exp(x[2][1]);
>+    result[2][2] = exp(x[2][2]);
>+    return result;
>+}
>+float3x4 exp(float3x4 x) {
>+    float3x4 result;
>+    result[0][0] = exp(x[0][0]);
>+    result[0][1] = exp(x[0][1]);
>+    result[0][2] = exp(x[0][2]);
>+    result[0][3] = exp(x[0][3]);
>+    result[1][0] = exp(x[1][0]);
>+    result[1][1] = exp(x[1][1]);
>+    result[1][2] = exp(x[1][2]);
>+    result[1][3] = exp(x[1][3]);
>+    result[2][0] = exp(x[2][0]);
>+    result[2][1] = exp(x[2][1]);
>+    result[2][2] = exp(x[2][2]);
>+    result[2][3] = exp(x[2][3]);
>+    return result;
>+}
>+float4x2 exp(float4x2 x) {
>+    float4x2 result;
>+    result[0][0] = exp(x[0][0]);
>+    result[0][1] = exp(x[0][1]);
>+    result[1][0] = exp(x[1][0]);
>+    result[1][1] = exp(x[1][1]);
>+    result[2][0] = exp(x[2][0]);
>+    result[2][1] = exp(x[2][1]);
>+    result[3][0] = exp(x[3][0]);
>+    result[3][1] = exp(x[3][1]);
>+    return result;
>+}
>+float4x3 exp(float4x3 x) {
>+    float4x3 result;
>+    result[0][0] = exp(x[0][0]);
>+    result[0][1] = exp(x[0][1]);
>+    result[0][2] = exp(x[0][2]);
>+    result[1][0] = exp(x[1][0]);
>+    result[1][1] = exp(x[1][1]);
>+    result[1][2] = exp(x[1][2]);
>+    result[2][0] = exp(x[2][0]);
>+    result[2][1] = exp(x[2][1]);
>+    result[2][2] = exp(x[2][2]);
>+    result[3][0] = exp(x[3][0]);
>+    result[3][1] = exp(x[3][1]);
>+    result[3][2] = exp(x[3][2]);
>+    return result;
>+}
>+float4x4 exp(float4x4 x) {
>+    float4x4 result;
>+    result[0][0] = exp(x[0][0]);
>+    result[0][1] = exp(x[0][1]);
>+    result[0][2] = exp(x[0][2]);
>+    result[0][3] = exp(x[0][3]);
>+    result[1][0] = exp(x[1][0]);
>+    result[1][1] = exp(x[1][1]);
>+    result[1][2] = exp(x[1][2]);
>+    result[1][3] = exp(x[1][3]);
>+    result[2][0] = exp(x[2][0]);
>+    result[2][1] = exp(x[2][1]);
>+    result[2][2] = exp(x[2][2]);
>+    result[2][3] = exp(x[2][3]);
>+    result[3][0] = exp(x[3][0]);
>+    result[3][1] = exp(x[3][1]);
>+    result[3][2] = exp(x[3][2]);
>+    result[3][3] = exp(x[3][3]);
>+    return result;
>+}
>+
>+/* Functions named operator.zxw= */
>+bool4 operator.zxw=(bool4 v, bool3 c) {
>+    bool4 result = v;
>+    result.z = c.x;
>+    result.x = c.y;
>+    result.w = c.z;
>+    return result;
>+}
>+uchar4 operator.zxw=(uchar4 v, uchar3 c) {
>+    uchar4 result = v;
>+    result.z = c.x;
>+    result.x = c.y;
>+    result.w = c.z;
>+    return result;
>+}
>+ushort4 operator.zxw=(ushort4 v, ushort3 c) {
>+    ushort4 result = v;
>+    result.z = c.x;
>+    result.x = c.y;
>+    result.w = c.z;
>+    return result;
>+}
>+uint4 operator.zxw=(uint4 v, uint3 c) {
>+    uint4 result = v;
>+    result.z = c.x;
>+    result.x = c.y;
>+    result.w = c.z;
>+    return result;
>+}
>+char4 operator.zxw=(char4 v, char3 c) {
>+    char4 result = v;
>+    result.z = c.x;
>+    result.x = c.y;
>+    result.w = c.z;
>+    return result;
>+}
>+short4 operator.zxw=(short4 v, short3 c) {
>+    short4 result = v;
>+    result.z = c.x;
>+    result.x = c.y;
>+    result.w = c.z;
>+    return result;
>+}
>+int4 operator.zxw=(int4 v, int3 c) {
>+    int4 result = v;
>+    result.z = c.x;
>+    result.x = c.y;
>+    result.w = c.z;
>+    return result;
>+}
>+half4 operator.zxw=(half4 v, half3 c) {
>+    half4 result = v;
>+    result.z = c.x;
>+    result.x = c.y;
>+    result.w = c.z;
>+    return result;
>+}
>+float4 operator.zxw=(float4 v, float3 c) {
>+    float4 result = v;
>+    result.z = c.x;
>+    result.x = c.y;
>+    result.w = c.z;
>+    return result;
>+}
>+
>+/* Functions named operator.zzz */
>+bool3 operator.zzz(bool3 v) {
>+    bool3 result;
>+    result.x = v.z;
>+    result.y = v.z;
>+    result.z = v.z;
>+    return result;
>+}
>+bool3 operator.zzz(bool4 v) {
>+    bool3 result;
>+    result.x = v.z;
>+    result.y = v.z;
>+    result.z = v.z;
>+    return result;
>+}
>+uchar3 operator.zzz(uchar3 v) {
>+    uchar3 result;
>+    result.x = v.z;
>+    result.y = v.z;
>+    result.z = v.z;
>+    return result;
>+}
>+uchar3 operator.zzz(uchar4 v) {
>+    uchar3 result;
>+    result.x = v.z;
>+    result.y = v.z;
>+    result.z = v.z;
>+    return result;
>+}
>+ushort3 operator.zzz(ushort3 v) {
>+    ushort3 result;
>+    result.x = v.z;
>+    result.y = v.z;
>+    result.z = v.z;
>+    return result;
>+}
>+ushort3 operator.zzz(ushort4 v) {
>+    ushort3 result;
>+    result.x = v.z;
>+    result.y = v.z;
>+    result.z = v.z;
>+    return result;
>+}
>+uint3 operator.zzz(uint3 v) {
>+    uint3 result;
>+    result.x = v.z;
>+    result.y = v.z;
>+    result.z = v.z;
>+    return result;
>+}
>+uint3 operator.zzz(uint4 v) {
>+    uint3 result;
>+    result.x = v.z;
>+    result.y = v.z;
>+    result.z = v.z;
>+    return result;
>+}
>+char3 operator.zzz(char3 v) {
>+    char3 result;
>+    result.x = v.z;
>+    result.y = v.z;
>+    result.z = v.z;
>+    return result;
>+}
>+char3 operator.zzz(char4 v) {
>+    char3 result;
>+    result.x = v.z;
>+    result.y = v.z;
>+    result.z = v.z;
>+    return result;
>+}
>+short3 operator.zzz(short3 v) {
>+    short3 result;
>+    result.x = v.z;
>+    result.y = v.z;
>+    result.z = v.z;
>+    return result;
>+}
>+short3 operator.zzz(short4 v) {
>+    short3 result;
>+    result.x = v.z;
>+    result.y = v.z;
>+    result.z = v.z;
>+    return result;
>+}
>+int3 operator.zzz(int3 v) {
>+    int3 result;
>+    result.x = v.z;
>+    result.y = v.z;
>+    result.z = v.z;
>+    return result;
>+}
>+int3 operator.zzz(int4 v) {
>+    int3 result;
>+    result.x = v.z;
>+    result.y = v.z;
>+    result.z = v.z;
>+    return result;
>+}
>+half3 operator.zzz(half3 v) {
>+    half3 result;
>+    result.x = v.z;
>+    result.y = v.z;
>+    result.z = v.z;
>+    return result;
>+}
>+half3 operator.zzz(half4 v) {
>+    half3 result;
>+    result.x = v.z;
>+    result.y = v.z;
>+    result.z = v.z;
>+    return result;
>+}
>+float3 operator.zzz(float3 v) {
>+    float3 result;
>+    result.x = v.z;
>+    result.y = v.z;
>+    result.z = v.z;
>+    return result;
>+}
>+float3 operator.zzz(float4 v) {
>+    float3 result;
>+    result.x = v.z;
>+    result.y = v.z;
>+    result.z = v.z;
>+    return result;
>+}
>+
>+/* Functions named operator.wzwx */
>+bool4 operator.wzwx(bool4 v) {
>+    bool4 result;
>+    result.x = v.w;
>+    result.y = v.z;
>+    result.z = v.w;
>+    result.w = v.x;
>+    return result;
>+}
>+uchar4 operator.wzwx(uchar4 v) {
>+    uchar4 result;
>+    result.x = v.w;
>+    result.y = v.z;
>+    result.z = v.w;
>+    result.w = v.x;
>+    return result;
>+}
>+ushort4 operator.wzwx(ushort4 v) {
>+    ushort4 result;
>+    result.x = v.w;
>+    result.y = v.z;
>+    result.z = v.w;
>+    result.w = v.x;
>+    return result;
>+}
>+uint4 operator.wzwx(uint4 v) {
>+    uint4 result;
>+    result.x = v.w;
>+    result.y = v.z;
>+    result.z = v.w;
>+    result.w = v.x;
>+    return result;
>+}
>+char4 operator.wzwx(char4 v) {
>+    char4 result;
>+    result.x = v.w;
>+    result.y = v.z;
>+    result.z = v.w;
>+    result.w = v.x;
>+    return result;
>+}
>+short4 operator.wzwx(short4 v) {
>+    short4 result;
>+    result.x = v.w;
>+    result.y = v.z;
>+    result.z = v.w;
>+    result.w = v.x;
>+    return result;
>+}
>+int4 operator.wzwx(int4 v) {
>+    int4 result;
>+    result.x = v.w;
>+    result.y = v.z;
>+    result.z = v.w;
>+    result.w = v.x;
>+    return result;
>+}
>+half4 operator.wzwx(half4 v) {
>+    half4 result;
>+    result.x = v.w;
>+    result.y = v.z;
>+    result.z = v.w;
>+    result.w = v.x;
>+    return result;
>+}
>+float4 operator.wzwx(float4 v) {
>+    float4 result;
>+    result.x = v.w;
>+    result.y = v.z;
>+    result.z = v.w;
>+    result.w = v.x;
>+    return result;
>+}
>+
>+/* Functions named operator.yyzz */
>+bool4 operator.yyzz(bool3 v) {
>+    bool4 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.z;
>+    result.w = v.z;
>+    return result;
>+}
>+bool4 operator.yyzz(bool4 v) {
>+    bool4 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.z;
>+    result.w = v.z;
>+    return result;
>+}
>+uchar4 operator.yyzz(uchar3 v) {
>+    uchar4 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.z;
>+    result.w = v.z;
>+    return result;
>+}
>+uchar4 operator.yyzz(uchar4 v) {
>+    uchar4 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.z;
>+    result.w = v.z;
>+    return result;
>+}
>+ushort4 operator.yyzz(ushort3 v) {
>+    ushort4 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.z;
>+    result.w = v.z;
>+    return result;
>+}
>+ushort4 operator.yyzz(ushort4 v) {
>+    ushort4 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.z;
>+    result.w = v.z;
>+    return result;
>+}
>+uint4 operator.yyzz(uint3 v) {
>+    uint4 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.z;
>+    result.w = v.z;
>+    return result;
>+}
>+uint4 operator.yyzz(uint4 v) {
>+    uint4 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.z;
>+    result.w = v.z;
>+    return result;
>+}
>+char4 operator.yyzz(char3 v) {
>+    char4 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.z;
>+    result.w = v.z;
>+    return result;
>+}
>+char4 operator.yyzz(char4 v) {
>+    char4 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.z;
>+    result.w = v.z;
>+    return result;
>+}
>+short4 operator.yyzz(short3 v) {
>+    short4 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.z;
>+    result.w = v.z;
>+    return result;
>+}
>+short4 operator.yyzz(short4 v) {
>+    short4 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.z;
>+    result.w = v.z;
>+    return result;
>+}
>+int4 operator.yyzz(int3 v) {
>+    int4 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.z;
>+    result.w = v.z;
>+    return result;
>+}
>+int4 operator.yyzz(int4 v) {
>+    int4 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.z;
>+    result.w = v.z;
>+    return result;
>+}
>+half4 operator.yyzz(half3 v) {
>+    half4 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.z;
>+    result.w = v.z;
>+    return result;
>+}
>+half4 operator.yyzz(half4 v) {
>+    half4 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.z;
>+    result.w = v.z;
>+    return result;
>+}
>+float4 operator.yyzz(float3 v) {
>+    float4 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.z;
>+    result.w = v.z;
>+    return result;
>+}
>+float4 operator.yyzz(float4 v) {
>+    float4 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.z;
>+    result.w = v.z;
>+    return result;
>+}
>+
>+/* Functions named operator.yywx */
>+bool4 operator.yywx(bool4 v) {
>+    bool4 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.w;
>+    result.w = v.x;
>+    return result;
>+}
>+uchar4 operator.yywx(uchar4 v) {
>+    uchar4 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.w;
>+    result.w = v.x;
>+    return result;
>+}
>+ushort4 operator.yywx(ushort4 v) {
>+    ushort4 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.w;
>+    result.w = v.x;
>+    return result;
>+}
>+uint4 operator.yywx(uint4 v) {
>+    uint4 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.w;
>+    result.w = v.x;
>+    return result;
>+}
>+char4 operator.yywx(char4 v) {
>+    char4 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.w;
>+    result.w = v.x;
>+    return result;
>+}
>+short4 operator.yywx(short4 v) {
>+    short4 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.w;
>+    result.w = v.x;
>+    return result;
>+}
>+int4 operator.yywx(int4 v) {
>+    int4 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.w;
>+    result.w = v.x;
>+    return result;
>+}
>+half4 operator.yywx(half4 v) {
>+    half4 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.w;
>+    result.w = v.x;
>+    return result;
>+}
>+float4 operator.yywx(float4 v) {
>+    float4 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.w;
>+    result.w = v.x;
>+    return result;
>+}
>+
>+/* Functions named operator.zzx */
>+bool3 operator.zzx(bool3 v) {
>+    bool3 result;
>+    result.x = v.z;
>+    result.y = v.z;
>+    result.z = v.x;
>+    return result;
>+}
>+bool3 operator.zzx(bool4 v) {
>+    bool3 result;
>+    result.x = v.z;
>+    result.y = v.z;
>+    result.z = v.x;
>+    return result;
>+}
>+uchar3 operator.zzx(uchar3 v) {
>+    uchar3 result;
>+    result.x = v.z;
>+    result.y = v.z;
>+    result.z = v.x;
>+    return result;
>+}
>+uchar3 operator.zzx(uchar4 v) {
>+    uchar3 result;
>+    result.x = v.z;
>+    result.y = v.z;
>+    result.z = v.x;
>+    return result;
>+}
>+ushort3 operator.zzx(ushort3 v) {
>+    ushort3 result;
>+    result.x = v.z;
>+    result.y = v.z;
>+    result.z = v.x;
>+    return result;
>+}
>+ushort3 operator.zzx(ushort4 v) {
>+    ushort3 result;
>+    result.x = v.z;
>+    result.y = v.z;
>+    result.z = v.x;
>+    return result;
>+}
>+uint3 operator.zzx(uint3 v) {
>+    uint3 result;
>+    result.x = v.z;
>+    result.y = v.z;
>+    result.z = v.x;
>+    return result;
>+}
>+uint3 operator.zzx(uint4 v) {
>+    uint3 result;
>+    result.x = v.z;
>+    result.y = v.z;
>+    result.z = v.x;
>+    return result;
>+}
>+char3 operator.zzx(char3 v) {
>+    char3 result;
>+    result.x = v.z;
>+    result.y = v.z;
>+    result.z = v.x;
>+    return result;
>+}
>+char3 operator.zzx(char4 v) {
>+    char3 result;
>+    result.x = v.z;
>+    result.y = v.z;
>+    result.z = v.x;
>+    return result;
>+}
>+short3 operator.zzx(short3 v) {
>+    short3 result;
>+    result.x = v.z;
>+    result.y = v.z;
>+    result.z = v.x;
>+    return result;
>+}
>+short3 operator.zzx(short4 v) {
>+    short3 result;
>+    result.x = v.z;
>+    result.y = v.z;
>+    result.z = v.x;
>+    return result;
>+}
>+int3 operator.zzx(int3 v) {
>+    int3 result;
>+    result.x = v.z;
>+    result.y = v.z;
>+    result.z = v.x;
>+    return result;
>+}
>+int3 operator.zzx(int4 v) {
>+    int3 result;
>+    result.x = v.z;
>+    result.y = v.z;
>+    result.z = v.x;
>+    return result;
>+}
>+half3 operator.zzx(half3 v) {
>+    half3 result;
>+    result.x = v.z;
>+    result.y = v.z;
>+    result.z = v.x;
>+    return result;
>+}
>+half3 operator.zzx(half4 v) {
>+    half3 result;
>+    result.x = v.z;
>+    result.y = v.z;
>+    result.z = v.x;
>+    return result;
>+}
>+float3 operator.zzx(float3 v) {
>+    float3 result;
>+    result.x = v.z;
>+    result.y = v.z;
>+    result.z = v.x;
>+    return result;
>+}
>+float3 operator.zzx(float4 v) {
>+    float3 result;
>+    result.x = v.z;
>+    result.y = v.z;
>+    result.z = v.x;
>+    return result;
>+}
>+
>+/* Functions named operator.xxx */
>+bool3 operator.xxx(bool2 v) {
>+    bool3 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.x;
>+    return result;
>+}
>+bool3 operator.xxx(bool3 v) {
>+    bool3 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.x;
>+    return result;
>+}
>+bool3 operator.xxx(bool4 v) {
>+    bool3 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.x;
>+    return result;
>+}
>+uchar3 operator.xxx(uchar2 v) {
>+    uchar3 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.x;
>+    return result;
>+}
>+uchar3 operator.xxx(uchar3 v) {
>+    uchar3 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.x;
>+    return result;
>+}
>+uchar3 operator.xxx(uchar4 v) {
>+    uchar3 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.x;
>+    return result;
>+}
>+ushort3 operator.xxx(ushort2 v) {
>+    ushort3 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.x;
>+    return result;
>+}
>+ushort3 operator.xxx(ushort3 v) {
>+    ushort3 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.x;
>+    return result;
>+}
>+ushort3 operator.xxx(ushort4 v) {
>+    ushort3 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.x;
>+    return result;
>+}
>+uint3 operator.xxx(uint2 v) {
>+    uint3 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.x;
>+    return result;
>+}
>+uint3 operator.xxx(uint3 v) {
>+    uint3 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.x;
>+    return result;
>+}
>+uint3 operator.xxx(uint4 v) {
>+    uint3 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.x;
>+    return result;
>+}
>+char3 operator.xxx(char2 v) {
>+    char3 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.x;
>+    return result;
>+}
>+char3 operator.xxx(char3 v) {
>+    char3 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.x;
>+    return result;
>+}
>+char3 operator.xxx(char4 v) {
>+    char3 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.x;
>+    return result;
>+}
>+short3 operator.xxx(short2 v) {
>+    short3 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.x;
>+    return result;
>+}
>+short3 operator.xxx(short3 v) {
>+    short3 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.x;
>+    return result;
>+}
>+short3 operator.xxx(short4 v) {
>+    short3 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.x;
>+    return result;
>+}
>+int3 operator.xxx(int2 v) {
>+    int3 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.x;
>+    return result;
>+}
>+int3 operator.xxx(int3 v) {
>+    int3 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.x;
>+    return result;
>+}
>+int3 operator.xxx(int4 v) {
>+    int3 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.x;
>+    return result;
>+}
>+half3 operator.xxx(half2 v) {
>+    half3 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.x;
>+    return result;
>+}
>+half3 operator.xxx(half3 v) {
>+    half3 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.x;
>+    return result;
>+}
>+half3 operator.xxx(half4 v) {
>+    half3 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.x;
>+    return result;
>+}
>+float3 operator.xxx(float2 v) {
>+    float3 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.x;
>+    return result;
>+}
>+float3 operator.xxx(float3 v) {
>+    float3 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.x;
>+    return result;
>+}
>+float3 operator.xxx(float4 v) {
>+    float3 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.x;
>+    return result;
>+}
>+
>+/* Functions named operator.yxxy */
>+bool4 operator.yxxy(bool2 v) {
>+    bool4 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.x;
>+    result.w = v.y;
>+    return result;
>+}
>+bool4 operator.yxxy(bool3 v) {
>+    bool4 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.x;
>+    result.w = v.y;
>+    return result;
>+}
>+bool4 operator.yxxy(bool4 v) {
>+    bool4 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.x;
>+    result.w = v.y;
>+    return result;
>+}
>+uchar4 operator.yxxy(uchar2 v) {
>+    uchar4 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.x;
>+    result.w = v.y;
>+    return result;
>+}
>+uchar4 operator.yxxy(uchar3 v) {
>+    uchar4 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.x;
>+    result.w = v.y;
>+    return result;
>+}
>+uchar4 operator.yxxy(uchar4 v) {
>+    uchar4 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.x;
>+    result.w = v.y;
>+    return result;
>+}
>+ushort4 operator.yxxy(ushort2 v) {
>+    ushort4 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.x;
>+    result.w = v.y;
>+    return result;
>+}
>+ushort4 operator.yxxy(ushort3 v) {
>+    ushort4 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.x;
>+    result.w = v.y;
>+    return result;
>+}
>+ushort4 operator.yxxy(ushort4 v) {
>+    ushort4 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.x;
>+    result.w = v.y;
>+    return result;
>+}
>+uint4 operator.yxxy(uint2 v) {
>+    uint4 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.x;
>+    result.w = v.y;
>+    return result;
>+}
>+uint4 operator.yxxy(uint3 v) {
>+    uint4 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.x;
>+    result.w = v.y;
>+    return result;
>+}
>+uint4 operator.yxxy(uint4 v) {
>+    uint4 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.x;
>+    result.w = v.y;
>+    return result;
>+}
>+char4 operator.yxxy(char2 v) {
>+    char4 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.x;
>+    result.w = v.y;
>+    return result;
>+}
>+char4 operator.yxxy(char3 v) {
>+    char4 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.x;
>+    result.w = v.y;
>+    return result;
>+}
>+char4 operator.yxxy(char4 v) {
>+    char4 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.x;
>+    result.w = v.y;
>+    return result;
>+}
>+short4 operator.yxxy(short2 v) {
>+    short4 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.x;
>+    result.w = v.y;
>+    return result;
>+}
>+short4 operator.yxxy(short3 v) {
>+    short4 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.x;
>+    result.w = v.y;
>+    return result;
>+}
>+short4 operator.yxxy(short4 v) {
>+    short4 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.x;
>+    result.w = v.y;
>+    return result;
>+}
>+int4 operator.yxxy(int2 v) {
>+    int4 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.x;
>+    result.w = v.y;
>+    return result;
>+}
>+int4 operator.yxxy(int3 v) {
>+    int4 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.x;
>+    result.w = v.y;
>+    return result;
>+}
>+int4 operator.yxxy(int4 v) {
>+    int4 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.x;
>+    result.w = v.y;
>+    return result;
>+}
>+half4 operator.yxxy(half2 v) {
>+    half4 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.x;
>+    result.w = v.y;
>+    return result;
>+}
>+half4 operator.yxxy(half3 v) {
>+    half4 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.x;
>+    result.w = v.y;
>+    return result;
>+}
>+half4 operator.yxxy(half4 v) {
>+    half4 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.x;
>+    result.w = v.y;
>+    return result;
>+}
>+float4 operator.yxxy(float2 v) {
>+    float4 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.x;
>+    result.w = v.y;
>+    return result;
>+}
>+float4 operator.yxxy(float3 v) {
>+    float4 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.x;
>+    result.w = v.y;
>+    return result;
>+}
>+float4 operator.yxxy(float4 v) {
>+    float4 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.x;
>+    result.w = v.y;
>+    return result;
>+}
>+
>+/* Functions named operator.wyyy */
>+bool4 operator.wyyy(bool4 v) {
>+    bool4 result;
>+    result.x = v.w;
>+    result.y = v.y;
>+    result.z = v.y;
>+    result.w = v.y;
>+    return result;
>+}
>+uchar4 operator.wyyy(uchar4 v) {
>+    uchar4 result;
>+    result.x = v.w;
>+    result.y = v.y;
>+    result.z = v.y;
>+    result.w = v.y;
>+    return result;
>+}
>+ushort4 operator.wyyy(ushort4 v) {
>+    ushort4 result;
>+    result.x = v.w;
>+    result.y = v.y;
>+    result.z = v.y;
>+    result.w = v.y;
>+    return result;
>+}
>+uint4 operator.wyyy(uint4 v) {
>+    uint4 result;
>+    result.x = v.w;
>+    result.y = v.y;
>+    result.z = v.y;
>+    result.w = v.y;
>+    return result;
>+}
>+char4 operator.wyyy(char4 v) {
>+    char4 result;
>+    result.x = v.w;
>+    result.y = v.y;
>+    result.z = v.y;
>+    result.w = v.y;
>+    return result;
>+}
>+short4 operator.wyyy(short4 v) {
>+    short4 result;
>+    result.x = v.w;
>+    result.y = v.y;
>+    result.z = v.y;
>+    result.w = v.y;
>+    return result;
>+}
>+int4 operator.wyyy(int4 v) {
>+    int4 result;
>+    result.x = v.w;
>+    result.y = v.y;
>+    result.z = v.y;
>+    result.w = v.y;
>+    return result;
>+}
>+half4 operator.wyyy(half4 v) {
>+    half4 result;
>+    result.x = v.w;
>+    result.y = v.y;
>+    result.z = v.y;
>+    result.w = v.y;
>+    return result;
>+}
>+float4 operator.wyyy(float4 v) {
>+    float4 result;
>+    result.x = v.w;
>+    result.y = v.y;
>+    result.z = v.y;
>+    result.w = v.y;
>+    return result;
>+}
>+
>+/* Functions named operator.wyww */
>+bool4 operator.wyww(bool4 v) {
>+    bool4 result;
>+    result.x = v.w;
>+    result.y = v.y;
>+    result.z = v.w;
>+    result.w = v.w;
>+    return result;
>+}
>+uchar4 operator.wyww(uchar4 v) {
>+    uchar4 result;
>+    result.x = v.w;
>+    result.y = v.y;
>+    result.z = v.w;
>+    result.w = v.w;
>+    return result;
>+}
>+ushort4 operator.wyww(ushort4 v) {
>+    ushort4 result;
>+    result.x = v.w;
>+    result.y = v.y;
>+    result.z = v.w;
>+    result.w = v.w;
>+    return result;
>+}
>+uint4 operator.wyww(uint4 v) {
>+    uint4 result;
>+    result.x = v.w;
>+    result.y = v.y;
>+    result.z = v.w;
>+    result.w = v.w;
>+    return result;
>+}
>+char4 operator.wyww(char4 v) {
>+    char4 result;
>+    result.x = v.w;
>+    result.y = v.y;
>+    result.z = v.w;
>+    result.w = v.w;
>+    return result;
>+}
>+short4 operator.wyww(short4 v) {
>+    short4 result;
>+    result.x = v.w;
>+    result.y = v.y;
>+    result.z = v.w;
>+    result.w = v.w;
>+    return result;
>+}
>+int4 operator.wyww(int4 v) {
>+    int4 result;
>+    result.x = v.w;
>+    result.y = v.y;
>+    result.z = v.w;
>+    result.w = v.w;
>+    return result;
>+}
>+half4 operator.wyww(half4 v) {
>+    half4 result;
>+    result.x = v.w;
>+    result.y = v.y;
>+    result.z = v.w;
>+    result.w = v.w;
>+    return result;
>+}
>+float4 operator.wyww(float4 v) {
>+    float4 result;
>+    result.x = v.w;
>+    result.y = v.y;
>+    result.z = v.w;
>+    result.w = v.w;
>+    return result;
>+}
>+
>+/* Functions named operator.yyyw */
>+bool4 operator.yyyw(bool4 v) {
>+    bool4 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.y;
>+    result.w = v.w;
>+    return result;
>+}
>+uchar4 operator.yyyw(uchar4 v) {
>+    uchar4 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.y;
>+    result.w = v.w;
>+    return result;
>+}
>+ushort4 operator.yyyw(ushort4 v) {
>+    ushort4 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.y;
>+    result.w = v.w;
>+    return result;
>+}
>+uint4 operator.yyyw(uint4 v) {
>+    uint4 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.y;
>+    result.w = v.w;
>+    return result;
>+}
>+char4 operator.yyyw(char4 v) {
>+    char4 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.y;
>+    result.w = v.w;
>+    return result;
>+}
>+short4 operator.yyyw(short4 v) {
>+    short4 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.y;
>+    result.w = v.w;
>+    return result;
>+}
>+int4 operator.yyyw(int4 v) {
>+    int4 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.y;
>+    result.w = v.w;
>+    return result;
>+}
>+half4 operator.yyyw(half4 v) {
>+    half4 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.y;
>+    result.w = v.w;
>+    return result;
>+}
>+float4 operator.yyyw(float4 v) {
>+    float4 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.y;
>+    result.w = v.w;
>+    return result;
>+}
>+
>+/* Functions named operator.xxw */
>+bool3 operator.xxw(bool4 v) {
>+    bool3 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.w;
>+    return result;
>+}
>+uchar3 operator.xxw(uchar4 v) {
>+    uchar3 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.w;
>+    return result;
>+}
>+ushort3 operator.xxw(ushort4 v) {
>+    ushort3 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.w;
>+    return result;
>+}
>+uint3 operator.xxw(uint4 v) {
>+    uint3 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.w;
>+    return result;
>+}
>+char3 operator.xxw(char4 v) {
>+    char3 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.w;
>+    return result;
>+}
>+short3 operator.xxw(short4 v) {
>+    short3 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.w;
>+    return result;
>+}
>+int3 operator.xxw(int4 v) {
>+    int3 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.w;
>+    return result;
>+}
>+half3 operator.xxw(half4 v) {
>+    half3 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.w;
>+    return result;
>+}
>+float3 operator.xxw(float4 v) {
>+    float3 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.w;
>+    return result;
>+}
>+
>+/* Functions named operator.xzxy */
>+bool4 operator.xzxy(bool3 v) {
>+    bool4 result;
>+    result.x = v.x;
>+    result.y = v.z;
>+    result.z = v.x;
>+    result.w = v.y;
>+    return result;
>+}
>+bool4 operator.xzxy(bool4 v) {
>+    bool4 result;
>+    result.x = v.x;
>+    result.y = v.z;
>+    result.z = v.x;
>+    result.w = v.y;
>+    return result;
>+}
>+uchar4 operator.xzxy(uchar3 v) {
>+    uchar4 result;
>+    result.x = v.x;
>+    result.y = v.z;
>+    result.z = v.x;
>+    result.w = v.y;
>+    return result;
>+}
>+uchar4 operator.xzxy(uchar4 v) {
>+    uchar4 result;
>+    result.x = v.x;
>+    result.y = v.z;
>+    result.z = v.x;
>+    result.w = v.y;
>+    return result;
>+}
>+ushort4 operator.xzxy(ushort3 v) {
>+    ushort4 result;
>+    result.x = v.x;
>+    result.y = v.z;
>+    result.z = v.x;
>+    result.w = v.y;
>+    return result;
>+}
>+ushort4 operator.xzxy(ushort4 v) {
>+    ushort4 result;
>+    result.x = v.x;
>+    result.y = v.z;
>+    result.z = v.x;
>+    result.w = v.y;
>+    return result;
>+}
>+uint4 operator.xzxy(uint3 v) {
>+    uint4 result;
>+    result.x = v.x;
>+    result.y = v.z;
>+    result.z = v.x;
>+    result.w = v.y;
>+    return result;
>+}
>+uint4 operator.xzxy(uint4 v) {
>+    uint4 result;
>+    result.x = v.x;
>+    result.y = v.z;
>+    result.z = v.x;
>+    result.w = v.y;
>+    return result;
>+}
>+char4 operator.xzxy(char3 v) {
>+    char4 result;
>+    result.x = v.x;
>+    result.y = v.z;
>+    result.z = v.x;
>+    result.w = v.y;
>+    return result;
>+}
>+char4 operator.xzxy(char4 v) {
>+    char4 result;
>+    result.x = v.x;
>+    result.y = v.z;
>+    result.z = v.x;
>+    result.w = v.y;
>+    return result;
>+}
>+short4 operator.xzxy(short3 v) {
>+    short4 result;
>+    result.x = v.x;
>+    result.y = v.z;
>+    result.z = v.x;
>+    result.w = v.y;
>+    return result;
>+}
>+short4 operator.xzxy(short4 v) {
>+    short4 result;
>+    result.x = v.x;
>+    result.y = v.z;
>+    result.z = v.x;
>+    result.w = v.y;
>+    return result;
>+}
>+int4 operator.xzxy(int3 v) {
>+    int4 result;
>+    result.x = v.x;
>+    result.y = v.z;
>+    result.z = v.x;
>+    result.w = v.y;
>+    return result;
>+}
>+int4 operator.xzxy(int4 v) {
>+    int4 result;
>+    result.x = v.x;
>+    result.y = v.z;
>+    result.z = v.x;
>+    result.w = v.y;
>+    return result;
>+}
>+half4 operator.xzxy(half3 v) {
>+    half4 result;
>+    result.x = v.x;
>+    result.y = v.z;
>+    result.z = v.x;
>+    result.w = v.y;
>+    return result;
>+}
>+half4 operator.xzxy(half4 v) {
>+    half4 result;
>+    result.x = v.x;
>+    result.y = v.z;
>+    result.z = v.x;
>+    result.w = v.y;
>+    return result;
>+}
>+float4 operator.xzxy(float3 v) {
>+    float4 result;
>+    result.x = v.x;
>+    result.y = v.z;
>+    result.z = v.x;
>+    result.w = v.y;
>+    return result;
>+}
>+float4 operator.xzxy(float4 v) {
>+    float4 result;
>+    result.x = v.x;
>+    result.y = v.z;
>+    result.z = v.x;
>+    result.w = v.y;
>+    return result;
>+}
>+
>+/* Functions named operator.yw= */
>+bool4 operator.yw=(bool4 v, bool2 c) {
>+    bool4 result = v;
>+    result.y = c.x;
>+    result.w = c.y;
>+    return result;
>+}
>+uchar4 operator.yw=(uchar4 v, uchar2 c) {
>+    uchar4 result = v;
>+    result.y = c.x;
>+    result.w = c.y;
>+    return result;
>+}
>+ushort4 operator.yw=(ushort4 v, ushort2 c) {
>+    ushort4 result = v;
>+    result.y = c.x;
>+    result.w = c.y;
>+    return result;
>+}
>+uint4 operator.yw=(uint4 v, uint2 c) {
>+    uint4 result = v;
>+    result.y = c.x;
>+    result.w = c.y;
>+    return result;
>+}
>+char4 operator.yw=(char4 v, char2 c) {
>+    char4 result = v;
>+    result.y = c.x;
>+    result.w = c.y;
>+    return result;
>+}
>+short4 operator.yw=(short4 v, short2 c) {
>+    short4 result = v;
>+    result.y = c.x;
>+    result.w = c.y;
>+    return result;
>+}
>+int4 operator.yw=(int4 v, int2 c) {
>+    int4 result = v;
>+    result.y = c.x;
>+    result.w = c.y;
>+    return result;
>+}
>+half4 operator.yw=(half4 v, half2 c) {
>+    half4 result = v;
>+    result.y = c.x;
>+    result.w = c.y;
>+    return result;
>+}
>+float4 operator.yw=(float4 v, float2 c) {
>+    float4 result = v;
>+    result.y = c.x;
>+    result.w = c.y;
>+    return result;
>+}
>+
>+/* Functions named operator.xyx */
>+bool3 operator.xyx(bool2 v) {
>+    bool3 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.x;
>+    return result;
>+}
>+bool3 operator.xyx(bool3 v) {
>+    bool3 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.x;
>+    return result;
>+}
>+bool3 operator.xyx(bool4 v) {
>+    bool3 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.x;
>+    return result;
>+}
>+uchar3 operator.xyx(uchar2 v) {
>+    uchar3 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.x;
>+    return result;
>+}
>+uchar3 operator.xyx(uchar3 v) {
>+    uchar3 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.x;
>+    return result;
>+}
>+uchar3 operator.xyx(uchar4 v) {
>+    uchar3 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.x;
>+    return result;
>+}
>+ushort3 operator.xyx(ushort2 v) {
>+    ushort3 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.x;
>+    return result;
>+}
>+ushort3 operator.xyx(ushort3 v) {
>+    ushort3 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.x;
>+    return result;
>+}
>+ushort3 operator.xyx(ushort4 v) {
>+    ushort3 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.x;
>+    return result;
>+}
>+uint3 operator.xyx(uint2 v) {
>+    uint3 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.x;
>+    return result;
>+}
>+uint3 operator.xyx(uint3 v) {
>+    uint3 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.x;
>+    return result;
>+}
>+uint3 operator.xyx(uint4 v) {
>+    uint3 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.x;
>+    return result;
>+}
>+char3 operator.xyx(char2 v) {
>+    char3 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.x;
>+    return result;
>+}
>+char3 operator.xyx(char3 v) {
>+    char3 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.x;
>+    return result;
>+}
>+char3 operator.xyx(char4 v) {
>+    char3 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.x;
>+    return result;
>+}
>+short3 operator.xyx(short2 v) {
>+    short3 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.x;
>+    return result;
>+}
>+short3 operator.xyx(short3 v) {
>+    short3 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.x;
>+    return result;
>+}
>+short3 operator.xyx(short4 v) {
>+    short3 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.x;
>+    return result;
>+}
>+int3 operator.xyx(int2 v) {
>+    int3 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.x;
>+    return result;
>+}
>+int3 operator.xyx(int3 v) {
>+    int3 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.x;
>+    return result;
>+}
>+int3 operator.xyx(int4 v) {
>+    int3 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.x;
>+    return result;
>+}
>+half3 operator.xyx(half2 v) {
>+    half3 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.x;
>+    return result;
>+}
>+half3 operator.xyx(half3 v) {
>+    half3 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.x;
>+    return result;
>+}
>+half3 operator.xyx(half4 v) {
>+    half3 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.x;
>+    return result;
>+}
>+float3 operator.xyx(float2 v) {
>+    float3 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.x;
>+    return result;
>+}
>+float3 operator.xyx(float3 v) {
>+    float3 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.x;
>+    return result;
>+}
>+float3 operator.xyx(float4 v) {
>+    float3 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.x;
>+    return result;
>+}
>+
>+/* Functions named all */
>+bool all(bool x) {
>+    return x;
>+}
>+bool all(bool2 x) {
>+    bool result = true;
>+    result = result && (x[0]);
>+    result = result && (x[1]);
>+    return result;
>+}
>+bool all(bool3 x) {
>+    bool result = true;
>+    result = result && (x[0]);
>+    result = result && (x[1]);
>+    result = result && (x[2]);
>+    return result;
>+}
>+bool all(bool4 x) {
>+    bool result = true;
>+    result = result && (x[0]);
>+    result = result && (x[1]);
>+    result = result && (x[2]);
>+    result = result && (x[3]);
>+    return result;
>+}
>+bool all(uchar x) {
>+    return x != 0;
>+}
>+bool all(uchar2 x) {
>+    bool result = true;
>+    result = result && (x[0] != 0);
>+    result = result && (x[1] != 0);
>+    return result;
>+}
>+bool all(uchar3 x) {
>+    bool result = true;
>+    result = result && (x[0] != 0);
>+    result = result && (x[1] != 0);
>+    result = result && (x[2] != 0);
>+    return result;
>+}
>+bool all(uchar4 x) {
>+    bool result = true;
>+    result = result && (x[0] != 0);
>+    result = result && (x[1] != 0);
>+    result = result && (x[2] != 0);
>+    result = result && (x[3] != 0);
>+    return result;
>+}
>+bool all(ushort x) {
>+    return x != 0;
>+}
>+bool all(ushort2 x) {
>+    bool result = true;
>+    result = result && (x[0] != 0);
>+    result = result && (x[1] != 0);
>+    return result;
>+}
>+bool all(ushort3 x) {
>+    bool result = true;
>+    result = result && (x[0] != 0);
>+    result = result && (x[1] != 0);
>+    result = result && (x[2] != 0);
>+    return result;
>+}
>+bool all(ushort4 x) {
>+    bool result = true;
>+    result = result && (x[0] != 0);
>+    result = result && (x[1] != 0);
>+    result = result && (x[2] != 0);
>+    result = result && (x[3] != 0);
>+    return result;
>+}
>+bool all(uint x) {
>+    return x != 0;
>+}
>+bool all(uint2 x) {
>+    bool result = true;
>+    result = result && (x[0] != 0);
>+    result = result && (x[1] != 0);
>+    return result;
>+}
>+bool all(uint3 x) {
>+    bool result = true;
>+    result = result && (x[0] != 0);
>+    result = result && (x[1] != 0);
>+    result = result && (x[2] != 0);
>+    return result;
>+}
>+bool all(uint4 x) {
>+    bool result = true;
>+    result = result && (x[0] != 0);
>+    result = result && (x[1] != 0);
>+    result = result && (x[2] != 0);
>+    result = result && (x[3] != 0);
>+    return result;
>+}
>+bool all(char x) {
>+    return x != 0;
>+}
>+bool all(char2 x) {
>+    bool result = true;
>+    result = result && (x[0] != 0);
>+    result = result && (x[1] != 0);
>+    return result;
>+}
>+bool all(char3 x) {
>+    bool result = true;
>+    result = result && (x[0] != 0);
>+    result = result && (x[1] != 0);
>+    result = result && (x[2] != 0);
>+    return result;
>+}
>+bool all(char4 x) {
>+    bool result = true;
>+    result = result && (x[0] != 0);
>+    result = result && (x[1] != 0);
>+    result = result && (x[2] != 0);
>+    result = result && (x[3] != 0);
>+    return result;
>+}
>+bool all(short x) {
>+    return x != 0;
>+}
>+bool all(short2 x) {
>+    bool result = true;
>+    result = result && (x[0] != 0);
>+    result = result && (x[1] != 0);
>+    return result;
>+}
>+bool all(short3 x) {
>+    bool result = true;
>+    result = result && (x[0] != 0);
>+    result = result && (x[1] != 0);
>+    result = result && (x[2] != 0);
>+    return result;
>+}
>+bool all(short4 x) {
>+    bool result = true;
>+    result = result && (x[0] != 0);
>+    result = result && (x[1] != 0);
>+    result = result && (x[2] != 0);
>+    result = result && (x[3] != 0);
>+    return result;
>+}
>+bool all(int x) {
>+    return x != 0;
>+}
>+bool all(int2 x) {
>+    bool result = true;
>+    result = result && (x[0] != 0);
>+    result = result && (x[1] != 0);
>+    return result;
>+}
>+bool all(int3 x) {
>+    bool result = true;
>+    result = result && (x[0] != 0);
>+    result = result && (x[1] != 0);
>+    result = result && (x[2] != 0);
>+    return result;
>+}
>+bool all(int4 x) {
>+    bool result = true;
>+    result = result && (x[0] != 0);
>+    result = result && (x[1] != 0);
>+    result = result && (x[2] != 0);
>+    result = result && (x[3] != 0);
>+    return result;
>+}
>+bool all(half x) {
>+    return x != 0;
>+}
>+bool all(half2 x) {
>+    bool result = true;
>+    result = result && (x[0] != 0);
>+    result = result && (x[1] != 0);
>+    return result;
>+}
>+bool all(half3 x) {
>+    bool result = true;
>+    result = result && (x[0] != 0);
>+    result = result && (x[1] != 0);
>+    result = result && (x[2] != 0);
>+    return result;
>+}
>+bool all(half4 x) {
>+    bool result = true;
>+    result = result && (x[0] != 0);
>+    result = result && (x[1] != 0);
>+    result = result && (x[2] != 0);
>+    result = result && (x[3] != 0);
>+    return result;
>+}
>+bool all(half2x2 x) {
>+    bool result = true;
>+    result = result && (x[0][0] != 0);
>+    result = result && (x[0][1] != 0);
>+    result = result && (x[1][0] != 0);
>+    result = result && (x[1][1] != 0);
>+    return result;
>+}
>+bool all(half2x3 x) {
>+    bool result = true;
>+    result = result && (x[0][0] != 0);
>+    result = result && (x[0][1] != 0);
>+    result = result && (x[0][2] != 0);
>+    result = result && (x[1][0] != 0);
>+    result = result && (x[1][1] != 0);
>+    result = result && (x[1][2] != 0);
>+    return result;
>+}
>+bool all(half2x4 x) {
>+    bool result = true;
>+    result = result && (x[0][0] != 0);
>+    result = result && (x[0][1] != 0);
>+    result = result && (x[0][2] != 0);
>+    result = result && (x[0][3] != 0);
>+    result = result && (x[1][0] != 0);
>+    result = result && (x[1][1] != 0);
>+    result = result && (x[1][2] != 0);
>+    result = result && (x[1][3] != 0);
>+    return result;
>+}
>+bool all(half3x2 x) {
>+    bool result = true;
>+    result = result && (x[0][0] != 0);
>+    result = result && (x[0][1] != 0);
>+    result = result && (x[1][0] != 0);
>+    result = result && (x[1][1] != 0);
>+    result = result && (x[2][0] != 0);
>+    result = result && (x[2][1] != 0);
>+    return result;
>+}
>+bool all(half3x3 x) {
>+    bool result = true;
>+    result = result && (x[0][0] != 0);
>+    result = result && (x[0][1] != 0);
>+    result = result && (x[0][2] != 0);
>+    result = result && (x[1][0] != 0);
>+    result = result && (x[1][1] != 0);
>+    result = result && (x[1][2] != 0);
>+    result = result && (x[2][0] != 0);
>+    result = result && (x[2][1] != 0);
>+    result = result && (x[2][2] != 0);
>+    return result;
>+}
>+bool all(half3x4 x) {
>+    bool result = true;
>+    result = result && (x[0][0] != 0);
>+    result = result && (x[0][1] != 0);
>+    result = result && (x[0][2] != 0);
>+    result = result && (x[0][3] != 0);
>+    result = result && (x[1][0] != 0);
>+    result = result && (x[1][1] != 0);
>+    result = result && (x[1][2] != 0);
>+    result = result && (x[1][3] != 0);
>+    result = result && (x[2][0] != 0);
>+    result = result && (x[2][1] != 0);
>+    result = result && (x[2][2] != 0);
>+    result = result && (x[2][3] != 0);
>+    return result;
>+}
>+bool all(half4x2 x) {
>+    bool result = true;
>+    result = result && (x[0][0] != 0);
>+    result = result && (x[0][1] != 0);
>+    result = result && (x[1][0] != 0);
>+    result = result && (x[1][1] != 0);
>+    result = result && (x[2][0] != 0);
>+    result = result && (x[2][1] != 0);
>+    result = result && (x[3][0] != 0);
>+    result = result && (x[3][1] != 0);
>+    return result;
>+}
>+bool all(half4x3 x) {
>+    bool result = true;
>+    result = result && (x[0][0] != 0);
>+    result = result && (x[0][1] != 0);
>+    result = result && (x[0][2] != 0);
>+    result = result && (x[1][0] != 0);
>+    result = result && (x[1][1] != 0);
>+    result = result && (x[1][2] != 0);
>+    result = result && (x[2][0] != 0);
>+    result = result && (x[2][1] != 0);
>+    result = result && (x[2][2] != 0);
>+    result = result && (x[3][0] != 0);
>+    result = result && (x[3][1] != 0);
>+    result = result && (x[3][2] != 0);
>+    return result;
>+}
>+bool all(half4x4 x) {
>+    bool result = true;
>+    result = result && (x[0][0] != 0);
>+    result = result && (x[0][1] != 0);
>+    result = result && (x[0][2] != 0);
>+    result = result && (x[0][3] != 0);
>+    result = result && (x[1][0] != 0);
>+    result = result && (x[1][1] != 0);
>+    result = result && (x[1][2] != 0);
>+    result = result && (x[1][3] != 0);
>+    result = result && (x[2][0] != 0);
>+    result = result && (x[2][1] != 0);
>+    result = result && (x[2][2] != 0);
>+    result = result && (x[2][3] != 0);
>+    result = result && (x[3][0] != 0);
>+    result = result && (x[3][1] != 0);
>+    result = result && (x[3][2] != 0);
>+    result = result && (x[3][3] != 0);
>+    return result;
>+}
>+bool all(float x) {
>+    return x != 0;
>+}
>+bool all(float2 x) {
>+    bool result = true;
>+    result = result && (x[0] != 0);
>+    result = result && (x[1] != 0);
>+    return result;
>+}
>+bool all(float3 x) {
>+    bool result = true;
>+    result = result && (x[0] != 0);
>+    result = result && (x[1] != 0);
>+    result = result && (x[2] != 0);
>+    return result;
>+}
>+bool all(float4 x) {
>+    bool result = true;
>+    result = result && (x[0] != 0);
>+    result = result && (x[1] != 0);
>+    result = result && (x[2] != 0);
>+    result = result && (x[3] != 0);
>+    return result;
>+}
>+bool all(float2x2 x) {
>+    bool result = true;
>+    result = result && (x[0][0] != 0);
>+    result = result && (x[0][1] != 0);
>+    result = result && (x[1][0] != 0);
>+    result = result && (x[1][1] != 0);
>+    return result;
>+}
>+bool all(float2x3 x) {
>+    bool result = true;
>+    result = result && (x[0][0] != 0);
>+    result = result && (x[0][1] != 0);
>+    result = result && (x[0][2] != 0);
>+    result = result && (x[1][0] != 0);
>+    result = result && (x[1][1] != 0);
>+    result = result && (x[1][2] != 0);
>+    return result;
>+}
>+bool all(float2x4 x) {
>+    bool result = true;
>+    result = result && (x[0][0] != 0);
>+    result = result && (x[0][1] != 0);
>+    result = result && (x[0][2] != 0);
>+    result = result && (x[0][3] != 0);
>+    result = result && (x[1][0] != 0);
>+    result = result && (x[1][1] != 0);
>+    result = result && (x[1][2] != 0);
>+    result = result && (x[1][3] != 0);
>+    return result;
>+}
>+bool all(float3x2 x) {
>+    bool result = true;
>+    result = result && (x[0][0] != 0);
>+    result = result && (x[0][1] != 0);
>+    result = result && (x[1][0] != 0);
>+    result = result && (x[1][1] != 0);
>+    result = result && (x[2][0] != 0);
>+    result = result && (x[2][1] != 0);
>+    return result;
>+}
>+bool all(float3x3 x) {
>+    bool result = true;
>+    result = result && (x[0][0] != 0);
>+    result = result && (x[0][1] != 0);
>+    result = result && (x[0][2] != 0);
>+    result = result && (x[1][0] != 0);
>+    result = result && (x[1][1] != 0);
>+    result = result && (x[1][2] != 0);
>+    result = result && (x[2][0] != 0);
>+    result = result && (x[2][1] != 0);
>+    result = result && (x[2][2] != 0);
>+    return result;
>+}
>+bool all(float3x4 x) {
>+    bool result = true;
>+    result = result && (x[0][0] != 0);
>+    result = result && (x[0][1] != 0);
>+    result = result && (x[0][2] != 0);
>+    result = result && (x[0][3] != 0);
>+    result = result && (x[1][0] != 0);
>+    result = result && (x[1][1] != 0);
>+    result = result && (x[1][2] != 0);
>+    result = result && (x[1][3] != 0);
>+    result = result && (x[2][0] != 0);
>+    result = result && (x[2][1] != 0);
>+    result = result && (x[2][2] != 0);
>+    result = result && (x[2][3] != 0);
>+    return result;
>+}
>+bool all(float4x2 x) {
>+    bool result = true;
>+    result = result && (x[0][0] != 0);
>+    result = result && (x[0][1] != 0);
>+    result = result && (x[1][0] != 0);
>+    result = result && (x[1][1] != 0);
>+    result = result && (x[2][0] != 0);
>+    result = result && (x[2][1] != 0);
>+    result = result && (x[3][0] != 0);
>+    result = result && (x[3][1] != 0);
>+    return result;
>+}
>+bool all(float4x3 x) {
>+    bool result = true;
>+    result = result && (x[0][0] != 0);
>+    result = result && (x[0][1] != 0);
>+    result = result && (x[0][2] != 0);
>+    result = result && (x[1][0] != 0);
>+    result = result && (x[1][1] != 0);
>+    result = result && (x[1][2] != 0);
>+    result = result && (x[2][0] != 0);
>+    result = result && (x[2][1] != 0);
>+    result = result && (x[2][2] != 0);
>+    result = result && (x[3][0] != 0);
>+    result = result && (x[3][1] != 0);
>+    result = result && (x[3][2] != 0);
>+    return result;
>+}
>+bool all(float4x4 x) {
>+    bool result = true;
>+    result = result && (x[0][0] != 0);
>+    result = result && (x[0][1] != 0);
>+    result = result && (x[0][2] != 0);
>+    result = result && (x[0][3] != 0);
>+    result = result && (x[1][0] != 0);
>+    result = result && (x[1][1] != 0);
>+    result = result && (x[1][2] != 0);
>+    result = result && (x[1][3] != 0);
>+    result = result && (x[2][0] != 0);
>+    result = result && (x[2][1] != 0);
>+    result = result && (x[2][2] != 0);
>+    result = result && (x[2][3] != 0);
>+    result = result && (x[3][0] != 0);
>+    result = result && (x[3][1] != 0);
>+    result = result && (x[3][2] != 0);
>+    result = result && (x[3][3] != 0);
>+    return result;
>+}
>+
>+
>+/* Functions named operator.w= */
>+native bool4 operator.w=(bool4, bool);
>+native uchar4 operator.w=(uchar4, uchar);
>+native ushort4 operator.w=(ushort4, ushort);
>+native uint4 operator.w=(uint4, uint);
>+native char4 operator.w=(char4, char);
>+native short4 operator.w=(short4, short);
>+native int4 operator.w=(int4, int);
>+native half4 operator.w=(half4, half);
>+native float4 operator.w=(float4, float);
>+
>+/* Functions named firstbitlow */
>+uint firstbitlow(uchar x) {
>+    if ((x & uchar(1 << 0)) != 0)
>+        return 7;
>+    if ((x & uchar(1 << 1)) != 0)
>+        return 6;
>+    if ((x & uchar(1 << 2)) != 0)
>+        return 5;
>+    if ((x & uchar(1 << 3)) != 0)
>+        return 4;
>+    if ((x & uchar(1 << 4)) != 0)
>+        return 3;
>+    if ((x & uchar(1 << 5)) != 0)
>+        return 2;
>+    if ((x & uchar(1 << 6)) != 0)
>+        return 1;
>+    if ((x & uchar(1 << 7)) != 0)
>+        return 0;
>+    return 8;
>+}
>+uint firstbitlow(ushort x) {
>+    if ((x & ushort(1 << 0)) != 0)
>+        return 15;
>+    if ((x & ushort(1 << 1)) != 0)
>+        return 14;
>+    if ((x & ushort(1 << 2)) != 0)
>+        return 13;
>+    if ((x & ushort(1 << 3)) != 0)
>+        return 12;
>+    if ((x & ushort(1 << 4)) != 0)
>+        return 11;
>+    if ((x & ushort(1 << 5)) != 0)
>+        return 10;
>+    if ((x & ushort(1 << 6)) != 0)
>+        return 9;
>+    if ((x & ushort(1 << 7)) != 0)
>+        return 8;
>+    if ((x & ushort(1 << 8)) != 0)
>+        return 7;
>+    if ((x & ushort(1 << 9)) != 0)
>+        return 6;
>+    if ((x & ushort(1 << 10)) != 0)
>+        return 5;
>+    if ((x & ushort(1 << 11)) != 0)
>+        return 4;
>+    if ((x & ushort(1 << 12)) != 0)
>+        return 3;
>+    if ((x & ushort(1 << 13)) != 0)
>+        return 2;
>+    if ((x & ushort(1 << 14)) != 0)
>+        return 1;
>+    if ((x & ushort(1 << 15)) != 0)
>+        return 0;
>+    return 16;
>+}
>+uint firstbitlow(uint x) {
>+    if ((x & uint(1 << 0)) != 0)
>+        return 31;
>+    if ((x & uint(1 << 1)) != 0)
>+        return 30;
>+    if ((x & uint(1 << 2)) != 0)
>+        return 29;
>+    if ((x & uint(1 << 3)) != 0)
>+        return 28;
>+    if ((x & uint(1 << 4)) != 0)
>+        return 27;
>+    if ((x & uint(1 << 5)) != 0)
>+        return 26;
>+    if ((x & uint(1 << 6)) != 0)
>+        return 25;
>+    if ((x & uint(1 << 7)) != 0)
>+        return 24;
>+    if ((x & uint(1 << 8)) != 0)
>+        return 23;
>+    if ((x & uint(1 << 9)) != 0)
>+        return 22;
>+    if ((x & uint(1 << 10)) != 0)
>+        return 21;
>+    if ((x & uint(1 << 11)) != 0)
>+        return 20;
>+    if ((x & uint(1 << 12)) != 0)
>+        return 19;
>+    if ((x & uint(1 << 13)) != 0)
>+        return 18;
>+    if ((x & uint(1 << 14)) != 0)
>+        return 17;
>+    if ((x & uint(1 << 15)) != 0)
>+        return 16;
>+    if ((x & uint(1 << 16)) != 0)
>+        return 15;
>+    if ((x & uint(1 << 17)) != 0)
>+        return 14;
>+    if ((x & uint(1 << 18)) != 0)
>+        return 13;
>+    if ((x & uint(1 << 19)) != 0)
>+        return 12;
>+    if ((x & uint(1 << 20)) != 0)
>+        return 11;
>+    if ((x & uint(1 << 21)) != 0)
>+        return 10;
>+    if ((x & uint(1 << 22)) != 0)
>+        return 9;
>+    if ((x & uint(1 << 23)) != 0)
>+        return 8;
>+    if ((x & uint(1 << 24)) != 0)
>+        return 7;
>+    if ((x & uint(1 << 25)) != 0)
>+        return 6;
>+    if ((x & uint(1 << 26)) != 0)
>+        return 5;
>+    if ((x & uint(1 << 27)) != 0)
>+        return 4;
>+    if ((x & uint(1 << 28)) != 0)
>+        return 3;
>+    if ((x & uint(1 << 29)) != 0)
>+        return 2;
>+    if ((x & uint(1 << 30)) != 0)
>+        return 1;
>+    if ((x & uint(1 << 31)) != 0)
>+        return 0;
>+    return 32;
>+}
>+uint firstbitlow(char x) {
>+    return firstbitlow(uchar(x));
>+}
>+uint firstbitlow(short x) {
>+    return firstbitlow(ushort(x));
>+}
>+uint firstbitlow(int x) {
>+    return firstbitlow(uint(x));
>+}
>+uint2 firstbitlow(uchar2 x) {
>+    uint2 result;
>+    result[0] = firstbitlow(x[0]);
>+    result[1] = firstbitlow(x[1]);
>+    return result;
>+}
>+uint3 firstbitlow(uchar3 x) {
>+    uint3 result;
>+    result[0] = firstbitlow(x[0]);
>+    result[1] = firstbitlow(x[1]);
>+    result[2] = firstbitlow(x[2]);
>+    return result;
>+}
>+uint4 firstbitlow(uchar4 x) {
>+    uint4 result;
>+    result[0] = firstbitlow(x[0]);
>+    result[1] = firstbitlow(x[1]);
>+    result[2] = firstbitlow(x[2]);
>+    result[3] = firstbitlow(x[3]);
>+    return result;
>+}
>+uint2 firstbitlow(ushort2 x) {
>+    uint2 result;
>+    result[0] = firstbitlow(x[0]);
>+    result[1] = firstbitlow(x[1]);
>+    return result;
>+}
>+uint3 firstbitlow(ushort3 x) {
>+    uint3 result;
>+    result[0] = firstbitlow(x[0]);
>+    result[1] = firstbitlow(x[1]);
>+    result[2] = firstbitlow(x[2]);
>+    return result;
>+}
>+uint4 firstbitlow(ushort4 x) {
>+    uint4 result;
>+    result[0] = firstbitlow(x[0]);
>+    result[1] = firstbitlow(x[1]);
>+    result[2] = firstbitlow(x[2]);
>+    result[3] = firstbitlow(x[3]);
>+    return result;
>+}
>+uint2 firstbitlow(uint2 x) {
>+    uint2 result;
>+    result[0] = firstbitlow(x[0]);
>+    result[1] = firstbitlow(x[1]);
>+    return result;
>+}
>+uint3 firstbitlow(uint3 x) {
>+    uint3 result;
>+    result[0] = firstbitlow(x[0]);
>+    result[1] = firstbitlow(x[1]);
>+    result[2] = firstbitlow(x[2]);
>+    return result;
>+}
>+uint4 firstbitlow(uint4 x) {
>+    uint4 result;
>+    result[0] = firstbitlow(x[0]);
>+    result[1] = firstbitlow(x[1]);
>+    result[2] = firstbitlow(x[2]);
>+    result[3] = firstbitlow(x[3]);
>+    return result;
>+}
>+uint2 firstbitlow(char2 x) {
>+    uint2 result;
>+    result[0] = firstbitlow(x[0]);
>+    result[1] = firstbitlow(x[1]);
>+    return result;
>+}
>+uint3 firstbitlow(char3 x) {
>+    uint3 result;
>+    result[0] = firstbitlow(x[0]);
>+    result[1] = firstbitlow(x[1]);
>+    result[2] = firstbitlow(x[2]);
>+    return result;
>+}
>+uint4 firstbitlow(char4 x) {
>+    uint4 result;
>+    result[0] = firstbitlow(x[0]);
>+    result[1] = firstbitlow(x[1]);
>+    result[2] = firstbitlow(x[2]);
>+    result[3] = firstbitlow(x[3]);
>+    return result;
>+}
>+uint2 firstbitlow(short2 x) {
>+    uint2 result;
>+    result[0] = firstbitlow(x[0]);
>+    result[1] = firstbitlow(x[1]);
>+    return result;
>+}
>+uint3 firstbitlow(short3 x) {
>+    uint3 result;
>+    result[0] = firstbitlow(x[0]);
>+    result[1] = firstbitlow(x[1]);
>+    result[2] = firstbitlow(x[2]);
>+    return result;
>+}
>+uint4 firstbitlow(short4 x) {
>+    uint4 result;
>+    result[0] = firstbitlow(x[0]);
>+    result[1] = firstbitlow(x[1]);
>+    result[2] = firstbitlow(x[2]);
>+    result[3] = firstbitlow(x[3]);
>+    return result;
>+}
>+uint2 firstbitlow(int2 x) {
>+    uint2 result;
>+    result[0] = firstbitlow(x[0]);
>+    result[1] = firstbitlow(x[1]);
>+    return result;
>+}
>+uint3 firstbitlow(int3 x) {
>+    uint3 result;
>+    result[0] = firstbitlow(x[0]);
>+    result[1] = firstbitlow(x[1]);
>+    result[2] = firstbitlow(x[2]);
>+    return result;
>+}
>+uint4 firstbitlow(int4 x) {
>+    uint4 result;
>+    result[0] = firstbitlow(x[0]);
>+    result[1] = firstbitlow(x[1]);
>+    result[2] = firstbitlow(x[2]);
>+    result[3] = firstbitlow(x[3]);
>+    return result;
>+}
>+
>+
>+/* Functions named operator.xwxy */
>+bool4 operator.xwxy(bool4 v) {
>+    bool4 result;
>+    result.x = v.x;
>+    result.y = v.w;
>+    result.z = v.x;
>+    result.w = v.y;
>+    return result;
>+}
>+uchar4 operator.xwxy(uchar4 v) {
>+    uchar4 result;
>+    result.x = v.x;
>+    result.y = v.w;
>+    result.z = v.x;
>+    result.w = v.y;
>+    return result;
>+}
>+ushort4 operator.xwxy(ushort4 v) {
>+    ushort4 result;
>+    result.x = v.x;
>+    result.y = v.w;
>+    result.z = v.x;
>+    result.w = v.y;
>+    return result;
>+}
>+uint4 operator.xwxy(uint4 v) {
>+    uint4 result;
>+    result.x = v.x;
>+    result.y = v.w;
>+    result.z = v.x;
>+    result.w = v.y;
>+    return result;
>+}
>+char4 operator.xwxy(char4 v) {
>+    char4 result;
>+    result.x = v.x;
>+    result.y = v.w;
>+    result.z = v.x;
>+    result.w = v.y;
>+    return result;
>+}
>+short4 operator.xwxy(short4 v) {
>+    short4 result;
>+    result.x = v.x;
>+    result.y = v.w;
>+    result.z = v.x;
>+    result.w = v.y;
>+    return result;
>+}
>+int4 operator.xwxy(int4 v) {
>+    int4 result;
>+    result.x = v.x;
>+    result.y = v.w;
>+    result.z = v.x;
>+    result.w = v.y;
>+    return result;
>+}
>+half4 operator.xwxy(half4 v) {
>+    half4 result;
>+    result.x = v.x;
>+    result.y = v.w;
>+    result.z = v.x;
>+    result.w = v.y;
>+    return result;
>+}
>+float4 operator.xwxy(float4 v) {
>+    float4 result;
>+    result.x = v.x;
>+    result.y = v.w;
>+    result.z = v.x;
>+    result.w = v.y;
>+    return result;
>+}
>+
>+/* Functions named operator.yzz */
>+bool3 operator.yzz(bool3 v) {
>+    bool3 result;
>+    result.x = v.y;
>+    result.y = v.z;
>+    result.z = v.z;
>+    return result;
>+}
>+bool3 operator.yzz(bool4 v) {
>+    bool3 result;
>+    result.x = v.y;
>+    result.y = v.z;
>+    result.z = v.z;
>+    return result;
>+}
>+uchar3 operator.yzz(uchar3 v) {
>+    uchar3 result;
>+    result.x = v.y;
>+    result.y = v.z;
>+    result.z = v.z;
>+    return result;
>+}
>+uchar3 operator.yzz(uchar4 v) {
>+    uchar3 result;
>+    result.x = v.y;
>+    result.y = v.z;
>+    result.z = v.z;
>+    return result;
>+}
>+ushort3 operator.yzz(ushort3 v) {
>+    ushort3 result;
>+    result.x = v.y;
>+    result.y = v.z;
>+    result.z = v.z;
>+    return result;
>+}
>+ushort3 operator.yzz(ushort4 v) {
>+    ushort3 result;
>+    result.x = v.y;
>+    result.y = v.z;
>+    result.z = v.z;
>+    return result;
>+}
>+uint3 operator.yzz(uint3 v) {
>+    uint3 result;
>+    result.x = v.y;
>+    result.y = v.z;
>+    result.z = v.z;
>+    return result;
>+}
>+uint3 operator.yzz(uint4 v) {
>+    uint3 result;
>+    result.x = v.y;
>+    result.y = v.z;
>+    result.z = v.z;
>+    return result;
>+}
>+char3 operator.yzz(char3 v) {
>+    char3 result;
>+    result.x = v.y;
>+    result.y = v.z;
>+    result.z = v.z;
>+    return result;
>+}
>+char3 operator.yzz(char4 v) {
>+    char3 result;
>+    result.x = v.y;
>+    result.y = v.z;
>+    result.z = v.z;
>+    return result;
>+}
>+short3 operator.yzz(short3 v) {
>+    short3 result;
>+    result.x = v.y;
>+    result.y = v.z;
>+    result.z = v.z;
>+    return result;
>+}
>+short3 operator.yzz(short4 v) {
>+    short3 result;
>+    result.x = v.y;
>+    result.y = v.z;
>+    result.z = v.z;
>+    return result;
>+}
>+int3 operator.yzz(int3 v) {
>+    int3 result;
>+    result.x = v.y;
>+    result.y = v.z;
>+    result.z = v.z;
>+    return result;
>+}
>+int3 operator.yzz(int4 v) {
>+    int3 result;
>+    result.x = v.y;
>+    result.y = v.z;
>+    result.z = v.z;
>+    return result;
>+}
>+half3 operator.yzz(half3 v) {
>+    half3 result;
>+    result.x = v.y;
>+    result.y = v.z;
>+    result.z = v.z;
>+    return result;
>+}
>+half3 operator.yzz(half4 v) {
>+    half3 result;
>+    result.x = v.y;
>+    result.y = v.z;
>+    result.z = v.z;
>+    return result;
>+}
>+float3 operator.yzz(float3 v) {
>+    float3 result;
>+    result.x = v.y;
>+    result.y = v.z;
>+    result.z = v.z;
>+    return result;
>+}
>+float3 operator.yzz(float4 v) {
>+    float3 result;
>+    result.x = v.y;
>+    result.y = v.z;
>+    result.z = v.z;
>+    return result;
>+}
>+
>+/* Functions named operator.yzwx */
>+bool4 operator.yzwx(bool4 v) {
>+    bool4 result;
>+    result.x = v.y;
>+    result.y = v.z;
>+    result.z = v.w;
>+    result.w = v.x;
>+    return result;
>+}
>+uchar4 operator.yzwx(uchar4 v) {
>+    uchar4 result;
>+    result.x = v.y;
>+    result.y = v.z;
>+    result.z = v.w;
>+    result.w = v.x;
>+    return result;
>+}
>+ushort4 operator.yzwx(ushort4 v) {
>+    ushort4 result;
>+    result.x = v.y;
>+    result.y = v.z;
>+    result.z = v.w;
>+    result.w = v.x;
>+    return result;
>+}
>+uint4 operator.yzwx(uint4 v) {
>+    uint4 result;
>+    result.x = v.y;
>+    result.y = v.z;
>+    result.z = v.w;
>+    result.w = v.x;
>+    return result;
>+}
>+char4 operator.yzwx(char4 v) {
>+    char4 result;
>+    result.x = v.y;
>+    result.y = v.z;
>+    result.z = v.w;
>+    result.w = v.x;
>+    return result;
>+}
>+short4 operator.yzwx(short4 v) {
>+    short4 result;
>+    result.x = v.y;
>+    result.y = v.z;
>+    result.z = v.w;
>+    result.w = v.x;
>+    return result;
>+}
>+int4 operator.yzwx(int4 v) {
>+    int4 result;
>+    result.x = v.y;
>+    result.y = v.z;
>+    result.z = v.w;
>+    result.w = v.x;
>+    return result;
>+}
>+half4 operator.yzwx(half4 v) {
>+    half4 result;
>+    result.x = v.y;
>+    result.y = v.z;
>+    result.z = v.w;
>+    result.w = v.x;
>+    return result;
>+}
>+float4 operator.yzwx(float4 v) {
>+    float4 result;
>+    result.x = v.y;
>+    result.y = v.z;
>+    result.z = v.w;
>+    result.w = v.x;
>+    return result;
>+}
>+
>+/* Functions named operator.ywxz= */
>+bool4 operator.ywxz=(bool4 v, bool4 c) {
>+    bool4 result = v;
>+    result.y = c.x;
>+    result.w = c.y;
>+    result.x = c.z;
>+    result.z = c.w;
>+    return result;
>+}
>+uchar4 operator.ywxz=(uchar4 v, uchar4 c) {
>+    uchar4 result = v;
>+    result.y = c.x;
>+    result.w = c.y;
>+    result.x = c.z;
>+    result.z = c.w;
>+    return result;
>+}
>+ushort4 operator.ywxz=(ushort4 v, ushort4 c) {
>+    ushort4 result = v;
>+    result.y = c.x;
>+    result.w = c.y;
>+    result.x = c.z;
>+    result.z = c.w;
>+    return result;
>+}
>+uint4 operator.ywxz=(uint4 v, uint4 c) {
>+    uint4 result = v;
>+    result.y = c.x;
>+    result.w = c.y;
>+    result.x = c.z;
>+    result.z = c.w;
>+    return result;
>+}
>+char4 operator.ywxz=(char4 v, char4 c) {
>+    char4 result = v;
>+    result.y = c.x;
>+    result.w = c.y;
>+    result.x = c.z;
>+    result.z = c.w;
>+    return result;
>+}
>+short4 operator.ywxz=(short4 v, short4 c) {
>+    short4 result = v;
>+    result.y = c.x;
>+    result.w = c.y;
>+    result.x = c.z;
>+    result.z = c.w;
>+    return result;
>+}
>+int4 operator.ywxz=(int4 v, int4 c) {
>+    int4 result = v;
>+    result.y = c.x;
>+    result.w = c.y;
>+    result.x = c.z;
>+    result.z = c.w;
>+    return result;
>+}
>+half4 operator.ywxz=(half4 v, half4 c) {
>+    half4 result = v;
>+    result.y = c.x;
>+    result.w = c.y;
>+    result.x = c.z;
>+    result.z = c.w;
>+    return result;
>+}
>+float4 operator.ywxz=(float4 v, float4 c) {
>+    float4 result = v;
>+    result.y = c.x;
>+    result.w = c.y;
>+    result.x = c.z;
>+    result.z = c.w;
>+    return result;
>+}
>+
>+/* Functions named operator.ywwx */
>+bool4 operator.ywwx(bool4 v) {
>+    bool4 result;
>+    result.x = v.y;
>+    result.y = v.w;
>+    result.z = v.w;
>+    result.w = v.x;
>+    return result;
>+}
>+uchar4 operator.ywwx(uchar4 v) {
>+    uchar4 result;
>+    result.x = v.y;
>+    result.y = v.w;
>+    result.z = v.w;
>+    result.w = v.x;
>+    return result;
>+}
>+ushort4 operator.ywwx(ushort4 v) {
>+    ushort4 result;
>+    result.x = v.y;
>+    result.y = v.w;
>+    result.z = v.w;
>+    result.w = v.x;
>+    return result;
>+}
>+uint4 operator.ywwx(uint4 v) {
>+    uint4 result;
>+    result.x = v.y;
>+    result.y = v.w;
>+    result.z = v.w;
>+    result.w = v.x;
>+    return result;
>+}
>+char4 operator.ywwx(char4 v) {
>+    char4 result;
>+    result.x = v.y;
>+    result.y = v.w;
>+    result.z = v.w;
>+    result.w = v.x;
>+    return result;
>+}
>+short4 operator.ywwx(short4 v) {
>+    short4 result;
>+    result.x = v.y;
>+    result.y = v.w;
>+    result.z = v.w;
>+    result.w = v.x;
>+    return result;
>+}
>+int4 operator.ywwx(int4 v) {
>+    int4 result;
>+    result.x = v.y;
>+    result.y = v.w;
>+    result.z = v.w;
>+    result.w = v.x;
>+    return result;
>+}
>+half4 operator.ywwx(half4 v) {
>+    half4 result;
>+    result.x = v.y;
>+    result.y = v.w;
>+    result.z = v.w;
>+    result.w = v.x;
>+    return result;
>+}
>+float4 operator.ywwx(float4 v) {
>+    float4 result;
>+    result.x = v.y;
>+    result.y = v.w;
>+    result.z = v.w;
>+    result.w = v.x;
>+    return result;
>+}
>+
>+/* Functions named operator.zyzw */
>+bool4 operator.zyzw(bool4 v) {
>+    bool4 result;
>+    result.x = v.z;
>+    result.y = v.y;
>+    result.z = v.z;
>+    result.w = v.w;
>+    return result;
>+}
>+uchar4 operator.zyzw(uchar4 v) {
>+    uchar4 result;
>+    result.x = v.z;
>+    result.y = v.y;
>+    result.z = v.z;
>+    result.w = v.w;
>+    return result;
>+}
>+ushort4 operator.zyzw(ushort4 v) {
>+    ushort4 result;
>+    result.x = v.z;
>+    result.y = v.y;
>+    result.z = v.z;
>+    result.w = v.w;
>+    return result;
>+}
>+uint4 operator.zyzw(uint4 v) {
>+    uint4 result;
>+    result.x = v.z;
>+    result.y = v.y;
>+    result.z = v.z;
>+    result.w = v.w;
>+    return result;
>+}
>+char4 operator.zyzw(char4 v) {
>+    char4 result;
>+    result.x = v.z;
>+    result.y = v.y;
>+    result.z = v.z;
>+    result.w = v.w;
>+    return result;
>+}
>+short4 operator.zyzw(short4 v) {
>+    short4 result;
>+    result.x = v.z;
>+    result.y = v.y;
>+    result.z = v.z;
>+    result.w = v.w;
>+    return result;
>+}
>+int4 operator.zyzw(int4 v) {
>+    int4 result;
>+    result.x = v.z;
>+    result.y = v.y;
>+    result.z = v.z;
>+    result.w = v.w;
>+    return result;
>+}
>+half4 operator.zyzw(half4 v) {
>+    half4 result;
>+    result.x = v.z;
>+    result.y = v.y;
>+    result.z = v.z;
>+    result.w = v.w;
>+    return result;
>+}
>+float4 operator.zyzw(float4 v) {
>+    float4 result;
>+    result.x = v.z;
>+    result.y = v.y;
>+    result.z = v.z;
>+    result.w = v.w;
>+    return result;
>+}
>+
>+/* Functions named operator.zwwz */
>+bool4 operator.zwwz(bool4 v) {
>+    bool4 result;
>+    result.x = v.z;
>+    result.y = v.w;
>+    result.z = v.w;
>+    result.w = v.z;
>+    return result;
>+}
>+uchar4 operator.zwwz(uchar4 v) {
>+    uchar4 result;
>+    result.x = v.z;
>+    result.y = v.w;
>+    result.z = v.w;
>+    result.w = v.z;
>+    return result;
>+}
>+ushort4 operator.zwwz(ushort4 v) {
>+    ushort4 result;
>+    result.x = v.z;
>+    result.y = v.w;
>+    result.z = v.w;
>+    result.w = v.z;
>+    return result;
>+}
>+uint4 operator.zwwz(uint4 v) {
>+    uint4 result;
>+    result.x = v.z;
>+    result.y = v.w;
>+    result.z = v.w;
>+    result.w = v.z;
>+    return result;
>+}
>+char4 operator.zwwz(char4 v) {
>+    char4 result;
>+    result.x = v.z;
>+    result.y = v.w;
>+    result.z = v.w;
>+    result.w = v.z;
>+    return result;
>+}
>+short4 operator.zwwz(short4 v) {
>+    short4 result;
>+    result.x = v.z;
>+    result.y = v.w;
>+    result.z = v.w;
>+    result.w = v.z;
>+    return result;
>+}
>+int4 operator.zwwz(int4 v) {
>+    int4 result;
>+    result.x = v.z;
>+    result.y = v.w;
>+    result.z = v.w;
>+    result.w = v.z;
>+    return result;
>+}
>+half4 operator.zwwz(half4 v) {
>+    half4 result;
>+    result.x = v.z;
>+    result.y = v.w;
>+    result.z = v.w;
>+    result.w = v.z;
>+    return result;
>+}
>+float4 operator.zwwz(float4 v) {
>+    float4 result;
>+    result.x = v.z;
>+    result.y = v.w;
>+    result.z = v.w;
>+    result.w = v.z;
>+    return result;
>+}
>+
>+/* Functions named operator.yyww */
>+bool4 operator.yyww(bool4 v) {
>+    bool4 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.w;
>+    result.w = v.w;
>+    return result;
>+}
>+uchar4 operator.yyww(uchar4 v) {
>+    uchar4 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.w;
>+    result.w = v.w;
>+    return result;
>+}
>+ushort4 operator.yyww(ushort4 v) {
>+    ushort4 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.w;
>+    result.w = v.w;
>+    return result;
>+}
>+uint4 operator.yyww(uint4 v) {
>+    uint4 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.w;
>+    result.w = v.w;
>+    return result;
>+}
>+char4 operator.yyww(char4 v) {
>+    char4 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.w;
>+    result.w = v.w;
>+    return result;
>+}
>+short4 operator.yyww(short4 v) {
>+    short4 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.w;
>+    result.w = v.w;
>+    return result;
>+}
>+int4 operator.yyww(int4 v) {
>+    int4 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.w;
>+    result.w = v.w;
>+    return result;
>+}
>+half4 operator.yyww(half4 v) {
>+    half4 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.w;
>+    result.w = v.w;
>+    return result;
>+}
>+float4 operator.yyww(float4 v) {
>+    float4 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.w;
>+    result.w = v.w;
>+    return result;
>+}
>+
>+/* Functions named operator<= */
>+native bool operator<=(int, int);
>+native bool operator<=(uint, uint);
>+native bool operator<=(float, float);
>+bool operator<=(uchar a, uchar b) {
>+    return uint(a) <= uint(b);
>+}
>+bool operator<=(ushort a, ushort b) {
>+    return uint(a) <= uint(b);
>+}
>+bool operator<=(char a, char b) {
>+    return int(a) <= int(b);
>+}
>+bool operator<=(short a, short b) {
>+    return int(a) <= int(b);
>+}
>+bool operator<=(half a, half b) {
>+    return float(a) <= float(b);
>+}
>+
>+/* Functions named ddx_fine */
>+half ddx_fine(half x) {
>+    return ddx(x);
>+}
>+half2 ddx_fine(half2 x) {
>+    half2 result;
>+    result[0] = ddx_fine(x[0]);
>+    result[1] = ddx_fine(x[1]);
>+    return result;
>+}
>+half3 ddx_fine(half3 x) {
>+    half3 result;
>+    result[0] = ddx_fine(x[0]);
>+    result[1] = ddx_fine(x[1]);
>+    result[2] = ddx_fine(x[2]);
>+    return result;
>+}
>+half4 ddx_fine(half4 x) {
>+    half4 result;
>+    result[0] = ddx_fine(x[0]);
>+    result[1] = ddx_fine(x[1]);
>+    result[2] = ddx_fine(x[2]);
>+    result[3] = ddx_fine(x[3]);
>+    return result;
>+}
>+half2x2 ddx_fine(half2x2 x) {
>+    half2x2 result;
>+    result[0][0] = ddx_fine(x[0][0]);
>+    result[0][1] = ddx_fine(x[0][1]);
>+    result[1][0] = ddx_fine(x[1][0]);
>+    result[1][1] = ddx_fine(x[1][1]);
>+    return result;
>+}
>+half2x3 ddx_fine(half2x3 x) {
>+    half2x3 result;
>+    result[0][0] = ddx_fine(x[0][0]);
>+    result[0][1] = ddx_fine(x[0][1]);
>+    result[0][2] = ddx_fine(x[0][2]);
>+    result[1][0] = ddx_fine(x[1][0]);
>+    result[1][1] = ddx_fine(x[1][1]);
>+    result[1][2] = ddx_fine(x[1][2]);
>+    return result;
>+}
>+half2x4 ddx_fine(half2x4 x) {
>+    half2x4 result;
>+    result[0][0] = ddx_fine(x[0][0]);
>+    result[0][1] = ddx_fine(x[0][1]);
>+    result[0][2] = ddx_fine(x[0][2]);
>+    result[0][3] = ddx_fine(x[0][3]);
>+    result[1][0] = ddx_fine(x[1][0]);
>+    result[1][1] = ddx_fine(x[1][1]);
>+    result[1][2] = ddx_fine(x[1][2]);
>+    result[1][3] = ddx_fine(x[1][3]);
>+    return result;
>+}
>+half3x2 ddx_fine(half3x2 x) {
>+    half3x2 result;
>+    result[0][0] = ddx_fine(x[0][0]);
>+    result[0][1] = ddx_fine(x[0][1]);
>+    result[1][0] = ddx_fine(x[1][0]);
>+    result[1][1] = ddx_fine(x[1][1]);
>+    result[2][0] = ddx_fine(x[2][0]);
>+    result[2][1] = ddx_fine(x[2][1]);
>+    return result;
>+}
>+half3x3 ddx_fine(half3x3 x) {
>+    half3x3 result;
>+    result[0][0] = ddx_fine(x[0][0]);
>+    result[0][1] = ddx_fine(x[0][1]);
>+    result[0][2] = ddx_fine(x[0][2]);
>+    result[1][0] = ddx_fine(x[1][0]);
>+    result[1][1] = ddx_fine(x[1][1]);
>+    result[1][2] = ddx_fine(x[1][2]);
>+    result[2][0] = ddx_fine(x[2][0]);
>+    result[2][1] = ddx_fine(x[2][1]);
>+    result[2][2] = ddx_fine(x[2][2]);
>+    return result;
>+}
>+half3x4 ddx_fine(half3x4 x) {
>+    half3x4 result;
>+    result[0][0] = ddx_fine(x[0][0]);
>+    result[0][1] = ddx_fine(x[0][1]);
>+    result[0][2] = ddx_fine(x[0][2]);
>+    result[0][3] = ddx_fine(x[0][3]);
>+    result[1][0] = ddx_fine(x[1][0]);
>+    result[1][1] = ddx_fine(x[1][1]);
>+    result[1][2] = ddx_fine(x[1][2]);
>+    result[1][3] = ddx_fine(x[1][3]);
>+    result[2][0] = ddx_fine(x[2][0]);
>+    result[2][1] = ddx_fine(x[2][1]);
>+    result[2][2] = ddx_fine(x[2][2]);
>+    result[2][3] = ddx_fine(x[2][3]);
>+    return result;
>+}
>+half4x2 ddx_fine(half4x2 x) {
>+    half4x2 result;
>+    result[0][0] = ddx_fine(x[0][0]);
>+    result[0][1] = ddx_fine(x[0][1]);
>+    result[1][0] = ddx_fine(x[1][0]);
>+    result[1][1] = ddx_fine(x[1][1]);
>+    result[2][0] = ddx_fine(x[2][0]);
>+    result[2][1] = ddx_fine(x[2][1]);
>+    result[3][0] = ddx_fine(x[3][0]);
>+    result[3][1] = ddx_fine(x[3][1]);
>+    return result;
>+}
>+half4x3 ddx_fine(half4x3 x) {
>+    half4x3 result;
>+    result[0][0] = ddx_fine(x[0][0]);
>+    result[0][1] = ddx_fine(x[0][1]);
>+    result[0][2] = ddx_fine(x[0][2]);
>+    result[1][0] = ddx_fine(x[1][0]);
>+    result[1][1] = ddx_fine(x[1][1]);
>+    result[1][2] = ddx_fine(x[1][2]);
>+    result[2][0] = ddx_fine(x[2][0]);
>+    result[2][1] = ddx_fine(x[2][1]);
>+    result[2][2] = ddx_fine(x[2][2]);
>+    result[3][0] = ddx_fine(x[3][0]);
>+    result[3][1] = ddx_fine(x[3][1]);
>+    result[3][2] = ddx_fine(x[3][2]);
>+    return result;
>+}
>+half4x4 ddx_fine(half4x4 x) {
>+    half4x4 result;
>+    result[0][0] = ddx_fine(x[0][0]);
>+    result[0][1] = ddx_fine(x[0][1]);
>+    result[0][2] = ddx_fine(x[0][2]);
>+    result[0][3] = ddx_fine(x[0][3]);
>+    result[1][0] = ddx_fine(x[1][0]);
>+    result[1][1] = ddx_fine(x[1][1]);
>+    result[1][2] = ddx_fine(x[1][2]);
>+    result[1][3] = ddx_fine(x[1][3]);
>+    result[2][0] = ddx_fine(x[2][0]);
>+    result[2][1] = ddx_fine(x[2][1]);
>+    result[2][2] = ddx_fine(x[2][2]);
>+    result[2][3] = ddx_fine(x[2][3]);
>+    result[3][0] = ddx_fine(x[3][0]);
>+    result[3][1] = ddx_fine(x[3][1]);
>+    result[3][2] = ddx_fine(x[3][2]);
>+    result[3][3] = ddx_fine(x[3][3]);
>+    return result;
>+}
>+float ddx_fine(float x) {
>+    return ddx(x);
>+}
>+float2 ddx_fine(float2 x) {
>+    float2 result;
>+    result[0] = ddx_fine(x[0]);
>+    result[1] = ddx_fine(x[1]);
>+    return result;
>+}
>+float3 ddx_fine(float3 x) {
>+    float3 result;
>+    result[0] = ddx_fine(x[0]);
>+    result[1] = ddx_fine(x[1]);
>+    result[2] = ddx_fine(x[2]);
>+    return result;
>+}
>+float4 ddx_fine(float4 x) {
>+    float4 result;
>+    result[0] = ddx_fine(x[0]);
>+    result[1] = ddx_fine(x[1]);
>+    result[2] = ddx_fine(x[2]);
>+    result[3] = ddx_fine(x[3]);
>+    return result;
>+}
>+float2x2 ddx_fine(float2x2 x) {
>+    float2x2 result;
>+    result[0][0] = ddx_fine(x[0][0]);
>+    result[0][1] = ddx_fine(x[0][1]);
>+    result[1][0] = ddx_fine(x[1][0]);
>+    result[1][1] = ddx_fine(x[1][1]);
>+    return result;
>+}
>+float2x3 ddx_fine(float2x3 x) {
>+    float2x3 result;
>+    result[0][0] = ddx_fine(x[0][0]);
>+    result[0][1] = ddx_fine(x[0][1]);
>+    result[0][2] = ddx_fine(x[0][2]);
>+    result[1][0] = ddx_fine(x[1][0]);
>+    result[1][1] = ddx_fine(x[1][1]);
>+    result[1][2] = ddx_fine(x[1][2]);
>+    return result;
>+}
>+float2x4 ddx_fine(float2x4 x) {
>+    float2x4 result;
>+    result[0][0] = ddx_fine(x[0][0]);
>+    result[0][1] = ddx_fine(x[0][1]);
>+    result[0][2] = ddx_fine(x[0][2]);
>+    result[0][3] = ddx_fine(x[0][3]);
>+    result[1][0] = ddx_fine(x[1][0]);
>+    result[1][1] = ddx_fine(x[1][1]);
>+    result[1][2] = ddx_fine(x[1][2]);
>+    result[1][3] = ddx_fine(x[1][3]);
>+    return result;
>+}
>+float3x2 ddx_fine(float3x2 x) {
>+    float3x2 result;
>+    result[0][0] = ddx_fine(x[0][0]);
>+    result[0][1] = ddx_fine(x[0][1]);
>+    result[1][0] = ddx_fine(x[1][0]);
>+    result[1][1] = ddx_fine(x[1][1]);
>+    result[2][0] = ddx_fine(x[2][0]);
>+    result[2][1] = ddx_fine(x[2][1]);
>+    return result;
>+}
>+float3x3 ddx_fine(float3x3 x) {
>+    float3x3 result;
>+    result[0][0] = ddx_fine(x[0][0]);
>+    result[0][1] = ddx_fine(x[0][1]);
>+    result[0][2] = ddx_fine(x[0][2]);
>+    result[1][0] = ddx_fine(x[1][0]);
>+    result[1][1] = ddx_fine(x[1][1]);
>+    result[1][2] = ddx_fine(x[1][2]);
>+    result[2][0] = ddx_fine(x[2][0]);
>+    result[2][1] = ddx_fine(x[2][1]);
>+    result[2][2] = ddx_fine(x[2][2]);
>+    return result;
>+}
>+float3x4 ddx_fine(float3x4 x) {
>+    float3x4 result;
>+    result[0][0] = ddx_fine(x[0][0]);
>+    result[0][1] = ddx_fine(x[0][1]);
>+    result[0][2] = ddx_fine(x[0][2]);
>+    result[0][3] = ddx_fine(x[0][3]);
>+    result[1][0] = ddx_fine(x[1][0]);
>+    result[1][1] = ddx_fine(x[1][1]);
>+    result[1][2] = ddx_fine(x[1][2]);
>+    result[1][3] = ddx_fine(x[1][3]);
>+    result[2][0] = ddx_fine(x[2][0]);
>+    result[2][1] = ddx_fine(x[2][1]);
>+    result[2][2] = ddx_fine(x[2][2]);
>+    result[2][3] = ddx_fine(x[2][3]);
>+    return result;
>+}
>+float4x2 ddx_fine(float4x2 x) {
>+    float4x2 result;
>+    result[0][0] = ddx_fine(x[0][0]);
>+    result[0][1] = ddx_fine(x[0][1]);
>+    result[1][0] = ddx_fine(x[1][0]);
>+    result[1][1] = ddx_fine(x[1][1]);
>+    result[2][0] = ddx_fine(x[2][0]);
>+    result[2][1] = ddx_fine(x[2][1]);
>+    result[3][0] = ddx_fine(x[3][0]);
>+    result[3][1] = ddx_fine(x[3][1]);
>+    return result;
>+}
>+float4x3 ddx_fine(float4x3 x) {
>+    float4x3 result;
>+    result[0][0] = ddx_fine(x[0][0]);
>+    result[0][1] = ddx_fine(x[0][1]);
>+    result[0][2] = ddx_fine(x[0][2]);
>+    result[1][0] = ddx_fine(x[1][0]);
>+    result[1][1] = ddx_fine(x[1][1]);
>+    result[1][2] = ddx_fine(x[1][2]);
>+    result[2][0] = ddx_fine(x[2][0]);
>+    result[2][1] = ddx_fine(x[2][1]);
>+    result[2][2] = ddx_fine(x[2][2]);
>+    result[3][0] = ddx_fine(x[3][0]);
>+    result[3][1] = ddx_fine(x[3][1]);
>+    result[3][2] = ddx_fine(x[3][2]);
>+    return result;
>+}
>+float4x4 ddx_fine(float4x4 x) {
>+    float4x4 result;
>+    result[0][0] = ddx_fine(x[0][0]);
>+    result[0][1] = ddx_fine(x[0][1]);
>+    result[0][2] = ddx_fine(x[0][2]);
>+    result[0][3] = ddx_fine(x[0][3]);
>+    result[1][0] = ddx_fine(x[1][0]);
>+    result[1][1] = ddx_fine(x[1][1]);
>+    result[1][2] = ddx_fine(x[1][2]);
>+    result[1][3] = ddx_fine(x[1][3]);
>+    result[2][0] = ddx_fine(x[2][0]);
>+    result[2][1] = ddx_fine(x[2][1]);
>+    result[2][2] = ddx_fine(x[2][2]);
>+    result[2][3] = ddx_fine(x[2][3]);
>+    result[3][0] = ddx_fine(x[3][0]);
>+    result[3][1] = ddx_fine(x[3][1]);
>+    result[3][2] = ddx_fine(x[3][2]);
>+    result[3][3] = ddx_fine(x[3][3]);
>+    return result;
>+}
>+
>+/* Functions named operator.xwx */
>+bool3 operator.xwx(bool4 v) {
>+    bool3 result;
>+    result.x = v.x;
>+    result.y = v.w;
>+    result.z = v.x;
>+    return result;
>+}
>+uchar3 operator.xwx(uchar4 v) {
>+    uchar3 result;
>+    result.x = v.x;
>+    result.y = v.w;
>+    result.z = v.x;
>+    return result;
>+}
>+ushort3 operator.xwx(ushort4 v) {
>+    ushort3 result;
>+    result.x = v.x;
>+    result.y = v.w;
>+    result.z = v.x;
>+    return result;
>+}
>+uint3 operator.xwx(uint4 v) {
>+    uint3 result;
>+    result.x = v.x;
>+    result.y = v.w;
>+    result.z = v.x;
>+    return result;
>+}
>+char3 operator.xwx(char4 v) {
>+    char3 result;
>+    result.x = v.x;
>+    result.y = v.w;
>+    result.z = v.x;
>+    return result;
>+}
>+short3 operator.xwx(short4 v) {
>+    short3 result;
>+    result.x = v.x;
>+    result.y = v.w;
>+    result.z = v.x;
>+    return result;
>+}
>+int3 operator.xwx(int4 v) {
>+    int3 result;
>+    result.x = v.x;
>+    result.y = v.w;
>+    result.z = v.x;
>+    return result;
>+}
>+half3 operator.xwx(half4 v) {
>+    half3 result;
>+    result.x = v.x;
>+    result.y = v.w;
>+    result.z = v.x;
>+    return result;
>+}
>+float3 operator.xwx(float4 v) {
>+    float3 result;
>+    result.x = v.x;
>+    result.y = v.w;
>+    result.z = v.x;
>+    return result;
>+}
>+
>+/* Functions named operator cast */
>+native operator uchar(ushort);
>+native operator uchar(uint);
>+native operator uchar(char);
>+native operator uchar(short);
>+native operator uchar(int);
>+native operator uchar(half);
>+native operator uchar(float);
>+native operator ushort(uchar);
>+native operator ushort(uint);
>+native operator ushort(char);
>+native operator ushort(short);
>+native operator ushort(int);
>+native operator ushort(half);
>+native operator ushort(float);
>+native operator uint(uchar);
>+native operator uint(ushort);
>+native operator uint(char);
>+native operator uint(short);
>+native operator uint(int);
>+native operator uint(half);
>+native operator uint(float);
>+native operator char(uchar);
>+native operator char(ushort);
>+native operator char(uint);
>+native operator char(short);
>+native operator char(int);
>+native operator char(half);
>+native operator char(float);
>+native operator short(uchar);
>+native operator short(ushort);
>+native operator short(uint);
>+native operator short(char);
>+native operator short(int);
>+native operator short(half);
>+native operator short(float);
>+native operator int(uchar);
>+native operator int(ushort);
>+native operator int(uint);
>+native operator int(char);
>+native operator int(short);
>+native operator int(half);
>+native operator int(float);
>+native operator half(uchar);
>+native operator half(ushort);
>+native operator half(uint);
>+native operator half(char);
>+native operator half(short);
>+native operator half(int);
>+native operator half(float);
>+native operator float(uchar);
>+native operator float(ushort);
>+native operator float(uint);
>+native operator float(char);
>+native operator float(short);
>+native operator float(int);
>+native operator float(half);
>+
>+operator bool(uchar x) {
>+    return x != 0;
>+}
>+operator bool(ushort x) {
>+    return x != 0;
>+}
>+operator bool(uint x) {
>+    return x != 0;
>+}
>+operator bool(char x) {
>+    return x != 0;
>+}
>+operator bool(short x) {
>+    return x != 0;
>+}
>+operator bool(int x) {
>+    return x != 0;
>+}
>+operator bool(half x) {
>+    return x != 0;
>+}
>+operator bool(float x) {
>+    return x != 0;
>+}
>+
>+operator bool2(bool x, bool y) {
>+    bool2 result;
>+    result.x = x;
>+    result.y = y;
>+    return result;
>+}
>+operator bool3(bool x, bool y, bool z) {
>+    bool3 result;
>+    result.x = x;
>+    result.y = y;
>+    result.z = z;
>+    return result;
>+}
>+operator bool3(bool2 x, bool y) {
>+    bool3 result;
>+    result.x = x.x;
>+    result.y = x.y;
>+    result.z = y;
>+    return result;
>+}
>+operator bool3(bool x, bool2 y) {
>+    bool3 result;
>+    result.x = x;
>+    result.y = y.x;
>+    result.z = y.y;
>+    return result;
>+}
>+operator bool4(bool x, bool y, bool z, bool w) {
>+    bool4 result;
>+    result.x = x;
>+    result.y = y;
>+    result.z = z;
>+    result.w = w;
>+    return result;
>+}
>+operator bool4(bool2 x, bool y, bool z) {
>+    bool4 result;
>+    result.x = x.x;
>+    result.y = x.y;
>+    result.z = y;
>+    result.w = z;
>+    return result;
>+}
>+operator bool4(bool x, bool2 y, bool z) {
>+    bool4 result;
>+    result.x = x;
>+    result.y = y.x;
>+    result.z = y.y;
>+    result.w = z;
>+    return result;
>+}
>+operator bool4(bool x, bool y, bool2 z) {
>+    bool4 result;
>+    result.x = x;
>+    result.y = y;
>+    result.z = z.x;
>+    result.w = z.y;
>+    return result;
>+}
>+operator bool4(bool2 x, bool2 y) {
>+    bool4 result;
>+    result.x = x.x;
>+    result.y = x.y;
>+    result.z = y.x;
>+    result.w = y.y;
>+    return result;
>+}
>+operator bool4(bool3 x, bool y) {
>+    bool4 result;
>+    result.x = x.x;
>+    result.y = x.y;
>+    result.z = x.z;
>+    result.w = y;
>+    return result;
>+}
>+operator bool4(bool x, bool3 y) {
>+    bool4 result;
>+    result.x = x;
>+    result.y = y.x;
>+    result.z = y.y;
>+    result.w = y.z;
>+    return result;
>+}
>+operator uchar2(uchar x, uchar y) {
>+    uchar2 result;
>+    result.x = x;
>+    result.y = y;
>+    return result;
>+}
>+operator uchar3(uchar x, uchar y, uchar z) {
>+    uchar3 result;
>+    result.x = x;
>+    result.y = y;
>+    result.z = z;
>+    return result;
>+}
>+operator uchar3(uchar2 x, uchar y) {
>+    uchar3 result;
>+    result.x = x.x;
>+    result.y = x.y;
>+    result.z = y;
>+    return result;
>+}
>+operator uchar3(uchar x, uchar2 y) {
>+    uchar3 result;
>+    result.x = x;
>+    result.y = y.x;
>+    result.z = y.y;
>+    return result;
>+}
>+operator uchar4(uchar x, uchar y, uchar z, uchar w) {
>+    uchar4 result;
>+    result.x = x;
>+    result.y = y;
>+    result.z = z;
>+    result.w = w;
>+    return result;
>+}
>+operator uchar4(uchar2 x, uchar y, uchar z) {
>+    uchar4 result;
>+    result.x = x.x;
>+    result.y = x.y;
>+    result.z = y;
>+    result.w = z;
>+    return result;
>+}
>+operator uchar4(uchar x, uchar2 y, uchar z) {
>+    uchar4 result;
>+    result.x = x;
>+    result.y = y.x;
>+    result.z = y.y;
>+    result.w = z;
>+    return result;
>+}
>+operator uchar4(uchar x, uchar y, uchar2 z) {
>+    uchar4 result;
>+    result.x = x;
>+    result.y = y;
>+    result.z = z.x;
>+    result.w = z.y;
>+    return result;
>+}
>+operator uchar4(uchar2 x, uchar2 y) {
>+    uchar4 result;
>+    result.x = x.x;
>+    result.y = x.y;
>+    result.z = y.x;
>+    result.w = y.y;
>+    return result;
>+}
>+operator uchar4(uchar3 x, uchar y) {
>+    uchar4 result;
>+    result.x = x.x;
>+    result.y = x.y;
>+    result.z = x.z;
>+    result.w = y;
>+    return result;
>+}
>+operator uchar4(uchar x, uchar3 y) {
>+    uchar4 result;
>+    result.x = x;
>+    result.y = y.x;
>+    result.z = y.y;
>+    result.w = y.z;
>+    return result;
>+}
>+operator ushort2(ushort x, ushort y) {
>+    ushort2 result;
>+    result.x = x;
>+    result.y = y;
>+    return result;
>+}
>+operator ushort3(ushort x, ushort y, ushort z) {
>+    ushort3 result;
>+    result.x = x;
>+    result.y = y;
>+    result.z = z;
>+    return result;
>+}
>+operator ushort3(ushort2 x, ushort y) {
>+    ushort3 result;
>+    result.x = x.x;
>+    result.y = x.y;
>+    result.z = y;
>+    return result;
>+}
>+operator ushort3(ushort x, ushort2 y) {
>+    ushort3 result;
>+    result.x = x;
>+    result.y = y.x;
>+    result.z = y.y;
>+    return result;
>+}
>+operator ushort4(ushort x, ushort y, ushort z, ushort w) {
>+    ushort4 result;
>+    result.x = x;
>+    result.y = y;
>+    result.z = z;
>+    result.w = w;
>+    return result;
>+}
>+operator ushort4(ushort2 x, ushort y, ushort z) {
>+    ushort4 result;
>+    result.x = x.x;
>+    result.y = x.y;
>+    result.z = y;
>+    result.w = z;
>+    return result;
>+}
>+operator ushort4(ushort x, ushort2 y, ushort z) {
>+    ushort4 result;
>+    result.x = x;
>+    result.y = y.x;
>+    result.z = y.y;
>+    result.w = z;
>+    return result;
>+}
>+operator ushort4(ushort x, ushort y, ushort2 z) {
>+    ushort4 result;
>+    result.x = x;
>+    result.y = y;
>+    result.z = z.x;
>+    result.w = z.y;
>+    return result;
>+}
>+operator ushort4(ushort2 x, ushort2 y) {
>+    ushort4 result;
>+    result.x = x.x;
>+    result.y = x.y;
>+    result.z = y.x;
>+    result.w = y.y;
>+    return result;
>+}
>+operator ushort4(ushort3 x, ushort y) {
>+    ushort4 result;
>+    result.x = x.x;
>+    result.y = x.y;
>+    result.z = x.z;
>+    result.w = y;
>+    return result;
>+}
>+operator ushort4(ushort x, ushort3 y) {
>+    ushort4 result;
>+    result.x = x;
>+    result.y = y.x;
>+    result.z = y.y;
>+    result.w = y.z;
>+    return result;
>+}
>+operator uint2(uint x, uint y) {
>+    uint2 result;
>+    result.x = x;
>+    result.y = y;
>+    return result;
>+}
>+operator uint3(uint x, uint y, uint z) {
>+    uint3 result;
>+    result.x = x;
>+    result.y = y;
>+    result.z = z;
>+    return result;
>+}
>+operator uint3(uint2 x, uint y) {
>+    uint3 result;
>+    result.x = x.x;
>+    result.y = x.y;
>+    result.z = y;
>+    return result;
>+}
>+operator uint3(uint x, uint2 y) {
>+    uint3 result;
>+    result.x = x;
>+    result.y = y.x;
>+    result.z = y.y;
>+    return result;
>+}
>+operator uint4(uint x, uint y, uint z, uint w) {
>+    uint4 result;
>+    result.x = x;
>+    result.y = y;
>+    result.z = z;
>+    result.w = w;
>+    return result;
>+}
>+operator uint4(uint2 x, uint y, uint z) {
>+    uint4 result;
>+    result.x = x.x;
>+    result.y = x.y;
>+    result.z = y;
>+    result.w = z;
>+    return result;
>+}
>+operator uint4(uint x, uint2 y, uint z) {
>+    uint4 result;
>+    result.x = x;
>+    result.y = y.x;
>+    result.z = y.y;
>+    result.w = z;
>+    return result;
>+}
>+operator uint4(uint x, uint y, uint2 z) {
>+    uint4 result;
>+    result.x = x;
>+    result.y = y;
>+    result.z = z.x;
>+    result.w = z.y;
>+    return result;
>+}
>+operator uint4(uint2 x, uint2 y) {
>+    uint4 result;
>+    result.x = x.x;
>+    result.y = x.y;
>+    result.z = y.x;
>+    result.w = y.y;
>+    return result;
>+}
>+operator uint4(uint3 x, uint y) {
>+    uint4 result;
>+    result.x = x.x;
>+    result.y = x.y;
>+    result.z = x.z;
>+    result.w = y;
>+    return result;
>+}
>+operator uint4(uint x, uint3 y) {
>+    uint4 result;
>+    result.x = x;
>+    result.y = y.x;
>+    result.z = y.y;
>+    result.w = y.z;
>+    return result;
>+}
>+operator char2(char x, char y) {
>+    char2 result;
>+    result.x = x;
>+    result.y = y;
>+    return result;
>+}
>+operator char3(char x, char y, char z) {
>+    char3 result;
>+    result.x = x;
>+    result.y = y;
>+    result.z = z;
>+    return result;
>+}
>+operator char3(char2 x, char y) {
>+    char3 result;
>+    result.x = x.x;
>+    result.y = x.y;
>+    result.z = y;
>+    return result;
>+}
>+operator char3(char x, char2 y) {
>+    char3 result;
>+    result.x = x;
>+    result.y = y.x;
>+    result.z = y.y;
>+    return result;
>+}
>+operator char4(char x, char y, char z, char w) {
>+    char4 result;
>+    result.x = x;
>+    result.y = y;
>+    result.z = z;
>+    result.w = w;
>+    return result;
>+}
>+operator char4(char2 x, char y, char z) {
>+    char4 result;
>+    result.x = x.x;
>+    result.y = x.y;
>+    result.z = y;
>+    result.w = z;
>+    return result;
>+}
>+operator char4(char x, char2 y, char z) {
>+    char4 result;
>+    result.x = x;
>+    result.y = y.x;
>+    result.z = y.y;
>+    result.w = z;
>+    return result;
>+}
>+operator char4(char x, char y, char2 z) {
>+    char4 result;
>+    result.x = x;
>+    result.y = y;
>+    result.z = z.x;
>+    result.w = z.y;
>+    return result;
>+}
>+operator char4(char2 x, char2 y) {
>+    char4 result;
>+    result.x = x.x;
>+    result.y = x.y;
>+    result.z = y.x;
>+    result.w = y.y;
>+    return result;
>+}
>+operator char4(char3 x, char y) {
>+    char4 result;
>+    result.x = x.x;
>+    result.y = x.y;
>+    result.z = x.z;
>+    result.w = y;
>+    return result;
>+}
>+operator char4(char x, char3 y) {
>+    char4 result;
>+    result.x = x;
>+    result.y = y.x;
>+    result.z = y.y;
>+    result.w = y.z;
>+    return result;
>+}
>+operator short2(short x, short y) {
>+    short2 result;
>+    result.x = x;
>+    result.y = y;
>+    return result;
>+}
>+operator short3(short x, short y, short z) {
>+    short3 result;
>+    result.x = x;
>+    result.y = y;
>+    result.z = z;
>+    return result;
>+}
>+operator short3(short2 x, short y) {
>+    short3 result;
>+    result.x = x.x;
>+    result.y = x.y;
>+    result.z = y;
>+    return result;
>+}
>+operator short3(short x, short2 y) {
>+    short3 result;
>+    result.x = x;
>+    result.y = y.x;
>+    result.z = y.y;
>+    return result;
>+}
>+operator short4(short x, short y, short z, short w) {
>+    short4 result;
>+    result.x = x;
>+    result.y = y;
>+    result.z = z;
>+    result.w = w;
>+    return result;
>+}
>+operator short4(short2 x, short y, short z) {
>+    short4 result;
>+    result.x = x.x;
>+    result.y = x.y;
>+    result.z = y;
>+    result.w = z;
>+    return result;
>+}
>+operator short4(short x, short2 y, short z) {
>+    short4 result;
>+    result.x = x;
>+    result.y = y.x;
>+    result.z = y.y;
>+    result.w = z;
>+    return result;
>+}
>+operator short4(short x, short y, short2 z) {
>+    short4 result;
>+    result.x = x;
>+    result.y = y;
>+    result.z = z.x;
>+    result.w = z.y;
>+    return result;
>+}
>+operator short4(short2 x, short2 y) {
>+    short4 result;
>+    result.x = x.x;
>+    result.y = x.y;
>+    result.z = y.x;
>+    result.w = y.y;
>+    return result;
>+}
>+operator short4(short3 x, short y) {
>+    short4 result;
>+    result.x = x.x;
>+    result.y = x.y;
>+    result.z = x.z;
>+    result.w = y;
>+    return result;
>+}
>+operator short4(short x, short3 y) {
>+    short4 result;
>+    result.x = x;
>+    result.y = y.x;
>+    result.z = y.y;
>+    result.w = y.z;
>+    return result;
>+}
>+operator int2(int x, int y) {
>+    int2 result;
>+    result.x = x;
>+    result.y = y;
>+    return result;
>+}
>+operator int3(int x, int y, int z) {
>+    int3 result;
>+    result.x = x;
>+    result.y = y;
>+    result.z = z;
>+    return result;
>+}
>+operator int3(int2 x, int y) {
>+    int3 result;
>+    result.x = x.x;
>+    result.y = x.y;
>+    result.z = y;
>+    return result;
>+}
>+operator int3(int x, int2 y) {
>+    int3 result;
>+    result.x = x;
>+    result.y = y.x;
>+    result.z = y.y;
>+    return result;
>+}
>+operator int4(int x, int y, int z, int w) {
>+    int4 result;
>+    result.x = x;
>+    result.y = y;
>+    result.z = z;
>+    result.w = w;
>+    return result;
>+}
>+operator int4(int2 x, int y, int z) {
>+    int4 result;
>+    result.x = x.x;
>+    result.y = x.y;
>+    result.z = y;
>+    result.w = z;
>+    return result;
>+}
>+operator int4(int x, int2 y, int z) {
>+    int4 result;
>+    result.x = x;
>+    result.y = y.x;
>+    result.z = y.y;
>+    result.w = z;
>+    return result;
>+}
>+operator int4(int x, int y, int2 z) {
>+    int4 result;
>+    result.x = x;
>+    result.y = y;
>+    result.z = z.x;
>+    result.w = z.y;
>+    return result;
>+}
>+operator int4(int2 x, int2 y) {
>+    int4 result;
>+    result.x = x.x;
>+    result.y = x.y;
>+    result.z = y.x;
>+    result.w = y.y;
>+    return result;
>+}
>+operator int4(int3 x, int y) {
>+    int4 result;
>+    result.x = x.x;
>+    result.y = x.y;
>+    result.z = x.z;
>+    result.w = y;
>+    return result;
>+}
>+operator int4(int x, int3 y) {
>+    int4 result;
>+    result.x = x;
>+    result.y = y.x;
>+    result.z = y.y;
>+    result.w = y.z;
>+    return result;
>+}
>+operator half2(half x, half y) {
>+    half2 result;
>+    result.x = x;
>+    result.y = y;
>+    return result;
>+}
>+operator half3(half x, half y, half z) {
>+    half3 result;
>+    result.x = x;
>+    result.y = y;
>+    result.z = z;
>+    return result;
>+}
>+operator half3(half2 x, half y) {
>+    half3 result;
>+    result.x = x.x;
>+    result.y = x.y;
>+    result.z = y;
>+    return result;
>+}
>+operator half3(half x, half2 y) {
>+    half3 result;
>+    result.x = x;
>+    result.y = y.x;
>+    result.z = y.y;
>+    return result;
>+}
>+operator half4(half x, half y, half z, half w) {
>+    half4 result;
>+    result.x = x;
>+    result.y = y;
>+    result.z = z;
>+    result.w = w;
>+    return result;
>+}
>+operator half4(half2 x, half y, half z) {
>+    half4 result;
>+    result.x = x.x;
>+    result.y = x.y;
>+    result.z = y;
>+    result.w = z;
>+    return result;
>+}
>+operator half4(half x, half2 y, half z) {
>+    half4 result;
>+    result.x = x;
>+    result.y = y.x;
>+    result.z = y.y;
>+    result.w = z;
>+    return result;
>+}
>+operator half4(half x, half y, half2 z) {
>+    half4 result;
>+    result.x = x;
>+    result.y = y;
>+    result.z = z.x;
>+    result.w = z.y;
>+    return result;
>+}
>+operator half4(half2 x, half2 y) {
>+    half4 result;
>+    result.x = x.x;
>+    result.y = x.y;
>+    result.z = y.x;
>+    result.w = y.y;
>+    return result;
>+}
>+operator half4(half3 x, half y) {
>+    half4 result;
>+    result.x = x.x;
>+    result.y = x.y;
>+    result.z = x.z;
>+    result.w = y;
>+    return result;
>+}
>+operator half4(half x, half3 y) {
>+    half4 result;
>+    result.x = x;
>+    result.y = y.x;
>+    result.z = y.y;
>+    result.w = y.z;
>+    return result;
>+}
>+operator float2(float x, float y) {
>+    float2 result;
>+    result.x = x;
>+    result.y = y;
>+    return result;
>+}
>+operator float3(float x, float y, float z) {
>+    float3 result;
>+    result.x = x;
>+    result.y = y;
>+    result.z = z;
>+    return result;
>+}
>+operator float3(float2 x, float y) {
>+    float3 result;
>+    result.x = x.x;
>+    result.y = x.y;
>+    result.z = y;
>+    return result;
>+}
>+operator float3(float x, float2 y) {
>+    float3 result;
>+    result.x = x;
>+    result.y = y.x;
>+    result.z = y.y;
>+    return result;
>+}
>+operator float4(float x, float y, float z, float w) {
>+    float4 result;
>+    result.x = x;
>+    result.y = y;
>+    result.z = z;
>+    result.w = w;
>+    return result;
>+}
>+operator float4(float2 x, float y, float z) {
>+    float4 result;
>+    result.x = x.x;
>+    result.y = x.y;
>+    result.z = y;
>+    result.w = z;
>+    return result;
>+}
>+operator float4(float x, float2 y, float z) {
>+    float4 result;
>+    result.x = x;
>+    result.y = y.x;
>+    result.z = y.y;
>+    result.w = z;
>+    return result;
>+}
>+operator float4(float x, float y, float2 z) {
>+    float4 result;
>+    result.x = x;
>+    result.y = y;
>+    result.z = z.x;
>+    result.w = z.y;
>+    return result;
>+}
>+operator float4(float2 x, float2 y) {
>+    float4 result;
>+    result.x = x.x;
>+    result.y = x.y;
>+    result.z = y.x;
>+    result.w = y.y;
>+    return result;
>+}
>+operator float4(float3 x, float y) {
>+    float4 result;
>+    result.x = x.x;
>+    result.y = x.y;
>+    result.z = x.z;
>+    result.w = y;
>+    return result;
>+}
>+operator float4(float x, float3 y) {
>+    float4 result;
>+    result.x = x;
>+    result.y = y.x;
>+    result.z = y.y;
>+    result.w = y.z;
>+    return result;
>+}
>+operator half2x2(half2 a, half2 b) {
>+    half2x2 result;
>+    result[0] = a;
>+    result[1] = b;
>+    return result;
>+}
>+operator half2x3(half3 a, half3 b) {
>+    half2x3 result;
>+    result[0] = a;
>+    result[1] = b;
>+    return result;
>+}
>+operator half2x4(half4 a, half4 b) {
>+    half2x4 result;
>+    result[0] = a;
>+    result[1] = b;
>+    return result;
>+}
>+operator half3x2(half2 a, half2 b, half2 c) {
>+    half3x2 result;
>+    result[0] = a;
>+    result[1] = b;
>+    result[2] = c;
>+    return result;
>+}
>+operator half3x3(half3 a, half3 b, half3 c) {
>+    half3x3 result;
>+    result[0] = a;
>+    result[1] = b;
>+    result[2] = c;
>+    return result;
>+}
>+operator half3x4(half4 a, half4 b, half4 c) {
>+    half3x4 result;
>+    result[0] = a;
>+    result[1] = b;
>+    result[2] = c;
>+    return result;
>+}
>+operator half4x2(half2 a, half2 b, half2 c, half2 d) {
>+    half4x2 result;
>+    result[0] = a;
>+    result[1] = b;
>+    result[2] = c;
>+    result[3] = d;
>+    return result;
>+}
>+operator half4x3(half3 a, half3 b, half3 c, half3 d) {
>+    half4x3 result;
>+    result[0] = a;
>+    result[1] = b;
>+    result[2] = c;
>+    result[3] = d;
>+    return result;
>+}
>+operator half4x4(half4 a, half4 b, half4 c, half4 d) {
>+    half4x4 result;
>+    result[0] = a;
>+    result[1] = b;
>+    result[2] = c;
>+    result[3] = d;
>+    return result;
>+}
>+operator float2x2(float2 a, float2 b) {
>+    float2x2 result;
>+    result[0] = a;
>+    result[1] = b;
>+    return result;
>+}
>+operator float2x3(float3 a, float3 b) {
>+    float2x3 result;
>+    result[0] = a;
>+    result[1] = b;
>+    return result;
>+}
>+operator float2x4(float4 a, float4 b) {
>+    float2x4 result;
>+    result[0] = a;
>+    result[1] = b;
>+    return result;
>+}
>+operator float3x2(float2 a, float2 b, float2 c) {
>+    float3x2 result;
>+    result[0] = a;
>+    result[1] = b;
>+    result[2] = c;
>+    return result;
>+}
>+operator float3x3(float3 a, float3 b, float3 c) {
>+    float3x3 result;
>+    result[0] = a;
>+    result[1] = b;
>+    result[2] = c;
>+    return result;
>+}
>+operator float3x4(float4 a, float4 b, float4 c) {
>+    float3x4 result;
>+    result[0] = a;
>+    result[1] = b;
>+    result[2] = c;
>+    return result;
>+}
>+operator float4x2(float2 a, float2 b, float2 c, float2 d) {
>+    float4x2 result;
>+    result[0] = a;
>+    result[1] = b;
>+    result[2] = c;
>+    result[3] = d;
>+    return result;
>+}
>+operator float4x3(float3 a, float3 b, float3 c, float3 d) {
>+    float4x3 result;
>+    result[0] = a;
>+    result[1] = b;
>+    result[2] = c;
>+    result[3] = d;
>+    return result;
>+}
>+operator float4x4(float4 a, float4 b, float4 c, float4 d) {
>+    float4x4 result;
>+    result[0] = a;
>+    result[1] = b;
>+    result[2] = c;
>+    result[3] = d;
>+    return result;
>+}
>+
>+
>+/* Functions named operator.wyx */
>+bool3 operator.wyx(bool4 v) {
>+    bool3 result;
>+    result.x = v.w;
>+    result.y = v.y;
>+    result.z = v.x;
>+    return result;
>+}
>+uchar3 operator.wyx(uchar4 v) {
>+    uchar3 result;
>+    result.x = v.w;
>+    result.y = v.y;
>+    result.z = v.x;
>+    return result;
>+}
>+ushort3 operator.wyx(ushort4 v) {
>+    ushort3 result;
>+    result.x = v.w;
>+    result.y = v.y;
>+    result.z = v.x;
>+    return result;
>+}
>+uint3 operator.wyx(uint4 v) {
>+    uint3 result;
>+    result.x = v.w;
>+    result.y = v.y;
>+    result.z = v.x;
>+    return result;
>+}
>+char3 operator.wyx(char4 v) {
>+    char3 result;
>+    result.x = v.w;
>+    result.y = v.y;
>+    result.z = v.x;
>+    return result;
>+}
>+short3 operator.wyx(short4 v) {
>+    short3 result;
>+    result.x = v.w;
>+    result.y = v.y;
>+    result.z = v.x;
>+    return result;
>+}
>+int3 operator.wyx(int4 v) {
>+    int3 result;
>+    result.x = v.w;
>+    result.y = v.y;
>+    result.z = v.x;
>+    return result;
>+}
>+half3 operator.wyx(half4 v) {
>+    half3 result;
>+    result.x = v.w;
>+    result.y = v.y;
>+    result.z = v.x;
>+    return result;
>+}
>+float3 operator.wyx(float4 v) {
>+    float3 result;
>+    result.x = v.w;
>+    result.y = v.y;
>+    result.z = v.x;
>+    return result;
>+}
>+
>+/* Functions named load */
>+native int load(device atomic_int*);
>+native uint load(device atomic_uint*);
>+native int load(threadgroup atomic_int*);
>+native uint load(threadgroup atomic_uint*);
>+
>+/* Functions named operator.xxxx */
>+bool4 operator.xxxx(bool2 v) {
>+    bool4 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.x;
>+    result.w = v.x;
>+    return result;
>+}
>+bool4 operator.xxxx(bool3 v) {
>+    bool4 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.x;
>+    result.w = v.x;
>+    return result;
>+}
>+bool4 operator.xxxx(bool4 v) {
>+    bool4 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.x;
>+    result.w = v.x;
>+    return result;
>+}
>+uchar4 operator.xxxx(uchar2 v) {
>+    uchar4 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.x;
>+    result.w = v.x;
>+    return result;
>+}
>+uchar4 operator.xxxx(uchar3 v) {
>+    uchar4 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.x;
>+    result.w = v.x;
>+    return result;
>+}
>+uchar4 operator.xxxx(uchar4 v) {
>+    uchar4 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.x;
>+    result.w = v.x;
>+    return result;
>+}
>+ushort4 operator.xxxx(ushort2 v) {
>+    ushort4 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.x;
>+    result.w = v.x;
>+    return result;
>+}
>+ushort4 operator.xxxx(ushort3 v) {
>+    ushort4 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.x;
>+    result.w = v.x;
>+    return result;
>+}
>+ushort4 operator.xxxx(ushort4 v) {
>+    ushort4 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.x;
>+    result.w = v.x;
>+    return result;
>+}
>+uint4 operator.xxxx(uint2 v) {
>+    uint4 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.x;
>+    result.w = v.x;
>+    return result;
>+}
>+uint4 operator.xxxx(uint3 v) {
>+    uint4 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.x;
>+    result.w = v.x;
>+    return result;
>+}
>+uint4 operator.xxxx(uint4 v) {
>+    uint4 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.x;
>+    result.w = v.x;
>+    return result;
>+}
>+char4 operator.xxxx(char2 v) {
>+    char4 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.x;
>+    result.w = v.x;
>+    return result;
>+}
>+char4 operator.xxxx(char3 v) {
>+    char4 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.x;
>+    result.w = v.x;
>+    return result;
>+}
>+char4 operator.xxxx(char4 v) {
>+    char4 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.x;
>+    result.w = v.x;
>+    return result;
>+}
>+short4 operator.xxxx(short2 v) {
>+    short4 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.x;
>+    result.w = v.x;
>+    return result;
>+}
>+short4 operator.xxxx(short3 v) {
>+    short4 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.x;
>+    result.w = v.x;
>+    return result;
>+}
>+short4 operator.xxxx(short4 v) {
>+    short4 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.x;
>+    result.w = v.x;
>+    return result;
>+}
>+int4 operator.xxxx(int2 v) {
>+    int4 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.x;
>+    result.w = v.x;
>+    return result;
>+}
>+int4 operator.xxxx(int3 v) {
>+    int4 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.x;
>+    result.w = v.x;
>+    return result;
>+}
>+int4 operator.xxxx(int4 v) {
>+    int4 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.x;
>+    result.w = v.x;
>+    return result;
>+}
>+half4 operator.xxxx(half2 v) {
>+    half4 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.x;
>+    result.w = v.x;
>+    return result;
>+}
>+half4 operator.xxxx(half3 v) {
>+    half4 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.x;
>+    result.w = v.x;
>+    return result;
>+}
>+half4 operator.xxxx(half4 v) {
>+    half4 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.x;
>+    result.w = v.x;
>+    return result;
>+}
>+float4 operator.xxxx(float2 v) {
>+    float4 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.x;
>+    result.w = v.x;
>+    return result;
>+}
>+float4 operator.xxxx(float3 v) {
>+    float4 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.x;
>+    result.w = v.x;
>+    return result;
>+}
>+float4 operator.xxxx(float4 v) {
>+    float4 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.x;
>+    result.w = v.x;
>+    return result;
>+}
>+
>+/* Functions named operator.zyxz */
>+bool4 operator.zyxz(bool3 v) {
>+    bool4 result;
>+    result.x = v.z;
>+    result.y = v.y;
>+    result.z = v.x;
>+    result.w = v.z;
>+    return result;
>+}
>+bool4 operator.zyxz(bool4 v) {
>+    bool4 result;
>+    result.x = v.z;
>+    result.y = v.y;
>+    result.z = v.x;
>+    result.w = v.z;
>+    return result;
>+}
>+uchar4 operator.zyxz(uchar3 v) {
>+    uchar4 result;
>+    result.x = v.z;
>+    result.y = v.y;
>+    result.z = v.x;
>+    result.w = v.z;
>+    return result;
>+}
>+uchar4 operator.zyxz(uchar4 v) {
>+    uchar4 result;
>+    result.x = v.z;
>+    result.y = v.y;
>+    result.z = v.x;
>+    result.w = v.z;
>+    return result;
>+}
>+ushort4 operator.zyxz(ushort3 v) {
>+    ushort4 result;
>+    result.x = v.z;
>+    result.y = v.y;
>+    result.z = v.x;
>+    result.w = v.z;
>+    return result;
>+}
>+ushort4 operator.zyxz(ushort4 v) {
>+    ushort4 result;
>+    result.x = v.z;
>+    result.y = v.y;
>+    result.z = v.x;
>+    result.w = v.z;
>+    return result;
>+}
>+uint4 operator.zyxz(uint3 v) {
>+    uint4 result;
>+    result.x = v.z;
>+    result.y = v.y;
>+    result.z = v.x;
>+    result.w = v.z;
>+    return result;
>+}
>+uint4 operator.zyxz(uint4 v) {
>+    uint4 result;
>+    result.x = v.z;
>+    result.y = v.y;
>+    result.z = v.x;
>+    result.w = v.z;
>+    return result;
>+}
>+char4 operator.zyxz(char3 v) {
>+    char4 result;
>+    result.x = v.z;
>+    result.y = v.y;
>+    result.z = v.x;
>+    result.w = v.z;
>+    return result;
>+}
>+char4 operator.zyxz(char4 v) {
>+    char4 result;
>+    result.x = v.z;
>+    result.y = v.y;
>+    result.z = v.x;
>+    result.w = v.z;
>+    return result;
>+}
>+short4 operator.zyxz(short3 v) {
>+    short4 result;
>+    result.x = v.z;
>+    result.y = v.y;
>+    result.z = v.x;
>+    result.w = v.z;
>+    return result;
>+}
>+short4 operator.zyxz(short4 v) {
>+    short4 result;
>+    result.x = v.z;
>+    result.y = v.y;
>+    result.z = v.x;
>+    result.w = v.z;
>+    return result;
>+}
>+int4 operator.zyxz(int3 v) {
>+    int4 result;
>+    result.x = v.z;
>+    result.y = v.y;
>+    result.z = v.x;
>+    result.w = v.z;
>+    return result;
>+}
>+int4 operator.zyxz(int4 v) {
>+    int4 result;
>+    result.x = v.z;
>+    result.y = v.y;
>+    result.z = v.x;
>+    result.w = v.z;
>+    return result;
>+}
>+half4 operator.zyxz(half3 v) {
>+    half4 result;
>+    result.x = v.z;
>+    result.y = v.y;
>+    result.z = v.x;
>+    result.w = v.z;
>+    return result;
>+}
>+half4 operator.zyxz(half4 v) {
>+    half4 result;
>+    result.x = v.z;
>+    result.y = v.y;
>+    result.z = v.x;
>+    result.w = v.z;
>+    return result;
>+}
>+float4 operator.zyxz(float3 v) {
>+    float4 result;
>+    result.x = v.z;
>+    result.y = v.y;
>+    result.z = v.x;
>+    result.w = v.z;
>+    return result;
>+}
>+float4 operator.zyxz(float4 v) {
>+    float4 result;
>+    result.x = v.z;
>+    result.y = v.y;
>+    result.z = v.x;
>+    result.w = v.z;
>+    return result;
>+}
>+
>+/* Functions named operator.xz= */
>+bool3 operator.xz=(bool3 v, bool2 c) {
>+    bool3 result = v;
>+    result.x = c.x;
>+    result.z = c.y;
>+    return result;
>+}
>+bool4 operator.xz=(bool4 v, bool2 c) {
>+    bool4 result = v;
>+    result.x = c.x;
>+    result.z = c.y;
>+    return result;
>+}
>+uchar3 operator.xz=(uchar3 v, uchar2 c) {
>+    uchar3 result = v;
>+    result.x = c.x;
>+    result.z = c.y;
>+    return result;
>+}
>+uchar4 operator.xz=(uchar4 v, uchar2 c) {
>+    uchar4 result = v;
>+    result.x = c.x;
>+    result.z = c.y;
>+    return result;
>+}
>+ushort3 operator.xz=(ushort3 v, ushort2 c) {
>+    ushort3 result = v;
>+    result.x = c.x;
>+    result.z = c.y;
>+    return result;
>+}
>+ushort4 operator.xz=(ushort4 v, ushort2 c) {
>+    ushort4 result = v;
>+    result.x = c.x;
>+    result.z = c.y;
>+    return result;
>+}
>+uint3 operator.xz=(uint3 v, uint2 c) {
>+    uint3 result = v;
>+    result.x = c.x;
>+    result.z = c.y;
>+    return result;
>+}
>+uint4 operator.xz=(uint4 v, uint2 c) {
>+    uint4 result = v;
>+    result.x = c.x;
>+    result.z = c.y;
>+    return result;
>+}
>+char3 operator.xz=(char3 v, char2 c) {
>+    char3 result = v;
>+    result.x = c.x;
>+    result.z = c.y;
>+    return result;
>+}
>+char4 operator.xz=(char4 v, char2 c) {
>+    char4 result = v;
>+    result.x = c.x;
>+    result.z = c.y;
>+    return result;
>+}
>+short3 operator.xz=(short3 v, short2 c) {
>+    short3 result = v;
>+    result.x = c.x;
>+    result.z = c.y;
>+    return result;
>+}
>+short4 operator.xz=(short4 v, short2 c) {
>+    short4 result = v;
>+    result.x = c.x;
>+    result.z = c.y;
>+    return result;
>+}
>+int3 operator.xz=(int3 v, int2 c) {
>+    int3 result = v;
>+    result.x = c.x;
>+    result.z = c.y;
>+    return result;
>+}
>+int4 operator.xz=(int4 v, int2 c) {
>+    int4 result = v;
>+    result.x = c.x;
>+    result.z = c.y;
>+    return result;
>+}
>+half3 operator.xz=(half3 v, half2 c) {
>+    half3 result = v;
>+    result.x = c.x;
>+    result.z = c.y;
>+    return result;
>+}
>+half4 operator.xz=(half4 v, half2 c) {
>+    half4 result = v;
>+    result.x = c.x;
>+    result.z = c.y;
>+    return result;
>+}
>+float3 operator.xz=(float3 v, float2 c) {
>+    float3 result = v;
>+    result.x = c.x;
>+    result.z = c.y;
>+    return result;
>+}
>+float4 operator.xz=(float4 v, float2 c) {
>+    float4 result = v;
>+    result.x = c.x;
>+    result.z = c.y;
>+    return result;
>+}
>+
>+/* Functions named operator.zyxw */
>+bool4 operator.zyxw(bool4 v) {
>+    bool4 result;
>+    result.x = v.z;
>+    result.y = v.y;
>+    result.z = v.x;
>+    result.w = v.w;
>+    return result;
>+}
>+uchar4 operator.zyxw(uchar4 v) {
>+    uchar4 result;
>+    result.x = v.z;
>+    result.y = v.y;
>+    result.z = v.x;
>+    result.w = v.w;
>+    return result;
>+}
>+ushort4 operator.zyxw(ushort4 v) {
>+    ushort4 result;
>+    result.x = v.z;
>+    result.y = v.y;
>+    result.z = v.x;
>+    result.w = v.w;
>+    return result;
>+}
>+uint4 operator.zyxw(uint4 v) {
>+    uint4 result;
>+    result.x = v.z;
>+    result.y = v.y;
>+    result.z = v.x;
>+    result.w = v.w;
>+    return result;
>+}
>+char4 operator.zyxw(char4 v) {
>+    char4 result;
>+    result.x = v.z;
>+    result.y = v.y;
>+    result.z = v.x;
>+    result.w = v.w;
>+    return result;
>+}
>+short4 operator.zyxw(short4 v) {
>+    short4 result;
>+    result.x = v.z;
>+    result.y = v.y;
>+    result.z = v.x;
>+    result.w = v.w;
>+    return result;
>+}
>+int4 operator.zyxw(int4 v) {
>+    int4 result;
>+    result.x = v.z;
>+    result.y = v.y;
>+    result.z = v.x;
>+    result.w = v.w;
>+    return result;
>+}
>+half4 operator.zyxw(half4 v) {
>+    half4 result;
>+    result.x = v.z;
>+    result.y = v.y;
>+    result.z = v.x;
>+    result.w = v.w;
>+    return result;
>+}
>+float4 operator.zyxw(float4 v) {
>+    float4 result;
>+    result.x = v.z;
>+    result.y = v.y;
>+    result.z = v.x;
>+    result.w = v.w;
>+    return result;
>+}
>+
>+/* Functions named operator.zz */
>+bool2 operator.zz(bool3 v) {
>+    bool2 result;
>+    result.x = v.z;
>+    result.y = v.z;
>+    return result;
>+}
>+bool2 operator.zz(bool4 v) {
>+    bool2 result;
>+    result.x = v.z;
>+    result.y = v.z;
>+    return result;
>+}
>+uchar2 operator.zz(uchar3 v) {
>+    uchar2 result;
>+    result.x = v.z;
>+    result.y = v.z;
>+    return result;
>+}
>+uchar2 operator.zz(uchar4 v) {
>+    uchar2 result;
>+    result.x = v.z;
>+    result.y = v.z;
>+    return result;
>+}
>+ushort2 operator.zz(ushort3 v) {
>+    ushort2 result;
>+    result.x = v.z;
>+    result.y = v.z;
>+    return result;
>+}
>+ushort2 operator.zz(ushort4 v) {
>+    ushort2 result;
>+    result.x = v.z;
>+    result.y = v.z;
>+    return result;
>+}
>+uint2 operator.zz(uint3 v) {
>+    uint2 result;
>+    result.x = v.z;
>+    result.y = v.z;
>+    return result;
>+}
>+uint2 operator.zz(uint4 v) {
>+    uint2 result;
>+    result.x = v.z;
>+    result.y = v.z;
>+    return result;
>+}
>+char2 operator.zz(char3 v) {
>+    char2 result;
>+    result.x = v.z;
>+    result.y = v.z;
>+    return result;
>+}
>+char2 operator.zz(char4 v) {
>+    char2 result;
>+    result.x = v.z;
>+    result.y = v.z;
>+    return result;
>+}
>+short2 operator.zz(short3 v) {
>+    short2 result;
>+    result.x = v.z;
>+    result.y = v.z;
>+    return result;
>+}
>+short2 operator.zz(short4 v) {
>+    short2 result;
>+    result.x = v.z;
>+    result.y = v.z;
>+    return result;
>+}
>+int2 operator.zz(int3 v) {
>+    int2 result;
>+    result.x = v.z;
>+    result.y = v.z;
>+    return result;
>+}
>+int2 operator.zz(int4 v) {
>+    int2 result;
>+    result.x = v.z;
>+    result.y = v.z;
>+    return result;
>+}
>+half2 operator.zz(half3 v) {
>+    half2 result;
>+    result.x = v.z;
>+    result.y = v.z;
>+    return result;
>+}
>+half2 operator.zz(half4 v) {
>+    half2 result;
>+    result.x = v.z;
>+    result.y = v.z;
>+    return result;
>+}
>+float2 operator.zz(float3 v) {
>+    float2 result;
>+    result.x = v.z;
>+    result.y = v.z;
>+    return result;
>+}
>+float2 operator.zz(float4 v) {
>+    float2 result;
>+    result.x = v.z;
>+    result.y = v.z;
>+    return result;
>+}
>+
>+/* Functions named operator.wxzz */
>+bool4 operator.wxzz(bool4 v) {
>+    bool4 result;
>+    result.x = v.w;
>+    result.y = v.x;
>+    result.z = v.z;
>+    result.w = v.z;
>+    return result;
>+}
>+uchar4 operator.wxzz(uchar4 v) {
>+    uchar4 result;
>+    result.x = v.w;
>+    result.y = v.x;
>+    result.z = v.z;
>+    result.w = v.z;
>+    return result;
>+}
>+ushort4 operator.wxzz(ushort4 v) {
>+    ushort4 result;
>+    result.x = v.w;
>+    result.y = v.x;
>+    result.z = v.z;
>+    result.w = v.z;
>+    return result;
>+}
>+uint4 operator.wxzz(uint4 v) {
>+    uint4 result;
>+    result.x = v.w;
>+    result.y = v.x;
>+    result.z = v.z;
>+    result.w = v.z;
>+    return result;
>+}
>+char4 operator.wxzz(char4 v) {
>+    char4 result;
>+    result.x = v.w;
>+    result.y = v.x;
>+    result.z = v.z;
>+    result.w = v.z;
>+    return result;
>+}
>+short4 operator.wxzz(short4 v) {
>+    short4 result;
>+    result.x = v.w;
>+    result.y = v.x;
>+    result.z = v.z;
>+    result.w = v.z;
>+    return result;
>+}
>+int4 operator.wxzz(int4 v) {
>+    int4 result;
>+    result.x = v.w;
>+    result.y = v.x;
>+    result.z = v.z;
>+    result.w = v.z;
>+    return result;
>+}
>+half4 operator.wxzz(half4 v) {
>+    half4 result;
>+    result.x = v.w;
>+    result.y = v.x;
>+    result.z = v.z;
>+    result.w = v.z;
>+    return result;
>+}
>+float4 operator.wxzz(float4 v) {
>+    float4 result;
>+    result.x = v.w;
>+    result.y = v.x;
>+    result.z = v.z;
>+    result.w = v.z;
>+    return result;
>+}
>+
>+/* Functions named operator.wzwy */
>+bool4 operator.wzwy(bool4 v) {
>+    bool4 result;
>+    result.x = v.w;
>+    result.y = v.z;
>+    result.z = v.w;
>+    result.w = v.y;
>+    return result;
>+}
>+uchar4 operator.wzwy(uchar4 v) {
>+    uchar4 result;
>+    result.x = v.w;
>+    result.y = v.z;
>+    result.z = v.w;
>+    result.w = v.y;
>+    return result;
>+}
>+ushort4 operator.wzwy(ushort4 v) {
>+    ushort4 result;
>+    result.x = v.w;
>+    result.y = v.z;
>+    result.z = v.w;
>+    result.w = v.y;
>+    return result;
>+}
>+uint4 operator.wzwy(uint4 v) {
>+    uint4 result;
>+    result.x = v.w;
>+    result.y = v.z;
>+    result.z = v.w;
>+    result.w = v.y;
>+    return result;
>+}
>+char4 operator.wzwy(char4 v) {
>+    char4 result;
>+    result.x = v.w;
>+    result.y = v.z;
>+    result.z = v.w;
>+    result.w = v.y;
>+    return result;
>+}
>+short4 operator.wzwy(short4 v) {
>+    short4 result;
>+    result.x = v.w;
>+    result.y = v.z;
>+    result.z = v.w;
>+    result.w = v.y;
>+    return result;
>+}
>+int4 operator.wzwy(int4 v) {
>+    int4 result;
>+    result.x = v.w;
>+    result.y = v.z;
>+    result.z = v.w;
>+    result.w = v.y;
>+    return result;
>+}
>+half4 operator.wzwy(half4 v) {
>+    half4 result;
>+    result.x = v.w;
>+    result.y = v.z;
>+    result.z = v.w;
>+    result.w = v.y;
>+    return result;
>+}
>+float4 operator.wzwy(float4 v) {
>+    float4 result;
>+    result.x = v.w;
>+    result.y = v.z;
>+    result.z = v.w;
>+    result.w = v.y;
>+    return result;
>+}
>+
>+/* Functions named operator.wyzy */
>+bool4 operator.wyzy(bool4 v) {
>+    bool4 result;
>+    result.x = v.w;
>+    result.y = v.y;
>+    result.z = v.z;
>+    result.w = v.y;
>+    return result;
>+}
>+uchar4 operator.wyzy(uchar4 v) {
>+    uchar4 result;
>+    result.x = v.w;
>+    result.y = v.y;
>+    result.z = v.z;
>+    result.w = v.y;
>+    return result;
>+}
>+ushort4 operator.wyzy(ushort4 v) {
>+    ushort4 result;
>+    result.x = v.w;
>+    result.y = v.y;
>+    result.z = v.z;
>+    result.w = v.y;
>+    return result;
>+}
>+uint4 operator.wyzy(uint4 v) {
>+    uint4 result;
>+    result.x = v.w;
>+    result.y = v.y;
>+    result.z = v.z;
>+    result.w = v.y;
>+    return result;
>+}
>+char4 operator.wyzy(char4 v) {
>+    char4 result;
>+    result.x = v.w;
>+    result.y = v.y;
>+    result.z = v.z;
>+    result.w = v.y;
>+    return result;
>+}
>+short4 operator.wyzy(short4 v) {
>+    short4 result;
>+    result.x = v.w;
>+    result.y = v.y;
>+    result.z = v.z;
>+    result.w = v.y;
>+    return result;
>+}
>+int4 operator.wyzy(int4 v) {
>+    int4 result;
>+    result.x = v.w;
>+    result.y = v.y;
>+    result.z = v.z;
>+    result.w = v.y;
>+    return result;
>+}
>+half4 operator.wyzy(half4 v) {
>+    half4 result;
>+    result.x = v.w;
>+    result.y = v.y;
>+    result.z = v.z;
>+    result.w = v.y;
>+    return result;
>+}
>+float4 operator.wyzy(float4 v) {
>+    float4 result;
>+    result.x = v.w;
>+    result.y = v.y;
>+    result.z = v.z;
>+    result.w = v.y;
>+    return result;
>+}
>+
>+/* Functions named operator.xwxx */
>+bool4 operator.xwxx(bool4 v) {
>+    bool4 result;
>+    result.x = v.x;
>+    result.y = v.w;
>+    result.z = v.x;
>+    result.w = v.x;
>+    return result;
>+}
>+uchar4 operator.xwxx(uchar4 v) {
>+    uchar4 result;
>+    result.x = v.x;
>+    result.y = v.w;
>+    result.z = v.x;
>+    result.w = v.x;
>+    return result;
>+}
>+ushort4 operator.xwxx(ushort4 v) {
>+    ushort4 result;
>+    result.x = v.x;
>+    result.y = v.w;
>+    result.z = v.x;
>+    result.w = v.x;
>+    return result;
>+}
>+uint4 operator.xwxx(uint4 v) {
>+    uint4 result;
>+    result.x = v.x;
>+    result.y = v.w;
>+    result.z = v.x;
>+    result.w = v.x;
>+    return result;
>+}
>+char4 operator.xwxx(char4 v) {
>+    char4 result;
>+    result.x = v.x;
>+    result.y = v.w;
>+    result.z = v.x;
>+    result.w = v.x;
>+    return result;
>+}
>+short4 operator.xwxx(short4 v) {
>+    short4 result;
>+    result.x = v.x;
>+    result.y = v.w;
>+    result.z = v.x;
>+    result.w = v.x;
>+    return result;
>+}
>+int4 operator.xwxx(int4 v) {
>+    int4 result;
>+    result.x = v.x;
>+    result.y = v.w;
>+    result.z = v.x;
>+    result.w = v.x;
>+    return result;
>+}
>+half4 operator.xwxx(half4 v) {
>+    half4 result;
>+    result.x = v.x;
>+    result.y = v.w;
>+    result.z = v.x;
>+    result.w = v.x;
>+    return result;
>+}
>+float4 operator.xwxx(float4 v) {
>+    float4 result;
>+    result.x = v.x;
>+    result.y = v.w;
>+    result.z = v.x;
>+    result.w = v.x;
>+    return result;
>+}
>+
>+/* Functions named operator.xyy */
>+bool3 operator.xyy(bool2 v) {
>+    bool3 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.y;
>+    return result;
>+}
>+bool3 operator.xyy(bool3 v) {
>+    bool3 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.y;
>+    return result;
>+}
>+bool3 operator.xyy(bool4 v) {
>+    bool3 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.y;
>+    return result;
>+}
>+uchar3 operator.xyy(uchar2 v) {
>+    uchar3 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.y;
>+    return result;
>+}
>+uchar3 operator.xyy(uchar3 v) {
>+    uchar3 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.y;
>+    return result;
>+}
>+uchar3 operator.xyy(uchar4 v) {
>+    uchar3 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.y;
>+    return result;
>+}
>+ushort3 operator.xyy(ushort2 v) {
>+    ushort3 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.y;
>+    return result;
>+}
>+ushort3 operator.xyy(ushort3 v) {
>+    ushort3 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.y;
>+    return result;
>+}
>+ushort3 operator.xyy(ushort4 v) {
>+    ushort3 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.y;
>+    return result;
>+}
>+uint3 operator.xyy(uint2 v) {
>+    uint3 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.y;
>+    return result;
>+}
>+uint3 operator.xyy(uint3 v) {
>+    uint3 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.y;
>+    return result;
>+}
>+uint3 operator.xyy(uint4 v) {
>+    uint3 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.y;
>+    return result;
>+}
>+char3 operator.xyy(char2 v) {
>+    char3 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.y;
>+    return result;
>+}
>+char3 operator.xyy(char3 v) {
>+    char3 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.y;
>+    return result;
>+}
>+char3 operator.xyy(char4 v) {
>+    char3 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.y;
>+    return result;
>+}
>+short3 operator.xyy(short2 v) {
>+    short3 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.y;
>+    return result;
>+}
>+short3 operator.xyy(short3 v) {
>+    short3 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.y;
>+    return result;
>+}
>+short3 operator.xyy(short4 v) {
>+    short3 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.y;
>+    return result;
>+}
>+int3 operator.xyy(int2 v) {
>+    int3 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.y;
>+    return result;
>+}
>+int3 operator.xyy(int3 v) {
>+    int3 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.y;
>+    return result;
>+}
>+int3 operator.xyy(int4 v) {
>+    int3 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.y;
>+    return result;
>+}
>+half3 operator.xyy(half2 v) {
>+    half3 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.y;
>+    return result;
>+}
>+half3 operator.xyy(half3 v) {
>+    half3 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.y;
>+    return result;
>+}
>+half3 operator.xyy(half4 v) {
>+    half3 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.y;
>+    return result;
>+}
>+float3 operator.xyy(float2 v) {
>+    float3 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.y;
>+    return result;
>+}
>+float3 operator.xyy(float3 v) {
>+    float3 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.y;
>+    return result;
>+}
>+float3 operator.xyy(float4 v) {
>+    float3 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.y;
>+    return result;
>+}
>+
>+/* Functions named operator.wzxy= */
>+bool4 operator.wzxy=(bool4 v, bool4 c) {
>+    bool4 result = v;
>+    result.w = c.x;
>+    result.z = c.y;
>+    result.x = c.z;
>+    result.y = c.w;
>+    return result;
>+}
>+uchar4 operator.wzxy=(uchar4 v, uchar4 c) {
>+    uchar4 result = v;
>+    result.w = c.x;
>+    result.z = c.y;
>+    result.x = c.z;
>+    result.y = c.w;
>+    return result;
>+}
>+ushort4 operator.wzxy=(ushort4 v, ushort4 c) {
>+    ushort4 result = v;
>+    result.w = c.x;
>+    result.z = c.y;
>+    result.x = c.z;
>+    result.y = c.w;
>+    return result;
>+}
>+uint4 operator.wzxy=(uint4 v, uint4 c) {
>+    uint4 result = v;
>+    result.w = c.x;
>+    result.z = c.y;
>+    result.x = c.z;
>+    result.y = c.w;
>+    return result;
>+}
>+char4 operator.wzxy=(char4 v, char4 c) {
>+    char4 result = v;
>+    result.w = c.x;
>+    result.z = c.y;
>+    result.x = c.z;
>+    result.y = c.w;
>+    return result;
>+}
>+short4 operator.wzxy=(short4 v, short4 c) {
>+    short4 result = v;
>+    result.w = c.x;
>+    result.z = c.y;
>+    result.x = c.z;
>+    result.y = c.w;
>+    return result;
>+}
>+int4 operator.wzxy=(int4 v, int4 c) {
>+    int4 result = v;
>+    result.w = c.x;
>+    result.z = c.y;
>+    result.x = c.z;
>+    result.y = c.w;
>+    return result;
>+}
>+half4 operator.wzxy=(half4 v, half4 c) {
>+    half4 result = v;
>+    result.w = c.x;
>+    result.z = c.y;
>+    result.x = c.z;
>+    result.y = c.w;
>+    return result;
>+}
>+float4 operator.wzxy=(float4 v, float4 c) {
>+    float4 result = v;
>+    result.w = c.x;
>+    result.z = c.y;
>+    result.x = c.z;
>+    result.y = c.w;
>+    return result;
>+}
>+
>+/* Functions named operator.zw */
>+bool2 operator.zw(bool4 v) {
>+    bool2 result;
>+    result.x = v.z;
>+    result.y = v.w;
>+    return result;
>+}
>+uchar2 operator.zw(uchar4 v) {
>+    uchar2 result;
>+    result.x = v.z;
>+    result.y = v.w;
>+    return result;
>+}
>+ushort2 operator.zw(ushort4 v) {
>+    ushort2 result;
>+    result.x = v.z;
>+    result.y = v.w;
>+    return result;
>+}
>+uint2 operator.zw(uint4 v) {
>+    uint2 result;
>+    result.x = v.z;
>+    result.y = v.w;
>+    return result;
>+}
>+char2 operator.zw(char4 v) {
>+    char2 result;
>+    result.x = v.z;
>+    result.y = v.w;
>+    return result;
>+}
>+short2 operator.zw(short4 v) {
>+    short2 result;
>+    result.x = v.z;
>+    result.y = v.w;
>+    return result;
>+}
>+int2 operator.zw(int4 v) {
>+    int2 result;
>+    result.x = v.z;
>+    result.y = v.w;
>+    return result;
>+}
>+half2 operator.zw(half4 v) {
>+    half2 result;
>+    result.x = v.z;
>+    result.y = v.w;
>+    return result;
>+}
>+float2 operator.zw(float4 v) {
>+    float2 result;
>+    result.x = v.z;
>+    result.y = v.w;
>+    return result;
>+}
>+
>+/* Functions named operator.xxz */
>+bool3 operator.xxz(bool3 v) {
>+    bool3 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.z;
>+    return result;
>+}
>+bool3 operator.xxz(bool4 v) {
>+    bool3 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.z;
>+    return result;
>+}
>+uchar3 operator.xxz(uchar3 v) {
>+    uchar3 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.z;
>+    return result;
>+}
>+uchar3 operator.xxz(uchar4 v) {
>+    uchar3 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.z;
>+    return result;
>+}
>+ushort3 operator.xxz(ushort3 v) {
>+    ushort3 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.z;
>+    return result;
>+}
>+ushort3 operator.xxz(ushort4 v) {
>+    ushort3 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.z;
>+    return result;
>+}
>+uint3 operator.xxz(uint3 v) {
>+    uint3 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.z;
>+    return result;
>+}
>+uint3 operator.xxz(uint4 v) {
>+    uint3 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.z;
>+    return result;
>+}
>+char3 operator.xxz(char3 v) {
>+    char3 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.z;
>+    return result;
>+}
>+char3 operator.xxz(char4 v) {
>+    char3 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.z;
>+    return result;
>+}
>+short3 operator.xxz(short3 v) {
>+    short3 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.z;
>+    return result;
>+}
>+short3 operator.xxz(short4 v) {
>+    short3 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.z;
>+    return result;
>+}
>+int3 operator.xxz(int3 v) {
>+    int3 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.z;
>+    return result;
>+}
>+int3 operator.xxz(int4 v) {
>+    int3 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.z;
>+    return result;
>+}
>+half3 operator.xxz(half3 v) {
>+    half3 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.z;
>+    return result;
>+}
>+half3 operator.xxz(half4 v) {
>+    half3 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.z;
>+    return result;
>+}
>+float3 operator.xxz(float3 v) {
>+    float3 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.z;
>+    return result;
>+}
>+float3 operator.xxz(float4 v) {
>+    float3 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.z;
>+    return result;
>+}
>+
>+/* Functions named operator.yxy */
>+bool3 operator.yxy(bool2 v) {
>+    bool3 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.y;
>+    return result;
>+}
>+bool3 operator.yxy(bool3 v) {
>+    bool3 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.y;
>+    return result;
>+}
>+bool3 operator.yxy(bool4 v) {
>+    bool3 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.y;
>+    return result;
>+}
>+uchar3 operator.yxy(uchar2 v) {
>+    uchar3 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.y;
>+    return result;
>+}
>+uchar3 operator.yxy(uchar3 v) {
>+    uchar3 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.y;
>+    return result;
>+}
>+uchar3 operator.yxy(uchar4 v) {
>+    uchar3 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.y;
>+    return result;
>+}
>+ushort3 operator.yxy(ushort2 v) {
>+    ushort3 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.y;
>+    return result;
>+}
>+ushort3 operator.yxy(ushort3 v) {
>+    ushort3 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.y;
>+    return result;
>+}
>+ushort3 operator.yxy(ushort4 v) {
>+    ushort3 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.y;
>+    return result;
>+}
>+uint3 operator.yxy(uint2 v) {
>+    uint3 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.y;
>+    return result;
>+}
>+uint3 operator.yxy(uint3 v) {
>+    uint3 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.y;
>+    return result;
>+}
>+uint3 operator.yxy(uint4 v) {
>+    uint3 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.y;
>+    return result;
>+}
>+char3 operator.yxy(char2 v) {
>+    char3 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.y;
>+    return result;
>+}
>+char3 operator.yxy(char3 v) {
>+    char3 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.y;
>+    return result;
>+}
>+char3 operator.yxy(char4 v) {
>+    char3 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.y;
>+    return result;
>+}
>+short3 operator.yxy(short2 v) {
>+    short3 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.y;
>+    return result;
>+}
>+short3 operator.yxy(short3 v) {
>+    short3 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.y;
>+    return result;
>+}
>+short3 operator.yxy(short4 v) {
>+    short3 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.y;
>+    return result;
>+}
>+int3 operator.yxy(int2 v) {
>+    int3 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.y;
>+    return result;
>+}
>+int3 operator.yxy(int3 v) {
>+    int3 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.y;
>+    return result;
>+}
>+int3 operator.yxy(int4 v) {
>+    int3 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.y;
>+    return result;
>+}
>+half3 operator.yxy(half2 v) {
>+    half3 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.y;
>+    return result;
>+}
>+half3 operator.yxy(half3 v) {
>+    half3 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.y;
>+    return result;
>+}
>+half3 operator.yxy(half4 v) {
>+    half3 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.y;
>+    return result;
>+}
>+float3 operator.yxy(float2 v) {
>+    float3 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.y;
>+    return result;
>+}
>+float3 operator.yxy(float3 v) {
>+    float3 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.y;
>+    return result;
>+}
>+float3 operator.yxy(float4 v) {
>+    float3 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.y;
>+    return result;
>+}
>+
>+/* Functions named count_bits */
>+uchar count_bits(uchar x) {
>+    return uchar(((x | uchar(1 << 0)) == 0 ? 0 : 1) +
>+           ((x | uchar(1 << 1)) == 0 ? 0 : 1) +
>+           ((x | uchar(1 << 2)) == 0 ? 0 : 1) +
>+           ((x | uchar(1 << 3)) == 0 ? 0 : 1) +
>+           ((x | uchar(1 << 4)) == 0 ? 0 : 1) +
>+           ((x | uchar(1 << 5)) == 0 ? 0 : 1) +
>+           ((x | uchar(1 << 6)) == 0 ? 0 : 1) +
>+           ((x | uchar(1 << 7)) == 0 ? 0 : 1));
>+}
>+uchar count_bits(ushort x) {
>+    return uchar(((x | ushort(1 << 0)) == 0 ? 0 : 1) +
>+           ((x | ushort(1 << 1)) == 0 ? 0 : 1) +
>+           ((x | ushort(1 << 2)) == 0 ? 0 : 1) +
>+           ((x | ushort(1 << 3)) == 0 ? 0 : 1) +
>+           ((x | ushort(1 << 4)) == 0 ? 0 : 1) +
>+           ((x | ushort(1 << 5)) == 0 ? 0 : 1) +
>+           ((x | ushort(1 << 6)) == 0 ? 0 : 1) +
>+           ((x | ushort(1 << 7)) == 0 ? 0 : 1) +
>+           ((x | ushort(1 << 8)) == 0 ? 0 : 1) +
>+           ((x | ushort(1 << 9)) == 0 ? 0 : 1) +
>+           ((x | ushort(1 << 10)) == 0 ? 0 : 1) +
>+           ((x | ushort(1 << 11)) == 0 ? 0 : 1) +
>+           ((x | ushort(1 << 12)) == 0 ? 0 : 1) +
>+           ((x | ushort(1 << 13)) == 0 ? 0 : 1) +
>+           ((x | ushort(1 << 14)) == 0 ? 0 : 1) +
>+           ((x | ushort(1 << 15)) == 0 ? 0 : 1));
>+}
>+uchar count_bits(uint x) {
>+    return uchar(((x | uint(1 << 0)) == 0 ? 0 : 1) +
>+           ((x | uint(1 << 1)) == 0 ? 0 : 1) +
>+           ((x | uint(1 << 2)) == 0 ? 0 : 1) +
>+           ((x | uint(1 << 3)) == 0 ? 0 : 1) +
>+           ((x | uint(1 << 4)) == 0 ? 0 : 1) +
>+           ((x | uint(1 << 5)) == 0 ? 0 : 1) +
>+           ((x | uint(1 << 6)) == 0 ? 0 : 1) +
>+           ((x | uint(1 << 7)) == 0 ? 0 : 1) +
>+           ((x | uint(1 << 8)) == 0 ? 0 : 1) +
>+           ((x | uint(1 << 9)) == 0 ? 0 : 1) +
>+           ((x | uint(1 << 10)) == 0 ? 0 : 1) +
>+           ((x | uint(1 << 11)) == 0 ? 0 : 1) +
>+           ((x | uint(1 << 12)) == 0 ? 0 : 1) +
>+           ((x | uint(1 << 13)) == 0 ? 0 : 1) +
>+           ((x | uint(1 << 14)) == 0 ? 0 : 1) +
>+           ((x | uint(1 << 15)) == 0 ? 0 : 1) +
>+           ((x | uint(1 << 16)) == 0 ? 0 : 1) +
>+           ((x | uint(1 << 17)) == 0 ? 0 : 1) +
>+           ((x | uint(1 << 18)) == 0 ? 0 : 1) +
>+           ((x | uint(1 << 19)) == 0 ? 0 : 1) +
>+           ((x | uint(1 << 20)) == 0 ? 0 : 1) +
>+           ((x | uint(1 << 21)) == 0 ? 0 : 1) +
>+           ((x | uint(1 << 22)) == 0 ? 0 : 1) +
>+           ((x | uint(1 << 23)) == 0 ? 0 : 1) +
>+           ((x | uint(1 << 24)) == 0 ? 0 : 1) +
>+           ((x | uint(1 << 25)) == 0 ? 0 : 1) +
>+           ((x | uint(1 << 26)) == 0 ? 0 : 1) +
>+           ((x | uint(1 << 27)) == 0 ? 0 : 1) +
>+           ((x | uint(1 << 28)) == 0 ? 0 : 1) +
>+           ((x | uint(1 << 29)) == 0 ? 0 : 1) +
>+           ((x | uint(1 << 30)) == 0 ? 0 : 1) +
>+           ((x | uint(1 << 31)) == 0 ? 0 : 1));
>+}
>+uchar2 count_bits(uchar2 x) {
>+    uchar2 result;
>+    result[0] = count_bits(x[0]);
>+    result[1] = count_bits(x[1]);
>+    return result;
>+}
>+uchar3 count_bits(uchar3 x) {
>+    uchar3 result;
>+    result[0] = count_bits(x[0]);
>+    result[1] = count_bits(x[1]);
>+    result[2] = count_bits(x[2]);
>+    return result;
>+}
>+uchar4 count_bits(uchar4 x) {
>+    uchar4 result;
>+    result[0] = count_bits(x[0]);
>+    result[1] = count_bits(x[1]);
>+    result[2] = count_bits(x[2]);
>+    result[3] = count_bits(x[3]);
>+    return result;
>+}
>+uchar2 count_bits(ushort2 x) {
>+    uchar2 result;
>+    result[0] = count_bits(x[0]);
>+    result[1] = count_bits(x[1]);
>+    return result;
>+}
>+uchar3 count_bits(ushort3 x) {
>+    uchar3 result;
>+    result[0] = count_bits(x[0]);
>+    result[1] = count_bits(x[1]);
>+    result[2] = count_bits(x[2]);
>+    return result;
>+}
>+uchar4 count_bits(ushort4 x) {
>+    uchar4 result;
>+    result[0] = count_bits(x[0]);
>+    result[1] = count_bits(x[1]);
>+    result[2] = count_bits(x[2]);
>+    result[3] = count_bits(x[3]);
>+    return result;
>+}
>+uchar2 count_bits(uint2 x) {
>+    uchar2 result;
>+    result[0] = count_bits(x[0]);
>+    result[1] = count_bits(x[1]);
>+    return result;
>+}
>+uchar3 count_bits(uint3 x) {
>+    uchar3 result;
>+    result[0] = count_bits(x[0]);
>+    result[1] = count_bits(x[1]);
>+    result[2] = count_bits(x[2]);
>+    return result;
>+}
>+uchar4 count_bits(uint4 x) {
>+    uchar4 result;
>+    result[0] = count_bits(x[0]);
>+    result[1] = count_bits(x[1]);
>+    result[2] = count_bits(x[2]);
>+    result[3] = count_bits(x[3]);
>+    return result;
>+}
>+
>+/* Functions named operator.yyz */
>+bool3 operator.yyz(bool3 v) {
>+    bool3 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.z;
>+    return result;
>+}
>+bool3 operator.yyz(bool4 v) {
>+    bool3 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.z;
>+    return result;
>+}
>+uchar3 operator.yyz(uchar3 v) {
>+    uchar3 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.z;
>+    return result;
>+}
>+uchar3 operator.yyz(uchar4 v) {
>+    uchar3 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.z;
>+    return result;
>+}
>+ushort3 operator.yyz(ushort3 v) {
>+    ushort3 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.z;
>+    return result;
>+}
>+ushort3 operator.yyz(ushort4 v) {
>+    ushort3 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.z;
>+    return result;
>+}
>+uint3 operator.yyz(uint3 v) {
>+    uint3 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.z;
>+    return result;
>+}
>+uint3 operator.yyz(uint4 v) {
>+    uint3 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.z;
>+    return result;
>+}
>+char3 operator.yyz(char3 v) {
>+    char3 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.z;
>+    return result;
>+}
>+char3 operator.yyz(char4 v) {
>+    char3 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.z;
>+    return result;
>+}
>+short3 operator.yyz(short3 v) {
>+    short3 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.z;
>+    return result;
>+}
>+short3 operator.yyz(short4 v) {
>+    short3 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.z;
>+    return result;
>+}
>+int3 operator.yyz(int3 v) {
>+    int3 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.z;
>+    return result;
>+}
>+int3 operator.yyz(int4 v) {
>+    int3 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.z;
>+    return result;
>+}
>+half3 operator.yyz(half3 v) {
>+    half3 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.z;
>+    return result;
>+}
>+half3 operator.yyz(half4 v) {
>+    half3 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.z;
>+    return result;
>+}
>+float3 operator.yyz(float3 v) {
>+    float3 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.z;
>+    return result;
>+}
>+float3 operator.yyz(float4 v) {
>+    float3 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.z;
>+    return result;
>+}
>+
>+/* Functions named operator.wx */
>+bool2 operator.wx(bool4 v) {
>+    bool2 result;
>+    result.x = v.w;
>+    result.y = v.x;
>+    return result;
>+}
>+uchar2 operator.wx(uchar4 v) {
>+    uchar2 result;
>+    result.x = v.w;
>+    result.y = v.x;
>+    return result;
>+}
>+ushort2 operator.wx(ushort4 v) {
>+    ushort2 result;
>+    result.x = v.w;
>+    result.y = v.x;
>+    return result;
>+}
>+uint2 operator.wx(uint4 v) {
>+    uint2 result;
>+    result.x = v.w;
>+    result.y = v.x;
>+    return result;
>+}
>+char2 operator.wx(char4 v) {
>+    char2 result;
>+    result.x = v.w;
>+    result.y = v.x;
>+    return result;
>+}
>+short2 operator.wx(short4 v) {
>+    short2 result;
>+    result.x = v.w;
>+    result.y = v.x;
>+    return result;
>+}
>+int2 operator.wx(int4 v) {
>+    int2 result;
>+    result.x = v.w;
>+    result.y = v.x;
>+    return result;
>+}
>+half2 operator.wx(half4 v) {
>+    half2 result;
>+    result.x = v.w;
>+    result.y = v.x;
>+    return result;
>+}
>+float2 operator.wx(float4 v) {
>+    float2 result;
>+    result.x = v.w;
>+    result.y = v.x;
>+    return result;
>+}
>+
>+/* Functions named operator.yxwz= */
>+bool4 operator.yxwz=(bool4 v, bool4 c) {
>+    bool4 result = v;
>+    result.y = c.x;
>+    result.x = c.y;
>+    result.w = c.z;
>+    result.z = c.w;
>+    return result;
>+}
>+uchar4 operator.yxwz=(uchar4 v, uchar4 c) {
>+    uchar4 result = v;
>+    result.y = c.x;
>+    result.x = c.y;
>+    result.w = c.z;
>+    result.z = c.w;
>+    return result;
>+}
>+ushort4 operator.yxwz=(ushort4 v, ushort4 c) {
>+    ushort4 result = v;
>+    result.y = c.x;
>+    result.x = c.y;
>+    result.w = c.z;
>+    result.z = c.w;
>+    return result;
>+}
>+uint4 operator.yxwz=(uint4 v, uint4 c) {
>+    uint4 result = v;
>+    result.y = c.x;
>+    result.x = c.y;
>+    result.w = c.z;
>+    result.z = c.w;
>+    return result;
>+}
>+char4 operator.yxwz=(char4 v, char4 c) {
>+    char4 result = v;
>+    result.y = c.x;
>+    result.x = c.y;
>+    result.w = c.z;
>+    result.z = c.w;
>+    return result;
>+}
>+short4 operator.yxwz=(short4 v, short4 c) {
>+    short4 result = v;
>+    result.y = c.x;
>+    result.x = c.y;
>+    result.w = c.z;
>+    result.z = c.w;
>+    return result;
>+}
>+int4 operator.yxwz=(int4 v, int4 c) {
>+    int4 result = v;
>+    result.y = c.x;
>+    result.x = c.y;
>+    result.w = c.z;
>+    result.z = c.w;
>+    return result;
>+}
>+half4 operator.yxwz=(half4 v, half4 c) {
>+    half4 result = v;
>+    result.y = c.x;
>+    result.x = c.y;
>+    result.w = c.z;
>+    result.z = c.w;
>+    return result;
>+}
>+float4 operator.yxwz=(float4 v, float4 c) {
>+    float4 result = v;
>+    result.y = c.x;
>+    result.x = c.y;
>+    result.w = c.z;
>+    result.z = c.w;
>+    return result;
>+}
>+
>+/* Functions named operator.xx */
>+bool2 operator.xx(bool2 v) {
>+    bool2 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    return result;
>+}
>+bool2 operator.xx(bool3 v) {
>+    bool2 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    return result;
>+}
>+bool2 operator.xx(bool4 v) {
>+    bool2 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    return result;
>+}
>+uchar2 operator.xx(uchar2 v) {
>+    uchar2 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    return result;
>+}
>+uchar2 operator.xx(uchar3 v) {
>+    uchar2 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    return result;
>+}
>+uchar2 operator.xx(uchar4 v) {
>+    uchar2 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    return result;
>+}
>+ushort2 operator.xx(ushort2 v) {
>+    ushort2 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    return result;
>+}
>+ushort2 operator.xx(ushort3 v) {
>+    ushort2 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    return result;
>+}
>+ushort2 operator.xx(ushort4 v) {
>+    ushort2 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    return result;
>+}
>+uint2 operator.xx(uint2 v) {
>+    uint2 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    return result;
>+}
>+uint2 operator.xx(uint3 v) {
>+    uint2 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    return result;
>+}
>+uint2 operator.xx(uint4 v) {
>+    uint2 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    return result;
>+}
>+char2 operator.xx(char2 v) {
>+    char2 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    return result;
>+}
>+char2 operator.xx(char3 v) {
>+    char2 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    return result;
>+}
>+char2 operator.xx(char4 v) {
>+    char2 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    return result;
>+}
>+short2 operator.xx(short2 v) {
>+    short2 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    return result;
>+}
>+short2 operator.xx(short3 v) {
>+    short2 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    return result;
>+}
>+short2 operator.xx(short4 v) {
>+    short2 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    return result;
>+}
>+int2 operator.xx(int2 v) {
>+    int2 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    return result;
>+}
>+int2 operator.xx(int3 v) {
>+    int2 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    return result;
>+}
>+int2 operator.xx(int4 v) {
>+    int2 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    return result;
>+}
>+half2 operator.xx(half2 v) {
>+    half2 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    return result;
>+}
>+half2 operator.xx(half3 v) {
>+    half2 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    return result;
>+}
>+half2 operator.xx(half4 v) {
>+    half2 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    return result;
>+}
>+float2 operator.xx(float2 v) {
>+    float2 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    return result;
>+}
>+float2 operator.xx(float3 v) {
>+    float2 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    return result;
>+}
>+float2 operator.xx(float4 v) {
>+    float2 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    return result;
>+}
>+
>+/* Functions named operator.wzyw */
>+bool4 operator.wzyw(bool4 v) {
>+    bool4 result;
>+    result.x = v.w;
>+    result.y = v.z;
>+    result.z = v.y;
>+    result.w = v.w;
>+    return result;
>+}
>+uchar4 operator.wzyw(uchar4 v) {
>+    uchar4 result;
>+    result.x = v.w;
>+    result.y = v.z;
>+    result.z = v.y;
>+    result.w = v.w;
>+    return result;
>+}
>+ushort4 operator.wzyw(ushort4 v) {
>+    ushort4 result;
>+    result.x = v.w;
>+    result.y = v.z;
>+    result.z = v.y;
>+    result.w = v.w;
>+    return result;
>+}
>+uint4 operator.wzyw(uint4 v) {
>+    uint4 result;
>+    result.x = v.w;
>+    result.y = v.z;
>+    result.z = v.y;
>+    result.w = v.w;
>+    return result;
>+}
>+char4 operator.wzyw(char4 v) {
>+    char4 result;
>+    result.x = v.w;
>+    result.y = v.z;
>+    result.z = v.y;
>+    result.w = v.w;
>+    return result;
>+}
>+short4 operator.wzyw(short4 v) {
>+    short4 result;
>+    result.x = v.w;
>+    result.y = v.z;
>+    result.z = v.y;
>+    result.w = v.w;
>+    return result;
>+}
>+int4 operator.wzyw(int4 v) {
>+    int4 result;
>+    result.x = v.w;
>+    result.y = v.z;
>+    result.z = v.y;
>+    result.w = v.w;
>+    return result;
>+}
>+half4 operator.wzyw(half4 v) {
>+    half4 result;
>+    result.x = v.w;
>+    result.y = v.z;
>+    result.z = v.y;
>+    result.w = v.w;
>+    return result;
>+}
>+float4 operator.wzyw(float4 v) {
>+    float4 result;
>+    result.x = v.w;
>+    result.y = v.z;
>+    result.z = v.y;
>+    result.w = v.w;
>+    return result;
>+}
>+
>+/* Functions named operator.zxzy */
>+bool4 operator.zxzy(bool3 v) {
>+    bool4 result;
>+    result.x = v.z;
>+    result.y = v.x;
>+    result.z = v.z;
>+    result.w = v.y;
>+    return result;
>+}
>+bool4 operator.zxzy(bool4 v) {
>+    bool4 result;
>+    result.x = v.z;
>+    result.y = v.x;
>+    result.z = v.z;
>+    result.w = v.y;
>+    return result;
>+}
>+uchar4 operator.zxzy(uchar3 v) {
>+    uchar4 result;
>+    result.x = v.z;
>+    result.y = v.x;
>+    result.z = v.z;
>+    result.w = v.y;
>+    return result;
>+}
>+uchar4 operator.zxzy(uchar4 v) {
>+    uchar4 result;
>+    result.x = v.z;
>+    result.y = v.x;
>+    result.z = v.z;
>+    result.w = v.y;
>+    return result;
>+}
>+ushort4 operator.zxzy(ushort3 v) {
>+    ushort4 result;
>+    result.x = v.z;
>+    result.y = v.x;
>+    result.z = v.z;
>+    result.w = v.y;
>+    return result;
>+}
>+ushort4 operator.zxzy(ushort4 v) {
>+    ushort4 result;
>+    result.x = v.z;
>+    result.y = v.x;
>+    result.z = v.z;
>+    result.w = v.y;
>+    return result;
>+}
>+uint4 operator.zxzy(uint3 v) {
>+    uint4 result;
>+    result.x = v.z;
>+    result.y = v.x;
>+    result.z = v.z;
>+    result.w = v.y;
>+    return result;
>+}
>+uint4 operator.zxzy(uint4 v) {
>+    uint4 result;
>+    result.x = v.z;
>+    result.y = v.x;
>+    result.z = v.z;
>+    result.w = v.y;
>+    return result;
>+}
>+char4 operator.zxzy(char3 v) {
>+    char4 result;
>+    result.x = v.z;
>+    result.y = v.x;
>+    result.z = v.z;
>+    result.w = v.y;
>+    return result;
>+}
>+char4 operator.zxzy(char4 v) {
>+    char4 result;
>+    result.x = v.z;
>+    result.y = v.x;
>+    result.z = v.z;
>+    result.w = v.y;
>+    return result;
>+}
>+short4 operator.zxzy(short3 v) {
>+    short4 result;
>+    result.x = v.z;
>+    result.y = v.x;
>+    result.z = v.z;
>+    result.w = v.y;
>+    return result;
>+}
>+short4 operator.zxzy(short4 v) {
>+    short4 result;
>+    result.x = v.z;
>+    result.y = v.x;
>+    result.z = v.z;
>+    result.w = v.y;
>+    return result;
>+}
>+int4 operator.zxzy(int3 v) {
>+    int4 result;
>+    result.x = v.z;
>+    result.y = v.x;
>+    result.z = v.z;
>+    result.w = v.y;
>+    return result;
>+}
>+int4 operator.zxzy(int4 v) {
>+    int4 result;
>+    result.x = v.z;
>+    result.y = v.x;
>+    result.z = v.z;
>+    result.w = v.y;
>+    return result;
>+}
>+half4 operator.zxzy(half3 v) {
>+    half4 result;
>+    result.x = v.z;
>+    result.y = v.x;
>+    result.z = v.z;
>+    result.w = v.y;
>+    return result;
>+}
>+half4 operator.zxzy(half4 v) {
>+    half4 result;
>+    result.x = v.z;
>+    result.y = v.x;
>+    result.z = v.z;
>+    result.w = v.y;
>+    return result;
>+}
>+float4 operator.zxzy(float3 v) {
>+    float4 result;
>+    result.x = v.z;
>+    result.y = v.x;
>+    result.z = v.z;
>+    result.w = v.y;
>+    return result;
>+}
>+float4 operator.zxzy(float4 v) {
>+    float4 result;
>+    result.x = v.z;
>+    result.y = v.x;
>+    result.z = v.z;
>+    result.w = v.y;
>+    return result;
>+}
>+
>+/* Functions named operator.zwxx */
>+bool4 operator.zwxx(bool4 v) {
>+    bool4 result;
>+    result.x = v.z;
>+    result.y = v.w;
>+    result.z = v.x;
>+    result.w = v.x;
>+    return result;
>+}
>+uchar4 operator.zwxx(uchar4 v) {
>+    uchar4 result;
>+    result.x = v.z;
>+    result.y = v.w;
>+    result.z = v.x;
>+    result.w = v.x;
>+    return result;
>+}
>+ushort4 operator.zwxx(ushort4 v) {
>+    ushort4 result;
>+    result.x = v.z;
>+    result.y = v.w;
>+    result.z = v.x;
>+    result.w = v.x;
>+    return result;
>+}
>+uint4 operator.zwxx(uint4 v) {
>+    uint4 result;
>+    result.x = v.z;
>+    result.y = v.w;
>+    result.z = v.x;
>+    result.w = v.x;
>+    return result;
>+}
>+char4 operator.zwxx(char4 v) {
>+    char4 result;
>+    result.x = v.z;
>+    result.y = v.w;
>+    result.z = v.x;
>+    result.w = v.x;
>+    return result;
>+}
>+short4 operator.zwxx(short4 v) {
>+    short4 result;
>+    result.x = v.z;
>+    result.y = v.w;
>+    result.z = v.x;
>+    result.w = v.x;
>+    return result;
>+}
>+int4 operator.zwxx(int4 v) {
>+    int4 result;
>+    result.x = v.z;
>+    result.y = v.w;
>+    result.z = v.x;
>+    result.w = v.x;
>+    return result;
>+}
>+half4 operator.zwxx(half4 v) {
>+    half4 result;
>+    result.x = v.z;
>+    result.y = v.w;
>+    result.z = v.x;
>+    result.w = v.x;
>+    return result;
>+}
>+float4 operator.zwxx(float4 v) {
>+    float4 result;
>+    result.x = v.z;
>+    result.y = v.w;
>+    result.z = v.x;
>+    result.w = v.x;
>+    return result;
>+}
>+
>+/* Functions named rsqrt */
>+half rsqrt(half x) {
>+    return 1 / sqrt(x);
>+}
>+half2 rsqrt(half2 x) {
>+    half2 result;
>+    result[0] = rsqrt(x[0]);
>+    result[1] = rsqrt(x[1]);
>+    return result;
>+}
>+half3 rsqrt(half3 x) {
>+    half3 result;
>+    result[0] = rsqrt(x[0]);
>+    result[1] = rsqrt(x[1]);
>+    result[2] = rsqrt(x[2]);
>+    return result;
>+}
>+half4 rsqrt(half4 x) {
>+    half4 result;
>+    result[0] = rsqrt(x[0]);
>+    result[1] = rsqrt(x[1]);
>+    result[2] = rsqrt(x[2]);
>+    result[3] = rsqrt(x[3]);
>+    return result;
>+}
>+half2x2 rsqrt(half2x2 x) {
>+    half2x2 result;
>+    result[0][0] = rsqrt(x[0][0]);
>+    result[0][1] = rsqrt(x[0][1]);
>+    result[1][0] = rsqrt(x[1][0]);
>+    result[1][1] = rsqrt(x[1][1]);
>+    return result;
>+}
>+half2x3 rsqrt(half2x3 x) {
>+    half2x3 result;
>+    result[0][0] = rsqrt(x[0][0]);
>+    result[0][1] = rsqrt(x[0][1]);
>+    result[0][2] = rsqrt(x[0][2]);
>+    result[1][0] = rsqrt(x[1][0]);
>+    result[1][1] = rsqrt(x[1][1]);
>+    result[1][2] = rsqrt(x[1][2]);
>+    return result;
>+}
>+half2x4 rsqrt(half2x4 x) {
>+    half2x4 result;
>+    result[0][0] = rsqrt(x[0][0]);
>+    result[0][1] = rsqrt(x[0][1]);
>+    result[0][2] = rsqrt(x[0][2]);
>+    result[0][3] = rsqrt(x[0][3]);
>+    result[1][0] = rsqrt(x[1][0]);
>+    result[1][1] = rsqrt(x[1][1]);
>+    result[1][2] = rsqrt(x[1][2]);
>+    result[1][3] = rsqrt(x[1][3]);
>+    return result;
>+}
>+half3x2 rsqrt(half3x2 x) {
>+    half3x2 result;
>+    result[0][0] = rsqrt(x[0][0]);
>+    result[0][1] = rsqrt(x[0][1]);
>+    result[1][0] = rsqrt(x[1][0]);
>+    result[1][1] = rsqrt(x[1][1]);
>+    result[2][0] = rsqrt(x[2][0]);
>+    result[2][1] = rsqrt(x[2][1]);
>+    return result;
>+}
>+half3x3 rsqrt(half3x3 x) {
>+    half3x3 result;
>+    result[0][0] = rsqrt(x[0][0]);
>+    result[0][1] = rsqrt(x[0][1]);
>+    result[0][2] = rsqrt(x[0][2]);
>+    result[1][0] = rsqrt(x[1][0]);
>+    result[1][1] = rsqrt(x[1][1]);
>+    result[1][2] = rsqrt(x[1][2]);
>+    result[2][0] = rsqrt(x[2][0]);
>+    result[2][1] = rsqrt(x[2][1]);
>+    result[2][2] = rsqrt(x[2][2]);
>+    return result;
>+}
>+half3x4 rsqrt(half3x4 x) {
>+    half3x4 result;
>+    result[0][0] = rsqrt(x[0][0]);
>+    result[0][1] = rsqrt(x[0][1]);
>+    result[0][2] = rsqrt(x[0][2]);
>+    result[0][3] = rsqrt(x[0][3]);
>+    result[1][0] = rsqrt(x[1][0]);
>+    result[1][1] = rsqrt(x[1][1]);
>+    result[1][2] = rsqrt(x[1][2]);
>+    result[1][3] = rsqrt(x[1][3]);
>+    result[2][0] = rsqrt(x[2][0]);
>+    result[2][1] = rsqrt(x[2][1]);
>+    result[2][2] = rsqrt(x[2][2]);
>+    result[2][3] = rsqrt(x[2][3]);
>+    return result;
>+}
>+half4x2 rsqrt(half4x2 x) {
>+    half4x2 result;
>+    result[0][0] = rsqrt(x[0][0]);
>+    result[0][1] = rsqrt(x[0][1]);
>+    result[1][0] = rsqrt(x[1][0]);
>+    result[1][1] = rsqrt(x[1][1]);
>+    result[2][0] = rsqrt(x[2][0]);
>+    result[2][1] = rsqrt(x[2][1]);
>+    result[3][0] = rsqrt(x[3][0]);
>+    result[3][1] = rsqrt(x[3][1]);
>+    return result;
>+}
>+half4x3 rsqrt(half4x3 x) {
>+    half4x3 result;
>+    result[0][0] = rsqrt(x[0][0]);
>+    result[0][1] = rsqrt(x[0][1]);
>+    result[0][2] = rsqrt(x[0][2]);
>+    result[1][0] = rsqrt(x[1][0]);
>+    result[1][1] = rsqrt(x[1][1]);
>+    result[1][2] = rsqrt(x[1][2]);
>+    result[2][0] = rsqrt(x[2][0]);
>+    result[2][1] = rsqrt(x[2][1]);
>+    result[2][2] = rsqrt(x[2][2]);
>+    result[3][0] = rsqrt(x[3][0]);
>+    result[3][1] = rsqrt(x[3][1]);
>+    result[3][2] = rsqrt(x[3][2]);
>+    return result;
>+}
>+half4x4 rsqrt(half4x4 x) {
>+    half4x4 result;
>+    result[0][0] = rsqrt(x[0][0]);
>+    result[0][1] = rsqrt(x[0][1]);
>+    result[0][2] = rsqrt(x[0][2]);
>+    result[0][3] = rsqrt(x[0][3]);
>+    result[1][0] = rsqrt(x[1][0]);
>+    result[1][1] = rsqrt(x[1][1]);
>+    result[1][2] = rsqrt(x[1][2]);
>+    result[1][3] = rsqrt(x[1][3]);
>+    result[2][0] = rsqrt(x[2][0]);
>+    result[2][1] = rsqrt(x[2][1]);
>+    result[2][2] = rsqrt(x[2][2]);
>+    result[2][3] = rsqrt(x[2][3]);
>+    result[3][0] = rsqrt(x[3][0]);
>+    result[3][1] = rsqrt(x[3][1]);
>+    result[3][2] = rsqrt(x[3][2]);
>+    result[3][3] = rsqrt(x[3][3]);
>+    return result;
>+}
>+float rsqrt(float x) {
>+    return 1 / sqrt(x);
>+}
>+float2 rsqrt(float2 x) {
>+    float2 result;
>+    result[0] = rsqrt(x[0]);
>+    result[1] = rsqrt(x[1]);
>+    return result;
>+}
>+float3 rsqrt(float3 x) {
>+    float3 result;
>+    result[0] = rsqrt(x[0]);
>+    result[1] = rsqrt(x[1]);
>+    result[2] = rsqrt(x[2]);
>+    return result;
>+}
>+float4 rsqrt(float4 x) {
>+    float4 result;
>+    result[0] = rsqrt(x[0]);
>+    result[1] = rsqrt(x[1]);
>+    result[2] = rsqrt(x[2]);
>+    result[3] = rsqrt(x[3]);
>+    return result;
>+}
>+float2x2 rsqrt(float2x2 x) {
>+    float2x2 result;
>+    result[0][0] = rsqrt(x[0][0]);
>+    result[0][1] = rsqrt(x[0][1]);
>+    result[1][0] = rsqrt(x[1][0]);
>+    result[1][1] = rsqrt(x[1][1]);
>+    return result;
>+}
>+float2x3 rsqrt(float2x3 x) {
>+    float2x3 result;
>+    result[0][0] = rsqrt(x[0][0]);
>+    result[0][1] = rsqrt(x[0][1]);
>+    result[0][2] = rsqrt(x[0][2]);
>+    result[1][0] = rsqrt(x[1][0]);
>+    result[1][1] = rsqrt(x[1][1]);
>+    result[1][2] = rsqrt(x[1][2]);
>+    return result;
>+}
>+float2x4 rsqrt(float2x4 x) {
>+    float2x4 result;
>+    result[0][0] = rsqrt(x[0][0]);
>+    result[0][1] = rsqrt(x[0][1]);
>+    result[0][2] = rsqrt(x[0][2]);
>+    result[0][3] = rsqrt(x[0][3]);
>+    result[1][0] = rsqrt(x[1][0]);
>+    result[1][1] = rsqrt(x[1][1]);
>+    result[1][2] = rsqrt(x[1][2]);
>+    result[1][3] = rsqrt(x[1][3]);
>+    return result;
>+}
>+float3x2 rsqrt(float3x2 x) {
>+    float3x2 result;
>+    result[0][0] = rsqrt(x[0][0]);
>+    result[0][1] = rsqrt(x[0][1]);
>+    result[1][0] = rsqrt(x[1][0]);
>+    result[1][1] = rsqrt(x[1][1]);
>+    result[2][0] = rsqrt(x[2][0]);
>+    result[2][1] = rsqrt(x[2][1]);
>+    return result;
>+}
>+float3x3 rsqrt(float3x3 x) {
>+    float3x3 result;
>+    result[0][0] = rsqrt(x[0][0]);
>+    result[0][1] = rsqrt(x[0][1]);
>+    result[0][2] = rsqrt(x[0][2]);
>+    result[1][0] = rsqrt(x[1][0]);
>+    result[1][1] = rsqrt(x[1][1]);
>+    result[1][2] = rsqrt(x[1][2]);
>+    result[2][0] = rsqrt(x[2][0]);
>+    result[2][1] = rsqrt(x[2][1]);
>+    result[2][2] = rsqrt(x[2][2]);
>+    return result;
>+}
>+float3x4 rsqrt(float3x4 x) {
>+    float3x4 result;
>+    result[0][0] = rsqrt(x[0][0]);
>+    result[0][1] = rsqrt(x[0][1]);
>+    result[0][2] = rsqrt(x[0][2]);
>+    result[0][3] = rsqrt(x[0][3]);
>+    result[1][0] = rsqrt(x[1][0]);
>+    result[1][1] = rsqrt(x[1][1]);
>+    result[1][2] = rsqrt(x[1][2]);
>+    result[1][3] = rsqrt(x[1][3]);
>+    result[2][0] = rsqrt(x[2][0]);
>+    result[2][1] = rsqrt(x[2][1]);
>+    result[2][2] = rsqrt(x[2][2]);
>+    result[2][3] = rsqrt(x[2][3]);
>+    return result;
>+}
>+float4x2 rsqrt(float4x2 x) {
>+    float4x2 result;
>+    result[0][0] = rsqrt(x[0][0]);
>+    result[0][1] = rsqrt(x[0][1]);
>+    result[1][0] = rsqrt(x[1][0]);
>+    result[1][1] = rsqrt(x[1][1]);
>+    result[2][0] = rsqrt(x[2][0]);
>+    result[2][1] = rsqrt(x[2][1]);
>+    result[3][0] = rsqrt(x[3][0]);
>+    result[3][1] = rsqrt(x[3][1]);
>+    return result;
>+}
>+float4x3 rsqrt(float4x3 x) {
>+    float4x3 result;
>+    result[0][0] = rsqrt(x[0][0]);
>+    result[0][1] = rsqrt(x[0][1]);
>+    result[0][2] = rsqrt(x[0][2]);
>+    result[1][0] = rsqrt(x[1][0]);
>+    result[1][1] = rsqrt(x[1][1]);
>+    result[1][2] = rsqrt(x[1][2]);
>+    result[2][0] = rsqrt(x[2][0]);
>+    result[2][1] = rsqrt(x[2][1]);
>+    result[2][2] = rsqrt(x[2][2]);
>+    result[3][0] = rsqrt(x[3][0]);
>+    result[3][1] = rsqrt(x[3][1]);
>+    result[3][2] = rsqrt(x[3][2]);
>+    return result;
>+}
>+float4x4 rsqrt(float4x4 x) {
>+    float4x4 result;
>+    result[0][0] = rsqrt(x[0][0]);
>+    result[0][1] = rsqrt(x[0][1]);
>+    result[0][2] = rsqrt(x[0][2]);
>+    result[0][3] = rsqrt(x[0][3]);
>+    result[1][0] = rsqrt(x[1][0]);
>+    result[1][1] = rsqrt(x[1][1]);
>+    result[1][2] = rsqrt(x[1][2]);
>+    result[1][3] = rsqrt(x[1][3]);
>+    result[2][0] = rsqrt(x[2][0]);
>+    result[2][1] = rsqrt(x[2][1]);
>+    result[2][2] = rsqrt(x[2][2]);
>+    result[2][3] = rsqrt(x[2][3]);
>+    result[3][0] = rsqrt(x[3][0]);
>+    result[3][1] = rsqrt(x[3][1]);
>+    result[3][2] = rsqrt(x[3][2]);
>+    result[3][3] = rsqrt(x[3][3]);
>+    return result;
>+}
>+
>+/* Functions named operator.z */
>+native bool operator.z(bool3);
>+native bool operator.z(bool4);
>+native uchar operator.z(uchar3);
>+native uchar operator.z(uchar4);
>+native ushort operator.z(ushort3);
>+native ushort operator.z(ushort4);
>+native uint operator.z(uint3);
>+native uint operator.z(uint4);
>+native char operator.z(char3);
>+native char operator.z(char4);
>+native short operator.z(short3);
>+native short operator.z(short4);
>+native int operator.z(int3);
>+native int operator.z(int4);
>+native half operator.z(half3);
>+native half operator.z(half4);
>+native float operator.z(float3);
>+native float operator.z(float4);
>+
>+/* Functions named operator.wzyx= */
>+bool4 operator.wzyx=(bool4 v, bool4 c) {
>+    bool4 result = v;
>+    result.w = c.x;
>+    result.z = c.y;
>+    result.y = c.z;
>+    result.x = c.w;
>+    return result;
>+}
>+uchar4 operator.wzyx=(uchar4 v, uchar4 c) {
>+    uchar4 result = v;
>+    result.w = c.x;
>+    result.z = c.y;
>+    result.y = c.z;
>+    result.x = c.w;
>+    return result;
>+}
>+ushort4 operator.wzyx=(ushort4 v, ushort4 c) {
>+    ushort4 result = v;
>+    result.w = c.x;
>+    result.z = c.y;
>+    result.y = c.z;
>+    result.x = c.w;
>+    return result;
>+}
>+uint4 operator.wzyx=(uint4 v, uint4 c) {
>+    uint4 result = v;
>+    result.w = c.x;
>+    result.z = c.y;
>+    result.y = c.z;
>+    result.x = c.w;
>+    return result;
>+}
>+char4 operator.wzyx=(char4 v, char4 c) {
>+    char4 result = v;
>+    result.w = c.x;
>+    result.z = c.y;
>+    result.y = c.z;
>+    result.x = c.w;
>+    return result;
>+}
>+short4 operator.wzyx=(short4 v, short4 c) {
>+    short4 result = v;
>+    result.w = c.x;
>+    result.z = c.y;
>+    result.y = c.z;
>+    result.x = c.w;
>+    return result;
>+}
>+int4 operator.wzyx=(int4 v, int4 c) {
>+    int4 result = v;
>+    result.w = c.x;
>+    result.z = c.y;
>+    result.y = c.z;
>+    result.x = c.w;
>+    return result;
>+}
>+half4 operator.wzyx=(half4 v, half4 c) {
>+    half4 result = v;
>+    result.w = c.x;
>+    result.z = c.y;
>+    result.y = c.z;
>+    result.x = c.w;
>+    return result;
>+}
>+float4 operator.wzyx=(float4 v, float4 c) {
>+    float4 result = v;
>+    result.w = c.x;
>+    result.z = c.y;
>+    result.y = c.z;
>+    result.x = c.w;
>+    return result;
>+}
>+
>+/* Functions named operator.yyxw */
>+bool4 operator.yyxw(bool4 v) {
>+    bool4 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.x;
>+    result.w = v.w;
>+    return result;
>+}
>+uchar4 operator.yyxw(uchar4 v) {
>+    uchar4 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.x;
>+    result.w = v.w;
>+    return result;
>+}
>+ushort4 operator.yyxw(ushort4 v) {
>+    ushort4 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.x;
>+    result.w = v.w;
>+    return result;
>+}
>+uint4 operator.yyxw(uint4 v) {
>+    uint4 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.x;
>+    result.w = v.w;
>+    return result;
>+}
>+char4 operator.yyxw(char4 v) {
>+    char4 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.x;
>+    result.w = v.w;
>+    return result;
>+}
>+short4 operator.yyxw(short4 v) {
>+    short4 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.x;
>+    result.w = v.w;
>+    return result;
>+}
>+int4 operator.yyxw(int4 v) {
>+    int4 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.x;
>+    result.w = v.w;
>+    return result;
>+}
>+half4 operator.yyxw(half4 v) {
>+    half4 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.x;
>+    result.w = v.w;
>+    return result;
>+}
>+float4 operator.yyxw(float4 v) {
>+    float4 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.x;
>+    result.w = v.w;
>+    return result;
>+}
>+
>+/* Functions named operator.zwz */
>+bool3 operator.zwz(bool4 v) {
>+    bool3 result;
>+    result.x = v.z;
>+    result.y = v.w;
>+    result.z = v.z;
>+    return result;
>+}
>+uchar3 operator.zwz(uchar4 v) {
>+    uchar3 result;
>+    result.x = v.z;
>+    result.y = v.w;
>+    result.z = v.z;
>+    return result;
>+}
>+ushort3 operator.zwz(ushort4 v) {
>+    ushort3 result;
>+    result.x = v.z;
>+    result.y = v.w;
>+    result.z = v.z;
>+    return result;
>+}
>+uint3 operator.zwz(uint4 v) {
>+    uint3 result;
>+    result.x = v.z;
>+    result.y = v.w;
>+    result.z = v.z;
>+    return result;
>+}
>+char3 operator.zwz(char4 v) {
>+    char3 result;
>+    result.x = v.z;
>+    result.y = v.w;
>+    result.z = v.z;
>+    return result;
>+}
>+short3 operator.zwz(short4 v) {
>+    short3 result;
>+    result.x = v.z;
>+    result.y = v.w;
>+    result.z = v.z;
>+    return result;
>+}
>+int3 operator.zwz(int4 v) {
>+    int3 result;
>+    result.x = v.z;
>+    result.y = v.w;
>+    result.z = v.z;
>+    return result;
>+}
>+half3 operator.zwz(half4 v) {
>+    half3 result;
>+    result.x = v.z;
>+    result.y = v.w;
>+    result.z = v.z;
>+    return result;
>+}
>+float3 operator.zwz(float4 v) {
>+    float3 result;
>+    result.x = v.z;
>+    result.y = v.w;
>+    result.z = v.z;
>+    return result;
>+}
>+
>+/* Functions named operator.zywz */
>+bool4 operator.zywz(bool4 v) {
>+    bool4 result;
>+    result.x = v.z;
>+    result.y = v.y;
>+    result.z = v.w;
>+    result.w = v.z;
>+    return result;
>+}
>+uchar4 operator.zywz(uchar4 v) {
>+    uchar4 result;
>+    result.x = v.z;
>+    result.y = v.y;
>+    result.z = v.w;
>+    result.w = v.z;
>+    return result;
>+}
>+ushort4 operator.zywz(ushort4 v) {
>+    ushort4 result;
>+    result.x = v.z;
>+    result.y = v.y;
>+    result.z = v.w;
>+    result.w = v.z;
>+    return result;
>+}
>+uint4 operator.zywz(uint4 v) {
>+    uint4 result;
>+    result.x = v.z;
>+    result.y = v.y;
>+    result.z = v.w;
>+    result.w = v.z;
>+    return result;
>+}
>+char4 operator.zywz(char4 v) {
>+    char4 result;
>+    result.x = v.z;
>+    result.y = v.y;
>+    result.z = v.w;
>+    result.w = v.z;
>+    return result;
>+}
>+short4 operator.zywz(short4 v) {
>+    short4 result;
>+    result.x = v.z;
>+    result.y = v.y;
>+    result.z = v.w;
>+    result.w = v.z;
>+    return result;
>+}
>+int4 operator.zywz(int4 v) {
>+    int4 result;
>+    result.x = v.z;
>+    result.y = v.y;
>+    result.z = v.w;
>+    result.w = v.z;
>+    return result;
>+}
>+half4 operator.zywz(half4 v) {
>+    half4 result;
>+    result.x = v.z;
>+    result.y = v.y;
>+    result.z = v.w;
>+    result.w = v.z;
>+    return result;
>+}
>+float4 operator.zywz(float4 v) {
>+    float4 result;
>+    result.x = v.z;
>+    result.y = v.y;
>+    result.z = v.w;
>+    result.w = v.z;
>+    return result;
>+}
>+
>+/* Functions named operator.zyww */
>+bool4 operator.zyww(bool4 v) {
>+    bool4 result;
>+    result.x = v.z;
>+    result.y = v.y;
>+    result.z = v.w;
>+    result.w = v.w;
>+    return result;
>+}
>+uchar4 operator.zyww(uchar4 v) {
>+    uchar4 result;
>+    result.x = v.z;
>+    result.y = v.y;
>+    result.z = v.w;
>+    result.w = v.w;
>+    return result;
>+}
>+ushort4 operator.zyww(ushort4 v) {
>+    ushort4 result;
>+    result.x = v.z;
>+    result.y = v.y;
>+    result.z = v.w;
>+    result.w = v.w;
>+    return result;
>+}
>+uint4 operator.zyww(uint4 v) {
>+    uint4 result;
>+    result.x = v.z;
>+    result.y = v.y;
>+    result.z = v.w;
>+    result.w = v.w;
>+    return result;
>+}
>+char4 operator.zyww(char4 v) {
>+    char4 result;
>+    result.x = v.z;
>+    result.y = v.y;
>+    result.z = v.w;
>+    result.w = v.w;
>+    return result;
>+}
>+short4 operator.zyww(short4 v) {
>+    short4 result;
>+    result.x = v.z;
>+    result.y = v.y;
>+    result.z = v.w;
>+    result.w = v.w;
>+    return result;
>+}
>+int4 operator.zyww(int4 v) {
>+    int4 result;
>+    result.x = v.z;
>+    result.y = v.y;
>+    result.z = v.w;
>+    result.w = v.w;
>+    return result;
>+}
>+half4 operator.zyww(half4 v) {
>+    half4 result;
>+    result.x = v.z;
>+    result.y = v.y;
>+    result.z = v.w;
>+    result.w = v.w;
>+    return result;
>+}
>+float4 operator.zyww(float4 v) {
>+    float4 result;
>+    result.x = v.z;
>+    result.y = v.y;
>+    result.z = v.w;
>+    result.w = v.w;
>+    return result;
>+}
>+
>+/* Functions named operator.xwz= */
>+bool4 operator.xwz=(bool4 v, bool3 c) {
>+    bool4 result = v;
>+    result.x = c.x;
>+    result.w = c.y;
>+    result.z = c.z;
>+    return result;
>+}
>+uchar4 operator.xwz=(uchar4 v, uchar3 c) {
>+    uchar4 result = v;
>+    result.x = c.x;
>+    result.w = c.y;
>+    result.z = c.z;
>+    return result;
>+}
>+ushort4 operator.xwz=(ushort4 v, ushort3 c) {
>+    ushort4 result = v;
>+    result.x = c.x;
>+    result.w = c.y;
>+    result.z = c.z;
>+    return result;
>+}
>+uint4 operator.xwz=(uint4 v, uint3 c) {
>+    uint4 result = v;
>+    result.x = c.x;
>+    result.w = c.y;
>+    result.z = c.z;
>+    return result;
>+}
>+char4 operator.xwz=(char4 v, char3 c) {
>+    char4 result = v;
>+    result.x = c.x;
>+    result.w = c.y;
>+    result.z = c.z;
>+    return result;
>+}
>+short4 operator.xwz=(short4 v, short3 c) {
>+    short4 result = v;
>+    result.x = c.x;
>+    result.w = c.y;
>+    result.z = c.z;
>+    return result;
>+}
>+int4 operator.xwz=(int4 v, int3 c) {
>+    int4 result = v;
>+    result.x = c.x;
>+    result.w = c.y;
>+    result.z = c.z;
>+    return result;
>+}
>+half4 operator.xwz=(half4 v, half3 c) {
>+    half4 result = v;
>+    result.x = c.x;
>+    result.w = c.y;
>+    result.z = c.z;
>+    return result;
>+}
>+float4 operator.xwz=(float4 v, float3 c) {
>+    float4 result = v;
>+    result.x = c.x;
>+    result.w = c.y;
>+    result.z = c.z;
>+    return result;
>+}
>+
>+/* Functions named operator.xyxw */
>+bool4 operator.xyxw(bool4 v) {
>+    bool4 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.x;
>+    result.w = v.w;
>+    return result;
>+}
>+uchar4 operator.xyxw(uchar4 v) {
>+    uchar4 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.x;
>+    result.w = v.w;
>+    return result;
>+}
>+ushort4 operator.xyxw(ushort4 v) {
>+    ushort4 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.x;
>+    result.w = v.w;
>+    return result;
>+}
>+uint4 operator.xyxw(uint4 v) {
>+    uint4 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.x;
>+    result.w = v.w;
>+    return result;
>+}
>+char4 operator.xyxw(char4 v) {
>+    char4 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.x;
>+    result.w = v.w;
>+    return result;
>+}
>+short4 operator.xyxw(short4 v) {
>+    short4 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.x;
>+    result.w = v.w;
>+    return result;
>+}
>+int4 operator.xyxw(int4 v) {
>+    int4 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.x;
>+    result.w = v.w;
>+    return result;
>+}
>+half4 operator.xyxw(half4 v) {
>+    half4 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.x;
>+    result.w = v.w;
>+    return result;
>+}
>+float4 operator.xyxw(float4 v) {
>+    float4 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.x;
>+    result.w = v.w;
>+    return result;
>+}
>+
>+/* Functions named operator.wzy= */
>+bool4 operator.wzy=(bool4 v, bool3 c) {
>+    bool4 result = v;
>+    result.w = c.x;
>+    result.z = c.y;
>+    result.y = c.z;
>+    return result;
>+}
>+uchar4 operator.wzy=(uchar4 v, uchar3 c) {
>+    uchar4 result = v;
>+    result.w = c.x;
>+    result.z = c.y;
>+    result.y = c.z;
>+    return result;
>+}
>+ushort4 operator.wzy=(ushort4 v, ushort3 c) {
>+    ushort4 result = v;
>+    result.w = c.x;
>+    result.z = c.y;
>+    result.y = c.z;
>+    return result;
>+}
>+uint4 operator.wzy=(uint4 v, uint3 c) {
>+    uint4 result = v;
>+    result.w = c.x;
>+    result.z = c.y;
>+    result.y = c.z;
>+    return result;
>+}
>+char4 operator.wzy=(char4 v, char3 c) {
>+    char4 result = v;
>+    result.w = c.x;
>+    result.z = c.y;
>+    result.y = c.z;
>+    return result;
>+}
>+short4 operator.wzy=(short4 v, short3 c) {
>+    short4 result = v;
>+    result.w = c.x;
>+    result.z = c.y;
>+    result.y = c.z;
>+    return result;
>+}
>+int4 operator.wzy=(int4 v, int3 c) {
>+    int4 result = v;
>+    result.w = c.x;
>+    result.z = c.y;
>+    result.y = c.z;
>+    return result;
>+}
>+half4 operator.wzy=(half4 v, half3 c) {
>+    half4 result = v;
>+    result.w = c.x;
>+    result.z = c.y;
>+    result.y = c.z;
>+    return result;
>+}
>+float4 operator.wzy=(float4 v, float3 c) {
>+    float4 result = v;
>+    result.w = c.x;
>+    result.z = c.y;
>+    result.y = c.z;
>+    return result;
>+}
>+
>+/* Functions named operator.xxzx */
>+bool4 operator.xxzx(bool3 v) {
>+    bool4 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.z;
>+    result.w = v.x;
>+    return result;
>+}
>+bool4 operator.xxzx(bool4 v) {
>+    bool4 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.z;
>+    result.w = v.x;
>+    return result;
>+}
>+uchar4 operator.xxzx(uchar3 v) {
>+    uchar4 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.z;
>+    result.w = v.x;
>+    return result;
>+}
>+uchar4 operator.xxzx(uchar4 v) {
>+    uchar4 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.z;
>+    result.w = v.x;
>+    return result;
>+}
>+ushort4 operator.xxzx(ushort3 v) {
>+    ushort4 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.z;
>+    result.w = v.x;
>+    return result;
>+}
>+ushort4 operator.xxzx(ushort4 v) {
>+    ushort4 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.z;
>+    result.w = v.x;
>+    return result;
>+}
>+uint4 operator.xxzx(uint3 v) {
>+    uint4 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.z;
>+    result.w = v.x;
>+    return result;
>+}
>+uint4 operator.xxzx(uint4 v) {
>+    uint4 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.z;
>+    result.w = v.x;
>+    return result;
>+}
>+char4 operator.xxzx(char3 v) {
>+    char4 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.z;
>+    result.w = v.x;
>+    return result;
>+}
>+char4 operator.xxzx(char4 v) {
>+    char4 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.z;
>+    result.w = v.x;
>+    return result;
>+}
>+short4 operator.xxzx(short3 v) {
>+    short4 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.z;
>+    result.w = v.x;
>+    return result;
>+}
>+short4 operator.xxzx(short4 v) {
>+    short4 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.z;
>+    result.w = v.x;
>+    return result;
>+}
>+int4 operator.xxzx(int3 v) {
>+    int4 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.z;
>+    result.w = v.x;
>+    return result;
>+}
>+int4 operator.xxzx(int4 v) {
>+    int4 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.z;
>+    result.w = v.x;
>+    return result;
>+}
>+half4 operator.xxzx(half3 v) {
>+    half4 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.z;
>+    result.w = v.x;
>+    return result;
>+}
>+half4 operator.xxzx(half4 v) {
>+    half4 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.z;
>+    result.w = v.x;
>+    return result;
>+}
>+float4 operator.xxzx(float3 v) {
>+    float4 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.z;
>+    result.w = v.x;
>+    return result;
>+}
>+float4 operator.xxzx(float4 v) {
>+    float4 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.z;
>+    result.w = v.x;
>+    return result;
>+}
>+
>+/* Functions named operator.ywxz */
>+bool4 operator.ywxz(bool4 v) {
>+    bool4 result;
>+    result.x = v.y;
>+    result.y = v.w;
>+    result.z = v.x;
>+    result.w = v.z;
>+    return result;
>+}
>+uchar4 operator.ywxz(uchar4 v) {
>+    uchar4 result;
>+    result.x = v.y;
>+    result.y = v.w;
>+    result.z = v.x;
>+    result.w = v.z;
>+    return result;
>+}
>+ushort4 operator.ywxz(ushort4 v) {
>+    ushort4 result;
>+    result.x = v.y;
>+    result.y = v.w;
>+    result.z = v.x;
>+    result.w = v.z;
>+    return result;
>+}
>+uint4 operator.ywxz(uint4 v) {
>+    uint4 result;
>+    result.x = v.y;
>+    result.y = v.w;
>+    result.z = v.x;
>+    result.w = v.z;
>+    return result;
>+}
>+char4 operator.ywxz(char4 v) {
>+    char4 result;
>+    result.x = v.y;
>+    result.y = v.w;
>+    result.z = v.x;
>+    result.w = v.z;
>+    return result;
>+}
>+short4 operator.ywxz(short4 v) {
>+    short4 result;
>+    result.x = v.y;
>+    result.y = v.w;
>+    result.z = v.x;
>+    result.w = v.z;
>+    return result;
>+}
>+int4 operator.ywxz(int4 v) {
>+    int4 result;
>+    result.x = v.y;
>+    result.y = v.w;
>+    result.z = v.x;
>+    result.w = v.z;
>+    return result;
>+}
>+half4 operator.ywxz(half4 v) {
>+    half4 result;
>+    result.x = v.y;
>+    result.y = v.w;
>+    result.z = v.x;
>+    result.w = v.z;
>+    return result;
>+}
>+float4 operator.ywxz(float4 v) {
>+    float4 result;
>+    result.x = v.y;
>+    result.y = v.w;
>+    result.z = v.x;
>+    result.w = v.z;
>+    return result;
>+}
>+
>+/* Functions named operator.xyxz */
>+bool4 operator.xyxz(bool3 v) {
>+    bool4 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.x;
>+    result.w = v.z;
>+    return result;
>+}
>+bool4 operator.xyxz(bool4 v) {
>+    bool4 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.x;
>+    result.w = v.z;
>+    return result;
>+}
>+uchar4 operator.xyxz(uchar3 v) {
>+    uchar4 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.x;
>+    result.w = v.z;
>+    return result;
>+}
>+uchar4 operator.xyxz(uchar4 v) {
>+    uchar4 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.x;
>+    result.w = v.z;
>+    return result;
>+}
>+ushort4 operator.xyxz(ushort3 v) {
>+    ushort4 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.x;
>+    result.w = v.z;
>+    return result;
>+}
>+ushort4 operator.xyxz(ushort4 v) {
>+    ushort4 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.x;
>+    result.w = v.z;
>+    return result;
>+}
>+uint4 operator.xyxz(uint3 v) {
>+    uint4 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.x;
>+    result.w = v.z;
>+    return result;
>+}
>+uint4 operator.xyxz(uint4 v) {
>+    uint4 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.x;
>+    result.w = v.z;
>+    return result;
>+}
>+char4 operator.xyxz(char3 v) {
>+    char4 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.x;
>+    result.w = v.z;
>+    return result;
>+}
>+char4 operator.xyxz(char4 v) {
>+    char4 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.x;
>+    result.w = v.z;
>+    return result;
>+}
>+short4 operator.xyxz(short3 v) {
>+    short4 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.x;
>+    result.w = v.z;
>+    return result;
>+}
>+short4 operator.xyxz(short4 v) {
>+    short4 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.x;
>+    result.w = v.z;
>+    return result;
>+}
>+int4 operator.xyxz(int3 v) {
>+    int4 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.x;
>+    result.w = v.z;
>+    return result;
>+}
>+int4 operator.xyxz(int4 v) {
>+    int4 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.x;
>+    result.w = v.z;
>+    return result;
>+}
>+half4 operator.xyxz(half3 v) {
>+    half4 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.x;
>+    result.w = v.z;
>+    return result;
>+}
>+half4 operator.xyxz(half4 v) {
>+    half4 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.x;
>+    result.w = v.z;
>+    return result;
>+}
>+float4 operator.xyxz(float3 v) {
>+    float4 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.x;
>+    result.w = v.z;
>+    return result;
>+}
>+float4 operator.xyxz(float4 v) {
>+    float4 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.x;
>+    result.w = v.z;
>+    return result;
>+}
>+
>+/* Functions named sqrt */
>+half sqrt(half x) {
>+    return pow(x, 0.5);
>+}
>+half2 sqrt(half2 x) {
>+    half2 result;
>+    result[0] = sqrt(x[0]);
>+    result[1] = sqrt(x[1]);
>+    return result;
>+}
>+half3 sqrt(half3 x) {
>+    half3 result;
>+    result[0] = sqrt(x[0]);
>+    result[1] = sqrt(x[1]);
>+    result[2] = sqrt(x[2]);
>+    return result;
>+}
>+half4 sqrt(half4 x) {
>+    half4 result;
>+    result[0] = sqrt(x[0]);
>+    result[1] = sqrt(x[1]);
>+    result[2] = sqrt(x[2]);
>+    result[3] = sqrt(x[3]);
>+    return result;
>+}
>+half2x2 sqrt(half2x2 x) {
>+    half2x2 result;
>+    result[0][0] = sqrt(x[0][0]);
>+    result[0][1] = sqrt(x[0][1]);
>+    result[1][0] = sqrt(x[1][0]);
>+    result[1][1] = sqrt(x[1][1]);
>+    return result;
>+}
>+half2x3 sqrt(half2x3 x) {
>+    half2x3 result;
>+    result[0][0] = sqrt(x[0][0]);
>+    result[0][1] = sqrt(x[0][1]);
>+    result[0][2] = sqrt(x[0][2]);
>+    result[1][0] = sqrt(x[1][0]);
>+    result[1][1] = sqrt(x[1][1]);
>+    result[1][2] = sqrt(x[1][2]);
>+    return result;
>+}
>+half2x4 sqrt(half2x4 x) {
>+    half2x4 result;
>+    result[0][0] = sqrt(x[0][0]);
>+    result[0][1] = sqrt(x[0][1]);
>+    result[0][2] = sqrt(x[0][2]);
>+    result[0][3] = sqrt(x[0][3]);
>+    result[1][0] = sqrt(x[1][0]);
>+    result[1][1] = sqrt(x[1][1]);
>+    result[1][2] = sqrt(x[1][2]);
>+    result[1][3] = sqrt(x[1][3]);
>+    return result;
>+}
>+half3x2 sqrt(half3x2 x) {
>+    half3x2 result;
>+    result[0][0] = sqrt(x[0][0]);
>+    result[0][1] = sqrt(x[0][1]);
>+    result[1][0] = sqrt(x[1][0]);
>+    result[1][1] = sqrt(x[1][1]);
>+    result[2][0] = sqrt(x[2][0]);
>+    result[2][1] = sqrt(x[2][1]);
>+    return result;
>+}
>+half3x3 sqrt(half3x3 x) {
>+    half3x3 result;
>+    result[0][0] = sqrt(x[0][0]);
>+    result[0][1] = sqrt(x[0][1]);
>+    result[0][2] = sqrt(x[0][2]);
>+    result[1][0] = sqrt(x[1][0]);
>+    result[1][1] = sqrt(x[1][1]);
>+    result[1][2] = sqrt(x[1][2]);
>+    result[2][0] = sqrt(x[2][0]);
>+    result[2][1] = sqrt(x[2][1]);
>+    result[2][2] = sqrt(x[2][2]);
>+    return result;
>+}
>+half3x4 sqrt(half3x4 x) {
>+    half3x4 result;
>+    result[0][0] = sqrt(x[0][0]);
>+    result[0][1] = sqrt(x[0][1]);
>+    result[0][2] = sqrt(x[0][2]);
>+    result[0][3] = sqrt(x[0][3]);
>+    result[1][0] = sqrt(x[1][0]);
>+    result[1][1] = sqrt(x[1][1]);
>+    result[1][2] = sqrt(x[1][2]);
>+    result[1][3] = sqrt(x[1][3]);
>+    result[2][0] = sqrt(x[2][0]);
>+    result[2][1] = sqrt(x[2][1]);
>+    result[2][2] = sqrt(x[2][2]);
>+    result[2][3] = sqrt(x[2][3]);
>+    return result;
>+}
>+half4x2 sqrt(half4x2 x) {
>+    half4x2 result;
>+    result[0][0] = sqrt(x[0][0]);
>+    result[0][1] = sqrt(x[0][1]);
>+    result[1][0] = sqrt(x[1][0]);
>+    result[1][1] = sqrt(x[1][1]);
>+    result[2][0] = sqrt(x[2][0]);
>+    result[2][1] = sqrt(x[2][1]);
>+    result[3][0] = sqrt(x[3][0]);
>+    result[3][1] = sqrt(x[3][1]);
>+    return result;
>+}
>+half4x3 sqrt(half4x3 x) {
>+    half4x3 result;
>+    result[0][0] = sqrt(x[0][0]);
>+    result[0][1] = sqrt(x[0][1]);
>+    result[0][2] = sqrt(x[0][2]);
>+    result[1][0] = sqrt(x[1][0]);
>+    result[1][1] = sqrt(x[1][1]);
>+    result[1][2] = sqrt(x[1][2]);
>+    result[2][0] = sqrt(x[2][0]);
>+    result[2][1] = sqrt(x[2][1]);
>+    result[2][2] = sqrt(x[2][2]);
>+    result[3][0] = sqrt(x[3][0]);
>+    result[3][1] = sqrt(x[3][1]);
>+    result[3][2] = sqrt(x[3][2]);
>+    return result;
>+}
>+half4x4 sqrt(half4x4 x) {
>+    half4x4 result;
>+    result[0][0] = sqrt(x[0][0]);
>+    result[0][1] = sqrt(x[0][1]);
>+    result[0][2] = sqrt(x[0][2]);
>+    result[0][3] = sqrt(x[0][3]);
>+    result[1][0] = sqrt(x[1][0]);
>+    result[1][1] = sqrt(x[1][1]);
>+    result[1][2] = sqrt(x[1][2]);
>+    result[1][3] = sqrt(x[1][3]);
>+    result[2][0] = sqrt(x[2][0]);
>+    result[2][1] = sqrt(x[2][1]);
>+    result[2][2] = sqrt(x[2][2]);
>+    result[2][3] = sqrt(x[2][3]);
>+    result[3][0] = sqrt(x[3][0]);
>+    result[3][1] = sqrt(x[3][1]);
>+    result[3][2] = sqrt(x[3][2]);
>+    result[3][3] = sqrt(x[3][3]);
>+    return result;
>+}
>+float sqrt(float x) {
>+    return pow(x, 0.5);
>+}
>+float2 sqrt(float2 x) {
>+    float2 result;
>+    result[0] = sqrt(x[0]);
>+    result[1] = sqrt(x[1]);
>+    return result;
>+}
>+float3 sqrt(float3 x) {
>+    float3 result;
>+    result[0] = sqrt(x[0]);
>+    result[1] = sqrt(x[1]);
>+    result[2] = sqrt(x[2]);
>+    return result;
>+}
>+float4 sqrt(float4 x) {
>+    float4 result;
>+    result[0] = sqrt(x[0]);
>+    result[1] = sqrt(x[1]);
>+    result[2] = sqrt(x[2]);
>+    result[3] = sqrt(x[3]);
>+    return result;
>+}
>+float2x2 sqrt(float2x2 x) {
>+    float2x2 result;
>+    result[0][0] = sqrt(x[0][0]);
>+    result[0][1] = sqrt(x[0][1]);
>+    result[1][0] = sqrt(x[1][0]);
>+    result[1][1] = sqrt(x[1][1]);
>+    return result;
>+}
>+float2x3 sqrt(float2x3 x) {
>+    float2x3 result;
>+    result[0][0] = sqrt(x[0][0]);
>+    result[0][1] = sqrt(x[0][1]);
>+    result[0][2] = sqrt(x[0][2]);
>+    result[1][0] = sqrt(x[1][0]);
>+    result[1][1] = sqrt(x[1][1]);
>+    result[1][2] = sqrt(x[1][2]);
>+    return result;
>+}
>+float2x4 sqrt(float2x4 x) {
>+    float2x4 result;
>+    result[0][0] = sqrt(x[0][0]);
>+    result[0][1] = sqrt(x[0][1]);
>+    result[0][2] = sqrt(x[0][2]);
>+    result[0][3] = sqrt(x[0][3]);
>+    result[1][0] = sqrt(x[1][0]);
>+    result[1][1] = sqrt(x[1][1]);
>+    result[1][2] = sqrt(x[1][2]);
>+    result[1][3] = sqrt(x[1][3]);
>+    return result;
>+}
>+float3x2 sqrt(float3x2 x) {
>+    float3x2 result;
>+    result[0][0] = sqrt(x[0][0]);
>+    result[0][1] = sqrt(x[0][1]);
>+    result[1][0] = sqrt(x[1][0]);
>+    result[1][1] = sqrt(x[1][1]);
>+    result[2][0] = sqrt(x[2][0]);
>+    result[2][1] = sqrt(x[2][1]);
>+    return result;
>+}
>+float3x3 sqrt(float3x3 x) {
>+    float3x3 result;
>+    result[0][0] = sqrt(x[0][0]);
>+    result[0][1] = sqrt(x[0][1]);
>+    result[0][2] = sqrt(x[0][2]);
>+    result[1][0] = sqrt(x[1][0]);
>+    result[1][1] = sqrt(x[1][1]);
>+    result[1][2] = sqrt(x[1][2]);
>+    result[2][0] = sqrt(x[2][0]);
>+    result[2][1] = sqrt(x[2][1]);
>+    result[2][2] = sqrt(x[2][2]);
>+    return result;
>+}
>+float3x4 sqrt(float3x4 x) {
>+    float3x4 result;
>+    result[0][0] = sqrt(x[0][0]);
>+    result[0][1] = sqrt(x[0][1]);
>+    result[0][2] = sqrt(x[0][2]);
>+    result[0][3] = sqrt(x[0][3]);
>+    result[1][0] = sqrt(x[1][0]);
>+    result[1][1] = sqrt(x[1][1]);
>+    result[1][2] = sqrt(x[1][2]);
>+    result[1][3] = sqrt(x[1][3]);
>+    result[2][0] = sqrt(x[2][0]);
>+    result[2][1] = sqrt(x[2][1]);
>+    result[2][2] = sqrt(x[2][2]);
>+    result[2][3] = sqrt(x[2][3]);
>+    return result;
>+}
>+float4x2 sqrt(float4x2 x) {
>+    float4x2 result;
>+    result[0][0] = sqrt(x[0][0]);
>+    result[0][1] = sqrt(x[0][1]);
>+    result[1][0] = sqrt(x[1][0]);
>+    result[1][1] = sqrt(x[1][1]);
>+    result[2][0] = sqrt(x[2][0]);
>+    result[2][1] = sqrt(x[2][1]);
>+    result[3][0] = sqrt(x[3][0]);
>+    result[3][1] = sqrt(x[3][1]);
>+    return result;
>+}
>+float4x3 sqrt(float4x3 x) {
>+    float4x3 result;
>+    result[0][0] = sqrt(x[0][0]);
>+    result[0][1] = sqrt(x[0][1]);
>+    result[0][2] = sqrt(x[0][2]);
>+    result[1][0] = sqrt(x[1][0]);
>+    result[1][1] = sqrt(x[1][1]);
>+    result[1][2] = sqrt(x[1][2]);
>+    result[2][0] = sqrt(x[2][0]);
>+    result[2][1] = sqrt(x[2][1]);
>+    result[2][2] = sqrt(x[2][2]);
>+    result[3][0] = sqrt(x[3][0]);
>+    result[3][1] = sqrt(x[3][1]);
>+    result[3][2] = sqrt(x[3][2]);
>+    return result;
>+}
>+float4x4 sqrt(float4x4 x) {
>+    float4x4 result;
>+    result[0][0] = sqrt(x[0][0]);
>+    result[0][1] = sqrt(x[0][1]);
>+    result[0][2] = sqrt(x[0][2]);
>+    result[0][3] = sqrt(x[0][3]);
>+    result[1][0] = sqrt(x[1][0]);
>+    result[1][1] = sqrt(x[1][1]);
>+    result[1][2] = sqrt(x[1][2]);
>+    result[1][3] = sqrt(x[1][3]);
>+    result[2][0] = sqrt(x[2][0]);
>+    result[2][1] = sqrt(x[2][1]);
>+    result[2][2] = sqrt(x[2][2]);
>+    result[2][3] = sqrt(x[2][3]);
>+    result[3][0] = sqrt(x[3][0]);
>+    result[3][1] = sqrt(x[3][1]);
>+    result[3][2] = sqrt(x[3][2]);
>+    result[3][3] = sqrt(x[3][3]);
>+    return result;
>+}
>+
>+/* Functions named acos */
>+native float acos(float);
>+half acos(half x) {
>+    return half(acos(float(x)));
>+}
>+half2 acos(half2 x) {
>+    half2 result;
>+    result[0] = acos(x[0]);
>+    result[1] = acos(x[1]);
>+    return result;
>+}
>+half3 acos(half3 x) {
>+    half3 result;
>+    result[0] = acos(x[0]);
>+    result[1] = acos(x[1]);
>+    result[2] = acos(x[2]);
>+    return result;
>+}
>+half4 acos(half4 x) {
>+    half4 result;
>+    result[0] = acos(x[0]);
>+    result[1] = acos(x[1]);
>+    result[2] = acos(x[2]);
>+    result[3] = acos(x[3]);
>+    return result;
>+}
>+half2x2 acos(half2x2 x) {
>+    half2x2 result;
>+    result[0][0] = acos(x[0][0]);
>+    result[0][1] = acos(x[0][1]);
>+    result[1][0] = acos(x[1][0]);
>+    result[1][1] = acos(x[1][1]);
>+    return result;
>+}
>+half2x3 acos(half2x3 x) {
>+    half2x3 result;
>+    result[0][0] = acos(x[0][0]);
>+    result[0][1] = acos(x[0][1]);
>+    result[0][2] = acos(x[0][2]);
>+    result[1][0] = acos(x[1][0]);
>+    result[1][1] = acos(x[1][1]);
>+    result[1][2] = acos(x[1][2]);
>+    return result;
>+}
>+half2x4 acos(half2x4 x) {
>+    half2x4 result;
>+    result[0][0] = acos(x[0][0]);
>+    result[0][1] = acos(x[0][1]);
>+    result[0][2] = acos(x[0][2]);
>+    result[0][3] = acos(x[0][3]);
>+    result[1][0] = acos(x[1][0]);
>+    result[1][1] = acos(x[1][1]);
>+    result[1][2] = acos(x[1][2]);
>+    result[1][3] = acos(x[1][3]);
>+    return result;
>+}
>+half3x2 acos(half3x2 x) {
>+    half3x2 result;
>+    result[0][0] = acos(x[0][0]);
>+    result[0][1] = acos(x[0][1]);
>+    result[1][0] = acos(x[1][0]);
>+    result[1][1] = acos(x[1][1]);
>+    result[2][0] = acos(x[2][0]);
>+    result[2][1] = acos(x[2][1]);
>+    return result;
>+}
>+half3x3 acos(half3x3 x) {
>+    half3x3 result;
>+    result[0][0] = acos(x[0][0]);
>+    result[0][1] = acos(x[0][1]);
>+    result[0][2] = acos(x[0][2]);
>+    result[1][0] = acos(x[1][0]);
>+    result[1][1] = acos(x[1][1]);
>+    result[1][2] = acos(x[1][2]);
>+    result[2][0] = acos(x[2][0]);
>+    result[2][1] = acos(x[2][1]);
>+    result[2][2] = acos(x[2][2]);
>+    return result;
>+}
>+half3x4 acos(half3x4 x) {
>+    half3x4 result;
>+    result[0][0] = acos(x[0][0]);
>+    result[0][1] = acos(x[0][1]);
>+    result[0][2] = acos(x[0][2]);
>+    result[0][3] = acos(x[0][3]);
>+    result[1][0] = acos(x[1][0]);
>+    result[1][1] = acos(x[1][1]);
>+    result[1][2] = acos(x[1][2]);
>+    result[1][3] = acos(x[1][3]);
>+    result[2][0] = acos(x[2][0]);
>+    result[2][1] = acos(x[2][1]);
>+    result[2][2] = acos(x[2][2]);
>+    result[2][3] = acos(x[2][3]);
>+    return result;
>+}
>+half4x2 acos(half4x2 x) {
>+    half4x2 result;
>+    result[0][0] = acos(x[0][0]);
>+    result[0][1] = acos(x[0][1]);
>+    result[1][0] = acos(x[1][0]);
>+    result[1][1] = acos(x[1][1]);
>+    result[2][0] = acos(x[2][0]);
>+    result[2][1] = acos(x[2][1]);
>+    result[3][0] = acos(x[3][0]);
>+    result[3][1] = acos(x[3][1]);
>+    return result;
>+}
>+half4x3 acos(half4x3 x) {
>+    half4x3 result;
>+    result[0][0] = acos(x[0][0]);
>+    result[0][1] = acos(x[0][1]);
>+    result[0][2] = acos(x[0][2]);
>+    result[1][0] = acos(x[1][0]);
>+    result[1][1] = acos(x[1][1]);
>+    result[1][2] = acos(x[1][2]);
>+    result[2][0] = acos(x[2][0]);
>+    result[2][1] = acos(x[2][1]);
>+    result[2][2] = acos(x[2][2]);
>+    result[3][0] = acos(x[3][0]);
>+    result[3][1] = acos(x[3][1]);
>+    result[3][2] = acos(x[3][2]);
>+    return result;
>+}
>+half4x4 acos(half4x4 x) {
>+    half4x4 result;
>+    result[0][0] = acos(x[0][0]);
>+    result[0][1] = acos(x[0][1]);
>+    result[0][2] = acos(x[0][2]);
>+    result[0][3] = acos(x[0][3]);
>+    result[1][0] = acos(x[1][0]);
>+    result[1][1] = acos(x[1][1]);
>+    result[1][2] = acos(x[1][2]);
>+    result[1][3] = acos(x[1][3]);
>+    result[2][0] = acos(x[2][0]);
>+    result[2][1] = acos(x[2][1]);
>+    result[2][2] = acos(x[2][2]);
>+    result[2][3] = acos(x[2][3]);
>+    result[3][0] = acos(x[3][0]);
>+    result[3][1] = acos(x[3][1]);
>+    result[3][2] = acos(x[3][2]);
>+    result[3][3] = acos(x[3][3]);
>+    return result;
>+}
>+float2 acos(float2 x) {
>+    float2 result;
>+    result[0] = acos(x[0]);
>+    result[1] = acos(x[1]);
>+    return result;
>+}
>+float3 acos(float3 x) {
>+    float3 result;
>+    result[0] = acos(x[0]);
>+    result[1] = acos(x[1]);
>+    result[2] = acos(x[2]);
>+    return result;
>+}
>+float4 acos(float4 x) {
>+    float4 result;
>+    result[0] = acos(x[0]);
>+    result[1] = acos(x[1]);
>+    result[2] = acos(x[2]);
>+    result[3] = acos(x[3]);
>+    return result;
>+}
>+float2x2 acos(float2x2 x) {
>+    float2x2 result;
>+    result[0][0] = acos(x[0][0]);
>+    result[0][1] = acos(x[0][1]);
>+    result[1][0] = acos(x[1][0]);
>+    result[1][1] = acos(x[1][1]);
>+    return result;
>+}
>+float2x3 acos(float2x3 x) {
>+    float2x3 result;
>+    result[0][0] = acos(x[0][0]);
>+    result[0][1] = acos(x[0][1]);
>+    result[0][2] = acos(x[0][2]);
>+    result[1][0] = acos(x[1][0]);
>+    result[1][1] = acos(x[1][1]);
>+    result[1][2] = acos(x[1][2]);
>+    return result;
>+}
>+float2x4 acos(float2x4 x) {
>+    float2x4 result;
>+    result[0][0] = acos(x[0][0]);
>+    result[0][1] = acos(x[0][1]);
>+    result[0][2] = acos(x[0][2]);
>+    result[0][3] = acos(x[0][3]);
>+    result[1][0] = acos(x[1][0]);
>+    result[1][1] = acos(x[1][1]);
>+    result[1][2] = acos(x[1][2]);
>+    result[1][3] = acos(x[1][3]);
>+    return result;
>+}
>+float3x2 acos(float3x2 x) {
>+    float3x2 result;
>+    result[0][0] = acos(x[0][0]);
>+    result[0][1] = acos(x[0][1]);
>+    result[1][0] = acos(x[1][0]);
>+    result[1][1] = acos(x[1][1]);
>+    result[2][0] = acos(x[2][0]);
>+    result[2][1] = acos(x[2][1]);
>+    return result;
>+}
>+float3x3 acos(float3x3 x) {
>+    float3x3 result;
>+    result[0][0] = acos(x[0][0]);
>+    result[0][1] = acos(x[0][1]);
>+    result[0][2] = acos(x[0][2]);
>+    result[1][0] = acos(x[1][0]);
>+    result[1][1] = acos(x[1][1]);
>+    result[1][2] = acos(x[1][2]);
>+    result[2][0] = acos(x[2][0]);
>+    result[2][1] = acos(x[2][1]);
>+    result[2][2] = acos(x[2][2]);
>+    return result;
>+}
>+float3x4 acos(float3x4 x) {
>+    float3x4 result;
>+    result[0][0] = acos(x[0][0]);
>+    result[0][1] = acos(x[0][1]);
>+    result[0][2] = acos(x[0][2]);
>+    result[0][3] = acos(x[0][3]);
>+    result[1][0] = acos(x[1][0]);
>+    result[1][1] = acos(x[1][1]);
>+    result[1][2] = acos(x[1][2]);
>+    result[1][3] = acos(x[1][3]);
>+    result[2][0] = acos(x[2][0]);
>+    result[2][1] = acos(x[2][1]);
>+    result[2][2] = acos(x[2][2]);
>+    result[2][3] = acos(x[2][3]);
>+    return result;
>+}
>+float4x2 acos(float4x2 x) {
>+    float4x2 result;
>+    result[0][0] = acos(x[0][0]);
>+    result[0][1] = acos(x[0][1]);
>+    result[1][0] = acos(x[1][0]);
>+    result[1][1] = acos(x[1][1]);
>+    result[2][0] = acos(x[2][0]);
>+    result[2][1] = acos(x[2][1]);
>+    result[3][0] = acos(x[3][0]);
>+    result[3][1] = acos(x[3][1]);
>+    return result;
>+}
>+float4x3 acos(float4x3 x) {
>+    float4x3 result;
>+    result[0][0] = acos(x[0][0]);
>+    result[0][1] = acos(x[0][1]);
>+    result[0][2] = acos(x[0][2]);
>+    result[1][0] = acos(x[1][0]);
>+    result[1][1] = acos(x[1][1]);
>+    result[1][2] = acos(x[1][2]);
>+    result[2][0] = acos(x[2][0]);
>+    result[2][1] = acos(x[2][1]);
>+    result[2][2] = acos(x[2][2]);
>+    result[3][0] = acos(x[3][0]);
>+    result[3][1] = acos(x[3][1]);
>+    result[3][2] = acos(x[3][2]);
>+    return result;
>+}
>+float4x4 acos(float4x4 x) {
>+    float4x4 result;
>+    result[0][0] = acos(x[0][0]);
>+    result[0][1] = acos(x[0][1]);
>+    result[0][2] = acos(x[0][2]);
>+    result[0][3] = acos(x[0][3]);
>+    result[1][0] = acos(x[1][0]);
>+    result[1][1] = acos(x[1][1]);
>+    result[1][2] = acos(x[1][2]);
>+    result[1][3] = acos(x[1][3]);
>+    result[2][0] = acos(x[2][0]);
>+    result[2][1] = acos(x[2][1]);
>+    result[2][2] = acos(x[2][2]);
>+    result[2][3] = acos(x[2][3]);
>+    result[3][0] = acos(x[3][0]);
>+    result[3][1] = acos(x[3][1]);
>+    result[3][2] = acos(x[3][2]);
>+    result[3][3] = acos(x[3][3]);
>+    return result;
>+}
>+
>+/* Functions named operator.xyww */
>+bool4 operator.xyww(bool4 v) {
>+    bool4 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.w;
>+    result.w = v.w;
>+    return result;
>+}
>+uchar4 operator.xyww(uchar4 v) {
>+    uchar4 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.w;
>+    result.w = v.w;
>+    return result;
>+}
>+ushort4 operator.xyww(ushort4 v) {
>+    ushort4 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.w;
>+    result.w = v.w;
>+    return result;
>+}
>+uint4 operator.xyww(uint4 v) {
>+    uint4 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.w;
>+    result.w = v.w;
>+    return result;
>+}
>+char4 operator.xyww(char4 v) {
>+    char4 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.w;
>+    result.w = v.w;
>+    return result;
>+}
>+short4 operator.xyww(short4 v) {
>+    short4 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.w;
>+    result.w = v.w;
>+    return result;
>+}
>+int4 operator.xyww(int4 v) {
>+    int4 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.w;
>+    result.w = v.w;
>+    return result;
>+}
>+half4 operator.xyww(half4 v) {
>+    half4 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.w;
>+    result.w = v.w;
>+    return result;
>+}
>+float4 operator.xyww(float4 v) {
>+    float4 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.w;
>+    result.w = v.w;
>+    return result;
>+}
>+
>+/* Functions named operator> */
>+native bool operator>(int, int);
>+native bool operator>(uint, uint);
>+native bool operator>(float, float);
>+bool operator>(uchar a, uchar b) {
>+    return uint(a) > uint(b);
>+}
>+bool operator>(ushort a, ushort b) {
>+    return uint(a) > uint(b);
>+}
>+bool operator>(char a, char b) {
>+    return int(a) > int(b);
>+}
>+bool operator>(short a, short b) {
>+    return int(a) > int(b);
>+}
>+bool operator>(half a, half b) {
>+    return float(a) < float(b);
>+}
>+
>+/* Functions named operator& */
>+bool operator&(bool a, bool b) {
>+    return a && b;
>+}
>+native int operator&(int, int);
>+native uint operator&(uint, uint);
>+uchar operator&(uchar a, uchar b) {
>+    return uchar(uint(a) & uint(b));
>+}
>+ushort operator&(ushort a, ushort b) {
>+    return ushort(uint(a) & uint(b));
>+}
>+char operator&(char a, char b) {
>+    return char(int(a) & int(b));
>+}
>+short operator&(short a, short b) {
>+    return short(int(a) & int(b));
>+}
>+
>+/* Functions named operator.zxyz */
>+bool4 operator.zxyz(bool3 v) {
>+    bool4 result;
>+    result.x = v.z;
>+    result.y = v.x;
>+    result.z = v.y;
>+    result.w = v.z;
>+    return result;
>+}
>+bool4 operator.zxyz(bool4 v) {
>+    bool4 result;
>+    result.x = v.z;
>+    result.y = v.x;
>+    result.z = v.y;
>+    result.w = v.z;
>+    return result;
>+}
>+uchar4 operator.zxyz(uchar3 v) {
>+    uchar4 result;
>+    result.x = v.z;
>+    result.y = v.x;
>+    result.z = v.y;
>+    result.w = v.z;
>+    return result;
>+}
>+uchar4 operator.zxyz(uchar4 v) {
>+    uchar4 result;
>+    result.x = v.z;
>+    result.y = v.x;
>+    result.z = v.y;
>+    result.w = v.z;
>+    return result;
>+}
>+ushort4 operator.zxyz(ushort3 v) {
>+    ushort4 result;
>+    result.x = v.z;
>+    result.y = v.x;
>+    result.z = v.y;
>+    result.w = v.z;
>+    return result;
>+}
>+ushort4 operator.zxyz(ushort4 v) {
>+    ushort4 result;
>+    result.x = v.z;
>+    result.y = v.x;
>+    result.z = v.y;
>+    result.w = v.z;
>+    return result;
>+}
>+uint4 operator.zxyz(uint3 v) {
>+    uint4 result;
>+    result.x = v.z;
>+    result.y = v.x;
>+    result.z = v.y;
>+    result.w = v.z;
>+    return result;
>+}
>+uint4 operator.zxyz(uint4 v) {
>+    uint4 result;
>+    result.x = v.z;
>+    result.y = v.x;
>+    result.z = v.y;
>+    result.w = v.z;
>+    return result;
>+}
>+char4 operator.zxyz(char3 v) {
>+    char4 result;
>+    result.x = v.z;
>+    result.y = v.x;
>+    result.z = v.y;
>+    result.w = v.z;
>+    return result;
>+}
>+char4 operator.zxyz(char4 v) {
>+    char4 result;
>+    result.x = v.z;
>+    result.y = v.x;
>+    result.z = v.y;
>+    result.w = v.z;
>+    return result;
>+}
>+short4 operator.zxyz(short3 v) {
>+    short4 result;
>+    result.x = v.z;
>+    result.y = v.x;
>+    result.z = v.y;
>+    result.w = v.z;
>+    return result;
>+}
>+short4 operator.zxyz(short4 v) {
>+    short4 result;
>+    result.x = v.z;
>+    result.y = v.x;
>+    result.z = v.y;
>+    result.w = v.z;
>+    return result;
>+}
>+int4 operator.zxyz(int3 v) {
>+    int4 result;
>+    result.x = v.z;
>+    result.y = v.x;
>+    result.z = v.y;
>+    result.w = v.z;
>+    return result;
>+}
>+int4 operator.zxyz(int4 v) {
>+    int4 result;
>+    result.x = v.z;
>+    result.y = v.x;
>+    result.z = v.y;
>+    result.w = v.z;
>+    return result;
>+}
>+half4 operator.zxyz(half3 v) {
>+    half4 result;
>+    result.x = v.z;
>+    result.y = v.x;
>+    result.z = v.y;
>+    result.w = v.z;
>+    return result;
>+}
>+half4 operator.zxyz(half4 v) {
>+    half4 result;
>+    result.x = v.z;
>+    result.y = v.x;
>+    result.z = v.y;
>+    result.w = v.z;
>+    return result;
>+}
>+float4 operator.zxyz(float3 v) {
>+    float4 result;
>+    result.x = v.z;
>+    result.y = v.x;
>+    result.z = v.y;
>+    result.w = v.z;
>+    return result;
>+}
>+float4 operator.zxyz(float4 v) {
>+    float4 result;
>+    result.x = v.z;
>+    result.y = v.x;
>+    result.z = v.y;
>+    result.w = v.z;
>+    return result;
>+}
>+
>+/* Functions named operator.zyzy */
>+bool4 operator.zyzy(bool3 v) {
>+    bool4 result;
>+    result.x = v.z;
>+    result.y = v.y;
>+    result.z = v.z;
>+    result.w = v.y;
>+    return result;
>+}
>+bool4 operator.zyzy(bool4 v) {
>+    bool4 result;
>+    result.x = v.z;
>+    result.y = v.y;
>+    result.z = v.z;
>+    result.w = v.y;
>+    return result;
>+}
>+uchar4 operator.zyzy(uchar3 v) {
>+    uchar4 result;
>+    result.x = v.z;
>+    result.y = v.y;
>+    result.z = v.z;
>+    result.w = v.y;
>+    return result;
>+}
>+uchar4 operator.zyzy(uchar4 v) {
>+    uchar4 result;
>+    result.x = v.z;
>+    result.y = v.y;
>+    result.z = v.z;
>+    result.w = v.y;
>+    return result;
>+}
>+ushort4 operator.zyzy(ushort3 v) {
>+    ushort4 result;
>+    result.x = v.z;
>+    result.y = v.y;
>+    result.z = v.z;
>+    result.w = v.y;
>+    return result;
>+}
>+ushort4 operator.zyzy(ushort4 v) {
>+    ushort4 result;
>+    result.x = v.z;
>+    result.y = v.y;
>+    result.z = v.z;
>+    result.w = v.y;
>+    return result;
>+}
>+uint4 operator.zyzy(uint3 v) {
>+    uint4 result;
>+    result.x = v.z;
>+    result.y = v.y;
>+    result.z = v.z;
>+    result.w = v.y;
>+    return result;
>+}
>+uint4 operator.zyzy(uint4 v) {
>+    uint4 result;
>+    result.x = v.z;
>+    result.y = v.y;
>+    result.z = v.z;
>+    result.w = v.y;
>+    return result;
>+}
>+char4 operator.zyzy(char3 v) {
>+    char4 result;
>+    result.x = v.z;
>+    result.y = v.y;
>+    result.z = v.z;
>+    result.w = v.y;
>+    return result;
>+}
>+char4 operator.zyzy(char4 v) {
>+    char4 result;
>+    result.x = v.z;
>+    result.y = v.y;
>+    result.z = v.z;
>+    result.w = v.y;
>+    return result;
>+}
>+short4 operator.zyzy(short3 v) {
>+    short4 result;
>+    result.x = v.z;
>+    result.y = v.y;
>+    result.z = v.z;
>+    result.w = v.y;
>+    return result;
>+}
>+short4 operator.zyzy(short4 v) {
>+    short4 result;
>+    result.x = v.z;
>+    result.y = v.y;
>+    result.z = v.z;
>+    result.w = v.y;
>+    return result;
>+}
>+int4 operator.zyzy(int3 v) {
>+    int4 result;
>+    result.x = v.z;
>+    result.y = v.y;
>+    result.z = v.z;
>+    result.w = v.y;
>+    return result;
>+}
>+int4 operator.zyzy(int4 v) {
>+    int4 result;
>+    result.x = v.z;
>+    result.y = v.y;
>+    result.z = v.z;
>+    result.w = v.y;
>+    return result;
>+}
>+half4 operator.zyzy(half3 v) {
>+    half4 result;
>+    result.x = v.z;
>+    result.y = v.y;
>+    result.z = v.z;
>+    result.w = v.y;
>+    return result;
>+}
>+half4 operator.zyzy(half4 v) {
>+    half4 result;
>+    result.x = v.z;
>+    result.y = v.y;
>+    result.z = v.z;
>+    result.w = v.y;
>+    return result;
>+}
>+float4 operator.zyzy(float3 v) {
>+    float4 result;
>+    result.x = v.z;
>+    result.y = v.y;
>+    result.z = v.z;
>+    result.w = v.y;
>+    return result;
>+}
>+float4 operator.zyzy(float4 v) {
>+    float4 result;
>+    result.x = v.z;
>+    result.y = v.y;
>+    result.z = v.z;
>+    result.w = v.y;
>+    return result;
>+}
>+
>+/* Functions named operator.yxyw */
>+bool4 operator.yxyw(bool4 v) {
>+    bool4 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.y;
>+    result.w = v.w;
>+    return result;
>+}
>+uchar4 operator.yxyw(uchar4 v) {
>+    uchar4 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.y;
>+    result.w = v.w;
>+    return result;
>+}
>+ushort4 operator.yxyw(ushort4 v) {
>+    ushort4 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.y;
>+    result.w = v.w;
>+    return result;
>+}
>+uint4 operator.yxyw(uint4 v) {
>+    uint4 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.y;
>+    result.w = v.w;
>+    return result;
>+}
>+char4 operator.yxyw(char4 v) {
>+    char4 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.y;
>+    result.w = v.w;
>+    return result;
>+}
>+short4 operator.yxyw(short4 v) {
>+    short4 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.y;
>+    result.w = v.w;
>+    return result;
>+}
>+int4 operator.yxyw(int4 v) {
>+    int4 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.y;
>+    result.w = v.w;
>+    return result;
>+}
>+half4 operator.yxyw(half4 v) {
>+    half4 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.y;
>+    result.w = v.w;
>+    return result;
>+}
>+float4 operator.yxyw(float4 v) {
>+    float4 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.y;
>+    result.w = v.w;
>+    return result;
>+}
>+
>+/* Functions named operator.zwxz */
>+bool4 operator.zwxz(bool4 v) {
>+    bool4 result;
>+    result.x = v.z;
>+    result.y = v.w;
>+    result.z = v.x;
>+    result.w = v.z;
>+    return result;
>+}
>+uchar4 operator.zwxz(uchar4 v) {
>+    uchar4 result;
>+    result.x = v.z;
>+    result.y = v.w;
>+    result.z = v.x;
>+    result.w = v.z;
>+    return result;
>+}
>+ushort4 operator.zwxz(ushort4 v) {
>+    ushort4 result;
>+    result.x = v.z;
>+    result.y = v.w;
>+    result.z = v.x;
>+    result.w = v.z;
>+    return result;
>+}
>+uint4 operator.zwxz(uint4 v) {
>+    uint4 result;
>+    result.x = v.z;
>+    result.y = v.w;
>+    result.z = v.x;
>+    result.w = v.z;
>+    return result;
>+}
>+char4 operator.zwxz(char4 v) {
>+    char4 result;
>+    result.x = v.z;
>+    result.y = v.w;
>+    result.z = v.x;
>+    result.w = v.z;
>+    return result;
>+}
>+short4 operator.zwxz(short4 v) {
>+    short4 result;
>+    result.x = v.z;
>+    result.y = v.w;
>+    result.z = v.x;
>+    result.w = v.z;
>+    return result;
>+}
>+int4 operator.zwxz(int4 v) {
>+    int4 result;
>+    result.x = v.z;
>+    result.y = v.w;
>+    result.z = v.x;
>+    result.w = v.z;
>+    return result;
>+}
>+half4 operator.zwxz(half4 v) {
>+    half4 result;
>+    result.x = v.z;
>+    result.y = v.w;
>+    result.z = v.x;
>+    result.w = v.z;
>+    return result;
>+}
>+float4 operator.zwxz(float4 v) {
>+    float4 result;
>+    result.x = v.z;
>+    result.y = v.w;
>+    result.z = v.x;
>+    result.w = v.z;
>+    return result;
>+}
>+
>+/* Functions named operator.wwxy */
>+bool4 operator.wwxy(bool4 v) {
>+    bool4 result;
>+    result.x = v.w;
>+    result.y = v.w;
>+    result.z = v.x;
>+    result.w = v.y;
>+    return result;
>+}
>+uchar4 operator.wwxy(uchar4 v) {
>+    uchar4 result;
>+    result.x = v.w;
>+    result.y = v.w;
>+    result.z = v.x;
>+    result.w = v.y;
>+    return result;
>+}
>+ushort4 operator.wwxy(ushort4 v) {
>+    ushort4 result;
>+    result.x = v.w;
>+    result.y = v.w;
>+    result.z = v.x;
>+    result.w = v.y;
>+    return result;
>+}
>+uint4 operator.wwxy(uint4 v) {
>+    uint4 result;
>+    result.x = v.w;
>+    result.y = v.w;
>+    result.z = v.x;
>+    result.w = v.y;
>+    return result;
>+}
>+char4 operator.wwxy(char4 v) {
>+    char4 result;
>+    result.x = v.w;
>+    result.y = v.w;
>+    result.z = v.x;
>+    result.w = v.y;
>+    return result;
>+}
>+short4 operator.wwxy(short4 v) {
>+    short4 result;
>+    result.x = v.w;
>+    result.y = v.w;
>+    result.z = v.x;
>+    result.w = v.y;
>+    return result;
>+}
>+int4 operator.wwxy(int4 v) {
>+    int4 result;
>+    result.x = v.w;
>+    result.y = v.w;
>+    result.z = v.x;
>+    result.w = v.y;
>+    return result;
>+}
>+half4 operator.wwxy(half4 v) {
>+    half4 result;
>+    result.x = v.w;
>+    result.y = v.w;
>+    result.z = v.x;
>+    result.w = v.y;
>+    return result;
>+}
>+float4 operator.wwxy(float4 v) {
>+    float4 result;
>+    result.x = v.w;
>+    result.y = v.w;
>+    result.z = v.x;
>+    result.w = v.y;
>+    return result;
>+}
>+
>+/* Functions named operator.yx */
>+bool2 operator.yx(bool2 v) {
>+    bool2 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    return result;
>+}
>+bool2 operator.yx(bool3 v) {
>+    bool2 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    return result;
>+}
>+bool2 operator.yx(bool4 v) {
>+    bool2 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    return result;
>+}
>+uchar2 operator.yx(uchar2 v) {
>+    uchar2 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    return result;
>+}
>+uchar2 operator.yx(uchar3 v) {
>+    uchar2 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    return result;
>+}
>+uchar2 operator.yx(uchar4 v) {
>+    uchar2 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    return result;
>+}
>+ushort2 operator.yx(ushort2 v) {
>+    ushort2 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    return result;
>+}
>+ushort2 operator.yx(ushort3 v) {
>+    ushort2 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    return result;
>+}
>+ushort2 operator.yx(ushort4 v) {
>+    ushort2 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    return result;
>+}
>+uint2 operator.yx(uint2 v) {
>+    uint2 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    return result;
>+}
>+uint2 operator.yx(uint3 v) {
>+    uint2 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    return result;
>+}
>+uint2 operator.yx(uint4 v) {
>+    uint2 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    return result;
>+}
>+char2 operator.yx(char2 v) {
>+    char2 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    return result;
>+}
>+char2 operator.yx(char3 v) {
>+    char2 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    return result;
>+}
>+char2 operator.yx(char4 v) {
>+    char2 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    return result;
>+}
>+short2 operator.yx(short2 v) {
>+    short2 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    return result;
>+}
>+short2 operator.yx(short3 v) {
>+    short2 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    return result;
>+}
>+short2 operator.yx(short4 v) {
>+    short2 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    return result;
>+}
>+int2 operator.yx(int2 v) {
>+    int2 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    return result;
>+}
>+int2 operator.yx(int3 v) {
>+    int2 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    return result;
>+}
>+int2 operator.yx(int4 v) {
>+    int2 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    return result;
>+}
>+half2 operator.yx(half2 v) {
>+    half2 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    return result;
>+}
>+half2 operator.yx(half3 v) {
>+    half2 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    return result;
>+}
>+half2 operator.yx(half4 v) {
>+    half2 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    return result;
>+}
>+float2 operator.yx(float2 v) {
>+    float2 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    return result;
>+}
>+float2 operator.yx(float3 v) {
>+    float2 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    return result;
>+}
>+float2 operator.yx(float4 v) {
>+    float2 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    return result;
>+}
>+
>+/* Functions named tanh */
>+native float tanh(float);
>+half tanh(half x) {
>+    return half(tanh(float(x)));
>+}
>+half2 tanh(half2 x) {
>+    half2 result;
>+    result[0] = tanh(x[0]);
>+    result[1] = tanh(x[1]);
>+    return result;
>+}
>+half3 tanh(half3 x) {
>+    half3 result;
>+    result[0] = tanh(x[0]);
>+    result[1] = tanh(x[1]);
>+    result[2] = tanh(x[2]);
>+    return result;
>+}
>+half4 tanh(half4 x) {
>+    half4 result;
>+    result[0] = tanh(x[0]);
>+    result[1] = tanh(x[1]);
>+    result[2] = tanh(x[2]);
>+    result[3] = tanh(x[3]);
>+    return result;
>+}
>+half2x2 tanh(half2x2 x) {
>+    half2x2 result;
>+    result[0][0] = tanh(x[0][0]);
>+    result[0][1] = tanh(x[0][1]);
>+    result[1][0] = tanh(x[1][0]);
>+    result[1][1] = tanh(x[1][1]);
>+    return result;
>+}
>+half2x3 tanh(half2x3 x) {
>+    half2x3 result;
>+    result[0][0] = tanh(x[0][0]);
>+    result[0][1] = tanh(x[0][1]);
>+    result[0][2] = tanh(x[0][2]);
>+    result[1][0] = tanh(x[1][0]);
>+    result[1][1] = tanh(x[1][1]);
>+    result[1][2] = tanh(x[1][2]);
>+    return result;
>+}
>+half2x4 tanh(half2x4 x) {
>+    half2x4 result;
>+    result[0][0] = tanh(x[0][0]);
>+    result[0][1] = tanh(x[0][1]);
>+    result[0][2] = tanh(x[0][2]);
>+    result[0][3] = tanh(x[0][3]);
>+    result[1][0] = tanh(x[1][0]);
>+    result[1][1] = tanh(x[1][1]);
>+    result[1][2] = tanh(x[1][2]);
>+    result[1][3] = tanh(x[1][3]);
>+    return result;
>+}
>+half3x2 tanh(half3x2 x) {
>+    half3x2 result;
>+    result[0][0] = tanh(x[0][0]);
>+    result[0][1] = tanh(x[0][1]);
>+    result[1][0] = tanh(x[1][0]);
>+    result[1][1] = tanh(x[1][1]);
>+    result[2][0] = tanh(x[2][0]);
>+    result[2][1] = tanh(x[2][1]);
>+    return result;
>+}
>+half3x3 tanh(half3x3 x) {
>+    half3x3 result;
>+    result[0][0] = tanh(x[0][0]);
>+    result[0][1] = tanh(x[0][1]);
>+    result[0][2] = tanh(x[0][2]);
>+    result[1][0] = tanh(x[1][0]);
>+    result[1][1] = tanh(x[1][1]);
>+    result[1][2] = tanh(x[1][2]);
>+    result[2][0] = tanh(x[2][0]);
>+    result[2][1] = tanh(x[2][1]);
>+    result[2][2] = tanh(x[2][2]);
>+    return result;
>+}
>+half3x4 tanh(half3x4 x) {
>+    half3x4 result;
>+    result[0][0] = tanh(x[0][0]);
>+    result[0][1] = tanh(x[0][1]);
>+    result[0][2] = tanh(x[0][2]);
>+    result[0][3] = tanh(x[0][3]);
>+    result[1][0] = tanh(x[1][0]);
>+    result[1][1] = tanh(x[1][1]);
>+    result[1][2] = tanh(x[1][2]);
>+    result[1][3] = tanh(x[1][3]);
>+    result[2][0] = tanh(x[2][0]);
>+    result[2][1] = tanh(x[2][1]);
>+    result[2][2] = tanh(x[2][2]);
>+    result[2][3] = tanh(x[2][3]);
>+    return result;
>+}
>+half4x2 tanh(half4x2 x) {
>+    half4x2 result;
>+    result[0][0] = tanh(x[0][0]);
>+    result[0][1] = tanh(x[0][1]);
>+    result[1][0] = tanh(x[1][0]);
>+    result[1][1] = tanh(x[1][1]);
>+    result[2][0] = tanh(x[2][0]);
>+    result[2][1] = tanh(x[2][1]);
>+    result[3][0] = tanh(x[3][0]);
>+    result[3][1] = tanh(x[3][1]);
>+    return result;
>+}
>+half4x3 tanh(half4x3 x) {
>+    half4x3 result;
>+    result[0][0] = tanh(x[0][0]);
>+    result[0][1] = tanh(x[0][1]);
>+    result[0][2] = tanh(x[0][2]);
>+    result[1][0] = tanh(x[1][0]);
>+    result[1][1] = tanh(x[1][1]);
>+    result[1][2] = tanh(x[1][2]);
>+    result[2][0] = tanh(x[2][0]);
>+    result[2][1] = tanh(x[2][1]);
>+    result[2][2] = tanh(x[2][2]);
>+    result[3][0] = tanh(x[3][0]);
>+    result[3][1] = tanh(x[3][1]);
>+    result[3][2] = tanh(x[3][2]);
>+    return result;
>+}
>+half4x4 tanh(half4x4 x) {
>+    half4x4 result;
>+    result[0][0] = tanh(x[0][0]);
>+    result[0][1] = tanh(x[0][1]);
>+    result[0][2] = tanh(x[0][2]);
>+    result[0][3] = tanh(x[0][3]);
>+    result[1][0] = tanh(x[1][0]);
>+    result[1][1] = tanh(x[1][1]);
>+    result[1][2] = tanh(x[1][2]);
>+    result[1][3] = tanh(x[1][3]);
>+    result[2][0] = tanh(x[2][0]);
>+    result[2][1] = tanh(x[2][1]);
>+    result[2][2] = tanh(x[2][2]);
>+    result[2][3] = tanh(x[2][3]);
>+    result[3][0] = tanh(x[3][0]);
>+    result[3][1] = tanh(x[3][1]);
>+    result[3][2] = tanh(x[3][2]);
>+    result[3][3] = tanh(x[3][3]);
>+    return result;
>+}
>+float2 tanh(float2 x) {
>+    float2 result;
>+    result[0] = tanh(x[0]);
>+    result[1] = tanh(x[1]);
>+    return result;
>+}
>+float3 tanh(float3 x) {
>+    float3 result;
>+    result[0] = tanh(x[0]);
>+    result[1] = tanh(x[1]);
>+    result[2] = tanh(x[2]);
>+    return result;
>+}
>+float4 tanh(float4 x) {
>+    float4 result;
>+    result[0] = tanh(x[0]);
>+    result[1] = tanh(x[1]);
>+    result[2] = tanh(x[2]);
>+    result[3] = tanh(x[3]);
>+    return result;
>+}
>+float2x2 tanh(float2x2 x) {
>+    float2x2 result;
>+    result[0][0] = tanh(x[0][0]);
>+    result[0][1] = tanh(x[0][1]);
>+    result[1][0] = tanh(x[1][0]);
>+    result[1][1] = tanh(x[1][1]);
>+    return result;
>+}
>+float2x3 tanh(float2x3 x) {
>+    float2x3 result;
>+    result[0][0] = tanh(x[0][0]);
>+    result[0][1] = tanh(x[0][1]);
>+    result[0][2] = tanh(x[0][2]);
>+    result[1][0] = tanh(x[1][0]);
>+    result[1][1] = tanh(x[1][1]);
>+    result[1][2] = tanh(x[1][2]);
>+    return result;
>+}
>+float2x4 tanh(float2x4 x) {
>+    float2x4 result;
>+    result[0][0] = tanh(x[0][0]);
>+    result[0][1] = tanh(x[0][1]);
>+    result[0][2] = tanh(x[0][2]);
>+    result[0][3] = tanh(x[0][3]);
>+    result[1][0] = tanh(x[1][0]);
>+    result[1][1] = tanh(x[1][1]);
>+    result[1][2] = tanh(x[1][2]);
>+    result[1][3] = tanh(x[1][3]);
>+    return result;
>+}
>+float3x2 tanh(float3x2 x) {
>+    float3x2 result;
>+    result[0][0] = tanh(x[0][0]);
>+    result[0][1] = tanh(x[0][1]);
>+    result[1][0] = tanh(x[1][0]);
>+    result[1][1] = tanh(x[1][1]);
>+    result[2][0] = tanh(x[2][0]);
>+    result[2][1] = tanh(x[2][1]);
>+    return result;
>+}
>+float3x3 tanh(float3x3 x) {
>+    float3x3 result;
>+    result[0][0] = tanh(x[0][0]);
>+    result[0][1] = tanh(x[0][1]);
>+    result[0][2] = tanh(x[0][2]);
>+    result[1][0] = tanh(x[1][0]);
>+    result[1][1] = tanh(x[1][1]);
>+    result[1][2] = tanh(x[1][2]);
>+    result[2][0] = tanh(x[2][0]);
>+    result[2][1] = tanh(x[2][1]);
>+    result[2][2] = tanh(x[2][2]);
>+    return result;
>+}
>+float3x4 tanh(float3x4 x) {
>+    float3x4 result;
>+    result[0][0] = tanh(x[0][0]);
>+    result[0][1] = tanh(x[0][1]);
>+    result[0][2] = tanh(x[0][2]);
>+    result[0][3] = tanh(x[0][3]);
>+    result[1][0] = tanh(x[1][0]);
>+    result[1][1] = tanh(x[1][1]);
>+    result[1][2] = tanh(x[1][2]);
>+    result[1][3] = tanh(x[1][3]);
>+    result[2][0] = tanh(x[2][0]);
>+    result[2][1] = tanh(x[2][1]);
>+    result[2][2] = tanh(x[2][2]);
>+    result[2][3] = tanh(x[2][3]);
>+    return result;
>+}
>+float4x2 tanh(float4x2 x) {
>+    float4x2 result;
>+    result[0][0] = tanh(x[0][0]);
>+    result[0][1] = tanh(x[0][1]);
>+    result[1][0] = tanh(x[1][0]);
>+    result[1][1] = tanh(x[1][1]);
>+    result[2][0] = tanh(x[2][0]);
>+    result[2][1] = tanh(x[2][1]);
>+    result[3][0] = tanh(x[3][0]);
>+    result[3][1] = tanh(x[3][1]);
>+    return result;
>+}
>+float4x3 tanh(float4x3 x) {
>+    float4x3 result;
>+    result[0][0] = tanh(x[0][0]);
>+    result[0][1] = tanh(x[0][1]);
>+    result[0][2] = tanh(x[0][2]);
>+    result[1][0] = tanh(x[1][0]);
>+    result[1][1] = tanh(x[1][1]);
>+    result[1][2] = tanh(x[1][2]);
>+    result[2][0] = tanh(x[2][0]);
>+    result[2][1] = tanh(x[2][1]);
>+    result[2][2] = tanh(x[2][2]);
>+    result[3][0] = tanh(x[3][0]);
>+    result[3][1] = tanh(x[3][1]);
>+    result[3][2] = tanh(x[3][2]);
>+    return result;
>+}
>+float4x4 tanh(float4x4 x) {
>+    float4x4 result;
>+    result[0][0] = tanh(x[0][0]);
>+    result[0][1] = tanh(x[0][1]);
>+    result[0][2] = tanh(x[0][2]);
>+    result[0][3] = tanh(x[0][3]);
>+    result[1][0] = tanh(x[1][0]);
>+    result[1][1] = tanh(x[1][1]);
>+    result[1][2] = tanh(x[1][2]);
>+    result[1][3] = tanh(x[1][3]);
>+    result[2][0] = tanh(x[2][0]);
>+    result[2][1] = tanh(x[2][1]);
>+    result[2][2] = tanh(x[2][2]);
>+    result[2][3] = tanh(x[2][3]);
>+    result[3][0] = tanh(x[3][0]);
>+    result[3][1] = tanh(x[3][1]);
>+    result[3][2] = tanh(x[3][2]);
>+    result[3][3] = tanh(x[3][3]);
>+    return result;
>+}
>+
>+/* Functions named operator.yxz= */
>+bool3 operator.yxz=(bool3 v, bool3 c) {
>+    bool3 result = v;
>+    result.y = c.x;
>+    result.x = c.y;
>+    result.z = c.z;
>+    return result;
>+}
>+bool4 operator.yxz=(bool4 v, bool3 c) {
>+    bool4 result = v;
>+    result.y = c.x;
>+    result.x = c.y;
>+    result.z = c.z;
>+    return result;
>+}
>+uchar3 operator.yxz=(uchar3 v, uchar3 c) {
>+    uchar3 result = v;
>+    result.y = c.x;
>+    result.x = c.y;
>+    result.z = c.z;
>+    return result;
>+}
>+uchar4 operator.yxz=(uchar4 v, uchar3 c) {
>+    uchar4 result = v;
>+    result.y = c.x;
>+    result.x = c.y;
>+    result.z = c.z;
>+    return result;
>+}
>+ushort3 operator.yxz=(ushort3 v, ushort3 c) {
>+    ushort3 result = v;
>+    result.y = c.x;
>+    result.x = c.y;
>+    result.z = c.z;
>+    return result;
>+}
>+ushort4 operator.yxz=(ushort4 v, ushort3 c) {
>+    ushort4 result = v;
>+    result.y = c.x;
>+    result.x = c.y;
>+    result.z = c.z;
>+    return result;
>+}
>+uint3 operator.yxz=(uint3 v, uint3 c) {
>+    uint3 result = v;
>+    result.y = c.x;
>+    result.x = c.y;
>+    result.z = c.z;
>+    return result;
>+}
>+uint4 operator.yxz=(uint4 v, uint3 c) {
>+    uint4 result = v;
>+    result.y = c.x;
>+    result.x = c.y;
>+    result.z = c.z;
>+    return result;
>+}
>+char3 operator.yxz=(char3 v, char3 c) {
>+    char3 result = v;
>+    result.y = c.x;
>+    result.x = c.y;
>+    result.z = c.z;
>+    return result;
>+}
>+char4 operator.yxz=(char4 v, char3 c) {
>+    char4 result = v;
>+    result.y = c.x;
>+    result.x = c.y;
>+    result.z = c.z;
>+    return result;
>+}
>+short3 operator.yxz=(short3 v, short3 c) {
>+    short3 result = v;
>+    result.y = c.x;
>+    result.x = c.y;
>+    result.z = c.z;
>+    return result;
>+}
>+short4 operator.yxz=(short4 v, short3 c) {
>+    short4 result = v;
>+    result.y = c.x;
>+    result.x = c.y;
>+    result.z = c.z;
>+    return result;
>+}
>+int3 operator.yxz=(int3 v, int3 c) {
>+    int3 result = v;
>+    result.y = c.x;
>+    result.x = c.y;
>+    result.z = c.z;
>+    return result;
>+}
>+int4 operator.yxz=(int4 v, int3 c) {
>+    int4 result = v;
>+    result.y = c.x;
>+    result.x = c.y;
>+    result.z = c.z;
>+    return result;
>+}
>+half3 operator.yxz=(half3 v, half3 c) {
>+    half3 result = v;
>+    result.y = c.x;
>+    result.x = c.y;
>+    result.z = c.z;
>+    return result;
>+}
>+half4 operator.yxz=(half4 v, half3 c) {
>+    half4 result = v;
>+    result.y = c.x;
>+    result.x = c.y;
>+    result.z = c.z;
>+    return result;
>+}
>+float3 operator.yxz=(float3 v, float3 c) {
>+    float3 result = v;
>+    result.y = c.x;
>+    result.x = c.y;
>+    result.z = c.z;
>+    return result;
>+}
>+float4 operator.yxz=(float4 v, float3 c) {
>+    float4 result = v;
>+    result.y = c.x;
>+    result.x = c.y;
>+    result.z = c.z;
>+    return result;
>+}
>+
>+/* Functions named operator.wxzy= */
>+bool4 operator.wxzy=(bool4 v, bool4 c) {
>+    bool4 result = v;
>+    result.w = c.x;
>+    result.x = c.y;
>+    result.z = c.z;
>+    result.y = c.w;
>+    return result;
>+}
>+uchar4 operator.wxzy=(uchar4 v, uchar4 c) {
>+    uchar4 result = v;
>+    result.w = c.x;
>+    result.x = c.y;
>+    result.z = c.z;
>+    result.y = c.w;
>+    return result;
>+}
>+ushort4 operator.wxzy=(ushort4 v, ushort4 c) {
>+    ushort4 result = v;
>+    result.w = c.x;
>+    result.x = c.y;
>+    result.z = c.z;
>+    result.y = c.w;
>+    return result;
>+}
>+uint4 operator.wxzy=(uint4 v, uint4 c) {
>+    uint4 result = v;
>+    result.w = c.x;
>+    result.x = c.y;
>+    result.z = c.z;
>+    result.y = c.w;
>+    return result;
>+}
>+char4 operator.wxzy=(char4 v, char4 c) {
>+    char4 result = v;
>+    result.w = c.x;
>+    result.x = c.y;
>+    result.z = c.z;
>+    result.y = c.w;
>+    return result;
>+}
>+short4 operator.wxzy=(short4 v, short4 c) {
>+    short4 result = v;
>+    result.w = c.x;
>+    result.x = c.y;
>+    result.z = c.z;
>+    result.y = c.w;
>+    return result;
>+}
>+int4 operator.wxzy=(int4 v, int4 c) {
>+    int4 result = v;
>+    result.w = c.x;
>+    result.x = c.y;
>+    result.z = c.z;
>+    result.y = c.w;
>+    return result;
>+}
>+half4 operator.wxzy=(half4 v, half4 c) {
>+    half4 result = v;
>+    result.w = c.x;
>+    result.x = c.y;
>+    result.z = c.z;
>+    result.y = c.w;
>+    return result;
>+}
>+float4 operator.wxzy=(float4 v, float4 c) {
>+    float4 result = v;
>+    result.w = c.x;
>+    result.x = c.y;
>+    result.z = c.z;
>+    result.y = c.w;
>+    return result;
>+}
>+
>+/* Functions named operator* */
>+native int operator*(int, int);
>+native uint operator*(uint, uint);
>+native float operator*(float, float);
>+uchar operator*(uchar a, uchar b) {
>+    return uchar(uint(a) * uint(b));
>+}
>+ushort operator*(ushort a, ushort b) {
>+    return ushort(uint(a) * uint(b));
>+}
>+char operator*(char a, char b) {
>+    return char(int(a) * int(b));
>+}
>+short operator*(short a, short b) {
>+    return short(int(a) * int(b));
>+}
>+half operator*(half a, half b) {
>+    return half(float(a) * float(b));
>+}
>+uchar2 operator*(uchar2 a, uchar2 b) {
>+    uchar2 result;
>+    result[0] = a[0] * b[0];
>+    result[1] = a[1] * b[1];
>+    return result;
>+}
>+uchar2 operator*(uchar2 a, uchar b) {
>+    uchar2 result;
>+    result[0] = a[0] * b;
>+    result[1] = a[1] * b;
>+    return result;
>+}
>+uchar2 operator*(uchar a, uchar2 b) {
>+    uchar2 result;
>+    result[0] = a * b[0];
>+    result[1] = a * b[1];
>+    return result;
>+}
>+uchar3 operator*(uchar3 a, uchar3 b) {
>+    uchar3 result;
>+    result[0] = a[0] * b[0];
>+    result[1] = a[1] * b[1];
>+    result[2] = a[2] * b[2];
>+    return result;
>+}
>+uchar3 operator*(uchar3 a, uchar b) {
>+    uchar3 result;
>+    result[0] = a[0] * b;
>+    result[1] = a[1] * b;
>+    result[2] = a[2] * b;
>+    return result;
>+}
>+uchar3 operator*(uchar a, uchar3 b) {
>+    uchar3 result;
>+    result[0] = a * b[0];
>+    result[1] = a * b[1];
>+    result[2] = a * b[2];
>+    return result;
>+}
>+uchar4 operator*(uchar4 a, uchar4 b) {
>+    uchar4 result;
>+    result[0] = a[0] * b[0];
>+    result[1] = a[1] * b[1];
>+    result[2] = a[2] * b[2];
>+    result[3] = a[3] * b[3];
>+    return result;
>+}
>+uchar4 operator*(uchar4 a, uchar b) {
>+    uchar4 result;
>+    result[0] = a[0] * b;
>+    result[1] = a[1] * b;
>+    result[2] = a[2] * b;
>+    result[3] = a[3] * b;
>+    return result;
>+}
>+uchar4 operator*(uchar a, uchar4 b) {
>+    uchar4 result;
>+    result[0] = a * b[0];
>+    result[1] = a * b[1];
>+    result[2] = a * b[2];
>+    result[3] = a * b[3];
>+    return result;
>+}
>+ushort2 operator*(ushort2 a, ushort2 b) {
>+    ushort2 result;
>+    result[0] = a[0] * b[0];
>+    result[1] = a[1] * b[1];
>+    return result;
>+}
>+ushort2 operator*(ushort2 a, ushort b) {
>+    ushort2 result;
>+    result[0] = a[0] * b;
>+    result[1] = a[1] * b;
>+    return result;
>+}
>+ushort2 operator*(ushort a, ushort2 b) {
>+    ushort2 result;
>+    result[0] = a * b[0];
>+    result[1] = a * b[1];
>+    return result;
>+}
>+ushort3 operator*(ushort3 a, ushort3 b) {
>+    ushort3 result;
>+    result[0] = a[0] * b[0];
>+    result[1] = a[1] * b[1];
>+    result[2] = a[2] * b[2];
>+    return result;
>+}
>+ushort3 operator*(ushort3 a, ushort b) {
>+    ushort3 result;
>+    result[0] = a[0] * b;
>+    result[1] = a[1] * b;
>+    result[2] = a[2] * b;
>+    return result;
>+}
>+ushort3 operator*(ushort a, ushort3 b) {
>+    ushort3 result;
>+    result[0] = a * b[0];
>+    result[1] = a * b[1];
>+    result[2] = a * b[2];
>+    return result;
>+}
>+ushort4 operator*(ushort4 a, ushort4 b) {
>+    ushort4 result;
>+    result[0] = a[0] * b[0];
>+    result[1] = a[1] * b[1];
>+    result[2] = a[2] * b[2];
>+    result[3] = a[3] * b[3];
>+    return result;
>+}
>+ushort4 operator*(ushort4 a, ushort b) {
>+    ushort4 result;
>+    result[0] = a[0] * b;
>+    result[1] = a[1] * b;
>+    result[2] = a[2] * b;
>+    result[3] = a[3] * b;
>+    return result;
>+}
>+ushort4 operator*(ushort a, ushort4 b) {
>+    ushort4 result;
>+    result[0] = a * b[0];
>+    result[1] = a * b[1];
>+    result[2] = a * b[2];
>+    result[3] = a * b[3];
>+    return result;
>+}
>+uint2 operator*(uint2 a, uint2 b) {
>+    uint2 result;
>+    result[0] = a[0] * b[0];
>+    result[1] = a[1] * b[1];
>+    return result;
>+}
>+uint2 operator*(uint2 a, uint b) {
>+    uint2 result;
>+    result[0] = a[0] * b;
>+    result[1] = a[1] * b;
>+    return result;
>+}
>+uint2 operator*(uint a, uint2 b) {
>+    uint2 result;
>+    result[0] = a * b[0];
>+    result[1] = a * b[1];
>+    return result;
>+}
>+uint3 operator*(uint3 a, uint3 b) {
>+    uint3 result;
>+    result[0] = a[0] * b[0];
>+    result[1] = a[1] * b[1];
>+    result[2] = a[2] * b[2];
>+    return result;
>+}
>+uint3 operator*(uint3 a, uint b) {
>+    uint3 result;
>+    result[0] = a[0] * b;
>+    result[1] = a[1] * b;
>+    result[2] = a[2] * b;
>+    return result;
>+}
>+uint3 operator*(uint a, uint3 b) {
>+    uint3 result;
>+    result[0] = a * b[0];
>+    result[1] = a * b[1];
>+    result[2] = a * b[2];
>+    return result;
>+}
>+uint4 operator*(uint4 a, uint4 b) {
>+    uint4 result;
>+    result[0] = a[0] * b[0];
>+    result[1] = a[1] * b[1];
>+    result[2] = a[2] * b[2];
>+    result[3] = a[3] * b[3];
>+    return result;
>+}
>+uint4 operator*(uint4 a, uint b) {
>+    uint4 result;
>+    result[0] = a[0] * b;
>+    result[1] = a[1] * b;
>+    result[2] = a[2] * b;
>+    result[3] = a[3] * b;
>+    return result;
>+}
>+uint4 operator*(uint a, uint4 b) {
>+    uint4 result;
>+    result[0] = a * b[0];
>+    result[1] = a * b[1];
>+    result[2] = a * b[2];
>+    result[3] = a * b[3];
>+    return result;
>+}
>+char2 operator*(char2 a, char2 b) {
>+    char2 result;
>+    result[0] = a[0] * b[0];
>+    result[1] = a[1] * b[1];
>+    return result;
>+}
>+char2 operator*(char2 a, char b) {
>+    char2 result;
>+    result[0] = a[0] * b;
>+    result[1] = a[1] * b;
>+    return result;
>+}
>+char2 operator*(char a, char2 b) {
>+    char2 result;
>+    result[0] = a * b[0];
>+    result[1] = a * b[1];
>+    return result;
>+}
>+char3 operator*(char3 a, char3 b) {
>+    char3 result;
>+    result[0] = a[0] * b[0];
>+    result[1] = a[1] * b[1];
>+    result[2] = a[2] * b[2];
>+    return result;
>+}
>+char3 operator*(char3 a, char b) {
>+    char3 result;
>+    result[0] = a[0] * b;
>+    result[1] = a[1] * b;
>+    result[2] = a[2] * b;
>+    return result;
>+}
>+char3 operator*(char a, char3 b) {
>+    char3 result;
>+    result[0] = a * b[0];
>+    result[1] = a * b[1];
>+    result[2] = a * b[2];
>+    return result;
>+}
>+char4 operator*(char4 a, char4 b) {
>+    char4 result;
>+    result[0] = a[0] * b[0];
>+    result[1] = a[1] * b[1];
>+    result[2] = a[2] * b[2];
>+    result[3] = a[3] * b[3];
>+    return result;
>+}
>+char4 operator*(char4 a, char b) {
>+    char4 result;
>+    result[0] = a[0] * b;
>+    result[1] = a[1] * b;
>+    result[2] = a[2] * b;
>+    result[3] = a[3] * b;
>+    return result;
>+}
>+char4 operator*(char a, char4 b) {
>+    char4 result;
>+    result[0] = a * b[0];
>+    result[1] = a * b[1];
>+    result[2] = a * b[2];
>+    result[3] = a * b[3];
>+    return result;
>+}
>+short2 operator*(short2 a, short2 b) {
>+    short2 result;
>+    result[0] = a[0] * b[0];
>+    result[1] = a[1] * b[1];
>+    return result;
>+}
>+short2 operator*(short2 a, short b) {
>+    short2 result;
>+    result[0] = a[0] * b;
>+    result[1] = a[1] * b;
>+    return result;
>+}
>+short2 operator*(short a, short2 b) {
>+    short2 result;
>+    result[0] = a * b[0];
>+    result[1] = a * b[1];
>+    return result;
>+}
>+short3 operator*(short3 a, short3 b) {
>+    short3 result;
>+    result[0] = a[0] * b[0];
>+    result[1] = a[1] * b[1];
>+    result[2] = a[2] * b[2];
>+    return result;
>+}
>+short3 operator*(short3 a, short b) {
>+    short3 result;
>+    result[0] = a[0] * b;
>+    result[1] = a[1] * b;
>+    result[2] = a[2] * b;
>+    return result;
>+}
>+short3 operator*(short a, short3 b) {
>+    short3 result;
>+    result[0] = a * b[0];
>+    result[1] = a * b[1];
>+    result[2] = a * b[2];
>+    return result;
>+}
>+short4 operator*(short4 a, short4 b) {
>+    short4 result;
>+    result[0] = a[0] * b[0];
>+    result[1] = a[1] * b[1];
>+    result[2] = a[2] * b[2];
>+    result[3] = a[3] * b[3];
>+    return result;
>+}
>+short4 operator*(short4 a, short b) {
>+    short4 result;
>+    result[0] = a[0] * b;
>+    result[1] = a[1] * b;
>+    result[2] = a[2] * b;
>+    result[3] = a[3] * b;
>+    return result;
>+}
>+short4 operator*(short a, short4 b) {
>+    short4 result;
>+    result[0] = a * b[0];
>+    result[1] = a * b[1];
>+    result[2] = a * b[2];
>+    result[3] = a * b[3];
>+    return result;
>+}
>+int2 operator*(int2 a, int2 b) {
>+    int2 result;
>+    result[0] = a[0] * b[0];
>+    result[1] = a[1] * b[1];
>+    return result;
>+}
>+int2 operator*(int2 a, int b) {
>+    int2 result;
>+    result[0] = a[0] * b;
>+    result[1] = a[1] * b;
>+    return result;
>+}
>+int2 operator*(int a, int2 b) {
>+    int2 result;
>+    result[0] = a * b[0];
>+    result[1] = a * b[1];
>+    return result;
>+}
>+int3 operator*(int3 a, int3 b) {
>+    int3 result;
>+    result[0] = a[0] * b[0];
>+    result[1] = a[1] * b[1];
>+    result[2] = a[2] * b[2];
>+    return result;
>+}
>+int3 operator*(int3 a, int b) {
>+    int3 result;
>+    result[0] = a[0] * b;
>+    result[1] = a[1] * b;
>+    result[2] = a[2] * b;
>+    return result;
>+}
>+int3 operator*(int a, int3 b) {
>+    int3 result;
>+    result[0] = a * b[0];
>+    result[1] = a * b[1];
>+    result[2] = a * b[2];
>+    return result;
>+}
>+int4 operator*(int4 a, int4 b) {
>+    int4 result;
>+    result[0] = a[0] * b[0];
>+    result[1] = a[1] * b[1];
>+    result[2] = a[2] * b[2];
>+    result[3] = a[3] * b[3];
>+    return result;
>+}
>+int4 operator*(int4 a, int b) {
>+    int4 result;
>+    result[0] = a[0] * b;
>+    result[1] = a[1] * b;
>+    result[2] = a[2] * b;
>+    result[3] = a[3] * b;
>+    return result;
>+}
>+int4 operator*(int a, int4 b) {
>+    int4 result;
>+    result[0] = a * b[0];
>+    result[1] = a * b[1];
>+    result[2] = a * b[2];
>+    result[3] = a * b[3];
>+    return result;
>+}
>+half2 operator*(half2 a, half2 b) {
>+    half2 result;
>+    result[0] = a[0] * b[0];
>+    result[1] = a[1] * b[1];
>+    return result;
>+}
>+half2 operator*(half2 a, half b) {
>+    half2 result;
>+    result[0] = a[0] * b;
>+    result[1] = a[1] * b;
>+    return result;
>+}
>+half2 operator*(half a, half2 b) {
>+    half2 result;
>+    result[0] = a * b[0];
>+    result[1] = a * b[1];
>+    return result;
>+}
>+half3 operator*(half3 a, half3 b) {
>+    half3 result;
>+    result[0] = a[0] * b[0];
>+    result[1] = a[1] * b[1];
>+    result[2] = a[2] * b[2];
>+    return result;
>+}
>+half3 operator*(half3 a, half b) {
>+    half3 result;
>+    result[0] = a[0] * b;
>+    result[1] = a[1] * b;
>+    result[2] = a[2] * b;
>+    return result;
>+}
>+half3 operator*(half a, half3 b) {
>+    half3 result;
>+    result[0] = a * b[0];
>+    result[1] = a * b[1];
>+    result[2] = a * b[2];
>+    return result;
>+}
>+half4 operator*(half4 a, half4 b) {
>+    half4 result;
>+    result[0] = a[0] * b[0];
>+    result[1] = a[1] * b[1];
>+    result[2] = a[2] * b[2];
>+    result[3] = a[3] * b[3];
>+    return result;
>+}
>+half4 operator*(half4 a, half b) {
>+    half4 result;
>+    result[0] = a[0] * b;
>+    result[1] = a[1] * b;
>+    result[2] = a[2] * b;
>+    result[3] = a[3] * b;
>+    return result;
>+}
>+half4 operator*(half a, half4 b) {
>+    half4 result;
>+    result[0] = a * b[0];
>+    result[1] = a * b[1];
>+    result[2] = a * b[2];
>+    result[3] = a * b[3];
>+    return result;
>+}
>+float2 operator*(float2 a, float2 b) {
>+    float2 result;
>+    result[0] = a[0] * b[0];
>+    result[1] = a[1] * b[1];
>+    return result;
>+}
>+float2 operator*(float2 a, float b) {
>+    float2 result;
>+    result[0] = a[0] * b;
>+    result[1] = a[1] * b;
>+    return result;
>+}
>+float2 operator*(float a, float2 b) {
>+    float2 result;
>+    result[0] = a * b[0];
>+    result[1] = a * b[1];
>+    return result;
>+}
>+float3 operator*(float3 a, float3 b) {
>+    float3 result;
>+    result[0] = a[0] * b[0];
>+    result[1] = a[1] * b[1];
>+    result[2] = a[2] * b[2];
>+    return result;
>+}
>+float3 operator*(float3 a, float b) {
>+    float3 result;
>+    result[0] = a[0] * b;
>+    result[1] = a[1] * b;
>+    result[2] = a[2] * b;
>+    return result;
>+}
>+float3 operator*(float a, float3 b) {
>+    float3 result;
>+    result[0] = a * b[0];
>+    result[1] = a * b[1];
>+    result[2] = a * b[2];
>+    return result;
>+}
>+float4 operator*(float4 a, float4 b) {
>+    float4 result;
>+    result[0] = a[0] * b[0];
>+    result[1] = a[1] * b[1];
>+    result[2] = a[2] * b[2];
>+    result[3] = a[3] * b[3];
>+    return result;
>+}
>+float4 operator*(float4 a, float b) {
>+    float4 result;
>+    result[0] = a[0] * b;
>+    result[1] = a[1] * b;
>+    result[2] = a[2] * b;
>+    result[3] = a[3] * b;
>+    return result;
>+}
>+float4 operator*(float a, float4 b) {
>+    float4 result;
>+    result[0] = a * b[0];
>+    result[1] = a * b[1];
>+    result[2] = a * b[2];
>+    result[3] = a * b[3];
>+    return result;
>+}
>+half2x2 operator*(half2x2 a, half2x2 b) {
>+    half2x2 result;
>+    result[0][0] = a[0][0] * b[0][0];
>+    result[0][1] = a[0][1] * b[0][1];
>+    result[1][0] = a[1][0] * b[1][0];
>+    result[1][1] = a[1][1] * b[1][1];
>+    return result;
>+}
>+half2x2 operator*(half2x2 a, half b) {
>+    half2x2 result;
>+    result[0][0] = a[0][0] * b;
>+    result[0][1] = a[0][1] * b;
>+    result[1][0] = a[1][0] * b;
>+    result[1][1] = a[1][1] * b;
>+    return result;
>+}
>+half2x2 operator*(half a, half2x2 b) {
>+    half2x2 result;
>+    result[0][0] = a * b[0][0];
>+    result[0][1] = a * b[0][1];
>+    result[1][0] = a * b[1][0];
>+    result[1][1] = a * b[1][1];
>+    return result;
>+}
>+half2x3 operator*(half2x3 a, half2x3 b) {
>+    half2x3 result;
>+    result[0][0] = a[0][0] * b[0][0];
>+    result[0][1] = a[0][1] * b[0][1];
>+    result[0][2] = a[0][2] * b[0][2];
>+    result[1][0] = a[1][0] * b[1][0];
>+    result[1][1] = a[1][1] * b[1][1];
>+    result[1][2] = a[1][2] * b[1][2];
>+    return result;
>+}
>+half2x3 operator*(half2x3 a, half b) {
>+    half2x3 result;
>+    result[0][0] = a[0][0] * b;
>+    result[0][1] = a[0][1] * b;
>+    result[0][2] = a[0][2] * b;
>+    result[1][0] = a[1][0] * b;
>+    result[1][1] = a[1][1] * b;
>+    result[1][2] = a[1][2] * b;
>+    return result;
>+}
>+half2x3 operator*(half a, half2x3 b) {
>+    half2x3 result;
>+    result[0][0] = a * b[0][0];
>+    result[0][1] = a * b[0][1];
>+    result[0][2] = a * b[0][2];
>+    result[1][0] = a * b[1][0];
>+    result[1][1] = a * b[1][1];
>+    result[1][2] = a * b[1][2];
>+    return result;
>+}
>+half2x4 operator*(half2x4 a, half2x4 b) {
>+    half2x4 result;
>+    result[0][0] = a[0][0] * b[0][0];
>+    result[0][1] = a[0][1] * b[0][1];
>+    result[0][2] = a[0][2] * b[0][2];
>+    result[0][3] = a[0][3] * b[0][3];
>+    result[1][0] = a[1][0] * b[1][0];
>+    result[1][1] = a[1][1] * b[1][1];
>+    result[1][2] = a[1][2] * b[1][2];
>+    result[1][3] = a[1][3] * b[1][3];
>+    return result;
>+}
>+half2x4 operator*(half2x4 a, half b) {
>+    half2x4 result;
>+    result[0][0] = a[0][0] * b;
>+    result[0][1] = a[0][1] * b;
>+    result[0][2] = a[0][2] * b;
>+    result[0][3] = a[0][3] * b;
>+    result[1][0] = a[1][0] * b;
>+    result[1][1] = a[1][1] * b;
>+    result[1][2] = a[1][2] * b;
>+    result[1][3] = a[1][3] * b;
>+    return result;
>+}
>+half2x4 operator*(half a, half2x4 b) {
>+    half2x4 result;
>+    result[0][0] = a * b[0][0];
>+    result[0][1] = a * b[0][1];
>+    result[0][2] = a * b[0][2];
>+    result[0][3] = a * b[0][3];
>+    result[1][0] = a * b[1][0];
>+    result[1][1] = a * b[1][1];
>+    result[1][2] = a * b[1][2];
>+    result[1][3] = a * b[1][3];
>+    return result;
>+}
>+half3x2 operator*(half3x2 a, half3x2 b) {
>+    half3x2 result;
>+    result[0][0] = a[0][0] * b[0][0];
>+    result[0][1] = a[0][1] * b[0][1];
>+    result[1][0] = a[1][0] * b[1][0];
>+    result[1][1] = a[1][1] * b[1][1];
>+    result[2][0] = a[2][0] * b[2][0];
>+    result[2][1] = a[2][1] * b[2][1];
>+    return result;
>+}
>+half3x2 operator*(half3x2 a, half b) {
>+    half3x2 result;
>+    result[0][0] = a[0][0] * b;
>+    result[0][1] = a[0][1] * b;
>+    result[1][0] = a[1][0] * b;
>+    result[1][1] = a[1][1] * b;
>+    result[2][0] = a[2][0] * b;
>+    result[2][1] = a[2][1] * b;
>+    return result;
>+}
>+half3x2 operator*(half a, half3x2 b) {
>+    half3x2 result;
>+    result[0][0] = a * b[0][0];
>+    result[0][1] = a * b[0][1];
>+    result[1][0] = a * b[1][0];
>+    result[1][1] = a * b[1][1];
>+    result[2][0] = a * b[2][0];
>+    result[2][1] = a * b[2][1];
>+    return result;
>+}
>+half3x3 operator*(half3x3 a, half3x3 b) {
>+    half3x3 result;
>+    result[0][0] = a[0][0] * b[0][0];
>+    result[0][1] = a[0][1] * b[0][1];
>+    result[0][2] = a[0][2] * b[0][2];
>+    result[1][0] = a[1][0] * b[1][0];
>+    result[1][1] = a[1][1] * b[1][1];
>+    result[1][2] = a[1][2] * b[1][2];
>+    result[2][0] = a[2][0] * b[2][0];
>+    result[2][1] = a[2][1] * b[2][1];
>+    result[2][2] = a[2][2] * b[2][2];
>+    return result;
>+}
>+half3x3 operator*(half3x3 a, half b) {
>+    half3x3 result;
>+    result[0][0] = a[0][0] * b;
>+    result[0][1] = a[0][1] * b;
>+    result[0][2] = a[0][2] * b;
>+    result[1][0] = a[1][0] * b;
>+    result[1][1] = a[1][1] * b;
>+    result[1][2] = a[1][2] * b;
>+    result[2][0] = a[2][0] * b;
>+    result[2][1] = a[2][1] * b;
>+    result[2][2] = a[2][2] * b;
>+    return result;
>+}
>+half3x3 operator*(half a, half3x3 b) {
>+    half3x3 result;
>+    result[0][0] = a * b[0][0];
>+    result[0][1] = a * b[0][1];
>+    result[0][2] = a * b[0][2];
>+    result[1][0] = a * b[1][0];
>+    result[1][1] = a * b[1][1];
>+    result[1][2] = a * b[1][2];
>+    result[2][0] = a * b[2][0];
>+    result[2][1] = a * b[2][1];
>+    result[2][2] = a * b[2][2];
>+    return result;
>+}
>+half3x4 operator*(half3x4 a, half3x4 b) {
>+    half3x4 result;
>+    result[0][0] = a[0][0] * b[0][0];
>+    result[0][1] = a[0][1] * b[0][1];
>+    result[0][2] = a[0][2] * b[0][2];
>+    result[0][3] = a[0][3] * b[0][3];
>+    result[1][0] = a[1][0] * b[1][0];
>+    result[1][1] = a[1][1] * b[1][1];
>+    result[1][2] = a[1][2] * b[1][2];
>+    result[1][3] = a[1][3] * b[1][3];
>+    result[2][0] = a[2][0] * b[2][0];
>+    result[2][1] = a[2][1] * b[2][1];
>+    result[2][2] = a[2][2] * b[2][2];
>+    result[2][3] = a[2][3] * b[2][3];
>+    return result;
>+}
>+half3x4 operator*(half3x4 a, half b) {
>+    half3x4 result;
>+    result[0][0] = a[0][0] * b;
>+    result[0][1] = a[0][1] * b;
>+    result[0][2] = a[0][2] * b;
>+    result[0][3] = a[0][3] * b;
>+    result[1][0] = a[1][0] * b;
>+    result[1][1] = a[1][1] * b;
>+    result[1][2] = a[1][2] * b;
>+    result[1][3] = a[1][3] * b;
>+    result[2][0] = a[2][0] * b;
>+    result[2][1] = a[2][1] * b;
>+    result[2][2] = a[2][2] * b;
>+    result[2][3] = a[2][3] * b;
>+    return result;
>+}
>+half3x4 operator*(half a, half3x4 b) {
>+    half3x4 result;
>+    result[0][0] = a * b[0][0];
>+    result[0][1] = a * b[0][1];
>+    result[0][2] = a * b[0][2];
>+    result[0][3] = a * b[0][3];
>+    result[1][0] = a * b[1][0];
>+    result[1][1] = a * b[1][1];
>+    result[1][2] = a * b[1][2];
>+    result[1][3] = a * b[1][3];
>+    result[2][0] = a * b[2][0];
>+    result[2][1] = a * b[2][1];
>+    result[2][2] = a * b[2][2];
>+    result[2][3] = a * b[2][3];
>+    return result;
>+}
>+half4x2 operator*(half4x2 a, half4x2 b) {
>+    half4x2 result;
>+    result[0][0] = a[0][0] * b[0][0];
>+    result[0][1] = a[0][1] * b[0][1];
>+    result[1][0] = a[1][0] * b[1][0];
>+    result[1][1] = a[1][1] * b[1][1];
>+    result[2][0] = a[2][0] * b[2][0];
>+    result[2][1] = a[2][1] * b[2][1];
>+    result[3][0] = a[3][0] * b[3][0];
>+    result[3][1] = a[3][1] * b[3][1];
>+    return result;
>+}
>+half4x2 operator*(half4x2 a, half b) {
>+    half4x2 result;
>+    result[0][0] = a[0][0] * b;
>+    result[0][1] = a[0][1] * b;
>+    result[1][0] = a[1][0] * b;
>+    result[1][1] = a[1][1] * b;
>+    result[2][0] = a[2][0] * b;
>+    result[2][1] = a[2][1] * b;
>+    result[3][0] = a[3][0] * b;
>+    result[3][1] = a[3][1] * b;
>+    return result;
>+}
>+half4x2 operator*(half a, half4x2 b) {
>+    half4x2 result;
>+    result[0][0] = a * b[0][0];
>+    result[0][1] = a * b[0][1];
>+    result[1][0] = a * b[1][0];
>+    result[1][1] = a * b[1][1];
>+    result[2][0] = a * b[2][0];
>+    result[2][1] = a * b[2][1];
>+    result[3][0] = a * b[3][0];
>+    result[3][1] = a * b[3][1];
>+    return result;
>+}
>+half4x3 operator*(half4x3 a, half4x3 b) {
>+    half4x3 result;
>+    result[0][0] = a[0][0] * b[0][0];
>+    result[0][1] = a[0][1] * b[0][1];
>+    result[0][2] = a[0][2] * b[0][2];
>+    result[1][0] = a[1][0] * b[1][0];
>+    result[1][1] = a[1][1] * b[1][1];
>+    result[1][2] = a[1][2] * b[1][2];
>+    result[2][0] = a[2][0] * b[2][0];
>+    result[2][1] = a[2][1] * b[2][1];
>+    result[2][2] = a[2][2] * b[2][2];
>+    result[3][0] = a[3][0] * b[3][0];
>+    result[3][1] = a[3][1] * b[3][1];
>+    result[3][2] = a[3][2] * b[3][2];
>+    return result;
>+}
>+half4x3 operator*(half4x3 a, half b) {
>+    half4x3 result;
>+    result[0][0] = a[0][0] * b;
>+    result[0][1] = a[0][1] * b;
>+    result[0][2] = a[0][2] * b;
>+    result[1][0] = a[1][0] * b;
>+    result[1][1] = a[1][1] * b;
>+    result[1][2] = a[1][2] * b;
>+    result[2][0] = a[2][0] * b;
>+    result[2][1] = a[2][1] * b;
>+    result[2][2] = a[2][2] * b;
>+    result[3][0] = a[3][0] * b;
>+    result[3][1] = a[3][1] * b;
>+    result[3][2] = a[3][2] * b;
>+    return result;
>+}
>+half4x3 operator*(half a, half4x3 b) {
>+    half4x3 result;
>+    result[0][0] = a * b[0][0];
>+    result[0][1] = a * b[0][1];
>+    result[0][2] = a * b[0][2];
>+    result[1][0] = a * b[1][0];
>+    result[1][1] = a * b[1][1];
>+    result[1][2] = a * b[1][2];
>+    result[2][0] = a * b[2][0];
>+    result[2][1] = a * b[2][1];
>+    result[2][2] = a * b[2][2];
>+    result[3][0] = a * b[3][0];
>+    result[3][1] = a * b[3][1];
>+    result[3][2] = a * b[3][2];
>+    return result;
>+}
>+half4x4 operator*(half4x4 a, half4x4 b) {
>+    half4x4 result;
>+    result[0][0] = a[0][0] * b[0][0];
>+    result[0][1] = a[0][1] * b[0][1];
>+    result[0][2] = a[0][2] * b[0][2];
>+    result[0][3] = a[0][3] * b[0][3];
>+    result[1][0] = a[1][0] * b[1][0];
>+    result[1][1] = a[1][1] * b[1][1];
>+    result[1][2] = a[1][2] * b[1][2];
>+    result[1][3] = a[1][3] * b[1][3];
>+    result[2][0] = a[2][0] * b[2][0];
>+    result[2][1] = a[2][1] * b[2][1];
>+    result[2][2] = a[2][2] * b[2][2];
>+    result[2][3] = a[2][3] * b[2][3];
>+    result[3][0] = a[3][0] * b[3][0];
>+    result[3][1] = a[3][1] * b[3][1];
>+    result[3][2] = a[3][2] * b[3][2];
>+    result[3][3] = a[3][3] * b[3][3];
>+    return result;
>+}
>+half4x4 operator*(half4x4 a, half b) {
>+    half4x4 result;
>+    result[0][0] = a[0][0] * b;
>+    result[0][1] = a[0][1] * b;
>+    result[0][2] = a[0][2] * b;
>+    result[0][3] = a[0][3] * b;
>+    result[1][0] = a[1][0] * b;
>+    result[1][1] = a[1][1] * b;
>+    result[1][2] = a[1][2] * b;
>+    result[1][3] = a[1][3] * b;
>+    result[2][0] = a[2][0] * b;
>+    result[2][1] = a[2][1] * b;
>+    result[2][2] = a[2][2] * b;
>+    result[2][3] = a[2][3] * b;
>+    result[3][0] = a[3][0] * b;
>+    result[3][1] = a[3][1] * b;
>+    result[3][2] = a[3][2] * b;
>+    result[3][3] = a[3][3] * b;
>+    return result;
>+}
>+half4x4 operator*(half a, half4x4 b) {
>+    half4x4 result;
>+    result[0][0] = a * b[0][0];
>+    result[0][1] = a * b[0][1];
>+    result[0][2] = a * b[0][2];
>+    result[0][3] = a * b[0][3];
>+    result[1][0] = a * b[1][0];
>+    result[1][1] = a * b[1][1];
>+    result[1][2] = a * b[1][2];
>+    result[1][3] = a * b[1][3];
>+    result[2][0] = a * b[2][0];
>+    result[2][1] = a * b[2][1];
>+    result[2][2] = a * b[2][2];
>+    result[2][3] = a * b[2][3];
>+    result[3][0] = a * b[3][0];
>+    result[3][1] = a * b[3][1];
>+    result[3][2] = a * b[3][2];
>+    result[3][3] = a * b[3][3];
>+    return result;
>+}
>+float2x2 operator*(float2x2 a, float2x2 b) {
>+    float2x2 result;
>+    result[0][0] = a[0][0] * b[0][0];
>+    result[0][1] = a[0][1] * b[0][1];
>+    result[1][0] = a[1][0] * b[1][0];
>+    result[1][1] = a[1][1] * b[1][1];
>+    return result;
>+}
>+float2x2 operator*(float2x2 a, float b) {
>+    float2x2 result;
>+    result[0][0] = a[0][0] * b;
>+    result[0][1] = a[0][1] * b;
>+    result[1][0] = a[1][0] * b;
>+    result[1][1] = a[1][1] * b;
>+    return result;
>+}
>+float2x2 operator*(float a, float2x2 b) {
>+    float2x2 result;
>+    result[0][0] = a * b[0][0];
>+    result[0][1] = a * b[0][1];
>+    result[1][0] = a * b[1][0];
>+    result[1][1] = a * b[1][1];
>+    return result;
>+}
>+float2x3 operator*(float2x3 a, float2x3 b) {
>+    float2x3 result;
>+    result[0][0] = a[0][0] * b[0][0];
>+    result[0][1] = a[0][1] * b[0][1];
>+    result[0][2] = a[0][2] * b[0][2];
>+    result[1][0] = a[1][0] * b[1][0];
>+    result[1][1] = a[1][1] * b[1][1];
>+    result[1][2] = a[1][2] * b[1][2];
>+    return result;
>+}
>+float2x3 operator*(float2x3 a, float b) {
>+    float2x3 result;
>+    result[0][0] = a[0][0] * b;
>+    result[0][1] = a[0][1] * b;
>+    result[0][2] = a[0][2] * b;
>+    result[1][0] = a[1][0] * b;
>+    result[1][1] = a[1][1] * b;
>+    result[1][2] = a[1][2] * b;
>+    return result;
>+}
>+float2x3 operator*(float a, float2x3 b) {
>+    float2x3 result;
>+    result[0][0] = a * b[0][0];
>+    result[0][1] = a * b[0][1];
>+    result[0][2] = a * b[0][2];
>+    result[1][0] = a * b[1][0];
>+    result[1][1] = a * b[1][1];
>+    result[1][2] = a * b[1][2];
>+    return result;
>+}
>+float2x4 operator*(float2x4 a, float2x4 b) {
>+    float2x4 result;
>+    result[0][0] = a[0][0] * b[0][0];
>+    result[0][1] = a[0][1] * b[0][1];
>+    result[0][2] = a[0][2] * b[0][2];
>+    result[0][3] = a[0][3] * b[0][3];
>+    result[1][0] = a[1][0] * b[1][0];
>+    result[1][1] = a[1][1] * b[1][1];
>+    result[1][2] = a[1][2] * b[1][2];
>+    result[1][3] = a[1][3] * b[1][3];
>+    return result;
>+}
>+float2x4 operator*(float2x4 a, float b) {
>+    float2x4 result;
>+    result[0][0] = a[0][0] * b;
>+    result[0][1] = a[0][1] * b;
>+    result[0][2] = a[0][2] * b;
>+    result[0][3] = a[0][3] * b;
>+    result[1][0] = a[1][0] * b;
>+    result[1][1] = a[1][1] * b;
>+    result[1][2] = a[1][2] * b;
>+    result[1][3] = a[1][3] * b;
>+    return result;
>+}
>+float2x4 operator*(float a, float2x4 b) {
>+    float2x4 result;
>+    result[0][0] = a * b[0][0];
>+    result[0][1] = a * b[0][1];
>+    result[0][2] = a * b[0][2];
>+    result[0][3] = a * b[0][3];
>+    result[1][0] = a * b[1][0];
>+    result[1][1] = a * b[1][1];
>+    result[1][2] = a * b[1][2];
>+    result[1][3] = a * b[1][3];
>+    return result;
>+}
>+float3x2 operator*(float3x2 a, float3x2 b) {
>+    float3x2 result;
>+    result[0][0] = a[0][0] * b[0][0];
>+    result[0][1] = a[0][1] * b[0][1];
>+    result[1][0] = a[1][0] * b[1][0];
>+    result[1][1] = a[1][1] * b[1][1];
>+    result[2][0] = a[2][0] * b[2][0];
>+    result[2][1] = a[2][1] * b[2][1];
>+    return result;
>+}
>+float3x2 operator*(float3x2 a, float b) {
>+    float3x2 result;
>+    result[0][0] = a[0][0] * b;
>+    result[0][1] = a[0][1] * b;
>+    result[1][0] = a[1][0] * b;
>+    result[1][1] = a[1][1] * b;
>+    result[2][0] = a[2][0] * b;
>+    result[2][1] = a[2][1] * b;
>+    return result;
>+}
>+float3x2 operator*(float a, float3x2 b) {
>+    float3x2 result;
>+    result[0][0] = a * b[0][0];
>+    result[0][1] = a * b[0][1];
>+    result[1][0] = a * b[1][0];
>+    result[1][1] = a * b[1][1];
>+    result[2][0] = a * b[2][0];
>+    result[2][1] = a * b[2][1];
>+    return result;
>+}
>+float3x3 operator*(float3x3 a, float3x3 b) {
>+    float3x3 result;
>+    result[0][0] = a[0][0] * b[0][0];
>+    result[0][1] = a[0][1] * b[0][1];
>+    result[0][2] = a[0][2] * b[0][2];
>+    result[1][0] = a[1][0] * b[1][0];
>+    result[1][1] = a[1][1] * b[1][1];
>+    result[1][2] = a[1][2] * b[1][2];
>+    result[2][0] = a[2][0] * b[2][0];
>+    result[2][1] = a[2][1] * b[2][1];
>+    result[2][2] = a[2][2] * b[2][2];
>+    return result;
>+}
>+float3x3 operator*(float3x3 a, float b) {
>+    float3x3 result;
>+    result[0][0] = a[0][0] * b;
>+    result[0][1] = a[0][1] * b;
>+    result[0][2] = a[0][2] * b;
>+    result[1][0] = a[1][0] * b;
>+    result[1][1] = a[1][1] * b;
>+    result[1][2] = a[1][2] * b;
>+    result[2][0] = a[2][0] * b;
>+    result[2][1] = a[2][1] * b;
>+    result[2][2] = a[2][2] * b;
>+    return result;
>+}
>+float3x3 operator*(float a, float3x3 b) {
>+    float3x3 result;
>+    result[0][0] = a * b[0][0];
>+    result[0][1] = a * b[0][1];
>+    result[0][2] = a * b[0][2];
>+    result[1][0] = a * b[1][0];
>+    result[1][1] = a * b[1][1];
>+    result[1][2] = a * b[1][2];
>+    result[2][0] = a * b[2][0];
>+    result[2][1] = a * b[2][1];
>+    result[2][2] = a * b[2][2];
>+    return result;
>+}
>+float3x4 operator*(float3x4 a, float3x4 b) {
>+    float3x4 result;
>+    result[0][0] = a[0][0] * b[0][0];
>+    result[0][1] = a[0][1] * b[0][1];
>+    result[0][2] = a[0][2] * b[0][2];
>+    result[0][3] = a[0][3] * b[0][3];
>+    result[1][0] = a[1][0] * b[1][0];
>+    result[1][1] = a[1][1] * b[1][1];
>+    result[1][2] = a[1][2] * b[1][2];
>+    result[1][3] = a[1][3] * b[1][3];
>+    result[2][0] = a[2][0] * b[2][0];
>+    result[2][1] = a[2][1] * b[2][1];
>+    result[2][2] = a[2][2] * b[2][2];
>+    result[2][3] = a[2][3] * b[2][3];
>+    return result;
>+}
>+float3x4 operator*(float3x4 a, float b) {
>+    float3x4 result;
>+    result[0][0] = a[0][0] * b;
>+    result[0][1] = a[0][1] * b;
>+    result[0][2] = a[0][2] * b;
>+    result[0][3] = a[0][3] * b;
>+    result[1][0] = a[1][0] * b;
>+    result[1][1] = a[1][1] * b;
>+    result[1][2] = a[1][2] * b;
>+    result[1][3] = a[1][3] * b;
>+    result[2][0] = a[2][0] * b;
>+    result[2][1] = a[2][1] * b;
>+    result[2][2] = a[2][2] * b;
>+    result[2][3] = a[2][3] * b;
>+    return result;
>+}
>+float3x4 operator*(float a, float3x4 b) {
>+    float3x4 result;
>+    result[0][0] = a * b[0][0];
>+    result[0][1] = a * b[0][1];
>+    result[0][2] = a * b[0][2];
>+    result[0][3] = a * b[0][3];
>+    result[1][0] = a * b[1][0];
>+    result[1][1] = a * b[1][1];
>+    result[1][2] = a * b[1][2];
>+    result[1][3] = a * b[1][3];
>+    result[2][0] = a * b[2][0];
>+    result[2][1] = a * b[2][1];
>+    result[2][2] = a * b[2][2];
>+    result[2][3] = a * b[2][3];
>+    return result;
>+}
>+float4x2 operator*(float4x2 a, float4x2 b) {
>+    float4x2 result;
>+    result[0][0] = a[0][0] * b[0][0];
>+    result[0][1] = a[0][1] * b[0][1];
>+    result[1][0] = a[1][0] * b[1][0];
>+    result[1][1] = a[1][1] * b[1][1];
>+    result[2][0] = a[2][0] * b[2][0];
>+    result[2][1] = a[2][1] * b[2][1];
>+    result[3][0] = a[3][0] * b[3][0];
>+    result[3][1] = a[3][1] * b[3][1];
>+    return result;
>+}
>+float4x2 operator*(float4x2 a, float b) {
>+    float4x2 result;
>+    result[0][0] = a[0][0] * b;
>+    result[0][1] = a[0][1] * b;
>+    result[1][0] = a[1][0] * b;
>+    result[1][1] = a[1][1] * b;
>+    result[2][0] = a[2][0] * b;
>+    result[2][1] = a[2][1] * b;
>+    result[3][0] = a[3][0] * b;
>+    result[3][1] = a[3][1] * b;
>+    return result;
>+}
>+float4x2 operator*(float a, float4x2 b) {
>+    float4x2 result;
>+    result[0][0] = a * b[0][0];
>+    result[0][1] = a * b[0][1];
>+    result[1][0] = a * b[1][0];
>+    result[1][1] = a * b[1][1];
>+    result[2][0] = a * b[2][0];
>+    result[2][1] = a * b[2][1];
>+    result[3][0] = a * b[3][0];
>+    result[3][1] = a * b[3][1];
>+    return result;
>+}
>+float4x3 operator*(float4x3 a, float4x3 b) {
>+    float4x3 result;
>+    result[0][0] = a[0][0] * b[0][0];
>+    result[0][1] = a[0][1] * b[0][1];
>+    result[0][2] = a[0][2] * b[0][2];
>+    result[1][0] = a[1][0] * b[1][0];
>+    result[1][1] = a[1][1] * b[1][1];
>+    result[1][2] = a[1][2] * b[1][2];
>+    result[2][0] = a[2][0] * b[2][0];
>+    result[2][1] = a[2][1] * b[2][1];
>+    result[2][2] = a[2][2] * b[2][2];
>+    result[3][0] = a[3][0] * b[3][0];
>+    result[3][1] = a[3][1] * b[3][1];
>+    result[3][2] = a[3][2] * b[3][2];
>+    return result;
>+}
>+float4x3 operator*(float4x3 a, float b) {
>+    float4x3 result;
>+    result[0][0] = a[0][0] * b;
>+    result[0][1] = a[0][1] * b;
>+    result[0][2] = a[0][2] * b;
>+    result[1][0] = a[1][0] * b;
>+    result[1][1] = a[1][1] * b;
>+    result[1][2] = a[1][2] * b;
>+    result[2][0] = a[2][0] * b;
>+    result[2][1] = a[2][1] * b;
>+    result[2][2] = a[2][2] * b;
>+    result[3][0] = a[3][0] * b;
>+    result[3][1] = a[3][1] * b;
>+    result[3][2] = a[3][2] * b;
>+    return result;
>+}
>+float4x3 operator*(float a, float4x3 b) {
>+    float4x3 result;
>+    result[0][0] = a * b[0][0];
>+    result[0][1] = a * b[0][1];
>+    result[0][2] = a * b[0][2];
>+    result[1][0] = a * b[1][0];
>+    result[1][1] = a * b[1][1];
>+    result[1][2] = a * b[1][2];
>+    result[2][0] = a * b[2][0];
>+    result[2][1] = a * b[2][1];
>+    result[2][2] = a * b[2][2];
>+    result[3][0] = a * b[3][0];
>+    result[3][1] = a * b[3][1];
>+    result[3][2] = a * b[3][2];
>+    return result;
>+}
>+float4x4 operator*(float4x4 a, float4x4 b) {
>+    float4x4 result;
>+    result[0][0] = a[0][0] * b[0][0];
>+    result[0][1] = a[0][1] * b[0][1];
>+    result[0][2] = a[0][2] * b[0][2];
>+    result[0][3] = a[0][3] * b[0][3];
>+    result[1][0] = a[1][0] * b[1][0];
>+    result[1][1] = a[1][1] * b[1][1];
>+    result[1][2] = a[1][2] * b[1][2];
>+    result[1][3] = a[1][3] * b[1][3];
>+    result[2][0] = a[2][0] * b[2][0];
>+    result[2][1] = a[2][1] * b[2][1];
>+    result[2][2] = a[2][2] * b[2][2];
>+    result[2][3] = a[2][3] * b[2][3];
>+    result[3][0] = a[3][0] * b[3][0];
>+    result[3][1] = a[3][1] * b[3][1];
>+    result[3][2] = a[3][2] * b[3][2];
>+    result[3][3] = a[3][3] * b[3][3];
>+    return result;
>+}
>+float4x4 operator*(float4x4 a, float b) {
>+    float4x4 result;
>+    result[0][0] = a[0][0] * b;
>+    result[0][1] = a[0][1] * b;
>+    result[0][2] = a[0][2] * b;
>+    result[0][3] = a[0][3] * b;
>+    result[1][0] = a[1][0] * b;
>+    result[1][1] = a[1][1] * b;
>+    result[1][2] = a[1][2] * b;
>+    result[1][3] = a[1][3] * b;
>+    result[2][0] = a[2][0] * b;
>+    result[2][1] = a[2][1] * b;
>+    result[2][2] = a[2][2] * b;
>+    result[2][3] = a[2][3] * b;
>+    result[3][0] = a[3][0] * b;
>+    result[3][1] = a[3][1] * b;
>+    result[3][2] = a[3][2] * b;
>+    result[3][3] = a[3][3] * b;
>+    return result;
>+}
>+float4x4 operator*(float a, float4x4 b) {
>+    float4x4 result;
>+    result[0][0] = a * b[0][0];
>+    result[0][1] = a * b[0][1];
>+    result[0][2] = a * b[0][2];
>+    result[0][3] = a * b[0][3];
>+    result[1][0] = a * b[1][0];
>+    result[1][1] = a * b[1][1];
>+    result[1][2] = a * b[1][2];
>+    result[1][3] = a * b[1][3];
>+    result[2][0] = a * b[2][0];
>+    result[2][1] = a * b[2][1];
>+    result[2][2] = a * b[2][2];
>+    result[2][3] = a * b[2][3];
>+    result[3][0] = a * b[3][0];
>+    result[3][1] = a * b[3][1];
>+    result[3][2] = a * b[3][2];
>+    result[3][3] = a * b[3][3];
>+    return result;
>+}
>+
>+/* Functions named cos */
>+native float cos(float);
>+half cos(half x) {
>+    return half(cos(float(x)));
>+}
>+half2 cos(half2 x) {
>+    half2 result;
>+    result[0] = cos(x[0]);
>+    result[1] = cos(x[1]);
>+    return result;
>+}
>+half3 cos(half3 x) {
>+    half3 result;
>+    result[0] = cos(x[0]);
>+    result[1] = cos(x[1]);
>+    result[2] = cos(x[2]);
>+    return result;
>+}
>+half4 cos(half4 x) {
>+    half4 result;
>+    result[0] = cos(x[0]);
>+    result[1] = cos(x[1]);
>+    result[2] = cos(x[2]);
>+    result[3] = cos(x[3]);
>+    return result;
>+}
>+half2x2 cos(half2x2 x) {
>+    half2x2 result;
>+    result[0][0] = cos(x[0][0]);
>+    result[0][1] = cos(x[0][1]);
>+    result[1][0] = cos(x[1][0]);
>+    result[1][1] = cos(x[1][1]);
>+    return result;
>+}
>+half2x3 cos(half2x3 x) {
>+    half2x3 result;
>+    result[0][0] = cos(x[0][0]);
>+    result[0][1] = cos(x[0][1]);
>+    result[0][2] = cos(x[0][2]);
>+    result[1][0] = cos(x[1][0]);
>+    result[1][1] = cos(x[1][1]);
>+    result[1][2] = cos(x[1][2]);
>+    return result;
>+}
>+half2x4 cos(half2x4 x) {
>+    half2x4 result;
>+    result[0][0] = cos(x[0][0]);
>+    result[0][1] = cos(x[0][1]);
>+    result[0][2] = cos(x[0][2]);
>+    result[0][3] = cos(x[0][3]);
>+    result[1][0] = cos(x[1][0]);
>+    result[1][1] = cos(x[1][1]);
>+    result[1][2] = cos(x[1][2]);
>+    result[1][3] = cos(x[1][3]);
>+    return result;
>+}
>+half3x2 cos(half3x2 x) {
>+    half3x2 result;
>+    result[0][0] = cos(x[0][0]);
>+    result[0][1] = cos(x[0][1]);
>+    result[1][0] = cos(x[1][0]);
>+    result[1][1] = cos(x[1][1]);
>+    result[2][0] = cos(x[2][0]);
>+    result[2][1] = cos(x[2][1]);
>+    return result;
>+}
>+half3x3 cos(half3x3 x) {
>+    half3x3 result;
>+    result[0][0] = cos(x[0][0]);
>+    result[0][1] = cos(x[0][1]);
>+    result[0][2] = cos(x[0][2]);
>+    result[1][0] = cos(x[1][0]);
>+    result[1][1] = cos(x[1][1]);
>+    result[1][2] = cos(x[1][2]);
>+    result[2][0] = cos(x[2][0]);
>+    result[2][1] = cos(x[2][1]);
>+    result[2][2] = cos(x[2][2]);
>+    return result;
>+}
>+half3x4 cos(half3x4 x) {
>+    half3x4 result;
>+    result[0][0] = cos(x[0][0]);
>+    result[0][1] = cos(x[0][1]);
>+    result[0][2] = cos(x[0][2]);
>+    result[0][3] = cos(x[0][3]);
>+    result[1][0] = cos(x[1][0]);
>+    result[1][1] = cos(x[1][1]);
>+    result[1][2] = cos(x[1][2]);
>+    result[1][3] = cos(x[1][3]);
>+    result[2][0] = cos(x[2][0]);
>+    result[2][1] = cos(x[2][1]);
>+    result[2][2] = cos(x[2][2]);
>+    result[2][3] = cos(x[2][3]);
>+    return result;
>+}
>+half4x2 cos(half4x2 x) {
>+    half4x2 result;
>+    result[0][0] = cos(x[0][0]);
>+    result[0][1] = cos(x[0][1]);
>+    result[1][0] = cos(x[1][0]);
>+    result[1][1] = cos(x[1][1]);
>+    result[2][0] = cos(x[2][0]);
>+    result[2][1] = cos(x[2][1]);
>+    result[3][0] = cos(x[3][0]);
>+    result[3][1] = cos(x[3][1]);
>+    return result;
>+}
>+half4x3 cos(half4x3 x) {
>+    half4x3 result;
>+    result[0][0] = cos(x[0][0]);
>+    result[0][1] = cos(x[0][1]);
>+    result[0][2] = cos(x[0][2]);
>+    result[1][0] = cos(x[1][0]);
>+    result[1][1] = cos(x[1][1]);
>+    result[1][2] = cos(x[1][2]);
>+    result[2][0] = cos(x[2][0]);
>+    result[2][1] = cos(x[2][1]);
>+    result[2][2] = cos(x[2][2]);
>+    result[3][0] = cos(x[3][0]);
>+    result[3][1] = cos(x[3][1]);
>+    result[3][2] = cos(x[3][2]);
>+    return result;
>+}
>+half4x4 cos(half4x4 x) {
>+    half4x4 result;
>+    result[0][0] = cos(x[0][0]);
>+    result[0][1] = cos(x[0][1]);
>+    result[0][2] = cos(x[0][2]);
>+    result[0][3] = cos(x[0][3]);
>+    result[1][0] = cos(x[1][0]);
>+    result[1][1] = cos(x[1][1]);
>+    result[1][2] = cos(x[1][2]);
>+    result[1][3] = cos(x[1][3]);
>+    result[2][0] = cos(x[2][0]);
>+    result[2][1] = cos(x[2][1]);
>+    result[2][2] = cos(x[2][2]);
>+    result[2][3] = cos(x[2][3]);
>+    result[3][0] = cos(x[3][0]);
>+    result[3][1] = cos(x[3][1]);
>+    result[3][2] = cos(x[3][2]);
>+    result[3][3] = cos(x[3][3]);
>+    return result;
>+}
>+float2 cos(float2 x) {
>+    float2 result;
>+    result[0] = cos(x[0]);
>+    result[1] = cos(x[1]);
>+    return result;
>+}
>+float3 cos(float3 x) {
>+    float3 result;
>+    result[0] = cos(x[0]);
>+    result[1] = cos(x[1]);
>+    result[2] = cos(x[2]);
>+    return result;
>+}
>+float4 cos(float4 x) {
>+    float4 result;
>+    result[0] = cos(x[0]);
>+    result[1] = cos(x[1]);
>+    result[2] = cos(x[2]);
>+    result[3] = cos(x[3]);
>+    return result;
>+}
>+float2x2 cos(float2x2 x) {
>+    float2x2 result;
>+    result[0][0] = cos(x[0][0]);
>+    result[0][1] = cos(x[0][1]);
>+    result[1][0] = cos(x[1][0]);
>+    result[1][1] = cos(x[1][1]);
>+    return result;
>+}
>+float2x3 cos(float2x3 x) {
>+    float2x3 result;
>+    result[0][0] = cos(x[0][0]);
>+    result[0][1] = cos(x[0][1]);
>+    result[0][2] = cos(x[0][2]);
>+    result[1][0] = cos(x[1][0]);
>+    result[1][1] = cos(x[1][1]);
>+    result[1][2] = cos(x[1][2]);
>+    return result;
>+}
>+float2x4 cos(float2x4 x) {
>+    float2x4 result;
>+    result[0][0] = cos(x[0][0]);
>+    result[0][1] = cos(x[0][1]);
>+    result[0][2] = cos(x[0][2]);
>+    result[0][3] = cos(x[0][3]);
>+    result[1][0] = cos(x[1][0]);
>+    result[1][1] = cos(x[1][1]);
>+    result[1][2] = cos(x[1][2]);
>+    result[1][3] = cos(x[1][3]);
>+    return result;
>+}
>+float3x2 cos(float3x2 x) {
>+    float3x2 result;
>+    result[0][0] = cos(x[0][0]);
>+    result[0][1] = cos(x[0][1]);
>+    result[1][0] = cos(x[1][0]);
>+    result[1][1] = cos(x[1][1]);
>+    result[2][0] = cos(x[2][0]);
>+    result[2][1] = cos(x[2][1]);
>+    return result;
>+}
>+float3x3 cos(float3x3 x) {
>+    float3x3 result;
>+    result[0][0] = cos(x[0][0]);
>+    result[0][1] = cos(x[0][1]);
>+    result[0][2] = cos(x[0][2]);
>+    result[1][0] = cos(x[1][0]);
>+    result[1][1] = cos(x[1][1]);
>+    result[1][2] = cos(x[1][2]);
>+    result[2][0] = cos(x[2][0]);
>+    result[2][1] = cos(x[2][1]);
>+    result[2][2] = cos(x[2][2]);
>+    return result;
>+}
>+float3x4 cos(float3x4 x) {
>+    float3x4 result;
>+    result[0][0] = cos(x[0][0]);
>+    result[0][1] = cos(x[0][1]);
>+    result[0][2] = cos(x[0][2]);
>+    result[0][3] = cos(x[0][3]);
>+    result[1][0] = cos(x[1][0]);
>+    result[1][1] = cos(x[1][1]);
>+    result[1][2] = cos(x[1][2]);
>+    result[1][3] = cos(x[1][3]);
>+    result[2][0] = cos(x[2][0]);
>+    result[2][1] = cos(x[2][1]);
>+    result[2][2] = cos(x[2][2]);
>+    result[2][3] = cos(x[2][3]);
>+    return result;
>+}
>+float4x2 cos(float4x2 x) {
>+    float4x2 result;
>+    result[0][0] = cos(x[0][0]);
>+    result[0][1] = cos(x[0][1]);
>+    result[1][0] = cos(x[1][0]);
>+    result[1][1] = cos(x[1][1]);
>+    result[2][0] = cos(x[2][0]);
>+    result[2][1] = cos(x[2][1]);
>+    result[3][0] = cos(x[3][0]);
>+    result[3][1] = cos(x[3][1]);
>+    return result;
>+}
>+float4x3 cos(float4x3 x) {
>+    float4x3 result;
>+    result[0][0] = cos(x[0][0]);
>+    result[0][1] = cos(x[0][1]);
>+    result[0][2] = cos(x[0][2]);
>+    result[1][0] = cos(x[1][0]);
>+    result[1][1] = cos(x[1][1]);
>+    result[1][2] = cos(x[1][2]);
>+    result[2][0] = cos(x[2][0]);
>+    result[2][1] = cos(x[2][1]);
>+    result[2][2] = cos(x[2][2]);
>+    result[3][0] = cos(x[3][0]);
>+    result[3][1] = cos(x[3][1]);
>+    result[3][2] = cos(x[3][2]);
>+    return result;
>+}
>+float4x4 cos(float4x4 x) {
>+    float4x4 result;
>+    result[0][0] = cos(x[0][0]);
>+    result[0][1] = cos(x[0][1]);
>+    result[0][2] = cos(x[0][2]);
>+    result[0][3] = cos(x[0][3]);
>+    result[1][0] = cos(x[1][0]);
>+    result[1][1] = cos(x[1][1]);
>+    result[1][2] = cos(x[1][2]);
>+    result[1][3] = cos(x[1][3]);
>+    result[2][0] = cos(x[2][0]);
>+    result[2][1] = cos(x[2][1]);
>+    result[2][2] = cos(x[2][2]);
>+    result[2][3] = cos(x[2][3]);
>+    result[3][0] = cos(x[3][0]);
>+    result[3][1] = cos(x[3][1]);
>+    result[3][2] = cos(x[3][2]);
>+    result[3][3] = cos(x[3][3]);
>+    return result;
>+}
>+
>+/* Functions named operator.zzzw */
>+bool4 operator.zzzw(bool4 v) {
>+    bool4 result;
>+    result.x = v.z;
>+    result.y = v.z;
>+    result.z = v.z;
>+    result.w = v.w;
>+    return result;
>+}
>+uchar4 operator.zzzw(uchar4 v) {
>+    uchar4 result;
>+    result.x = v.z;
>+    result.y = v.z;
>+    result.z = v.z;
>+    result.w = v.w;
>+    return result;
>+}
>+ushort4 operator.zzzw(ushort4 v) {
>+    ushort4 result;
>+    result.x = v.z;
>+    result.y = v.z;
>+    result.z = v.z;
>+    result.w = v.w;
>+    return result;
>+}
>+uint4 operator.zzzw(uint4 v) {
>+    uint4 result;
>+    result.x = v.z;
>+    result.y = v.z;
>+    result.z = v.z;
>+    result.w = v.w;
>+    return result;
>+}
>+char4 operator.zzzw(char4 v) {
>+    char4 result;
>+    result.x = v.z;
>+    result.y = v.z;
>+    result.z = v.z;
>+    result.w = v.w;
>+    return result;
>+}
>+short4 operator.zzzw(short4 v) {
>+    short4 result;
>+    result.x = v.z;
>+    result.y = v.z;
>+    result.z = v.z;
>+    result.w = v.w;
>+    return result;
>+}
>+int4 operator.zzzw(int4 v) {
>+    int4 result;
>+    result.x = v.z;
>+    result.y = v.z;
>+    result.z = v.z;
>+    result.w = v.w;
>+    return result;
>+}
>+half4 operator.zzzw(half4 v) {
>+    half4 result;
>+    result.x = v.z;
>+    result.y = v.z;
>+    result.z = v.z;
>+    result.w = v.w;
>+    return result;
>+}
>+float4 operator.zzzw(float4 v) {
>+    float4 result;
>+    result.x = v.z;
>+    result.y = v.z;
>+    result.z = v.z;
>+    result.w = v.w;
>+    return result;
>+}
>+
>+/* Functions named operator.yywy */
>+bool4 operator.yywy(bool4 v) {
>+    bool4 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.w;
>+    result.w = v.y;
>+    return result;
>+}
>+uchar4 operator.yywy(uchar4 v) {
>+    uchar4 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.w;
>+    result.w = v.y;
>+    return result;
>+}
>+ushort4 operator.yywy(ushort4 v) {
>+    ushort4 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.w;
>+    result.w = v.y;
>+    return result;
>+}
>+uint4 operator.yywy(uint4 v) {
>+    uint4 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.w;
>+    result.w = v.y;
>+    return result;
>+}
>+char4 operator.yywy(char4 v) {
>+    char4 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.w;
>+    result.w = v.y;
>+    return result;
>+}
>+short4 operator.yywy(short4 v) {
>+    short4 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.w;
>+    result.w = v.y;
>+    return result;
>+}
>+int4 operator.yywy(int4 v) {
>+    int4 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.w;
>+    result.w = v.y;
>+    return result;
>+}
>+half4 operator.yywy(half4 v) {
>+    half4 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.w;
>+    result.w = v.y;
>+    return result;
>+}
>+float4 operator.yywy(float4 v) {
>+    float4 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.w;
>+    result.w = v.y;
>+    return result;
>+}
>+
>+/* Functions named operator.xzwy= */
>+bool4 operator.xzwy=(bool4 v, bool4 c) {
>+    bool4 result = v;
>+    result.x = c.x;
>+    result.z = c.y;
>+    result.w = c.z;
>+    result.y = c.w;
>+    return result;
>+}
>+uchar4 operator.xzwy=(uchar4 v, uchar4 c) {
>+    uchar4 result = v;
>+    result.x = c.x;
>+    result.z = c.y;
>+    result.w = c.z;
>+    result.y = c.w;
>+    return result;
>+}
>+ushort4 operator.xzwy=(ushort4 v, ushort4 c) {
>+    ushort4 result = v;
>+    result.x = c.x;
>+    result.z = c.y;
>+    result.w = c.z;
>+    result.y = c.w;
>+    return result;
>+}
>+uint4 operator.xzwy=(uint4 v, uint4 c) {
>+    uint4 result = v;
>+    result.x = c.x;
>+    result.z = c.y;
>+    result.w = c.z;
>+    result.y = c.w;
>+    return result;
>+}
>+char4 operator.xzwy=(char4 v, char4 c) {
>+    char4 result = v;
>+    result.x = c.x;
>+    result.z = c.y;
>+    result.w = c.z;
>+    result.y = c.w;
>+    return result;
>+}
>+short4 operator.xzwy=(short4 v, short4 c) {
>+    short4 result = v;
>+    result.x = c.x;
>+    result.z = c.y;
>+    result.w = c.z;
>+    result.y = c.w;
>+    return result;
>+}
>+int4 operator.xzwy=(int4 v, int4 c) {
>+    int4 result = v;
>+    result.x = c.x;
>+    result.z = c.y;
>+    result.w = c.z;
>+    result.y = c.w;
>+    return result;
>+}
>+half4 operator.xzwy=(half4 v, half4 c) {
>+    half4 result = v;
>+    result.x = c.x;
>+    result.z = c.y;
>+    result.w = c.z;
>+    result.y = c.w;
>+    return result;
>+}
>+float4 operator.xzwy=(float4 v, float4 c) {
>+    float4 result = v;
>+    result.x = c.x;
>+    result.z = c.y;
>+    result.w = c.z;
>+    result.y = c.w;
>+    return result;
>+}
>+
>+/* Functions named operator.ywzz */
>+bool4 operator.ywzz(bool4 v) {
>+    bool4 result;
>+    result.x = v.y;
>+    result.y = v.w;
>+    result.z = v.z;
>+    result.w = v.z;
>+    return result;
>+}
>+uchar4 operator.ywzz(uchar4 v) {
>+    uchar4 result;
>+    result.x = v.y;
>+    result.y = v.w;
>+    result.z = v.z;
>+    result.w = v.z;
>+    return result;
>+}
>+ushort4 operator.ywzz(ushort4 v) {
>+    ushort4 result;
>+    result.x = v.y;
>+    result.y = v.w;
>+    result.z = v.z;
>+    result.w = v.z;
>+    return result;
>+}
>+uint4 operator.ywzz(uint4 v) {
>+    uint4 result;
>+    result.x = v.y;
>+    result.y = v.w;
>+    result.z = v.z;
>+    result.w = v.z;
>+    return result;
>+}
>+char4 operator.ywzz(char4 v) {
>+    char4 result;
>+    result.x = v.y;
>+    result.y = v.w;
>+    result.z = v.z;
>+    result.w = v.z;
>+    return result;
>+}
>+short4 operator.ywzz(short4 v) {
>+    short4 result;
>+    result.x = v.y;
>+    result.y = v.w;
>+    result.z = v.z;
>+    result.w = v.z;
>+    return result;
>+}
>+int4 operator.ywzz(int4 v) {
>+    int4 result;
>+    result.x = v.y;
>+    result.y = v.w;
>+    result.z = v.z;
>+    result.w = v.z;
>+    return result;
>+}
>+half4 operator.ywzz(half4 v) {
>+    half4 result;
>+    result.x = v.y;
>+    result.y = v.w;
>+    result.z = v.z;
>+    result.w = v.z;
>+    return result;
>+}
>+float4 operator.ywzz(float4 v) {
>+    float4 result;
>+    result.x = v.y;
>+    result.y = v.w;
>+    result.z = v.z;
>+    result.w = v.z;
>+    return result;
>+}
>+
>+/* Functions named operator.zw= */
>+bool4 operator.zw=(bool4 v, bool2 c) {
>+    bool4 result = v;
>+    result.z = c.x;
>+    result.w = c.y;
>+    return result;
>+}
>+uchar4 operator.zw=(uchar4 v, uchar2 c) {
>+    uchar4 result = v;
>+    result.z = c.x;
>+    result.w = c.y;
>+    return result;
>+}
>+ushort4 operator.zw=(ushort4 v, ushort2 c) {
>+    ushort4 result = v;
>+    result.z = c.x;
>+    result.w = c.y;
>+    return result;
>+}
>+uint4 operator.zw=(uint4 v, uint2 c) {
>+    uint4 result = v;
>+    result.z = c.x;
>+    result.w = c.y;
>+    return result;
>+}
>+char4 operator.zw=(char4 v, char2 c) {
>+    char4 result = v;
>+    result.z = c.x;
>+    result.w = c.y;
>+    return result;
>+}
>+short4 operator.zw=(short4 v, short2 c) {
>+    short4 result = v;
>+    result.z = c.x;
>+    result.w = c.y;
>+    return result;
>+}
>+int4 operator.zw=(int4 v, int2 c) {
>+    int4 result = v;
>+    result.z = c.x;
>+    result.w = c.y;
>+    return result;
>+}
>+half4 operator.zw=(half4 v, half2 c) {
>+    half4 result = v;
>+    result.z = c.x;
>+    result.w = c.y;
>+    return result;
>+}
>+float4 operator.zw=(float4 v, float2 c) {
>+    float4 result = v;
>+    result.z = c.x;
>+    result.w = c.y;
>+    return result;
>+}
>+
>+/* Functions named operator.xzxz */
>+bool4 operator.xzxz(bool3 v) {
>+    bool4 result;
>+    result.x = v.x;
>+    result.y = v.z;
>+    result.z = v.x;
>+    result.w = v.z;
>+    return result;
>+}
>+bool4 operator.xzxz(bool4 v) {
>+    bool4 result;
>+    result.x = v.x;
>+    result.y = v.z;
>+    result.z = v.x;
>+    result.w = v.z;
>+    return result;
>+}
>+uchar4 operator.xzxz(uchar3 v) {
>+    uchar4 result;
>+    result.x = v.x;
>+    result.y = v.z;
>+    result.z = v.x;
>+    result.w = v.z;
>+    return result;
>+}
>+uchar4 operator.xzxz(uchar4 v) {
>+    uchar4 result;
>+    result.x = v.x;
>+    result.y = v.z;
>+    result.z = v.x;
>+    result.w = v.z;
>+    return result;
>+}
>+ushort4 operator.xzxz(ushort3 v) {
>+    ushort4 result;
>+    result.x = v.x;
>+    result.y = v.z;
>+    result.z = v.x;
>+    result.w = v.z;
>+    return result;
>+}
>+ushort4 operator.xzxz(ushort4 v) {
>+    ushort4 result;
>+    result.x = v.x;
>+    result.y = v.z;
>+    result.z = v.x;
>+    result.w = v.z;
>+    return result;
>+}
>+uint4 operator.xzxz(uint3 v) {
>+    uint4 result;
>+    result.x = v.x;
>+    result.y = v.z;
>+    result.z = v.x;
>+    result.w = v.z;
>+    return result;
>+}
>+uint4 operator.xzxz(uint4 v) {
>+    uint4 result;
>+    result.x = v.x;
>+    result.y = v.z;
>+    result.z = v.x;
>+    result.w = v.z;
>+    return result;
>+}
>+char4 operator.xzxz(char3 v) {
>+    char4 result;
>+    result.x = v.x;
>+    result.y = v.z;
>+    result.z = v.x;
>+    result.w = v.z;
>+    return result;
>+}
>+char4 operator.xzxz(char4 v) {
>+    char4 result;
>+    result.x = v.x;
>+    result.y = v.z;
>+    result.z = v.x;
>+    result.w = v.z;
>+    return result;
>+}
>+short4 operator.xzxz(short3 v) {
>+    short4 result;
>+    result.x = v.x;
>+    result.y = v.z;
>+    result.z = v.x;
>+    result.w = v.z;
>+    return result;
>+}
>+short4 operator.xzxz(short4 v) {
>+    short4 result;
>+    result.x = v.x;
>+    result.y = v.z;
>+    result.z = v.x;
>+    result.w = v.z;
>+    return result;
>+}
>+int4 operator.xzxz(int3 v) {
>+    int4 result;
>+    result.x = v.x;
>+    result.y = v.z;
>+    result.z = v.x;
>+    result.w = v.z;
>+    return result;
>+}
>+int4 operator.xzxz(int4 v) {
>+    int4 result;
>+    result.x = v.x;
>+    result.y = v.z;
>+    result.z = v.x;
>+    result.w = v.z;
>+    return result;
>+}
>+half4 operator.xzxz(half3 v) {
>+    half4 result;
>+    result.x = v.x;
>+    result.y = v.z;
>+    result.z = v.x;
>+    result.w = v.z;
>+    return result;
>+}
>+half4 operator.xzxz(half4 v) {
>+    half4 result;
>+    result.x = v.x;
>+    result.y = v.z;
>+    result.z = v.x;
>+    result.w = v.z;
>+    return result;
>+}
>+float4 operator.xzxz(float3 v) {
>+    float4 result;
>+    result.x = v.x;
>+    result.y = v.z;
>+    result.z = v.x;
>+    result.w = v.z;
>+    return result;
>+}
>+float4 operator.xzxz(float4 v) {
>+    float4 result;
>+    result.x = v.x;
>+    result.y = v.z;
>+    result.z = v.x;
>+    result.w = v.z;
>+    return result;
>+}
>+
>+/* Functions named operator== */
>+native bool operator==(bool, bool);
>+native bool operator==(int, int);
>+native bool operator==(uint, uint);
>+native bool operator==(float, float);
>+bool operator==(uchar a, uchar b) {
>+    return uint(a) == uint(b);
>+}
>+bool operator==(ushort a, ushort b) {
>+    return uint(a) == uint(b);
>+}
>+bool operator==(char a, char b) {
>+    return int(a) == int(b);
>+}
>+bool operator==(short a, short b) {
>+    return int(a) == int(b);
>+}
>+bool operator==(half a, half b) {
>+    return float(a) == float(b);
>+}
>+bool operator==(bool2 a, bool2 b) {
>+    return a.x == b.x && a.y == b.y;
>+}
>+bool operator==(bool3 a, bool3 b) {
>+    return a.x == b.x && a.y == b.y && a.z == b.z;
>+}
>+bool operator==(bool4 a, bool4 b) {
>+    return a.x == b.x && a.y == b.y && a.z == b.z && a.w == b.w;
>+}
>+bool operator==(uchar2 a, uchar2 b) {
>+    return a.x == b.x && a.y == b.y;
>+}
>+bool operator==(uchar3 a, uchar3 b) {
>+    return a.x == b.x && a.y == b.y && a.z == b.z;
>+}
>+bool operator==(uchar4 a, uchar4 b) {
>+    return a.x == b.x && a.y == b.y && a.z == b.z && a.w == b.w;
>+}
>+bool operator==(ushort2 a, ushort2 b) {
>+    return a.x == b.x && a.y == b.y;
>+}
>+bool operator==(ushort3 a, ushort3 b) {
>+    return a.x == b.x && a.y == b.y && a.z == b.z;
>+}
>+bool operator==(ushort4 a, ushort4 b) {
>+    return a.x == b.x && a.y == b.y && a.z == b.z && a.w == b.w;
>+}
>+bool operator==(uint2 a, uint2 b) {
>+    return a.x == b.x && a.y == b.y;
>+}
>+bool operator==(uint3 a, uint3 b) {
>+    return a.x == b.x && a.y == b.y && a.z == b.z;
>+}
>+bool operator==(uint4 a, uint4 b) {
>+    return a.x == b.x && a.y == b.y && a.z == b.z && a.w == b.w;
>+}
>+bool operator==(char2 a, char2 b) {
>+    return a.x == b.x && a.y == b.y;
>+}
>+bool operator==(char3 a, char3 b) {
>+    return a.x == b.x && a.y == b.y && a.z == b.z;
>+}
>+bool operator==(char4 a, char4 b) {
>+    return a.x == b.x && a.y == b.y && a.z == b.z && a.w == b.w;
>+}
>+bool operator==(short2 a, short2 b) {
>+    return a.x == b.x && a.y == b.y;
>+}
>+bool operator==(short3 a, short3 b) {
>+    return a.x == b.x && a.y == b.y && a.z == b.z;
>+}
>+bool operator==(short4 a, short4 b) {
>+    return a.x == b.x && a.y == b.y && a.z == b.z && a.w == b.w;
>+}
>+bool operator==(int2 a, int2 b) {
>+    return a.x == b.x && a.y == b.y;
>+}
>+bool operator==(int3 a, int3 b) {
>+    return a.x == b.x && a.y == b.y && a.z == b.z;
>+}
>+bool operator==(int4 a, int4 b) {
>+    return a.x == b.x && a.y == b.y && a.z == b.z && a.w == b.w;
>+}
>+bool operator==(half2 a, half2 b) {
>+    return a.x == b.x && a.y == b.y;
>+}
>+bool operator==(half3 a, half3 b) {
>+    return a.x == b.x && a.y == b.y && a.z == b.z;
>+}
>+bool operator==(half4 a, half4 b) {
>+    return a.x == b.x && a.y == b.y && a.z == b.z && a.w == b.w;
>+}
>+bool operator==(float2 a, float2 b) {
>+    return a.x == b.x && a.y == b.y;
>+}
>+bool operator==(float3 a, float3 b) {
>+    return a.x == b.x && a.y == b.y && a.z == b.z;
>+}
>+bool operator==(float4 a, float4 b) {
>+    return a.x == b.x && a.y == b.y && a.z == b.z && a.w == b.w;
>+}
>+bool operator==(half2x2 a, half2x2 b) {
>+    return
>+        a[0][0] == b[0][0] &&
>+        a[0][1] == b[0][1] &&
>+        a[1][0] == b[1][0] &&
>+        a[1][1] == b[1][1] &&
>+    true;
>+}
>+bool operator==(half2x3 a, half2x3 b) {
>+    return
>+        a[0][0] == b[0][0] &&
>+        a[0][1] == b[0][1] &&
>+        a[0][2] == b[0][2] &&
>+        a[1][0] == b[1][0] &&
>+        a[1][1] == b[1][1] &&
>+        a[1][2] == b[1][2] &&
>+    true;
>+}
>+bool operator==(half2x4 a, half2x4 b) {
>+    return
>+        a[0][0] == b[0][0] &&
>+        a[0][1] == b[0][1] &&
>+        a[0][2] == b[0][2] &&
>+        a[0][3] == b[0][3] &&
>+        a[1][0] == b[1][0] &&
>+        a[1][1] == b[1][1] &&
>+        a[1][2] == b[1][2] &&
>+        a[1][3] == b[1][3] &&
>+    true;
>+}
>+bool operator==(half3x2 a, half3x2 b) {
>+    return
>+        a[0][0] == b[0][0] &&
>+        a[0][1] == b[0][1] &&
>+        a[1][0] == b[1][0] &&
>+        a[1][1] == b[1][1] &&
>+        a[2][0] == b[2][0] &&
>+        a[2][1] == b[2][1] &&
>+    true;
>+}
>+bool operator==(half3x3 a, half3x3 b) {
>+    return
>+        a[0][0] == b[0][0] &&
>+        a[0][1] == b[0][1] &&
>+        a[0][2] == b[0][2] &&
>+        a[1][0] == b[1][0] &&
>+        a[1][1] == b[1][1] &&
>+        a[1][2] == b[1][2] &&
>+        a[2][0] == b[2][0] &&
>+        a[2][1] == b[2][1] &&
>+        a[2][2] == b[2][2] &&
>+    true;
>+}
>+bool operator==(half3x4 a, half3x4 b) {
>+    return
>+        a[0][0] == b[0][0] &&
>+        a[0][1] == b[0][1] &&
>+        a[0][2] == b[0][2] &&
>+        a[0][3] == b[0][3] &&
>+        a[1][0] == b[1][0] &&
>+        a[1][1] == b[1][1] &&
>+        a[1][2] == b[1][2] &&
>+        a[1][3] == b[1][3] &&
>+        a[2][0] == b[2][0] &&
>+        a[2][1] == b[2][1] &&
>+        a[2][2] == b[2][2] &&
>+        a[2][3] == b[2][3] &&
>+    true;
>+}
>+bool operator==(half4x2 a, half4x2 b) {
>+    return
>+        a[0][0] == b[0][0] &&
>+        a[0][1] == b[0][1] &&
>+        a[1][0] == b[1][0] &&
>+        a[1][1] == b[1][1] &&
>+        a[2][0] == b[2][0] &&
>+        a[2][1] == b[2][1] &&
>+        a[3][0] == b[3][0] &&
>+        a[3][1] == b[3][1] &&
>+    true;
>+}
>+bool operator==(half4x3 a, half4x3 b) {
>+    return
>+        a[0][0] == b[0][0] &&
>+        a[0][1] == b[0][1] &&
>+        a[0][2] == b[0][2] &&
>+        a[1][0] == b[1][0] &&
>+        a[1][1] == b[1][1] &&
>+        a[1][2] == b[1][2] &&
>+        a[2][0] == b[2][0] &&
>+        a[2][1] == b[2][1] &&
>+        a[2][2] == b[2][2] &&
>+        a[3][0] == b[3][0] &&
>+        a[3][1] == b[3][1] &&
>+        a[3][2] == b[3][2] &&
>+    true;
>+}
>+bool operator==(half4x4 a, half4x4 b) {
>+    return
>+        a[0][0] == b[0][0] &&
>+        a[0][1] == b[0][1] &&
>+        a[0][2] == b[0][2] &&
>+        a[0][3] == b[0][3] &&
>+        a[1][0] == b[1][0] &&
>+        a[1][1] == b[1][1] &&
>+        a[1][2] == b[1][2] &&
>+        a[1][3] == b[1][3] &&
>+        a[2][0] == b[2][0] &&
>+        a[2][1] == b[2][1] &&
>+        a[2][2] == b[2][2] &&
>+        a[2][3] == b[2][3] &&
>+        a[3][0] == b[3][0] &&
>+        a[3][1] == b[3][1] &&
>+        a[3][2] == b[3][2] &&
>+        a[3][3] == b[3][3] &&
>+    true;
>+}
>+bool operator==(float2x2 a, float2x2 b) {
>+    return
>+        a[0][0] == b[0][0] &&
>+        a[0][1] == b[0][1] &&
>+        a[1][0] == b[1][0] &&
>+        a[1][1] == b[1][1] &&
>+    true;
>+}
>+bool operator==(float2x3 a, float2x3 b) {
>+    return
>+        a[0][0] == b[0][0] &&
>+        a[0][1] == b[0][1] &&
>+        a[0][2] == b[0][2] &&
>+        a[1][0] == b[1][0] &&
>+        a[1][1] == b[1][1] &&
>+        a[1][2] == b[1][2] &&
>+    true;
>+}
>+bool operator==(float2x4 a, float2x4 b) {
>+    return
>+        a[0][0] == b[0][0] &&
>+        a[0][1] == b[0][1] &&
>+        a[0][2] == b[0][2] &&
>+        a[0][3] == b[0][3] &&
>+        a[1][0] == b[1][0] &&
>+        a[1][1] == b[1][1] &&
>+        a[1][2] == b[1][2] &&
>+        a[1][3] == b[1][3] &&
>+    true;
>+}
>+bool operator==(float3x2 a, float3x2 b) {
>+    return
>+        a[0][0] == b[0][0] &&
>+        a[0][1] == b[0][1] &&
>+        a[1][0] == b[1][0] &&
>+        a[1][1] == b[1][1] &&
>+        a[2][0] == b[2][0] &&
>+        a[2][1] == b[2][1] &&
>+    true;
>+}
>+bool operator==(float3x3 a, float3x3 b) {
>+    return
>+        a[0][0] == b[0][0] &&
>+        a[0][1] == b[0][1] &&
>+        a[0][2] == b[0][2] &&
>+        a[1][0] == b[1][0] &&
>+        a[1][1] == b[1][1] &&
>+        a[1][2] == b[1][2] &&
>+        a[2][0] == b[2][0] &&
>+        a[2][1] == b[2][1] &&
>+        a[2][2] == b[2][2] &&
>+    true;
>+}
>+bool operator==(float3x4 a, float3x4 b) {
>+    return
>+        a[0][0] == b[0][0] &&
>+        a[0][1] == b[0][1] &&
>+        a[0][2] == b[0][2] &&
>+        a[0][3] == b[0][3] &&
>+        a[1][0] == b[1][0] &&
>+        a[1][1] == b[1][1] &&
>+        a[1][2] == b[1][2] &&
>+        a[1][3] == b[1][3] &&
>+        a[2][0] == b[2][0] &&
>+        a[2][1] == b[2][1] &&
>+        a[2][2] == b[2][2] &&
>+        a[2][3] == b[2][3] &&
>+    true;
>+}
>+bool operator==(float4x2 a, float4x2 b) {
>+    return
>+        a[0][0] == b[0][0] &&
>+        a[0][1] == b[0][1] &&
>+        a[1][0] == b[1][0] &&
>+        a[1][1] == b[1][1] &&
>+        a[2][0] == b[2][0] &&
>+        a[2][1] == b[2][1] &&
>+        a[3][0] == b[3][0] &&
>+        a[3][1] == b[3][1] &&
>+    true;
>+}
>+bool operator==(float4x3 a, float4x3 b) {
>+    return
>+        a[0][0] == b[0][0] &&
>+        a[0][1] == b[0][1] &&
>+        a[0][2] == b[0][2] &&
>+        a[1][0] == b[1][0] &&
>+        a[1][1] == b[1][1] &&
>+        a[1][2] == b[1][2] &&
>+        a[2][0] == b[2][0] &&
>+        a[2][1] == b[2][1] &&
>+        a[2][2] == b[2][2] &&
>+        a[3][0] == b[3][0] &&
>+        a[3][1] == b[3][1] &&
>+        a[3][2] == b[3][2] &&
>+    true;
>+}
>+bool operator==(float4x4 a, float4x4 b) {
>+    return
>+        a[0][0] == b[0][0] &&
>+        a[0][1] == b[0][1] &&
>+        a[0][2] == b[0][2] &&
>+        a[0][3] == b[0][3] &&
>+        a[1][0] == b[1][0] &&
>+        a[1][1] == b[1][1] &&
>+        a[1][2] == b[1][2] &&
>+        a[1][3] == b[1][3] &&
>+        a[2][0] == b[2][0] &&
>+        a[2][1] == b[2][1] &&
>+        a[2][2] == b[2][2] &&
>+        a[2][3] == b[2][3] &&
>+        a[3][0] == b[3][0] &&
>+        a[3][1] == b[3][1] &&
>+        a[3][2] == b[3][2] &&
>+        a[3][3] == b[3][3] &&
>+    true;
>+}
>+
>+/* Functions named operator>> */
>+native int operator>>(int, uint);
>+native uint operator>>(uint, uint);
>+uchar operator>>(uchar a, uint b) {
>+    return uchar(uint(a) >> (b & 255));
>+}
>+ushort operator>>(ushort a, uint b) {
>+    return ushort(uint(a) >> (b & 65535));
>+}
>+char operator>>(char a, uint b) {
>+    return char(int(a) >> (b & 255));
>+}
>+short operator>>(short a, uint b) {
>+    return short(int(a) >> (b & 65535));
>+}
>+
>+/* Functions named reflect */
>+half reflect(half i, half n) {
>+    return i - 2 * n * dot(i, n);
>+}
>+half2 reflect(half2 i, half2 n) {
>+    return i - 2 * n * dot(i, n);
>+}
>+half3 reflect(half3 i, half3 n) {
>+    return i - 2 * n * dot(i, n);
>+}
>+half4 reflect(half4 i, half4 n) {
>+    return i - 2 * n * dot(i, n);
>+}
>+float reflect(float i, float n) {
>+    return i - 2 * n * dot(i, n);
>+}
>+float2 reflect(float2 i, float2 n) {
>+    return i - 2 * n * dot(i, n);
>+}
>+float3 reflect(float3 i, float3 n) {
>+    return i - 2 * n * dot(i, n);
>+}
>+float4 reflect(float4 i, float4 n) {
>+    return i - 2 * n * dot(i, n);
>+}
>+
>+
>+/* Functions named operator.wwxw */
>+bool4 operator.wwxw(bool4 v) {
>+    bool4 result;
>+    result.x = v.w;
>+    result.y = v.w;
>+    result.z = v.x;
>+    result.w = v.w;
>+    return result;
>+}
>+uchar4 operator.wwxw(uchar4 v) {
>+    uchar4 result;
>+    result.x = v.w;
>+    result.y = v.w;
>+    result.z = v.x;
>+    result.w = v.w;
>+    return result;
>+}
>+ushort4 operator.wwxw(ushort4 v) {
>+    ushort4 result;
>+    result.x = v.w;
>+    result.y = v.w;
>+    result.z = v.x;
>+    result.w = v.w;
>+    return result;
>+}
>+uint4 operator.wwxw(uint4 v) {
>+    uint4 result;
>+    result.x = v.w;
>+    result.y = v.w;
>+    result.z = v.x;
>+    result.w = v.w;
>+    return result;
>+}
>+char4 operator.wwxw(char4 v) {
>+    char4 result;
>+    result.x = v.w;
>+    result.y = v.w;
>+    result.z = v.x;
>+    result.w = v.w;
>+    return result;
>+}
>+short4 operator.wwxw(short4 v) {
>+    short4 result;
>+    result.x = v.w;
>+    result.y = v.w;
>+    result.z = v.x;
>+    result.w = v.w;
>+    return result;
>+}
>+int4 operator.wwxw(int4 v) {
>+    int4 result;
>+    result.x = v.w;
>+    result.y = v.w;
>+    result.z = v.x;
>+    result.w = v.w;
>+    return result;
>+}
>+half4 operator.wwxw(half4 v) {
>+    half4 result;
>+    result.x = v.w;
>+    result.y = v.w;
>+    result.z = v.x;
>+    result.w = v.w;
>+    return result;
>+}
>+float4 operator.wwxw(float4 v) {
>+    float4 result;
>+    result.x = v.w;
>+    result.y = v.w;
>+    result.z = v.x;
>+    result.w = v.w;
>+    return result;
>+}
>+
>+/* Functions named operator.xzyz */
>+bool4 operator.xzyz(bool3 v) {
>+    bool4 result;
>+    result.x = v.x;
>+    result.y = v.z;
>+    result.z = v.y;
>+    result.w = v.z;
>+    return result;
>+}
>+bool4 operator.xzyz(bool4 v) {
>+    bool4 result;
>+    result.x = v.x;
>+    result.y = v.z;
>+    result.z = v.y;
>+    result.w = v.z;
>+    return result;
>+}
>+uchar4 operator.xzyz(uchar3 v) {
>+    uchar4 result;
>+    result.x = v.x;
>+    result.y = v.z;
>+    result.z = v.y;
>+    result.w = v.z;
>+    return result;
>+}
>+uchar4 operator.xzyz(uchar4 v) {
>+    uchar4 result;
>+    result.x = v.x;
>+    result.y = v.z;
>+    result.z = v.y;
>+    result.w = v.z;
>+    return result;
>+}
>+ushort4 operator.xzyz(ushort3 v) {
>+    ushort4 result;
>+    result.x = v.x;
>+    result.y = v.z;
>+    result.z = v.y;
>+    result.w = v.z;
>+    return result;
>+}
>+ushort4 operator.xzyz(ushort4 v) {
>+    ushort4 result;
>+    result.x = v.x;
>+    result.y = v.z;
>+    result.z = v.y;
>+    result.w = v.z;
>+    return result;
>+}
>+uint4 operator.xzyz(uint3 v) {
>+    uint4 result;
>+    result.x = v.x;
>+    result.y = v.z;
>+    result.z = v.y;
>+    result.w = v.z;
>+    return result;
>+}
>+uint4 operator.xzyz(uint4 v) {
>+    uint4 result;
>+    result.x = v.x;
>+    result.y = v.z;
>+    result.z = v.y;
>+    result.w = v.z;
>+    return result;
>+}
>+char4 operator.xzyz(char3 v) {
>+    char4 result;
>+    result.x = v.x;
>+    result.y = v.z;
>+    result.z = v.y;
>+    result.w = v.z;
>+    return result;
>+}
>+char4 operator.xzyz(char4 v) {
>+    char4 result;
>+    result.x = v.x;
>+    result.y = v.z;
>+    result.z = v.y;
>+    result.w = v.z;
>+    return result;
>+}
>+short4 operator.xzyz(short3 v) {
>+    short4 result;
>+    result.x = v.x;
>+    result.y = v.z;
>+    result.z = v.y;
>+    result.w = v.z;
>+    return result;
>+}
>+short4 operator.xzyz(short4 v) {
>+    short4 result;
>+    result.x = v.x;
>+    result.y = v.z;
>+    result.z = v.y;
>+    result.w = v.z;
>+    return result;
>+}
>+int4 operator.xzyz(int3 v) {
>+    int4 result;
>+    result.x = v.x;
>+    result.y = v.z;
>+    result.z = v.y;
>+    result.w = v.z;
>+    return result;
>+}
>+int4 operator.xzyz(int4 v) {
>+    int4 result;
>+    result.x = v.x;
>+    result.y = v.z;
>+    result.z = v.y;
>+    result.w = v.z;
>+    return result;
>+}
>+half4 operator.xzyz(half3 v) {
>+    half4 result;
>+    result.x = v.x;
>+    result.y = v.z;
>+    result.z = v.y;
>+    result.w = v.z;
>+    return result;
>+}
>+half4 operator.xzyz(half4 v) {
>+    half4 result;
>+    result.x = v.x;
>+    result.y = v.z;
>+    result.z = v.y;
>+    result.w = v.z;
>+    return result;
>+}
>+float4 operator.xzyz(float3 v) {
>+    float4 result;
>+    result.x = v.x;
>+    result.y = v.z;
>+    result.z = v.y;
>+    result.w = v.z;
>+    return result;
>+}
>+float4 operator.xzyz(float4 v) {
>+    float4 result;
>+    result.x = v.x;
>+    result.y = v.z;
>+    result.z = v.y;
>+    result.w = v.z;
>+    return result;
>+}
>+
>+/* Functions named lit */
>+half4 lit(half n_dot_l, half n_dot_h, half m) {
>+    half ambient = 1;
>+    half diffuse = max(0, n_dot_l);
>+    half specular = n_dot_l < 0 || n_dot_h < 0 ? 0 : n_dot_h * m;
>+    half4 result;
>+    result.x = ambient;
>+    result.y = diffuse;
>+    result.z = specular;
>+    result.w = 1;
>+    return result;
>+}
>+float4 lit(float n_dot_l, float n_dot_h, float m) {
>+    float ambient = 1;
>+    float diffuse = max(0, n_dot_l);
>+    float specular = n_dot_l < 0 || n_dot_h < 0 ? 0 : n_dot_h * m;
>+    float4 result;
>+    result.x = ambient;
>+    result.y = diffuse;
>+    result.z = specular;
>+    result.w = 1;
>+    return result;
>+}
>+
>+
>+/* Functions named operator.yxwx */
>+bool4 operator.yxwx(bool4 v) {
>+    bool4 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.w;
>+    result.w = v.x;
>+    return result;
>+}
>+uchar4 operator.yxwx(uchar4 v) {
>+    uchar4 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.w;
>+    result.w = v.x;
>+    return result;
>+}
>+ushort4 operator.yxwx(ushort4 v) {
>+    ushort4 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.w;
>+    result.w = v.x;
>+    return result;
>+}
>+uint4 operator.yxwx(uint4 v) {
>+    uint4 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.w;
>+    result.w = v.x;
>+    return result;
>+}
>+char4 operator.yxwx(char4 v) {
>+    char4 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.w;
>+    result.w = v.x;
>+    return result;
>+}
>+short4 operator.yxwx(short4 v) {
>+    short4 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.w;
>+    result.w = v.x;
>+    return result;
>+}
>+int4 operator.yxwx(int4 v) {
>+    int4 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.w;
>+    result.w = v.x;
>+    return result;
>+}
>+half4 operator.yxwx(half4 v) {
>+    half4 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.w;
>+    result.w = v.x;
>+    return result;
>+}
>+float4 operator.yxwx(float4 v) {
>+    float4 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.w;
>+    result.w = v.x;
>+    return result;
>+}
>+
>+/* Functions named log2 */
>+half log2(half x) {
>+    return log(x) / log(half(2));
>+}
>+half2 log2(half2 x) {
>+    half2 result;
>+    result[0] = log2(x[0]);
>+    result[1] = log2(x[1]);
>+    return result;
>+}
>+half3 log2(half3 x) {
>+    half3 result;
>+    result[0] = log2(x[0]);
>+    result[1] = log2(x[1]);
>+    result[2] = log2(x[2]);
>+    return result;
>+}
>+half4 log2(half4 x) {
>+    half4 result;
>+    result[0] = log2(x[0]);
>+    result[1] = log2(x[1]);
>+    result[2] = log2(x[2]);
>+    result[3] = log2(x[3]);
>+    return result;
>+}
>+half2x2 log2(half2x2 x) {
>+    half2x2 result;
>+    result[0][0] = log2(x[0][0]);
>+    result[0][1] = log2(x[0][1]);
>+    result[1][0] = log2(x[1][0]);
>+    result[1][1] = log2(x[1][1]);
>+    return result;
>+}
>+half2x3 log2(half2x3 x) {
>+    half2x3 result;
>+    result[0][0] = log2(x[0][0]);
>+    result[0][1] = log2(x[0][1]);
>+    result[0][2] = log2(x[0][2]);
>+    result[1][0] = log2(x[1][0]);
>+    result[1][1] = log2(x[1][1]);
>+    result[1][2] = log2(x[1][2]);
>+    return result;
>+}
>+half2x4 log2(half2x4 x) {
>+    half2x4 result;
>+    result[0][0] = log2(x[0][0]);
>+    result[0][1] = log2(x[0][1]);
>+    result[0][2] = log2(x[0][2]);
>+    result[0][3] = log2(x[0][3]);
>+    result[1][0] = log2(x[1][0]);
>+    result[1][1] = log2(x[1][1]);
>+    result[1][2] = log2(x[1][2]);
>+    result[1][3] = log2(x[1][3]);
>+    return result;
>+}
>+half3x2 log2(half3x2 x) {
>+    half3x2 result;
>+    result[0][0] = log2(x[0][0]);
>+    result[0][1] = log2(x[0][1]);
>+    result[1][0] = log2(x[1][0]);
>+    result[1][1] = log2(x[1][1]);
>+    result[2][0] = log2(x[2][0]);
>+    result[2][1] = log2(x[2][1]);
>+    return result;
>+}
>+half3x3 log2(half3x3 x) {
>+    half3x3 result;
>+    result[0][0] = log2(x[0][0]);
>+    result[0][1] = log2(x[0][1]);
>+    result[0][2] = log2(x[0][2]);
>+    result[1][0] = log2(x[1][0]);
>+    result[1][1] = log2(x[1][1]);
>+    result[1][2] = log2(x[1][2]);
>+    result[2][0] = log2(x[2][0]);
>+    result[2][1] = log2(x[2][1]);
>+    result[2][2] = log2(x[2][2]);
>+    return result;
>+}
>+half3x4 log2(half3x4 x) {
>+    half3x4 result;
>+    result[0][0] = log2(x[0][0]);
>+    result[0][1] = log2(x[0][1]);
>+    result[0][2] = log2(x[0][2]);
>+    result[0][3] = log2(x[0][3]);
>+    result[1][0] = log2(x[1][0]);
>+    result[1][1] = log2(x[1][1]);
>+    result[1][2] = log2(x[1][2]);
>+    result[1][3] = log2(x[1][3]);
>+    result[2][0] = log2(x[2][0]);
>+    result[2][1] = log2(x[2][1]);
>+    result[2][2] = log2(x[2][2]);
>+    result[2][3] = log2(x[2][3]);
>+    return result;
>+}
>+half4x2 log2(half4x2 x) {
>+    half4x2 result;
>+    result[0][0] = log2(x[0][0]);
>+    result[0][1] = log2(x[0][1]);
>+    result[1][0] = log2(x[1][0]);
>+    result[1][1] = log2(x[1][1]);
>+    result[2][0] = log2(x[2][0]);
>+    result[2][1] = log2(x[2][1]);
>+    result[3][0] = log2(x[3][0]);
>+    result[3][1] = log2(x[3][1]);
>+    return result;
>+}
>+half4x3 log2(half4x3 x) {
>+    half4x3 result;
>+    result[0][0] = log2(x[0][0]);
>+    result[0][1] = log2(x[0][1]);
>+    result[0][2] = log2(x[0][2]);
>+    result[1][0] = log2(x[1][0]);
>+    result[1][1] = log2(x[1][1]);
>+    result[1][2] = log2(x[1][2]);
>+    result[2][0] = log2(x[2][0]);
>+    result[2][1] = log2(x[2][1]);
>+    result[2][2] = log2(x[2][2]);
>+    result[3][0] = log2(x[3][0]);
>+    result[3][1] = log2(x[3][1]);
>+    result[3][2] = log2(x[3][2]);
>+    return result;
>+}
>+half4x4 log2(half4x4 x) {
>+    half4x4 result;
>+    result[0][0] = log2(x[0][0]);
>+    result[0][1] = log2(x[0][1]);
>+    result[0][2] = log2(x[0][2]);
>+    result[0][3] = log2(x[0][3]);
>+    result[1][0] = log2(x[1][0]);
>+    result[1][1] = log2(x[1][1]);
>+    result[1][2] = log2(x[1][2]);
>+    result[1][3] = log2(x[1][3]);
>+    result[2][0] = log2(x[2][0]);
>+    result[2][1] = log2(x[2][1]);
>+    result[2][2] = log2(x[2][2]);
>+    result[2][3] = log2(x[2][3]);
>+    result[3][0] = log2(x[3][0]);
>+    result[3][1] = log2(x[3][1]);
>+    result[3][2] = log2(x[3][2]);
>+    result[3][3] = log2(x[3][3]);
>+    return result;
>+}
>+float log2(float x) {
>+    return log(x) / log(float(2));
>+}
>+float2 log2(float2 x) {
>+    float2 result;
>+    result[0] = log2(x[0]);
>+    result[1] = log2(x[1]);
>+    return result;
>+}
>+float3 log2(float3 x) {
>+    float3 result;
>+    result[0] = log2(x[0]);
>+    result[1] = log2(x[1]);
>+    result[2] = log2(x[2]);
>+    return result;
>+}
>+float4 log2(float4 x) {
>+    float4 result;
>+    result[0] = log2(x[0]);
>+    result[1] = log2(x[1]);
>+    result[2] = log2(x[2]);
>+    result[3] = log2(x[3]);
>+    return result;
>+}
>+float2x2 log2(float2x2 x) {
>+    float2x2 result;
>+    result[0][0] = log2(x[0][0]);
>+    result[0][1] = log2(x[0][1]);
>+    result[1][0] = log2(x[1][0]);
>+    result[1][1] = log2(x[1][1]);
>+    return result;
>+}
>+float2x3 log2(float2x3 x) {
>+    float2x3 result;
>+    result[0][0] = log2(x[0][0]);
>+    result[0][1] = log2(x[0][1]);
>+    result[0][2] = log2(x[0][2]);
>+    result[1][0] = log2(x[1][0]);
>+    result[1][1] = log2(x[1][1]);
>+    result[1][2] = log2(x[1][2]);
>+    return result;
>+}
>+float2x4 log2(float2x4 x) {
>+    float2x4 result;
>+    result[0][0] = log2(x[0][0]);
>+    result[0][1] = log2(x[0][1]);
>+    result[0][2] = log2(x[0][2]);
>+    result[0][3] = log2(x[0][3]);
>+    result[1][0] = log2(x[1][0]);
>+    result[1][1] = log2(x[1][1]);
>+    result[1][2] = log2(x[1][2]);
>+    result[1][3] = log2(x[1][3]);
>+    return result;
>+}
>+float3x2 log2(float3x2 x) {
>+    float3x2 result;
>+    result[0][0] = log2(x[0][0]);
>+    result[0][1] = log2(x[0][1]);
>+    result[1][0] = log2(x[1][0]);
>+    result[1][1] = log2(x[1][1]);
>+    result[2][0] = log2(x[2][0]);
>+    result[2][1] = log2(x[2][1]);
>+    return result;
>+}
>+float3x3 log2(float3x3 x) {
>+    float3x3 result;
>+    result[0][0] = log2(x[0][0]);
>+    result[0][1] = log2(x[0][1]);
>+    result[0][2] = log2(x[0][2]);
>+    result[1][0] = log2(x[1][0]);
>+    result[1][1] = log2(x[1][1]);
>+    result[1][2] = log2(x[1][2]);
>+    result[2][0] = log2(x[2][0]);
>+    result[2][1] = log2(x[2][1]);
>+    result[2][2] = log2(x[2][2]);
>+    return result;
>+}
>+float3x4 log2(float3x4 x) {
>+    float3x4 result;
>+    result[0][0] = log2(x[0][0]);
>+    result[0][1] = log2(x[0][1]);
>+    result[0][2] = log2(x[0][2]);
>+    result[0][3] = log2(x[0][3]);
>+    result[1][0] = log2(x[1][0]);
>+    result[1][1] = log2(x[1][1]);
>+    result[1][2] = log2(x[1][2]);
>+    result[1][3] = log2(x[1][3]);
>+    result[2][0] = log2(x[2][0]);
>+    result[2][1] = log2(x[2][1]);
>+    result[2][2] = log2(x[2][2]);
>+    result[2][3] = log2(x[2][3]);
>+    return result;
>+}
>+float4x2 log2(float4x2 x) {
>+    float4x2 result;
>+    result[0][0] = log2(x[0][0]);
>+    result[0][1] = log2(x[0][1]);
>+    result[1][0] = log2(x[1][0]);
>+    result[1][1] = log2(x[1][1]);
>+    result[2][0] = log2(x[2][0]);
>+    result[2][1] = log2(x[2][1]);
>+    result[3][0] = log2(x[3][0]);
>+    result[3][1] = log2(x[3][1]);
>+    return result;
>+}
>+float4x3 log2(float4x3 x) {
>+    float4x3 result;
>+    result[0][0] = log2(x[0][0]);
>+    result[0][1] = log2(x[0][1]);
>+    result[0][2] = log2(x[0][2]);
>+    result[1][0] = log2(x[1][0]);
>+    result[1][1] = log2(x[1][1]);
>+    result[1][2] = log2(x[1][2]);
>+    result[2][0] = log2(x[2][0]);
>+    result[2][1] = log2(x[2][1]);
>+    result[2][2] = log2(x[2][2]);
>+    result[3][0] = log2(x[3][0]);
>+    result[3][1] = log2(x[3][1]);
>+    result[3][2] = log2(x[3][2]);
>+    return result;
>+}
>+float4x4 log2(float4x4 x) {
>+    float4x4 result;
>+    result[0][0] = log2(x[0][0]);
>+    result[0][1] = log2(x[0][1]);
>+    result[0][2] = log2(x[0][2]);
>+    result[0][3] = log2(x[0][3]);
>+    result[1][0] = log2(x[1][0]);
>+    result[1][1] = log2(x[1][1]);
>+    result[1][2] = log2(x[1][2]);
>+    result[1][3] = log2(x[1][3]);
>+    result[2][0] = log2(x[2][0]);
>+    result[2][1] = log2(x[2][1]);
>+    result[2][2] = log2(x[2][2]);
>+    result[2][3] = log2(x[2][3]);
>+    result[3][0] = log2(x[3][0]);
>+    result[3][1] = log2(x[3][1]);
>+    result[3][2] = log2(x[3][2]);
>+    result[3][3] = log2(x[3][3]);
>+    return result;
>+}
>+
>+/* Functions named normalize */
>+half normalize(half x) {
>+    return x / length(x);
>+}
>+half2 normalize(half2 x) {
>+    return x / length(x);
>+}
>+half3 normalize(half3 x) {
>+    return x / length(x);
>+}
>+half4 normalize(half4 x) {
>+    return x / length(x);
>+}
>+float normalize(float x) {
>+    return x / length(x);
>+}
>+float2 normalize(float2 x) {
>+    return x / length(x);
>+}
>+float3 normalize(float3 x) {
>+    return x / length(x);
>+}
>+float4 normalize(float4 x) {
>+    return x / length(x);
>+}
>+
>+
>+/* Functions named ldexp */
>+half ldexp(half x, half e) {
>+    return x * pow(2, e);
>+}
>+half2 ldexp(half2 x, half2 y) {
>+    half2 result;
>+    result[0] = ldexp(x[0], y[0]);
>+    result[1] = ldexp(x[1], y[1]);
>+    return result;
>+}
>+half3 ldexp(half3 x, half3 y) {
>+    half3 result;
>+    result[0] = ldexp(x[0], y[0]);
>+    result[1] = ldexp(x[1], y[1]);
>+    result[2] = ldexp(x[2], y[2]);
>+    return result;
>+}
>+half4 ldexp(half4 x, half4 y) {
>+    half4 result;
>+    result[0] = ldexp(x[0], y[0]);
>+    result[1] = ldexp(x[1], y[1]);
>+    result[2] = ldexp(x[2], y[2]);
>+    result[3] = ldexp(x[3], y[3]);
>+    return result;
>+}
>+half2x2 ldexp(half2x2 x, half2x2 y) {
>+    half2x2 result;
>+    result[0][0] = ldexp(x[0][0], y[0][0]);
>+    result[0][1] = ldexp(x[0][1], y[0][1]);
>+    result[1][0] = ldexp(x[1][0], y[1][0]);
>+    result[1][1] = ldexp(x[1][1], y[1][1]);
>+    return result;
>+}
>+half2x3 ldexp(half2x3 x, half2x3 y) {
>+    half2x3 result;
>+    result[0][0] = ldexp(x[0][0], y[0][0]);
>+    result[0][1] = ldexp(x[0][1], y[0][1]);
>+    result[0][2] = ldexp(x[0][2], y[0][2]);
>+    result[1][0] = ldexp(x[1][0], y[1][0]);
>+    result[1][1] = ldexp(x[1][1], y[1][1]);
>+    result[1][2] = ldexp(x[1][2], y[1][2]);
>+    return result;
>+}
>+half2x4 ldexp(half2x4 x, half2x4 y) {
>+    half2x4 result;
>+    result[0][0] = ldexp(x[0][0], y[0][0]);
>+    result[0][1] = ldexp(x[0][1], y[0][1]);
>+    result[0][2] = ldexp(x[0][2], y[0][2]);
>+    result[0][3] = ldexp(x[0][3], y[0][3]);
>+    result[1][0] = ldexp(x[1][0], y[1][0]);
>+    result[1][1] = ldexp(x[1][1], y[1][1]);
>+    result[1][2] = ldexp(x[1][2], y[1][2]);
>+    result[1][3] = ldexp(x[1][3], y[1][3]);
>+    return result;
>+}
>+half3x2 ldexp(half3x2 x, half3x2 y) {
>+    half3x2 result;
>+    result[0][0] = ldexp(x[0][0], y[0][0]);
>+    result[0][1] = ldexp(x[0][1], y[0][1]);
>+    result[1][0] = ldexp(x[1][0], y[1][0]);
>+    result[1][1] = ldexp(x[1][1], y[1][1]);
>+    result[2][0] = ldexp(x[2][0], y[2][0]);
>+    result[2][1] = ldexp(x[2][1], y[2][1]);
>+    return result;
>+}
>+half3x3 ldexp(half3x3 x, half3x3 y) {
>+    half3x3 result;
>+    result[0][0] = ldexp(x[0][0], y[0][0]);
>+    result[0][1] = ldexp(x[0][1], y[0][1]);
>+    result[0][2] = ldexp(x[0][2], y[0][2]);
>+    result[1][0] = ldexp(x[1][0], y[1][0]);
>+    result[1][1] = ldexp(x[1][1], y[1][1]);
>+    result[1][2] = ldexp(x[1][2], y[1][2]);
>+    result[2][0] = ldexp(x[2][0], y[2][0]);
>+    result[2][1] = ldexp(x[2][1], y[2][1]);
>+    result[2][2] = ldexp(x[2][2], y[2][2]);
>+    return result;
>+}
>+half3x4 ldexp(half3x4 x, half3x4 y) {
>+    half3x4 result;
>+    result[0][0] = ldexp(x[0][0], y[0][0]);
>+    result[0][1] = ldexp(x[0][1], y[0][1]);
>+    result[0][2] = ldexp(x[0][2], y[0][2]);
>+    result[0][3] = ldexp(x[0][3], y[0][3]);
>+    result[1][0] = ldexp(x[1][0], y[1][0]);
>+    result[1][1] = ldexp(x[1][1], y[1][1]);
>+    result[1][2] = ldexp(x[1][2], y[1][2]);
>+    result[1][3] = ldexp(x[1][3], y[1][3]);
>+    result[2][0] = ldexp(x[2][0], y[2][0]);
>+    result[2][1] = ldexp(x[2][1], y[2][1]);
>+    result[2][2] = ldexp(x[2][2], y[2][2]);
>+    result[2][3] = ldexp(x[2][3], y[2][3]);
>+    return result;
>+}
>+half4x2 ldexp(half4x2 x, half4x2 y) {
>+    half4x2 result;
>+    result[0][0] = ldexp(x[0][0], y[0][0]);
>+    result[0][1] = ldexp(x[0][1], y[0][1]);
>+    result[1][0] = ldexp(x[1][0], y[1][0]);
>+    result[1][1] = ldexp(x[1][1], y[1][1]);
>+    result[2][0] = ldexp(x[2][0], y[2][0]);
>+    result[2][1] = ldexp(x[2][1], y[2][1]);
>+    result[3][0] = ldexp(x[3][0], y[3][0]);
>+    result[3][1] = ldexp(x[3][1], y[3][1]);
>+    return result;
>+}
>+half4x3 ldexp(half4x3 x, half4x3 y) {
>+    half4x3 result;
>+    result[0][0] = ldexp(x[0][0], y[0][0]);
>+    result[0][1] = ldexp(x[0][1], y[0][1]);
>+    result[0][2] = ldexp(x[0][2], y[0][2]);
>+    result[1][0] = ldexp(x[1][0], y[1][0]);
>+    result[1][1] = ldexp(x[1][1], y[1][1]);
>+    result[1][2] = ldexp(x[1][2], y[1][2]);
>+    result[2][0] = ldexp(x[2][0], y[2][0]);
>+    result[2][1] = ldexp(x[2][1], y[2][1]);
>+    result[2][2] = ldexp(x[2][2], y[2][2]);
>+    result[3][0] = ldexp(x[3][0], y[3][0]);
>+    result[3][1] = ldexp(x[3][1], y[3][1]);
>+    result[3][2] = ldexp(x[3][2], y[3][2]);
>+    return result;
>+}
>+half4x4 ldexp(half4x4 x, half4x4 y) {
>+    half4x4 result;
>+    result[0][0] = ldexp(x[0][0], y[0][0]);
>+    result[0][1] = ldexp(x[0][1], y[0][1]);
>+    result[0][2] = ldexp(x[0][2], y[0][2]);
>+    result[0][3] = ldexp(x[0][3], y[0][3]);
>+    result[1][0] = ldexp(x[1][0], y[1][0]);
>+    result[1][1] = ldexp(x[1][1], y[1][1]);
>+    result[1][2] = ldexp(x[1][2], y[1][2]);
>+    result[1][3] = ldexp(x[1][3], y[1][3]);
>+    result[2][0] = ldexp(x[2][0], y[2][0]);
>+    result[2][1] = ldexp(x[2][1], y[2][1]);
>+    result[2][2] = ldexp(x[2][2], y[2][2]);
>+    result[2][3] = ldexp(x[2][3], y[2][3]);
>+    result[3][0] = ldexp(x[3][0], y[3][0]);
>+    result[3][1] = ldexp(x[3][1], y[3][1]);
>+    result[3][2] = ldexp(x[3][2], y[3][2]);
>+    result[3][3] = ldexp(x[3][3], y[3][3]);
>+    return result;
>+}
>+float ldexp(float x, float e) {
>+    return x * pow(2, e);
>+}
>+float2 ldexp(float2 x, float2 y) {
>+    float2 result;
>+    result[0] = ldexp(x[0], y[0]);
>+    result[1] = ldexp(x[1], y[1]);
>+    return result;
>+}
>+float3 ldexp(float3 x, float3 y) {
>+    float3 result;
>+    result[0] = ldexp(x[0], y[0]);
>+    result[1] = ldexp(x[1], y[1]);
>+    result[2] = ldexp(x[2], y[2]);
>+    return result;
>+}
>+float4 ldexp(float4 x, float4 y) {
>+    float4 result;
>+    result[0] = ldexp(x[0], y[0]);
>+    result[1] = ldexp(x[1], y[1]);
>+    result[2] = ldexp(x[2], y[2]);
>+    result[3] = ldexp(x[3], y[3]);
>+    return result;
>+}
>+float2x2 ldexp(float2x2 x, float2x2 y) {
>+    float2x2 result;
>+    result[0][0] = ldexp(x[0][0], y[0][0]);
>+    result[0][1] = ldexp(x[0][1], y[0][1]);
>+    result[1][0] = ldexp(x[1][0], y[1][0]);
>+    result[1][1] = ldexp(x[1][1], y[1][1]);
>+    return result;
>+}
>+float2x3 ldexp(float2x3 x, float2x3 y) {
>+    float2x3 result;
>+    result[0][0] = ldexp(x[0][0], y[0][0]);
>+    result[0][1] = ldexp(x[0][1], y[0][1]);
>+    result[0][2] = ldexp(x[0][2], y[0][2]);
>+    result[1][0] = ldexp(x[1][0], y[1][0]);
>+    result[1][1] = ldexp(x[1][1], y[1][1]);
>+    result[1][2] = ldexp(x[1][2], y[1][2]);
>+    return result;
>+}
>+float2x4 ldexp(float2x4 x, float2x4 y) {
>+    float2x4 result;
>+    result[0][0] = ldexp(x[0][0], y[0][0]);
>+    result[0][1] = ldexp(x[0][1], y[0][1]);
>+    result[0][2] = ldexp(x[0][2], y[0][2]);
>+    result[0][3] = ldexp(x[0][3], y[0][3]);
>+    result[1][0] = ldexp(x[1][0], y[1][0]);
>+    result[1][1] = ldexp(x[1][1], y[1][1]);
>+    result[1][2] = ldexp(x[1][2], y[1][2]);
>+    result[1][3] = ldexp(x[1][3], y[1][3]);
>+    return result;
>+}
>+float3x2 ldexp(float3x2 x, float3x2 y) {
>+    float3x2 result;
>+    result[0][0] = ldexp(x[0][0], y[0][0]);
>+    result[0][1] = ldexp(x[0][1], y[0][1]);
>+    result[1][0] = ldexp(x[1][0], y[1][0]);
>+    result[1][1] = ldexp(x[1][1], y[1][1]);
>+    result[2][0] = ldexp(x[2][0], y[2][0]);
>+    result[2][1] = ldexp(x[2][1], y[2][1]);
>+    return result;
>+}
>+float3x3 ldexp(float3x3 x, float3x3 y) {
>+    float3x3 result;
>+    result[0][0] = ldexp(x[0][0], y[0][0]);
>+    result[0][1] = ldexp(x[0][1], y[0][1]);
>+    result[0][2] = ldexp(x[0][2], y[0][2]);
>+    result[1][0] = ldexp(x[1][0], y[1][0]);
>+    result[1][1] = ldexp(x[1][1], y[1][1]);
>+    result[1][2] = ldexp(x[1][2], y[1][2]);
>+    result[2][0] = ldexp(x[2][0], y[2][0]);
>+    result[2][1] = ldexp(x[2][1], y[2][1]);
>+    result[2][2] = ldexp(x[2][2], y[2][2]);
>+    return result;
>+}
>+float3x4 ldexp(float3x4 x, float3x4 y) {
>+    float3x4 result;
>+    result[0][0] = ldexp(x[0][0], y[0][0]);
>+    result[0][1] = ldexp(x[0][1], y[0][1]);
>+    result[0][2] = ldexp(x[0][2], y[0][2]);
>+    result[0][3] = ldexp(x[0][3], y[0][3]);
>+    result[1][0] = ldexp(x[1][0], y[1][0]);
>+    result[1][1] = ldexp(x[1][1], y[1][1]);
>+    result[1][2] = ldexp(x[1][2], y[1][2]);
>+    result[1][3] = ldexp(x[1][3], y[1][3]);
>+    result[2][0] = ldexp(x[2][0], y[2][0]);
>+    result[2][1] = ldexp(x[2][1], y[2][1]);
>+    result[2][2] = ldexp(x[2][2], y[2][2]);
>+    result[2][3] = ldexp(x[2][3], y[2][3]);
>+    return result;
>+}
>+float4x2 ldexp(float4x2 x, float4x2 y) {
>+    float4x2 result;
>+    result[0][0] = ldexp(x[0][0], y[0][0]);
>+    result[0][1] = ldexp(x[0][1], y[0][1]);
>+    result[1][0] = ldexp(x[1][0], y[1][0]);
>+    result[1][1] = ldexp(x[1][1], y[1][1]);
>+    result[2][0] = ldexp(x[2][0], y[2][0]);
>+    result[2][1] = ldexp(x[2][1], y[2][1]);
>+    result[3][0] = ldexp(x[3][0], y[3][0]);
>+    result[3][1] = ldexp(x[3][1], y[3][1]);
>+    return result;
>+}
>+float4x3 ldexp(float4x3 x, float4x3 y) {
>+    float4x3 result;
>+    result[0][0] = ldexp(x[0][0], y[0][0]);
>+    result[0][1] = ldexp(x[0][1], y[0][1]);
>+    result[0][2] = ldexp(x[0][2], y[0][2]);
>+    result[1][0] = ldexp(x[1][0], y[1][0]);
>+    result[1][1] = ldexp(x[1][1], y[1][1]);
>+    result[1][2] = ldexp(x[1][2], y[1][2]);
>+    result[2][0] = ldexp(x[2][0], y[2][0]);
>+    result[2][1] = ldexp(x[2][1], y[2][1]);
>+    result[2][2] = ldexp(x[2][2], y[2][2]);
>+    result[3][0] = ldexp(x[3][0], y[3][0]);
>+    result[3][1] = ldexp(x[3][1], y[3][1]);
>+    result[3][2] = ldexp(x[3][2], y[3][2]);
>+    return result;
>+}
>+float4x4 ldexp(float4x4 x, float4x4 y) {
>+    float4x4 result;
>+    result[0][0] = ldexp(x[0][0], y[0][0]);
>+    result[0][1] = ldexp(x[0][1], y[0][1]);
>+    result[0][2] = ldexp(x[0][2], y[0][2]);
>+    result[0][3] = ldexp(x[0][3], y[0][3]);
>+    result[1][0] = ldexp(x[1][0], y[1][0]);
>+    result[1][1] = ldexp(x[1][1], y[1][1]);
>+    result[1][2] = ldexp(x[1][2], y[1][2]);
>+    result[1][3] = ldexp(x[1][3], y[1][3]);
>+    result[2][0] = ldexp(x[2][0], y[2][0]);
>+    result[2][1] = ldexp(x[2][1], y[2][1]);
>+    result[2][2] = ldexp(x[2][2], y[2][2]);
>+    result[2][3] = ldexp(x[2][3], y[2][3]);
>+    result[3][0] = ldexp(x[3][0], y[3][0]);
>+    result[3][1] = ldexp(x[3][1], y[3][1]);
>+    result[3][2] = ldexp(x[3][2], y[3][2]);
>+    result[3][3] = ldexp(x[3][3], y[3][3]);
>+    return result;
>+}
>+
>+/* Functions named operator.xzwz */
>+bool4 operator.xzwz(bool4 v) {
>+    bool4 result;
>+    result.x = v.x;
>+    result.y = v.z;
>+    result.z = v.w;
>+    result.w = v.z;
>+    return result;
>+}
>+uchar4 operator.xzwz(uchar4 v) {
>+    uchar4 result;
>+    result.x = v.x;
>+    result.y = v.z;
>+    result.z = v.w;
>+    result.w = v.z;
>+    return result;
>+}
>+ushort4 operator.xzwz(ushort4 v) {
>+    ushort4 result;
>+    result.x = v.x;
>+    result.y = v.z;
>+    result.z = v.w;
>+    result.w = v.z;
>+    return result;
>+}
>+uint4 operator.xzwz(uint4 v) {
>+    uint4 result;
>+    result.x = v.x;
>+    result.y = v.z;
>+    result.z = v.w;
>+    result.w = v.z;
>+    return result;
>+}
>+char4 operator.xzwz(char4 v) {
>+    char4 result;
>+    result.x = v.x;
>+    result.y = v.z;
>+    result.z = v.w;
>+    result.w = v.z;
>+    return result;
>+}
>+short4 operator.xzwz(short4 v) {
>+    short4 result;
>+    result.x = v.x;
>+    result.y = v.z;
>+    result.z = v.w;
>+    result.w = v.z;
>+    return result;
>+}
>+int4 operator.xzwz(int4 v) {
>+    int4 result;
>+    result.x = v.x;
>+    result.y = v.z;
>+    result.z = v.w;
>+    result.w = v.z;
>+    return result;
>+}
>+half4 operator.xzwz(half4 v) {
>+    half4 result;
>+    result.x = v.x;
>+    result.y = v.z;
>+    result.z = v.w;
>+    result.w = v.z;
>+    return result;
>+}
>+float4 operator.xzwz(float4 v) {
>+    float4 result;
>+    result.x = v.x;
>+    result.y = v.z;
>+    result.z = v.w;
>+    result.w = v.z;
>+    return result;
>+}
>+
>+/* Functions named operator.wxyx */
>+bool4 operator.wxyx(bool4 v) {
>+    bool4 result;
>+    result.x = v.w;
>+    result.y = v.x;
>+    result.z = v.y;
>+    result.w = v.x;
>+    return result;
>+}
>+uchar4 operator.wxyx(uchar4 v) {
>+    uchar4 result;
>+    result.x = v.w;
>+    result.y = v.x;
>+    result.z = v.y;
>+    result.w = v.x;
>+    return result;
>+}
>+ushort4 operator.wxyx(ushort4 v) {
>+    ushort4 result;
>+    result.x = v.w;
>+    result.y = v.x;
>+    result.z = v.y;
>+    result.w = v.x;
>+    return result;
>+}
>+uint4 operator.wxyx(uint4 v) {
>+    uint4 result;
>+    result.x = v.w;
>+    result.y = v.x;
>+    result.z = v.y;
>+    result.w = v.x;
>+    return result;
>+}
>+char4 operator.wxyx(char4 v) {
>+    char4 result;
>+    result.x = v.w;
>+    result.y = v.x;
>+    result.z = v.y;
>+    result.w = v.x;
>+    return result;
>+}
>+short4 operator.wxyx(short4 v) {
>+    short4 result;
>+    result.x = v.w;
>+    result.y = v.x;
>+    result.z = v.y;
>+    result.w = v.x;
>+    return result;
>+}
>+int4 operator.wxyx(int4 v) {
>+    int4 result;
>+    result.x = v.w;
>+    result.y = v.x;
>+    result.z = v.y;
>+    result.w = v.x;
>+    return result;
>+}
>+half4 operator.wxyx(half4 v) {
>+    half4 result;
>+    result.x = v.w;
>+    result.y = v.x;
>+    result.z = v.y;
>+    result.w = v.x;
>+    return result;
>+}
>+float4 operator.wxyx(float4 v) {
>+    float4 result;
>+    result.x = v.w;
>+    result.y = v.x;
>+    result.z = v.y;
>+    result.w = v.x;
>+    return result;
>+}
>+
>+/* Functions named operator.ywxw */
>+bool4 operator.ywxw(bool4 v) {
>+    bool4 result;
>+    result.x = v.y;
>+    result.y = v.w;
>+    result.z = v.x;
>+    result.w = v.w;
>+    return result;
>+}
>+uchar4 operator.ywxw(uchar4 v) {
>+    uchar4 result;
>+    result.x = v.y;
>+    result.y = v.w;
>+    result.z = v.x;
>+    result.w = v.w;
>+    return result;
>+}
>+ushort4 operator.ywxw(ushort4 v) {
>+    ushort4 result;
>+    result.x = v.y;
>+    result.y = v.w;
>+    result.z = v.x;
>+    result.w = v.w;
>+    return result;
>+}
>+uint4 operator.ywxw(uint4 v) {
>+    uint4 result;
>+    result.x = v.y;
>+    result.y = v.w;
>+    result.z = v.x;
>+    result.w = v.w;
>+    return result;
>+}
>+char4 operator.ywxw(char4 v) {
>+    char4 result;
>+    result.x = v.y;
>+    result.y = v.w;
>+    result.z = v.x;
>+    result.w = v.w;
>+    return result;
>+}
>+short4 operator.ywxw(short4 v) {
>+    short4 result;
>+    result.x = v.y;
>+    result.y = v.w;
>+    result.z = v.x;
>+    result.w = v.w;
>+    return result;
>+}
>+int4 operator.ywxw(int4 v) {
>+    int4 result;
>+    result.x = v.y;
>+    result.y = v.w;
>+    result.z = v.x;
>+    result.w = v.w;
>+    return result;
>+}
>+half4 operator.ywxw(half4 v) {
>+    half4 result;
>+    result.x = v.y;
>+    result.y = v.w;
>+    result.z = v.x;
>+    result.w = v.w;
>+    return result;
>+}
>+float4 operator.ywxw(float4 v) {
>+    float4 result;
>+    result.x = v.y;
>+    result.y = v.w;
>+    result.z = v.x;
>+    result.w = v.w;
>+    return result;
>+}
>+
>+/* Functions named operator.zyyz */
>+bool4 operator.zyyz(bool3 v) {
>+    bool4 result;
>+    result.x = v.z;
>+    result.y = v.y;
>+    result.z = v.y;
>+    result.w = v.z;
>+    return result;
>+}
>+bool4 operator.zyyz(bool4 v) {
>+    bool4 result;
>+    result.x = v.z;
>+    result.y = v.y;
>+    result.z = v.y;
>+    result.w = v.z;
>+    return result;
>+}
>+uchar4 operator.zyyz(uchar3 v) {
>+    uchar4 result;
>+    result.x = v.z;
>+    result.y = v.y;
>+    result.z = v.y;
>+    result.w = v.z;
>+    return result;
>+}
>+uchar4 operator.zyyz(uchar4 v) {
>+    uchar4 result;
>+    result.x = v.z;
>+    result.y = v.y;
>+    result.z = v.y;
>+    result.w = v.z;
>+    return result;
>+}
>+ushort4 operator.zyyz(ushort3 v) {
>+    ushort4 result;
>+    result.x = v.z;
>+    result.y = v.y;
>+    result.z = v.y;
>+    result.w = v.z;
>+    return result;
>+}
>+ushort4 operator.zyyz(ushort4 v) {
>+    ushort4 result;
>+    result.x = v.z;
>+    result.y = v.y;
>+    result.z = v.y;
>+    result.w = v.z;
>+    return result;
>+}
>+uint4 operator.zyyz(uint3 v) {
>+    uint4 result;
>+    result.x = v.z;
>+    result.y = v.y;
>+    result.z = v.y;
>+    result.w = v.z;
>+    return result;
>+}
>+uint4 operator.zyyz(uint4 v) {
>+    uint4 result;
>+    result.x = v.z;
>+    result.y = v.y;
>+    result.z = v.y;
>+    result.w = v.z;
>+    return result;
>+}
>+char4 operator.zyyz(char3 v) {
>+    char4 result;
>+    result.x = v.z;
>+    result.y = v.y;
>+    result.z = v.y;
>+    result.w = v.z;
>+    return result;
>+}
>+char4 operator.zyyz(char4 v) {
>+    char4 result;
>+    result.x = v.z;
>+    result.y = v.y;
>+    result.z = v.y;
>+    result.w = v.z;
>+    return result;
>+}
>+short4 operator.zyyz(short3 v) {
>+    short4 result;
>+    result.x = v.z;
>+    result.y = v.y;
>+    result.z = v.y;
>+    result.w = v.z;
>+    return result;
>+}
>+short4 operator.zyyz(short4 v) {
>+    short4 result;
>+    result.x = v.z;
>+    result.y = v.y;
>+    result.z = v.y;
>+    result.w = v.z;
>+    return result;
>+}
>+int4 operator.zyyz(int3 v) {
>+    int4 result;
>+    result.x = v.z;
>+    result.y = v.y;
>+    result.z = v.y;
>+    result.w = v.z;
>+    return result;
>+}
>+int4 operator.zyyz(int4 v) {
>+    int4 result;
>+    result.x = v.z;
>+    result.y = v.y;
>+    result.z = v.y;
>+    result.w = v.z;
>+    return result;
>+}
>+half4 operator.zyyz(half3 v) {
>+    half4 result;
>+    result.x = v.z;
>+    result.y = v.y;
>+    result.z = v.y;
>+    result.w = v.z;
>+    return result;
>+}
>+half4 operator.zyyz(half4 v) {
>+    half4 result;
>+    result.x = v.z;
>+    result.y = v.y;
>+    result.z = v.y;
>+    result.w = v.z;
>+    return result;
>+}
>+float4 operator.zyyz(float3 v) {
>+    float4 result;
>+    result.x = v.z;
>+    result.y = v.y;
>+    result.z = v.y;
>+    result.w = v.z;
>+    return result;
>+}
>+float4 operator.zyyz(float4 v) {
>+    float4 result;
>+    result.x = v.z;
>+    result.y = v.y;
>+    result.z = v.y;
>+    result.w = v.z;
>+    return result;
>+}
>+
>+/* Functions named abs */
>+uchar abs(uchar x) {
>+    return x;
>+}
>+ushort abs(ushort x) {
>+    return x;
>+}
>+uint abs(uint x) {
>+    return x;
>+}
>+char abs(char x) {
>+    if (x < 0)
>+        return -x;
>+    return x;
>+}
>+short abs(short x) {
>+    if (x < 0)
>+        return -x;
>+    return x;
>+}
>+int abs(int x) {
>+    if (x < 0)
>+        return -x;
>+    return x;
>+}
>+half abs(half x) {
>+    if (x < 0)
>+        return -x;
>+    return x;
>+}
>+float abs(float x) {
>+    if (x < 0)
>+        return -x;
>+    return x;
>+}
>+uchar2 abs(uchar2 x) {
>+    uchar2 result;
>+    result[0] = abs(x[0]);
>+    result[1] = abs(x[1]);
>+    return result;
>+}
>+uchar3 abs(uchar3 x) {
>+    uchar3 result;
>+    result[0] = abs(x[0]);
>+    result[1] = abs(x[1]);
>+    result[2] = abs(x[2]);
>+    return result;
>+}
>+uchar4 abs(uchar4 x) {
>+    uchar4 result;
>+    result[0] = abs(x[0]);
>+    result[1] = abs(x[1]);
>+    result[2] = abs(x[2]);
>+    result[3] = abs(x[3]);
>+    return result;
>+}
>+ushort2 abs(ushort2 x) {
>+    ushort2 result;
>+    result[0] = abs(x[0]);
>+    result[1] = abs(x[1]);
>+    return result;
>+}
>+ushort3 abs(ushort3 x) {
>+    ushort3 result;
>+    result[0] = abs(x[0]);
>+    result[1] = abs(x[1]);
>+    result[2] = abs(x[2]);
>+    return result;
>+}
>+ushort4 abs(ushort4 x) {
>+    ushort4 result;
>+    result[0] = abs(x[0]);
>+    result[1] = abs(x[1]);
>+    result[2] = abs(x[2]);
>+    result[3] = abs(x[3]);
>+    return result;
>+}
>+uint2 abs(uint2 x) {
>+    uint2 result;
>+    result[0] = abs(x[0]);
>+    result[1] = abs(x[1]);
>+    return result;
>+}
>+uint3 abs(uint3 x) {
>+    uint3 result;
>+    result[0] = abs(x[0]);
>+    result[1] = abs(x[1]);
>+    result[2] = abs(x[2]);
>+    return result;
>+}
>+uint4 abs(uint4 x) {
>+    uint4 result;
>+    result[0] = abs(x[0]);
>+    result[1] = abs(x[1]);
>+    result[2] = abs(x[2]);
>+    result[3] = abs(x[3]);
>+    return result;
>+}
>+char2 abs(char2 x) {
>+    char2 result;
>+    result[0] = abs(x[0]);
>+    result[1] = abs(x[1]);
>+    return result;
>+}
>+char3 abs(char3 x) {
>+    char3 result;
>+    result[0] = abs(x[0]);
>+    result[1] = abs(x[1]);
>+    result[2] = abs(x[2]);
>+    return result;
>+}
>+char4 abs(char4 x) {
>+    char4 result;
>+    result[0] = abs(x[0]);
>+    result[1] = abs(x[1]);
>+    result[2] = abs(x[2]);
>+    result[3] = abs(x[3]);
>+    return result;
>+}
>+short2 abs(short2 x) {
>+    short2 result;
>+    result[0] = abs(x[0]);
>+    result[1] = abs(x[1]);
>+    return result;
>+}
>+short3 abs(short3 x) {
>+    short3 result;
>+    result[0] = abs(x[0]);
>+    result[1] = abs(x[1]);
>+    result[2] = abs(x[2]);
>+    return result;
>+}
>+short4 abs(short4 x) {
>+    short4 result;
>+    result[0] = abs(x[0]);
>+    result[1] = abs(x[1]);
>+    result[2] = abs(x[2]);
>+    result[3] = abs(x[3]);
>+    return result;
>+}
>+int2 abs(int2 x) {
>+    int2 result;
>+    result[0] = abs(x[0]);
>+    result[1] = abs(x[1]);
>+    return result;
>+}
>+int3 abs(int3 x) {
>+    int3 result;
>+    result[0] = abs(x[0]);
>+    result[1] = abs(x[1]);
>+    result[2] = abs(x[2]);
>+    return result;
>+}
>+int4 abs(int4 x) {
>+    int4 result;
>+    result[0] = abs(x[0]);
>+    result[1] = abs(x[1]);
>+    result[2] = abs(x[2]);
>+    result[3] = abs(x[3]);
>+    return result;
>+}
>+half2 abs(half2 x) {
>+    half2 result;
>+    result[0] = abs(x[0]);
>+    result[1] = abs(x[1]);
>+    return result;
>+}
>+half3 abs(half3 x) {
>+    half3 result;
>+    result[0] = abs(x[0]);
>+    result[1] = abs(x[1]);
>+    result[2] = abs(x[2]);
>+    return result;
>+}
>+half4 abs(half4 x) {
>+    half4 result;
>+    result[0] = abs(x[0]);
>+    result[1] = abs(x[1]);
>+    result[2] = abs(x[2]);
>+    result[3] = abs(x[3]);
>+    return result;
>+}
>+half2x2 abs(half2x2 x) {
>+    half2x2 result;
>+    result[0][0] = abs(x[0][0]);
>+    result[0][1] = abs(x[0][1]);
>+    result[1][0] = abs(x[1][0]);
>+    result[1][1] = abs(x[1][1]);
>+    return result;
>+}
>+half2x3 abs(half2x3 x) {
>+    half2x3 result;
>+    result[0][0] = abs(x[0][0]);
>+    result[0][1] = abs(x[0][1]);
>+    result[0][2] = abs(x[0][2]);
>+    result[1][0] = abs(x[1][0]);
>+    result[1][1] = abs(x[1][1]);
>+    result[1][2] = abs(x[1][2]);
>+    return result;
>+}
>+half2x4 abs(half2x4 x) {
>+    half2x4 result;
>+    result[0][0] = abs(x[0][0]);
>+    result[0][1] = abs(x[0][1]);
>+    result[0][2] = abs(x[0][2]);
>+    result[0][3] = abs(x[0][3]);
>+    result[1][0] = abs(x[1][0]);
>+    result[1][1] = abs(x[1][1]);
>+    result[1][2] = abs(x[1][2]);
>+    result[1][3] = abs(x[1][3]);
>+    return result;
>+}
>+half3x2 abs(half3x2 x) {
>+    half3x2 result;
>+    result[0][0] = abs(x[0][0]);
>+    result[0][1] = abs(x[0][1]);
>+    result[1][0] = abs(x[1][0]);
>+    result[1][1] = abs(x[1][1]);
>+    result[2][0] = abs(x[2][0]);
>+    result[2][1] = abs(x[2][1]);
>+    return result;
>+}
>+half3x3 abs(half3x3 x) {
>+    half3x3 result;
>+    result[0][0] = abs(x[0][0]);
>+    result[0][1] = abs(x[0][1]);
>+    result[0][2] = abs(x[0][2]);
>+    result[1][0] = abs(x[1][0]);
>+    result[1][1] = abs(x[1][1]);
>+    result[1][2] = abs(x[1][2]);
>+    result[2][0] = abs(x[2][0]);
>+    result[2][1] = abs(x[2][1]);
>+    result[2][2] = abs(x[2][2]);
>+    return result;
>+}
>+half3x4 abs(half3x4 x) {
>+    half3x4 result;
>+    result[0][0] = abs(x[0][0]);
>+    result[0][1] = abs(x[0][1]);
>+    result[0][2] = abs(x[0][2]);
>+    result[0][3] = abs(x[0][3]);
>+    result[1][0] = abs(x[1][0]);
>+    result[1][1] = abs(x[1][1]);
>+    result[1][2] = abs(x[1][2]);
>+    result[1][3] = abs(x[1][3]);
>+    result[2][0] = abs(x[2][0]);
>+    result[2][1] = abs(x[2][1]);
>+    result[2][2] = abs(x[2][2]);
>+    result[2][3] = abs(x[2][3]);
>+    return result;
>+}
>+half4x2 abs(half4x2 x) {
>+    half4x2 result;
>+    result[0][0] = abs(x[0][0]);
>+    result[0][1] = abs(x[0][1]);
>+    result[1][0] = abs(x[1][0]);
>+    result[1][1] = abs(x[1][1]);
>+    result[2][0] = abs(x[2][0]);
>+    result[2][1] = abs(x[2][1]);
>+    result[3][0] = abs(x[3][0]);
>+    result[3][1] = abs(x[3][1]);
>+    return result;
>+}
>+half4x3 abs(half4x3 x) {
>+    half4x3 result;
>+    result[0][0] = abs(x[0][0]);
>+    result[0][1] = abs(x[0][1]);
>+    result[0][2] = abs(x[0][2]);
>+    result[1][0] = abs(x[1][0]);
>+    result[1][1] = abs(x[1][1]);
>+    result[1][2] = abs(x[1][2]);
>+    result[2][0] = abs(x[2][0]);
>+    result[2][1] = abs(x[2][1]);
>+    result[2][2] = abs(x[2][2]);
>+    result[3][0] = abs(x[3][0]);
>+    result[3][1] = abs(x[3][1]);
>+    result[3][2] = abs(x[3][2]);
>+    return result;
>+}
>+half4x4 abs(half4x4 x) {
>+    half4x4 result;
>+    result[0][0] = abs(x[0][0]);
>+    result[0][1] = abs(x[0][1]);
>+    result[0][2] = abs(x[0][2]);
>+    result[0][3] = abs(x[0][3]);
>+    result[1][0] = abs(x[1][0]);
>+    result[1][1] = abs(x[1][1]);
>+    result[1][2] = abs(x[1][2]);
>+    result[1][3] = abs(x[1][3]);
>+    result[2][0] = abs(x[2][0]);
>+    result[2][1] = abs(x[2][1]);
>+    result[2][2] = abs(x[2][2]);
>+    result[2][3] = abs(x[2][3]);
>+    result[3][0] = abs(x[3][0]);
>+    result[3][1] = abs(x[3][1]);
>+    result[3][2] = abs(x[3][2]);
>+    result[3][3] = abs(x[3][3]);
>+    return result;
>+}
>+float2 abs(float2 x) {
>+    float2 result;
>+    result[0] = abs(x[0]);
>+    result[1] = abs(x[1]);
>+    return result;
>+}
>+float3 abs(float3 x) {
>+    float3 result;
>+    result[0] = abs(x[0]);
>+    result[1] = abs(x[1]);
>+    result[2] = abs(x[2]);
>+    return result;
>+}
>+float4 abs(float4 x) {
>+    float4 result;
>+    result[0] = abs(x[0]);
>+    result[1] = abs(x[1]);
>+    result[2] = abs(x[2]);
>+    result[3] = abs(x[3]);
>+    return result;
>+}
>+float2x2 abs(float2x2 x) {
>+    float2x2 result;
>+    result[0][0] = abs(x[0][0]);
>+    result[0][1] = abs(x[0][1]);
>+    result[1][0] = abs(x[1][0]);
>+    result[1][1] = abs(x[1][1]);
>+    return result;
>+}
>+float2x3 abs(float2x3 x) {
>+    float2x3 result;
>+    result[0][0] = abs(x[0][0]);
>+    result[0][1] = abs(x[0][1]);
>+    result[0][2] = abs(x[0][2]);
>+    result[1][0] = abs(x[1][0]);
>+    result[1][1] = abs(x[1][1]);
>+    result[1][2] = abs(x[1][2]);
>+    return result;
>+}
>+float2x4 abs(float2x4 x) {
>+    float2x4 result;
>+    result[0][0] = abs(x[0][0]);
>+    result[0][1] = abs(x[0][1]);
>+    result[0][2] = abs(x[0][2]);
>+    result[0][3] = abs(x[0][3]);
>+    result[1][0] = abs(x[1][0]);
>+    result[1][1] = abs(x[1][1]);
>+    result[1][2] = abs(x[1][2]);
>+    result[1][3] = abs(x[1][3]);
>+    return result;
>+}
>+float3x2 abs(float3x2 x) {
>+    float3x2 result;
>+    result[0][0] = abs(x[0][0]);
>+    result[0][1] = abs(x[0][1]);
>+    result[1][0] = abs(x[1][0]);
>+    result[1][1] = abs(x[1][1]);
>+    result[2][0] = abs(x[2][0]);
>+    result[2][1] = abs(x[2][1]);
>+    return result;
>+}
>+float3x3 abs(float3x3 x) {
>+    float3x3 result;
>+    result[0][0] = abs(x[0][0]);
>+    result[0][1] = abs(x[0][1]);
>+    result[0][2] = abs(x[0][2]);
>+    result[1][0] = abs(x[1][0]);
>+    result[1][1] = abs(x[1][1]);
>+    result[1][2] = abs(x[1][2]);
>+    result[2][0] = abs(x[2][0]);
>+    result[2][1] = abs(x[2][1]);
>+    result[2][2] = abs(x[2][2]);
>+    return result;
>+}
>+float3x4 abs(float3x4 x) {
>+    float3x4 result;
>+    result[0][0] = abs(x[0][0]);
>+    result[0][1] = abs(x[0][1]);
>+    result[0][2] = abs(x[0][2]);
>+    result[0][3] = abs(x[0][3]);
>+    result[1][0] = abs(x[1][0]);
>+    result[1][1] = abs(x[1][1]);
>+    result[1][2] = abs(x[1][2]);
>+    result[1][3] = abs(x[1][3]);
>+    result[2][0] = abs(x[2][0]);
>+    result[2][1] = abs(x[2][1]);
>+    result[2][2] = abs(x[2][2]);
>+    result[2][3] = abs(x[2][3]);
>+    return result;
>+}
>+float4x2 abs(float4x2 x) {
>+    float4x2 result;
>+    result[0][0] = abs(x[0][0]);
>+    result[0][1] = abs(x[0][1]);
>+    result[1][0] = abs(x[1][0]);
>+    result[1][1] = abs(x[1][1]);
>+    result[2][0] = abs(x[2][0]);
>+    result[2][1] = abs(x[2][1]);
>+    result[3][0] = abs(x[3][0]);
>+    result[3][1] = abs(x[3][1]);
>+    return result;
>+}
>+float4x3 abs(float4x3 x) {
>+    float4x3 result;
>+    result[0][0] = abs(x[0][0]);
>+    result[0][1] = abs(x[0][1]);
>+    result[0][2] = abs(x[0][2]);
>+    result[1][0] = abs(x[1][0]);
>+    result[1][1] = abs(x[1][1]);
>+    result[1][2] = abs(x[1][2]);
>+    result[2][0] = abs(x[2][0]);
>+    result[2][1] = abs(x[2][1]);
>+    result[2][2] = abs(x[2][2]);
>+    result[3][0] = abs(x[3][0]);
>+    result[3][1] = abs(x[3][1]);
>+    result[3][2] = abs(x[3][2]);
>+    return result;
>+}
>+float4x4 abs(float4x4 x) {
>+    float4x4 result;
>+    result[0][0] = abs(x[0][0]);
>+    result[0][1] = abs(x[0][1]);
>+    result[0][2] = abs(x[0][2]);
>+    result[0][3] = abs(x[0][3]);
>+    result[1][0] = abs(x[1][0]);
>+    result[1][1] = abs(x[1][1]);
>+    result[1][2] = abs(x[1][2]);
>+    result[1][3] = abs(x[1][3]);
>+    result[2][0] = abs(x[2][0]);
>+    result[2][1] = abs(x[2][1]);
>+    result[2][2] = abs(x[2][2]);
>+    result[2][3] = abs(x[2][3]);
>+    result[3][0] = abs(x[3][0]);
>+    result[3][1] = abs(x[3][1]);
>+    result[3][2] = abs(x[3][2]);
>+    result[3][3] = abs(x[3][3]);
>+    return result;
>+}
>+
>+
>+/* Functions named operator.wwyy */
>+bool4 operator.wwyy(bool4 v) {
>+    bool4 result;
>+    result.x = v.w;
>+    result.y = v.w;
>+    result.z = v.y;
>+    result.w = v.y;
>+    return result;
>+}
>+uchar4 operator.wwyy(uchar4 v) {
>+    uchar4 result;
>+    result.x = v.w;
>+    result.y = v.w;
>+    result.z = v.y;
>+    result.w = v.y;
>+    return result;
>+}
>+ushort4 operator.wwyy(ushort4 v) {
>+    ushort4 result;
>+    result.x = v.w;
>+    result.y = v.w;
>+    result.z = v.y;
>+    result.w = v.y;
>+    return result;
>+}
>+uint4 operator.wwyy(uint4 v) {
>+    uint4 result;
>+    result.x = v.w;
>+    result.y = v.w;
>+    result.z = v.y;
>+    result.w = v.y;
>+    return result;
>+}
>+char4 operator.wwyy(char4 v) {
>+    char4 result;
>+    result.x = v.w;
>+    result.y = v.w;
>+    result.z = v.y;
>+    result.w = v.y;
>+    return result;
>+}
>+short4 operator.wwyy(short4 v) {
>+    short4 result;
>+    result.x = v.w;
>+    result.y = v.w;
>+    result.z = v.y;
>+    result.w = v.y;
>+    return result;
>+}
>+int4 operator.wwyy(int4 v) {
>+    int4 result;
>+    result.x = v.w;
>+    result.y = v.w;
>+    result.z = v.y;
>+    result.w = v.y;
>+    return result;
>+}
>+half4 operator.wwyy(half4 v) {
>+    half4 result;
>+    result.x = v.w;
>+    result.y = v.w;
>+    result.z = v.y;
>+    result.w = v.y;
>+    return result;
>+}
>+float4 operator.wwyy(float4 v) {
>+    float4 result;
>+    result.x = v.w;
>+    result.y = v.w;
>+    result.z = v.y;
>+    result.w = v.y;
>+    return result;
>+}
>+
>+/* Functions named round */
>+native float round(float);
>+half round(half x) {
>+    return half(round(float(x)));
>+}
>+half2 round(half2 x) {
>+    half2 result;
>+    result[0] = round(x[0]);
>+    result[1] = round(x[1]);
>+    return result;
>+}
>+half3 round(half3 x) {
>+    half3 result;
>+    result[0] = round(x[0]);
>+    result[1] = round(x[1]);
>+    result[2] = round(x[2]);
>+    return result;
>+}
>+half4 round(half4 x) {
>+    half4 result;
>+    result[0] = round(x[0]);
>+    result[1] = round(x[1]);
>+    result[2] = round(x[2]);
>+    result[3] = round(x[3]);
>+    return result;
>+}
>+half2x2 round(half2x2 x) {
>+    half2x2 result;
>+    result[0][0] = round(x[0][0]);
>+    result[0][1] = round(x[0][1]);
>+    result[1][0] = round(x[1][0]);
>+    result[1][1] = round(x[1][1]);
>+    return result;
>+}
>+half2x3 round(half2x3 x) {
>+    half2x3 result;
>+    result[0][0] = round(x[0][0]);
>+    result[0][1] = round(x[0][1]);
>+    result[0][2] = round(x[0][2]);
>+    result[1][0] = round(x[1][0]);
>+    result[1][1] = round(x[1][1]);
>+    result[1][2] = round(x[1][2]);
>+    return result;
>+}
>+half2x4 round(half2x4 x) {
>+    half2x4 result;
>+    result[0][0] = round(x[0][0]);
>+    result[0][1] = round(x[0][1]);
>+    result[0][2] = round(x[0][2]);
>+    result[0][3] = round(x[0][3]);
>+    result[1][0] = round(x[1][0]);
>+    result[1][1] = round(x[1][1]);
>+    result[1][2] = round(x[1][2]);
>+    result[1][3] = round(x[1][3]);
>+    return result;
>+}
>+half3x2 round(half3x2 x) {
>+    half3x2 result;
>+    result[0][0] = round(x[0][0]);
>+    result[0][1] = round(x[0][1]);
>+    result[1][0] = round(x[1][0]);
>+    result[1][1] = round(x[1][1]);
>+    result[2][0] = round(x[2][0]);
>+    result[2][1] = round(x[2][1]);
>+    return result;
>+}
>+half3x3 round(half3x3 x) {
>+    half3x3 result;
>+    result[0][0] = round(x[0][0]);
>+    result[0][1] = round(x[0][1]);
>+    result[0][2] = round(x[0][2]);
>+    result[1][0] = round(x[1][0]);
>+    result[1][1] = round(x[1][1]);
>+    result[1][2] = round(x[1][2]);
>+    result[2][0] = round(x[2][0]);
>+    result[2][1] = round(x[2][1]);
>+    result[2][2] = round(x[2][2]);
>+    return result;
>+}
>+half3x4 round(half3x4 x) {
>+    half3x4 result;
>+    result[0][0] = round(x[0][0]);
>+    result[0][1] = round(x[0][1]);
>+    result[0][2] = round(x[0][2]);
>+    result[0][3] = round(x[0][3]);
>+    result[1][0] = round(x[1][0]);
>+    result[1][1] = round(x[1][1]);
>+    result[1][2] = round(x[1][2]);
>+    result[1][3] = round(x[1][3]);
>+    result[2][0] = round(x[2][0]);
>+    result[2][1] = round(x[2][1]);
>+    result[2][2] = round(x[2][2]);
>+    result[2][3] = round(x[2][3]);
>+    return result;
>+}
>+half4x2 round(half4x2 x) {
>+    half4x2 result;
>+    result[0][0] = round(x[0][0]);
>+    result[0][1] = round(x[0][1]);
>+    result[1][0] = round(x[1][0]);
>+    result[1][1] = round(x[1][1]);
>+    result[2][0] = round(x[2][0]);
>+    result[2][1] = round(x[2][1]);
>+    result[3][0] = round(x[3][0]);
>+    result[3][1] = round(x[3][1]);
>+    return result;
>+}
>+half4x3 round(half4x3 x) {
>+    half4x3 result;
>+    result[0][0] = round(x[0][0]);
>+    result[0][1] = round(x[0][1]);
>+    result[0][2] = round(x[0][2]);
>+    result[1][0] = round(x[1][0]);
>+    result[1][1] = round(x[1][1]);
>+    result[1][2] = round(x[1][2]);
>+    result[2][0] = round(x[2][0]);
>+    result[2][1] = round(x[2][1]);
>+    result[2][2] = round(x[2][2]);
>+    result[3][0] = round(x[3][0]);
>+    result[3][1] = round(x[3][1]);
>+    result[3][2] = round(x[3][2]);
>+    return result;
>+}
>+half4x4 round(half4x4 x) {
>+    half4x4 result;
>+    result[0][0] = round(x[0][0]);
>+    result[0][1] = round(x[0][1]);
>+    result[0][2] = round(x[0][2]);
>+    result[0][3] = round(x[0][3]);
>+    result[1][0] = round(x[1][0]);
>+    result[1][1] = round(x[1][1]);
>+    result[1][2] = round(x[1][2]);
>+    result[1][3] = round(x[1][3]);
>+    result[2][0] = round(x[2][0]);
>+    result[2][1] = round(x[2][1]);
>+    result[2][2] = round(x[2][2]);
>+    result[2][3] = round(x[2][3]);
>+    result[3][0] = round(x[3][0]);
>+    result[3][1] = round(x[3][1]);
>+    result[3][2] = round(x[3][2]);
>+    result[3][3] = round(x[3][3]);
>+    return result;
>+}
>+float2 round(float2 x) {
>+    float2 result;
>+    result[0] = round(x[0]);
>+    result[1] = round(x[1]);
>+    return result;
>+}
>+float3 round(float3 x) {
>+    float3 result;
>+    result[0] = round(x[0]);
>+    result[1] = round(x[1]);
>+    result[2] = round(x[2]);
>+    return result;
>+}
>+float4 round(float4 x) {
>+    float4 result;
>+    result[0] = round(x[0]);
>+    result[1] = round(x[1]);
>+    result[2] = round(x[2]);
>+    result[3] = round(x[3]);
>+    return result;
>+}
>+float2x2 round(float2x2 x) {
>+    float2x2 result;
>+    result[0][0] = round(x[0][0]);
>+    result[0][1] = round(x[0][1]);
>+    result[1][0] = round(x[1][0]);
>+    result[1][1] = round(x[1][1]);
>+    return result;
>+}
>+float2x3 round(float2x3 x) {
>+    float2x3 result;
>+    result[0][0] = round(x[0][0]);
>+    result[0][1] = round(x[0][1]);
>+    result[0][2] = round(x[0][2]);
>+    result[1][0] = round(x[1][0]);
>+    result[1][1] = round(x[1][1]);
>+    result[1][2] = round(x[1][2]);
>+    return result;
>+}
>+float2x4 round(float2x4 x) {
>+    float2x4 result;
>+    result[0][0] = round(x[0][0]);
>+    result[0][1] = round(x[0][1]);
>+    result[0][2] = round(x[0][2]);
>+    result[0][3] = round(x[0][3]);
>+    result[1][0] = round(x[1][0]);
>+    result[1][1] = round(x[1][1]);
>+    result[1][2] = round(x[1][2]);
>+    result[1][3] = round(x[1][3]);
>+    return result;
>+}
>+float3x2 round(float3x2 x) {
>+    float3x2 result;
>+    result[0][0] = round(x[0][0]);
>+    result[0][1] = round(x[0][1]);
>+    result[1][0] = round(x[1][0]);
>+    result[1][1] = round(x[1][1]);
>+    result[2][0] = round(x[2][0]);
>+    result[2][1] = round(x[2][1]);
>+    return result;
>+}
>+float3x3 round(float3x3 x) {
>+    float3x3 result;
>+    result[0][0] = round(x[0][0]);
>+    result[0][1] = round(x[0][1]);
>+    result[0][2] = round(x[0][2]);
>+    result[1][0] = round(x[1][0]);
>+    result[1][1] = round(x[1][1]);
>+    result[1][2] = round(x[1][2]);
>+    result[2][0] = round(x[2][0]);
>+    result[2][1] = round(x[2][1]);
>+    result[2][2] = round(x[2][2]);
>+    return result;
>+}
>+float3x4 round(float3x4 x) {
>+    float3x4 result;
>+    result[0][0] = round(x[0][0]);
>+    result[0][1] = round(x[0][1]);
>+    result[0][2] = round(x[0][2]);
>+    result[0][3] = round(x[0][3]);
>+    result[1][0] = round(x[1][0]);
>+    result[1][1] = round(x[1][1]);
>+    result[1][2] = round(x[1][2]);
>+    result[1][3] = round(x[1][3]);
>+    result[2][0] = round(x[2][0]);
>+    result[2][1] = round(x[2][1]);
>+    result[2][2] = round(x[2][2]);
>+    result[2][3] = round(x[2][3]);
>+    return result;
>+}
>+float4x2 round(float4x2 x) {
>+    float4x2 result;
>+    result[0][0] = round(x[0][0]);
>+    result[0][1] = round(x[0][1]);
>+    result[1][0] = round(x[1][0]);
>+    result[1][1] = round(x[1][1]);
>+    result[2][0] = round(x[2][0]);
>+    result[2][1] = round(x[2][1]);
>+    result[3][0] = round(x[3][0]);
>+    result[3][1] = round(x[3][1]);
>+    return result;
>+}
>+float4x3 round(float4x3 x) {
>+    float4x3 result;
>+    result[0][0] = round(x[0][0]);
>+    result[0][1] = round(x[0][1]);
>+    result[0][2] = round(x[0][2]);
>+    result[1][0] = round(x[1][0]);
>+    result[1][1] = round(x[1][1]);
>+    result[1][2] = round(x[1][2]);
>+    result[2][0] = round(x[2][0]);
>+    result[2][1] = round(x[2][1]);
>+    result[2][2] = round(x[2][2]);
>+    result[3][0] = round(x[3][0]);
>+    result[3][1] = round(x[3][1]);
>+    result[3][2] = round(x[3][2]);
>+    return result;
>+}
>+float4x4 round(float4x4 x) {
>+    float4x4 result;
>+    result[0][0] = round(x[0][0]);
>+    result[0][1] = round(x[0][1]);
>+    result[0][2] = round(x[0][2]);
>+    result[0][3] = round(x[0][3]);
>+    result[1][0] = round(x[1][0]);
>+    result[1][1] = round(x[1][1]);
>+    result[1][2] = round(x[1][2]);
>+    result[1][3] = round(x[1][3]);
>+    result[2][0] = round(x[2][0]);
>+    result[2][1] = round(x[2][1]);
>+    result[2][2] = round(x[2][2]);
>+    result[2][3] = round(x[2][3]);
>+    result[3][0] = round(x[3][0]);
>+    result[3][1] = round(x[3][1]);
>+    result[3][2] = round(x[3][2]);
>+    result[3][3] = round(x[3][3]);
>+    return result;
>+}
>+
>+/* Functions named mul */
>+uchar mul(uchar x, uchar y) {
>+    return x * y;
>+}
>+ushort mul(ushort x, ushort y) {
>+    return x * y;
>+}
>+uint mul(uint x, uint y) {
>+    return x * y;
>+}
>+char mul(char x, char y) {
>+    return x * y;
>+}
>+short mul(short x, short y) {
>+    return x * y;
>+}
>+int mul(int x, int y) {
>+    return x * y;
>+}
>+half mul(half x, half y) {
>+    return x * y;
>+}
>+float mul(float x, float y) {
>+    return x * y;
>+}
>+uchar2 mul(uchar x, uchar2 y) {
>+    uchar2 result;
>+    result[0] = x * y[0];
>+    result[1] = x * y[1];
>+    return result;
>+}
>+uchar2 mul(uchar2 x, uchar y) {
>+    uchar2 result;
>+    result[0] = x[0] * y;
>+    result[1] = x[1] * y;
>+    return result;
>+}
>+uchar3 mul(uchar x, uchar3 y) {
>+    uchar3 result;
>+    result[0] = x * y[0];
>+    result[1] = x * y[1];
>+    result[2] = x * y[2];
>+    return result;
>+}
>+uchar3 mul(uchar3 x, uchar y) {
>+    uchar3 result;
>+    result[0] = x[0] * y;
>+    result[1] = x[1] * y;
>+    result[2] = x[2] * y;
>+    return result;
>+}
>+uchar4 mul(uchar x, uchar4 y) {
>+    uchar4 result;
>+    result[0] = x * y[0];
>+    result[1] = x * y[1];
>+    result[2] = x * y[2];
>+    result[3] = x * y[3];
>+    return result;
>+}
>+uchar4 mul(uchar4 x, uchar y) {
>+    uchar4 result;
>+    result[0] = x[0] * y;
>+    result[1] = x[1] * y;
>+    result[2] = x[2] * y;
>+    result[3] = x[3] * y;
>+    return result;
>+}
>+ushort2 mul(ushort x, ushort2 y) {
>+    ushort2 result;
>+    result[0] = x * y[0];
>+    result[1] = x * y[1];
>+    return result;
>+}
>+ushort2 mul(ushort2 x, ushort y) {
>+    ushort2 result;
>+    result[0] = x[0] * y;
>+    result[1] = x[1] * y;
>+    return result;
>+}
>+ushort3 mul(ushort x, ushort3 y) {
>+    ushort3 result;
>+    result[0] = x * y[0];
>+    result[1] = x * y[1];
>+    result[2] = x * y[2];
>+    return result;
>+}
>+ushort3 mul(ushort3 x, ushort y) {
>+    ushort3 result;
>+    result[0] = x[0] * y;
>+    result[1] = x[1] * y;
>+    result[2] = x[2] * y;
>+    return result;
>+}
>+ushort4 mul(ushort x, ushort4 y) {
>+    ushort4 result;
>+    result[0] = x * y[0];
>+    result[1] = x * y[1];
>+    result[2] = x * y[2];
>+    result[3] = x * y[3];
>+    return result;
>+}
>+ushort4 mul(ushort4 x, ushort y) {
>+    ushort4 result;
>+    result[0] = x[0] * y;
>+    result[1] = x[1] * y;
>+    result[2] = x[2] * y;
>+    result[3] = x[3] * y;
>+    return result;
>+}
>+uint2 mul(uint x, uint2 y) {
>+    uint2 result;
>+    result[0] = x * y[0];
>+    result[1] = x * y[1];
>+    return result;
>+}
>+uint2 mul(uint2 x, uint y) {
>+    uint2 result;
>+    result[0] = x[0] * y;
>+    result[1] = x[1] * y;
>+    return result;
>+}
>+uint3 mul(uint x, uint3 y) {
>+    uint3 result;
>+    result[0] = x * y[0];
>+    result[1] = x * y[1];
>+    result[2] = x * y[2];
>+    return result;
>+}
>+uint3 mul(uint3 x, uint y) {
>+    uint3 result;
>+    result[0] = x[0] * y;
>+    result[1] = x[1] * y;
>+    result[2] = x[2] * y;
>+    return result;
>+}
>+uint4 mul(uint x, uint4 y) {
>+    uint4 result;
>+    result[0] = x * y[0];
>+    result[1] = x * y[1];
>+    result[2] = x * y[2];
>+    result[3] = x * y[3];
>+    return result;
>+}
>+uint4 mul(uint4 x, uint y) {
>+    uint4 result;
>+    result[0] = x[0] * y;
>+    result[1] = x[1] * y;
>+    result[2] = x[2] * y;
>+    result[3] = x[3] * y;
>+    return result;
>+}
>+char2 mul(char x, char2 y) {
>+    char2 result;
>+    result[0] = x * y[0];
>+    result[1] = x * y[1];
>+    return result;
>+}
>+char2 mul(char2 x, char y) {
>+    char2 result;
>+    result[0] = x[0] * y;
>+    result[1] = x[1] * y;
>+    return result;
>+}
>+char3 mul(char x, char3 y) {
>+    char3 result;
>+    result[0] = x * y[0];
>+    result[1] = x * y[1];
>+    result[2] = x * y[2];
>+    return result;
>+}
>+char3 mul(char3 x, char y) {
>+    char3 result;
>+    result[0] = x[0] * y;
>+    result[1] = x[1] * y;
>+    result[2] = x[2] * y;
>+    return result;
>+}
>+char4 mul(char x, char4 y) {
>+    char4 result;
>+    result[0] = x * y[0];
>+    result[1] = x * y[1];
>+    result[2] = x * y[2];
>+    result[3] = x * y[3];
>+    return result;
>+}
>+char4 mul(char4 x, char y) {
>+    char4 result;
>+    result[0] = x[0] * y;
>+    result[1] = x[1] * y;
>+    result[2] = x[2] * y;
>+    result[3] = x[3] * y;
>+    return result;
>+}
>+short2 mul(short x, short2 y) {
>+    short2 result;
>+    result[0] = x * y[0];
>+    result[1] = x * y[1];
>+    return result;
>+}
>+short2 mul(short2 x, short y) {
>+    short2 result;
>+    result[0] = x[0] * y;
>+    result[1] = x[1] * y;
>+    return result;
>+}
>+short3 mul(short x, short3 y) {
>+    short3 result;
>+    result[0] = x * y[0];
>+    result[1] = x * y[1];
>+    result[2] = x * y[2];
>+    return result;
>+}
>+short3 mul(short3 x, short y) {
>+    short3 result;
>+    result[0] = x[0] * y;
>+    result[1] = x[1] * y;
>+    result[2] = x[2] * y;
>+    return result;
>+}
>+short4 mul(short x, short4 y) {
>+    short4 result;
>+    result[0] = x * y[0];
>+    result[1] = x * y[1];
>+    result[2] = x * y[2];
>+    result[3] = x * y[3];
>+    return result;
>+}
>+short4 mul(short4 x, short y) {
>+    short4 result;
>+    result[0] = x[0] * y;
>+    result[1] = x[1] * y;
>+    result[2] = x[2] * y;
>+    result[3] = x[3] * y;
>+    return result;
>+}
>+int2 mul(int x, int2 y) {
>+    int2 result;
>+    result[0] = x * y[0];
>+    result[1] = x * y[1];
>+    return result;
>+}
>+int2 mul(int2 x, int y) {
>+    int2 result;
>+    result[0] = x[0] * y;
>+    result[1] = x[1] * y;
>+    return result;
>+}
>+int3 mul(int x, int3 y) {
>+    int3 result;
>+    result[0] = x * y[0];
>+    result[1] = x * y[1];
>+    result[2] = x * y[2];
>+    return result;
>+}
>+int3 mul(int3 x, int y) {
>+    int3 result;
>+    result[0] = x[0] * y;
>+    result[1] = x[1] * y;
>+    result[2] = x[2] * y;
>+    return result;
>+}
>+int4 mul(int x, int4 y) {
>+    int4 result;
>+    result[0] = x * y[0];
>+    result[1] = x * y[1];
>+    result[2] = x * y[2];
>+    result[3] = x * y[3];
>+    return result;
>+}
>+int4 mul(int4 x, int y) {
>+    int4 result;
>+    result[0] = x[0] * y;
>+    result[1] = x[1] * y;
>+    result[2] = x[2] * y;
>+    result[3] = x[3] * y;
>+    return result;
>+}
>+half2 mul(half x, half2 y) {
>+    half2 result;
>+    result[0] = x * y[0];
>+    result[1] = x * y[1];
>+    return result;
>+}
>+half2 mul(half2 x, half y) {
>+    half2 result;
>+    result[0] = x[0] * y;
>+    result[1] = x[1] * y;
>+    return result;
>+}
>+half3 mul(half x, half3 y) {
>+    half3 result;
>+    result[0] = x * y[0];
>+    result[1] = x * y[1];
>+    result[2] = x * y[2];
>+    return result;
>+}
>+half3 mul(half3 x, half y) {
>+    half3 result;
>+    result[0] = x[0] * y;
>+    result[1] = x[1] * y;
>+    result[2] = x[2] * y;
>+    return result;
>+}
>+half4 mul(half x, half4 y) {
>+    half4 result;
>+    result[0] = x * y[0];
>+    result[1] = x * y[1];
>+    result[2] = x * y[2];
>+    result[3] = x * y[3];
>+    return result;
>+}
>+half4 mul(half4 x, half y) {
>+    half4 result;
>+    result[0] = x[0] * y;
>+    result[1] = x[1] * y;
>+    result[2] = x[2] * y;
>+    result[3] = x[3] * y;
>+    return result;
>+}
>+float2 mul(float x, float2 y) {
>+    float2 result;
>+    result[0] = x * y[0];
>+    result[1] = x * y[1];
>+    return result;
>+}
>+float2 mul(float2 x, float y) {
>+    float2 result;
>+    result[0] = x[0] * y;
>+    result[1] = x[1] * y;
>+    return result;
>+}
>+float3 mul(float x, float3 y) {
>+    float3 result;
>+    result[0] = x * y[0];
>+    result[1] = x * y[1];
>+    result[2] = x * y[2];
>+    return result;
>+}
>+float3 mul(float3 x, float y) {
>+    float3 result;
>+    result[0] = x[0] * y;
>+    result[1] = x[1] * y;
>+    result[2] = x[2] * y;
>+    return result;
>+}
>+float4 mul(float x, float4 y) {
>+    float4 result;
>+    result[0] = x * y[0];
>+    result[1] = x * y[1];
>+    result[2] = x * y[2];
>+    result[3] = x * y[3];
>+    return result;
>+}
>+float4 mul(float4 x, float y) {
>+    float4 result;
>+    result[0] = x[0] * y;
>+    result[1] = x[1] * y;
>+    result[2] = x[2] * y;
>+    result[3] = x[3] * y;
>+    return result;
>+}
>+half2x2 mul(half x, half2x2 y) {
>+    half2x2 result;
>+    result[0][0] = x * y[0][0];
>+    result[0][1] = x * y[0][1];
>+    result[1][0] = x * y[1][0];
>+    result[1][1] = x * y[1][1];
>+    return result;
>+}
>+half2x2 mul(half2x2 x, half y) {
>+    half2x2 result;
>+    result[0][0] = x[0][0] * y;
>+    result[0][1] = x[0][1] * y;
>+    result[1][0] = x[1][0] * y;
>+    result[1][1] = x[1][1] * y;
>+    return result;
>+}
>+half2x3 mul(half x, half2x3 y) {
>+    half2x3 result;
>+    result[0][0] = x * y[0][0];
>+    result[0][1] = x * y[0][1];
>+    result[0][2] = x * y[0][2];
>+    result[1][0] = x * y[1][0];
>+    result[1][1] = x * y[1][1];
>+    result[1][2] = x * y[1][2];
>+    return result;
>+}
>+half2x3 mul(half2x3 x, half y) {
>+    half2x3 result;
>+    result[0][0] = x[0][0] * y;
>+    result[0][1] = x[0][1] * y;
>+    result[0][2] = x[0][2] * y;
>+    result[1][0] = x[1][0] * y;
>+    result[1][1] = x[1][1] * y;
>+    result[1][2] = x[1][2] * y;
>+    return result;
>+}
>+half2x4 mul(half x, half2x4 y) {
>+    half2x4 result;
>+    result[0][0] = x * y[0][0];
>+    result[0][1] = x * y[0][1];
>+    result[0][2] = x * y[0][2];
>+    result[0][3] = x * y[0][3];
>+    result[1][0] = x * y[1][0];
>+    result[1][1] = x * y[1][1];
>+    result[1][2] = x * y[1][2];
>+    result[1][3] = x * y[1][3];
>+    return result;
>+}
>+half2x4 mul(half2x4 x, half y) {
>+    half2x4 result;
>+    result[0][0] = x[0][0] * y;
>+    result[0][1] = x[0][1] * y;
>+    result[0][2] = x[0][2] * y;
>+    result[0][3] = x[0][3] * y;
>+    result[1][0] = x[1][0] * y;
>+    result[1][1] = x[1][1] * y;
>+    result[1][2] = x[1][2] * y;
>+    result[1][3] = x[1][3] * y;
>+    return result;
>+}
>+half3x2 mul(half x, half3x2 y) {
>+    half3x2 result;
>+    result[0][0] = x * y[0][0];
>+    result[0][1] = x * y[0][1];
>+    result[1][0] = x * y[1][0];
>+    result[1][1] = x * y[1][1];
>+    result[2][0] = x * y[2][0];
>+    result[2][1] = x * y[2][1];
>+    return result;
>+}
>+half3x2 mul(half3x2 x, half y) {
>+    half3x2 result;
>+    result[0][0] = x[0][0] * y;
>+    result[0][1] = x[0][1] * y;
>+    result[1][0] = x[1][0] * y;
>+    result[1][1] = x[1][1] * y;
>+    result[2][0] = x[2][0] * y;
>+    result[2][1] = x[2][1] * y;
>+    return result;
>+}
>+half3x3 mul(half x, half3x3 y) {
>+    half3x3 result;
>+    result[0][0] = x * y[0][0];
>+    result[0][1] = x * y[0][1];
>+    result[0][2] = x * y[0][2];
>+    result[1][0] = x * y[1][0];
>+    result[1][1] = x * y[1][1];
>+    result[1][2] = x * y[1][2];
>+    result[2][0] = x * y[2][0];
>+    result[2][1] = x * y[2][1];
>+    result[2][2] = x * y[2][2];
>+    return result;
>+}
>+half3x3 mul(half3x3 x, half y) {
>+    half3x3 result;
>+    result[0][0] = x[0][0] * y;
>+    result[0][1] = x[0][1] * y;
>+    result[0][2] = x[0][2] * y;
>+    result[1][0] = x[1][0] * y;
>+    result[1][1] = x[1][1] * y;
>+    result[1][2] = x[1][2] * y;
>+    result[2][0] = x[2][0] * y;
>+    result[2][1] = x[2][1] * y;
>+    result[2][2] = x[2][2] * y;
>+    return result;
>+}
>+half3x4 mul(half x, half3x4 y) {
>+    half3x4 result;
>+    result[0][0] = x * y[0][0];
>+    result[0][1] = x * y[0][1];
>+    result[0][2] = x * y[0][2];
>+    result[0][3] = x * y[0][3];
>+    result[1][0] = x * y[1][0];
>+    result[1][1] = x * y[1][1];
>+    result[1][2] = x * y[1][2];
>+    result[1][3] = x * y[1][3];
>+    result[2][0] = x * y[2][0];
>+    result[2][1] = x * y[2][1];
>+    result[2][2] = x * y[2][2];
>+    result[2][3] = x * y[2][3];
>+    return result;
>+}
>+half3x4 mul(half3x4 x, half y) {
>+    half3x4 result;
>+    result[0][0] = x[0][0] * y;
>+    result[0][1] = x[0][1] * y;
>+    result[0][2] = x[0][2] * y;
>+    result[0][3] = x[0][3] * y;
>+    result[1][0] = x[1][0] * y;
>+    result[1][1] = x[1][1] * y;
>+    result[1][2] = x[1][2] * y;
>+    result[1][3] = x[1][3] * y;
>+    result[2][0] = x[2][0] * y;
>+    result[2][1] = x[2][1] * y;
>+    result[2][2] = x[2][2] * y;
>+    result[2][3] = x[2][3] * y;
>+    return result;
>+}
>+half4x2 mul(half x, half4x2 y) {
>+    half4x2 result;
>+    result[0][0] = x * y[0][0];
>+    result[0][1] = x * y[0][1];
>+    result[1][0] = x * y[1][0];
>+    result[1][1] = x * y[1][1];
>+    result[2][0] = x * y[2][0];
>+    result[2][1] = x * y[2][1];
>+    result[3][0] = x * y[3][0];
>+    result[3][1] = x * y[3][1];
>+    return result;
>+}
>+half4x2 mul(half4x2 x, half y) {
>+    half4x2 result;
>+    result[0][0] = x[0][0] * y;
>+    result[0][1] = x[0][1] * y;
>+    result[1][0] = x[1][0] * y;
>+    result[1][1] = x[1][1] * y;
>+    result[2][0] = x[2][0] * y;
>+    result[2][1] = x[2][1] * y;
>+    result[3][0] = x[3][0] * y;
>+    result[3][1] = x[3][1] * y;
>+    return result;
>+}
>+half4x3 mul(half x, half4x3 y) {
>+    half4x3 result;
>+    result[0][0] = x * y[0][0];
>+    result[0][1] = x * y[0][1];
>+    result[0][2] = x * y[0][2];
>+    result[1][0] = x * y[1][0];
>+    result[1][1] = x * y[1][1];
>+    result[1][2] = x * y[1][2];
>+    result[2][0] = x * y[2][0];
>+    result[2][1] = x * y[2][1];
>+    result[2][2] = x * y[2][2];
>+    result[3][0] = x * y[3][0];
>+    result[3][1] = x * y[3][1];
>+    result[3][2] = x * y[3][2];
>+    return result;
>+}
>+half4x3 mul(half4x3 x, half y) {
>+    half4x3 result;
>+    result[0][0] = x[0][0] * y;
>+    result[0][1] = x[0][1] * y;
>+    result[0][2] = x[0][2] * y;
>+    result[1][0] = x[1][0] * y;
>+    result[1][1] = x[1][1] * y;
>+    result[1][2] = x[1][2] * y;
>+    result[2][0] = x[2][0] * y;
>+    result[2][1] = x[2][1] * y;
>+    result[2][2] = x[2][2] * y;
>+    result[3][0] = x[3][0] * y;
>+    result[3][1] = x[3][1] * y;
>+    result[3][2] = x[3][2] * y;
>+    return result;
>+}
>+half4x4 mul(half x, half4x4 y) {
>+    half4x4 result;
>+    result[0][0] = x * y[0][0];
>+    result[0][1] = x * y[0][1];
>+    result[0][2] = x * y[0][2];
>+    result[0][3] = x * y[0][3];
>+    result[1][0] = x * y[1][0];
>+    result[1][1] = x * y[1][1];
>+    result[1][2] = x * y[1][2];
>+    result[1][3] = x * y[1][3];
>+    result[2][0] = x * y[2][0];
>+    result[2][1] = x * y[2][1];
>+    result[2][2] = x * y[2][2];
>+    result[2][3] = x * y[2][3];
>+    result[3][0] = x * y[3][0];
>+    result[3][1] = x * y[3][1];
>+    result[3][2] = x * y[3][2];
>+    result[3][3] = x * y[3][3];
>+    return result;
>+}
>+half4x4 mul(half4x4 x, half y) {
>+    half4x4 result;
>+    result[0][0] = x[0][0] * y;
>+    result[0][1] = x[0][1] * y;
>+    result[0][2] = x[0][2] * y;
>+    result[0][3] = x[0][3] * y;
>+    result[1][0] = x[1][0] * y;
>+    result[1][1] = x[1][1] * y;
>+    result[1][2] = x[1][2] * y;
>+    result[1][3] = x[1][3] * y;
>+    result[2][0] = x[2][0] * y;
>+    result[2][1] = x[2][1] * y;
>+    result[2][2] = x[2][2] * y;
>+    result[2][3] = x[2][3] * y;
>+    result[3][0] = x[3][0] * y;
>+    result[3][1] = x[3][1] * y;
>+    result[3][2] = x[3][2] * y;
>+    result[3][3] = x[3][3] * y;
>+    return result;
>+}
>+float2x2 mul(float x, float2x2 y) {
>+    float2x2 result;
>+    result[0][0] = x * y[0][0];
>+    result[0][1] = x * y[0][1];
>+    result[1][0] = x * y[1][0];
>+    result[1][1] = x * y[1][1];
>+    return result;
>+}
>+float2x2 mul(float2x2 x, float y) {
>+    float2x2 result;
>+    result[0][0] = x[0][0] * y;
>+    result[0][1] = x[0][1] * y;
>+    result[1][0] = x[1][0] * y;
>+    result[1][1] = x[1][1] * y;
>+    return result;
>+}
>+float2x3 mul(float x, float2x3 y) {
>+    float2x3 result;
>+    result[0][0] = x * y[0][0];
>+    result[0][1] = x * y[0][1];
>+    result[0][2] = x * y[0][2];
>+    result[1][0] = x * y[1][0];
>+    result[1][1] = x * y[1][1];
>+    result[1][2] = x * y[1][2];
>+    return result;
>+}
>+float2x3 mul(float2x3 x, float y) {
>+    float2x3 result;
>+    result[0][0] = x[0][0] * y;
>+    result[0][1] = x[0][1] * y;
>+    result[0][2] = x[0][2] * y;
>+    result[1][0] = x[1][0] * y;
>+    result[1][1] = x[1][1] * y;
>+    result[1][2] = x[1][2] * y;
>+    return result;
>+}
>+float2x4 mul(float x, float2x4 y) {
>+    float2x4 result;
>+    result[0][0] = x * y[0][0];
>+    result[0][1] = x * y[0][1];
>+    result[0][2] = x * y[0][2];
>+    result[0][3] = x * y[0][3];
>+    result[1][0] = x * y[1][0];
>+    result[1][1] = x * y[1][1];
>+    result[1][2] = x * y[1][2];
>+    result[1][3] = x * y[1][3];
>+    return result;
>+}
>+float2x4 mul(float2x4 x, float y) {
>+    float2x4 result;
>+    result[0][0] = x[0][0] * y;
>+    result[0][1] = x[0][1] * y;
>+    result[0][2] = x[0][2] * y;
>+    result[0][3] = x[0][3] * y;
>+    result[1][0] = x[1][0] * y;
>+    result[1][1] = x[1][1] * y;
>+    result[1][2] = x[1][2] * y;
>+    result[1][3] = x[1][3] * y;
>+    return result;
>+}
>+float3x2 mul(float x, float3x2 y) {
>+    float3x2 result;
>+    result[0][0] = x * y[0][0];
>+    result[0][1] = x * y[0][1];
>+    result[1][0] = x * y[1][0];
>+    result[1][1] = x * y[1][1];
>+    result[2][0] = x * y[2][0];
>+    result[2][1] = x * y[2][1];
>+    return result;
>+}
>+float3x2 mul(float3x2 x, float y) {
>+    float3x2 result;
>+    result[0][0] = x[0][0] * y;
>+    result[0][1] = x[0][1] * y;
>+    result[1][0] = x[1][0] * y;
>+    result[1][1] = x[1][1] * y;
>+    result[2][0] = x[2][0] * y;
>+    result[2][1] = x[2][1] * y;
>+    return result;
>+}
>+float3x3 mul(float x, float3x3 y) {
>+    float3x3 result;
>+    result[0][0] = x * y[0][0];
>+    result[0][1] = x * y[0][1];
>+    result[0][2] = x * y[0][2];
>+    result[1][0] = x * y[1][0];
>+    result[1][1] = x * y[1][1];
>+    result[1][2] = x * y[1][2];
>+    result[2][0] = x * y[2][0];
>+    result[2][1] = x * y[2][1];
>+    result[2][2] = x * y[2][2];
>+    return result;
>+}
>+float3x3 mul(float3x3 x, float y) {
>+    float3x3 result;
>+    result[0][0] = x[0][0] * y;
>+    result[0][1] = x[0][1] * y;
>+    result[0][2] = x[0][2] * y;
>+    result[1][0] = x[1][0] * y;
>+    result[1][1] = x[1][1] * y;
>+    result[1][2] = x[1][2] * y;
>+    result[2][0] = x[2][0] * y;
>+    result[2][1] = x[2][1] * y;
>+    result[2][2] = x[2][2] * y;
>+    return result;
>+}
>+float3x4 mul(float x, float3x4 y) {
>+    float3x4 result;
>+    result[0][0] = x * y[0][0];
>+    result[0][1] = x * y[0][1];
>+    result[0][2] = x * y[0][2];
>+    result[0][3] = x * y[0][3];
>+    result[1][0] = x * y[1][0];
>+    result[1][1] = x * y[1][1];
>+    result[1][2] = x * y[1][2];
>+    result[1][3] = x * y[1][3];
>+    result[2][0] = x * y[2][0];
>+    result[2][1] = x * y[2][1];
>+    result[2][2] = x * y[2][2];
>+    result[2][3] = x * y[2][3];
>+    return result;
>+}
>+float3x4 mul(float3x4 x, float y) {
>+    float3x4 result;
>+    result[0][0] = x[0][0] * y;
>+    result[0][1] = x[0][1] * y;
>+    result[0][2] = x[0][2] * y;
>+    result[0][3] = x[0][3] * y;
>+    result[1][0] = x[1][0] * y;
>+    result[1][1] = x[1][1] * y;
>+    result[1][2] = x[1][2] * y;
>+    result[1][3] = x[1][3] * y;
>+    result[2][0] = x[2][0] * y;
>+    result[2][1] = x[2][1] * y;
>+    result[2][2] = x[2][2] * y;
>+    result[2][3] = x[2][3] * y;
>+    return result;
>+}
>+float4x2 mul(float x, float4x2 y) {
>+    float4x2 result;
>+    result[0][0] = x * y[0][0];
>+    result[0][1] = x * y[0][1];
>+    result[1][0] = x * y[1][0];
>+    result[1][1] = x * y[1][1];
>+    result[2][0] = x * y[2][0];
>+    result[2][1] = x * y[2][1];
>+    result[3][0] = x * y[3][0];
>+    result[3][1] = x * y[3][1];
>+    return result;
>+}
>+float4x2 mul(float4x2 x, float y) {
>+    float4x2 result;
>+    result[0][0] = x[0][0] * y;
>+    result[0][1] = x[0][1] * y;
>+    result[1][0] = x[1][0] * y;
>+    result[1][1] = x[1][1] * y;
>+    result[2][0] = x[2][0] * y;
>+    result[2][1] = x[2][1] * y;
>+    result[3][0] = x[3][0] * y;
>+    result[3][1] = x[3][1] * y;
>+    return result;
>+}
>+float4x3 mul(float x, float4x3 y) {
>+    float4x3 result;
>+    result[0][0] = x * y[0][0];
>+    result[0][1] = x * y[0][1];
>+    result[0][2] = x * y[0][2];
>+    result[1][0] = x * y[1][0];
>+    result[1][1] = x * y[1][1];
>+    result[1][2] = x * y[1][2];
>+    result[2][0] = x * y[2][0];
>+    result[2][1] = x * y[2][1];
>+    result[2][2] = x * y[2][2];
>+    result[3][0] = x * y[3][0];
>+    result[3][1] = x * y[3][1];
>+    result[3][2] = x * y[3][2];
>+    return result;
>+}
>+float4x3 mul(float4x3 x, float y) {
>+    float4x3 result;
>+    result[0][0] = x[0][0] * y;
>+    result[0][1] = x[0][1] * y;
>+    result[0][2] = x[0][2] * y;
>+    result[1][0] = x[1][0] * y;
>+    result[1][1] = x[1][1] * y;
>+    result[1][2] = x[1][2] * y;
>+    result[2][0] = x[2][0] * y;
>+    result[2][1] = x[2][1] * y;
>+    result[2][2] = x[2][2] * y;
>+    result[3][0] = x[3][0] * y;
>+    result[3][1] = x[3][1] * y;
>+    result[3][2] = x[3][2] * y;
>+    return result;
>+}
>+float4x4 mul(float x, float4x4 y) {
>+    float4x4 result;
>+    result[0][0] = x * y[0][0];
>+    result[0][1] = x * y[0][1];
>+    result[0][2] = x * y[0][2];
>+    result[0][3] = x * y[0][3];
>+    result[1][0] = x * y[1][0];
>+    result[1][1] = x * y[1][1];
>+    result[1][2] = x * y[1][2];
>+    result[1][3] = x * y[1][3];
>+    result[2][0] = x * y[2][0];
>+    result[2][1] = x * y[2][1];
>+    result[2][2] = x * y[2][2];
>+    result[2][3] = x * y[2][3];
>+    result[3][0] = x * y[3][0];
>+    result[3][1] = x * y[3][1];
>+    result[3][2] = x * y[3][2];
>+    result[3][3] = x * y[3][3];
>+    return result;
>+}
>+float4x4 mul(float4x4 x, float y) {
>+    float4x4 result;
>+    result[0][0] = x[0][0] * y;
>+    result[0][1] = x[0][1] * y;
>+    result[0][2] = x[0][2] * y;
>+    result[0][3] = x[0][3] * y;
>+    result[1][0] = x[1][0] * y;
>+    result[1][1] = x[1][1] * y;
>+    result[1][2] = x[1][2] * y;
>+    result[1][3] = x[1][3] * y;
>+    result[2][0] = x[2][0] * y;
>+    result[2][1] = x[2][1] * y;
>+    result[2][2] = x[2][2] * y;
>+    result[2][3] = x[2][3] * y;
>+    result[3][0] = x[3][0] * y;
>+    result[3][1] = x[3][1] * y;
>+    result[3][2] = x[3][2] * y;
>+    result[3][3] = x[3][3] * y;
>+    return result;
>+}
>+uchar mul(uchar2 x, uchar2 y) {
>+    return dot(x, y);
>+}
>+uchar mul(uchar3 x, uchar3 y) {
>+    return dot(x, y);
>+}
>+uchar mul(uchar4 x, uchar4 y) {
>+    return dot(x, y);
>+}
>+ushort mul(ushort2 x, ushort2 y) {
>+    return dot(x, y);
>+}
>+ushort mul(ushort3 x, ushort3 y) {
>+    return dot(x, y);
>+}
>+ushort mul(ushort4 x, ushort4 y) {
>+    return dot(x, y);
>+}
>+uint mul(uint2 x, uint2 y) {
>+    return dot(x, y);
>+}
>+uint mul(uint3 x, uint3 y) {
>+    return dot(x, y);
>+}
>+uint mul(uint4 x, uint4 y) {
>+    return dot(x, y);
>+}
>+char mul(char2 x, char2 y) {
>+    return dot(x, y);
>+}
>+char mul(char3 x, char3 y) {
>+    return dot(x, y);
>+}
>+char mul(char4 x, char4 y) {
>+    return dot(x, y);
>+}
>+short mul(short2 x, short2 y) {
>+    return dot(x, y);
>+}
>+short mul(short3 x, short3 y) {
>+    return dot(x, y);
>+}
>+short mul(short4 x, short4 y) {
>+    return dot(x, y);
>+}
>+int mul(int2 x, int2 y) {
>+    return dot(x, y);
>+}
>+int mul(int3 x, int3 y) {
>+    return dot(x, y);
>+}
>+int mul(int4 x, int4 y) {
>+    return dot(x, y);
>+}
>+half mul(half2 x, half2 y) {
>+    return dot(x, y);
>+}
>+half mul(half3 x, half3 y) {
>+    return dot(x, y);
>+}
>+half mul(half4 x, half4 y) {
>+    return dot(x, y);
>+}
>+float mul(float2 x, float2 y) {
>+    return dot(x, y);
>+}
>+float mul(float3 x, float3 y) {
>+    return dot(x, y);
>+}
>+float mul(float4 x, float4 y) {
>+    return dot(x, y);
>+}
>+half2 mul(half2 x, half2x2 y) {
>+    half2 result;
>+    result[0] = 0;
>+    result[0] += x[0] * y[0][0];
>+    result[0] += x[1] * y[1][0];
>+    result[1] = 0;
>+    result[1] += x[0] * y[0][1];
>+    result[1] += x[1] * y[1][1];
>+    return result;
>+}
>+half2 mul(half2x2 x, half2 y) {
>+    half2 result;
>+    result[0] = 0;
>+    result[0] += x[0][0] * y[0];
>+    result[0] += x[0][1] * y[1];
>+    result[1] = 0;
>+    result[1] += x[1][0] * y[0];
>+    result[1] += x[1][1] * y[1];
>+    return result;
>+}
>+half3 mul(half2 x, half2x3 y) {
>+    half3 result;
>+    result[0] = 0;
>+    result[0] += x[0] * y[0][0];
>+    result[0] += x[1] * y[1][0];
>+    result[1] = 0;
>+    result[1] += x[0] * y[0][1];
>+    result[1] += x[1] * y[1][1];
>+    result[2] = 0;
>+    result[2] += x[0] * y[0][2];
>+    result[2] += x[1] * y[1][2];
>+    return result;
>+}
>+half2 mul(half2x3 x, half3 y) {
>+    half2 result;
>+    result[0] = 0;
>+    result[0] += x[0][0] * y[0];
>+    result[0] += x[0][1] * y[1];
>+    result[0] += x[0][2] * y[2];
>+    result[1] = 0;
>+    result[1] += x[1][0] * y[0];
>+    result[1] += x[1][1] * y[1];
>+    result[1] += x[1][2] * y[2];
>+    return result;
>+}
>+half4 mul(half2 x, half2x4 y) {
>+    half4 result;
>+    result[0] = 0;
>+    result[0] += x[0] * y[0][0];
>+    result[0] += x[1] * y[1][0];
>+    result[1] = 0;
>+    result[1] += x[0] * y[0][1];
>+    result[1] += x[1] * y[1][1];
>+    result[2] = 0;
>+    result[2] += x[0] * y[0][2];
>+    result[2] += x[1] * y[1][2];
>+    result[3] = 0;
>+    result[3] += x[0] * y[0][3];
>+    result[3] += x[1] * y[1][3];
>+    return result;
>+}
>+half2 mul(half2x4 x, half4 y) {
>+    half2 result;
>+    result[0] = 0;
>+    result[0] += x[0][0] * y[0];
>+    result[0] += x[0][1] * y[1];
>+    result[0] += x[0][2] * y[2];
>+    result[0] += x[0][3] * y[3];
>+    result[1] = 0;
>+    result[1] += x[1][0] * y[0];
>+    result[1] += x[1][1] * y[1];
>+    result[1] += x[1][2] * y[2];
>+    result[1] += x[1][3] * y[3];
>+    return result;
>+}
>+half2 mul(half3 x, half3x2 y) {
>+    half2 result;
>+    result[0] = 0;
>+    result[0] += x[0] * y[0][0];
>+    result[0] += x[1] * y[1][0];
>+    result[0] += x[2] * y[2][0];
>+    result[1] = 0;
>+    result[1] += x[0] * y[0][1];
>+    result[1] += x[1] * y[1][1];
>+    result[1] += x[2] * y[2][1];
>+    return result;
>+}
>+half3 mul(half3x2 x, half2 y) {
>+    half3 result;
>+    result[0] = 0;
>+    result[0] += x[0][0] * y[0];
>+    result[0] += x[0][1] * y[1];
>+    result[1] = 0;
>+    result[1] += x[1][0] * y[0];
>+    result[1] += x[1][1] * y[1];
>+    result[2] = 0;
>+    result[2] += x[2][0] * y[0];
>+    result[2] += x[2][1] * y[1];
>+    return result;
>+}
>+half3 mul(half3 x, half3x3 y) {
>+    half3 result;
>+    result[0] = 0;
>+    result[0] += x[0] * y[0][0];
>+    result[0] += x[1] * y[1][0];
>+    result[0] += x[2] * y[2][0];
>+    result[1] = 0;
>+    result[1] += x[0] * y[0][1];
>+    result[1] += x[1] * y[1][1];
>+    result[1] += x[2] * y[2][1];
>+    result[2] = 0;
>+    result[2] += x[0] * y[0][2];
>+    result[2] += x[1] * y[1][2];
>+    result[2] += x[2] * y[2][2];
>+    return result;
>+}
>+half3 mul(half3x3 x, half3 y) {
>+    half3 result;
>+    result[0] = 0;
>+    result[0] += x[0][0] * y[0];
>+    result[0] += x[0][1] * y[1];
>+    result[0] += x[0][2] * y[2];
>+    result[1] = 0;
>+    result[1] += x[1][0] * y[0];
>+    result[1] += x[1][1] * y[1];
>+    result[1] += x[1][2] * y[2];
>+    result[2] = 0;
>+    result[2] += x[2][0] * y[0];
>+    result[2] += x[2][1] * y[1];
>+    result[2] += x[2][2] * y[2];
>+    return result;
>+}
>+half4 mul(half3 x, half3x4 y) {
>+    half4 result;
>+    result[0] = 0;
>+    result[0] += x[0] * y[0][0];
>+    result[0] += x[1] * y[1][0];
>+    result[0] += x[2] * y[2][0];
>+    result[1] = 0;
>+    result[1] += x[0] * y[0][1];
>+    result[1] += x[1] * y[1][1];
>+    result[1] += x[2] * y[2][1];
>+    result[2] = 0;
>+    result[2] += x[0] * y[0][2];
>+    result[2] += x[1] * y[1][2];
>+    result[2] += x[2] * y[2][2];
>+    result[3] = 0;
>+    result[3] += x[0] * y[0][3];
>+    result[3] += x[1] * y[1][3];
>+    result[3] += x[2] * y[2][3];
>+    return result;
>+}
>+half3 mul(half3x4 x, half4 y) {
>+    half3 result;
>+    result[0] = 0;
>+    result[0] += x[0][0] * y[0];
>+    result[0] += x[0][1] * y[1];
>+    result[0] += x[0][2] * y[2];
>+    result[0] += x[0][3] * y[3];
>+    result[1] = 0;
>+    result[1] += x[1][0] * y[0];
>+    result[1] += x[1][1] * y[1];
>+    result[1] += x[1][2] * y[2];
>+    result[1] += x[1][3] * y[3];
>+    result[2] = 0;
>+    result[2] += x[2][0] * y[0];
>+    result[2] += x[2][1] * y[1];
>+    result[2] += x[2][2] * y[2];
>+    result[2] += x[2][3] * y[3];
>+    return result;
>+}
>+half2 mul(half4 x, half4x2 y) {
>+    half2 result;
>+    result[0] = 0;
>+    result[0] += x[0] * y[0][0];
>+    result[0] += x[1] * y[1][0];
>+    result[0] += x[2] * y[2][0];
>+    result[0] += x[3] * y[3][0];
>+    result[1] = 0;
>+    result[1] += x[0] * y[0][1];
>+    result[1] += x[1] * y[1][1];
>+    result[1] += x[2] * y[2][1];
>+    result[1] += x[3] * y[3][1];
>+    return result;
>+}
>+half4 mul(half4x2 x, half2 y) {
>+    half4 result;
>+    result[0] = 0;
>+    result[0] += x[0][0] * y[0];
>+    result[0] += x[0][1] * y[1];
>+    result[1] = 0;
>+    result[1] += x[1][0] * y[0];
>+    result[1] += x[1][1] * y[1];
>+    result[2] = 0;
>+    result[2] += x[2][0] * y[0];
>+    result[2] += x[2][1] * y[1];
>+    result[3] = 0;
>+    result[3] += x[3][0] * y[0];
>+    result[3] += x[3][1] * y[1];
>+    return result;
>+}
>+half3 mul(half4 x, half4x3 y) {
>+    half3 result;
>+    result[0] = 0;
>+    result[0] += x[0] * y[0][0];
>+    result[0] += x[1] * y[1][0];
>+    result[0] += x[2] * y[2][0];
>+    result[0] += x[3] * y[3][0];
>+    result[1] = 0;
>+    result[1] += x[0] * y[0][1];
>+    result[1] += x[1] * y[1][1];
>+    result[1] += x[2] * y[2][1];
>+    result[1] += x[3] * y[3][1];
>+    result[2] = 0;
>+    result[2] += x[0] * y[0][2];
>+    result[2] += x[1] * y[1][2];
>+    result[2] += x[2] * y[2][2];
>+    result[2] += x[3] * y[3][2];
>+    return result;
>+}
>+half4 mul(half4x3 x, half3 y) {
>+    half4 result;
>+    result[0] = 0;
>+    result[0] += x[0][0] * y[0];
>+    result[0] += x[0][1] * y[1];
>+    result[0] += x[0][2] * y[2];
>+    result[1] = 0;
>+    result[1] += x[1][0] * y[0];
>+    result[1] += x[1][1] * y[1];
>+    result[1] += x[1][2] * y[2];
>+    result[2] = 0;
>+    result[2] += x[2][0] * y[0];
>+    result[2] += x[2][1] * y[1];
>+    result[2] += x[2][2] * y[2];
>+    result[3] = 0;
>+    result[3] += x[3][0] * y[0];
>+    result[3] += x[3][1] * y[1];
>+    result[3] += x[3][2] * y[2];
>+    return result;
>+}
>+half4 mul(half4 x, half4x4 y) {
>+    half4 result;
>+    result[0] = 0;
>+    result[0] += x[0] * y[0][0];
>+    result[0] += x[1] * y[1][0];
>+    result[0] += x[2] * y[2][0];
>+    result[0] += x[3] * y[3][0];
>+    result[1] = 0;
>+    result[1] += x[0] * y[0][1];
>+    result[1] += x[1] * y[1][1];
>+    result[1] += x[2] * y[2][1];
>+    result[1] += x[3] * y[3][1];
>+    result[2] = 0;
>+    result[2] += x[0] * y[0][2];
>+    result[2] += x[1] * y[1][2];
>+    result[2] += x[2] * y[2][2];
>+    result[2] += x[3] * y[3][2];
>+    result[3] = 0;
>+    result[3] += x[0] * y[0][3];
>+    result[3] += x[1] * y[1][3];
>+    result[3] += x[2] * y[2][3];
>+    result[3] += x[3] * y[3][3];
>+    return result;
>+}
>+half4 mul(half4x4 x, half4 y) {
>+    half4 result;
>+    result[0] = 0;
>+    result[0] += x[0][0] * y[0];
>+    result[0] += x[0][1] * y[1];
>+    result[0] += x[0][2] * y[2];
>+    result[0] += x[0][3] * y[3];
>+    result[1] = 0;
>+    result[1] += x[1][0] * y[0];
>+    result[1] += x[1][1] * y[1];
>+    result[1] += x[1][2] * y[2];
>+    result[1] += x[1][3] * y[3];
>+    result[2] = 0;
>+    result[2] += x[2][0] * y[0];
>+    result[2] += x[2][1] * y[1];
>+    result[2] += x[2][2] * y[2];
>+    result[2] += x[2][3] * y[3];
>+    result[3] = 0;
>+    result[3] += x[3][0] * y[0];
>+    result[3] += x[3][1] * y[1];
>+    result[3] += x[3][2] * y[2];
>+    result[3] += x[3][3] * y[3];
>+    return result;
>+}
>+float2 mul(float2 x, float2x2 y) {
>+    float2 result;
>+    result[0] = 0;
>+    result[0] += x[0] * y[0][0];
>+    result[0] += x[1] * y[1][0];
>+    result[1] = 0;
>+    result[1] += x[0] * y[0][1];
>+    result[1] += x[1] * y[1][1];
>+    return result;
>+}
>+float2 mul(float2x2 x, float2 y) {
>+    float2 result;
>+    result[0] = 0;
>+    result[0] += x[0][0] * y[0];
>+    result[0] += x[0][1] * y[1];
>+    result[1] = 0;
>+    result[1] += x[1][0] * y[0];
>+    result[1] += x[1][1] * y[1];
>+    return result;
>+}
>+float3 mul(float2 x, float2x3 y) {
>+    float3 result;
>+    result[0] = 0;
>+    result[0] += x[0] * y[0][0];
>+    result[0] += x[1] * y[1][0];
>+    result[1] = 0;
>+    result[1] += x[0] * y[0][1];
>+    result[1] += x[1] * y[1][1];
>+    result[2] = 0;
>+    result[2] += x[0] * y[0][2];
>+    result[2] += x[1] * y[1][2];
>+    return result;
>+}
>+float2 mul(float2x3 x, float3 y) {
>+    float2 result;
>+    result[0] = 0;
>+    result[0] += x[0][0] * y[0];
>+    result[0] += x[0][1] * y[1];
>+    result[0] += x[0][2] * y[2];
>+    result[1] = 0;
>+    result[1] += x[1][0] * y[0];
>+    result[1] += x[1][1] * y[1];
>+    result[1] += x[1][2] * y[2];
>+    return result;
>+}
>+float4 mul(float2 x, float2x4 y) {
>+    float4 result;
>+    result[0] = 0;
>+    result[0] += x[0] * y[0][0];
>+    result[0] += x[1] * y[1][0];
>+    result[1] = 0;
>+    result[1] += x[0] * y[0][1];
>+    result[1] += x[1] * y[1][1];
>+    result[2] = 0;
>+    result[2] += x[0] * y[0][2];
>+    result[2] += x[1] * y[1][2];
>+    result[3] = 0;
>+    result[3] += x[0] * y[0][3];
>+    result[3] += x[1] * y[1][3];
>+    return result;
>+}
>+float2 mul(float2x4 x, float4 y) {
>+    float2 result;
>+    result[0] = 0;
>+    result[0] += x[0][0] * y[0];
>+    result[0] += x[0][1] * y[1];
>+    result[0] += x[0][2] * y[2];
>+    result[0] += x[0][3] * y[3];
>+    result[1] = 0;
>+    result[1] += x[1][0] * y[0];
>+    result[1] += x[1][1] * y[1];
>+    result[1] += x[1][2] * y[2];
>+    result[1] += x[1][3] * y[3];
>+    return result;
>+}
>+float2 mul(float3 x, float3x2 y) {
>+    float2 result;
>+    result[0] = 0;
>+    result[0] += x[0] * y[0][0];
>+    result[0] += x[1] * y[1][0];
>+    result[0] += x[2] * y[2][0];
>+    result[1] = 0;
>+    result[1] += x[0] * y[0][1];
>+    result[1] += x[1] * y[1][1];
>+    result[1] += x[2] * y[2][1];
>+    return result;
>+}
>+float3 mul(float3x2 x, float2 y) {
>+    float3 result;
>+    result[0] = 0;
>+    result[0] += x[0][0] * y[0];
>+    result[0] += x[0][1] * y[1];
>+    result[1] = 0;
>+    result[1] += x[1][0] * y[0];
>+    result[1] += x[1][1] * y[1];
>+    result[2] = 0;
>+    result[2] += x[2][0] * y[0];
>+    result[2] += x[2][1] * y[1];
>+    return result;
>+}
>+float3 mul(float3 x, float3x3 y) {
>+    float3 result;
>+    result[0] = 0;
>+    result[0] += x[0] * y[0][0];
>+    result[0] += x[1] * y[1][0];
>+    result[0] += x[2] * y[2][0];
>+    result[1] = 0;
>+    result[1] += x[0] * y[0][1];
>+    result[1] += x[1] * y[1][1];
>+    result[1] += x[2] * y[2][1];
>+    result[2] = 0;
>+    result[2] += x[0] * y[0][2];
>+    result[2] += x[1] * y[1][2];
>+    result[2] += x[2] * y[2][2];
>+    return result;
>+}
>+float3 mul(float3x3 x, float3 y) {
>+    float3 result;
>+    result[0] = 0;
>+    result[0] += x[0][0] * y[0];
>+    result[0] += x[0][1] * y[1];
>+    result[0] += x[0][2] * y[2];
>+    result[1] = 0;
>+    result[1] += x[1][0] * y[0];
>+    result[1] += x[1][1] * y[1];
>+    result[1] += x[1][2] * y[2];
>+    result[2] = 0;
>+    result[2] += x[2][0] * y[0];
>+    result[2] += x[2][1] * y[1];
>+    result[2] += x[2][2] * y[2];
>+    return result;
>+}
>+float4 mul(float3 x, float3x4 y) {
>+    float4 result;
>+    result[0] = 0;
>+    result[0] += x[0] * y[0][0];
>+    result[0] += x[1] * y[1][0];
>+    result[0] += x[2] * y[2][0];
>+    result[1] = 0;
>+    result[1] += x[0] * y[0][1];
>+    result[1] += x[1] * y[1][1];
>+    result[1] += x[2] * y[2][1];
>+    result[2] = 0;
>+    result[2] += x[0] * y[0][2];
>+    result[2] += x[1] * y[1][2];
>+    result[2] += x[2] * y[2][2];
>+    result[3] = 0;
>+    result[3] += x[0] * y[0][3];
>+    result[3] += x[1] * y[1][3];
>+    result[3] += x[2] * y[2][3];
>+    return result;
>+}
>+float3 mul(float3x4 x, float4 y) {
>+    float3 result;
>+    result[0] = 0;
>+    result[0] += x[0][0] * y[0];
>+    result[0] += x[0][1] * y[1];
>+    result[0] += x[0][2] * y[2];
>+    result[0] += x[0][3] * y[3];
>+    result[1] = 0;
>+    result[1] += x[1][0] * y[0];
>+    result[1] += x[1][1] * y[1];
>+    result[1] += x[1][2] * y[2];
>+    result[1] += x[1][3] * y[3];
>+    result[2] = 0;
>+    result[2] += x[2][0] * y[0];
>+    result[2] += x[2][1] * y[1];
>+    result[2] += x[2][2] * y[2];
>+    result[2] += x[2][3] * y[3];
>+    return result;
>+}
>+float2 mul(float4 x, float4x2 y) {
>+    float2 result;
>+    result[0] = 0;
>+    result[0] += x[0] * y[0][0];
>+    result[0] += x[1] * y[1][0];
>+    result[0] += x[2] * y[2][0];
>+    result[0] += x[3] * y[3][0];
>+    result[1] = 0;
>+    result[1] += x[0] * y[0][1];
>+    result[1] += x[1] * y[1][1];
>+    result[1] += x[2] * y[2][1];
>+    result[1] += x[3] * y[3][1];
>+    return result;
>+}
>+float4 mul(float4x2 x, float2 y) {
>+    float4 result;
>+    result[0] = 0;
>+    result[0] += x[0][0] * y[0];
>+    result[0] += x[0][1] * y[1];
>+    result[1] = 0;
>+    result[1] += x[1][0] * y[0];
>+    result[1] += x[1][1] * y[1];
>+    result[2] = 0;
>+    result[2] += x[2][0] * y[0];
>+    result[2] += x[2][1] * y[1];
>+    result[3] = 0;
>+    result[3] += x[3][0] * y[0];
>+    result[3] += x[3][1] * y[1];
>+    return result;
>+}
>+float3 mul(float4 x, float4x3 y) {
>+    float3 result;
>+    result[0] = 0;
>+    result[0] += x[0] * y[0][0];
>+    result[0] += x[1] * y[1][0];
>+    result[0] += x[2] * y[2][0];
>+    result[0] += x[3] * y[3][0];
>+    result[1] = 0;
>+    result[1] += x[0] * y[0][1];
>+    result[1] += x[1] * y[1][1];
>+    result[1] += x[2] * y[2][1];
>+    result[1] += x[3] * y[3][1];
>+    result[2] = 0;
>+    result[2] += x[0] * y[0][2];
>+    result[2] += x[1] * y[1][2];
>+    result[2] += x[2] * y[2][2];
>+    result[2] += x[3] * y[3][2];
>+    return result;
>+}
>+float4 mul(float4x3 x, float3 y) {
>+    float4 result;
>+    result[0] = 0;
>+    result[0] += x[0][0] * y[0];
>+    result[0] += x[0][1] * y[1];
>+    result[0] += x[0][2] * y[2];
>+    result[1] = 0;
>+    result[1] += x[1][0] * y[0];
>+    result[1] += x[1][1] * y[1];
>+    result[1] += x[1][2] * y[2];
>+    result[2] = 0;
>+    result[2] += x[2][0] * y[0];
>+    result[2] += x[2][1] * y[1];
>+    result[2] += x[2][2] * y[2];
>+    result[3] = 0;
>+    result[3] += x[3][0] * y[0];
>+    result[3] += x[3][1] * y[1];
>+    result[3] += x[3][2] * y[2];
>+    return result;
>+}
>+float4 mul(float4 x, float4x4 y) {
>+    float4 result;
>+    result[0] = 0;
>+    result[0] += x[0] * y[0][0];
>+    result[0] += x[1] * y[1][0];
>+    result[0] += x[2] * y[2][0];
>+    result[0] += x[3] * y[3][0];
>+    result[1] = 0;
>+    result[1] += x[0] * y[0][1];
>+    result[1] += x[1] * y[1][1];
>+    result[1] += x[2] * y[2][1];
>+    result[1] += x[3] * y[3][1];
>+    result[2] = 0;
>+    result[2] += x[0] * y[0][2];
>+    result[2] += x[1] * y[1][2];
>+    result[2] += x[2] * y[2][2];
>+    result[2] += x[3] * y[3][2];
>+    result[3] = 0;
>+    result[3] += x[0] * y[0][3];
>+    result[3] += x[1] * y[1][3];
>+    result[3] += x[2] * y[2][3];
>+    result[3] += x[3] * y[3][3];
>+    return result;
>+}
>+float4 mul(float4x4 x, float4 y) {
>+    float4 result;
>+    result[0] = 0;
>+    result[0] += x[0][0] * y[0];
>+    result[0] += x[0][1] * y[1];
>+    result[0] += x[0][2] * y[2];
>+    result[0] += x[0][3] * y[3];
>+    result[1] = 0;
>+    result[1] += x[1][0] * y[0];
>+    result[1] += x[1][1] * y[1];
>+    result[1] += x[1][2] * y[2];
>+    result[1] += x[1][3] * y[3];
>+    result[2] = 0;
>+    result[2] += x[2][0] * y[0];
>+    result[2] += x[2][1] * y[1];
>+    result[2] += x[2][2] * y[2];
>+    result[2] += x[2][3] * y[3];
>+    result[3] = 0;
>+    result[3] += x[3][0] * y[0];
>+    result[3] += x[3][1] * y[1];
>+    result[3] += x[3][2] * y[2];
>+    result[3] += x[3][3] * y[3];
>+    return result;
>+}
>+half2x2 mul(half2x2 x, half2x2 y) {
>+    half2x2 result;
>+    result[0][0] = 0;
>+    result[0][0] += x[0][0] * y[0][0];
>+    result[0][0] += x[0][1] * y[1][0];
>+    result[0][1] = 0;
>+    result[0][1] += x[0][0] * y[0][1];
>+    result[0][1] += x[0][1] * y[1][1];
>+    result[1][0] = 0;
>+    result[1][0] += x[1][0] * y[0][0];
>+    result[1][0] += x[1][1] * y[1][0];
>+    result[1][1] = 0;
>+    result[1][1] += x[1][0] * y[0][1];
>+    result[1][1] += x[1][1] * y[1][1];
>+    return result;
>+}
>+half2x3 mul(half2x2 x, half2x3 y) {
>+    half2x3 result;
>+    result[0][0] = 0;
>+    result[0][0] += x[0][0] * y[0][0];
>+    result[0][0] += x[0][1] * y[1][0];
>+    result[0][1] = 0;
>+    result[0][1] += x[0][0] * y[0][1];
>+    result[0][1] += x[0][1] * y[1][1];
>+    result[0][2] = 0;
>+    result[0][2] += x[0][0] * y[0][2];
>+    result[0][2] += x[0][1] * y[1][2];
>+    result[1][0] = 0;
>+    result[1][0] += x[1][0] * y[0][0];
>+    result[1][0] += x[1][1] * y[1][0];
>+    result[1][1] = 0;
>+    result[1][1] += x[1][0] * y[0][1];
>+    result[1][1] += x[1][1] * y[1][1];
>+    result[1][2] = 0;
>+    result[1][2] += x[1][0] * y[0][2];
>+    result[1][2] += x[1][1] * y[1][2];
>+    return result;
>+}
>+half2x4 mul(half2x2 x, half2x4 y) {
>+    half2x4 result;
>+    result[0][0] = 0;
>+    result[0][0] += x[0][0] * y[0][0];
>+    result[0][0] += x[0][1] * y[1][0];
>+    result[0][1] = 0;
>+    result[0][1] += x[0][0] * y[0][1];
>+    result[0][1] += x[0][1] * y[1][1];
>+    result[0][2] = 0;
>+    result[0][2] += x[0][0] * y[0][2];
>+    result[0][2] += x[0][1] * y[1][2];
>+    result[0][3] = 0;
>+    result[0][3] += x[0][0] * y[0][3];
>+    result[0][3] += x[0][1] * y[1][3];
>+    result[1][0] = 0;
>+    result[1][0] += x[1][0] * y[0][0];
>+    result[1][0] += x[1][1] * y[1][0];
>+    result[1][1] = 0;
>+    result[1][1] += x[1][0] * y[0][1];
>+    result[1][1] += x[1][1] * y[1][1];
>+    result[1][2] = 0;
>+    result[1][2] += x[1][0] * y[0][2];
>+    result[1][2] += x[1][1] * y[1][2];
>+    result[1][3] = 0;
>+    result[1][3] += x[1][0] * y[0][3];
>+    result[1][3] += x[1][1] * y[1][3];
>+    return result;
>+}
>+half2x2 mul(half2x3 x, half3x2 y) {
>+    half2x2 result;
>+    result[0][0] = 0;
>+    result[0][0] += x[0][0] * y[0][0];
>+    result[0][0] += x[0][1] * y[1][0];
>+    result[0][0] += x[0][2] * y[2][0];
>+    result[0][1] = 0;
>+    result[0][1] += x[0][0] * y[0][1];
>+    result[0][1] += x[0][1] * y[1][1];
>+    result[0][1] += x[0][2] * y[2][1];
>+    result[1][0] = 0;
>+    result[1][0] += x[1][0] * y[0][0];
>+    result[1][0] += x[1][1] * y[1][0];
>+    result[1][0] += x[1][2] * y[2][0];
>+    result[1][1] = 0;
>+    result[1][1] += x[1][0] * y[0][1];
>+    result[1][1] += x[1][1] * y[1][1];
>+    result[1][1] += x[1][2] * y[2][1];
>+    return result;
>+}
>+half2x3 mul(half2x3 x, half3x3 y) {
>+    half2x3 result;
>+    result[0][0] = 0;
>+    result[0][0] += x[0][0] * y[0][0];
>+    result[0][0] += x[0][1] * y[1][0];
>+    result[0][0] += x[0][2] * y[2][0];
>+    result[0][1] = 0;
>+    result[0][1] += x[0][0] * y[0][1];
>+    result[0][1] += x[0][1] * y[1][1];
>+    result[0][1] += x[0][2] * y[2][1];
>+    result[0][2] = 0;
>+    result[0][2] += x[0][0] * y[0][2];
>+    result[0][2] += x[0][1] * y[1][2];
>+    result[0][2] += x[0][2] * y[2][2];
>+    result[1][0] = 0;
>+    result[1][0] += x[1][0] * y[0][0];
>+    result[1][0] += x[1][1] * y[1][0];
>+    result[1][0] += x[1][2] * y[2][0];
>+    result[1][1] = 0;
>+    result[1][1] += x[1][0] * y[0][1];
>+    result[1][1] += x[1][1] * y[1][1];
>+    result[1][1] += x[1][2] * y[2][1];
>+    result[1][2] = 0;
>+    result[1][2] += x[1][0] * y[0][2];
>+    result[1][2] += x[1][1] * y[1][2];
>+    result[1][2] += x[1][2] * y[2][2];
>+    return result;
>+}
>+half2x4 mul(half2x3 x, half3x4 y) {
>+    half2x4 result;
>+    result[0][0] = 0;
>+    result[0][0] += x[0][0] * y[0][0];
>+    result[0][0] += x[0][1] * y[1][0];
>+    result[0][0] += x[0][2] * y[2][0];
>+    result[0][1] = 0;
>+    result[0][1] += x[0][0] * y[0][1];
>+    result[0][1] += x[0][1] * y[1][1];
>+    result[0][1] += x[0][2] * y[2][1];
>+    result[0][2] = 0;
>+    result[0][2] += x[0][0] * y[0][2];
>+    result[0][2] += x[0][1] * y[1][2];
>+    result[0][2] += x[0][2] * y[2][2];
>+    result[0][3] = 0;
>+    result[0][3] += x[0][0] * y[0][3];
>+    result[0][3] += x[0][1] * y[1][3];
>+    result[0][3] += x[0][2] * y[2][3];
>+    result[1][0] = 0;
>+    result[1][0] += x[1][0] * y[0][0];
>+    result[1][0] += x[1][1] * y[1][0];
>+    result[1][0] += x[1][2] * y[2][0];
>+    result[1][1] = 0;
>+    result[1][1] += x[1][0] * y[0][1];
>+    result[1][1] += x[1][1] * y[1][1];
>+    result[1][1] += x[1][2] * y[2][1];
>+    result[1][2] = 0;
>+    result[1][2] += x[1][0] * y[0][2];
>+    result[1][2] += x[1][1] * y[1][2];
>+    result[1][2] += x[1][2] * y[2][2];
>+    result[1][3] = 0;
>+    result[1][3] += x[1][0] * y[0][3];
>+    result[1][3] += x[1][1] * y[1][3];
>+    result[1][3] += x[1][2] * y[2][3];
>+    return result;
>+}
>+half2x2 mul(half2x4 x, half4x2 y) {
>+    half2x2 result;
>+    result[0][0] = 0;
>+    result[0][0] += x[0][0] * y[0][0];
>+    result[0][0] += x[0][1] * y[1][0];
>+    result[0][0] += x[0][2] * y[2][0];
>+    result[0][0] += x[0][3] * y[3][0];
>+    result[0][1] = 0;
>+    result[0][1] += x[0][0] * y[0][1];
>+    result[0][1] += x[0][1] * y[1][1];
>+    result[0][1] += x[0][2] * y[2][1];
>+    result[0][1] += x[0][3] * y[3][1];
>+    result[1][0] = 0;
>+    result[1][0] += x[1][0] * y[0][0];
>+    result[1][0] += x[1][1] * y[1][0];
>+    result[1][0] += x[1][2] * y[2][0];
>+    result[1][0] += x[1][3] * y[3][0];
>+    result[1][1] = 0;
>+    result[1][1] += x[1][0] * y[0][1];
>+    result[1][1] += x[1][1] * y[1][1];
>+    result[1][1] += x[1][2] * y[2][1];
>+    result[1][1] += x[1][3] * y[3][1];
>+    return result;
>+}
>+half2x3 mul(half2x4 x, half4x3 y) {
>+    half2x3 result;
>+    result[0][0] = 0;
>+    result[0][0] += x[0][0] * y[0][0];
>+    result[0][0] += x[0][1] * y[1][0];
>+    result[0][0] += x[0][2] * y[2][0];
>+    result[0][0] += x[0][3] * y[3][0];
>+    result[0][1] = 0;
>+    result[0][1] += x[0][0] * y[0][1];
>+    result[0][1] += x[0][1] * y[1][1];
>+    result[0][1] += x[0][2] * y[2][1];
>+    result[0][1] += x[0][3] * y[3][1];
>+    result[0][2] = 0;
>+    result[0][2] += x[0][0] * y[0][2];
>+    result[0][2] += x[0][1] * y[1][2];
>+    result[0][2] += x[0][2] * y[2][2];
>+    result[0][2] += x[0][3] * y[3][2];
>+    result[1][0] = 0;
>+    result[1][0] += x[1][0] * y[0][0];
>+    result[1][0] += x[1][1] * y[1][0];
>+    result[1][0] += x[1][2] * y[2][0];
>+    result[1][0] += x[1][3] * y[3][0];
>+    result[1][1] = 0;
>+    result[1][1] += x[1][0] * y[0][1];
>+    result[1][1] += x[1][1] * y[1][1];
>+    result[1][1] += x[1][2] * y[2][1];
>+    result[1][1] += x[1][3] * y[3][1];
>+    result[1][2] = 0;
>+    result[1][2] += x[1][0] * y[0][2];
>+    result[1][2] += x[1][1] * y[1][2];
>+    result[1][2] += x[1][2] * y[2][2];
>+    result[1][2] += x[1][3] * y[3][2];
>+    return result;
>+}
>+half2x4 mul(half2x4 x, half4x4 y) {
>+    half2x4 result;
>+    result[0][0] = 0;
>+    result[0][0] += x[0][0] * y[0][0];
>+    result[0][0] += x[0][1] * y[1][0];
>+    result[0][0] += x[0][2] * y[2][0];
>+    result[0][0] += x[0][3] * y[3][0];
>+    result[0][1] = 0;
>+    result[0][1] += x[0][0] * y[0][1];
>+    result[0][1] += x[0][1] * y[1][1];
>+    result[0][1] += x[0][2] * y[2][1];
>+    result[0][1] += x[0][3] * y[3][1];
>+    result[0][2] = 0;
>+    result[0][2] += x[0][0] * y[0][2];
>+    result[0][2] += x[0][1] * y[1][2];
>+    result[0][2] += x[0][2] * y[2][2];
>+    result[0][2] += x[0][3] * y[3][2];
>+    result[0][3] = 0;
>+    result[0][3] += x[0][0] * y[0][3];
>+    result[0][3] += x[0][1] * y[1][3];
>+    result[0][3] += x[0][2] * y[2][3];
>+    result[0][3] += x[0][3] * y[3][3];
>+    result[1][0] = 0;
>+    result[1][0] += x[1][0] * y[0][0];
>+    result[1][0] += x[1][1] * y[1][0];
>+    result[1][0] += x[1][2] * y[2][0];
>+    result[1][0] += x[1][3] * y[3][0];
>+    result[1][1] = 0;
>+    result[1][1] += x[1][0] * y[0][1];
>+    result[1][1] += x[1][1] * y[1][1];
>+    result[1][1] += x[1][2] * y[2][1];
>+    result[1][1] += x[1][3] * y[3][1];
>+    result[1][2] = 0;
>+    result[1][2] += x[1][0] * y[0][2];
>+    result[1][2] += x[1][1] * y[1][2];
>+    result[1][2] += x[1][2] * y[2][2];
>+    result[1][2] += x[1][3] * y[3][2];
>+    result[1][3] = 0;
>+    result[1][3] += x[1][0] * y[0][3];
>+    result[1][3] += x[1][1] * y[1][3];
>+    result[1][3] += x[1][2] * y[2][3];
>+    result[1][3] += x[1][3] * y[3][3];
>+    return result;
>+}
>+half3x2 mul(half3x2 x, half2x2 y) {
>+    half3x2 result;
>+    result[0][0] = 0;
>+    result[0][0] += x[0][0] * y[0][0];
>+    result[0][0] += x[0][1] * y[1][0];
>+    result[0][1] = 0;
>+    result[0][1] += x[0][0] * y[0][1];
>+    result[0][1] += x[0][1] * y[1][1];
>+    result[1][0] = 0;
>+    result[1][0] += x[1][0] * y[0][0];
>+    result[1][0] += x[1][1] * y[1][0];
>+    result[1][1] = 0;
>+    result[1][1] += x[1][0] * y[0][1];
>+    result[1][1] += x[1][1] * y[1][1];
>+    result[2][0] = 0;
>+    result[2][0] += x[2][0] * y[0][0];
>+    result[2][0] += x[2][1] * y[1][0];
>+    result[2][1] = 0;
>+    result[2][1] += x[2][0] * y[0][1];
>+    result[2][1] += x[2][1] * y[1][1];
>+    return result;
>+}
>+half3x3 mul(half3x2 x, half2x3 y) {
>+    half3x3 result;
>+    result[0][0] = 0;
>+    result[0][0] += x[0][0] * y[0][0];
>+    result[0][0] += x[0][1] * y[1][0];
>+    result[0][1] = 0;
>+    result[0][1] += x[0][0] * y[0][1];
>+    result[0][1] += x[0][1] * y[1][1];
>+    result[0][2] = 0;
>+    result[0][2] += x[0][0] * y[0][2];
>+    result[0][2] += x[0][1] * y[1][2];
>+    result[1][0] = 0;
>+    result[1][0] += x[1][0] * y[0][0];
>+    result[1][0] += x[1][1] * y[1][0];
>+    result[1][1] = 0;
>+    result[1][1] += x[1][0] * y[0][1];
>+    result[1][1] += x[1][1] * y[1][1];
>+    result[1][2] = 0;
>+    result[1][2] += x[1][0] * y[0][2];
>+    result[1][2] += x[1][1] * y[1][2];
>+    result[2][0] = 0;
>+    result[2][0] += x[2][0] * y[0][0];
>+    result[2][0] += x[2][1] * y[1][0];
>+    result[2][1] = 0;
>+    result[2][1] += x[2][0] * y[0][1];
>+    result[2][1] += x[2][1] * y[1][1];
>+    result[2][2] = 0;
>+    result[2][2] += x[2][0] * y[0][2];
>+    result[2][2] += x[2][1] * y[1][2];
>+    return result;
>+}
>+half3x4 mul(half3x2 x, half2x4 y) {
>+    half3x4 result;
>+    result[0][0] = 0;
>+    result[0][0] += x[0][0] * y[0][0];
>+    result[0][0] += x[0][1] * y[1][0];
>+    result[0][1] = 0;
>+    result[0][1] += x[0][0] * y[0][1];
>+    result[0][1] += x[0][1] * y[1][1];
>+    result[0][2] = 0;
>+    result[0][2] += x[0][0] * y[0][2];
>+    result[0][2] += x[0][1] * y[1][2];
>+    result[0][3] = 0;
>+    result[0][3] += x[0][0] * y[0][3];
>+    result[0][3] += x[0][1] * y[1][3];
>+    result[1][0] = 0;
>+    result[1][0] += x[1][0] * y[0][0];
>+    result[1][0] += x[1][1] * y[1][0];
>+    result[1][1] = 0;
>+    result[1][1] += x[1][0] * y[0][1];
>+    result[1][1] += x[1][1] * y[1][1];
>+    result[1][2] = 0;
>+    result[1][2] += x[1][0] * y[0][2];
>+    result[1][2] += x[1][1] * y[1][2];
>+    result[1][3] = 0;
>+    result[1][3] += x[1][0] * y[0][3];
>+    result[1][3] += x[1][1] * y[1][3];
>+    result[2][0] = 0;
>+    result[2][0] += x[2][0] * y[0][0];
>+    result[2][0] += x[2][1] * y[1][0];
>+    result[2][1] = 0;
>+    result[2][1] += x[2][0] * y[0][1];
>+    result[2][1] += x[2][1] * y[1][1];
>+    result[2][2] = 0;
>+    result[2][2] += x[2][0] * y[0][2];
>+    result[2][2] += x[2][1] * y[1][2];
>+    result[2][3] = 0;
>+    result[2][3] += x[2][0] * y[0][3];
>+    result[2][3] += x[2][1] * y[1][3];
>+    return result;
>+}
>+half3x2 mul(half3x3 x, half3x2 y) {
>+    half3x2 result;
>+    result[0][0] = 0;
>+    result[0][0] += x[0][0] * y[0][0];
>+    result[0][0] += x[0][1] * y[1][0];
>+    result[0][0] += x[0][2] * y[2][0];
>+    result[0][1] = 0;
>+    result[0][1] += x[0][0] * y[0][1];
>+    result[0][1] += x[0][1] * y[1][1];
>+    result[0][1] += x[0][2] * y[2][1];
>+    result[1][0] = 0;
>+    result[1][0] += x[1][0] * y[0][0];
>+    result[1][0] += x[1][1] * y[1][0];
>+    result[1][0] += x[1][2] * y[2][0];
>+    result[1][1] = 0;
>+    result[1][1] += x[1][0] * y[0][1];
>+    result[1][1] += x[1][1] * y[1][1];
>+    result[1][1] += x[1][2] * y[2][1];
>+    result[2][0] = 0;
>+    result[2][0] += x[2][0] * y[0][0];
>+    result[2][0] += x[2][1] * y[1][0];
>+    result[2][0] += x[2][2] * y[2][0];
>+    result[2][1] = 0;
>+    result[2][1] += x[2][0] * y[0][1];
>+    result[2][1] += x[2][1] * y[1][1];
>+    result[2][1] += x[2][2] * y[2][1];
>+    return result;
>+}
>+half3x3 mul(half3x3 x, half3x3 y) {
>+    half3x3 result;
>+    result[0][0] = 0;
>+    result[0][0] += x[0][0] * y[0][0];
>+    result[0][0] += x[0][1] * y[1][0];
>+    result[0][0] += x[0][2] * y[2][0];
>+    result[0][1] = 0;
>+    result[0][1] += x[0][0] * y[0][1];
>+    result[0][1] += x[0][1] * y[1][1];
>+    result[0][1] += x[0][2] * y[2][1];
>+    result[0][2] = 0;
>+    result[0][2] += x[0][0] * y[0][2];
>+    result[0][2] += x[0][1] * y[1][2];
>+    result[0][2] += x[0][2] * y[2][2];
>+    result[1][0] = 0;
>+    result[1][0] += x[1][0] * y[0][0];
>+    result[1][0] += x[1][1] * y[1][0];
>+    result[1][0] += x[1][2] * y[2][0];
>+    result[1][1] = 0;
>+    result[1][1] += x[1][0] * y[0][1];
>+    result[1][1] += x[1][1] * y[1][1];
>+    result[1][1] += x[1][2] * y[2][1];
>+    result[1][2] = 0;
>+    result[1][2] += x[1][0] * y[0][2];
>+    result[1][2] += x[1][1] * y[1][2];
>+    result[1][2] += x[1][2] * y[2][2];
>+    result[2][0] = 0;
>+    result[2][0] += x[2][0] * y[0][0];
>+    result[2][0] += x[2][1] * y[1][0];
>+    result[2][0] += x[2][2] * y[2][0];
>+    result[2][1] = 0;
>+    result[2][1] += x[2][0] * y[0][1];
>+    result[2][1] += x[2][1] * y[1][1];
>+    result[2][1] += x[2][2] * y[2][1];
>+    result[2][2] = 0;
>+    result[2][2] += x[2][0] * y[0][2];
>+    result[2][2] += x[2][1] * y[1][2];
>+    result[2][2] += x[2][2] * y[2][2];
>+    return result;
>+}
>+half3x4 mul(half3x3 x, half3x4 y) {
>+    half3x4 result;
>+    result[0][0] = 0;
>+    result[0][0] += x[0][0] * y[0][0];
>+    result[0][0] += x[0][1] * y[1][0];
>+    result[0][0] += x[0][2] * y[2][0];
>+    result[0][1] = 0;
>+    result[0][1] += x[0][0] * y[0][1];
>+    result[0][1] += x[0][1] * y[1][1];
>+    result[0][1] += x[0][2] * y[2][1];
>+    result[0][2] = 0;
>+    result[0][2] += x[0][0] * y[0][2];
>+    result[0][2] += x[0][1] * y[1][2];
>+    result[0][2] += x[0][2] * y[2][2];
>+    result[0][3] = 0;
>+    result[0][3] += x[0][0] * y[0][3];
>+    result[0][3] += x[0][1] * y[1][3];
>+    result[0][3] += x[0][2] * y[2][3];
>+    result[1][0] = 0;
>+    result[1][0] += x[1][0] * y[0][0];
>+    result[1][0] += x[1][1] * y[1][0];
>+    result[1][0] += x[1][2] * y[2][0];
>+    result[1][1] = 0;
>+    result[1][1] += x[1][0] * y[0][1];
>+    result[1][1] += x[1][1] * y[1][1];
>+    result[1][1] += x[1][2] * y[2][1];
>+    result[1][2] = 0;
>+    result[1][2] += x[1][0] * y[0][2];
>+    result[1][2] += x[1][1] * y[1][2];
>+    result[1][2] += x[1][2] * y[2][2];
>+    result[1][3] = 0;
>+    result[1][3] += x[1][0] * y[0][3];
>+    result[1][3] += x[1][1] * y[1][3];
>+    result[1][3] += x[1][2] * y[2][3];
>+    result[2][0] = 0;
>+    result[2][0] += x[2][0] * y[0][0];
>+    result[2][0] += x[2][1] * y[1][0];
>+    result[2][0] += x[2][2] * y[2][0];
>+    result[2][1] = 0;
>+    result[2][1] += x[2][0] * y[0][1];
>+    result[2][1] += x[2][1] * y[1][1];
>+    result[2][1] += x[2][2] * y[2][1];
>+    result[2][2] = 0;
>+    result[2][2] += x[2][0] * y[0][2];
>+    result[2][2] += x[2][1] * y[1][2];
>+    result[2][2] += x[2][2] * y[2][2];
>+    result[2][3] = 0;
>+    result[2][3] += x[2][0] * y[0][3];
>+    result[2][3] += x[2][1] * y[1][3];
>+    result[2][3] += x[2][2] * y[2][3];
>+    return result;
>+}
>+half3x2 mul(half3x4 x, half4x2 y) {
>+    half3x2 result;
>+    result[0][0] = 0;
>+    result[0][0] += x[0][0] * y[0][0];
>+    result[0][0] += x[0][1] * y[1][0];
>+    result[0][0] += x[0][2] * y[2][0];
>+    result[0][0] += x[0][3] * y[3][0];
>+    result[0][1] = 0;
>+    result[0][1] += x[0][0] * y[0][1];
>+    result[0][1] += x[0][1] * y[1][1];
>+    result[0][1] += x[0][2] * y[2][1];
>+    result[0][1] += x[0][3] * y[3][1];
>+    result[1][0] = 0;
>+    result[1][0] += x[1][0] * y[0][0];
>+    result[1][0] += x[1][1] * y[1][0];
>+    result[1][0] += x[1][2] * y[2][0];
>+    result[1][0] += x[1][3] * y[3][0];
>+    result[1][1] = 0;
>+    result[1][1] += x[1][0] * y[0][1];
>+    result[1][1] += x[1][1] * y[1][1];
>+    result[1][1] += x[1][2] * y[2][1];
>+    result[1][1] += x[1][3] * y[3][1];
>+    result[2][0] = 0;
>+    result[2][0] += x[2][0] * y[0][0];
>+    result[2][0] += x[2][1] * y[1][0];
>+    result[2][0] += x[2][2] * y[2][0];
>+    result[2][0] += x[2][3] * y[3][0];
>+    result[2][1] = 0;
>+    result[2][1] += x[2][0] * y[0][1];
>+    result[2][1] += x[2][1] * y[1][1];
>+    result[2][1] += x[2][2] * y[2][1];
>+    result[2][1] += x[2][3] * y[3][1];
>+    return result;
>+}
>+half3x3 mul(half3x4 x, half4x3 y) {
>+    half3x3 result;
>+    result[0][0] = 0;
>+    result[0][0] += x[0][0] * y[0][0];
>+    result[0][0] += x[0][1] * y[1][0];
>+    result[0][0] += x[0][2] * y[2][0];
>+    result[0][0] += x[0][3] * y[3][0];
>+    result[0][1] = 0;
>+    result[0][1] += x[0][0] * y[0][1];
>+    result[0][1] += x[0][1] * y[1][1];
>+    result[0][1] += x[0][2] * y[2][1];
>+    result[0][1] += x[0][3] * y[3][1];
>+    result[0][2] = 0;
>+    result[0][2] += x[0][0] * y[0][2];
>+    result[0][2] += x[0][1] * y[1][2];
>+    result[0][2] += x[0][2] * y[2][2];
>+    result[0][2] += x[0][3] * y[3][2];
>+    result[1][0] = 0;
>+    result[1][0] += x[1][0] * y[0][0];
>+    result[1][0] += x[1][1] * y[1][0];
>+    result[1][0] += x[1][2] * y[2][0];
>+    result[1][0] += x[1][3] * y[3][0];
>+    result[1][1] = 0;
>+    result[1][1] += x[1][0] * y[0][1];
>+    result[1][1] += x[1][1] * y[1][1];
>+    result[1][1] += x[1][2] * y[2][1];
>+    result[1][1] += x[1][3] * y[3][1];
>+    result[1][2] = 0;
>+    result[1][2] += x[1][0] * y[0][2];
>+    result[1][2] += x[1][1] * y[1][2];
>+    result[1][2] += x[1][2] * y[2][2];
>+    result[1][2] += x[1][3] * y[3][2];
>+    result[2][0] = 0;
>+    result[2][0] += x[2][0] * y[0][0];
>+    result[2][0] += x[2][1] * y[1][0];
>+    result[2][0] += x[2][2] * y[2][0];
>+    result[2][0] += x[2][3] * y[3][0];
>+    result[2][1] = 0;
>+    result[2][1] += x[2][0] * y[0][1];
>+    result[2][1] += x[2][1] * y[1][1];
>+    result[2][1] += x[2][2] * y[2][1];
>+    result[2][1] += x[2][3] * y[3][1];
>+    result[2][2] = 0;
>+    result[2][2] += x[2][0] * y[0][2];
>+    result[2][2] += x[2][1] * y[1][2];
>+    result[2][2] += x[2][2] * y[2][2];
>+    result[2][2] += x[2][3] * y[3][2];
>+    return result;
>+}
>+half3x4 mul(half3x4 x, half4x4 y) {
>+    half3x4 result;
>+    result[0][0] = 0;
>+    result[0][0] += x[0][0] * y[0][0];
>+    result[0][0] += x[0][1] * y[1][0];
>+    result[0][0] += x[0][2] * y[2][0];
>+    result[0][0] += x[0][3] * y[3][0];
>+    result[0][1] = 0;
>+    result[0][1] += x[0][0] * y[0][1];
>+    result[0][1] += x[0][1] * y[1][1];
>+    result[0][1] += x[0][2] * y[2][1];
>+    result[0][1] += x[0][3] * y[3][1];
>+    result[0][2] = 0;
>+    result[0][2] += x[0][0] * y[0][2];
>+    result[0][2] += x[0][1] * y[1][2];
>+    result[0][2] += x[0][2] * y[2][2];
>+    result[0][2] += x[0][3] * y[3][2];
>+    result[0][3] = 0;
>+    result[0][3] += x[0][0] * y[0][3];
>+    result[0][3] += x[0][1] * y[1][3];
>+    result[0][3] += x[0][2] * y[2][3];
>+    result[0][3] += x[0][3] * y[3][3];
>+    result[1][0] = 0;
>+    result[1][0] += x[1][0] * y[0][0];
>+    result[1][0] += x[1][1] * y[1][0];
>+    result[1][0] += x[1][2] * y[2][0];
>+    result[1][0] += x[1][3] * y[3][0];
>+    result[1][1] = 0;
>+    result[1][1] += x[1][0] * y[0][1];
>+    result[1][1] += x[1][1] * y[1][1];
>+    result[1][1] += x[1][2] * y[2][1];
>+    result[1][1] += x[1][3] * y[3][1];
>+    result[1][2] = 0;
>+    result[1][2] += x[1][0] * y[0][2];
>+    result[1][2] += x[1][1] * y[1][2];
>+    result[1][2] += x[1][2] * y[2][2];
>+    result[1][2] += x[1][3] * y[3][2];
>+    result[1][3] = 0;
>+    result[1][3] += x[1][0] * y[0][3];
>+    result[1][3] += x[1][1] * y[1][3];
>+    result[1][3] += x[1][2] * y[2][3];
>+    result[1][3] += x[1][3] * y[3][3];
>+    result[2][0] = 0;
>+    result[2][0] += x[2][0] * y[0][0];
>+    result[2][0] += x[2][1] * y[1][0];
>+    result[2][0] += x[2][2] * y[2][0];
>+    result[2][0] += x[2][3] * y[3][0];
>+    result[2][1] = 0;
>+    result[2][1] += x[2][0] * y[0][1];
>+    result[2][1] += x[2][1] * y[1][1];
>+    result[2][1] += x[2][2] * y[2][1];
>+    result[2][1] += x[2][3] * y[3][1];
>+    result[2][2] = 0;
>+    result[2][2] += x[2][0] * y[0][2];
>+    result[2][2] += x[2][1] * y[1][2];
>+    result[2][2] += x[2][2] * y[2][2];
>+    result[2][2] += x[2][3] * y[3][2];
>+    result[2][3] = 0;
>+    result[2][3] += x[2][0] * y[0][3];
>+    result[2][3] += x[2][1] * y[1][3];
>+    result[2][3] += x[2][2] * y[2][3];
>+    result[2][3] += x[2][3] * y[3][3];
>+    return result;
>+}
>+half4x2 mul(half4x2 x, half2x2 y) {
>+    half4x2 result;
>+    result[0][0] = 0;
>+    result[0][0] += x[0][0] * y[0][0];
>+    result[0][0] += x[0][1] * y[1][0];
>+    result[0][1] = 0;
>+    result[0][1] += x[0][0] * y[0][1];
>+    result[0][1] += x[0][1] * y[1][1];
>+    result[1][0] = 0;
>+    result[1][0] += x[1][0] * y[0][0];
>+    result[1][0] += x[1][1] * y[1][0];
>+    result[1][1] = 0;
>+    result[1][1] += x[1][0] * y[0][1];
>+    result[1][1] += x[1][1] * y[1][1];
>+    result[2][0] = 0;
>+    result[2][0] += x[2][0] * y[0][0];
>+    result[2][0] += x[2][1] * y[1][0];
>+    result[2][1] = 0;
>+    result[2][1] += x[2][0] * y[0][1];
>+    result[2][1] += x[2][1] * y[1][1];
>+    result[3][0] = 0;
>+    result[3][0] += x[3][0] * y[0][0];
>+    result[3][0] += x[3][1] * y[1][0];
>+    result[3][1] = 0;
>+    result[3][1] += x[3][0] * y[0][1];
>+    result[3][1] += x[3][1] * y[1][1];
>+    return result;
>+}
>+half4x3 mul(half4x2 x, half2x3 y) {
>+    half4x3 result;
>+    result[0][0] = 0;
>+    result[0][0] += x[0][0] * y[0][0];
>+    result[0][0] += x[0][1] * y[1][0];
>+    result[0][1] = 0;
>+    result[0][1] += x[0][0] * y[0][1];
>+    result[0][1] += x[0][1] * y[1][1];
>+    result[0][2] = 0;
>+    result[0][2] += x[0][0] * y[0][2];
>+    result[0][2] += x[0][1] * y[1][2];
>+    result[1][0] = 0;
>+    result[1][0] += x[1][0] * y[0][0];
>+    result[1][0] += x[1][1] * y[1][0];
>+    result[1][1] = 0;
>+    result[1][1] += x[1][0] * y[0][1];
>+    result[1][1] += x[1][1] * y[1][1];
>+    result[1][2] = 0;
>+    result[1][2] += x[1][0] * y[0][2];
>+    result[1][2] += x[1][1] * y[1][2];
>+    result[2][0] = 0;
>+    result[2][0] += x[2][0] * y[0][0];
>+    result[2][0] += x[2][1] * y[1][0];
>+    result[2][1] = 0;
>+    result[2][1] += x[2][0] * y[0][1];
>+    result[2][1] += x[2][1] * y[1][1];
>+    result[2][2] = 0;
>+    result[2][2] += x[2][0] * y[0][2];
>+    result[2][2] += x[2][1] * y[1][2];
>+    result[3][0] = 0;
>+    result[3][0] += x[3][0] * y[0][0];
>+    result[3][0] += x[3][1] * y[1][0];
>+    result[3][1] = 0;
>+    result[3][1] += x[3][0] * y[0][1];
>+    result[3][1] += x[3][1] * y[1][1];
>+    result[3][2] = 0;
>+    result[3][2] += x[3][0] * y[0][2];
>+    result[3][2] += x[3][1] * y[1][2];
>+    return result;
>+}
>+half4x4 mul(half4x2 x, half2x4 y) {
>+    half4x4 result;
>+    result[0][0] = 0;
>+    result[0][0] += x[0][0] * y[0][0];
>+    result[0][0] += x[0][1] * y[1][0];
>+    result[0][1] = 0;
>+    result[0][1] += x[0][0] * y[0][1];
>+    result[0][1] += x[0][1] * y[1][1];
>+    result[0][2] = 0;
>+    result[0][2] += x[0][0] * y[0][2];
>+    result[0][2] += x[0][1] * y[1][2];
>+    result[0][3] = 0;
>+    result[0][3] += x[0][0] * y[0][3];
>+    result[0][3] += x[0][1] * y[1][3];
>+    result[1][0] = 0;
>+    result[1][0] += x[1][0] * y[0][0];
>+    result[1][0] += x[1][1] * y[1][0];
>+    result[1][1] = 0;
>+    result[1][1] += x[1][0] * y[0][1];
>+    result[1][1] += x[1][1] * y[1][1];
>+    result[1][2] = 0;
>+    result[1][2] += x[1][0] * y[0][2];
>+    result[1][2] += x[1][1] * y[1][2];
>+    result[1][3] = 0;
>+    result[1][3] += x[1][0] * y[0][3];
>+    result[1][3] += x[1][1] * y[1][3];
>+    result[2][0] = 0;
>+    result[2][0] += x[2][0] * y[0][0];
>+    result[2][0] += x[2][1] * y[1][0];
>+    result[2][1] = 0;
>+    result[2][1] += x[2][0] * y[0][1];
>+    result[2][1] += x[2][1] * y[1][1];
>+    result[2][2] = 0;
>+    result[2][2] += x[2][0] * y[0][2];
>+    result[2][2] += x[2][1] * y[1][2];
>+    result[2][3] = 0;
>+    result[2][3] += x[2][0] * y[0][3];
>+    result[2][3] += x[2][1] * y[1][3];
>+    result[3][0] = 0;
>+    result[3][0] += x[3][0] * y[0][0];
>+    result[3][0] += x[3][1] * y[1][0];
>+    result[3][1] = 0;
>+    result[3][1] += x[3][0] * y[0][1];
>+    result[3][1] += x[3][1] * y[1][1];
>+    result[3][2] = 0;
>+    result[3][2] += x[3][0] * y[0][2];
>+    result[3][2] += x[3][1] * y[1][2];
>+    result[3][3] = 0;
>+    result[3][3] += x[3][0] * y[0][3];
>+    result[3][3] += x[3][1] * y[1][3];
>+    return result;
>+}
>+half4x2 mul(half4x3 x, half3x2 y) {
>+    half4x2 result;
>+    result[0][0] = 0;
>+    result[0][0] += x[0][0] * y[0][0];
>+    result[0][0] += x[0][1] * y[1][0];
>+    result[0][0] += x[0][2] * y[2][0];
>+    result[0][1] = 0;
>+    result[0][1] += x[0][0] * y[0][1];
>+    result[0][1] += x[0][1] * y[1][1];
>+    result[0][1] += x[0][2] * y[2][1];
>+    result[1][0] = 0;
>+    result[1][0] += x[1][0] * y[0][0];
>+    result[1][0] += x[1][1] * y[1][0];
>+    result[1][0] += x[1][2] * y[2][0];
>+    result[1][1] = 0;
>+    result[1][1] += x[1][0] * y[0][1];
>+    result[1][1] += x[1][1] * y[1][1];
>+    result[1][1] += x[1][2] * y[2][1];
>+    result[2][0] = 0;
>+    result[2][0] += x[2][0] * y[0][0];
>+    result[2][0] += x[2][1] * y[1][0];
>+    result[2][0] += x[2][2] * y[2][0];
>+    result[2][1] = 0;
>+    result[2][1] += x[2][0] * y[0][1];
>+    result[2][1] += x[2][1] * y[1][1];
>+    result[2][1] += x[2][2] * y[2][1];
>+    result[3][0] = 0;
>+    result[3][0] += x[3][0] * y[0][0];
>+    result[3][0] += x[3][1] * y[1][0];
>+    result[3][0] += x[3][2] * y[2][0];
>+    result[3][1] = 0;
>+    result[3][1] += x[3][0] * y[0][1];
>+    result[3][1] += x[3][1] * y[1][1];
>+    result[3][1] += x[3][2] * y[2][1];
>+    return result;
>+}
>+half4x3 mul(half4x3 x, half3x3 y) {
>+    half4x3 result;
>+    result[0][0] = 0;
>+    result[0][0] += x[0][0] * y[0][0];
>+    result[0][0] += x[0][1] * y[1][0];
>+    result[0][0] += x[0][2] * y[2][0];
>+    result[0][1] = 0;
>+    result[0][1] += x[0][0] * y[0][1];
>+    result[0][1] += x[0][1] * y[1][1];
>+    result[0][1] += x[0][2] * y[2][1];
>+    result[0][2] = 0;
>+    result[0][2] += x[0][0] * y[0][2];
>+    result[0][2] += x[0][1] * y[1][2];
>+    result[0][2] += x[0][2] * y[2][2];
>+    result[1][0] = 0;
>+    result[1][0] += x[1][0] * y[0][0];
>+    result[1][0] += x[1][1] * y[1][0];
>+    result[1][0] += x[1][2] * y[2][0];
>+    result[1][1] = 0;
>+    result[1][1] += x[1][0] * y[0][1];
>+    result[1][1] += x[1][1] * y[1][1];
>+    result[1][1] += x[1][2] * y[2][1];
>+    result[1][2] = 0;
>+    result[1][2] += x[1][0] * y[0][2];
>+    result[1][2] += x[1][1] * y[1][2];
>+    result[1][2] += x[1][2] * y[2][2];
>+    result[2][0] = 0;
>+    result[2][0] += x[2][0] * y[0][0];
>+    result[2][0] += x[2][1] * y[1][0];
>+    result[2][0] += x[2][2] * y[2][0];
>+    result[2][1] = 0;
>+    result[2][1] += x[2][0] * y[0][1];
>+    result[2][1] += x[2][1] * y[1][1];
>+    result[2][1] += x[2][2] * y[2][1];
>+    result[2][2] = 0;
>+    result[2][2] += x[2][0] * y[0][2];
>+    result[2][2] += x[2][1] * y[1][2];
>+    result[2][2] += x[2][2] * y[2][2];
>+    result[3][0] = 0;
>+    result[3][0] += x[3][0] * y[0][0];
>+    result[3][0] += x[3][1] * y[1][0];
>+    result[3][0] += x[3][2] * y[2][0];
>+    result[3][1] = 0;
>+    result[3][1] += x[3][0] * y[0][1];
>+    result[3][1] += x[3][1] * y[1][1];
>+    result[3][1] += x[3][2] * y[2][1];
>+    result[3][2] = 0;
>+    result[3][2] += x[3][0] * y[0][2];
>+    result[3][2] += x[3][1] * y[1][2];
>+    result[3][2] += x[3][2] * y[2][2];
>+    return result;
>+}
>+half4x4 mul(half4x3 x, half3x4 y) {
>+    half4x4 result;
>+    result[0][0] = 0;
>+    result[0][0] += x[0][0] * y[0][0];
>+    result[0][0] += x[0][1] * y[1][0];
>+    result[0][0] += x[0][2] * y[2][0];
>+    result[0][1] = 0;
>+    result[0][1] += x[0][0] * y[0][1];
>+    result[0][1] += x[0][1] * y[1][1];
>+    result[0][1] += x[0][2] * y[2][1];
>+    result[0][2] = 0;
>+    result[0][2] += x[0][0] * y[0][2];
>+    result[0][2] += x[0][1] * y[1][2];
>+    result[0][2] += x[0][2] * y[2][2];
>+    result[0][3] = 0;
>+    result[0][3] += x[0][0] * y[0][3];
>+    result[0][3] += x[0][1] * y[1][3];
>+    result[0][3] += x[0][2] * y[2][3];
>+    result[1][0] = 0;
>+    result[1][0] += x[1][0] * y[0][0];
>+    result[1][0] += x[1][1] * y[1][0];
>+    result[1][0] += x[1][2] * y[2][0];
>+    result[1][1] = 0;
>+    result[1][1] += x[1][0] * y[0][1];
>+    result[1][1] += x[1][1] * y[1][1];
>+    result[1][1] += x[1][2] * y[2][1];
>+    result[1][2] = 0;
>+    result[1][2] += x[1][0] * y[0][2];
>+    result[1][2] += x[1][1] * y[1][2];
>+    result[1][2] += x[1][2] * y[2][2];
>+    result[1][3] = 0;
>+    result[1][3] += x[1][0] * y[0][3];
>+    result[1][3] += x[1][1] * y[1][3];
>+    result[1][3] += x[1][2] * y[2][3];
>+    result[2][0] = 0;
>+    result[2][0] += x[2][0] * y[0][0];
>+    result[2][0] += x[2][1] * y[1][0];
>+    result[2][0] += x[2][2] * y[2][0];
>+    result[2][1] = 0;
>+    result[2][1] += x[2][0] * y[0][1];
>+    result[2][1] += x[2][1] * y[1][1];
>+    result[2][1] += x[2][2] * y[2][1];
>+    result[2][2] = 0;
>+    result[2][2] += x[2][0] * y[0][2];
>+    result[2][2] += x[2][1] * y[1][2];
>+    result[2][2] += x[2][2] * y[2][2];
>+    result[2][3] = 0;
>+    result[2][3] += x[2][0] * y[0][3];
>+    result[2][3] += x[2][1] * y[1][3];
>+    result[2][3] += x[2][2] * y[2][3];
>+    result[3][0] = 0;
>+    result[3][0] += x[3][0] * y[0][0];
>+    result[3][0] += x[3][1] * y[1][0];
>+    result[3][0] += x[3][2] * y[2][0];
>+    result[3][1] = 0;
>+    result[3][1] += x[3][0] * y[0][1];
>+    result[3][1] += x[3][1] * y[1][1];
>+    result[3][1] += x[3][2] * y[2][1];
>+    result[3][2] = 0;
>+    result[3][2] += x[3][0] * y[0][2];
>+    result[3][2] += x[3][1] * y[1][2];
>+    result[3][2] += x[3][2] * y[2][2];
>+    result[3][3] = 0;
>+    result[3][3] += x[3][0] * y[0][3];
>+    result[3][3] += x[3][1] * y[1][3];
>+    result[3][3] += x[3][2] * y[2][3];
>+    return result;
>+}
>+half4x2 mul(half4x4 x, half4x2 y) {
>+    half4x2 result;
>+    result[0][0] = 0;
>+    result[0][0] += x[0][0] * y[0][0];
>+    result[0][0] += x[0][1] * y[1][0];
>+    result[0][0] += x[0][2] * y[2][0];
>+    result[0][0] += x[0][3] * y[3][0];
>+    result[0][1] = 0;
>+    result[0][1] += x[0][0] * y[0][1];
>+    result[0][1] += x[0][1] * y[1][1];
>+    result[0][1] += x[0][2] * y[2][1];
>+    result[0][1] += x[0][3] * y[3][1];
>+    result[1][0] = 0;
>+    result[1][0] += x[1][0] * y[0][0];
>+    result[1][0] += x[1][1] * y[1][0];
>+    result[1][0] += x[1][2] * y[2][0];
>+    result[1][0] += x[1][3] * y[3][0];
>+    result[1][1] = 0;
>+    result[1][1] += x[1][0] * y[0][1];
>+    result[1][1] += x[1][1] * y[1][1];
>+    result[1][1] += x[1][2] * y[2][1];
>+    result[1][1] += x[1][3] * y[3][1];
>+    result[2][0] = 0;
>+    result[2][0] += x[2][0] * y[0][0];
>+    result[2][0] += x[2][1] * y[1][0];
>+    result[2][0] += x[2][2] * y[2][0];
>+    result[2][0] += x[2][3] * y[3][0];
>+    result[2][1] = 0;
>+    result[2][1] += x[2][0] * y[0][1];
>+    result[2][1] += x[2][1] * y[1][1];
>+    result[2][1] += x[2][2] * y[2][1];
>+    result[2][1] += x[2][3] * y[3][1];
>+    result[3][0] = 0;
>+    result[3][0] += x[3][0] * y[0][0];
>+    result[3][0] += x[3][1] * y[1][0];
>+    result[3][0] += x[3][2] * y[2][0];
>+    result[3][0] += x[3][3] * y[3][0];
>+    result[3][1] = 0;
>+    result[3][1] += x[3][0] * y[0][1];
>+    result[3][1] += x[3][1] * y[1][1];
>+    result[3][1] += x[3][2] * y[2][1];
>+    result[3][1] += x[3][3] * y[3][1];
>+    return result;
>+}
>+half4x3 mul(half4x4 x, half4x3 y) {
>+    half4x3 result;
>+    result[0][0] = 0;
>+    result[0][0] += x[0][0] * y[0][0];
>+    result[0][0] += x[0][1] * y[1][0];
>+    result[0][0] += x[0][2] * y[2][0];
>+    result[0][0] += x[0][3] * y[3][0];
>+    result[0][1] = 0;
>+    result[0][1] += x[0][0] * y[0][1];
>+    result[0][1] += x[0][1] * y[1][1];
>+    result[0][1] += x[0][2] * y[2][1];
>+    result[0][1] += x[0][3] * y[3][1];
>+    result[0][2] = 0;
>+    result[0][2] += x[0][0] * y[0][2];
>+    result[0][2] += x[0][1] * y[1][2];
>+    result[0][2] += x[0][2] * y[2][2];
>+    result[0][2] += x[0][3] * y[3][2];
>+    result[1][0] = 0;
>+    result[1][0] += x[1][0] * y[0][0];
>+    result[1][0] += x[1][1] * y[1][0];
>+    result[1][0] += x[1][2] * y[2][0];
>+    result[1][0] += x[1][3] * y[3][0];
>+    result[1][1] = 0;
>+    result[1][1] += x[1][0] * y[0][1];
>+    result[1][1] += x[1][1] * y[1][1];
>+    result[1][1] += x[1][2] * y[2][1];
>+    result[1][1] += x[1][3] * y[3][1];
>+    result[1][2] = 0;
>+    result[1][2] += x[1][0] * y[0][2];
>+    result[1][2] += x[1][1] * y[1][2];
>+    result[1][2] += x[1][2] * y[2][2];
>+    result[1][2] += x[1][3] * y[3][2];
>+    result[2][0] = 0;
>+    result[2][0] += x[2][0] * y[0][0];
>+    result[2][0] += x[2][1] * y[1][0];
>+    result[2][0] += x[2][2] * y[2][0];
>+    result[2][0] += x[2][3] * y[3][0];
>+    result[2][1] = 0;
>+    result[2][1] += x[2][0] * y[0][1];
>+    result[2][1] += x[2][1] * y[1][1];
>+    result[2][1] += x[2][2] * y[2][1];
>+    result[2][1] += x[2][3] * y[3][1];
>+    result[2][2] = 0;
>+    result[2][2] += x[2][0] * y[0][2];
>+    result[2][2] += x[2][1] * y[1][2];
>+    result[2][2] += x[2][2] * y[2][2];
>+    result[2][2] += x[2][3] * y[3][2];
>+    result[3][0] = 0;
>+    result[3][0] += x[3][0] * y[0][0];
>+    result[3][0] += x[3][1] * y[1][0];
>+    result[3][0] += x[3][2] * y[2][0];
>+    result[3][0] += x[3][3] * y[3][0];
>+    result[3][1] = 0;
>+    result[3][1] += x[3][0] * y[0][1];
>+    result[3][1] += x[3][1] * y[1][1];
>+    result[3][1] += x[3][2] * y[2][1];
>+    result[3][1] += x[3][3] * y[3][1];
>+    result[3][2] = 0;
>+    result[3][2] += x[3][0] * y[0][2];
>+    result[3][2] += x[3][1] * y[1][2];
>+    result[3][2] += x[3][2] * y[2][2];
>+    result[3][2] += x[3][3] * y[3][2];
>+    return result;
>+}
>+half4x4 mul(half4x4 x, half4x4 y) {
>+    half4x4 result;
>+    result[0][0] = 0;
>+    result[0][0] += x[0][0] * y[0][0];
>+    result[0][0] += x[0][1] * y[1][0];
>+    result[0][0] += x[0][2] * y[2][0];
>+    result[0][0] += x[0][3] * y[3][0];
>+    result[0][1] = 0;
>+    result[0][1] += x[0][0] * y[0][1];
>+    result[0][1] += x[0][1] * y[1][1];
>+    result[0][1] += x[0][2] * y[2][1];
>+    result[0][1] += x[0][3] * y[3][1];
>+    result[0][2] = 0;
>+    result[0][2] += x[0][0] * y[0][2];
>+    result[0][2] += x[0][1] * y[1][2];
>+    result[0][2] += x[0][2] * y[2][2];
>+    result[0][2] += x[0][3] * y[3][2];
>+    result[0][3] = 0;
>+    result[0][3] += x[0][0] * y[0][3];
>+    result[0][3] += x[0][1] * y[1][3];
>+    result[0][3] += x[0][2] * y[2][3];
>+    result[0][3] += x[0][3] * y[3][3];
>+    result[1][0] = 0;
>+    result[1][0] += x[1][0] * y[0][0];
>+    result[1][0] += x[1][1] * y[1][0];
>+    result[1][0] += x[1][2] * y[2][0];
>+    result[1][0] += x[1][3] * y[3][0];
>+    result[1][1] = 0;
>+    result[1][1] += x[1][0] * y[0][1];
>+    result[1][1] += x[1][1] * y[1][1];
>+    result[1][1] += x[1][2] * y[2][1];
>+    result[1][1] += x[1][3] * y[3][1];
>+    result[1][2] = 0;
>+    result[1][2] += x[1][0] * y[0][2];
>+    result[1][2] += x[1][1] * y[1][2];
>+    result[1][2] += x[1][2] * y[2][2];
>+    result[1][2] += x[1][3] * y[3][2];
>+    result[1][3] = 0;
>+    result[1][3] += x[1][0] * y[0][3];
>+    result[1][3] += x[1][1] * y[1][3];
>+    result[1][3] += x[1][2] * y[2][3];
>+    result[1][3] += x[1][3] * y[3][3];
>+    result[2][0] = 0;
>+    result[2][0] += x[2][0] * y[0][0];
>+    result[2][0] += x[2][1] * y[1][0];
>+    result[2][0] += x[2][2] * y[2][0];
>+    result[2][0] += x[2][3] * y[3][0];
>+    result[2][1] = 0;
>+    result[2][1] += x[2][0] * y[0][1];
>+    result[2][1] += x[2][1] * y[1][1];
>+    result[2][1] += x[2][2] * y[2][1];
>+    result[2][1] += x[2][3] * y[3][1];
>+    result[2][2] = 0;
>+    result[2][2] += x[2][0] * y[0][2];
>+    result[2][2] += x[2][1] * y[1][2];
>+    result[2][2] += x[2][2] * y[2][2];
>+    result[2][2] += x[2][3] * y[3][2];
>+    result[2][3] = 0;
>+    result[2][3] += x[2][0] * y[0][3];
>+    result[2][3] += x[2][1] * y[1][3];
>+    result[2][3] += x[2][2] * y[2][3];
>+    result[2][3] += x[2][3] * y[3][3];
>+    result[3][0] = 0;
>+    result[3][0] += x[3][0] * y[0][0];
>+    result[3][0] += x[3][1] * y[1][0];
>+    result[3][0] += x[3][2] * y[2][0];
>+    result[3][0] += x[3][3] * y[3][0];
>+    result[3][1] = 0;
>+    result[3][1] += x[3][0] * y[0][1];
>+    result[3][1] += x[3][1] * y[1][1];
>+    result[3][1] += x[3][2] * y[2][1];
>+    result[3][1] += x[3][3] * y[3][1];
>+    result[3][2] = 0;
>+    result[3][2] += x[3][0] * y[0][2];
>+    result[3][2] += x[3][1] * y[1][2];
>+    result[3][2] += x[3][2] * y[2][2];
>+    result[3][2] += x[3][3] * y[3][2];
>+    result[3][3] = 0;
>+    result[3][3] += x[3][0] * y[0][3];
>+    result[3][3] += x[3][1] * y[1][3];
>+    result[3][3] += x[3][2] * y[2][3];
>+    result[3][3] += x[3][3] * y[3][3];
>+    return result;
>+}
>+float2x2 mul(float2x2 x, float2x2 y) {
>+    float2x2 result;
>+    result[0][0] = 0;
>+    result[0][0] += x[0][0] * y[0][0];
>+    result[0][0] += x[0][1] * y[1][0];
>+    result[0][1] = 0;
>+    result[0][1] += x[0][0] * y[0][1];
>+    result[0][1] += x[0][1] * y[1][1];
>+    result[1][0] = 0;
>+    result[1][0] += x[1][0] * y[0][0];
>+    result[1][0] += x[1][1] * y[1][0];
>+    result[1][1] = 0;
>+    result[1][1] += x[1][0] * y[0][1];
>+    result[1][1] += x[1][1] * y[1][1];
>+    return result;
>+}
>+float2x3 mul(float2x2 x, float2x3 y) {
>+    float2x3 result;
>+    result[0][0] = 0;
>+    result[0][0] += x[0][0] * y[0][0];
>+    result[0][0] += x[0][1] * y[1][0];
>+    result[0][1] = 0;
>+    result[0][1] += x[0][0] * y[0][1];
>+    result[0][1] += x[0][1] * y[1][1];
>+    result[0][2] = 0;
>+    result[0][2] += x[0][0] * y[0][2];
>+    result[0][2] += x[0][1] * y[1][2];
>+    result[1][0] = 0;
>+    result[1][0] += x[1][0] * y[0][0];
>+    result[1][0] += x[1][1] * y[1][0];
>+    result[1][1] = 0;
>+    result[1][1] += x[1][0] * y[0][1];
>+    result[1][1] += x[1][1] * y[1][1];
>+    result[1][2] = 0;
>+    result[1][2] += x[1][0] * y[0][2];
>+    result[1][2] += x[1][1] * y[1][2];
>+    return result;
>+}
>+float2x4 mul(float2x2 x, float2x4 y) {
>+    float2x4 result;
>+    result[0][0] = 0;
>+    result[0][0] += x[0][0] * y[0][0];
>+    result[0][0] += x[0][1] * y[1][0];
>+    result[0][1] = 0;
>+    result[0][1] += x[0][0] * y[0][1];
>+    result[0][1] += x[0][1] * y[1][1];
>+    result[0][2] = 0;
>+    result[0][2] += x[0][0] * y[0][2];
>+    result[0][2] += x[0][1] * y[1][2];
>+    result[0][3] = 0;
>+    result[0][3] += x[0][0] * y[0][3];
>+    result[0][3] += x[0][1] * y[1][3];
>+    result[1][0] = 0;
>+    result[1][0] += x[1][0] * y[0][0];
>+    result[1][0] += x[1][1] * y[1][0];
>+    result[1][1] = 0;
>+    result[1][1] += x[1][0] * y[0][1];
>+    result[1][1] += x[1][1] * y[1][1];
>+    result[1][2] = 0;
>+    result[1][2] += x[1][0] * y[0][2];
>+    result[1][2] += x[1][1] * y[1][2];
>+    result[1][3] = 0;
>+    result[1][3] += x[1][0] * y[0][3];
>+    result[1][3] += x[1][1] * y[1][3];
>+    return result;
>+}
>+float2x2 mul(float2x3 x, float3x2 y) {
>+    float2x2 result;
>+    result[0][0] = 0;
>+    result[0][0] += x[0][0] * y[0][0];
>+    result[0][0] += x[0][1] * y[1][0];
>+    result[0][0] += x[0][2] * y[2][0];
>+    result[0][1] = 0;
>+    result[0][1] += x[0][0] * y[0][1];
>+    result[0][1] += x[0][1] * y[1][1];
>+    result[0][1] += x[0][2] * y[2][1];
>+    result[1][0] = 0;
>+    result[1][0] += x[1][0] * y[0][0];
>+    result[1][0] += x[1][1] * y[1][0];
>+    result[1][0] += x[1][2] * y[2][0];
>+    result[1][1] = 0;
>+    result[1][1] += x[1][0] * y[0][1];
>+    result[1][1] += x[1][1] * y[1][1];
>+    result[1][1] += x[1][2] * y[2][1];
>+    return result;
>+}
>+float2x3 mul(float2x3 x, float3x3 y) {
>+    float2x3 result;
>+    result[0][0] = 0;
>+    result[0][0] += x[0][0] * y[0][0];
>+    result[0][0] += x[0][1] * y[1][0];
>+    result[0][0] += x[0][2] * y[2][0];
>+    result[0][1] = 0;
>+    result[0][1] += x[0][0] * y[0][1];
>+    result[0][1] += x[0][1] * y[1][1];
>+    result[0][1] += x[0][2] * y[2][1];
>+    result[0][2] = 0;
>+    result[0][2] += x[0][0] * y[0][2];
>+    result[0][2] += x[0][1] * y[1][2];
>+    result[0][2] += x[0][2] * y[2][2];
>+    result[1][0] = 0;
>+    result[1][0] += x[1][0] * y[0][0];
>+    result[1][0] += x[1][1] * y[1][0];
>+    result[1][0] += x[1][2] * y[2][0];
>+    result[1][1] = 0;
>+    result[1][1] += x[1][0] * y[0][1];
>+    result[1][1] += x[1][1] * y[1][1];
>+    result[1][1] += x[1][2] * y[2][1];
>+    result[1][2] = 0;
>+    result[1][2] += x[1][0] * y[0][2];
>+    result[1][2] += x[1][1] * y[1][2];
>+    result[1][2] += x[1][2] * y[2][2];
>+    return result;
>+}
>+float2x4 mul(float2x3 x, float3x4 y) {
>+    float2x4 result;
>+    result[0][0] = 0;
>+    result[0][0] += x[0][0] * y[0][0];
>+    result[0][0] += x[0][1] * y[1][0];
>+    result[0][0] += x[0][2] * y[2][0];
>+    result[0][1] = 0;
>+    result[0][1] += x[0][0] * y[0][1];
>+    result[0][1] += x[0][1] * y[1][1];
>+    result[0][1] += x[0][2] * y[2][1];
>+    result[0][2] = 0;
>+    result[0][2] += x[0][0] * y[0][2];
>+    result[0][2] += x[0][1] * y[1][2];
>+    result[0][2] += x[0][2] * y[2][2];
>+    result[0][3] = 0;
>+    result[0][3] += x[0][0] * y[0][3];
>+    result[0][3] += x[0][1] * y[1][3];
>+    result[0][3] += x[0][2] * y[2][3];
>+    result[1][0] = 0;
>+    result[1][0] += x[1][0] * y[0][0];
>+    result[1][0] += x[1][1] * y[1][0];
>+    result[1][0] += x[1][2] * y[2][0];
>+    result[1][1] = 0;
>+    result[1][1] += x[1][0] * y[0][1];
>+    result[1][1] += x[1][1] * y[1][1];
>+    result[1][1] += x[1][2] * y[2][1];
>+    result[1][2] = 0;
>+    result[1][2] += x[1][0] * y[0][2];
>+    result[1][2] += x[1][1] * y[1][2];
>+    result[1][2] += x[1][2] * y[2][2];
>+    result[1][3] = 0;
>+    result[1][3] += x[1][0] * y[0][3];
>+    result[1][3] += x[1][1] * y[1][3];
>+    result[1][3] += x[1][2] * y[2][3];
>+    return result;
>+}
>+float2x2 mul(float2x4 x, float4x2 y) {
>+    float2x2 result;
>+    result[0][0] = 0;
>+    result[0][0] += x[0][0] * y[0][0];
>+    result[0][0] += x[0][1] * y[1][0];
>+    result[0][0] += x[0][2] * y[2][0];
>+    result[0][0] += x[0][3] * y[3][0];
>+    result[0][1] = 0;
>+    result[0][1] += x[0][0] * y[0][1];
>+    result[0][1] += x[0][1] * y[1][1];
>+    result[0][1] += x[0][2] * y[2][1];
>+    result[0][1] += x[0][3] * y[3][1];
>+    result[1][0] = 0;
>+    result[1][0] += x[1][0] * y[0][0];
>+    result[1][0] += x[1][1] * y[1][0];
>+    result[1][0] += x[1][2] * y[2][0];
>+    result[1][0] += x[1][3] * y[3][0];
>+    result[1][1] = 0;
>+    result[1][1] += x[1][0] * y[0][1];
>+    result[1][1] += x[1][1] * y[1][1];
>+    result[1][1] += x[1][2] * y[2][1];
>+    result[1][1] += x[1][3] * y[3][1];
>+    return result;
>+}
>+float2x3 mul(float2x4 x, float4x3 y) {
>+    float2x3 result;
>+    result[0][0] = 0;
>+    result[0][0] += x[0][0] * y[0][0];
>+    result[0][0] += x[0][1] * y[1][0];
>+    result[0][0] += x[0][2] * y[2][0];
>+    result[0][0] += x[0][3] * y[3][0];
>+    result[0][1] = 0;
>+    result[0][1] += x[0][0] * y[0][1];
>+    result[0][1] += x[0][1] * y[1][1];
>+    result[0][1] += x[0][2] * y[2][1];
>+    result[0][1] += x[0][3] * y[3][1];
>+    result[0][2] = 0;
>+    result[0][2] += x[0][0] * y[0][2];
>+    result[0][2] += x[0][1] * y[1][2];
>+    result[0][2] += x[0][2] * y[2][2];
>+    result[0][2] += x[0][3] * y[3][2];
>+    result[1][0] = 0;
>+    result[1][0] += x[1][0] * y[0][0];
>+    result[1][0] += x[1][1] * y[1][0];
>+    result[1][0] += x[1][2] * y[2][0];
>+    result[1][0] += x[1][3] * y[3][0];
>+    result[1][1] = 0;
>+    result[1][1] += x[1][0] * y[0][1];
>+    result[1][1] += x[1][1] * y[1][1];
>+    result[1][1] += x[1][2] * y[2][1];
>+    result[1][1] += x[1][3] * y[3][1];
>+    result[1][2] = 0;
>+    result[1][2] += x[1][0] * y[0][2];
>+    result[1][2] += x[1][1] * y[1][2];
>+    result[1][2] += x[1][2] * y[2][2];
>+    result[1][2] += x[1][3] * y[3][2];
>+    return result;
>+}
>+float2x4 mul(float2x4 x, float4x4 y) {
>+    float2x4 result;
>+    result[0][0] = 0;
>+    result[0][0] += x[0][0] * y[0][0];
>+    result[0][0] += x[0][1] * y[1][0];
>+    result[0][0] += x[0][2] * y[2][0];
>+    result[0][0] += x[0][3] * y[3][0];
>+    result[0][1] = 0;
>+    result[0][1] += x[0][0] * y[0][1];
>+    result[0][1] += x[0][1] * y[1][1];
>+    result[0][1] += x[0][2] * y[2][1];
>+    result[0][1] += x[0][3] * y[3][1];
>+    result[0][2] = 0;
>+    result[0][2] += x[0][0] * y[0][2];
>+    result[0][2] += x[0][1] * y[1][2];
>+    result[0][2] += x[0][2] * y[2][2];
>+    result[0][2] += x[0][3] * y[3][2];
>+    result[0][3] = 0;
>+    result[0][3] += x[0][0] * y[0][3];
>+    result[0][3] += x[0][1] * y[1][3];
>+    result[0][3] += x[0][2] * y[2][3];
>+    result[0][3] += x[0][3] * y[3][3];
>+    result[1][0] = 0;
>+    result[1][0] += x[1][0] * y[0][0];
>+    result[1][0] += x[1][1] * y[1][0];
>+    result[1][0] += x[1][2] * y[2][0];
>+    result[1][0] += x[1][3] * y[3][0];
>+    result[1][1] = 0;
>+    result[1][1] += x[1][0] * y[0][1];
>+    result[1][1] += x[1][1] * y[1][1];
>+    result[1][1] += x[1][2] * y[2][1];
>+    result[1][1] += x[1][3] * y[3][1];
>+    result[1][2] = 0;
>+    result[1][2] += x[1][0] * y[0][2];
>+    result[1][2] += x[1][1] * y[1][2];
>+    result[1][2] += x[1][2] * y[2][2];
>+    result[1][2] += x[1][3] * y[3][2];
>+    result[1][3] = 0;
>+    result[1][3] += x[1][0] * y[0][3];
>+    result[1][3] += x[1][1] * y[1][3];
>+    result[1][3] += x[1][2] * y[2][3];
>+    result[1][3] += x[1][3] * y[3][3];
>+    return result;
>+}
>+float3x2 mul(float3x2 x, float2x2 y) {
>+    float3x2 result;
>+    result[0][0] = 0;
>+    result[0][0] += x[0][0] * y[0][0];
>+    result[0][0] += x[0][1] * y[1][0];
>+    result[0][1] = 0;
>+    result[0][1] += x[0][0] * y[0][1];
>+    result[0][1] += x[0][1] * y[1][1];
>+    result[1][0] = 0;
>+    result[1][0] += x[1][0] * y[0][0];
>+    result[1][0] += x[1][1] * y[1][0];
>+    result[1][1] = 0;
>+    result[1][1] += x[1][0] * y[0][1];
>+    result[1][1] += x[1][1] * y[1][1];
>+    result[2][0] = 0;
>+    result[2][0] += x[2][0] * y[0][0];
>+    result[2][0] += x[2][1] * y[1][0];
>+    result[2][1] = 0;
>+    result[2][1] += x[2][0] * y[0][1];
>+    result[2][1] += x[2][1] * y[1][1];
>+    return result;
>+}
>+float3x3 mul(float3x2 x, float2x3 y) {
>+    float3x3 result;
>+    result[0][0] = 0;
>+    result[0][0] += x[0][0] * y[0][0];
>+    result[0][0] += x[0][1] * y[1][0];
>+    result[0][1] = 0;
>+    result[0][1] += x[0][0] * y[0][1];
>+    result[0][1] += x[0][1] * y[1][1];
>+    result[0][2] = 0;
>+    result[0][2] += x[0][0] * y[0][2];
>+    result[0][2] += x[0][1] * y[1][2];
>+    result[1][0] = 0;
>+    result[1][0] += x[1][0] * y[0][0];
>+    result[1][0] += x[1][1] * y[1][0];
>+    result[1][1] = 0;
>+    result[1][1] += x[1][0] * y[0][1];
>+    result[1][1] += x[1][1] * y[1][1];
>+    result[1][2] = 0;
>+    result[1][2] += x[1][0] * y[0][2];
>+    result[1][2] += x[1][1] * y[1][2];
>+    result[2][0] = 0;
>+    result[2][0] += x[2][0] * y[0][0];
>+    result[2][0] += x[2][1] * y[1][0];
>+    result[2][1] = 0;
>+    result[2][1] += x[2][0] * y[0][1];
>+    result[2][1] += x[2][1] * y[1][1];
>+    result[2][2] = 0;
>+    result[2][2] += x[2][0] * y[0][2];
>+    result[2][2] += x[2][1] * y[1][2];
>+    return result;
>+}
>+float3x4 mul(float3x2 x, float2x4 y) {
>+    float3x4 result;
>+    result[0][0] = 0;
>+    result[0][0] += x[0][0] * y[0][0];
>+    result[0][0] += x[0][1] * y[1][0];
>+    result[0][1] = 0;
>+    result[0][1] += x[0][0] * y[0][1];
>+    result[0][1] += x[0][1] * y[1][1];
>+    result[0][2] = 0;
>+    result[0][2] += x[0][0] * y[0][2];
>+    result[0][2] += x[0][1] * y[1][2];
>+    result[0][3] = 0;
>+    result[0][3] += x[0][0] * y[0][3];
>+    result[0][3] += x[0][1] * y[1][3];
>+    result[1][0] = 0;
>+    result[1][0] += x[1][0] * y[0][0];
>+    result[1][0] += x[1][1] * y[1][0];
>+    result[1][1] = 0;
>+    result[1][1] += x[1][0] * y[0][1];
>+    result[1][1] += x[1][1] * y[1][1];
>+    result[1][2] = 0;
>+    result[1][2] += x[1][0] * y[0][2];
>+    result[1][2] += x[1][1] * y[1][2];
>+    result[1][3] = 0;
>+    result[1][3] += x[1][0] * y[0][3];
>+    result[1][3] += x[1][1] * y[1][3];
>+    result[2][0] = 0;
>+    result[2][0] += x[2][0] * y[0][0];
>+    result[2][0] += x[2][1] * y[1][0];
>+    result[2][1] = 0;
>+    result[2][1] += x[2][0] * y[0][1];
>+    result[2][1] += x[2][1] * y[1][1];
>+    result[2][2] = 0;
>+    result[2][2] += x[2][0] * y[0][2];
>+    result[2][2] += x[2][1] * y[1][2];
>+    result[2][3] = 0;
>+    result[2][3] += x[2][0] * y[0][3];
>+    result[2][3] += x[2][1] * y[1][3];
>+    return result;
>+}
>+float3x2 mul(float3x3 x, float3x2 y) {
>+    float3x2 result;
>+    result[0][0] = 0;
>+    result[0][0] += x[0][0] * y[0][0];
>+    result[0][0] += x[0][1] * y[1][0];
>+    result[0][0] += x[0][2] * y[2][0];
>+    result[0][1] = 0;
>+    result[0][1] += x[0][0] * y[0][1];
>+    result[0][1] += x[0][1] * y[1][1];
>+    result[0][1] += x[0][2] * y[2][1];
>+    result[1][0] = 0;
>+    result[1][0] += x[1][0] * y[0][0];
>+    result[1][0] += x[1][1] * y[1][0];
>+    result[1][0] += x[1][2] * y[2][0];
>+    result[1][1] = 0;
>+    result[1][1] += x[1][0] * y[0][1];
>+    result[1][1] += x[1][1] * y[1][1];
>+    result[1][1] += x[1][2] * y[2][1];
>+    result[2][0] = 0;
>+    result[2][0] += x[2][0] * y[0][0];
>+    result[2][0] += x[2][1] * y[1][0];
>+    result[2][0] += x[2][2] * y[2][0];
>+    result[2][1] = 0;
>+    result[2][1] += x[2][0] * y[0][1];
>+    result[2][1] += x[2][1] * y[1][1];
>+    result[2][1] += x[2][2] * y[2][1];
>+    return result;
>+}
>+float3x3 mul(float3x3 x, float3x3 y) {
>+    float3x3 result;
>+    result[0][0] = 0;
>+    result[0][0] += x[0][0] * y[0][0];
>+    result[0][0] += x[0][1] * y[1][0];
>+    result[0][0] += x[0][2] * y[2][0];
>+    result[0][1] = 0;
>+    result[0][1] += x[0][0] * y[0][1];
>+    result[0][1] += x[0][1] * y[1][1];
>+    result[0][1] += x[0][2] * y[2][1];
>+    result[0][2] = 0;
>+    result[0][2] += x[0][0] * y[0][2];
>+    result[0][2] += x[0][1] * y[1][2];
>+    result[0][2] += x[0][2] * y[2][2];
>+    result[1][0] = 0;
>+    result[1][0] += x[1][0] * y[0][0];
>+    result[1][0] += x[1][1] * y[1][0];
>+    result[1][0] += x[1][2] * y[2][0];
>+    result[1][1] = 0;
>+    result[1][1] += x[1][0] * y[0][1];
>+    result[1][1] += x[1][1] * y[1][1];
>+    result[1][1] += x[1][2] * y[2][1];
>+    result[1][2] = 0;
>+    result[1][2] += x[1][0] * y[0][2];
>+    result[1][2] += x[1][1] * y[1][2];
>+    result[1][2] += x[1][2] * y[2][2];
>+    result[2][0] = 0;
>+    result[2][0] += x[2][0] * y[0][0];
>+    result[2][0] += x[2][1] * y[1][0];
>+    result[2][0] += x[2][2] * y[2][0];
>+    result[2][1] = 0;
>+    result[2][1] += x[2][0] * y[0][1];
>+    result[2][1] += x[2][1] * y[1][1];
>+    result[2][1] += x[2][2] * y[2][1];
>+    result[2][2] = 0;
>+    result[2][2] += x[2][0] * y[0][2];
>+    result[2][2] += x[2][1] * y[1][2];
>+    result[2][2] += x[2][2] * y[2][2];
>+    return result;
>+}
>+float3x4 mul(float3x3 x, float3x4 y) {
>+    float3x4 result;
>+    result[0][0] = 0;
>+    result[0][0] += x[0][0] * y[0][0];
>+    result[0][0] += x[0][1] * y[1][0];
>+    result[0][0] += x[0][2] * y[2][0];
>+    result[0][1] = 0;
>+    result[0][1] += x[0][0] * y[0][1];
>+    result[0][1] += x[0][1] * y[1][1];
>+    result[0][1] += x[0][2] * y[2][1];
>+    result[0][2] = 0;
>+    result[0][2] += x[0][0] * y[0][2];
>+    result[0][2] += x[0][1] * y[1][2];
>+    result[0][2] += x[0][2] * y[2][2];
>+    result[0][3] = 0;
>+    result[0][3] += x[0][0] * y[0][3];
>+    result[0][3] += x[0][1] * y[1][3];
>+    result[0][3] += x[0][2] * y[2][3];
>+    result[1][0] = 0;
>+    result[1][0] += x[1][0] * y[0][0];
>+    result[1][0] += x[1][1] * y[1][0];
>+    result[1][0] += x[1][2] * y[2][0];
>+    result[1][1] = 0;
>+    result[1][1] += x[1][0] * y[0][1];
>+    result[1][1] += x[1][1] * y[1][1];
>+    result[1][1] += x[1][2] * y[2][1];
>+    result[1][2] = 0;
>+    result[1][2] += x[1][0] * y[0][2];
>+    result[1][2] += x[1][1] * y[1][2];
>+    result[1][2] += x[1][2] * y[2][2];
>+    result[1][3] = 0;
>+    result[1][3] += x[1][0] * y[0][3];
>+    result[1][3] += x[1][1] * y[1][3];
>+    result[1][3] += x[1][2] * y[2][3];
>+    result[2][0] = 0;
>+    result[2][0] += x[2][0] * y[0][0];
>+    result[2][0] += x[2][1] * y[1][0];
>+    result[2][0] += x[2][2] * y[2][0];
>+    result[2][1] = 0;
>+    result[2][1] += x[2][0] * y[0][1];
>+    result[2][1] += x[2][1] * y[1][1];
>+    result[2][1] += x[2][2] * y[2][1];
>+    result[2][2] = 0;
>+    result[2][2] += x[2][0] * y[0][2];
>+    result[2][2] += x[2][1] * y[1][2];
>+    result[2][2] += x[2][2] * y[2][2];
>+    result[2][3] = 0;
>+    result[2][3] += x[2][0] * y[0][3];
>+    result[2][3] += x[2][1] * y[1][3];
>+    result[2][3] += x[2][2] * y[2][3];
>+    return result;
>+}
>+float3x2 mul(float3x4 x, float4x2 y) {
>+    float3x2 result;
>+    result[0][0] = 0;
>+    result[0][0] += x[0][0] * y[0][0];
>+    result[0][0] += x[0][1] * y[1][0];
>+    result[0][0] += x[0][2] * y[2][0];
>+    result[0][0] += x[0][3] * y[3][0];
>+    result[0][1] = 0;
>+    result[0][1] += x[0][0] * y[0][1];
>+    result[0][1] += x[0][1] * y[1][1];
>+    result[0][1] += x[0][2] * y[2][1];
>+    result[0][1] += x[0][3] * y[3][1];
>+    result[1][0] = 0;
>+    result[1][0] += x[1][0] * y[0][0];
>+    result[1][0] += x[1][1] * y[1][0];
>+    result[1][0] += x[1][2] * y[2][0];
>+    result[1][0] += x[1][3] * y[3][0];
>+    result[1][1] = 0;
>+    result[1][1] += x[1][0] * y[0][1];
>+    result[1][1] += x[1][1] * y[1][1];
>+    result[1][1] += x[1][2] * y[2][1];
>+    result[1][1] += x[1][3] * y[3][1];
>+    result[2][0] = 0;
>+    result[2][0] += x[2][0] * y[0][0];
>+    result[2][0] += x[2][1] * y[1][0];
>+    result[2][0] += x[2][2] * y[2][0];
>+    result[2][0] += x[2][3] * y[3][0];
>+    result[2][1] = 0;
>+    result[2][1] += x[2][0] * y[0][1];
>+    result[2][1] += x[2][1] * y[1][1];
>+    result[2][1] += x[2][2] * y[2][1];
>+    result[2][1] += x[2][3] * y[3][1];
>+    return result;
>+}
>+float3x3 mul(float3x4 x, float4x3 y) {
>+    float3x3 result;
>+    result[0][0] = 0;
>+    result[0][0] += x[0][0] * y[0][0];
>+    result[0][0] += x[0][1] * y[1][0];
>+    result[0][0] += x[0][2] * y[2][0];
>+    result[0][0] += x[0][3] * y[3][0];
>+    result[0][1] = 0;
>+    result[0][1] += x[0][0] * y[0][1];
>+    result[0][1] += x[0][1] * y[1][1];
>+    result[0][1] += x[0][2] * y[2][1];
>+    result[0][1] += x[0][3] * y[3][1];
>+    result[0][2] = 0;
>+    result[0][2] += x[0][0] * y[0][2];
>+    result[0][2] += x[0][1] * y[1][2];
>+    result[0][2] += x[0][2] * y[2][2];
>+    result[0][2] += x[0][3] * y[3][2];
>+    result[1][0] = 0;
>+    result[1][0] += x[1][0] * y[0][0];
>+    result[1][0] += x[1][1] * y[1][0];
>+    result[1][0] += x[1][2] * y[2][0];
>+    result[1][0] += x[1][3] * y[3][0];
>+    result[1][1] = 0;
>+    result[1][1] += x[1][0] * y[0][1];
>+    result[1][1] += x[1][1] * y[1][1];
>+    result[1][1] += x[1][2] * y[2][1];
>+    result[1][1] += x[1][3] * y[3][1];
>+    result[1][2] = 0;
>+    result[1][2] += x[1][0] * y[0][2];
>+    result[1][2] += x[1][1] * y[1][2];
>+    result[1][2] += x[1][2] * y[2][2];
>+    result[1][2] += x[1][3] * y[3][2];
>+    result[2][0] = 0;
>+    result[2][0] += x[2][0] * y[0][0];
>+    result[2][0] += x[2][1] * y[1][0];
>+    result[2][0] += x[2][2] * y[2][0];
>+    result[2][0] += x[2][3] * y[3][0];
>+    result[2][1] = 0;
>+    result[2][1] += x[2][0] * y[0][1];
>+    result[2][1] += x[2][1] * y[1][1];
>+    result[2][1] += x[2][2] * y[2][1];
>+    result[2][1] += x[2][3] * y[3][1];
>+    result[2][2] = 0;
>+    result[2][2] += x[2][0] * y[0][2];
>+    result[2][2] += x[2][1] * y[1][2];
>+    result[2][2] += x[2][2] * y[2][2];
>+    result[2][2] += x[2][3] * y[3][2];
>+    return result;
>+}
>+float3x4 mul(float3x4 x, float4x4 y) {
>+    float3x4 result;
>+    result[0][0] = 0;
>+    result[0][0] += x[0][0] * y[0][0];
>+    result[0][0] += x[0][1] * y[1][0];
>+    result[0][0] += x[0][2] * y[2][0];
>+    result[0][0] += x[0][3] * y[3][0];
>+    result[0][1] = 0;
>+    result[0][1] += x[0][0] * y[0][1];
>+    result[0][1] += x[0][1] * y[1][1];
>+    result[0][1] += x[0][2] * y[2][1];
>+    result[0][1] += x[0][3] * y[3][1];
>+    result[0][2] = 0;
>+    result[0][2] += x[0][0] * y[0][2];
>+    result[0][2] += x[0][1] * y[1][2];
>+    result[0][2] += x[0][2] * y[2][2];
>+    result[0][2] += x[0][3] * y[3][2];
>+    result[0][3] = 0;
>+    result[0][3] += x[0][0] * y[0][3];
>+    result[0][3] += x[0][1] * y[1][3];
>+    result[0][3] += x[0][2] * y[2][3];
>+    result[0][3] += x[0][3] * y[3][3];
>+    result[1][0] = 0;
>+    result[1][0] += x[1][0] * y[0][0];
>+    result[1][0] += x[1][1] * y[1][0];
>+    result[1][0] += x[1][2] * y[2][0];
>+    result[1][0] += x[1][3] * y[3][0];
>+    result[1][1] = 0;
>+    result[1][1] += x[1][0] * y[0][1];
>+    result[1][1] += x[1][1] * y[1][1];
>+    result[1][1] += x[1][2] * y[2][1];
>+    result[1][1] += x[1][3] * y[3][1];
>+    result[1][2] = 0;
>+    result[1][2] += x[1][0] * y[0][2];
>+    result[1][2] += x[1][1] * y[1][2];
>+    result[1][2] += x[1][2] * y[2][2];
>+    result[1][2] += x[1][3] * y[3][2];
>+    result[1][3] = 0;
>+    result[1][3] += x[1][0] * y[0][3];
>+    result[1][3] += x[1][1] * y[1][3];
>+    result[1][3] += x[1][2] * y[2][3];
>+    result[1][3] += x[1][3] * y[3][3];
>+    result[2][0] = 0;
>+    result[2][0] += x[2][0] * y[0][0];
>+    result[2][0] += x[2][1] * y[1][0];
>+    result[2][0] += x[2][2] * y[2][0];
>+    result[2][0] += x[2][3] * y[3][0];
>+    result[2][1] = 0;
>+    result[2][1] += x[2][0] * y[0][1];
>+    result[2][1] += x[2][1] * y[1][1];
>+    result[2][1] += x[2][2] * y[2][1];
>+    result[2][1] += x[2][3] * y[3][1];
>+    result[2][2] = 0;
>+    result[2][2] += x[2][0] * y[0][2];
>+    result[2][2] += x[2][1] * y[1][2];
>+    result[2][2] += x[2][2] * y[2][2];
>+    result[2][2] += x[2][3] * y[3][2];
>+    result[2][3] = 0;
>+    result[2][3] += x[2][0] * y[0][3];
>+    result[2][3] += x[2][1] * y[1][3];
>+    result[2][3] += x[2][2] * y[2][3];
>+    result[2][3] += x[2][3] * y[3][3];
>+    return result;
>+}
>+float4x2 mul(float4x2 x, float2x2 y) {
>+    float4x2 result;
>+    result[0][0] = 0;
>+    result[0][0] += x[0][0] * y[0][0];
>+    result[0][0] += x[0][1] * y[1][0];
>+    result[0][1] = 0;
>+    result[0][1] += x[0][0] * y[0][1];
>+    result[0][1] += x[0][1] * y[1][1];
>+    result[1][0] = 0;
>+    result[1][0] += x[1][0] * y[0][0];
>+    result[1][0] += x[1][1] * y[1][0];
>+    result[1][1] = 0;
>+    result[1][1] += x[1][0] * y[0][1];
>+    result[1][1] += x[1][1] * y[1][1];
>+    result[2][0] = 0;
>+    result[2][0] += x[2][0] * y[0][0];
>+    result[2][0] += x[2][1] * y[1][0];
>+    result[2][1] = 0;
>+    result[2][1] += x[2][0] * y[0][1];
>+    result[2][1] += x[2][1] * y[1][1];
>+    result[3][0] = 0;
>+    result[3][0] += x[3][0] * y[0][0];
>+    result[3][0] += x[3][1] * y[1][0];
>+    result[3][1] = 0;
>+    result[3][1] += x[3][0] * y[0][1];
>+    result[3][1] += x[3][1] * y[1][1];
>+    return result;
>+}
>+float4x3 mul(float4x2 x, float2x3 y) {
>+    float4x3 result;
>+    result[0][0] = 0;
>+    result[0][0] += x[0][0] * y[0][0];
>+    result[0][0] += x[0][1] * y[1][0];
>+    result[0][1] = 0;
>+    result[0][1] += x[0][0] * y[0][1];
>+    result[0][1] += x[0][1] * y[1][1];
>+    result[0][2] = 0;
>+    result[0][2] += x[0][0] * y[0][2];
>+    result[0][2] += x[0][1] * y[1][2];
>+    result[1][0] = 0;
>+    result[1][0] += x[1][0] * y[0][0];
>+    result[1][0] += x[1][1] * y[1][0];
>+    result[1][1] = 0;
>+    result[1][1] += x[1][0] * y[0][1];
>+    result[1][1] += x[1][1] * y[1][1];
>+    result[1][2] = 0;
>+    result[1][2] += x[1][0] * y[0][2];
>+    result[1][2] += x[1][1] * y[1][2];
>+    result[2][0] = 0;
>+    result[2][0] += x[2][0] * y[0][0];
>+    result[2][0] += x[2][1] * y[1][0];
>+    result[2][1] = 0;
>+    result[2][1] += x[2][0] * y[0][1];
>+    result[2][1] += x[2][1] * y[1][1];
>+    result[2][2] = 0;
>+    result[2][2] += x[2][0] * y[0][2];
>+    result[2][2] += x[2][1] * y[1][2];
>+    result[3][0] = 0;
>+    result[3][0] += x[3][0] * y[0][0];
>+    result[3][0] += x[3][1] * y[1][0];
>+    result[3][1] = 0;
>+    result[3][1] += x[3][0] * y[0][1];
>+    result[3][1] += x[3][1] * y[1][1];
>+    result[3][2] = 0;
>+    result[3][2] += x[3][0] * y[0][2];
>+    result[3][2] += x[3][1] * y[1][2];
>+    return result;
>+}
>+float4x4 mul(float4x2 x, float2x4 y) {
>+    float4x4 result;
>+    result[0][0] = 0;
>+    result[0][0] += x[0][0] * y[0][0];
>+    result[0][0] += x[0][1] * y[1][0];
>+    result[0][1] = 0;
>+    result[0][1] += x[0][0] * y[0][1];
>+    result[0][1] += x[0][1] * y[1][1];
>+    result[0][2] = 0;
>+    result[0][2] += x[0][0] * y[0][2];
>+    result[0][2] += x[0][1] * y[1][2];
>+    result[0][3] = 0;
>+    result[0][3] += x[0][0] * y[0][3];
>+    result[0][3] += x[0][1] * y[1][3];
>+    result[1][0] = 0;
>+    result[1][0] += x[1][0] * y[0][0];
>+    result[1][0] += x[1][1] * y[1][0];
>+    result[1][1] = 0;
>+    result[1][1] += x[1][0] * y[0][1];
>+    result[1][1] += x[1][1] * y[1][1];
>+    result[1][2] = 0;
>+    result[1][2] += x[1][0] * y[0][2];
>+    result[1][2] += x[1][1] * y[1][2];
>+    result[1][3] = 0;
>+    result[1][3] += x[1][0] * y[0][3];
>+    result[1][3] += x[1][1] * y[1][3];
>+    result[2][0] = 0;
>+    result[2][0] += x[2][0] * y[0][0];
>+    result[2][0] += x[2][1] * y[1][0];
>+    result[2][1] = 0;
>+    result[2][1] += x[2][0] * y[0][1];
>+    result[2][1] += x[2][1] * y[1][1];
>+    result[2][2] = 0;
>+    result[2][2] += x[2][0] * y[0][2];
>+    result[2][2] += x[2][1] * y[1][2];
>+    result[2][3] = 0;
>+    result[2][3] += x[2][0] * y[0][3];
>+    result[2][3] += x[2][1] * y[1][3];
>+    result[3][0] = 0;
>+    result[3][0] += x[3][0] * y[0][0];
>+    result[3][0] += x[3][1] * y[1][0];
>+    result[3][1] = 0;
>+    result[3][1] += x[3][0] * y[0][1];
>+    result[3][1] += x[3][1] * y[1][1];
>+    result[3][2] = 0;
>+    result[3][2] += x[3][0] * y[0][2];
>+    result[3][2] += x[3][1] * y[1][2];
>+    result[3][3] = 0;
>+    result[3][3] += x[3][0] * y[0][3];
>+    result[3][3] += x[3][1] * y[1][3];
>+    return result;
>+}
>+float4x2 mul(float4x3 x, float3x2 y) {
>+    float4x2 result;
>+    result[0][0] = 0;
>+    result[0][0] += x[0][0] * y[0][0];
>+    result[0][0] += x[0][1] * y[1][0];
>+    result[0][0] += x[0][2] * y[2][0];
>+    result[0][1] = 0;
>+    result[0][1] += x[0][0] * y[0][1];
>+    result[0][1] += x[0][1] * y[1][1];
>+    result[0][1] += x[0][2] * y[2][1];
>+    result[1][0] = 0;
>+    result[1][0] += x[1][0] * y[0][0];
>+    result[1][0] += x[1][1] * y[1][0];
>+    result[1][0] += x[1][2] * y[2][0];
>+    result[1][1] = 0;
>+    result[1][1] += x[1][0] * y[0][1];
>+    result[1][1] += x[1][1] * y[1][1];
>+    result[1][1] += x[1][2] * y[2][1];
>+    result[2][0] = 0;
>+    result[2][0] += x[2][0] * y[0][0];
>+    result[2][0] += x[2][1] * y[1][0];
>+    result[2][0] += x[2][2] * y[2][0];
>+    result[2][1] = 0;
>+    result[2][1] += x[2][0] * y[0][1];
>+    result[2][1] += x[2][1] * y[1][1];
>+    result[2][1] += x[2][2] * y[2][1];
>+    result[3][0] = 0;
>+    result[3][0] += x[3][0] * y[0][0];
>+    result[3][0] += x[3][1] * y[1][0];
>+    result[3][0] += x[3][2] * y[2][0];
>+    result[3][1] = 0;
>+    result[3][1] += x[3][0] * y[0][1];
>+    result[3][1] += x[3][1] * y[1][1];
>+    result[3][1] += x[3][2] * y[2][1];
>+    return result;
>+}
>+float4x3 mul(float4x3 x, float3x3 y) {
>+    float4x3 result;
>+    result[0][0] = 0;
>+    result[0][0] += x[0][0] * y[0][0];
>+    result[0][0] += x[0][1] * y[1][0];
>+    result[0][0] += x[0][2] * y[2][0];
>+    result[0][1] = 0;
>+    result[0][1] += x[0][0] * y[0][1];
>+    result[0][1] += x[0][1] * y[1][1];
>+    result[0][1] += x[0][2] * y[2][1];
>+    result[0][2] = 0;
>+    result[0][2] += x[0][0] * y[0][2];
>+    result[0][2] += x[0][1] * y[1][2];
>+    result[0][2] += x[0][2] * y[2][2];
>+    result[1][0] = 0;
>+    result[1][0] += x[1][0] * y[0][0];
>+    result[1][0] += x[1][1] * y[1][0];
>+    result[1][0] += x[1][2] * y[2][0];
>+    result[1][1] = 0;
>+    result[1][1] += x[1][0] * y[0][1];
>+    result[1][1] += x[1][1] * y[1][1];
>+    result[1][1] += x[1][2] * y[2][1];
>+    result[1][2] = 0;
>+    result[1][2] += x[1][0] * y[0][2];
>+    result[1][2] += x[1][1] * y[1][2];
>+    result[1][2] += x[1][2] * y[2][2];
>+    result[2][0] = 0;
>+    result[2][0] += x[2][0] * y[0][0];
>+    result[2][0] += x[2][1] * y[1][0];
>+    result[2][0] += x[2][2] * y[2][0];
>+    result[2][1] = 0;
>+    result[2][1] += x[2][0] * y[0][1];
>+    result[2][1] += x[2][1] * y[1][1];
>+    result[2][1] += x[2][2] * y[2][1];
>+    result[2][2] = 0;
>+    result[2][2] += x[2][0] * y[0][2];
>+    result[2][2] += x[2][1] * y[1][2];
>+    result[2][2] += x[2][2] * y[2][2];
>+    result[3][0] = 0;
>+    result[3][0] += x[3][0] * y[0][0];
>+    result[3][0] += x[3][1] * y[1][0];
>+    result[3][0] += x[3][2] * y[2][0];
>+    result[3][1] = 0;
>+    result[3][1] += x[3][0] * y[0][1];
>+    result[3][1] += x[3][1] * y[1][1];
>+    result[3][1] += x[3][2] * y[2][1];
>+    result[3][2] = 0;
>+    result[3][2] += x[3][0] * y[0][2];
>+    result[3][2] += x[3][1] * y[1][2];
>+    result[3][2] += x[3][2] * y[2][2];
>+    return result;
>+}
>+float4x4 mul(float4x3 x, float3x4 y) {
>+    float4x4 result;
>+    result[0][0] = 0;
>+    result[0][0] += x[0][0] * y[0][0];
>+    result[0][0] += x[0][1] * y[1][0];
>+    result[0][0] += x[0][2] * y[2][0];
>+    result[0][1] = 0;
>+    result[0][1] += x[0][0] * y[0][1];
>+    result[0][1] += x[0][1] * y[1][1];
>+    result[0][1] += x[0][2] * y[2][1];
>+    result[0][2] = 0;
>+    result[0][2] += x[0][0] * y[0][2];
>+    result[0][2] += x[0][1] * y[1][2];
>+    result[0][2] += x[0][2] * y[2][2];
>+    result[0][3] = 0;
>+    result[0][3] += x[0][0] * y[0][3];
>+    result[0][3] += x[0][1] * y[1][3];
>+    result[0][3] += x[0][2] * y[2][3];
>+    result[1][0] = 0;
>+    result[1][0] += x[1][0] * y[0][0];
>+    result[1][0] += x[1][1] * y[1][0];
>+    result[1][0] += x[1][2] * y[2][0];
>+    result[1][1] = 0;
>+    result[1][1] += x[1][0] * y[0][1];
>+    result[1][1] += x[1][1] * y[1][1];
>+    result[1][1] += x[1][2] * y[2][1];
>+    result[1][2] = 0;
>+    result[1][2] += x[1][0] * y[0][2];
>+    result[1][2] += x[1][1] * y[1][2];
>+    result[1][2] += x[1][2] * y[2][2];
>+    result[1][3] = 0;
>+    result[1][3] += x[1][0] * y[0][3];
>+    result[1][3] += x[1][1] * y[1][3];
>+    result[1][3] += x[1][2] * y[2][3];
>+    result[2][0] = 0;
>+    result[2][0] += x[2][0] * y[0][0];
>+    result[2][0] += x[2][1] * y[1][0];
>+    result[2][0] += x[2][2] * y[2][0];
>+    result[2][1] = 0;
>+    result[2][1] += x[2][0] * y[0][1];
>+    result[2][1] += x[2][1] * y[1][1];
>+    result[2][1] += x[2][2] * y[2][1];
>+    result[2][2] = 0;
>+    result[2][2] += x[2][0] * y[0][2];
>+    result[2][2] += x[2][1] * y[1][2];
>+    result[2][2] += x[2][2] * y[2][2];
>+    result[2][3] = 0;
>+    result[2][3] += x[2][0] * y[0][3];
>+    result[2][3] += x[2][1] * y[1][3];
>+    result[2][3] += x[2][2] * y[2][3];
>+    result[3][0] = 0;
>+    result[3][0] += x[3][0] * y[0][0];
>+    result[3][0] += x[3][1] * y[1][0];
>+    result[3][0] += x[3][2] * y[2][0];
>+    result[3][1] = 0;
>+    result[3][1] += x[3][0] * y[0][1];
>+    result[3][1] += x[3][1] * y[1][1];
>+    result[3][1] += x[3][2] * y[2][1];
>+    result[3][2] = 0;
>+    result[3][2] += x[3][0] * y[0][2];
>+    result[3][2] += x[3][1] * y[1][2];
>+    result[3][2] += x[3][2] * y[2][2];
>+    result[3][3] = 0;
>+    result[3][3] += x[3][0] * y[0][3];
>+    result[3][3] += x[3][1] * y[1][3];
>+    result[3][3] += x[3][2] * y[2][3];
>+    return result;
>+}
>+float4x2 mul(float4x4 x, float4x2 y) {
>+    float4x2 result;
>+    result[0][0] = 0;
>+    result[0][0] += x[0][0] * y[0][0];
>+    result[0][0] += x[0][1] * y[1][0];
>+    result[0][0] += x[0][2] * y[2][0];
>+    result[0][0] += x[0][3] * y[3][0];
>+    result[0][1] = 0;
>+    result[0][1] += x[0][0] * y[0][1];
>+    result[0][1] += x[0][1] * y[1][1];
>+    result[0][1] += x[0][2] * y[2][1];
>+    result[0][1] += x[0][3] * y[3][1];
>+    result[1][0] = 0;
>+    result[1][0] += x[1][0] * y[0][0];
>+    result[1][0] += x[1][1] * y[1][0];
>+    result[1][0] += x[1][2] * y[2][0];
>+    result[1][0] += x[1][3] * y[3][0];
>+    result[1][1] = 0;
>+    result[1][1] += x[1][0] * y[0][1];
>+    result[1][1] += x[1][1] * y[1][1];
>+    result[1][1] += x[1][2] * y[2][1];
>+    result[1][1] += x[1][3] * y[3][1];
>+    result[2][0] = 0;
>+    result[2][0] += x[2][0] * y[0][0];
>+    result[2][0] += x[2][1] * y[1][0];
>+    result[2][0] += x[2][2] * y[2][0];
>+    result[2][0] += x[2][3] * y[3][0];
>+    result[2][1] = 0;
>+    result[2][1] += x[2][0] * y[0][1];
>+    result[2][1] += x[2][1] * y[1][1];
>+    result[2][1] += x[2][2] * y[2][1];
>+    result[2][1] += x[2][3] * y[3][1];
>+    result[3][0] = 0;
>+    result[3][0] += x[3][0] * y[0][0];
>+    result[3][0] += x[3][1] * y[1][0];
>+    result[3][0] += x[3][2] * y[2][0];
>+    result[3][0] += x[3][3] * y[3][0];
>+    result[3][1] = 0;
>+    result[3][1] += x[3][0] * y[0][1];
>+    result[3][1] += x[3][1] * y[1][1];
>+    result[3][1] += x[3][2] * y[2][1];
>+    result[3][1] += x[3][3] * y[3][1];
>+    return result;
>+}
>+float4x3 mul(float4x4 x, float4x3 y) {
>+    float4x3 result;
>+    result[0][0] = 0;
>+    result[0][0] += x[0][0] * y[0][0];
>+    result[0][0] += x[0][1] * y[1][0];
>+    result[0][0] += x[0][2] * y[2][0];
>+    result[0][0] += x[0][3] * y[3][0];
>+    result[0][1] = 0;
>+    result[0][1] += x[0][0] * y[0][1];
>+    result[0][1] += x[0][1] * y[1][1];
>+    result[0][1] += x[0][2] * y[2][1];
>+    result[0][1] += x[0][3] * y[3][1];
>+    result[0][2] = 0;
>+    result[0][2] += x[0][0] * y[0][2];
>+    result[0][2] += x[0][1] * y[1][2];
>+    result[0][2] += x[0][2] * y[2][2];
>+    result[0][2] += x[0][3] * y[3][2];
>+    result[1][0] = 0;
>+    result[1][0] += x[1][0] * y[0][0];
>+    result[1][0] += x[1][1] * y[1][0];
>+    result[1][0] += x[1][2] * y[2][0];
>+    result[1][0] += x[1][3] * y[3][0];
>+    result[1][1] = 0;
>+    result[1][1] += x[1][0] * y[0][1];
>+    result[1][1] += x[1][1] * y[1][1];
>+    result[1][1] += x[1][2] * y[2][1];
>+    result[1][1] += x[1][3] * y[3][1];
>+    result[1][2] = 0;
>+    result[1][2] += x[1][0] * y[0][2];
>+    result[1][2] += x[1][1] * y[1][2];
>+    result[1][2] += x[1][2] * y[2][2];
>+    result[1][2] += x[1][3] * y[3][2];
>+    result[2][0] = 0;
>+    result[2][0] += x[2][0] * y[0][0];
>+    result[2][0] += x[2][1] * y[1][0];
>+    result[2][0] += x[2][2] * y[2][0];
>+    result[2][0] += x[2][3] * y[3][0];
>+    result[2][1] = 0;
>+    result[2][1] += x[2][0] * y[0][1];
>+    result[2][1] += x[2][1] * y[1][1];
>+    result[2][1] += x[2][2] * y[2][1];
>+    result[2][1] += x[2][3] * y[3][1];
>+    result[2][2] = 0;
>+    result[2][2] += x[2][0] * y[0][2];
>+    result[2][2] += x[2][1] * y[1][2];
>+    result[2][2] += x[2][2] * y[2][2];
>+    result[2][2] += x[2][3] * y[3][2];
>+    result[3][0] = 0;
>+    result[3][0] += x[3][0] * y[0][0];
>+    result[3][0] += x[3][1] * y[1][0];
>+    result[3][0] += x[3][2] * y[2][0];
>+    result[3][0] += x[3][3] * y[3][0];
>+    result[3][1] = 0;
>+    result[3][1] += x[3][0] * y[0][1];
>+    result[3][1] += x[3][1] * y[1][1];
>+    result[3][1] += x[3][2] * y[2][1];
>+    result[3][1] += x[3][3] * y[3][1];
>+    result[3][2] = 0;
>+    result[3][2] += x[3][0] * y[0][2];
>+    result[3][2] += x[3][1] * y[1][2];
>+    result[3][2] += x[3][2] * y[2][2];
>+    result[3][2] += x[3][3] * y[3][2];
>+    return result;
>+}
>+float4x4 mul(float4x4 x, float4x4 y) {
>+    float4x4 result;
>+    result[0][0] = 0;
>+    result[0][0] += x[0][0] * y[0][0];
>+    result[0][0] += x[0][1] * y[1][0];
>+    result[0][0] += x[0][2] * y[2][0];
>+    result[0][0] += x[0][3] * y[3][0];
>+    result[0][1] = 0;
>+    result[0][1] += x[0][0] * y[0][1];
>+    result[0][1] += x[0][1] * y[1][1];
>+    result[0][1] += x[0][2] * y[2][1];
>+    result[0][1] += x[0][3] * y[3][1];
>+    result[0][2] = 0;
>+    result[0][2] += x[0][0] * y[0][2];
>+    result[0][2] += x[0][1] * y[1][2];
>+    result[0][2] += x[0][2] * y[2][2];
>+    result[0][2] += x[0][3] * y[3][2];
>+    result[0][3] = 0;
>+    result[0][3] += x[0][0] * y[0][3];
>+    result[0][3] += x[0][1] * y[1][3];
>+    result[0][3] += x[0][2] * y[2][3];
>+    result[0][3] += x[0][3] * y[3][3];
>+    result[1][0] = 0;
>+    result[1][0] += x[1][0] * y[0][0];
>+    result[1][0] += x[1][1] * y[1][0];
>+    result[1][0] += x[1][2] * y[2][0];
>+    result[1][0] += x[1][3] * y[3][0];
>+    result[1][1] = 0;
>+    result[1][1] += x[1][0] * y[0][1];
>+    result[1][1] += x[1][1] * y[1][1];
>+    result[1][1] += x[1][2] * y[2][1];
>+    result[1][1] += x[1][3] * y[3][1];
>+    result[1][2] = 0;
>+    result[1][2] += x[1][0] * y[0][2];
>+    result[1][2] += x[1][1] * y[1][2];
>+    result[1][2] += x[1][2] * y[2][2];
>+    result[1][2] += x[1][3] * y[3][2];
>+    result[1][3] = 0;
>+    result[1][3] += x[1][0] * y[0][3];
>+    result[1][3] += x[1][1] * y[1][3];
>+    result[1][3] += x[1][2] * y[2][3];
>+    result[1][3] += x[1][3] * y[3][3];
>+    result[2][0] = 0;
>+    result[2][0] += x[2][0] * y[0][0];
>+    result[2][0] += x[2][1] * y[1][0];
>+    result[2][0] += x[2][2] * y[2][0];
>+    result[2][0] += x[2][3] * y[3][0];
>+    result[2][1] = 0;
>+    result[2][1] += x[2][0] * y[0][1];
>+    result[2][1] += x[2][1] * y[1][1];
>+    result[2][1] += x[2][2] * y[2][1];
>+    result[2][1] += x[2][3] * y[3][1];
>+    result[2][2] = 0;
>+    result[2][2] += x[2][0] * y[0][2];
>+    result[2][2] += x[2][1] * y[1][2];
>+    result[2][2] += x[2][2] * y[2][2];
>+    result[2][2] += x[2][3] * y[3][2];
>+    result[2][3] = 0;
>+    result[2][3] += x[2][0] * y[0][3];
>+    result[2][3] += x[2][1] * y[1][3];
>+    result[2][3] += x[2][2] * y[2][3];
>+    result[2][3] += x[2][3] * y[3][3];
>+    result[3][0] = 0;
>+    result[3][0] += x[3][0] * y[0][0];
>+    result[3][0] += x[3][1] * y[1][0];
>+    result[3][0] += x[3][2] * y[2][0];
>+    result[3][0] += x[3][3] * y[3][0];
>+    result[3][1] = 0;
>+    result[3][1] += x[3][0] * y[0][1];
>+    result[3][1] += x[3][1] * y[1][1];
>+    result[3][1] += x[3][2] * y[2][1];
>+    result[3][1] += x[3][3] * y[3][1];
>+    result[3][2] = 0;
>+    result[3][2] += x[3][0] * y[0][2];
>+    result[3][2] += x[3][1] * y[1][2];
>+    result[3][2] += x[3][2] * y[2][2];
>+    result[3][2] += x[3][3] * y[3][2];
>+    result[3][3] = 0;
>+    result[3][3] += x[3][0] * y[0][3];
>+    result[3][3] += x[3][1] * y[1][3];
>+    result[3][3] += x[3][2] * y[2][3];
>+    result[3][3] += x[3][3] * y[3][3];
>+    return result;
>+}
>+
>+
>+/* Functions named operator.xzyw= */
>+bool4 operator.xzyw=(bool4 v, bool4 c) {
>+    bool4 result = v;
>+    result.x = c.x;
>+    result.z = c.y;
>+    result.y = c.z;
>+    result.w = c.w;
>+    return result;
>+}
>+uchar4 operator.xzyw=(uchar4 v, uchar4 c) {
>+    uchar4 result = v;
>+    result.x = c.x;
>+    result.z = c.y;
>+    result.y = c.z;
>+    result.w = c.w;
>+    return result;
>+}
>+ushort4 operator.xzyw=(ushort4 v, ushort4 c) {
>+    ushort4 result = v;
>+    result.x = c.x;
>+    result.z = c.y;
>+    result.y = c.z;
>+    result.w = c.w;
>+    return result;
>+}
>+uint4 operator.xzyw=(uint4 v, uint4 c) {
>+    uint4 result = v;
>+    result.x = c.x;
>+    result.z = c.y;
>+    result.y = c.z;
>+    result.w = c.w;
>+    return result;
>+}
>+char4 operator.xzyw=(char4 v, char4 c) {
>+    char4 result = v;
>+    result.x = c.x;
>+    result.z = c.y;
>+    result.y = c.z;
>+    result.w = c.w;
>+    return result;
>+}
>+short4 operator.xzyw=(short4 v, short4 c) {
>+    short4 result = v;
>+    result.x = c.x;
>+    result.z = c.y;
>+    result.y = c.z;
>+    result.w = c.w;
>+    return result;
>+}
>+int4 operator.xzyw=(int4 v, int4 c) {
>+    int4 result = v;
>+    result.x = c.x;
>+    result.z = c.y;
>+    result.y = c.z;
>+    result.w = c.w;
>+    return result;
>+}
>+half4 operator.xzyw=(half4 v, half4 c) {
>+    half4 result = v;
>+    result.x = c.x;
>+    result.z = c.y;
>+    result.y = c.z;
>+    result.w = c.w;
>+    return result;
>+}
>+float4 operator.xzyw=(float4 v, float4 c) {
>+    float4 result = v;
>+    result.x = c.x;
>+    result.z = c.y;
>+    result.y = c.z;
>+    result.w = c.w;
>+    return result;
>+}
>+
>+/* Functions named operator.wyxw */
>+bool4 operator.wyxw(bool4 v) {
>+    bool4 result;
>+    result.x = v.w;
>+    result.y = v.y;
>+    result.z = v.x;
>+    result.w = v.w;
>+    return result;
>+}
>+uchar4 operator.wyxw(uchar4 v) {
>+    uchar4 result;
>+    result.x = v.w;
>+    result.y = v.y;
>+    result.z = v.x;
>+    result.w = v.w;
>+    return result;
>+}
>+ushort4 operator.wyxw(ushort4 v) {
>+    ushort4 result;
>+    result.x = v.w;
>+    result.y = v.y;
>+    result.z = v.x;
>+    result.w = v.w;
>+    return result;
>+}
>+uint4 operator.wyxw(uint4 v) {
>+    uint4 result;
>+    result.x = v.w;
>+    result.y = v.y;
>+    result.z = v.x;
>+    result.w = v.w;
>+    return result;
>+}
>+char4 operator.wyxw(char4 v) {
>+    char4 result;
>+    result.x = v.w;
>+    result.y = v.y;
>+    result.z = v.x;
>+    result.w = v.w;
>+    return result;
>+}
>+short4 operator.wyxw(short4 v) {
>+    short4 result;
>+    result.x = v.w;
>+    result.y = v.y;
>+    result.z = v.x;
>+    result.w = v.w;
>+    return result;
>+}
>+int4 operator.wyxw(int4 v) {
>+    int4 result;
>+    result.x = v.w;
>+    result.y = v.y;
>+    result.z = v.x;
>+    result.w = v.w;
>+    return result;
>+}
>+half4 operator.wyxw(half4 v) {
>+    half4 result;
>+    result.x = v.w;
>+    result.y = v.y;
>+    result.z = v.x;
>+    result.w = v.w;
>+    return result;
>+}
>+float4 operator.wyxw(float4 v) {
>+    float4 result;
>+    result.x = v.w;
>+    result.y = v.y;
>+    result.z = v.x;
>+    result.w = v.w;
>+    return result;
>+}
>+
>+/* Functions named operator.zxxz */
>+bool4 operator.zxxz(bool3 v) {
>+    bool4 result;
>+    result.x = v.z;
>+    result.y = v.x;
>+    result.z = v.x;
>+    result.w = v.z;
>+    return result;
>+}
>+bool4 operator.zxxz(bool4 v) {
>+    bool4 result;
>+    result.x = v.z;
>+    result.y = v.x;
>+    result.z = v.x;
>+    result.w = v.z;
>+    return result;
>+}
>+uchar4 operator.zxxz(uchar3 v) {
>+    uchar4 result;
>+    result.x = v.z;
>+    result.y = v.x;
>+    result.z = v.x;
>+    result.w = v.z;
>+    return result;
>+}
>+uchar4 operator.zxxz(uchar4 v) {
>+    uchar4 result;
>+    result.x = v.z;
>+    result.y = v.x;
>+    result.z = v.x;
>+    result.w = v.z;
>+    return result;
>+}
>+ushort4 operator.zxxz(ushort3 v) {
>+    ushort4 result;
>+    result.x = v.z;
>+    result.y = v.x;
>+    result.z = v.x;
>+    result.w = v.z;
>+    return result;
>+}
>+ushort4 operator.zxxz(ushort4 v) {
>+    ushort4 result;
>+    result.x = v.z;
>+    result.y = v.x;
>+    result.z = v.x;
>+    result.w = v.z;
>+    return result;
>+}
>+uint4 operator.zxxz(uint3 v) {
>+    uint4 result;
>+    result.x = v.z;
>+    result.y = v.x;
>+    result.z = v.x;
>+    result.w = v.z;
>+    return result;
>+}
>+uint4 operator.zxxz(uint4 v) {
>+    uint4 result;
>+    result.x = v.z;
>+    result.y = v.x;
>+    result.z = v.x;
>+    result.w = v.z;
>+    return result;
>+}
>+char4 operator.zxxz(char3 v) {
>+    char4 result;
>+    result.x = v.z;
>+    result.y = v.x;
>+    result.z = v.x;
>+    result.w = v.z;
>+    return result;
>+}
>+char4 operator.zxxz(char4 v) {
>+    char4 result;
>+    result.x = v.z;
>+    result.y = v.x;
>+    result.z = v.x;
>+    result.w = v.z;
>+    return result;
>+}
>+short4 operator.zxxz(short3 v) {
>+    short4 result;
>+    result.x = v.z;
>+    result.y = v.x;
>+    result.z = v.x;
>+    result.w = v.z;
>+    return result;
>+}
>+short4 operator.zxxz(short4 v) {
>+    short4 result;
>+    result.x = v.z;
>+    result.y = v.x;
>+    result.z = v.x;
>+    result.w = v.z;
>+    return result;
>+}
>+int4 operator.zxxz(int3 v) {
>+    int4 result;
>+    result.x = v.z;
>+    result.y = v.x;
>+    result.z = v.x;
>+    result.w = v.z;
>+    return result;
>+}
>+int4 operator.zxxz(int4 v) {
>+    int4 result;
>+    result.x = v.z;
>+    result.y = v.x;
>+    result.z = v.x;
>+    result.w = v.z;
>+    return result;
>+}
>+half4 operator.zxxz(half3 v) {
>+    half4 result;
>+    result.x = v.z;
>+    result.y = v.x;
>+    result.z = v.x;
>+    result.w = v.z;
>+    return result;
>+}
>+half4 operator.zxxz(half4 v) {
>+    half4 result;
>+    result.x = v.z;
>+    result.y = v.x;
>+    result.z = v.x;
>+    result.w = v.z;
>+    return result;
>+}
>+float4 operator.zxxz(float3 v) {
>+    float4 result;
>+    result.x = v.z;
>+    result.y = v.x;
>+    result.z = v.x;
>+    result.w = v.z;
>+    return result;
>+}
>+float4 operator.zxxz(float4 v) {
>+    float4 result;
>+    result.x = v.z;
>+    result.y = v.x;
>+    result.z = v.x;
>+    result.w = v.z;
>+    return result;
>+}
>+
>+/* Functions named operator.yyxx */
>+bool4 operator.yyxx(bool2 v) {
>+    bool4 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.x;
>+    result.w = v.x;
>+    return result;
>+}
>+bool4 operator.yyxx(bool3 v) {
>+    bool4 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.x;
>+    result.w = v.x;
>+    return result;
>+}
>+bool4 operator.yyxx(bool4 v) {
>+    bool4 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.x;
>+    result.w = v.x;
>+    return result;
>+}
>+uchar4 operator.yyxx(uchar2 v) {
>+    uchar4 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.x;
>+    result.w = v.x;
>+    return result;
>+}
>+uchar4 operator.yyxx(uchar3 v) {
>+    uchar4 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.x;
>+    result.w = v.x;
>+    return result;
>+}
>+uchar4 operator.yyxx(uchar4 v) {
>+    uchar4 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.x;
>+    result.w = v.x;
>+    return result;
>+}
>+ushort4 operator.yyxx(ushort2 v) {
>+    ushort4 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.x;
>+    result.w = v.x;
>+    return result;
>+}
>+ushort4 operator.yyxx(ushort3 v) {
>+    ushort4 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.x;
>+    result.w = v.x;
>+    return result;
>+}
>+ushort4 operator.yyxx(ushort4 v) {
>+    ushort4 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.x;
>+    result.w = v.x;
>+    return result;
>+}
>+uint4 operator.yyxx(uint2 v) {
>+    uint4 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.x;
>+    result.w = v.x;
>+    return result;
>+}
>+uint4 operator.yyxx(uint3 v) {
>+    uint4 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.x;
>+    result.w = v.x;
>+    return result;
>+}
>+uint4 operator.yyxx(uint4 v) {
>+    uint4 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.x;
>+    result.w = v.x;
>+    return result;
>+}
>+char4 operator.yyxx(char2 v) {
>+    char4 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.x;
>+    result.w = v.x;
>+    return result;
>+}
>+char4 operator.yyxx(char3 v) {
>+    char4 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.x;
>+    result.w = v.x;
>+    return result;
>+}
>+char4 operator.yyxx(char4 v) {
>+    char4 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.x;
>+    result.w = v.x;
>+    return result;
>+}
>+short4 operator.yyxx(short2 v) {
>+    short4 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.x;
>+    result.w = v.x;
>+    return result;
>+}
>+short4 operator.yyxx(short3 v) {
>+    short4 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.x;
>+    result.w = v.x;
>+    return result;
>+}
>+short4 operator.yyxx(short4 v) {
>+    short4 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.x;
>+    result.w = v.x;
>+    return result;
>+}
>+int4 operator.yyxx(int2 v) {
>+    int4 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.x;
>+    result.w = v.x;
>+    return result;
>+}
>+int4 operator.yyxx(int3 v) {
>+    int4 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.x;
>+    result.w = v.x;
>+    return result;
>+}
>+int4 operator.yyxx(int4 v) {
>+    int4 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.x;
>+    result.w = v.x;
>+    return result;
>+}
>+half4 operator.yyxx(half2 v) {
>+    half4 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.x;
>+    result.w = v.x;
>+    return result;
>+}
>+half4 operator.yyxx(half3 v) {
>+    half4 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.x;
>+    result.w = v.x;
>+    return result;
>+}
>+half4 operator.yyxx(half4 v) {
>+    half4 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.x;
>+    result.w = v.x;
>+    return result;
>+}
>+float4 operator.yyxx(float2 v) {
>+    float4 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.x;
>+    result.w = v.x;
>+    return result;
>+}
>+float4 operator.yyxx(float3 v) {
>+    float4 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.x;
>+    result.w = v.x;
>+    return result;
>+}
>+float4 operator.yyxx(float4 v) {
>+    float4 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.x;
>+    result.w = v.x;
>+    return result;
>+}
>+
>+/* Functions named operator.www */
>+bool3 operator.www(bool4 v) {
>+    bool3 result;
>+    result.x = v.w;
>+    result.y = v.w;
>+    result.z = v.w;
>+    return result;
>+}
>+uchar3 operator.www(uchar4 v) {
>+    uchar3 result;
>+    result.x = v.w;
>+    result.y = v.w;
>+    result.z = v.w;
>+    return result;
>+}
>+ushort3 operator.www(ushort4 v) {
>+    ushort3 result;
>+    result.x = v.w;
>+    result.y = v.w;
>+    result.z = v.w;
>+    return result;
>+}
>+uint3 operator.www(uint4 v) {
>+    uint3 result;
>+    result.x = v.w;
>+    result.y = v.w;
>+    result.z = v.w;
>+    return result;
>+}
>+char3 operator.www(char4 v) {
>+    char3 result;
>+    result.x = v.w;
>+    result.y = v.w;
>+    result.z = v.w;
>+    return result;
>+}
>+short3 operator.www(short4 v) {
>+    short3 result;
>+    result.x = v.w;
>+    result.y = v.w;
>+    result.z = v.w;
>+    return result;
>+}
>+int3 operator.www(int4 v) {
>+    int3 result;
>+    result.x = v.w;
>+    result.y = v.w;
>+    result.z = v.w;
>+    return result;
>+}
>+half3 operator.www(half4 v) {
>+    half3 result;
>+    result.x = v.w;
>+    result.y = v.w;
>+    result.z = v.w;
>+    return result;
>+}
>+float3 operator.www(float4 v) {
>+    float3 result;
>+    result.x = v.w;
>+    result.y = v.w;
>+    result.z = v.w;
>+    return result;
>+}
>+
>+/* Functions named radians */
>+half radians(half x) {
>+    return x * 3.14159 / 180;
>+}
>+half2 radians(half2 x) {
>+    half2 result;
>+    result[0] = radians(x[0]);
>+    result[1] = radians(x[1]);
>+    return result;
>+}
>+half3 radians(half3 x) {
>+    half3 result;
>+    result[0] = radians(x[0]);
>+    result[1] = radians(x[1]);
>+    result[2] = radians(x[2]);
>+    return result;
>+}
>+half4 radians(half4 x) {
>+    half4 result;
>+    result[0] = radians(x[0]);
>+    result[1] = radians(x[1]);
>+    result[2] = radians(x[2]);
>+    result[3] = radians(x[3]);
>+    return result;
>+}
>+half2x2 radians(half2x2 x) {
>+    half2x2 result;
>+    result[0][0] = radians(x[0][0]);
>+    result[0][1] = radians(x[0][1]);
>+    result[1][0] = radians(x[1][0]);
>+    result[1][1] = radians(x[1][1]);
>+    return result;
>+}
>+half2x3 radians(half2x3 x) {
>+    half2x3 result;
>+    result[0][0] = radians(x[0][0]);
>+    result[0][1] = radians(x[0][1]);
>+    result[0][2] = radians(x[0][2]);
>+    result[1][0] = radians(x[1][0]);
>+    result[1][1] = radians(x[1][1]);
>+    result[1][2] = radians(x[1][2]);
>+    return result;
>+}
>+half2x4 radians(half2x4 x) {
>+    half2x4 result;
>+    result[0][0] = radians(x[0][0]);
>+    result[0][1] = radians(x[0][1]);
>+    result[0][2] = radians(x[0][2]);
>+    result[0][3] = radians(x[0][3]);
>+    result[1][0] = radians(x[1][0]);
>+    result[1][1] = radians(x[1][1]);
>+    result[1][2] = radians(x[1][2]);
>+    result[1][3] = radians(x[1][3]);
>+    return result;
>+}
>+half3x2 radians(half3x2 x) {
>+    half3x2 result;
>+    result[0][0] = radians(x[0][0]);
>+    result[0][1] = radians(x[0][1]);
>+    result[1][0] = radians(x[1][0]);
>+    result[1][1] = radians(x[1][1]);
>+    result[2][0] = radians(x[2][0]);
>+    result[2][1] = radians(x[2][1]);
>+    return result;
>+}
>+half3x3 radians(half3x3 x) {
>+    half3x3 result;
>+    result[0][0] = radians(x[0][0]);
>+    result[0][1] = radians(x[0][1]);
>+    result[0][2] = radians(x[0][2]);
>+    result[1][0] = radians(x[1][0]);
>+    result[1][1] = radians(x[1][1]);
>+    result[1][2] = radians(x[1][2]);
>+    result[2][0] = radians(x[2][0]);
>+    result[2][1] = radians(x[2][1]);
>+    result[2][2] = radians(x[2][2]);
>+    return result;
>+}
>+half3x4 radians(half3x4 x) {
>+    half3x4 result;
>+    result[0][0] = radians(x[0][0]);
>+    result[0][1] = radians(x[0][1]);
>+    result[0][2] = radians(x[0][2]);
>+    result[0][3] = radians(x[0][3]);
>+    result[1][0] = radians(x[1][0]);
>+    result[1][1] = radians(x[1][1]);
>+    result[1][2] = radians(x[1][2]);
>+    result[1][3] = radians(x[1][3]);
>+    result[2][0] = radians(x[2][0]);
>+    result[2][1] = radians(x[2][1]);
>+    result[2][2] = radians(x[2][2]);
>+    result[2][3] = radians(x[2][3]);
>+    return result;
>+}
>+half4x2 radians(half4x2 x) {
>+    half4x2 result;
>+    result[0][0] = radians(x[0][0]);
>+    result[0][1] = radians(x[0][1]);
>+    result[1][0] = radians(x[1][0]);
>+    result[1][1] = radians(x[1][1]);
>+    result[2][0] = radians(x[2][0]);
>+    result[2][1] = radians(x[2][1]);
>+    result[3][0] = radians(x[3][0]);
>+    result[3][1] = radians(x[3][1]);
>+    return result;
>+}
>+half4x3 radians(half4x3 x) {
>+    half4x3 result;
>+    result[0][0] = radians(x[0][0]);
>+    result[0][1] = radians(x[0][1]);
>+    result[0][2] = radians(x[0][2]);
>+    result[1][0] = radians(x[1][0]);
>+    result[1][1] = radians(x[1][1]);
>+    result[1][2] = radians(x[1][2]);
>+    result[2][0] = radians(x[2][0]);
>+    result[2][1] = radians(x[2][1]);
>+    result[2][2] = radians(x[2][2]);
>+    result[3][0] = radians(x[3][0]);
>+    result[3][1] = radians(x[3][1]);
>+    result[3][2] = radians(x[3][2]);
>+    return result;
>+}
>+half4x4 radians(half4x4 x) {
>+    half4x4 result;
>+    result[0][0] = radians(x[0][0]);
>+    result[0][1] = radians(x[0][1]);
>+    result[0][2] = radians(x[0][2]);
>+    result[0][3] = radians(x[0][3]);
>+    result[1][0] = radians(x[1][0]);
>+    result[1][1] = radians(x[1][1]);
>+    result[1][2] = radians(x[1][2]);
>+    result[1][3] = radians(x[1][3]);
>+    result[2][0] = radians(x[2][0]);
>+    result[2][1] = radians(x[2][1]);
>+    result[2][2] = radians(x[2][2]);
>+    result[2][3] = radians(x[2][3]);
>+    result[3][0] = radians(x[3][0]);
>+    result[3][1] = radians(x[3][1]);
>+    result[3][2] = radians(x[3][2]);
>+    result[3][3] = radians(x[3][3]);
>+    return result;
>+}
>+float radians(float x) {
>+    return x * 3.14159 / 180;
>+}
>+float2 radians(float2 x) {
>+    float2 result;
>+    result[0] = radians(x[0]);
>+    result[1] = radians(x[1]);
>+    return result;
>+}
>+float3 radians(float3 x) {
>+    float3 result;
>+    result[0] = radians(x[0]);
>+    result[1] = radians(x[1]);
>+    result[2] = radians(x[2]);
>+    return result;
>+}
>+float4 radians(float4 x) {
>+    float4 result;
>+    result[0] = radians(x[0]);
>+    result[1] = radians(x[1]);
>+    result[2] = radians(x[2]);
>+    result[3] = radians(x[3]);
>+    return result;
>+}
>+float2x2 radians(float2x2 x) {
>+    float2x2 result;
>+    result[0][0] = radians(x[0][0]);
>+    result[0][1] = radians(x[0][1]);
>+    result[1][0] = radians(x[1][0]);
>+    result[1][1] = radians(x[1][1]);
>+    return result;
>+}
>+float2x3 radians(float2x3 x) {
>+    float2x3 result;
>+    result[0][0] = radians(x[0][0]);
>+    result[0][1] = radians(x[0][1]);
>+    result[0][2] = radians(x[0][2]);
>+    result[1][0] = radians(x[1][0]);
>+    result[1][1] = radians(x[1][1]);
>+    result[1][2] = radians(x[1][2]);
>+    return result;
>+}
>+float2x4 radians(float2x4 x) {
>+    float2x4 result;
>+    result[0][0] = radians(x[0][0]);
>+    result[0][1] = radians(x[0][1]);
>+    result[0][2] = radians(x[0][2]);
>+    result[0][3] = radians(x[0][3]);
>+    result[1][0] = radians(x[1][0]);
>+    result[1][1] = radians(x[1][1]);
>+    result[1][2] = radians(x[1][2]);
>+    result[1][3] = radians(x[1][3]);
>+    return result;
>+}
>+float3x2 radians(float3x2 x) {
>+    float3x2 result;
>+    result[0][0] = radians(x[0][0]);
>+    result[0][1] = radians(x[0][1]);
>+    result[1][0] = radians(x[1][0]);
>+    result[1][1] = radians(x[1][1]);
>+    result[2][0] = radians(x[2][0]);
>+    result[2][1] = radians(x[2][1]);
>+    return result;
>+}
>+float3x3 radians(float3x3 x) {
>+    float3x3 result;
>+    result[0][0] = radians(x[0][0]);
>+    result[0][1] = radians(x[0][1]);
>+    result[0][2] = radians(x[0][2]);
>+    result[1][0] = radians(x[1][0]);
>+    result[1][1] = radians(x[1][1]);
>+    result[1][2] = radians(x[1][2]);
>+    result[2][0] = radians(x[2][0]);
>+    result[2][1] = radians(x[2][1]);
>+    result[2][2] = radians(x[2][2]);
>+    return result;
>+}
>+float3x4 radians(float3x4 x) {
>+    float3x4 result;
>+    result[0][0] = radians(x[0][0]);
>+    result[0][1] = radians(x[0][1]);
>+    result[0][2] = radians(x[0][2]);
>+    result[0][3] = radians(x[0][3]);
>+    result[1][0] = radians(x[1][0]);
>+    result[1][1] = radians(x[1][1]);
>+    result[1][2] = radians(x[1][2]);
>+    result[1][3] = radians(x[1][3]);
>+    result[2][0] = radians(x[2][0]);
>+    result[2][1] = radians(x[2][1]);
>+    result[2][2] = radians(x[2][2]);
>+    result[2][3] = radians(x[2][3]);
>+    return result;
>+}
>+float4x2 radians(float4x2 x) {
>+    float4x2 result;
>+    result[0][0] = radians(x[0][0]);
>+    result[0][1] = radians(x[0][1]);
>+    result[1][0] = radians(x[1][0]);
>+    result[1][1] = radians(x[1][1]);
>+    result[2][0] = radians(x[2][0]);
>+    result[2][1] = radians(x[2][1]);
>+    result[3][0] = radians(x[3][0]);
>+    result[3][1] = radians(x[3][1]);
>+    return result;
>+}
>+float4x3 radians(float4x3 x) {
>+    float4x3 result;
>+    result[0][0] = radians(x[0][0]);
>+    result[0][1] = radians(x[0][1]);
>+    result[0][2] = radians(x[0][2]);
>+    result[1][0] = radians(x[1][0]);
>+    result[1][1] = radians(x[1][1]);
>+    result[1][2] = radians(x[1][2]);
>+    result[2][0] = radians(x[2][0]);
>+    result[2][1] = radians(x[2][1]);
>+    result[2][2] = radians(x[2][2]);
>+    result[3][0] = radians(x[3][0]);
>+    result[3][1] = radians(x[3][1]);
>+    result[3][2] = radians(x[3][2]);
>+    return result;
>+}
>+float4x4 radians(float4x4 x) {
>+    float4x4 result;
>+    result[0][0] = radians(x[0][0]);
>+    result[0][1] = radians(x[0][1]);
>+    result[0][2] = radians(x[0][2]);
>+    result[0][3] = radians(x[0][3]);
>+    result[1][0] = radians(x[1][0]);
>+    result[1][1] = radians(x[1][1]);
>+    result[1][2] = radians(x[1][2]);
>+    result[1][3] = radians(x[1][3]);
>+    result[2][0] = radians(x[2][0]);
>+    result[2][1] = radians(x[2][1]);
>+    result[2][2] = radians(x[2][2]);
>+    result[2][3] = radians(x[2][3]);
>+    result[3][0] = radians(x[3][0]);
>+    result[3][1] = radians(x[3][1]);
>+    result[3][2] = radians(x[3][2]);
>+    result[3][3] = radians(x[3][3]);
>+    return result;
>+}
>+
>+/* Functions named operator.zwy= */
>+bool4 operator.zwy=(bool4 v, bool3 c) {
>+    bool4 result = v;
>+    result.z = c.x;
>+    result.w = c.y;
>+    result.y = c.z;
>+    return result;
>+}
>+uchar4 operator.zwy=(uchar4 v, uchar3 c) {
>+    uchar4 result = v;
>+    result.z = c.x;
>+    result.w = c.y;
>+    result.y = c.z;
>+    return result;
>+}
>+ushort4 operator.zwy=(ushort4 v, ushort3 c) {
>+    ushort4 result = v;
>+    result.z = c.x;
>+    result.w = c.y;
>+    result.y = c.z;
>+    return result;
>+}
>+uint4 operator.zwy=(uint4 v, uint3 c) {
>+    uint4 result = v;
>+    result.z = c.x;
>+    result.w = c.y;
>+    result.y = c.z;
>+    return result;
>+}
>+char4 operator.zwy=(char4 v, char3 c) {
>+    char4 result = v;
>+    result.z = c.x;
>+    result.w = c.y;
>+    result.y = c.z;
>+    return result;
>+}
>+short4 operator.zwy=(short4 v, short3 c) {
>+    short4 result = v;
>+    result.z = c.x;
>+    result.w = c.y;
>+    result.y = c.z;
>+    return result;
>+}
>+int4 operator.zwy=(int4 v, int3 c) {
>+    int4 result = v;
>+    result.z = c.x;
>+    result.w = c.y;
>+    result.y = c.z;
>+    return result;
>+}
>+half4 operator.zwy=(half4 v, half3 c) {
>+    half4 result = v;
>+    result.z = c.x;
>+    result.w = c.y;
>+    result.y = c.z;
>+    return result;
>+}
>+float4 operator.zwy=(float4 v, float3 c) {
>+    float4 result = v;
>+    result.z = c.x;
>+    result.w = c.y;
>+    result.y = c.z;
>+    return result;
>+}
>+
>+/* Functions named ceil */
>+native float ceil(float);
>+half ceil(half x) {
>+    return half(ceil(float(x)));
>+}
>+half2 ceil(half2 x) {
>+    half2 result;
>+    result[0] = ceil(x[0]);
>+    result[1] = ceil(x[1]);
>+    return result;
>+}
>+half3 ceil(half3 x) {
>+    half3 result;
>+    result[0] = ceil(x[0]);
>+    result[1] = ceil(x[1]);
>+    result[2] = ceil(x[2]);
>+    return result;
>+}
>+half4 ceil(half4 x) {
>+    half4 result;
>+    result[0] = ceil(x[0]);
>+    result[1] = ceil(x[1]);
>+    result[2] = ceil(x[2]);
>+    result[3] = ceil(x[3]);
>+    return result;
>+}
>+half2x2 ceil(half2x2 x) {
>+    half2x2 result;
>+    result[0][0] = ceil(x[0][0]);
>+    result[0][1] = ceil(x[0][1]);
>+    result[1][0] = ceil(x[1][0]);
>+    result[1][1] = ceil(x[1][1]);
>+    return result;
>+}
>+half2x3 ceil(half2x3 x) {
>+    half2x3 result;
>+    result[0][0] = ceil(x[0][0]);
>+    result[0][1] = ceil(x[0][1]);
>+    result[0][2] = ceil(x[0][2]);
>+    result[1][0] = ceil(x[1][0]);
>+    result[1][1] = ceil(x[1][1]);
>+    result[1][2] = ceil(x[1][2]);
>+    return result;
>+}
>+half2x4 ceil(half2x4 x) {
>+    half2x4 result;
>+    result[0][0] = ceil(x[0][0]);
>+    result[0][1] = ceil(x[0][1]);
>+    result[0][2] = ceil(x[0][2]);
>+    result[0][3] = ceil(x[0][3]);
>+    result[1][0] = ceil(x[1][0]);
>+    result[1][1] = ceil(x[1][1]);
>+    result[1][2] = ceil(x[1][2]);
>+    result[1][3] = ceil(x[1][3]);
>+    return result;
>+}
>+half3x2 ceil(half3x2 x) {
>+    half3x2 result;
>+    result[0][0] = ceil(x[0][0]);
>+    result[0][1] = ceil(x[0][1]);
>+    result[1][0] = ceil(x[1][0]);
>+    result[1][1] = ceil(x[1][1]);
>+    result[2][0] = ceil(x[2][0]);
>+    result[2][1] = ceil(x[2][1]);
>+    return result;
>+}
>+half3x3 ceil(half3x3 x) {
>+    half3x3 result;
>+    result[0][0] = ceil(x[0][0]);
>+    result[0][1] = ceil(x[0][1]);
>+    result[0][2] = ceil(x[0][2]);
>+    result[1][0] = ceil(x[1][0]);
>+    result[1][1] = ceil(x[1][1]);
>+    result[1][2] = ceil(x[1][2]);
>+    result[2][0] = ceil(x[2][0]);
>+    result[2][1] = ceil(x[2][1]);
>+    result[2][2] = ceil(x[2][2]);
>+    return result;
>+}
>+half3x4 ceil(half3x4 x) {
>+    half3x4 result;
>+    result[0][0] = ceil(x[0][0]);
>+    result[0][1] = ceil(x[0][1]);
>+    result[0][2] = ceil(x[0][2]);
>+    result[0][3] = ceil(x[0][3]);
>+    result[1][0] = ceil(x[1][0]);
>+    result[1][1] = ceil(x[1][1]);
>+    result[1][2] = ceil(x[1][2]);
>+    result[1][3] = ceil(x[1][3]);
>+    result[2][0] = ceil(x[2][0]);
>+    result[2][1] = ceil(x[2][1]);
>+    result[2][2] = ceil(x[2][2]);
>+    result[2][3] = ceil(x[2][3]);
>+    return result;
>+}
>+half4x2 ceil(half4x2 x) {
>+    half4x2 result;
>+    result[0][0] = ceil(x[0][0]);
>+    result[0][1] = ceil(x[0][1]);
>+    result[1][0] = ceil(x[1][0]);
>+    result[1][1] = ceil(x[1][1]);
>+    result[2][0] = ceil(x[2][0]);
>+    result[2][1] = ceil(x[2][1]);
>+    result[3][0] = ceil(x[3][0]);
>+    result[3][1] = ceil(x[3][1]);
>+    return result;
>+}
>+half4x3 ceil(half4x3 x) {
>+    half4x3 result;
>+    result[0][0] = ceil(x[0][0]);
>+    result[0][1] = ceil(x[0][1]);
>+    result[0][2] = ceil(x[0][2]);
>+    result[1][0] = ceil(x[1][0]);
>+    result[1][1] = ceil(x[1][1]);
>+    result[1][2] = ceil(x[1][2]);
>+    result[2][0] = ceil(x[2][0]);
>+    result[2][1] = ceil(x[2][1]);
>+    result[2][2] = ceil(x[2][2]);
>+    result[3][0] = ceil(x[3][0]);
>+    result[3][1] = ceil(x[3][1]);
>+    result[3][2] = ceil(x[3][2]);
>+    return result;
>+}
>+half4x4 ceil(half4x4 x) {
>+    half4x4 result;
>+    result[0][0] = ceil(x[0][0]);
>+    result[0][1] = ceil(x[0][1]);
>+    result[0][2] = ceil(x[0][2]);
>+    result[0][3] = ceil(x[0][3]);
>+    result[1][0] = ceil(x[1][0]);
>+    result[1][1] = ceil(x[1][1]);
>+    result[1][2] = ceil(x[1][2]);
>+    result[1][3] = ceil(x[1][3]);
>+    result[2][0] = ceil(x[2][0]);
>+    result[2][1] = ceil(x[2][1]);
>+    result[2][2] = ceil(x[2][2]);
>+    result[2][3] = ceil(x[2][3]);
>+    result[3][0] = ceil(x[3][0]);
>+    result[3][1] = ceil(x[3][1]);
>+    result[3][2] = ceil(x[3][2]);
>+    result[3][3] = ceil(x[3][3]);
>+    return result;
>+}
>+float2 ceil(float2 x) {
>+    float2 result;
>+    result[0] = ceil(x[0]);
>+    result[1] = ceil(x[1]);
>+    return result;
>+}
>+float3 ceil(float3 x) {
>+    float3 result;
>+    result[0] = ceil(x[0]);
>+    result[1] = ceil(x[1]);
>+    result[2] = ceil(x[2]);
>+    return result;
>+}
>+float4 ceil(float4 x) {
>+    float4 result;
>+    result[0] = ceil(x[0]);
>+    result[1] = ceil(x[1]);
>+    result[2] = ceil(x[2]);
>+    result[3] = ceil(x[3]);
>+    return result;
>+}
>+float2x2 ceil(float2x2 x) {
>+    float2x2 result;
>+    result[0][0] = ceil(x[0][0]);
>+    result[0][1] = ceil(x[0][1]);
>+    result[1][0] = ceil(x[1][0]);
>+    result[1][1] = ceil(x[1][1]);
>+    return result;
>+}
>+float2x3 ceil(float2x3 x) {
>+    float2x3 result;
>+    result[0][0] = ceil(x[0][0]);
>+    result[0][1] = ceil(x[0][1]);
>+    result[0][2] = ceil(x[0][2]);
>+    result[1][0] = ceil(x[1][0]);
>+    result[1][1] = ceil(x[1][1]);
>+    result[1][2] = ceil(x[1][2]);
>+    return result;
>+}
>+float2x4 ceil(float2x4 x) {
>+    float2x4 result;
>+    result[0][0] = ceil(x[0][0]);
>+    result[0][1] = ceil(x[0][1]);
>+    result[0][2] = ceil(x[0][2]);
>+    result[0][3] = ceil(x[0][3]);
>+    result[1][0] = ceil(x[1][0]);
>+    result[1][1] = ceil(x[1][1]);
>+    result[1][2] = ceil(x[1][2]);
>+    result[1][3] = ceil(x[1][3]);
>+    return result;
>+}
>+float3x2 ceil(float3x2 x) {
>+    float3x2 result;
>+    result[0][0] = ceil(x[0][0]);
>+    result[0][1] = ceil(x[0][1]);
>+    result[1][0] = ceil(x[1][0]);
>+    result[1][1] = ceil(x[1][1]);
>+    result[2][0] = ceil(x[2][0]);
>+    result[2][1] = ceil(x[2][1]);
>+    return result;
>+}
>+float3x3 ceil(float3x3 x) {
>+    float3x3 result;
>+    result[0][0] = ceil(x[0][0]);
>+    result[0][1] = ceil(x[0][1]);
>+    result[0][2] = ceil(x[0][2]);
>+    result[1][0] = ceil(x[1][0]);
>+    result[1][1] = ceil(x[1][1]);
>+    result[1][2] = ceil(x[1][2]);
>+    result[2][0] = ceil(x[2][0]);
>+    result[2][1] = ceil(x[2][1]);
>+    result[2][2] = ceil(x[2][2]);
>+    return result;
>+}
>+float3x4 ceil(float3x4 x) {
>+    float3x4 result;
>+    result[0][0] = ceil(x[0][0]);
>+    result[0][1] = ceil(x[0][1]);
>+    result[0][2] = ceil(x[0][2]);
>+    result[0][3] = ceil(x[0][3]);
>+    result[1][0] = ceil(x[1][0]);
>+    result[1][1] = ceil(x[1][1]);
>+    result[1][2] = ceil(x[1][2]);
>+    result[1][3] = ceil(x[1][3]);
>+    result[2][0] = ceil(x[2][0]);
>+    result[2][1] = ceil(x[2][1]);
>+    result[2][2] = ceil(x[2][2]);
>+    result[2][3] = ceil(x[2][3]);
>+    return result;
>+}
>+float4x2 ceil(float4x2 x) {
>+    float4x2 result;
>+    result[0][0] = ceil(x[0][0]);
>+    result[0][1] = ceil(x[0][1]);
>+    result[1][0] = ceil(x[1][0]);
>+    result[1][1] = ceil(x[1][1]);
>+    result[2][0] = ceil(x[2][0]);
>+    result[2][1] = ceil(x[2][1]);
>+    result[3][0] = ceil(x[3][0]);
>+    result[3][1] = ceil(x[3][1]);
>+    return result;
>+}
>+float4x3 ceil(float4x3 x) {
>+    float4x3 result;
>+    result[0][0] = ceil(x[0][0]);
>+    result[0][1] = ceil(x[0][1]);
>+    result[0][2] = ceil(x[0][2]);
>+    result[1][0] = ceil(x[1][0]);
>+    result[1][1] = ceil(x[1][1]);
>+    result[1][2] = ceil(x[1][2]);
>+    result[2][0] = ceil(x[2][0]);
>+    result[2][1] = ceil(x[2][1]);
>+    result[2][2] = ceil(x[2][2]);
>+    result[3][0] = ceil(x[3][0]);
>+    result[3][1] = ceil(x[3][1]);
>+    result[3][2] = ceil(x[3][2]);
>+    return result;
>+}
>+float4x4 ceil(float4x4 x) {
>+    float4x4 result;
>+    result[0][0] = ceil(x[0][0]);
>+    result[0][1] = ceil(x[0][1]);
>+    result[0][2] = ceil(x[0][2]);
>+    result[0][3] = ceil(x[0][3]);
>+    result[1][0] = ceil(x[1][0]);
>+    result[1][1] = ceil(x[1][1]);
>+    result[1][2] = ceil(x[1][2]);
>+    result[1][3] = ceil(x[1][3]);
>+    result[2][0] = ceil(x[2][0]);
>+    result[2][1] = ceil(x[2][1]);
>+    result[2][2] = ceil(x[2][2]);
>+    result[2][3] = ceil(x[2][3]);
>+    result[3][0] = ceil(x[3][0]);
>+    result[3][1] = ceil(x[3][1]);
>+    result[3][2] = ceil(x[3][2]);
>+    result[3][3] = ceil(x[3][3]);
>+    return result;
>+}
>+
>+/* Functions named operator.zywx= */
>+bool4 operator.zywx=(bool4 v, bool4 c) {
>+    bool4 result = v;
>+    result.z = c.x;
>+    result.y = c.y;
>+    result.w = c.z;
>+    result.x = c.w;
>+    return result;
>+}
>+uchar4 operator.zywx=(uchar4 v, uchar4 c) {
>+    uchar4 result = v;
>+    result.z = c.x;
>+    result.y = c.y;
>+    result.w = c.z;
>+    result.x = c.w;
>+    return result;
>+}
>+ushort4 operator.zywx=(ushort4 v, ushort4 c) {
>+    ushort4 result = v;
>+    result.z = c.x;
>+    result.y = c.y;
>+    result.w = c.z;
>+    result.x = c.w;
>+    return result;
>+}
>+uint4 operator.zywx=(uint4 v, uint4 c) {
>+    uint4 result = v;
>+    result.z = c.x;
>+    result.y = c.y;
>+    result.w = c.z;
>+    result.x = c.w;
>+    return result;
>+}
>+char4 operator.zywx=(char4 v, char4 c) {
>+    char4 result = v;
>+    result.z = c.x;
>+    result.y = c.y;
>+    result.w = c.z;
>+    result.x = c.w;
>+    return result;
>+}
>+short4 operator.zywx=(short4 v, short4 c) {
>+    short4 result = v;
>+    result.z = c.x;
>+    result.y = c.y;
>+    result.w = c.z;
>+    result.x = c.w;
>+    return result;
>+}
>+int4 operator.zywx=(int4 v, int4 c) {
>+    int4 result = v;
>+    result.z = c.x;
>+    result.y = c.y;
>+    result.w = c.z;
>+    result.x = c.w;
>+    return result;
>+}
>+half4 operator.zywx=(half4 v, half4 c) {
>+    half4 result = v;
>+    result.z = c.x;
>+    result.y = c.y;
>+    result.w = c.z;
>+    result.x = c.w;
>+    return result;
>+}
>+float4 operator.zywx=(float4 v, float4 c) {
>+    float4 result = v;
>+    result.z = c.x;
>+    result.y = c.y;
>+    result.w = c.z;
>+    result.x = c.w;
>+    return result;
>+}
>+
>+/* Functions named operator.yz= */
>+bool3 operator.yz=(bool3 v, bool2 c) {
>+    bool3 result = v;
>+    result.y = c.x;
>+    result.z = c.y;
>+    return result;
>+}
>+bool4 operator.yz=(bool4 v, bool2 c) {
>+    bool4 result = v;
>+    result.y = c.x;
>+    result.z = c.y;
>+    return result;
>+}
>+uchar3 operator.yz=(uchar3 v, uchar2 c) {
>+    uchar3 result = v;
>+    result.y = c.x;
>+    result.z = c.y;
>+    return result;
>+}
>+uchar4 operator.yz=(uchar4 v, uchar2 c) {
>+    uchar4 result = v;
>+    result.y = c.x;
>+    result.z = c.y;
>+    return result;
>+}
>+ushort3 operator.yz=(ushort3 v, ushort2 c) {
>+    ushort3 result = v;
>+    result.y = c.x;
>+    result.z = c.y;
>+    return result;
>+}
>+ushort4 operator.yz=(ushort4 v, ushort2 c) {
>+    ushort4 result = v;
>+    result.y = c.x;
>+    result.z = c.y;
>+    return result;
>+}
>+uint3 operator.yz=(uint3 v, uint2 c) {
>+    uint3 result = v;
>+    result.y = c.x;
>+    result.z = c.y;
>+    return result;
>+}
>+uint4 operator.yz=(uint4 v, uint2 c) {
>+    uint4 result = v;
>+    result.y = c.x;
>+    result.z = c.y;
>+    return result;
>+}
>+char3 operator.yz=(char3 v, char2 c) {
>+    char3 result = v;
>+    result.y = c.x;
>+    result.z = c.y;
>+    return result;
>+}
>+char4 operator.yz=(char4 v, char2 c) {
>+    char4 result = v;
>+    result.y = c.x;
>+    result.z = c.y;
>+    return result;
>+}
>+short3 operator.yz=(short3 v, short2 c) {
>+    short3 result = v;
>+    result.y = c.x;
>+    result.z = c.y;
>+    return result;
>+}
>+short4 operator.yz=(short4 v, short2 c) {
>+    short4 result = v;
>+    result.y = c.x;
>+    result.z = c.y;
>+    return result;
>+}
>+int3 operator.yz=(int3 v, int2 c) {
>+    int3 result = v;
>+    result.y = c.x;
>+    result.z = c.y;
>+    return result;
>+}
>+int4 operator.yz=(int4 v, int2 c) {
>+    int4 result = v;
>+    result.y = c.x;
>+    result.z = c.y;
>+    return result;
>+}
>+half3 operator.yz=(half3 v, half2 c) {
>+    half3 result = v;
>+    result.y = c.x;
>+    result.z = c.y;
>+    return result;
>+}
>+half4 operator.yz=(half4 v, half2 c) {
>+    half4 result = v;
>+    result.y = c.x;
>+    result.z = c.y;
>+    return result;
>+}
>+float3 operator.yz=(float3 v, float2 c) {
>+    float3 result = v;
>+    result.y = c.x;
>+    result.z = c.y;
>+    return result;
>+}
>+float4 operator.yz=(float4 v, float2 c) {
>+    float4 result = v;
>+    result.y = c.x;
>+    result.z = c.y;
>+    return result;
>+}
>+
>+/* Functions named asin */
>+native float asin(float);
>+half asin(half x) {
>+    return half(asin(float(x)));
>+}
>+half2 asin(half2 x) {
>+    half2 result;
>+    result[0] = asin(x[0]);
>+    result[1] = asin(x[1]);
>+    return result;
>+}
>+half3 asin(half3 x) {
>+    half3 result;
>+    result[0] = asin(x[0]);
>+    result[1] = asin(x[1]);
>+    result[2] = asin(x[2]);
>+    return result;
>+}
>+half4 asin(half4 x) {
>+    half4 result;
>+    result[0] = asin(x[0]);
>+    result[1] = asin(x[1]);
>+    result[2] = asin(x[2]);
>+    result[3] = asin(x[3]);
>+    return result;
>+}
>+half2x2 asin(half2x2 x) {
>+    half2x2 result;
>+    result[0][0] = asin(x[0][0]);
>+    result[0][1] = asin(x[0][1]);
>+    result[1][0] = asin(x[1][0]);
>+    result[1][1] = asin(x[1][1]);
>+    return result;
>+}
>+half2x3 asin(half2x3 x) {
>+    half2x3 result;
>+    result[0][0] = asin(x[0][0]);
>+    result[0][1] = asin(x[0][1]);
>+    result[0][2] = asin(x[0][2]);
>+    result[1][0] = asin(x[1][0]);
>+    result[1][1] = asin(x[1][1]);
>+    result[1][2] = asin(x[1][2]);
>+    return result;
>+}
>+half2x4 asin(half2x4 x) {
>+    half2x4 result;
>+    result[0][0] = asin(x[0][0]);
>+    result[0][1] = asin(x[0][1]);
>+    result[0][2] = asin(x[0][2]);
>+    result[0][3] = asin(x[0][3]);
>+    result[1][0] = asin(x[1][0]);
>+    result[1][1] = asin(x[1][1]);
>+    result[1][2] = asin(x[1][2]);
>+    result[1][3] = asin(x[1][3]);
>+    return result;
>+}
>+half3x2 asin(half3x2 x) {
>+    half3x2 result;
>+    result[0][0] = asin(x[0][0]);
>+    result[0][1] = asin(x[0][1]);
>+    result[1][0] = asin(x[1][0]);
>+    result[1][1] = asin(x[1][1]);
>+    result[2][0] = asin(x[2][0]);
>+    result[2][1] = asin(x[2][1]);
>+    return result;
>+}
>+half3x3 asin(half3x3 x) {
>+    half3x3 result;
>+    result[0][0] = asin(x[0][0]);
>+    result[0][1] = asin(x[0][1]);
>+    result[0][2] = asin(x[0][2]);
>+    result[1][0] = asin(x[1][0]);
>+    result[1][1] = asin(x[1][1]);
>+    result[1][2] = asin(x[1][2]);
>+    result[2][0] = asin(x[2][0]);
>+    result[2][1] = asin(x[2][1]);
>+    result[2][2] = asin(x[2][2]);
>+    return result;
>+}
>+half3x4 asin(half3x4 x) {
>+    half3x4 result;
>+    result[0][0] = asin(x[0][0]);
>+    result[0][1] = asin(x[0][1]);
>+    result[0][2] = asin(x[0][2]);
>+    result[0][3] = asin(x[0][3]);
>+    result[1][0] = asin(x[1][0]);
>+    result[1][1] = asin(x[1][1]);
>+    result[1][2] = asin(x[1][2]);
>+    result[1][3] = asin(x[1][3]);
>+    result[2][0] = asin(x[2][0]);
>+    result[2][1] = asin(x[2][1]);
>+    result[2][2] = asin(x[2][2]);
>+    result[2][3] = asin(x[2][3]);
>+    return result;
>+}
>+half4x2 asin(half4x2 x) {
>+    half4x2 result;
>+    result[0][0] = asin(x[0][0]);
>+    result[0][1] = asin(x[0][1]);
>+    result[1][0] = asin(x[1][0]);
>+    result[1][1] = asin(x[1][1]);
>+    result[2][0] = asin(x[2][0]);
>+    result[2][1] = asin(x[2][1]);
>+    result[3][0] = asin(x[3][0]);
>+    result[3][1] = asin(x[3][1]);
>+    return result;
>+}
>+half4x3 asin(half4x3 x) {
>+    half4x3 result;
>+    result[0][0] = asin(x[0][0]);
>+    result[0][1] = asin(x[0][1]);
>+    result[0][2] = asin(x[0][2]);
>+    result[1][0] = asin(x[1][0]);
>+    result[1][1] = asin(x[1][1]);
>+    result[1][2] = asin(x[1][2]);
>+    result[2][0] = asin(x[2][0]);
>+    result[2][1] = asin(x[2][1]);
>+    result[2][2] = asin(x[2][2]);
>+    result[3][0] = asin(x[3][0]);
>+    result[3][1] = asin(x[3][1]);
>+    result[3][2] = asin(x[3][2]);
>+    return result;
>+}
>+half4x4 asin(half4x4 x) {
>+    half4x4 result;
>+    result[0][0] = asin(x[0][0]);
>+    result[0][1] = asin(x[0][1]);
>+    result[0][2] = asin(x[0][2]);
>+    result[0][3] = asin(x[0][3]);
>+    result[1][0] = asin(x[1][0]);
>+    result[1][1] = asin(x[1][1]);
>+    result[1][2] = asin(x[1][2]);
>+    result[1][3] = asin(x[1][3]);
>+    result[2][0] = asin(x[2][0]);
>+    result[2][1] = asin(x[2][1]);
>+    result[2][2] = asin(x[2][2]);
>+    result[2][3] = asin(x[2][3]);
>+    result[3][0] = asin(x[3][0]);
>+    result[3][1] = asin(x[3][1]);
>+    result[3][2] = asin(x[3][2]);
>+    result[3][3] = asin(x[3][3]);
>+    return result;
>+}
>+float2 asin(float2 x) {
>+    float2 result;
>+    result[0] = asin(x[0]);
>+    result[1] = asin(x[1]);
>+    return result;
>+}
>+float3 asin(float3 x) {
>+    float3 result;
>+    result[0] = asin(x[0]);
>+    result[1] = asin(x[1]);
>+    result[2] = asin(x[2]);
>+    return result;
>+}
>+float4 asin(float4 x) {
>+    float4 result;
>+    result[0] = asin(x[0]);
>+    result[1] = asin(x[1]);
>+    result[2] = asin(x[2]);
>+    result[3] = asin(x[3]);
>+    return result;
>+}
>+float2x2 asin(float2x2 x) {
>+    float2x2 result;
>+    result[0][0] = asin(x[0][0]);
>+    result[0][1] = asin(x[0][1]);
>+    result[1][0] = asin(x[1][0]);
>+    result[1][1] = asin(x[1][1]);
>+    return result;
>+}
>+float2x3 asin(float2x3 x) {
>+    float2x3 result;
>+    result[0][0] = asin(x[0][0]);
>+    result[0][1] = asin(x[0][1]);
>+    result[0][2] = asin(x[0][2]);
>+    result[1][0] = asin(x[1][0]);
>+    result[1][1] = asin(x[1][1]);
>+    result[1][2] = asin(x[1][2]);
>+    return result;
>+}
>+float2x4 asin(float2x4 x) {
>+    float2x4 result;
>+    result[0][0] = asin(x[0][0]);
>+    result[0][1] = asin(x[0][1]);
>+    result[0][2] = asin(x[0][2]);
>+    result[0][3] = asin(x[0][3]);
>+    result[1][0] = asin(x[1][0]);
>+    result[1][1] = asin(x[1][1]);
>+    result[1][2] = asin(x[1][2]);
>+    result[1][3] = asin(x[1][3]);
>+    return result;
>+}
>+float3x2 asin(float3x2 x) {
>+    float3x2 result;
>+    result[0][0] = asin(x[0][0]);
>+    result[0][1] = asin(x[0][1]);
>+    result[1][0] = asin(x[1][0]);
>+    result[1][1] = asin(x[1][1]);
>+    result[2][0] = asin(x[2][0]);
>+    result[2][1] = asin(x[2][1]);
>+    return result;
>+}
>+float3x3 asin(float3x3 x) {
>+    float3x3 result;
>+    result[0][0] = asin(x[0][0]);
>+    result[0][1] = asin(x[0][1]);
>+    result[0][2] = asin(x[0][2]);
>+    result[1][0] = asin(x[1][0]);
>+    result[1][1] = asin(x[1][1]);
>+    result[1][2] = asin(x[1][2]);
>+    result[2][0] = asin(x[2][0]);
>+    result[2][1] = asin(x[2][1]);
>+    result[2][2] = asin(x[2][2]);
>+    return result;
>+}
>+float3x4 asin(float3x4 x) {
>+    float3x4 result;
>+    result[0][0] = asin(x[0][0]);
>+    result[0][1] = asin(x[0][1]);
>+    result[0][2] = asin(x[0][2]);
>+    result[0][3] = asin(x[0][3]);
>+    result[1][0] = asin(x[1][0]);
>+    result[1][1] = asin(x[1][1]);
>+    result[1][2] = asin(x[1][2]);
>+    result[1][3] = asin(x[1][3]);
>+    result[2][0] = asin(x[2][0]);
>+    result[2][1] = asin(x[2][1]);
>+    result[2][2] = asin(x[2][2]);
>+    result[2][3] = asin(x[2][3]);
>+    return result;
>+}
>+float4x2 asin(float4x2 x) {
>+    float4x2 result;
>+    result[0][0] = asin(x[0][0]);
>+    result[0][1] = asin(x[0][1]);
>+    result[1][0] = asin(x[1][0]);
>+    result[1][1] = asin(x[1][1]);
>+    result[2][0] = asin(x[2][0]);
>+    result[2][1] = asin(x[2][1]);
>+    result[3][0] = asin(x[3][0]);
>+    result[3][1] = asin(x[3][1]);
>+    return result;
>+}
>+float4x3 asin(float4x3 x) {
>+    float4x3 result;
>+    result[0][0] = asin(x[0][0]);
>+    result[0][1] = asin(x[0][1]);
>+    result[0][2] = asin(x[0][2]);
>+    result[1][0] = asin(x[1][0]);
>+    result[1][1] = asin(x[1][1]);
>+    result[1][2] = asin(x[1][2]);
>+    result[2][0] = asin(x[2][0]);
>+    result[2][1] = asin(x[2][1]);
>+    result[2][2] = asin(x[2][2]);
>+    result[3][0] = asin(x[3][0]);
>+    result[3][1] = asin(x[3][1]);
>+    result[3][2] = asin(x[3][2]);
>+    return result;
>+}
>+float4x4 asin(float4x4 x) {
>+    float4x4 result;
>+    result[0][0] = asin(x[0][0]);
>+    result[0][1] = asin(x[0][1]);
>+    result[0][2] = asin(x[0][2]);
>+    result[0][3] = asin(x[0][3]);
>+    result[1][0] = asin(x[1][0]);
>+    result[1][1] = asin(x[1][1]);
>+    result[1][2] = asin(x[1][2]);
>+    result[1][3] = asin(x[1][3]);
>+    result[2][0] = asin(x[2][0]);
>+    result[2][1] = asin(x[2][1]);
>+    result[2][2] = asin(x[2][2]);
>+    result[2][3] = asin(x[2][3]);
>+    result[3][0] = asin(x[3][0]);
>+    result[3][1] = asin(x[3][1]);
>+    result[3][2] = asin(x[3][2]);
>+    result[3][3] = asin(x[3][3]);
>+    return result;
>+}
>+
>+/* Functions named operator.xwzw */
>+bool4 operator.xwzw(bool4 v) {
>+    bool4 result;
>+    result.x = v.x;
>+    result.y = v.w;
>+    result.z = v.z;
>+    result.w = v.w;
>+    return result;
>+}
>+uchar4 operator.xwzw(uchar4 v) {
>+    uchar4 result;
>+    result.x = v.x;
>+    result.y = v.w;
>+    result.z = v.z;
>+    result.w = v.w;
>+    return result;
>+}
>+ushort4 operator.xwzw(ushort4 v) {
>+    ushort4 result;
>+    result.x = v.x;
>+    result.y = v.w;
>+    result.z = v.z;
>+    result.w = v.w;
>+    return result;
>+}
>+uint4 operator.xwzw(uint4 v) {
>+    uint4 result;
>+    result.x = v.x;
>+    result.y = v.w;
>+    result.z = v.z;
>+    result.w = v.w;
>+    return result;
>+}
>+char4 operator.xwzw(char4 v) {
>+    char4 result;
>+    result.x = v.x;
>+    result.y = v.w;
>+    result.z = v.z;
>+    result.w = v.w;
>+    return result;
>+}
>+short4 operator.xwzw(short4 v) {
>+    short4 result;
>+    result.x = v.x;
>+    result.y = v.w;
>+    result.z = v.z;
>+    result.w = v.w;
>+    return result;
>+}
>+int4 operator.xwzw(int4 v) {
>+    int4 result;
>+    result.x = v.x;
>+    result.y = v.w;
>+    result.z = v.z;
>+    result.w = v.w;
>+    return result;
>+}
>+half4 operator.xwzw(half4 v) {
>+    half4 result;
>+    result.x = v.x;
>+    result.y = v.w;
>+    result.z = v.z;
>+    result.w = v.w;
>+    return result;
>+}
>+float4 operator.xwzw(float4 v) {
>+    float4 result;
>+    result.x = v.x;
>+    result.y = v.w;
>+    result.z = v.z;
>+    result.w = v.w;
>+    return result;
>+}
>+
>+/* Functions named operator.ywzw */
>+bool4 operator.ywzw(bool4 v) {
>+    bool4 result;
>+    result.x = v.y;
>+    result.y = v.w;
>+    result.z = v.z;
>+    result.w = v.w;
>+    return result;
>+}
>+uchar4 operator.ywzw(uchar4 v) {
>+    uchar4 result;
>+    result.x = v.y;
>+    result.y = v.w;
>+    result.z = v.z;
>+    result.w = v.w;
>+    return result;
>+}
>+ushort4 operator.ywzw(ushort4 v) {
>+    ushort4 result;
>+    result.x = v.y;
>+    result.y = v.w;
>+    result.z = v.z;
>+    result.w = v.w;
>+    return result;
>+}
>+uint4 operator.ywzw(uint4 v) {
>+    uint4 result;
>+    result.x = v.y;
>+    result.y = v.w;
>+    result.z = v.z;
>+    result.w = v.w;
>+    return result;
>+}
>+char4 operator.ywzw(char4 v) {
>+    char4 result;
>+    result.x = v.y;
>+    result.y = v.w;
>+    result.z = v.z;
>+    result.w = v.w;
>+    return result;
>+}
>+short4 operator.ywzw(short4 v) {
>+    short4 result;
>+    result.x = v.y;
>+    result.y = v.w;
>+    result.z = v.z;
>+    result.w = v.w;
>+    return result;
>+}
>+int4 operator.ywzw(int4 v) {
>+    int4 result;
>+    result.x = v.y;
>+    result.y = v.w;
>+    result.z = v.z;
>+    result.w = v.w;
>+    return result;
>+}
>+half4 operator.ywzw(half4 v) {
>+    half4 result;
>+    result.x = v.y;
>+    result.y = v.w;
>+    result.z = v.z;
>+    result.w = v.w;
>+    return result;
>+}
>+float4 operator.ywzw(float4 v) {
>+    float4 result;
>+    result.x = v.y;
>+    result.y = v.w;
>+    result.z = v.z;
>+    result.w = v.w;
>+    return result;
>+}
>+
>+/* Functions named operator.zzyz */
>+bool4 operator.zzyz(bool3 v) {
>+    bool4 result;
>+    result.x = v.z;
>+    result.y = v.z;
>+    result.z = v.y;
>+    result.w = v.z;
>+    return result;
>+}
>+bool4 operator.zzyz(bool4 v) {
>+    bool4 result;
>+    result.x = v.z;
>+    result.y = v.z;
>+    result.z = v.y;
>+    result.w = v.z;
>+    return result;
>+}
>+uchar4 operator.zzyz(uchar3 v) {
>+    uchar4 result;
>+    result.x = v.z;
>+    result.y = v.z;
>+    result.z = v.y;
>+    result.w = v.z;
>+    return result;
>+}
>+uchar4 operator.zzyz(uchar4 v) {
>+    uchar4 result;
>+    result.x = v.z;
>+    result.y = v.z;
>+    result.z = v.y;
>+    result.w = v.z;
>+    return result;
>+}
>+ushort4 operator.zzyz(ushort3 v) {
>+    ushort4 result;
>+    result.x = v.z;
>+    result.y = v.z;
>+    result.z = v.y;
>+    result.w = v.z;
>+    return result;
>+}
>+ushort4 operator.zzyz(ushort4 v) {
>+    ushort4 result;
>+    result.x = v.z;
>+    result.y = v.z;
>+    result.z = v.y;
>+    result.w = v.z;
>+    return result;
>+}
>+uint4 operator.zzyz(uint3 v) {
>+    uint4 result;
>+    result.x = v.z;
>+    result.y = v.z;
>+    result.z = v.y;
>+    result.w = v.z;
>+    return result;
>+}
>+uint4 operator.zzyz(uint4 v) {
>+    uint4 result;
>+    result.x = v.z;
>+    result.y = v.z;
>+    result.z = v.y;
>+    result.w = v.z;
>+    return result;
>+}
>+char4 operator.zzyz(char3 v) {
>+    char4 result;
>+    result.x = v.z;
>+    result.y = v.z;
>+    result.z = v.y;
>+    result.w = v.z;
>+    return result;
>+}
>+char4 operator.zzyz(char4 v) {
>+    char4 result;
>+    result.x = v.z;
>+    result.y = v.z;
>+    result.z = v.y;
>+    result.w = v.z;
>+    return result;
>+}
>+short4 operator.zzyz(short3 v) {
>+    short4 result;
>+    result.x = v.z;
>+    result.y = v.z;
>+    result.z = v.y;
>+    result.w = v.z;
>+    return result;
>+}
>+short4 operator.zzyz(short4 v) {
>+    short4 result;
>+    result.x = v.z;
>+    result.y = v.z;
>+    result.z = v.y;
>+    result.w = v.z;
>+    return result;
>+}
>+int4 operator.zzyz(int3 v) {
>+    int4 result;
>+    result.x = v.z;
>+    result.y = v.z;
>+    result.z = v.y;
>+    result.w = v.z;
>+    return result;
>+}
>+int4 operator.zzyz(int4 v) {
>+    int4 result;
>+    result.x = v.z;
>+    result.y = v.z;
>+    result.z = v.y;
>+    result.w = v.z;
>+    return result;
>+}
>+half4 operator.zzyz(half3 v) {
>+    half4 result;
>+    result.x = v.z;
>+    result.y = v.z;
>+    result.z = v.y;
>+    result.w = v.z;
>+    return result;
>+}
>+half4 operator.zzyz(half4 v) {
>+    half4 result;
>+    result.x = v.z;
>+    result.y = v.z;
>+    result.z = v.y;
>+    result.w = v.z;
>+    return result;
>+}
>+float4 operator.zzyz(float3 v) {
>+    float4 result;
>+    result.x = v.z;
>+    result.y = v.z;
>+    result.z = v.y;
>+    result.w = v.z;
>+    return result;
>+}
>+float4 operator.zzyz(float4 v) {
>+    float4 result;
>+    result.x = v.z;
>+    result.y = v.z;
>+    result.z = v.y;
>+    result.w = v.z;
>+    return result;
>+}
>+
>+/* Functions named operator.zzzy */
>+bool4 operator.zzzy(bool3 v) {
>+    bool4 result;
>+    result.x = v.z;
>+    result.y = v.z;
>+    result.z = v.z;
>+    result.w = v.y;
>+    return result;
>+}
>+bool4 operator.zzzy(bool4 v) {
>+    bool4 result;
>+    result.x = v.z;
>+    result.y = v.z;
>+    result.z = v.z;
>+    result.w = v.y;
>+    return result;
>+}
>+uchar4 operator.zzzy(uchar3 v) {
>+    uchar4 result;
>+    result.x = v.z;
>+    result.y = v.z;
>+    result.z = v.z;
>+    result.w = v.y;
>+    return result;
>+}
>+uchar4 operator.zzzy(uchar4 v) {
>+    uchar4 result;
>+    result.x = v.z;
>+    result.y = v.z;
>+    result.z = v.z;
>+    result.w = v.y;
>+    return result;
>+}
>+ushort4 operator.zzzy(ushort3 v) {
>+    ushort4 result;
>+    result.x = v.z;
>+    result.y = v.z;
>+    result.z = v.z;
>+    result.w = v.y;
>+    return result;
>+}
>+ushort4 operator.zzzy(ushort4 v) {
>+    ushort4 result;
>+    result.x = v.z;
>+    result.y = v.z;
>+    result.z = v.z;
>+    result.w = v.y;
>+    return result;
>+}
>+uint4 operator.zzzy(uint3 v) {
>+    uint4 result;
>+    result.x = v.z;
>+    result.y = v.z;
>+    result.z = v.z;
>+    result.w = v.y;
>+    return result;
>+}
>+uint4 operator.zzzy(uint4 v) {
>+    uint4 result;
>+    result.x = v.z;
>+    result.y = v.z;
>+    result.z = v.z;
>+    result.w = v.y;
>+    return result;
>+}
>+char4 operator.zzzy(char3 v) {
>+    char4 result;
>+    result.x = v.z;
>+    result.y = v.z;
>+    result.z = v.z;
>+    result.w = v.y;
>+    return result;
>+}
>+char4 operator.zzzy(char4 v) {
>+    char4 result;
>+    result.x = v.z;
>+    result.y = v.z;
>+    result.z = v.z;
>+    result.w = v.y;
>+    return result;
>+}
>+short4 operator.zzzy(short3 v) {
>+    short4 result;
>+    result.x = v.z;
>+    result.y = v.z;
>+    result.z = v.z;
>+    result.w = v.y;
>+    return result;
>+}
>+short4 operator.zzzy(short4 v) {
>+    short4 result;
>+    result.x = v.z;
>+    result.y = v.z;
>+    result.z = v.z;
>+    result.w = v.y;
>+    return result;
>+}
>+int4 operator.zzzy(int3 v) {
>+    int4 result;
>+    result.x = v.z;
>+    result.y = v.z;
>+    result.z = v.z;
>+    result.w = v.y;
>+    return result;
>+}
>+int4 operator.zzzy(int4 v) {
>+    int4 result;
>+    result.x = v.z;
>+    result.y = v.z;
>+    result.z = v.z;
>+    result.w = v.y;
>+    return result;
>+}
>+half4 operator.zzzy(half3 v) {
>+    half4 result;
>+    result.x = v.z;
>+    result.y = v.z;
>+    result.z = v.z;
>+    result.w = v.y;
>+    return result;
>+}
>+half4 operator.zzzy(half4 v) {
>+    half4 result;
>+    result.x = v.z;
>+    result.y = v.z;
>+    result.z = v.z;
>+    result.w = v.y;
>+    return result;
>+}
>+float4 operator.zzzy(float3 v) {
>+    float4 result;
>+    result.x = v.z;
>+    result.y = v.z;
>+    result.z = v.z;
>+    result.w = v.y;
>+    return result;
>+}
>+float4 operator.zzzy(float4 v) {
>+    float4 result;
>+    result.x = v.z;
>+    result.y = v.z;
>+    result.z = v.z;
>+    result.w = v.y;
>+    return result;
>+}
>+
>+/* Functions named asuint */
>+uint asuint(int x) {
>+    return uint(x);
>+}
>+uint2 asuint(int2 x) {
>+    uint2 result;
>+    result[0] = asuint(x[0]);
>+    result[1] = asuint(x[1]);
>+    return result;
>+}
>+uint3 asuint(int3 x) {
>+    uint3 result;
>+    result[0] = asuint(x[0]);
>+    result[1] = asuint(x[1]);
>+    result[2] = asuint(x[2]);
>+    return result;
>+}
>+uint4 asuint(int4 x) {
>+    uint4 result;
>+    result[0] = asuint(x[0]);
>+    result[1] = asuint(x[1]);
>+    result[2] = asuint(x[2]);
>+    result[3] = asuint(x[3]);
>+    return result;
>+}
>+uint asuint(uint x) {
>+    return x;
>+}
>+uint2 asuint(uint2 x) {
>+    return x;
>+}
>+uint3 asuint(uint3 x) {
>+    return x;
>+}
>+uint4 asuint(uint4 x) {
>+    return x;
>+}
>+native uint asuint(float);
>+uint2 asuint(float2 x) {
>+    uint2 result;
>+    result[0] = asuint(x[0]);
>+    result[1] = asuint(x[1]);
>+    return result;
>+}
>+uint3 asuint(float3 x) {
>+    uint3 result;
>+    result[0] = asuint(x[0]);
>+    result[1] = asuint(x[1]);
>+    result[2] = asuint(x[2]);
>+    return result;
>+}
>+uint4 asuint(float4 x) {
>+    uint4 result;
>+    result[0] = asuint(x[0]);
>+    result[1] = asuint(x[1]);
>+    result[2] = asuint(x[2]);
>+    result[3] = asuint(x[3]);
>+    return result;
>+}
>+
>+/* Functions named operator.yzxy */
>+bool4 operator.yzxy(bool3 v) {
>+    bool4 result;
>+    result.x = v.y;
>+    result.y = v.z;
>+    result.z = v.x;
>+    result.w = v.y;
>+    return result;
>+}
>+bool4 operator.yzxy(bool4 v) {
>+    bool4 result;
>+    result.x = v.y;
>+    result.y = v.z;
>+    result.z = v.x;
>+    result.w = v.y;
>+    return result;
>+}
>+uchar4 operator.yzxy(uchar3 v) {
>+    uchar4 result;
>+    result.x = v.y;
>+    result.y = v.z;
>+    result.z = v.x;
>+    result.w = v.y;
>+    return result;
>+}
>+uchar4 operator.yzxy(uchar4 v) {
>+    uchar4 result;
>+    result.x = v.y;
>+    result.y = v.z;
>+    result.z = v.x;
>+    result.w = v.y;
>+    return result;
>+}
>+ushort4 operator.yzxy(ushort3 v) {
>+    ushort4 result;
>+    result.x = v.y;
>+    result.y = v.z;
>+    result.z = v.x;
>+    result.w = v.y;
>+    return result;
>+}
>+ushort4 operator.yzxy(ushort4 v) {
>+    ushort4 result;
>+    result.x = v.y;
>+    result.y = v.z;
>+    result.z = v.x;
>+    result.w = v.y;
>+    return result;
>+}
>+uint4 operator.yzxy(uint3 v) {
>+    uint4 result;
>+    result.x = v.y;
>+    result.y = v.z;
>+    result.z = v.x;
>+    result.w = v.y;
>+    return result;
>+}
>+uint4 operator.yzxy(uint4 v) {
>+    uint4 result;
>+    result.x = v.y;
>+    result.y = v.z;
>+    result.z = v.x;
>+    result.w = v.y;
>+    return result;
>+}
>+char4 operator.yzxy(char3 v) {
>+    char4 result;
>+    result.x = v.y;
>+    result.y = v.z;
>+    result.z = v.x;
>+    result.w = v.y;
>+    return result;
>+}
>+char4 operator.yzxy(char4 v) {
>+    char4 result;
>+    result.x = v.y;
>+    result.y = v.z;
>+    result.z = v.x;
>+    result.w = v.y;
>+    return result;
>+}
>+short4 operator.yzxy(short3 v) {
>+    short4 result;
>+    result.x = v.y;
>+    result.y = v.z;
>+    result.z = v.x;
>+    result.w = v.y;
>+    return result;
>+}
>+short4 operator.yzxy(short4 v) {
>+    short4 result;
>+    result.x = v.y;
>+    result.y = v.z;
>+    result.z = v.x;
>+    result.w = v.y;
>+    return result;
>+}
>+int4 operator.yzxy(int3 v) {
>+    int4 result;
>+    result.x = v.y;
>+    result.y = v.z;
>+    result.z = v.x;
>+    result.w = v.y;
>+    return result;
>+}
>+int4 operator.yzxy(int4 v) {
>+    int4 result;
>+    result.x = v.y;
>+    result.y = v.z;
>+    result.z = v.x;
>+    result.w = v.y;
>+    return result;
>+}
>+half4 operator.yzxy(half3 v) {
>+    half4 result;
>+    result.x = v.y;
>+    result.y = v.z;
>+    result.z = v.x;
>+    result.w = v.y;
>+    return result;
>+}
>+half4 operator.yzxy(half4 v) {
>+    half4 result;
>+    result.x = v.y;
>+    result.y = v.z;
>+    result.z = v.x;
>+    result.w = v.y;
>+    return result;
>+}
>+float4 operator.yzxy(float3 v) {
>+    float4 result;
>+    result.x = v.y;
>+    result.y = v.z;
>+    result.z = v.x;
>+    result.w = v.y;
>+    return result;
>+}
>+float4 operator.yzxy(float4 v) {
>+    float4 result;
>+    result.x = v.y;
>+    result.y = v.z;
>+    result.z = v.x;
>+    result.w = v.y;
>+    return result;
>+}
>+
>+/* Functions named pow */
>+native float pow(float, float);
>+half pow(half x, half y) {
>+    return half(pow(float(x), float(y)));
>+}
>+half2 pow(half2 x, half2 y) {
>+    half2 result;
>+    result[0] = pow(x[0], y[0]);
>+    result[1] = pow(x[1], y[1]);
>+    return result;
>+}
>+half3 pow(half3 x, half3 y) {
>+    half3 result;
>+    result[0] = pow(x[0], y[0]);
>+    result[1] = pow(x[1], y[1]);
>+    result[2] = pow(x[2], y[2]);
>+    return result;
>+}
>+half4 pow(half4 x, half4 y) {
>+    half4 result;
>+    result[0] = pow(x[0], y[0]);
>+    result[1] = pow(x[1], y[1]);
>+    result[2] = pow(x[2], y[2]);
>+    result[3] = pow(x[3], y[3]);
>+    return result;
>+}
>+half2x2 pow(half2x2 x, half2x2 y) {
>+    half2x2 result;
>+    result[0][0] = pow(x[0][0], y[0][0]);
>+    result[0][1] = pow(x[0][1], y[0][1]);
>+    result[1][0] = pow(x[1][0], y[1][0]);
>+    result[1][1] = pow(x[1][1], y[1][1]);
>+    return result;
>+}
>+half2x3 pow(half2x3 x, half2x3 y) {
>+    half2x3 result;
>+    result[0][0] = pow(x[0][0], y[0][0]);
>+    result[0][1] = pow(x[0][1], y[0][1]);
>+    result[0][2] = pow(x[0][2], y[0][2]);
>+    result[1][0] = pow(x[1][0], y[1][0]);
>+    result[1][1] = pow(x[1][1], y[1][1]);
>+    result[1][2] = pow(x[1][2], y[1][2]);
>+    return result;
>+}
>+half2x4 pow(half2x4 x, half2x4 y) {
>+    half2x4 result;
>+    result[0][0] = pow(x[0][0], y[0][0]);
>+    result[0][1] = pow(x[0][1], y[0][1]);
>+    result[0][2] = pow(x[0][2], y[0][2]);
>+    result[0][3] = pow(x[0][3], y[0][3]);
>+    result[1][0] = pow(x[1][0], y[1][0]);
>+    result[1][1] = pow(x[1][1], y[1][1]);
>+    result[1][2] = pow(x[1][2], y[1][2]);
>+    result[1][3] = pow(x[1][3], y[1][3]);
>+    return result;
>+}
>+half3x2 pow(half3x2 x, half3x2 y) {
>+    half3x2 result;
>+    result[0][0] = pow(x[0][0], y[0][0]);
>+    result[0][1] = pow(x[0][1], y[0][1]);
>+    result[1][0] = pow(x[1][0], y[1][0]);
>+    result[1][1] = pow(x[1][1], y[1][1]);
>+    result[2][0] = pow(x[2][0], y[2][0]);
>+    result[2][1] = pow(x[2][1], y[2][1]);
>+    return result;
>+}
>+half3x3 pow(half3x3 x, half3x3 y) {
>+    half3x3 result;
>+    result[0][0] = pow(x[0][0], y[0][0]);
>+    result[0][1] = pow(x[0][1], y[0][1]);
>+    result[0][2] = pow(x[0][2], y[0][2]);
>+    result[1][0] = pow(x[1][0], y[1][0]);
>+    result[1][1] = pow(x[1][1], y[1][1]);
>+    result[1][2] = pow(x[1][2], y[1][2]);
>+    result[2][0] = pow(x[2][0], y[2][0]);
>+    result[2][1] = pow(x[2][1], y[2][1]);
>+    result[2][2] = pow(x[2][2], y[2][2]);
>+    return result;
>+}
>+half3x4 pow(half3x4 x, half3x4 y) {
>+    half3x4 result;
>+    result[0][0] = pow(x[0][0], y[0][0]);
>+    result[0][1] = pow(x[0][1], y[0][1]);
>+    result[0][2] = pow(x[0][2], y[0][2]);
>+    result[0][3] = pow(x[0][3], y[0][3]);
>+    result[1][0] = pow(x[1][0], y[1][0]);
>+    result[1][1] = pow(x[1][1], y[1][1]);
>+    result[1][2] = pow(x[1][2], y[1][2]);
>+    result[1][3] = pow(x[1][3], y[1][3]);
>+    result[2][0] = pow(x[2][0], y[2][0]);
>+    result[2][1] = pow(x[2][1], y[2][1]);
>+    result[2][2] = pow(x[2][2], y[2][2]);
>+    result[2][3] = pow(x[2][3], y[2][3]);
>+    return result;
>+}
>+half4x2 pow(half4x2 x, half4x2 y) {
>+    half4x2 result;
>+    result[0][0] = pow(x[0][0], y[0][0]);
>+    result[0][1] = pow(x[0][1], y[0][1]);
>+    result[1][0] = pow(x[1][0], y[1][0]);
>+    result[1][1] = pow(x[1][1], y[1][1]);
>+    result[2][0] = pow(x[2][0], y[2][0]);
>+    result[2][1] = pow(x[2][1], y[2][1]);
>+    result[3][0] = pow(x[3][0], y[3][0]);
>+    result[3][1] = pow(x[3][1], y[3][1]);
>+    return result;
>+}
>+half4x3 pow(half4x3 x, half4x3 y) {
>+    half4x3 result;
>+    result[0][0] = pow(x[0][0], y[0][0]);
>+    result[0][1] = pow(x[0][1], y[0][1]);
>+    result[0][2] = pow(x[0][2], y[0][2]);
>+    result[1][0] = pow(x[1][0], y[1][0]);
>+    result[1][1] = pow(x[1][1], y[1][1]);
>+    result[1][2] = pow(x[1][2], y[1][2]);
>+    result[2][0] = pow(x[2][0], y[2][0]);
>+    result[2][1] = pow(x[2][1], y[2][1]);
>+    result[2][2] = pow(x[2][2], y[2][2]);
>+    result[3][0] = pow(x[3][0], y[3][0]);
>+    result[3][1] = pow(x[3][1], y[3][1]);
>+    result[3][2] = pow(x[3][2], y[3][2]);
>+    return result;
>+}
>+half4x4 pow(half4x4 x, half4x4 y) {
>+    half4x4 result;
>+    result[0][0] = pow(x[0][0], y[0][0]);
>+    result[0][1] = pow(x[0][1], y[0][1]);
>+    result[0][2] = pow(x[0][2], y[0][2]);
>+    result[0][3] = pow(x[0][3], y[0][3]);
>+    result[1][0] = pow(x[1][0], y[1][0]);
>+    result[1][1] = pow(x[1][1], y[1][1]);
>+    result[1][2] = pow(x[1][2], y[1][2]);
>+    result[1][3] = pow(x[1][3], y[1][3]);
>+    result[2][0] = pow(x[2][0], y[2][0]);
>+    result[2][1] = pow(x[2][1], y[2][1]);
>+    result[2][2] = pow(x[2][2], y[2][2]);
>+    result[2][3] = pow(x[2][3], y[2][3]);
>+    result[3][0] = pow(x[3][0], y[3][0]);
>+    result[3][1] = pow(x[3][1], y[3][1]);
>+    result[3][2] = pow(x[3][2], y[3][2]);
>+    result[3][3] = pow(x[3][3], y[3][3]);
>+    return result;
>+}
>+float2 pow(float2 x, float2 y) {
>+    float2 result;
>+    result[0] = pow(x[0], y[0]);
>+    result[1] = pow(x[1], y[1]);
>+    return result;
>+}
>+float3 pow(float3 x, float3 y) {
>+    float3 result;
>+    result[0] = pow(x[0], y[0]);
>+    result[1] = pow(x[1], y[1]);
>+    result[2] = pow(x[2], y[2]);
>+    return result;
>+}
>+float4 pow(float4 x, float4 y) {
>+    float4 result;
>+    result[0] = pow(x[0], y[0]);
>+    result[1] = pow(x[1], y[1]);
>+    result[2] = pow(x[2], y[2]);
>+    result[3] = pow(x[3], y[3]);
>+    return result;
>+}
>+float2x2 pow(float2x2 x, float2x2 y) {
>+    float2x2 result;
>+    result[0][0] = pow(x[0][0], y[0][0]);
>+    result[0][1] = pow(x[0][1], y[0][1]);
>+    result[1][0] = pow(x[1][0], y[1][0]);
>+    result[1][1] = pow(x[1][1], y[1][1]);
>+    return result;
>+}
>+float2x3 pow(float2x3 x, float2x3 y) {
>+    float2x3 result;
>+    result[0][0] = pow(x[0][0], y[0][0]);
>+    result[0][1] = pow(x[0][1], y[0][1]);
>+    result[0][2] = pow(x[0][2], y[0][2]);
>+    result[1][0] = pow(x[1][0], y[1][0]);
>+    result[1][1] = pow(x[1][1], y[1][1]);
>+    result[1][2] = pow(x[1][2], y[1][2]);
>+    return result;
>+}
>+float2x4 pow(float2x4 x, float2x4 y) {
>+    float2x4 result;
>+    result[0][0] = pow(x[0][0], y[0][0]);
>+    result[0][1] = pow(x[0][1], y[0][1]);
>+    result[0][2] = pow(x[0][2], y[0][2]);
>+    result[0][3] = pow(x[0][3], y[0][3]);
>+    result[1][0] = pow(x[1][0], y[1][0]);
>+    result[1][1] = pow(x[1][1], y[1][1]);
>+    result[1][2] = pow(x[1][2], y[1][2]);
>+    result[1][3] = pow(x[1][3], y[1][3]);
>+    return result;
>+}
>+float3x2 pow(float3x2 x, float3x2 y) {
>+    float3x2 result;
>+    result[0][0] = pow(x[0][0], y[0][0]);
>+    result[0][1] = pow(x[0][1], y[0][1]);
>+    result[1][0] = pow(x[1][0], y[1][0]);
>+    result[1][1] = pow(x[1][1], y[1][1]);
>+    result[2][0] = pow(x[2][0], y[2][0]);
>+    result[2][1] = pow(x[2][1], y[2][1]);
>+    return result;
>+}
>+float3x3 pow(float3x3 x, float3x3 y) {
>+    float3x3 result;
>+    result[0][0] = pow(x[0][0], y[0][0]);
>+    result[0][1] = pow(x[0][1], y[0][1]);
>+    result[0][2] = pow(x[0][2], y[0][2]);
>+    result[1][0] = pow(x[1][0], y[1][0]);
>+    result[1][1] = pow(x[1][1], y[1][1]);
>+    result[1][2] = pow(x[1][2], y[1][2]);
>+    result[2][0] = pow(x[2][0], y[2][0]);
>+    result[2][1] = pow(x[2][1], y[2][1]);
>+    result[2][2] = pow(x[2][2], y[2][2]);
>+    return result;
>+}
>+float3x4 pow(float3x4 x, float3x4 y) {
>+    float3x4 result;
>+    result[0][0] = pow(x[0][0], y[0][0]);
>+    result[0][1] = pow(x[0][1], y[0][1]);
>+    result[0][2] = pow(x[0][2], y[0][2]);
>+    result[0][3] = pow(x[0][3], y[0][3]);
>+    result[1][0] = pow(x[1][0], y[1][0]);
>+    result[1][1] = pow(x[1][1], y[1][1]);
>+    result[1][2] = pow(x[1][2], y[1][2]);
>+    result[1][3] = pow(x[1][3], y[1][3]);
>+    result[2][0] = pow(x[2][0], y[2][0]);
>+    result[2][1] = pow(x[2][1], y[2][1]);
>+    result[2][2] = pow(x[2][2], y[2][2]);
>+    result[2][3] = pow(x[2][3], y[2][3]);
>+    return result;
>+}
>+float4x2 pow(float4x2 x, float4x2 y) {
>+    float4x2 result;
>+    result[0][0] = pow(x[0][0], y[0][0]);
>+    result[0][1] = pow(x[0][1], y[0][1]);
>+    result[1][0] = pow(x[1][0], y[1][0]);
>+    result[1][1] = pow(x[1][1], y[1][1]);
>+    result[2][0] = pow(x[2][0], y[2][0]);
>+    result[2][1] = pow(x[2][1], y[2][1]);
>+    result[3][0] = pow(x[3][0], y[3][0]);
>+    result[3][1] = pow(x[3][1], y[3][1]);
>+    return result;
>+}
>+float4x3 pow(float4x3 x, float4x3 y) {
>+    float4x3 result;
>+    result[0][0] = pow(x[0][0], y[0][0]);
>+    result[0][1] = pow(x[0][1], y[0][1]);
>+    result[0][2] = pow(x[0][2], y[0][2]);
>+    result[1][0] = pow(x[1][0], y[1][0]);
>+    result[1][1] = pow(x[1][1], y[1][1]);
>+    result[1][2] = pow(x[1][2], y[1][2]);
>+    result[2][0] = pow(x[2][0], y[2][0]);
>+    result[2][1] = pow(x[2][1], y[2][1]);
>+    result[2][2] = pow(x[2][2], y[2][2]);
>+    result[3][0] = pow(x[3][0], y[3][0]);
>+    result[3][1] = pow(x[3][1], y[3][1]);
>+    result[3][2] = pow(x[3][2], y[3][2]);
>+    return result;
>+}
>+float4x4 pow(float4x4 x, float4x4 y) {
>+    float4x4 result;
>+    result[0][0] = pow(x[0][0], y[0][0]);
>+    result[0][1] = pow(x[0][1], y[0][1]);
>+    result[0][2] = pow(x[0][2], y[0][2]);
>+    result[0][3] = pow(x[0][3], y[0][3]);
>+    result[1][0] = pow(x[1][0], y[1][0]);
>+    result[1][1] = pow(x[1][1], y[1][1]);
>+    result[1][2] = pow(x[1][2], y[1][2]);
>+    result[1][3] = pow(x[1][3], y[1][3]);
>+    result[2][0] = pow(x[2][0], y[2][0]);
>+    result[2][1] = pow(x[2][1], y[2][1]);
>+    result[2][2] = pow(x[2][2], y[2][2]);
>+    result[2][3] = pow(x[2][3], y[2][3]);
>+    result[3][0] = pow(x[3][0], y[3][0]);
>+    result[3][1] = pow(x[3][1], y[3][1]);
>+    result[3][2] = pow(x[3][2], y[3][2]);
>+    result[3][3] = pow(x[3][3], y[3][3]);
>+    return result;
>+}
>+
>+/* Functions named operator.zxxw */
>+bool4 operator.zxxw(bool4 v) {
>+    bool4 result;
>+    result.x = v.z;
>+    result.y = v.x;
>+    result.z = v.x;
>+    result.w = v.w;
>+    return result;
>+}
>+uchar4 operator.zxxw(uchar4 v) {
>+    uchar4 result;
>+    result.x = v.z;
>+    result.y = v.x;
>+    result.z = v.x;
>+    result.w = v.w;
>+    return result;
>+}
>+ushort4 operator.zxxw(ushort4 v) {
>+    ushort4 result;
>+    result.x = v.z;
>+    result.y = v.x;
>+    result.z = v.x;
>+    result.w = v.w;
>+    return result;
>+}
>+uint4 operator.zxxw(uint4 v) {
>+    uint4 result;
>+    result.x = v.z;
>+    result.y = v.x;
>+    result.z = v.x;
>+    result.w = v.w;
>+    return result;
>+}
>+char4 operator.zxxw(char4 v) {
>+    char4 result;
>+    result.x = v.z;
>+    result.y = v.x;
>+    result.z = v.x;
>+    result.w = v.w;
>+    return result;
>+}
>+short4 operator.zxxw(short4 v) {
>+    short4 result;
>+    result.x = v.z;
>+    result.y = v.x;
>+    result.z = v.x;
>+    result.w = v.w;
>+    return result;
>+}
>+int4 operator.zxxw(int4 v) {
>+    int4 result;
>+    result.x = v.z;
>+    result.y = v.x;
>+    result.z = v.x;
>+    result.w = v.w;
>+    return result;
>+}
>+half4 operator.zxxw(half4 v) {
>+    half4 result;
>+    result.x = v.z;
>+    result.y = v.x;
>+    result.z = v.x;
>+    result.w = v.w;
>+    return result;
>+}
>+float4 operator.zxxw(float4 v) {
>+    float4 result;
>+    result.x = v.z;
>+    result.y = v.x;
>+    result.z = v.x;
>+    result.w = v.w;
>+    return result;
>+}
>+
>+/* Functions named operator.xzzz */
>+bool4 operator.xzzz(bool3 v) {
>+    bool4 result;
>+    result.x = v.x;
>+    result.y = v.z;
>+    result.z = v.z;
>+    result.w = v.z;
>+    return result;
>+}
>+bool4 operator.xzzz(bool4 v) {
>+    bool4 result;
>+    result.x = v.x;
>+    result.y = v.z;
>+    result.z = v.z;
>+    result.w = v.z;
>+    return result;
>+}
>+uchar4 operator.xzzz(uchar3 v) {
>+    uchar4 result;
>+    result.x = v.x;
>+    result.y = v.z;
>+    result.z = v.z;
>+    result.w = v.z;
>+    return result;
>+}
>+uchar4 operator.xzzz(uchar4 v) {
>+    uchar4 result;
>+    result.x = v.x;
>+    result.y = v.z;
>+    result.z = v.z;
>+    result.w = v.z;
>+    return result;
>+}
>+ushort4 operator.xzzz(ushort3 v) {
>+    ushort4 result;
>+    result.x = v.x;
>+    result.y = v.z;
>+    result.z = v.z;
>+    result.w = v.z;
>+    return result;
>+}
>+ushort4 operator.xzzz(ushort4 v) {
>+    ushort4 result;
>+    result.x = v.x;
>+    result.y = v.z;
>+    result.z = v.z;
>+    result.w = v.z;
>+    return result;
>+}
>+uint4 operator.xzzz(uint3 v) {
>+    uint4 result;
>+    result.x = v.x;
>+    result.y = v.z;
>+    result.z = v.z;
>+    result.w = v.z;
>+    return result;
>+}
>+uint4 operator.xzzz(uint4 v) {
>+    uint4 result;
>+    result.x = v.x;
>+    result.y = v.z;
>+    result.z = v.z;
>+    result.w = v.z;
>+    return result;
>+}
>+char4 operator.xzzz(char3 v) {
>+    char4 result;
>+    result.x = v.x;
>+    result.y = v.z;
>+    result.z = v.z;
>+    result.w = v.z;
>+    return result;
>+}
>+char4 operator.xzzz(char4 v) {
>+    char4 result;
>+    result.x = v.x;
>+    result.y = v.z;
>+    result.z = v.z;
>+    result.w = v.z;
>+    return result;
>+}
>+short4 operator.xzzz(short3 v) {
>+    short4 result;
>+    result.x = v.x;
>+    result.y = v.z;
>+    result.z = v.z;
>+    result.w = v.z;
>+    return result;
>+}
>+short4 operator.xzzz(short4 v) {
>+    short4 result;
>+    result.x = v.x;
>+    result.y = v.z;
>+    result.z = v.z;
>+    result.w = v.z;
>+    return result;
>+}
>+int4 operator.xzzz(int3 v) {
>+    int4 result;
>+    result.x = v.x;
>+    result.y = v.z;
>+    result.z = v.z;
>+    result.w = v.z;
>+    return result;
>+}
>+int4 operator.xzzz(int4 v) {
>+    int4 result;
>+    result.x = v.x;
>+    result.y = v.z;
>+    result.z = v.z;
>+    result.w = v.z;
>+    return result;
>+}
>+half4 operator.xzzz(half3 v) {
>+    half4 result;
>+    result.x = v.x;
>+    result.y = v.z;
>+    result.z = v.z;
>+    result.w = v.z;
>+    return result;
>+}
>+half4 operator.xzzz(half4 v) {
>+    half4 result;
>+    result.x = v.x;
>+    result.y = v.z;
>+    result.z = v.z;
>+    result.w = v.z;
>+    return result;
>+}
>+float4 operator.xzzz(float3 v) {
>+    float4 result;
>+    result.x = v.x;
>+    result.y = v.z;
>+    result.z = v.z;
>+    result.w = v.z;
>+    return result;
>+}
>+float4 operator.xzzz(float4 v) {
>+    float4 result;
>+    result.x = v.x;
>+    result.y = v.z;
>+    result.z = v.z;
>+    result.w = v.z;
>+    return result;
>+}
>+
>+/* Functions named operator.zxy */
>+bool3 operator.zxy(bool3 v) {
>+    bool3 result;
>+    result.x = v.z;
>+    result.y = v.x;
>+    result.z = v.y;
>+    return result;
>+}
>+bool3 operator.zxy(bool4 v) {
>+    bool3 result;
>+    result.x = v.z;
>+    result.y = v.x;
>+    result.z = v.y;
>+    return result;
>+}
>+uchar3 operator.zxy(uchar3 v) {
>+    uchar3 result;
>+    result.x = v.z;
>+    result.y = v.x;
>+    result.z = v.y;
>+    return result;
>+}
>+uchar3 operator.zxy(uchar4 v) {
>+    uchar3 result;
>+    result.x = v.z;
>+    result.y = v.x;
>+    result.z = v.y;
>+    return result;
>+}
>+ushort3 operator.zxy(ushort3 v) {
>+    ushort3 result;
>+    result.x = v.z;
>+    result.y = v.x;
>+    result.z = v.y;
>+    return result;
>+}
>+ushort3 operator.zxy(ushort4 v) {
>+    ushort3 result;
>+    result.x = v.z;
>+    result.y = v.x;
>+    result.z = v.y;
>+    return result;
>+}
>+uint3 operator.zxy(uint3 v) {
>+    uint3 result;
>+    result.x = v.z;
>+    result.y = v.x;
>+    result.z = v.y;
>+    return result;
>+}
>+uint3 operator.zxy(uint4 v) {
>+    uint3 result;
>+    result.x = v.z;
>+    result.y = v.x;
>+    result.z = v.y;
>+    return result;
>+}
>+char3 operator.zxy(char3 v) {
>+    char3 result;
>+    result.x = v.z;
>+    result.y = v.x;
>+    result.z = v.y;
>+    return result;
>+}
>+char3 operator.zxy(char4 v) {
>+    char3 result;
>+    result.x = v.z;
>+    result.y = v.x;
>+    result.z = v.y;
>+    return result;
>+}
>+short3 operator.zxy(short3 v) {
>+    short3 result;
>+    result.x = v.z;
>+    result.y = v.x;
>+    result.z = v.y;
>+    return result;
>+}
>+short3 operator.zxy(short4 v) {
>+    short3 result;
>+    result.x = v.z;
>+    result.y = v.x;
>+    result.z = v.y;
>+    return result;
>+}
>+int3 operator.zxy(int3 v) {
>+    int3 result;
>+    result.x = v.z;
>+    result.y = v.x;
>+    result.z = v.y;
>+    return result;
>+}
>+int3 operator.zxy(int4 v) {
>+    int3 result;
>+    result.x = v.z;
>+    result.y = v.x;
>+    result.z = v.y;
>+    return result;
>+}
>+half3 operator.zxy(half3 v) {
>+    half3 result;
>+    result.x = v.z;
>+    result.y = v.x;
>+    result.z = v.y;
>+    return result;
>+}
>+half3 operator.zxy(half4 v) {
>+    half3 result;
>+    result.x = v.z;
>+    result.y = v.x;
>+    result.z = v.y;
>+    return result;
>+}
>+float3 operator.zxy(float3 v) {
>+    float3 result;
>+    result.x = v.z;
>+    result.y = v.x;
>+    result.z = v.y;
>+    return result;
>+}
>+float3 operator.zxy(float4 v) {
>+    float3 result;
>+    result.x = v.z;
>+    result.y = v.x;
>+    result.z = v.y;
>+    return result;
>+}
>+
>+/* Functions named operator.wxyy */
>+bool4 operator.wxyy(bool4 v) {
>+    bool4 result;
>+    result.x = v.w;
>+    result.y = v.x;
>+    result.z = v.y;
>+    result.w = v.y;
>+    return result;
>+}
>+uchar4 operator.wxyy(uchar4 v) {
>+    uchar4 result;
>+    result.x = v.w;
>+    result.y = v.x;
>+    result.z = v.y;
>+    result.w = v.y;
>+    return result;
>+}
>+ushort4 operator.wxyy(ushort4 v) {
>+    ushort4 result;
>+    result.x = v.w;
>+    result.y = v.x;
>+    result.z = v.y;
>+    result.w = v.y;
>+    return result;
>+}
>+uint4 operator.wxyy(uint4 v) {
>+    uint4 result;
>+    result.x = v.w;
>+    result.y = v.x;
>+    result.z = v.y;
>+    result.w = v.y;
>+    return result;
>+}
>+char4 operator.wxyy(char4 v) {
>+    char4 result;
>+    result.x = v.w;
>+    result.y = v.x;
>+    result.z = v.y;
>+    result.w = v.y;
>+    return result;
>+}
>+short4 operator.wxyy(short4 v) {
>+    short4 result;
>+    result.x = v.w;
>+    result.y = v.x;
>+    result.z = v.y;
>+    result.w = v.y;
>+    return result;
>+}
>+int4 operator.wxyy(int4 v) {
>+    int4 result;
>+    result.x = v.w;
>+    result.y = v.x;
>+    result.z = v.y;
>+    result.w = v.y;
>+    return result;
>+}
>+half4 operator.wxyy(half4 v) {
>+    half4 result;
>+    result.x = v.w;
>+    result.y = v.x;
>+    result.z = v.y;
>+    result.w = v.y;
>+    return result;
>+}
>+float4 operator.wxyy(float4 v) {
>+    float4 result;
>+    result.x = v.w;
>+    result.y = v.x;
>+    result.z = v.y;
>+    result.w = v.y;
>+    return result;
>+}
>+
>+/* Functions named operator.zyzx */
>+bool4 operator.zyzx(bool3 v) {
>+    bool4 result;
>+    result.x = v.z;
>+    result.y = v.y;
>+    result.z = v.z;
>+    result.w = v.x;
>+    return result;
>+}
>+bool4 operator.zyzx(bool4 v) {
>+    bool4 result;
>+    result.x = v.z;
>+    result.y = v.y;
>+    result.z = v.z;
>+    result.w = v.x;
>+    return result;
>+}
>+uchar4 operator.zyzx(uchar3 v) {
>+    uchar4 result;
>+    result.x = v.z;
>+    result.y = v.y;
>+    result.z = v.z;
>+    result.w = v.x;
>+    return result;
>+}
>+uchar4 operator.zyzx(uchar4 v) {
>+    uchar4 result;
>+    result.x = v.z;
>+    result.y = v.y;
>+    result.z = v.z;
>+    result.w = v.x;
>+    return result;
>+}
>+ushort4 operator.zyzx(ushort3 v) {
>+    ushort4 result;
>+    result.x = v.z;
>+    result.y = v.y;
>+    result.z = v.z;
>+    result.w = v.x;
>+    return result;
>+}
>+ushort4 operator.zyzx(ushort4 v) {
>+    ushort4 result;
>+    result.x = v.z;
>+    result.y = v.y;
>+    result.z = v.z;
>+    result.w = v.x;
>+    return result;
>+}
>+uint4 operator.zyzx(uint3 v) {
>+    uint4 result;
>+    result.x = v.z;
>+    result.y = v.y;
>+    result.z = v.z;
>+    result.w = v.x;
>+    return result;
>+}
>+uint4 operator.zyzx(uint4 v) {
>+    uint4 result;
>+    result.x = v.z;
>+    result.y = v.y;
>+    result.z = v.z;
>+    result.w = v.x;
>+    return result;
>+}
>+char4 operator.zyzx(char3 v) {
>+    char4 result;
>+    result.x = v.z;
>+    result.y = v.y;
>+    result.z = v.z;
>+    result.w = v.x;
>+    return result;
>+}
>+char4 operator.zyzx(char4 v) {
>+    char4 result;
>+    result.x = v.z;
>+    result.y = v.y;
>+    result.z = v.z;
>+    result.w = v.x;
>+    return result;
>+}
>+short4 operator.zyzx(short3 v) {
>+    short4 result;
>+    result.x = v.z;
>+    result.y = v.y;
>+    result.z = v.z;
>+    result.w = v.x;
>+    return result;
>+}
>+short4 operator.zyzx(short4 v) {
>+    short4 result;
>+    result.x = v.z;
>+    result.y = v.y;
>+    result.z = v.z;
>+    result.w = v.x;
>+    return result;
>+}
>+int4 operator.zyzx(int3 v) {
>+    int4 result;
>+    result.x = v.z;
>+    result.y = v.y;
>+    result.z = v.z;
>+    result.w = v.x;
>+    return result;
>+}
>+int4 operator.zyzx(int4 v) {
>+    int4 result;
>+    result.x = v.z;
>+    result.y = v.y;
>+    result.z = v.z;
>+    result.w = v.x;
>+    return result;
>+}
>+half4 operator.zyzx(half3 v) {
>+    half4 result;
>+    result.x = v.z;
>+    result.y = v.y;
>+    result.z = v.z;
>+    result.w = v.x;
>+    return result;
>+}
>+half4 operator.zyzx(half4 v) {
>+    half4 result;
>+    result.x = v.z;
>+    result.y = v.y;
>+    result.z = v.z;
>+    result.w = v.x;
>+    return result;
>+}
>+float4 operator.zyzx(float3 v) {
>+    float4 result;
>+    result.x = v.z;
>+    result.y = v.y;
>+    result.z = v.z;
>+    result.w = v.x;
>+    return result;
>+}
>+float4 operator.zyzx(float4 v) {
>+    float4 result;
>+    result.x = v.z;
>+    result.y = v.y;
>+    result.z = v.z;
>+    result.w = v.x;
>+    return result;
>+}
>+
>+/* Functions named operator.xzxw */
>+bool4 operator.xzxw(bool4 v) {
>+    bool4 result;
>+    result.x = v.x;
>+    result.y = v.z;
>+    result.z = v.x;
>+    result.w = v.w;
>+    return result;
>+}
>+uchar4 operator.xzxw(uchar4 v) {
>+    uchar4 result;
>+    result.x = v.x;
>+    result.y = v.z;
>+    result.z = v.x;
>+    result.w = v.w;
>+    return result;
>+}
>+ushort4 operator.xzxw(ushort4 v) {
>+    ushort4 result;
>+    result.x = v.x;
>+    result.y = v.z;
>+    result.z = v.x;
>+    result.w = v.w;
>+    return result;
>+}
>+uint4 operator.xzxw(uint4 v) {
>+    uint4 result;
>+    result.x = v.x;
>+    result.y = v.z;
>+    result.z = v.x;
>+    result.w = v.w;
>+    return result;
>+}
>+char4 operator.xzxw(char4 v) {
>+    char4 result;
>+    result.x = v.x;
>+    result.y = v.z;
>+    result.z = v.x;
>+    result.w = v.w;
>+    return result;
>+}
>+short4 operator.xzxw(short4 v) {
>+    short4 result;
>+    result.x = v.x;
>+    result.y = v.z;
>+    result.z = v.x;
>+    result.w = v.w;
>+    return result;
>+}
>+int4 operator.xzxw(int4 v) {
>+    int4 result;
>+    result.x = v.x;
>+    result.y = v.z;
>+    result.z = v.x;
>+    result.w = v.w;
>+    return result;
>+}
>+half4 operator.xzxw(half4 v) {
>+    half4 result;
>+    result.x = v.x;
>+    result.y = v.z;
>+    result.z = v.x;
>+    result.w = v.w;
>+    return result;
>+}
>+float4 operator.xzxw(float4 v) {
>+    float4 result;
>+    result.x = v.x;
>+    result.y = v.z;
>+    result.z = v.x;
>+    result.w = v.w;
>+    return result;
>+}
>+
>+/* Functions named operator.xzw= */
>+bool4 operator.xzw=(bool4 v, bool3 c) {
>+    bool4 result = v;
>+    result.x = c.x;
>+    result.z = c.y;
>+    result.w = c.z;
>+    return result;
>+}
>+uchar4 operator.xzw=(uchar4 v, uchar3 c) {
>+    uchar4 result = v;
>+    result.x = c.x;
>+    result.z = c.y;
>+    result.w = c.z;
>+    return result;
>+}
>+ushort4 operator.xzw=(ushort4 v, ushort3 c) {
>+    ushort4 result = v;
>+    result.x = c.x;
>+    result.z = c.y;
>+    result.w = c.z;
>+    return result;
>+}
>+uint4 operator.xzw=(uint4 v, uint3 c) {
>+    uint4 result = v;
>+    result.x = c.x;
>+    result.z = c.y;
>+    result.w = c.z;
>+    return result;
>+}
>+char4 operator.xzw=(char4 v, char3 c) {
>+    char4 result = v;
>+    result.x = c.x;
>+    result.z = c.y;
>+    result.w = c.z;
>+    return result;
>+}
>+short4 operator.xzw=(short4 v, short3 c) {
>+    short4 result = v;
>+    result.x = c.x;
>+    result.z = c.y;
>+    result.w = c.z;
>+    return result;
>+}
>+int4 operator.xzw=(int4 v, int3 c) {
>+    int4 result = v;
>+    result.x = c.x;
>+    result.z = c.y;
>+    result.w = c.z;
>+    return result;
>+}
>+half4 operator.xzw=(half4 v, half3 c) {
>+    half4 result = v;
>+    result.x = c.x;
>+    result.z = c.y;
>+    result.w = c.z;
>+    return result;
>+}
>+float4 operator.xzw=(float4 v, float3 c) {
>+    float4 result = v;
>+    result.x = c.x;
>+    result.z = c.y;
>+    result.w = c.z;
>+    return result;
>+}
>+
>+/* Functions named tan */
>+native float tan(float);
>+half tan(half x) {
>+    return half(tan(float(x)));
>+}
>+half2 tan(half2 x) {
>+    half2 result;
>+    result[0] = tan(x[0]);
>+    result[1] = tan(x[1]);
>+    return result;
>+}
>+half3 tan(half3 x) {
>+    half3 result;
>+    result[0] = tan(x[0]);
>+    result[1] = tan(x[1]);
>+    result[2] = tan(x[2]);
>+    return result;
>+}
>+half4 tan(half4 x) {
>+    half4 result;
>+    result[0] = tan(x[0]);
>+    result[1] = tan(x[1]);
>+    result[2] = tan(x[2]);
>+    result[3] = tan(x[3]);
>+    return result;
>+}
>+half2x2 tan(half2x2 x) {
>+    half2x2 result;
>+    result[0][0] = tan(x[0][0]);
>+    result[0][1] = tan(x[0][1]);
>+    result[1][0] = tan(x[1][0]);
>+    result[1][1] = tan(x[1][1]);
>+    return result;
>+}
>+half2x3 tan(half2x3 x) {
>+    half2x3 result;
>+    result[0][0] = tan(x[0][0]);
>+    result[0][1] = tan(x[0][1]);
>+    result[0][2] = tan(x[0][2]);
>+    result[1][0] = tan(x[1][0]);
>+    result[1][1] = tan(x[1][1]);
>+    result[1][2] = tan(x[1][2]);
>+    return result;
>+}
>+half2x4 tan(half2x4 x) {
>+    half2x4 result;
>+    result[0][0] = tan(x[0][0]);
>+    result[0][1] = tan(x[0][1]);
>+    result[0][2] = tan(x[0][2]);
>+    result[0][3] = tan(x[0][3]);
>+    result[1][0] = tan(x[1][0]);
>+    result[1][1] = tan(x[1][1]);
>+    result[1][2] = tan(x[1][2]);
>+    result[1][3] = tan(x[1][3]);
>+    return result;
>+}
>+half3x2 tan(half3x2 x) {
>+    half3x2 result;
>+    result[0][0] = tan(x[0][0]);
>+    result[0][1] = tan(x[0][1]);
>+    result[1][0] = tan(x[1][0]);
>+    result[1][1] = tan(x[1][1]);
>+    result[2][0] = tan(x[2][0]);
>+    result[2][1] = tan(x[2][1]);
>+    return result;
>+}
>+half3x3 tan(half3x3 x) {
>+    half3x3 result;
>+    result[0][0] = tan(x[0][0]);
>+    result[0][1] = tan(x[0][1]);
>+    result[0][2] = tan(x[0][2]);
>+    result[1][0] = tan(x[1][0]);
>+    result[1][1] = tan(x[1][1]);
>+    result[1][2] = tan(x[1][2]);
>+    result[2][0] = tan(x[2][0]);
>+    result[2][1] = tan(x[2][1]);
>+    result[2][2] = tan(x[2][2]);
>+    return result;
>+}
>+half3x4 tan(half3x4 x) {
>+    half3x4 result;
>+    result[0][0] = tan(x[0][0]);
>+    result[0][1] = tan(x[0][1]);
>+    result[0][2] = tan(x[0][2]);
>+    result[0][3] = tan(x[0][3]);
>+    result[1][0] = tan(x[1][0]);
>+    result[1][1] = tan(x[1][1]);
>+    result[1][2] = tan(x[1][2]);
>+    result[1][3] = tan(x[1][3]);
>+    result[2][0] = tan(x[2][0]);
>+    result[2][1] = tan(x[2][1]);
>+    result[2][2] = tan(x[2][2]);
>+    result[2][3] = tan(x[2][3]);
>+    return result;
>+}
>+half4x2 tan(half4x2 x) {
>+    half4x2 result;
>+    result[0][0] = tan(x[0][0]);
>+    result[0][1] = tan(x[0][1]);
>+    result[1][0] = tan(x[1][0]);
>+    result[1][1] = tan(x[1][1]);
>+    result[2][0] = tan(x[2][0]);
>+    result[2][1] = tan(x[2][1]);
>+    result[3][0] = tan(x[3][0]);
>+    result[3][1] = tan(x[3][1]);
>+    return result;
>+}
>+half4x3 tan(half4x3 x) {
>+    half4x3 result;
>+    result[0][0] = tan(x[0][0]);
>+    result[0][1] = tan(x[0][1]);
>+    result[0][2] = tan(x[0][2]);
>+    result[1][0] = tan(x[1][0]);
>+    result[1][1] = tan(x[1][1]);
>+    result[1][2] = tan(x[1][2]);
>+    result[2][0] = tan(x[2][0]);
>+    result[2][1] = tan(x[2][1]);
>+    result[2][2] = tan(x[2][2]);
>+    result[3][0] = tan(x[3][0]);
>+    result[3][1] = tan(x[3][1]);
>+    result[3][2] = tan(x[3][2]);
>+    return result;
>+}
>+half4x4 tan(half4x4 x) {
>+    half4x4 result;
>+    result[0][0] = tan(x[0][0]);
>+    result[0][1] = tan(x[0][1]);
>+    result[0][2] = tan(x[0][2]);
>+    result[0][3] = tan(x[0][3]);
>+    result[1][0] = tan(x[1][0]);
>+    result[1][1] = tan(x[1][1]);
>+    result[1][2] = tan(x[1][2]);
>+    result[1][3] = tan(x[1][3]);
>+    result[2][0] = tan(x[2][0]);
>+    result[2][1] = tan(x[2][1]);
>+    result[2][2] = tan(x[2][2]);
>+    result[2][3] = tan(x[2][3]);
>+    result[3][0] = tan(x[3][0]);
>+    result[3][1] = tan(x[3][1]);
>+    result[3][2] = tan(x[3][2]);
>+    result[3][3] = tan(x[3][3]);
>+    return result;
>+}
>+float2 tan(float2 x) {
>+    float2 result;
>+    result[0] = tan(x[0]);
>+    result[1] = tan(x[1]);
>+    return result;
>+}
>+float3 tan(float3 x) {
>+    float3 result;
>+    result[0] = tan(x[0]);
>+    result[1] = tan(x[1]);
>+    result[2] = tan(x[2]);
>+    return result;
>+}
>+float4 tan(float4 x) {
>+    float4 result;
>+    result[0] = tan(x[0]);
>+    result[1] = tan(x[1]);
>+    result[2] = tan(x[2]);
>+    result[3] = tan(x[3]);
>+    return result;
>+}
>+float2x2 tan(float2x2 x) {
>+    float2x2 result;
>+    result[0][0] = tan(x[0][0]);
>+    result[0][1] = tan(x[0][1]);
>+    result[1][0] = tan(x[1][0]);
>+    result[1][1] = tan(x[1][1]);
>+    return result;
>+}
>+float2x3 tan(float2x3 x) {
>+    float2x3 result;
>+    result[0][0] = tan(x[0][0]);
>+    result[0][1] = tan(x[0][1]);
>+    result[0][2] = tan(x[0][2]);
>+    result[1][0] = tan(x[1][0]);
>+    result[1][1] = tan(x[1][1]);
>+    result[1][2] = tan(x[1][2]);
>+    return result;
>+}
>+float2x4 tan(float2x4 x) {
>+    float2x4 result;
>+    result[0][0] = tan(x[0][0]);
>+    result[0][1] = tan(x[0][1]);
>+    result[0][2] = tan(x[0][2]);
>+    result[0][3] = tan(x[0][3]);
>+    result[1][0] = tan(x[1][0]);
>+    result[1][1] = tan(x[1][1]);
>+    result[1][2] = tan(x[1][2]);
>+    result[1][3] = tan(x[1][3]);
>+    return result;
>+}
>+float3x2 tan(float3x2 x) {
>+    float3x2 result;
>+    result[0][0] = tan(x[0][0]);
>+    result[0][1] = tan(x[0][1]);
>+    result[1][0] = tan(x[1][0]);
>+    result[1][1] = tan(x[1][1]);
>+    result[2][0] = tan(x[2][0]);
>+    result[2][1] = tan(x[2][1]);
>+    return result;
>+}
>+float3x3 tan(float3x3 x) {
>+    float3x3 result;
>+    result[0][0] = tan(x[0][0]);
>+    result[0][1] = tan(x[0][1]);
>+    result[0][2] = tan(x[0][2]);
>+    result[1][0] = tan(x[1][0]);
>+    result[1][1] = tan(x[1][1]);
>+    result[1][2] = tan(x[1][2]);
>+    result[2][0] = tan(x[2][0]);
>+    result[2][1] = tan(x[2][1]);
>+    result[2][2] = tan(x[2][2]);
>+    return result;
>+}
>+float3x4 tan(float3x4 x) {
>+    float3x4 result;
>+    result[0][0] = tan(x[0][0]);
>+    result[0][1] = tan(x[0][1]);
>+    result[0][2] = tan(x[0][2]);
>+    result[0][3] = tan(x[0][3]);
>+    result[1][0] = tan(x[1][0]);
>+    result[1][1] = tan(x[1][1]);
>+    result[1][2] = tan(x[1][2]);
>+    result[1][3] = tan(x[1][3]);
>+    result[2][0] = tan(x[2][0]);
>+    result[2][1] = tan(x[2][1]);
>+    result[2][2] = tan(x[2][2]);
>+    result[2][3] = tan(x[2][3]);
>+    return result;
>+}
>+float4x2 tan(float4x2 x) {
>+    float4x2 result;
>+    result[0][0] = tan(x[0][0]);
>+    result[0][1] = tan(x[0][1]);
>+    result[1][0] = tan(x[1][0]);
>+    result[1][1] = tan(x[1][1]);
>+    result[2][0] = tan(x[2][0]);
>+    result[2][1] = tan(x[2][1]);
>+    result[3][0] = tan(x[3][0]);
>+    result[3][1] = tan(x[3][1]);
>+    return result;
>+}
>+float4x3 tan(float4x3 x) {
>+    float4x3 result;
>+    result[0][0] = tan(x[0][0]);
>+    result[0][1] = tan(x[0][1]);
>+    result[0][2] = tan(x[0][2]);
>+    result[1][0] = tan(x[1][0]);
>+    result[1][1] = tan(x[1][1]);
>+    result[1][2] = tan(x[1][2]);
>+    result[2][0] = tan(x[2][0]);
>+    result[2][1] = tan(x[2][1]);
>+    result[2][2] = tan(x[2][2]);
>+    result[3][0] = tan(x[3][0]);
>+    result[3][1] = tan(x[3][1]);
>+    result[3][2] = tan(x[3][2]);
>+    return result;
>+}
>+float4x4 tan(float4x4 x) {
>+    float4x4 result;
>+    result[0][0] = tan(x[0][0]);
>+    result[0][1] = tan(x[0][1]);
>+    result[0][2] = tan(x[0][2]);
>+    result[0][3] = tan(x[0][3]);
>+    result[1][0] = tan(x[1][0]);
>+    result[1][1] = tan(x[1][1]);
>+    result[1][2] = tan(x[1][2]);
>+    result[1][3] = tan(x[1][3]);
>+    result[2][0] = tan(x[2][0]);
>+    result[2][1] = tan(x[2][1]);
>+    result[2][2] = tan(x[2][2]);
>+    result[2][3] = tan(x[2][3]);
>+    result[3][0] = tan(x[3][0]);
>+    result[3][1] = tan(x[3][1]);
>+    result[3][2] = tan(x[3][2]);
>+    result[3][3] = tan(x[3][3]);
>+    return result;
>+}
>+
>+/* Functions named fma */
>+half fma(half x, half y, half z) {
>+    return x * y + z;
>+}
>+half2 fma(half2 x, half2 y, half2 z) {
>+    half2 result;
>+    result[0] = fma(x[0], y[0], z[0]);
>+    result[1] = fma(x[1], y[1], z[1]);
>+    return result;
>+}
>+half3 fma(half3 x, half3 y, half3 z) {
>+    half3 result;
>+    result[0] = fma(x[0], y[0], z[0]);
>+    result[1] = fma(x[1], y[1], z[1]);
>+    result[2] = fma(x[2], y[2], z[2]);
>+    return result;
>+}
>+half4 fma(half4 x, half4 y, half4 z) {
>+    half4 result;
>+    result[0] = fma(x[0], y[0], z[0]);
>+    result[1] = fma(x[1], y[1], z[1]);
>+    result[2] = fma(x[2], y[2], z[2]);
>+    result[3] = fma(x[3], y[3], z[3]);
>+    return result;
>+}
>+half2x2 fma(half2x2 x, half2x2 y, half2x2 z) {
>+    half2x2 result;
>+    result[0][0] = fma(x[0][0], y[0][0], z[0][0]);
>+    result[0][1] = fma(x[0][1], y[0][1], z[0][1]);
>+    result[1][0] = fma(x[1][0], y[1][0], z[1][0]);
>+    result[1][1] = fma(x[1][1], y[1][1], z[1][1]);
>+    return result;
>+}
>+half2x3 fma(half2x3 x, half2x3 y, half2x3 z) {
>+    half2x3 result;
>+    result[0][0] = fma(x[0][0], y[0][0], z[0][0]);
>+    result[0][1] = fma(x[0][1], y[0][1], z[0][1]);
>+    result[0][2] = fma(x[0][2], y[0][2], z[0][2]);
>+    result[1][0] = fma(x[1][0], y[1][0], z[1][0]);
>+    result[1][1] = fma(x[1][1], y[1][1], z[1][1]);
>+    result[1][2] = fma(x[1][2], y[1][2], z[1][2]);
>+    return result;
>+}
>+half2x4 fma(half2x4 x, half2x4 y, half2x4 z) {
>+    half2x4 result;
>+    result[0][0] = fma(x[0][0], y[0][0], z[0][0]);
>+    result[0][1] = fma(x[0][1], y[0][1], z[0][1]);
>+    result[0][2] = fma(x[0][2], y[0][2], z[0][2]);
>+    result[0][3] = fma(x[0][3], y[0][3], z[0][3]);
>+    result[1][0] = fma(x[1][0], y[1][0], z[1][0]);
>+    result[1][1] = fma(x[1][1], y[1][1], z[1][1]);
>+    result[1][2] = fma(x[1][2], y[1][2], z[1][2]);
>+    result[1][3] = fma(x[1][3], y[1][3], z[1][3]);
>+    return result;
>+}
>+half3x2 fma(half3x2 x, half3x2 y, half3x2 z) {
>+    half3x2 result;
>+    result[0][0] = fma(x[0][0], y[0][0], z[0][0]);
>+    result[0][1] = fma(x[0][1], y[0][1], z[0][1]);
>+    result[1][0] = fma(x[1][0], y[1][0], z[1][0]);
>+    result[1][1] = fma(x[1][1], y[1][1], z[1][1]);
>+    result[2][0] = fma(x[2][0], y[2][0], z[2][0]);
>+    result[2][1] = fma(x[2][1], y[2][1], z[2][1]);
>+    return result;
>+}
>+half3x3 fma(half3x3 x, half3x3 y, half3x3 z) {
>+    half3x3 result;
>+    result[0][0] = fma(x[0][0], y[0][0], z[0][0]);
>+    result[0][1] = fma(x[0][1], y[0][1], z[0][1]);
>+    result[0][2] = fma(x[0][2], y[0][2], z[0][2]);
>+    result[1][0] = fma(x[1][0], y[1][0], z[1][0]);
>+    result[1][1] = fma(x[1][1], y[1][1], z[1][1]);
>+    result[1][2] = fma(x[1][2], y[1][2], z[1][2]);
>+    result[2][0] = fma(x[2][0], y[2][0], z[2][0]);
>+    result[2][1] = fma(x[2][1], y[2][1], z[2][1]);
>+    result[2][2] = fma(x[2][2], y[2][2], z[2][2]);
>+    return result;
>+}
>+half3x4 fma(half3x4 x, half3x4 y, half3x4 z) {
>+    half3x4 result;
>+    result[0][0] = fma(x[0][0], y[0][0], z[0][0]);
>+    result[0][1] = fma(x[0][1], y[0][1], z[0][1]);
>+    result[0][2] = fma(x[0][2], y[0][2], z[0][2]);
>+    result[0][3] = fma(x[0][3], y[0][3], z[0][3]);
>+    result[1][0] = fma(x[1][0], y[1][0], z[1][0]);
>+    result[1][1] = fma(x[1][1], y[1][1], z[1][1]);
>+    result[1][2] = fma(x[1][2], y[1][2], z[1][2]);
>+    result[1][3] = fma(x[1][3], y[1][3], z[1][3]);
>+    result[2][0] = fma(x[2][0], y[2][0], z[2][0]);
>+    result[2][1] = fma(x[2][1], y[2][1], z[2][1]);
>+    result[2][2] = fma(x[2][2], y[2][2], z[2][2]);
>+    result[2][3] = fma(x[2][3], y[2][3], z[2][3]);
>+    return result;
>+}
>+half4x2 fma(half4x2 x, half4x2 y, half4x2 z) {
>+    half4x2 result;
>+    result[0][0] = fma(x[0][0], y[0][0], z[0][0]);
>+    result[0][1] = fma(x[0][1], y[0][1], z[0][1]);
>+    result[1][0] = fma(x[1][0], y[1][0], z[1][0]);
>+    result[1][1] = fma(x[1][1], y[1][1], z[1][1]);
>+    result[2][0] = fma(x[2][0], y[2][0], z[2][0]);
>+    result[2][1] = fma(x[2][1], y[2][1], z[2][1]);
>+    result[3][0] = fma(x[3][0], y[3][0], z[3][0]);
>+    result[3][1] = fma(x[3][1], y[3][1], z[3][1]);
>+    return result;
>+}
>+half4x3 fma(half4x3 x, half4x3 y, half4x3 z) {
>+    half4x3 result;
>+    result[0][0] = fma(x[0][0], y[0][0], z[0][0]);
>+    result[0][1] = fma(x[0][1], y[0][1], z[0][1]);
>+    result[0][2] = fma(x[0][2], y[0][2], z[0][2]);
>+    result[1][0] = fma(x[1][0], y[1][0], z[1][0]);
>+    result[1][1] = fma(x[1][1], y[1][1], z[1][1]);
>+    result[1][2] = fma(x[1][2], y[1][2], z[1][2]);
>+    result[2][0] = fma(x[2][0], y[2][0], z[2][0]);
>+    result[2][1] = fma(x[2][1], y[2][1], z[2][1]);
>+    result[2][2] = fma(x[2][2], y[2][2], z[2][2]);
>+    result[3][0] = fma(x[3][0], y[3][0], z[3][0]);
>+    result[3][1] = fma(x[3][1], y[3][1], z[3][1]);
>+    result[3][2] = fma(x[3][2], y[3][2], z[3][2]);
>+    return result;
>+}
>+half4x4 fma(half4x4 x, half4x4 y, half4x4 z) {
>+    half4x4 result;
>+    result[0][0] = fma(x[0][0], y[0][0], z[0][0]);
>+    result[0][1] = fma(x[0][1], y[0][1], z[0][1]);
>+    result[0][2] = fma(x[0][2], y[0][2], z[0][2]);
>+    result[0][3] = fma(x[0][3], y[0][3], z[0][3]);
>+    result[1][0] = fma(x[1][0], y[1][0], z[1][0]);
>+    result[1][1] = fma(x[1][1], y[1][1], z[1][1]);
>+    result[1][2] = fma(x[1][2], y[1][2], z[1][2]);
>+    result[1][3] = fma(x[1][3], y[1][3], z[1][3]);
>+    result[2][0] = fma(x[2][0], y[2][0], z[2][0]);
>+    result[2][1] = fma(x[2][1], y[2][1], z[2][1]);
>+    result[2][2] = fma(x[2][2], y[2][2], z[2][2]);
>+    result[2][3] = fma(x[2][3], y[2][3], z[2][3]);
>+    result[3][0] = fma(x[3][0], y[3][0], z[3][0]);
>+    result[3][1] = fma(x[3][1], y[3][1], z[3][1]);
>+    result[3][2] = fma(x[3][2], y[3][2], z[3][2]);
>+    result[3][3] = fma(x[3][3], y[3][3], z[3][3]);
>+    return result;
>+}
>+float fma(float x, float y, float z) {
>+    return x * y + z;
>+}
>+float2 fma(float2 x, float2 y, float2 z) {
>+    float2 result;
>+    result[0] = fma(x[0], y[0], z[0]);
>+    result[1] = fma(x[1], y[1], z[1]);
>+    return result;
>+}
>+float3 fma(float3 x, float3 y, float3 z) {
>+    float3 result;
>+    result[0] = fma(x[0], y[0], z[0]);
>+    result[1] = fma(x[1], y[1], z[1]);
>+    result[2] = fma(x[2], y[2], z[2]);
>+    return result;
>+}
>+float4 fma(float4 x, float4 y, float4 z) {
>+    float4 result;
>+    result[0] = fma(x[0], y[0], z[0]);
>+    result[1] = fma(x[1], y[1], z[1]);
>+    result[2] = fma(x[2], y[2], z[2]);
>+    result[3] = fma(x[3], y[3], z[3]);
>+    return result;
>+}
>+float2x2 fma(float2x2 x, float2x2 y, float2x2 z) {
>+    float2x2 result;
>+    result[0][0] = fma(x[0][0], y[0][0], z[0][0]);
>+    result[0][1] = fma(x[0][1], y[0][1], z[0][1]);
>+    result[1][0] = fma(x[1][0], y[1][0], z[1][0]);
>+    result[1][1] = fma(x[1][1], y[1][1], z[1][1]);
>+    return result;
>+}
>+float2x3 fma(float2x3 x, float2x3 y, float2x3 z) {
>+    float2x3 result;
>+    result[0][0] = fma(x[0][0], y[0][0], z[0][0]);
>+    result[0][1] = fma(x[0][1], y[0][1], z[0][1]);
>+    result[0][2] = fma(x[0][2], y[0][2], z[0][2]);
>+    result[1][0] = fma(x[1][0], y[1][0], z[1][0]);
>+    result[1][1] = fma(x[1][1], y[1][1], z[1][1]);
>+    result[1][2] = fma(x[1][2], y[1][2], z[1][2]);
>+    return result;
>+}
>+float2x4 fma(float2x4 x, float2x4 y, float2x4 z) {
>+    float2x4 result;
>+    result[0][0] = fma(x[0][0], y[0][0], z[0][0]);
>+    result[0][1] = fma(x[0][1], y[0][1], z[0][1]);
>+    result[0][2] = fma(x[0][2], y[0][2], z[0][2]);
>+    result[0][3] = fma(x[0][3], y[0][3], z[0][3]);
>+    result[1][0] = fma(x[1][0], y[1][0], z[1][0]);
>+    result[1][1] = fma(x[1][1], y[1][1], z[1][1]);
>+    result[1][2] = fma(x[1][2], y[1][2], z[1][2]);
>+    result[1][3] = fma(x[1][3], y[1][3], z[1][3]);
>+    return result;
>+}
>+float3x2 fma(float3x2 x, float3x2 y, float3x2 z) {
>+    float3x2 result;
>+    result[0][0] = fma(x[0][0], y[0][0], z[0][0]);
>+    result[0][1] = fma(x[0][1], y[0][1], z[0][1]);
>+    result[1][0] = fma(x[1][0], y[1][0], z[1][0]);
>+    result[1][1] = fma(x[1][1], y[1][1], z[1][1]);
>+    result[2][0] = fma(x[2][0], y[2][0], z[2][0]);
>+    result[2][1] = fma(x[2][1], y[2][1], z[2][1]);
>+    return result;
>+}
>+float3x3 fma(float3x3 x, float3x3 y, float3x3 z) {
>+    float3x3 result;
>+    result[0][0] = fma(x[0][0], y[0][0], z[0][0]);
>+    result[0][1] = fma(x[0][1], y[0][1], z[0][1]);
>+    result[0][2] = fma(x[0][2], y[0][2], z[0][2]);
>+    result[1][0] = fma(x[1][0], y[1][0], z[1][0]);
>+    result[1][1] = fma(x[1][1], y[1][1], z[1][1]);
>+    result[1][2] = fma(x[1][2], y[1][2], z[1][2]);
>+    result[2][0] = fma(x[2][0], y[2][0], z[2][0]);
>+    result[2][1] = fma(x[2][1], y[2][1], z[2][1]);
>+    result[2][2] = fma(x[2][2], y[2][2], z[2][2]);
>+    return result;
>+}
>+float3x4 fma(float3x4 x, float3x4 y, float3x4 z) {
>+    float3x4 result;
>+    result[0][0] = fma(x[0][0], y[0][0], z[0][0]);
>+    result[0][1] = fma(x[0][1], y[0][1], z[0][1]);
>+    result[0][2] = fma(x[0][2], y[0][2], z[0][2]);
>+    result[0][3] = fma(x[0][3], y[0][3], z[0][3]);
>+    result[1][0] = fma(x[1][0], y[1][0], z[1][0]);
>+    result[1][1] = fma(x[1][1], y[1][1], z[1][1]);
>+    result[1][2] = fma(x[1][2], y[1][2], z[1][2]);
>+    result[1][3] = fma(x[1][3], y[1][3], z[1][3]);
>+    result[2][0] = fma(x[2][0], y[2][0], z[2][0]);
>+    result[2][1] = fma(x[2][1], y[2][1], z[2][1]);
>+    result[2][2] = fma(x[2][2], y[2][2], z[2][2]);
>+    result[2][3] = fma(x[2][3], y[2][3], z[2][3]);
>+    return result;
>+}
>+float4x2 fma(float4x2 x, float4x2 y, float4x2 z) {
>+    float4x2 result;
>+    result[0][0] = fma(x[0][0], y[0][0], z[0][0]);
>+    result[0][1] = fma(x[0][1], y[0][1], z[0][1]);
>+    result[1][0] = fma(x[1][0], y[1][0], z[1][0]);
>+    result[1][1] = fma(x[1][1], y[1][1], z[1][1]);
>+    result[2][0] = fma(x[2][0], y[2][0], z[2][0]);
>+    result[2][1] = fma(x[2][1], y[2][1], z[2][1]);
>+    result[3][0] = fma(x[3][0], y[3][0], z[3][0]);
>+    result[3][1] = fma(x[3][1], y[3][1], z[3][1]);
>+    return result;
>+}
>+float4x3 fma(float4x3 x, float4x3 y, float4x3 z) {
>+    float4x3 result;
>+    result[0][0] = fma(x[0][0], y[0][0], z[0][0]);
>+    result[0][1] = fma(x[0][1], y[0][1], z[0][1]);
>+    result[0][2] = fma(x[0][2], y[0][2], z[0][2]);
>+    result[1][0] = fma(x[1][0], y[1][0], z[1][0]);
>+    result[1][1] = fma(x[1][1], y[1][1], z[1][1]);
>+    result[1][2] = fma(x[1][2], y[1][2], z[1][2]);
>+    result[2][0] = fma(x[2][0], y[2][0], z[2][0]);
>+    result[2][1] = fma(x[2][1], y[2][1], z[2][1]);
>+    result[2][2] = fma(x[2][2], y[2][2], z[2][2]);
>+    result[3][0] = fma(x[3][0], y[3][0], z[3][0]);
>+    result[3][1] = fma(x[3][1], y[3][1], z[3][1]);
>+    result[3][2] = fma(x[3][2], y[3][2], z[3][2]);
>+    return result;
>+}
>+float4x4 fma(float4x4 x, float4x4 y, float4x4 z) {
>+    float4x4 result;
>+    result[0][0] = fma(x[0][0], y[0][0], z[0][0]);
>+    result[0][1] = fma(x[0][1], y[0][1], z[0][1]);
>+    result[0][2] = fma(x[0][2], y[0][2], z[0][2]);
>+    result[0][3] = fma(x[0][3], y[0][3], z[0][3]);
>+    result[1][0] = fma(x[1][0], y[1][0], z[1][0]);
>+    result[1][1] = fma(x[1][1], y[1][1], z[1][1]);
>+    result[1][2] = fma(x[1][2], y[1][2], z[1][2]);
>+    result[1][3] = fma(x[1][3], y[1][3], z[1][3]);
>+    result[2][0] = fma(x[2][0], y[2][0], z[2][0]);
>+    result[2][1] = fma(x[2][1], y[2][1], z[2][1]);
>+    result[2][2] = fma(x[2][2], y[2][2], z[2][2]);
>+    result[2][3] = fma(x[2][3], y[2][3], z[2][3]);
>+    result[3][0] = fma(x[3][0], y[3][0], z[3][0]);
>+    result[3][1] = fma(x[3][1], y[3][1], z[3][1]);
>+    result[3][2] = fma(x[3][2], y[3][2], z[3][2]);
>+    result[3][3] = fma(x[3][3], y[3][3], z[3][3]);
>+    return result;
>+}
>+
>+/* Functions named determinant */
>+half determinant(half x) {
>+    return x;
>+}
>+half determinant(half2x2 x) {
>+    return x[0][0] * x[1][1] - x[0][1] * x[1][0];
>+}
>+half determinant(half3x3 x) {
>+    return x[0][0] * x[1][1] * x[2][2] +
>+           x[0][1] * x[1][2] * x[2][0] +
>+           x[0][2] * x[1][0] * x[2][1] -
>+           x[2][0] * x[1][1] * x[0][2] -
>+           x[2][1] * x[1][2] * x[0][0] -
>+           x[2][2] * x[1][0] * x[0][1];
>+}
>+half determinant(half4x4 x) {
>+    half result;
>+    half3x3 minor;
>+    minor[0][0] = x[1][1];
>+    minor[0][1] = x[1][2];
>+    minor[0][2] = x[1][3];
>+    minor[1][0] = x[2][1];
>+    minor[1][1] = x[2][2];
>+    minor[1][2] = x[2][3];
>+    minor[2][0] = x[3][1];
>+    minor[2][1] = x[3][2];
>+    minor[2][2] = x[3][3];
>+    result = result + x[0][0] * determinant(minor);
>+    minor[0][0] = x[1][0];
>+    minor[0][1] = x[1][2];
>+    minor[0][2] = x[1][3];
>+    minor[1][0] = x[2][0];
>+    minor[1][1] = x[2][2];
>+    minor[1][2] = x[2][3];
>+    minor[2][0] = x[3][0];
>+    minor[2][1] = x[3][2];
>+    minor[2][2] = x[3][3];
>+    result = result - x[0][1] * determinant(minor);
>+    minor[0][0] = x[1][0];
>+    minor[0][1] = x[1][1];
>+    minor[0][2] = x[1][3];
>+    minor[1][0] = x[2][0];
>+    minor[1][1] = x[2][1];
>+    minor[1][2] = x[2][3];
>+    minor[2][0] = x[3][0];
>+    minor[2][1] = x[3][1];
>+    minor[2][2] = x[3][3];
>+    result = result + x[0][2] * determinant(minor);
>+    minor[0][0] = x[1][0];
>+    minor[0][1] = x[1][1];
>+    minor[0][2] = x[1][2];
>+    minor[1][0] = x[2][0];
>+    minor[1][1] = x[2][1];
>+    minor[1][2] = x[2][2];
>+    minor[2][0] = x[3][0];
>+    minor[2][1] = x[3][1];
>+    minor[2][2] = x[3][2];
>+    result = result - x[0][3] * determinant(minor);
>+    return result;
>+}
>+float determinant(float x) {
>+    return x;
>+}
>+float determinant(float2x2 x) {
>+    return x[0][0] * x[1][1] - x[0][1] * x[1][0];
>+}
>+float determinant(float3x3 x) {
>+    return x[0][0] * x[1][1] * x[2][2] +
>+           x[0][1] * x[1][2] * x[2][0] +
>+           x[0][2] * x[1][0] * x[2][1] -
>+           x[2][0] * x[1][1] * x[0][2] -
>+           x[2][1] * x[1][2] * x[0][0] -
>+           x[2][2] * x[1][0] * x[0][1];
>+}
>+float determinant(float4x4 x) {
>+    float result;
>+    float3x3 minor;
>+    minor[0][0] = x[1][1];
>+    minor[0][1] = x[1][2];
>+    minor[0][2] = x[1][3];
>+    minor[1][0] = x[2][1];
>+    minor[1][1] = x[2][2];
>+    minor[1][2] = x[2][3];
>+    minor[2][0] = x[3][1];
>+    minor[2][1] = x[3][2];
>+    minor[2][2] = x[3][3];
>+    result = result + x[0][0] * determinant(minor);
>+    minor[0][0] = x[1][0];
>+    minor[0][1] = x[1][2];
>+    minor[0][2] = x[1][3];
>+    minor[1][0] = x[2][0];
>+    minor[1][1] = x[2][2];
>+    minor[1][2] = x[2][3];
>+    minor[2][0] = x[3][0];
>+    minor[2][1] = x[3][2];
>+    minor[2][2] = x[3][3];
>+    result = result - x[0][1] * determinant(minor);
>+    minor[0][0] = x[1][0];
>+    minor[0][1] = x[1][1];
>+    minor[0][2] = x[1][3];
>+    minor[1][0] = x[2][0];
>+    minor[1][1] = x[2][1];
>+    minor[1][2] = x[2][3];
>+    minor[2][0] = x[3][0];
>+    minor[2][1] = x[3][1];
>+    minor[2][2] = x[3][3];
>+    result = result + x[0][2] * determinant(minor);
>+    minor[0][0] = x[1][0];
>+    minor[0][1] = x[1][1];
>+    minor[0][2] = x[1][2];
>+    minor[1][0] = x[2][0];
>+    minor[1][1] = x[2][1];
>+    minor[1][2] = x[2][2];
>+    minor[2][0] = x[3][0];
>+    minor[2][1] = x[3][1];
>+    minor[2][2] = x[3][2];
>+    result = result - x[0][3] * determinant(minor);
>+    return result;
>+}
>+
>+
>+/* Functions named operator.ywxy */
>+bool4 operator.ywxy(bool4 v) {
>+    bool4 result;
>+    result.x = v.y;
>+    result.y = v.w;
>+    result.z = v.x;
>+    result.w = v.y;
>+    return result;
>+}
>+uchar4 operator.ywxy(uchar4 v) {
>+    uchar4 result;
>+    result.x = v.y;
>+    result.y = v.w;
>+    result.z = v.x;
>+    result.w = v.y;
>+    return result;
>+}
>+ushort4 operator.ywxy(ushort4 v) {
>+    ushort4 result;
>+    result.x = v.y;
>+    result.y = v.w;
>+    result.z = v.x;
>+    result.w = v.y;
>+    return result;
>+}
>+uint4 operator.ywxy(uint4 v) {
>+    uint4 result;
>+    result.x = v.y;
>+    result.y = v.w;
>+    result.z = v.x;
>+    result.w = v.y;
>+    return result;
>+}
>+char4 operator.ywxy(char4 v) {
>+    char4 result;
>+    result.x = v.y;
>+    result.y = v.w;
>+    result.z = v.x;
>+    result.w = v.y;
>+    return result;
>+}
>+short4 operator.ywxy(short4 v) {
>+    short4 result;
>+    result.x = v.y;
>+    result.y = v.w;
>+    result.z = v.x;
>+    result.w = v.y;
>+    return result;
>+}
>+int4 operator.ywxy(int4 v) {
>+    int4 result;
>+    result.x = v.y;
>+    result.y = v.w;
>+    result.z = v.x;
>+    result.w = v.y;
>+    return result;
>+}
>+half4 operator.ywxy(half4 v) {
>+    half4 result;
>+    result.x = v.y;
>+    result.y = v.w;
>+    result.z = v.x;
>+    result.w = v.y;
>+    return result;
>+}
>+float4 operator.ywxy(float4 v) {
>+    float4 result;
>+    result.x = v.y;
>+    result.y = v.w;
>+    result.z = v.x;
>+    result.w = v.y;
>+    return result;
>+}
>+
>+/* Functions named floor */
>+native float floor(float);
>+half floor(half x) {
>+    return half(floor(float(x)));
>+}
>+half2 floor(half2 x) {
>+    half2 result;
>+    result[0] = floor(x[0]);
>+    result[1] = floor(x[1]);
>+    return result;
>+}
>+half3 floor(half3 x) {
>+    half3 result;
>+    result[0] = floor(x[0]);
>+    result[1] = floor(x[1]);
>+    result[2] = floor(x[2]);
>+    return result;
>+}
>+half4 floor(half4 x) {
>+    half4 result;
>+    result[0] = floor(x[0]);
>+    result[1] = floor(x[1]);
>+    result[2] = floor(x[2]);
>+    result[3] = floor(x[3]);
>+    return result;
>+}
>+half2x2 floor(half2x2 x) {
>+    half2x2 result;
>+    result[0][0] = floor(x[0][0]);
>+    result[0][1] = floor(x[0][1]);
>+    result[1][0] = floor(x[1][0]);
>+    result[1][1] = floor(x[1][1]);
>+    return result;
>+}
>+half2x3 floor(half2x3 x) {
>+    half2x3 result;
>+    result[0][0] = floor(x[0][0]);
>+    result[0][1] = floor(x[0][1]);
>+    result[0][2] = floor(x[0][2]);
>+    result[1][0] = floor(x[1][0]);
>+    result[1][1] = floor(x[1][1]);
>+    result[1][2] = floor(x[1][2]);
>+    return result;
>+}
>+half2x4 floor(half2x4 x) {
>+    half2x4 result;
>+    result[0][0] = floor(x[0][0]);
>+    result[0][1] = floor(x[0][1]);
>+    result[0][2] = floor(x[0][2]);
>+    result[0][3] = floor(x[0][3]);
>+    result[1][0] = floor(x[1][0]);
>+    result[1][1] = floor(x[1][1]);
>+    result[1][2] = floor(x[1][2]);
>+    result[1][3] = floor(x[1][3]);
>+    return result;
>+}
>+half3x2 floor(half3x2 x) {
>+    half3x2 result;
>+    result[0][0] = floor(x[0][0]);
>+    result[0][1] = floor(x[0][1]);
>+    result[1][0] = floor(x[1][0]);
>+    result[1][1] = floor(x[1][1]);
>+    result[2][0] = floor(x[2][0]);
>+    result[2][1] = floor(x[2][1]);
>+    return result;
>+}
>+half3x3 floor(half3x3 x) {
>+    half3x3 result;
>+    result[0][0] = floor(x[0][0]);
>+    result[0][1] = floor(x[0][1]);
>+    result[0][2] = floor(x[0][2]);
>+    result[1][0] = floor(x[1][0]);
>+    result[1][1] = floor(x[1][1]);
>+    result[1][2] = floor(x[1][2]);
>+    result[2][0] = floor(x[2][0]);
>+    result[2][1] = floor(x[2][1]);
>+    result[2][2] = floor(x[2][2]);
>+    return result;
>+}
>+half3x4 floor(half3x4 x) {
>+    half3x4 result;
>+    result[0][0] = floor(x[0][0]);
>+    result[0][1] = floor(x[0][1]);
>+    result[0][2] = floor(x[0][2]);
>+    result[0][3] = floor(x[0][3]);
>+    result[1][0] = floor(x[1][0]);
>+    result[1][1] = floor(x[1][1]);
>+    result[1][2] = floor(x[1][2]);
>+    result[1][3] = floor(x[1][3]);
>+    result[2][0] = floor(x[2][0]);
>+    result[2][1] = floor(x[2][1]);
>+    result[2][2] = floor(x[2][2]);
>+    result[2][3] = floor(x[2][3]);
>+    return result;
>+}
>+half4x2 floor(half4x2 x) {
>+    half4x2 result;
>+    result[0][0] = floor(x[0][0]);
>+    result[0][1] = floor(x[0][1]);
>+    result[1][0] = floor(x[1][0]);
>+    result[1][1] = floor(x[1][1]);
>+    result[2][0] = floor(x[2][0]);
>+    result[2][1] = floor(x[2][1]);
>+    result[3][0] = floor(x[3][0]);
>+    result[3][1] = floor(x[3][1]);
>+    return result;
>+}
>+half4x3 floor(half4x3 x) {
>+    half4x3 result;
>+    result[0][0] = floor(x[0][0]);
>+    result[0][1] = floor(x[0][1]);
>+    result[0][2] = floor(x[0][2]);
>+    result[1][0] = floor(x[1][0]);
>+    result[1][1] = floor(x[1][1]);
>+    result[1][2] = floor(x[1][2]);
>+    result[2][0] = floor(x[2][0]);
>+    result[2][1] = floor(x[2][1]);
>+    result[2][2] = floor(x[2][2]);
>+    result[3][0] = floor(x[3][0]);
>+    result[3][1] = floor(x[3][1]);
>+    result[3][2] = floor(x[3][2]);
>+    return result;
>+}
>+half4x4 floor(half4x4 x) {
>+    half4x4 result;
>+    result[0][0] = floor(x[0][0]);
>+    result[0][1] = floor(x[0][1]);
>+    result[0][2] = floor(x[0][2]);
>+    result[0][3] = floor(x[0][3]);
>+    result[1][0] = floor(x[1][0]);
>+    result[1][1] = floor(x[1][1]);
>+    result[1][2] = floor(x[1][2]);
>+    result[1][3] = floor(x[1][3]);
>+    result[2][0] = floor(x[2][0]);
>+    result[2][1] = floor(x[2][1]);
>+    result[2][2] = floor(x[2][2]);
>+    result[2][3] = floor(x[2][3]);
>+    result[3][0] = floor(x[3][0]);
>+    result[3][1] = floor(x[3][1]);
>+    result[3][2] = floor(x[3][2]);
>+    result[3][3] = floor(x[3][3]);
>+    return result;
>+}
>+float2 floor(float2 x) {
>+    float2 result;
>+    result[0] = floor(x[0]);
>+    result[1] = floor(x[1]);
>+    return result;
>+}
>+float3 floor(float3 x) {
>+    float3 result;
>+    result[0] = floor(x[0]);
>+    result[1] = floor(x[1]);
>+    result[2] = floor(x[2]);
>+    return result;
>+}
>+float4 floor(float4 x) {
>+    float4 result;
>+    result[0] = floor(x[0]);
>+    result[1] = floor(x[1]);
>+    result[2] = floor(x[2]);
>+    result[3] = floor(x[3]);
>+    return result;
>+}
>+float2x2 floor(float2x2 x) {
>+    float2x2 result;
>+    result[0][0] = floor(x[0][0]);
>+    result[0][1] = floor(x[0][1]);
>+    result[1][0] = floor(x[1][0]);
>+    result[1][1] = floor(x[1][1]);
>+    return result;
>+}
>+float2x3 floor(float2x3 x) {
>+    float2x3 result;
>+    result[0][0] = floor(x[0][0]);
>+    result[0][1] = floor(x[0][1]);
>+    result[0][2] = floor(x[0][2]);
>+    result[1][0] = floor(x[1][0]);
>+    result[1][1] = floor(x[1][1]);
>+    result[1][2] = floor(x[1][2]);
>+    return result;
>+}
>+float2x4 floor(float2x4 x) {
>+    float2x4 result;
>+    result[0][0] = floor(x[0][0]);
>+    result[0][1] = floor(x[0][1]);
>+    result[0][2] = floor(x[0][2]);
>+    result[0][3] = floor(x[0][3]);
>+    result[1][0] = floor(x[1][0]);
>+    result[1][1] = floor(x[1][1]);
>+    result[1][2] = floor(x[1][2]);
>+    result[1][3] = floor(x[1][3]);
>+    return result;
>+}
>+float3x2 floor(float3x2 x) {
>+    float3x2 result;
>+    result[0][0] = floor(x[0][0]);
>+    result[0][1] = floor(x[0][1]);
>+    result[1][0] = floor(x[1][0]);
>+    result[1][1] = floor(x[1][1]);
>+    result[2][0] = floor(x[2][0]);
>+    result[2][1] = floor(x[2][1]);
>+    return result;
>+}
>+float3x3 floor(float3x3 x) {
>+    float3x3 result;
>+    result[0][0] = floor(x[0][0]);
>+    result[0][1] = floor(x[0][1]);
>+    result[0][2] = floor(x[0][2]);
>+    result[1][0] = floor(x[1][0]);
>+    result[1][1] = floor(x[1][1]);
>+    result[1][2] = floor(x[1][2]);
>+    result[2][0] = floor(x[2][0]);
>+    result[2][1] = floor(x[2][1]);
>+    result[2][2] = floor(x[2][2]);
>+    return result;
>+}
>+float3x4 floor(float3x4 x) {
>+    float3x4 result;
>+    result[0][0] = floor(x[0][0]);
>+    result[0][1] = floor(x[0][1]);
>+    result[0][2] = floor(x[0][2]);
>+    result[0][3] = floor(x[0][3]);
>+    result[1][0] = floor(x[1][0]);
>+    result[1][1] = floor(x[1][1]);
>+    result[1][2] = floor(x[1][2]);
>+    result[1][3] = floor(x[1][3]);
>+    result[2][0] = floor(x[2][0]);
>+    result[2][1] = floor(x[2][1]);
>+    result[2][2] = floor(x[2][2]);
>+    result[2][3] = floor(x[2][3]);
>+    return result;
>+}
>+float4x2 floor(float4x2 x) {
>+    float4x2 result;
>+    result[0][0] = floor(x[0][0]);
>+    result[0][1] = floor(x[0][1]);
>+    result[1][0] = floor(x[1][0]);
>+    result[1][1] = floor(x[1][1]);
>+    result[2][0] = floor(x[2][0]);
>+    result[2][1] = floor(x[2][1]);
>+    result[3][0] = floor(x[3][0]);
>+    result[3][1] = floor(x[3][1]);
>+    return result;
>+}
>+float4x3 floor(float4x3 x) {
>+    float4x3 result;
>+    result[0][0] = floor(x[0][0]);
>+    result[0][1] = floor(x[0][1]);
>+    result[0][2] = floor(x[0][2]);
>+    result[1][0] = floor(x[1][0]);
>+    result[1][1] = floor(x[1][1]);
>+    result[1][2] = floor(x[1][2]);
>+    result[2][0] = floor(x[2][0]);
>+    result[2][1] = floor(x[2][1]);
>+    result[2][2] = floor(x[2][2]);
>+    result[3][0] = floor(x[3][0]);
>+    result[3][1] = floor(x[3][1]);
>+    result[3][2] = floor(x[3][2]);
>+    return result;
>+}
>+float4x4 floor(float4x4 x) {
>+    float4x4 result;
>+    result[0][0] = floor(x[0][0]);
>+    result[0][1] = floor(x[0][1]);
>+    result[0][2] = floor(x[0][2]);
>+    result[0][3] = floor(x[0][3]);
>+    result[1][0] = floor(x[1][0]);
>+    result[1][1] = floor(x[1][1]);
>+    result[1][2] = floor(x[1][2]);
>+    result[1][3] = floor(x[1][3]);
>+    result[2][0] = floor(x[2][0]);
>+    result[2][1] = floor(x[2][1]);
>+    result[2][2] = floor(x[2][2]);
>+    result[2][3] = floor(x[2][3]);
>+    result[3][0] = floor(x[3][0]);
>+    result[3][1] = floor(x[3][1]);
>+    result[3][2] = floor(x[3][2]);
>+    result[3][3] = floor(x[3][3]);
>+    return result;
>+}
>+
>+/* Functions named cross */
>+half3 cross(half3 u, half3 v) {
>+    half3 result;
>+    result.x = u.y * v.z - u.z * v.y;
>+    result.y = u.z * v.x - u.x * v.z;
>+    result.z = u.x * v.y - u.y * v.x;
>+    return result;
>+}
>+float3 cross(float3 u, float3 v) {
>+    float3 result;
>+    result.x = u.y * v.z - u.z * v.y;
>+    result.y = u.z * v.x - u.x * v.z;
>+    result.z = u.x * v.y - u.y * v.x;
>+    return result;
>+}
>+
>+
>+/* Functions named operator.xwyz */
>+bool4 operator.xwyz(bool4 v) {
>+    bool4 result;
>+    result.x = v.x;
>+    result.y = v.w;
>+    result.z = v.y;
>+    result.w = v.z;
>+    return result;
>+}
>+uchar4 operator.xwyz(uchar4 v) {
>+    uchar4 result;
>+    result.x = v.x;
>+    result.y = v.w;
>+    result.z = v.y;
>+    result.w = v.z;
>+    return result;
>+}
>+ushort4 operator.xwyz(ushort4 v) {
>+    ushort4 result;
>+    result.x = v.x;
>+    result.y = v.w;
>+    result.z = v.y;
>+    result.w = v.z;
>+    return result;
>+}
>+uint4 operator.xwyz(uint4 v) {
>+    uint4 result;
>+    result.x = v.x;
>+    result.y = v.w;
>+    result.z = v.y;
>+    result.w = v.z;
>+    return result;
>+}
>+char4 operator.xwyz(char4 v) {
>+    char4 result;
>+    result.x = v.x;
>+    result.y = v.w;
>+    result.z = v.y;
>+    result.w = v.z;
>+    return result;
>+}
>+short4 operator.xwyz(short4 v) {
>+    short4 result;
>+    result.x = v.x;
>+    result.y = v.w;
>+    result.z = v.y;
>+    result.w = v.z;
>+    return result;
>+}
>+int4 operator.xwyz(int4 v) {
>+    int4 result;
>+    result.x = v.x;
>+    result.y = v.w;
>+    result.z = v.y;
>+    result.w = v.z;
>+    return result;
>+}
>+half4 operator.xwyz(half4 v) {
>+    half4 result;
>+    result.x = v.x;
>+    result.y = v.w;
>+    result.z = v.y;
>+    result.w = v.z;
>+    return result;
>+}
>+float4 operator.xwyz(float4 v) {
>+    float4 result;
>+    result.x = v.x;
>+    result.y = v.w;
>+    result.z = v.y;
>+    result.w = v.z;
>+    return result;
>+}
>+
>+/* Functions named operator.xxyy */
>+bool4 operator.xxyy(bool2 v) {
>+    bool4 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.y;
>+    result.w = v.y;
>+    return result;
>+}
>+bool4 operator.xxyy(bool3 v) {
>+    bool4 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.y;
>+    result.w = v.y;
>+    return result;
>+}
>+bool4 operator.xxyy(bool4 v) {
>+    bool4 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.y;
>+    result.w = v.y;
>+    return result;
>+}
>+uchar4 operator.xxyy(uchar2 v) {
>+    uchar4 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.y;
>+    result.w = v.y;
>+    return result;
>+}
>+uchar4 operator.xxyy(uchar3 v) {
>+    uchar4 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.y;
>+    result.w = v.y;
>+    return result;
>+}
>+uchar4 operator.xxyy(uchar4 v) {
>+    uchar4 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.y;
>+    result.w = v.y;
>+    return result;
>+}
>+ushort4 operator.xxyy(ushort2 v) {
>+    ushort4 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.y;
>+    result.w = v.y;
>+    return result;
>+}
>+ushort4 operator.xxyy(ushort3 v) {
>+    ushort4 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.y;
>+    result.w = v.y;
>+    return result;
>+}
>+ushort4 operator.xxyy(ushort4 v) {
>+    ushort4 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.y;
>+    result.w = v.y;
>+    return result;
>+}
>+uint4 operator.xxyy(uint2 v) {
>+    uint4 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.y;
>+    result.w = v.y;
>+    return result;
>+}
>+uint4 operator.xxyy(uint3 v) {
>+    uint4 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.y;
>+    result.w = v.y;
>+    return result;
>+}
>+uint4 operator.xxyy(uint4 v) {
>+    uint4 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.y;
>+    result.w = v.y;
>+    return result;
>+}
>+char4 operator.xxyy(char2 v) {
>+    char4 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.y;
>+    result.w = v.y;
>+    return result;
>+}
>+char4 operator.xxyy(char3 v) {
>+    char4 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.y;
>+    result.w = v.y;
>+    return result;
>+}
>+char4 operator.xxyy(char4 v) {
>+    char4 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.y;
>+    result.w = v.y;
>+    return result;
>+}
>+short4 operator.xxyy(short2 v) {
>+    short4 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.y;
>+    result.w = v.y;
>+    return result;
>+}
>+short4 operator.xxyy(short3 v) {
>+    short4 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.y;
>+    result.w = v.y;
>+    return result;
>+}
>+short4 operator.xxyy(short4 v) {
>+    short4 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.y;
>+    result.w = v.y;
>+    return result;
>+}
>+int4 operator.xxyy(int2 v) {
>+    int4 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.y;
>+    result.w = v.y;
>+    return result;
>+}
>+int4 operator.xxyy(int3 v) {
>+    int4 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.y;
>+    result.w = v.y;
>+    return result;
>+}
>+int4 operator.xxyy(int4 v) {
>+    int4 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.y;
>+    result.w = v.y;
>+    return result;
>+}
>+half4 operator.xxyy(half2 v) {
>+    half4 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.y;
>+    result.w = v.y;
>+    return result;
>+}
>+half4 operator.xxyy(half3 v) {
>+    half4 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.y;
>+    result.w = v.y;
>+    return result;
>+}
>+half4 operator.xxyy(half4 v) {
>+    half4 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.y;
>+    result.w = v.y;
>+    return result;
>+}
>+float4 operator.xxyy(float2 v) {
>+    float4 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.y;
>+    result.w = v.y;
>+    return result;
>+}
>+float4 operator.xxyy(float3 v) {
>+    float4 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.y;
>+    result.w = v.y;
>+    return result;
>+}
>+float4 operator.xxyy(float4 v) {
>+    float4 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.y;
>+    result.w = v.y;
>+    return result;
>+}
>+
>+/* Functions named isfinite */
>+native bool isfinite(float);
>+bool isfinite(half x) {
>+    return isfinite(float(x));
>+}
>+bool2 isfinite(half2 x) {
>+    bool2 result;
>+    result[0] = isfinite(x[0]);
>+    result[1] = isfinite(x[1]);
>+    return result;
>+}
>+bool3 isfinite(half3 x) {
>+    bool3 result;
>+    result[0] = isfinite(x[0]);
>+    result[1] = isfinite(x[1]);
>+    result[2] = isfinite(x[2]);
>+    return result;
>+}
>+bool4 isfinite(half4 x) {
>+    bool4 result;
>+    result[0] = isfinite(x[0]);
>+    result[1] = isfinite(x[1]);
>+    result[2] = isfinite(x[2]);
>+    result[3] = isfinite(x[3]);
>+    return result;
>+}
>+bool2 isfinite(float2 x) {
>+    bool2 result;
>+    result[0] = isfinite(x[0]);
>+    result[1] = isfinite(x[1]);
>+    return result;
>+}
>+bool3 isfinite(float3 x) {
>+    bool3 result;
>+    result[0] = isfinite(x[0]);
>+    result[1] = isfinite(x[1]);
>+    result[2] = isfinite(x[2]);
>+    return result;
>+}
>+bool4 isfinite(float4 x) {
>+    bool4 result;
>+    result[0] = isfinite(x[0]);
>+    result[1] = isfinite(x[1]);
>+    result[2] = isfinite(x[2]);
>+    result[3] = isfinite(x[3]);
>+    return result;
>+}
>+
>+/* Functions named operator.zxy= */
>+bool3 operator.zxy=(bool3 v, bool3 c) {
>+    bool3 result = v;
>+    result.z = c.x;
>+    result.x = c.y;
>+    result.y = c.z;
>+    return result;
>+}
>+bool4 operator.zxy=(bool4 v, bool3 c) {
>+    bool4 result = v;
>+    result.z = c.x;
>+    result.x = c.y;
>+    result.y = c.z;
>+    return result;
>+}
>+uchar3 operator.zxy=(uchar3 v, uchar3 c) {
>+    uchar3 result = v;
>+    result.z = c.x;
>+    result.x = c.y;
>+    result.y = c.z;
>+    return result;
>+}
>+uchar4 operator.zxy=(uchar4 v, uchar3 c) {
>+    uchar4 result = v;
>+    result.z = c.x;
>+    result.x = c.y;
>+    result.y = c.z;
>+    return result;
>+}
>+ushort3 operator.zxy=(ushort3 v, ushort3 c) {
>+    ushort3 result = v;
>+    result.z = c.x;
>+    result.x = c.y;
>+    result.y = c.z;
>+    return result;
>+}
>+ushort4 operator.zxy=(ushort4 v, ushort3 c) {
>+    ushort4 result = v;
>+    result.z = c.x;
>+    result.x = c.y;
>+    result.y = c.z;
>+    return result;
>+}
>+uint3 operator.zxy=(uint3 v, uint3 c) {
>+    uint3 result = v;
>+    result.z = c.x;
>+    result.x = c.y;
>+    result.y = c.z;
>+    return result;
>+}
>+uint4 operator.zxy=(uint4 v, uint3 c) {
>+    uint4 result = v;
>+    result.z = c.x;
>+    result.x = c.y;
>+    result.y = c.z;
>+    return result;
>+}
>+char3 operator.zxy=(char3 v, char3 c) {
>+    char3 result = v;
>+    result.z = c.x;
>+    result.x = c.y;
>+    result.y = c.z;
>+    return result;
>+}
>+char4 operator.zxy=(char4 v, char3 c) {
>+    char4 result = v;
>+    result.z = c.x;
>+    result.x = c.y;
>+    result.y = c.z;
>+    return result;
>+}
>+short3 operator.zxy=(short3 v, short3 c) {
>+    short3 result = v;
>+    result.z = c.x;
>+    result.x = c.y;
>+    result.y = c.z;
>+    return result;
>+}
>+short4 operator.zxy=(short4 v, short3 c) {
>+    short4 result = v;
>+    result.z = c.x;
>+    result.x = c.y;
>+    result.y = c.z;
>+    return result;
>+}
>+int3 operator.zxy=(int3 v, int3 c) {
>+    int3 result = v;
>+    result.z = c.x;
>+    result.x = c.y;
>+    result.y = c.z;
>+    return result;
>+}
>+int4 operator.zxy=(int4 v, int3 c) {
>+    int4 result = v;
>+    result.z = c.x;
>+    result.x = c.y;
>+    result.y = c.z;
>+    return result;
>+}
>+half3 operator.zxy=(half3 v, half3 c) {
>+    half3 result = v;
>+    result.z = c.x;
>+    result.x = c.y;
>+    result.y = c.z;
>+    return result;
>+}
>+half4 operator.zxy=(half4 v, half3 c) {
>+    half4 result = v;
>+    result.z = c.x;
>+    result.x = c.y;
>+    result.y = c.z;
>+    return result;
>+}
>+float3 operator.zxy=(float3 v, float3 c) {
>+    float3 result = v;
>+    result.z = c.x;
>+    result.x = c.y;
>+    result.y = c.z;
>+    return result;
>+}
>+float4 operator.zxy=(float4 v, float3 c) {
>+    float4 result = v;
>+    result.z = c.x;
>+    result.x = c.y;
>+    result.y = c.z;
>+    return result;
>+}
>+
>+/* Functions named InterlockedOr */
>+native void InterlockedOr(device atomic_uint*, uint, thread uint*);
>+native void InterlockedOr(device atomic_int*, int, thread int*);
>+native void InterlockedOr(device atomic_uint*, uint, device uint*);
>+native void InterlockedOr(device atomic_int*, int, device int*);
>+native void InterlockedOr(device atomic_uint*, uint, threadgroup uint*);
>+native void InterlockedOr(device atomic_int*, int, threadgroup int*);
>+native void InterlockedOr(threadgroup atomic_uint*, uint, thread uint*);
>+native void InterlockedOr(threadgroup atomic_int*, int, thread int*);
>+native void InterlockedOr(threadgroup atomic_uint*, uint, device uint*);
>+native void InterlockedOr(threadgroup atomic_int*, int, device int*);
>+native void InterlockedOr(threadgroup atomic_uint*, uint, threadgroup uint*);
>+native void InterlockedOr(threadgroup atomic_int*, int, threadgroup int*);
>+
>+/* Functions named operator.zxzw */
>+bool4 operator.zxzw(bool4 v) {
>+    bool4 result;
>+    result.x = v.z;
>+    result.y = v.x;
>+    result.z = v.z;
>+    result.w = v.w;
>+    return result;
>+}
>+uchar4 operator.zxzw(uchar4 v) {
>+    uchar4 result;
>+    result.x = v.z;
>+    result.y = v.x;
>+    result.z = v.z;
>+    result.w = v.w;
>+    return result;
>+}
>+ushort4 operator.zxzw(ushort4 v) {
>+    ushort4 result;
>+    result.x = v.z;
>+    result.y = v.x;
>+    result.z = v.z;
>+    result.w = v.w;
>+    return result;
>+}
>+uint4 operator.zxzw(uint4 v) {
>+    uint4 result;
>+    result.x = v.z;
>+    result.y = v.x;
>+    result.z = v.z;
>+    result.w = v.w;
>+    return result;
>+}
>+char4 operator.zxzw(char4 v) {
>+    char4 result;
>+    result.x = v.z;
>+    result.y = v.x;
>+    result.z = v.z;
>+    result.w = v.w;
>+    return result;
>+}
>+short4 operator.zxzw(short4 v) {
>+    short4 result;
>+    result.x = v.z;
>+    result.y = v.x;
>+    result.z = v.z;
>+    result.w = v.w;
>+    return result;
>+}
>+int4 operator.zxzw(int4 v) {
>+    int4 result;
>+    result.x = v.z;
>+    result.y = v.x;
>+    result.z = v.z;
>+    result.w = v.w;
>+    return result;
>+}
>+half4 operator.zxzw(half4 v) {
>+    half4 result;
>+    result.x = v.z;
>+    result.y = v.x;
>+    result.z = v.z;
>+    result.w = v.w;
>+    return result;
>+}
>+float4 operator.zxzw(float4 v) {
>+    float4 result;
>+    result.x = v.z;
>+    result.y = v.x;
>+    result.z = v.z;
>+    result.w = v.w;
>+    return result;
>+}
>+
>+/* Functions named atan2 */
>+native float atan2(float, float);
>+half atan2(half x, half y) {
>+    return half(atan2(float(x), float(y)));
>+}
>+half2 atan2(half2 x, half2 y) {
>+    half2 result;
>+    result[0] = atan2(x[0], y[0]);
>+    result[1] = atan2(x[1], y[1]);
>+    return result;
>+}
>+half3 atan2(half3 x, half3 y) {
>+    half3 result;
>+    result[0] = atan2(x[0], y[0]);
>+    result[1] = atan2(x[1], y[1]);
>+    result[2] = atan2(x[2], y[2]);
>+    return result;
>+}
>+half4 atan2(half4 x, half4 y) {
>+    half4 result;
>+    result[0] = atan2(x[0], y[0]);
>+    result[1] = atan2(x[1], y[1]);
>+    result[2] = atan2(x[2], y[2]);
>+    result[3] = atan2(x[3], y[3]);
>+    return result;
>+}
>+half2x2 atan2(half2x2 x, half2x2 y) {
>+    half2x2 result;
>+    result[0][0] = atan2(x[0][0], y[0][0]);
>+    result[0][1] = atan2(x[0][1], y[0][1]);
>+    result[1][0] = atan2(x[1][0], y[1][0]);
>+    result[1][1] = atan2(x[1][1], y[1][1]);
>+    return result;
>+}
>+half2x3 atan2(half2x3 x, half2x3 y) {
>+    half2x3 result;
>+    result[0][0] = atan2(x[0][0], y[0][0]);
>+    result[0][1] = atan2(x[0][1], y[0][1]);
>+    result[0][2] = atan2(x[0][2], y[0][2]);
>+    result[1][0] = atan2(x[1][0], y[1][0]);
>+    result[1][1] = atan2(x[1][1], y[1][1]);
>+    result[1][2] = atan2(x[1][2], y[1][2]);
>+    return result;
>+}
>+half2x4 atan2(half2x4 x, half2x4 y) {
>+    half2x4 result;
>+    result[0][0] = atan2(x[0][0], y[0][0]);
>+    result[0][1] = atan2(x[0][1], y[0][1]);
>+    result[0][2] = atan2(x[0][2], y[0][2]);
>+    result[0][3] = atan2(x[0][3], y[0][3]);
>+    result[1][0] = atan2(x[1][0], y[1][0]);
>+    result[1][1] = atan2(x[1][1], y[1][1]);
>+    result[1][2] = atan2(x[1][2], y[1][2]);
>+    result[1][3] = atan2(x[1][3], y[1][3]);
>+    return result;
>+}
>+half3x2 atan2(half3x2 x, half3x2 y) {
>+    half3x2 result;
>+    result[0][0] = atan2(x[0][0], y[0][0]);
>+    result[0][1] = atan2(x[0][1], y[0][1]);
>+    result[1][0] = atan2(x[1][0], y[1][0]);
>+    result[1][1] = atan2(x[1][1], y[1][1]);
>+    result[2][0] = atan2(x[2][0], y[2][0]);
>+    result[2][1] = atan2(x[2][1], y[2][1]);
>+    return result;
>+}
>+half3x3 atan2(half3x3 x, half3x3 y) {
>+    half3x3 result;
>+    result[0][0] = atan2(x[0][0], y[0][0]);
>+    result[0][1] = atan2(x[0][1], y[0][1]);
>+    result[0][2] = atan2(x[0][2], y[0][2]);
>+    result[1][0] = atan2(x[1][0], y[1][0]);
>+    result[1][1] = atan2(x[1][1], y[1][1]);
>+    result[1][2] = atan2(x[1][2], y[1][2]);
>+    result[2][0] = atan2(x[2][0], y[2][0]);
>+    result[2][1] = atan2(x[2][1], y[2][1]);
>+    result[2][2] = atan2(x[2][2], y[2][2]);
>+    return result;
>+}
>+half3x4 atan2(half3x4 x, half3x4 y) {
>+    half3x4 result;
>+    result[0][0] = atan2(x[0][0], y[0][0]);
>+    result[0][1] = atan2(x[0][1], y[0][1]);
>+    result[0][2] = atan2(x[0][2], y[0][2]);
>+    result[0][3] = atan2(x[0][3], y[0][3]);
>+    result[1][0] = atan2(x[1][0], y[1][0]);
>+    result[1][1] = atan2(x[1][1], y[1][1]);
>+    result[1][2] = atan2(x[1][2], y[1][2]);
>+    result[1][3] = atan2(x[1][3], y[1][3]);
>+    result[2][0] = atan2(x[2][0], y[2][0]);
>+    result[2][1] = atan2(x[2][1], y[2][1]);
>+    result[2][2] = atan2(x[2][2], y[2][2]);
>+    result[2][3] = atan2(x[2][3], y[2][3]);
>+    return result;
>+}
>+half4x2 atan2(half4x2 x, half4x2 y) {
>+    half4x2 result;
>+    result[0][0] = atan2(x[0][0], y[0][0]);
>+    result[0][1] = atan2(x[0][1], y[0][1]);
>+    result[1][0] = atan2(x[1][0], y[1][0]);
>+    result[1][1] = atan2(x[1][1], y[1][1]);
>+    result[2][0] = atan2(x[2][0], y[2][0]);
>+    result[2][1] = atan2(x[2][1], y[2][1]);
>+    result[3][0] = atan2(x[3][0], y[3][0]);
>+    result[3][1] = atan2(x[3][1], y[3][1]);
>+    return result;
>+}
>+half4x3 atan2(half4x3 x, half4x3 y) {
>+    half4x3 result;
>+    result[0][0] = atan2(x[0][0], y[0][0]);
>+    result[0][1] = atan2(x[0][1], y[0][1]);
>+    result[0][2] = atan2(x[0][2], y[0][2]);
>+    result[1][0] = atan2(x[1][0], y[1][0]);
>+    result[1][1] = atan2(x[1][1], y[1][1]);
>+    result[1][2] = atan2(x[1][2], y[1][2]);
>+    result[2][0] = atan2(x[2][0], y[2][0]);
>+    result[2][1] = atan2(x[2][1], y[2][1]);
>+    result[2][2] = atan2(x[2][2], y[2][2]);
>+    result[3][0] = atan2(x[3][0], y[3][0]);
>+    result[3][1] = atan2(x[3][1], y[3][1]);
>+    result[3][2] = atan2(x[3][2], y[3][2]);
>+    return result;
>+}
>+half4x4 atan2(half4x4 x, half4x4 y) {
>+    half4x4 result;
>+    result[0][0] = atan2(x[0][0], y[0][0]);
>+    result[0][1] = atan2(x[0][1], y[0][1]);
>+    result[0][2] = atan2(x[0][2], y[0][2]);
>+    result[0][3] = atan2(x[0][3], y[0][3]);
>+    result[1][0] = atan2(x[1][0], y[1][0]);
>+    result[1][1] = atan2(x[1][1], y[1][1]);
>+    result[1][2] = atan2(x[1][2], y[1][2]);
>+    result[1][3] = atan2(x[1][3], y[1][3]);
>+    result[2][0] = atan2(x[2][0], y[2][0]);
>+    result[2][1] = atan2(x[2][1], y[2][1]);
>+    result[2][2] = atan2(x[2][2], y[2][2]);
>+    result[2][3] = atan2(x[2][3], y[2][3]);
>+    result[3][0] = atan2(x[3][0], y[3][0]);
>+    result[3][1] = atan2(x[3][1], y[3][1]);
>+    result[3][2] = atan2(x[3][2], y[3][2]);
>+    result[3][3] = atan2(x[3][3], y[3][3]);
>+    return result;
>+}
>+float2 atan2(float2 x, float2 y) {
>+    float2 result;
>+    result[0] = atan2(x[0], y[0]);
>+    result[1] = atan2(x[1], y[1]);
>+    return result;
>+}
>+float3 atan2(float3 x, float3 y) {
>+    float3 result;
>+    result[0] = atan2(x[0], y[0]);
>+    result[1] = atan2(x[1], y[1]);
>+    result[2] = atan2(x[2], y[2]);
>+    return result;
>+}
>+float4 atan2(float4 x, float4 y) {
>+    float4 result;
>+    result[0] = atan2(x[0], y[0]);
>+    result[1] = atan2(x[1], y[1]);
>+    result[2] = atan2(x[2], y[2]);
>+    result[3] = atan2(x[3], y[3]);
>+    return result;
>+}
>+float2x2 atan2(float2x2 x, float2x2 y) {
>+    float2x2 result;
>+    result[0][0] = atan2(x[0][0], y[0][0]);
>+    result[0][1] = atan2(x[0][1], y[0][1]);
>+    result[1][0] = atan2(x[1][0], y[1][0]);
>+    result[1][1] = atan2(x[1][1], y[1][1]);
>+    return result;
>+}
>+float2x3 atan2(float2x3 x, float2x3 y) {
>+    float2x3 result;
>+    result[0][0] = atan2(x[0][0], y[0][0]);
>+    result[0][1] = atan2(x[0][1], y[0][1]);
>+    result[0][2] = atan2(x[0][2], y[0][2]);
>+    result[1][0] = atan2(x[1][0], y[1][0]);
>+    result[1][1] = atan2(x[1][1], y[1][1]);
>+    result[1][2] = atan2(x[1][2], y[1][2]);
>+    return result;
>+}
>+float2x4 atan2(float2x4 x, float2x4 y) {
>+    float2x4 result;
>+    result[0][0] = atan2(x[0][0], y[0][0]);
>+    result[0][1] = atan2(x[0][1], y[0][1]);
>+    result[0][2] = atan2(x[0][2], y[0][2]);
>+    result[0][3] = atan2(x[0][3], y[0][3]);
>+    result[1][0] = atan2(x[1][0], y[1][0]);
>+    result[1][1] = atan2(x[1][1], y[1][1]);
>+    result[1][2] = atan2(x[1][2], y[1][2]);
>+    result[1][3] = atan2(x[1][3], y[1][3]);
>+    return result;
>+}
>+float3x2 atan2(float3x2 x, float3x2 y) {
>+    float3x2 result;
>+    result[0][0] = atan2(x[0][0], y[0][0]);
>+    result[0][1] = atan2(x[0][1], y[0][1]);
>+    result[1][0] = atan2(x[1][0], y[1][0]);
>+    result[1][1] = atan2(x[1][1], y[1][1]);
>+    result[2][0] = atan2(x[2][0], y[2][0]);
>+    result[2][1] = atan2(x[2][1], y[2][1]);
>+    return result;
>+}
>+float3x3 atan2(float3x3 x, float3x3 y) {
>+    float3x3 result;
>+    result[0][0] = atan2(x[0][0], y[0][0]);
>+    result[0][1] = atan2(x[0][1], y[0][1]);
>+    result[0][2] = atan2(x[0][2], y[0][2]);
>+    result[1][0] = atan2(x[1][0], y[1][0]);
>+    result[1][1] = atan2(x[1][1], y[1][1]);
>+    result[1][2] = atan2(x[1][2], y[1][2]);
>+    result[2][0] = atan2(x[2][0], y[2][0]);
>+    result[2][1] = atan2(x[2][1], y[2][1]);
>+    result[2][2] = atan2(x[2][2], y[2][2]);
>+    return result;
>+}
>+float3x4 atan2(float3x4 x, float3x4 y) {
>+    float3x4 result;
>+    result[0][0] = atan2(x[0][0], y[0][0]);
>+    result[0][1] = atan2(x[0][1], y[0][1]);
>+    result[0][2] = atan2(x[0][2], y[0][2]);
>+    result[0][3] = atan2(x[0][3], y[0][3]);
>+    result[1][0] = atan2(x[1][0], y[1][0]);
>+    result[1][1] = atan2(x[1][1], y[1][1]);
>+    result[1][2] = atan2(x[1][2], y[1][2]);
>+    result[1][3] = atan2(x[1][3], y[1][3]);
>+    result[2][0] = atan2(x[2][0], y[2][0]);
>+    result[2][1] = atan2(x[2][1], y[2][1]);
>+    result[2][2] = atan2(x[2][2], y[2][2]);
>+    result[2][3] = atan2(x[2][3], y[2][3]);
>+    return result;
>+}
>+float4x2 atan2(float4x2 x, float4x2 y) {
>+    float4x2 result;
>+    result[0][0] = atan2(x[0][0], y[0][0]);
>+    result[0][1] = atan2(x[0][1], y[0][1]);
>+    result[1][0] = atan2(x[1][0], y[1][0]);
>+    result[1][1] = atan2(x[1][1], y[1][1]);
>+    result[2][0] = atan2(x[2][0], y[2][0]);
>+    result[2][1] = atan2(x[2][1], y[2][1]);
>+    result[3][0] = atan2(x[3][0], y[3][0]);
>+    result[3][1] = atan2(x[3][1], y[3][1]);
>+    return result;
>+}
>+float4x3 atan2(float4x3 x, float4x3 y) {
>+    float4x3 result;
>+    result[0][0] = atan2(x[0][0], y[0][0]);
>+    result[0][1] = atan2(x[0][1], y[0][1]);
>+    result[0][2] = atan2(x[0][2], y[0][2]);
>+    result[1][0] = atan2(x[1][0], y[1][0]);
>+    result[1][1] = atan2(x[1][1], y[1][1]);
>+    result[1][2] = atan2(x[1][2], y[1][2]);
>+    result[2][0] = atan2(x[2][0], y[2][0]);
>+    result[2][1] = atan2(x[2][1], y[2][1]);
>+    result[2][2] = atan2(x[2][2], y[2][2]);
>+    result[3][0] = atan2(x[3][0], y[3][0]);
>+    result[3][1] = atan2(x[3][1], y[3][1]);
>+    result[3][2] = atan2(x[3][2], y[3][2]);
>+    return result;
>+}
>+float4x4 atan2(float4x4 x, float4x4 y) {
>+    float4x4 result;
>+    result[0][0] = atan2(x[0][0], y[0][0]);
>+    result[0][1] = atan2(x[0][1], y[0][1]);
>+    result[0][2] = atan2(x[0][2], y[0][2]);
>+    result[0][3] = atan2(x[0][3], y[0][3]);
>+    result[1][0] = atan2(x[1][0], y[1][0]);
>+    result[1][1] = atan2(x[1][1], y[1][1]);
>+    result[1][2] = atan2(x[1][2], y[1][2]);
>+    result[1][3] = atan2(x[1][3], y[1][3]);
>+    result[2][0] = atan2(x[2][0], y[2][0]);
>+    result[2][1] = atan2(x[2][1], y[2][1]);
>+    result[2][2] = atan2(x[2][2], y[2][2]);
>+    result[2][3] = atan2(x[2][3], y[2][3]);
>+    result[3][0] = atan2(x[3][0], y[3][0]);
>+    result[3][1] = atan2(x[3][1], y[3][1]);
>+    result[3][2] = atan2(x[3][2], y[3][2]);
>+    result[3][3] = atan2(x[3][3], y[3][3]);
>+    return result;
>+}
>+
>+
>+/* Functions named operator.yzwy */
>+bool4 operator.yzwy(bool4 v) {
>+    bool4 result;
>+    result.x = v.y;
>+    result.y = v.z;
>+    result.z = v.w;
>+    result.w = v.y;
>+    return result;
>+}
>+uchar4 operator.yzwy(uchar4 v) {
>+    uchar4 result;
>+    result.x = v.y;
>+    result.y = v.z;
>+    result.z = v.w;
>+    result.w = v.y;
>+    return result;
>+}
>+ushort4 operator.yzwy(ushort4 v) {
>+    ushort4 result;
>+    result.x = v.y;
>+    result.y = v.z;
>+    result.z = v.w;
>+    result.w = v.y;
>+    return result;
>+}
>+uint4 operator.yzwy(uint4 v) {
>+    uint4 result;
>+    result.x = v.y;
>+    result.y = v.z;
>+    result.z = v.w;
>+    result.w = v.y;
>+    return result;
>+}
>+char4 operator.yzwy(char4 v) {
>+    char4 result;
>+    result.x = v.y;
>+    result.y = v.z;
>+    result.z = v.w;
>+    result.w = v.y;
>+    return result;
>+}
>+short4 operator.yzwy(short4 v) {
>+    short4 result;
>+    result.x = v.y;
>+    result.y = v.z;
>+    result.z = v.w;
>+    result.w = v.y;
>+    return result;
>+}
>+int4 operator.yzwy(int4 v) {
>+    int4 result;
>+    result.x = v.y;
>+    result.y = v.z;
>+    result.z = v.w;
>+    result.w = v.y;
>+    return result;
>+}
>+half4 operator.yzwy(half4 v) {
>+    half4 result;
>+    result.x = v.y;
>+    result.y = v.z;
>+    result.z = v.w;
>+    result.w = v.y;
>+    return result;
>+}
>+float4 operator.yzwy(float4 v) {
>+    float4 result;
>+    result.x = v.y;
>+    result.y = v.z;
>+    result.z = v.w;
>+    result.w = v.y;
>+    return result;
>+}
>+
>+/* Functions named operator.zzxw */
>+bool4 operator.zzxw(bool4 v) {
>+    bool4 result;
>+    result.x = v.z;
>+    result.y = v.z;
>+    result.z = v.x;
>+    result.w = v.w;
>+    return result;
>+}
>+uchar4 operator.zzxw(uchar4 v) {
>+    uchar4 result;
>+    result.x = v.z;
>+    result.y = v.z;
>+    result.z = v.x;
>+    result.w = v.w;
>+    return result;
>+}
>+ushort4 operator.zzxw(ushort4 v) {
>+    ushort4 result;
>+    result.x = v.z;
>+    result.y = v.z;
>+    result.z = v.x;
>+    result.w = v.w;
>+    return result;
>+}
>+uint4 operator.zzxw(uint4 v) {
>+    uint4 result;
>+    result.x = v.z;
>+    result.y = v.z;
>+    result.z = v.x;
>+    result.w = v.w;
>+    return result;
>+}
>+char4 operator.zzxw(char4 v) {
>+    char4 result;
>+    result.x = v.z;
>+    result.y = v.z;
>+    result.z = v.x;
>+    result.w = v.w;
>+    return result;
>+}
>+short4 operator.zzxw(short4 v) {
>+    short4 result;
>+    result.x = v.z;
>+    result.y = v.z;
>+    result.z = v.x;
>+    result.w = v.w;
>+    return result;
>+}
>+int4 operator.zzxw(int4 v) {
>+    int4 result;
>+    result.x = v.z;
>+    result.y = v.z;
>+    result.z = v.x;
>+    result.w = v.w;
>+    return result;
>+}
>+half4 operator.zzxw(half4 v) {
>+    half4 result;
>+    result.x = v.z;
>+    result.y = v.z;
>+    result.z = v.x;
>+    result.w = v.w;
>+    return result;
>+}
>+float4 operator.zzxw(float4 v) {
>+    float4 result;
>+    result.x = v.z;
>+    result.y = v.z;
>+    result.z = v.x;
>+    result.w = v.w;
>+    return result;
>+}
>+
>+/* Functions named operator.wywz */
>+bool4 operator.wywz(bool4 v) {
>+    bool4 result;
>+    result.x = v.w;
>+    result.y = v.y;
>+    result.z = v.w;
>+    result.w = v.z;
>+    return result;
>+}
>+uchar4 operator.wywz(uchar4 v) {
>+    uchar4 result;
>+    result.x = v.w;
>+    result.y = v.y;
>+    result.z = v.w;
>+    result.w = v.z;
>+    return result;
>+}
>+ushort4 operator.wywz(ushort4 v) {
>+    ushort4 result;
>+    result.x = v.w;
>+    result.y = v.y;
>+    result.z = v.w;
>+    result.w = v.z;
>+    return result;
>+}
>+uint4 operator.wywz(uint4 v) {
>+    uint4 result;
>+    result.x = v.w;
>+    result.y = v.y;
>+    result.z = v.w;
>+    result.w = v.z;
>+    return result;
>+}
>+char4 operator.wywz(char4 v) {
>+    char4 result;
>+    result.x = v.w;
>+    result.y = v.y;
>+    result.z = v.w;
>+    result.w = v.z;
>+    return result;
>+}
>+short4 operator.wywz(short4 v) {
>+    short4 result;
>+    result.x = v.w;
>+    result.y = v.y;
>+    result.z = v.w;
>+    result.w = v.z;
>+    return result;
>+}
>+int4 operator.wywz(int4 v) {
>+    int4 result;
>+    result.x = v.w;
>+    result.y = v.y;
>+    result.z = v.w;
>+    result.w = v.z;
>+    return result;
>+}
>+half4 operator.wywz(half4 v) {
>+    half4 result;
>+    result.x = v.w;
>+    result.y = v.y;
>+    result.z = v.w;
>+    result.w = v.z;
>+    return result;
>+}
>+float4 operator.wywz(float4 v) {
>+    float4 result;
>+    result.x = v.w;
>+    result.y = v.y;
>+    result.z = v.w;
>+    result.w = v.z;
>+    return result;
>+}
>+
>+/* Functions named operator.ywyz */
>+bool4 operator.ywyz(bool4 v) {
>+    bool4 result;
>+    result.x = v.y;
>+    result.y = v.w;
>+    result.z = v.y;
>+    result.w = v.z;
>+    return result;
>+}
>+uchar4 operator.ywyz(uchar4 v) {
>+    uchar4 result;
>+    result.x = v.y;
>+    result.y = v.w;
>+    result.z = v.y;
>+    result.w = v.z;
>+    return result;
>+}
>+ushort4 operator.ywyz(ushort4 v) {
>+    ushort4 result;
>+    result.x = v.y;
>+    result.y = v.w;
>+    result.z = v.y;
>+    result.w = v.z;
>+    return result;
>+}
>+uint4 operator.ywyz(uint4 v) {
>+    uint4 result;
>+    result.x = v.y;
>+    result.y = v.w;
>+    result.z = v.y;
>+    result.w = v.z;
>+    return result;
>+}
>+char4 operator.ywyz(char4 v) {
>+    char4 result;
>+    result.x = v.y;
>+    result.y = v.w;
>+    result.z = v.y;
>+    result.w = v.z;
>+    return result;
>+}
>+short4 operator.ywyz(short4 v) {
>+    short4 result;
>+    result.x = v.y;
>+    result.y = v.w;
>+    result.z = v.y;
>+    result.w = v.z;
>+    return result;
>+}
>+int4 operator.ywyz(int4 v) {
>+    int4 result;
>+    result.x = v.y;
>+    result.y = v.w;
>+    result.z = v.y;
>+    result.w = v.z;
>+    return result;
>+}
>+half4 operator.ywyz(half4 v) {
>+    half4 result;
>+    result.x = v.y;
>+    result.y = v.w;
>+    result.z = v.y;
>+    result.w = v.z;
>+    return result;
>+}
>+float4 operator.ywyz(float4 v) {
>+    float4 result;
>+    result.x = v.y;
>+    result.y = v.w;
>+    result.z = v.y;
>+    result.w = v.z;
>+    return result;
>+}
>+
>+/* Functions named operator.yzx */
>+bool3 operator.yzx(bool3 v) {
>+    bool3 result;
>+    result.x = v.y;
>+    result.y = v.z;
>+    result.z = v.x;
>+    return result;
>+}
>+bool3 operator.yzx(bool4 v) {
>+    bool3 result;
>+    result.x = v.y;
>+    result.y = v.z;
>+    result.z = v.x;
>+    return result;
>+}
>+uchar3 operator.yzx(uchar3 v) {
>+    uchar3 result;
>+    result.x = v.y;
>+    result.y = v.z;
>+    result.z = v.x;
>+    return result;
>+}
>+uchar3 operator.yzx(uchar4 v) {
>+    uchar3 result;
>+    result.x = v.y;
>+    result.y = v.z;
>+    result.z = v.x;
>+    return result;
>+}
>+ushort3 operator.yzx(ushort3 v) {
>+    ushort3 result;
>+    result.x = v.y;
>+    result.y = v.z;
>+    result.z = v.x;
>+    return result;
>+}
>+ushort3 operator.yzx(ushort4 v) {
>+    ushort3 result;
>+    result.x = v.y;
>+    result.y = v.z;
>+    result.z = v.x;
>+    return result;
>+}
>+uint3 operator.yzx(uint3 v) {
>+    uint3 result;
>+    result.x = v.y;
>+    result.y = v.z;
>+    result.z = v.x;
>+    return result;
>+}
>+uint3 operator.yzx(uint4 v) {
>+    uint3 result;
>+    result.x = v.y;
>+    result.y = v.z;
>+    result.z = v.x;
>+    return result;
>+}
>+char3 operator.yzx(char3 v) {
>+    char3 result;
>+    result.x = v.y;
>+    result.y = v.z;
>+    result.z = v.x;
>+    return result;
>+}
>+char3 operator.yzx(char4 v) {
>+    char3 result;
>+    result.x = v.y;
>+    result.y = v.z;
>+    result.z = v.x;
>+    return result;
>+}
>+short3 operator.yzx(short3 v) {
>+    short3 result;
>+    result.x = v.y;
>+    result.y = v.z;
>+    result.z = v.x;
>+    return result;
>+}
>+short3 operator.yzx(short4 v) {
>+    short3 result;
>+    result.x = v.y;
>+    result.y = v.z;
>+    result.z = v.x;
>+    return result;
>+}
>+int3 operator.yzx(int3 v) {
>+    int3 result;
>+    result.x = v.y;
>+    result.y = v.z;
>+    result.z = v.x;
>+    return result;
>+}
>+int3 operator.yzx(int4 v) {
>+    int3 result;
>+    result.x = v.y;
>+    result.y = v.z;
>+    result.z = v.x;
>+    return result;
>+}
>+half3 operator.yzx(half3 v) {
>+    half3 result;
>+    result.x = v.y;
>+    result.y = v.z;
>+    result.z = v.x;
>+    return result;
>+}
>+half3 operator.yzx(half4 v) {
>+    half3 result;
>+    result.x = v.y;
>+    result.y = v.z;
>+    result.z = v.x;
>+    return result;
>+}
>+float3 operator.yzx(float3 v) {
>+    float3 result;
>+    result.x = v.y;
>+    result.y = v.z;
>+    result.z = v.x;
>+    return result;
>+}
>+float3 operator.yzx(float4 v) {
>+    float3 result;
>+    result.x = v.y;
>+    result.y = v.z;
>+    result.z = v.x;
>+    return result;
>+}
>+
>+/* Functions named operator.yz */
>+bool2 operator.yz(bool3 v) {
>+    bool2 result;
>+    result.x = v.y;
>+    result.y = v.z;
>+    return result;
>+}
>+bool2 operator.yz(bool4 v) {
>+    bool2 result;
>+    result.x = v.y;
>+    result.y = v.z;
>+    return result;
>+}
>+uchar2 operator.yz(uchar3 v) {
>+    uchar2 result;
>+    result.x = v.y;
>+    result.y = v.z;
>+    return result;
>+}
>+uchar2 operator.yz(uchar4 v) {
>+    uchar2 result;
>+    result.x = v.y;
>+    result.y = v.z;
>+    return result;
>+}
>+ushort2 operator.yz(ushort3 v) {
>+    ushort2 result;
>+    result.x = v.y;
>+    result.y = v.z;
>+    return result;
>+}
>+ushort2 operator.yz(ushort4 v) {
>+    ushort2 result;
>+    result.x = v.y;
>+    result.y = v.z;
>+    return result;
>+}
>+uint2 operator.yz(uint3 v) {
>+    uint2 result;
>+    result.x = v.y;
>+    result.y = v.z;
>+    return result;
>+}
>+uint2 operator.yz(uint4 v) {
>+    uint2 result;
>+    result.x = v.y;
>+    result.y = v.z;
>+    return result;
>+}
>+char2 operator.yz(char3 v) {
>+    char2 result;
>+    result.x = v.y;
>+    result.y = v.z;
>+    return result;
>+}
>+char2 operator.yz(char4 v) {
>+    char2 result;
>+    result.x = v.y;
>+    result.y = v.z;
>+    return result;
>+}
>+short2 operator.yz(short3 v) {
>+    short2 result;
>+    result.x = v.y;
>+    result.y = v.z;
>+    return result;
>+}
>+short2 operator.yz(short4 v) {
>+    short2 result;
>+    result.x = v.y;
>+    result.y = v.z;
>+    return result;
>+}
>+int2 operator.yz(int3 v) {
>+    int2 result;
>+    result.x = v.y;
>+    result.y = v.z;
>+    return result;
>+}
>+int2 operator.yz(int4 v) {
>+    int2 result;
>+    result.x = v.y;
>+    result.y = v.z;
>+    return result;
>+}
>+half2 operator.yz(half3 v) {
>+    half2 result;
>+    result.x = v.y;
>+    result.y = v.z;
>+    return result;
>+}
>+half2 operator.yz(half4 v) {
>+    half2 result;
>+    result.x = v.y;
>+    result.y = v.z;
>+    return result;
>+}
>+float2 operator.yz(float3 v) {
>+    float2 result;
>+    result.x = v.y;
>+    result.y = v.z;
>+    return result;
>+}
>+float2 operator.yz(float4 v) {
>+    float2 result;
>+    result.x = v.y;
>+    result.y = v.z;
>+    return result;
>+}
>+
>+/* Functions named operator.wxxz */
>+bool4 operator.wxxz(bool4 v) {
>+    bool4 result;
>+    result.x = v.w;
>+    result.y = v.x;
>+    result.z = v.x;
>+    result.w = v.z;
>+    return result;
>+}
>+uchar4 operator.wxxz(uchar4 v) {
>+    uchar4 result;
>+    result.x = v.w;
>+    result.y = v.x;
>+    result.z = v.x;
>+    result.w = v.z;
>+    return result;
>+}
>+ushort4 operator.wxxz(ushort4 v) {
>+    ushort4 result;
>+    result.x = v.w;
>+    result.y = v.x;
>+    result.z = v.x;
>+    result.w = v.z;
>+    return result;
>+}
>+uint4 operator.wxxz(uint4 v) {
>+    uint4 result;
>+    result.x = v.w;
>+    result.y = v.x;
>+    result.z = v.x;
>+    result.w = v.z;
>+    return result;
>+}
>+char4 operator.wxxz(char4 v) {
>+    char4 result;
>+    result.x = v.w;
>+    result.y = v.x;
>+    result.z = v.x;
>+    result.w = v.z;
>+    return result;
>+}
>+short4 operator.wxxz(short4 v) {
>+    short4 result;
>+    result.x = v.w;
>+    result.y = v.x;
>+    result.z = v.x;
>+    result.w = v.z;
>+    return result;
>+}
>+int4 operator.wxxz(int4 v) {
>+    int4 result;
>+    result.x = v.w;
>+    result.y = v.x;
>+    result.z = v.x;
>+    result.w = v.z;
>+    return result;
>+}
>+half4 operator.wxxz(half4 v) {
>+    half4 result;
>+    result.x = v.w;
>+    result.y = v.x;
>+    result.z = v.x;
>+    result.w = v.z;
>+    return result;
>+}
>+float4 operator.wxxz(float4 v) {
>+    float4 result;
>+    result.x = v.w;
>+    result.y = v.x;
>+    result.z = v.x;
>+    result.w = v.z;
>+    return result;
>+}
>+
>+/* Functions named operator.xw= */
>+bool4 operator.xw=(bool4 v, bool2 c) {
>+    bool4 result = v;
>+    result.x = c.x;
>+    result.w = c.y;
>+    return result;
>+}
>+uchar4 operator.xw=(uchar4 v, uchar2 c) {
>+    uchar4 result = v;
>+    result.x = c.x;
>+    result.w = c.y;
>+    return result;
>+}
>+ushort4 operator.xw=(ushort4 v, ushort2 c) {
>+    ushort4 result = v;
>+    result.x = c.x;
>+    result.w = c.y;
>+    return result;
>+}
>+uint4 operator.xw=(uint4 v, uint2 c) {
>+    uint4 result = v;
>+    result.x = c.x;
>+    result.w = c.y;
>+    return result;
>+}
>+char4 operator.xw=(char4 v, char2 c) {
>+    char4 result = v;
>+    result.x = c.x;
>+    result.w = c.y;
>+    return result;
>+}
>+short4 operator.xw=(short4 v, short2 c) {
>+    short4 result = v;
>+    result.x = c.x;
>+    result.w = c.y;
>+    return result;
>+}
>+int4 operator.xw=(int4 v, int2 c) {
>+    int4 result = v;
>+    result.x = c.x;
>+    result.w = c.y;
>+    return result;
>+}
>+half4 operator.xw=(half4 v, half2 c) {
>+    half4 result = v;
>+    result.x = c.x;
>+    result.w = c.y;
>+    return result;
>+}
>+float4 operator.xw=(float4 v, float2 c) {
>+    float4 result = v;
>+    result.x = c.x;
>+    result.w = c.y;
>+    return result;
>+}
>+
>+/* Functions named operator.xyxy */
>+bool4 operator.xyxy(bool2 v) {
>+    bool4 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.x;
>+    result.w = v.y;
>+    return result;
>+}
>+bool4 operator.xyxy(bool3 v) {
>+    bool4 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.x;
>+    result.w = v.y;
>+    return result;
>+}
>+bool4 operator.xyxy(bool4 v) {
>+    bool4 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.x;
>+    result.w = v.y;
>+    return result;
>+}
>+uchar4 operator.xyxy(uchar2 v) {
>+    uchar4 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.x;
>+    result.w = v.y;
>+    return result;
>+}
>+uchar4 operator.xyxy(uchar3 v) {
>+    uchar4 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.x;
>+    result.w = v.y;
>+    return result;
>+}
>+uchar4 operator.xyxy(uchar4 v) {
>+    uchar4 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.x;
>+    result.w = v.y;
>+    return result;
>+}
>+ushort4 operator.xyxy(ushort2 v) {
>+    ushort4 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.x;
>+    result.w = v.y;
>+    return result;
>+}
>+ushort4 operator.xyxy(ushort3 v) {
>+    ushort4 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.x;
>+    result.w = v.y;
>+    return result;
>+}
>+ushort4 operator.xyxy(ushort4 v) {
>+    ushort4 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.x;
>+    result.w = v.y;
>+    return result;
>+}
>+uint4 operator.xyxy(uint2 v) {
>+    uint4 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.x;
>+    result.w = v.y;
>+    return result;
>+}
>+uint4 operator.xyxy(uint3 v) {
>+    uint4 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.x;
>+    result.w = v.y;
>+    return result;
>+}
>+uint4 operator.xyxy(uint4 v) {
>+    uint4 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.x;
>+    result.w = v.y;
>+    return result;
>+}
>+char4 operator.xyxy(char2 v) {
>+    char4 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.x;
>+    result.w = v.y;
>+    return result;
>+}
>+char4 operator.xyxy(char3 v) {
>+    char4 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.x;
>+    result.w = v.y;
>+    return result;
>+}
>+char4 operator.xyxy(char4 v) {
>+    char4 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.x;
>+    result.w = v.y;
>+    return result;
>+}
>+short4 operator.xyxy(short2 v) {
>+    short4 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.x;
>+    result.w = v.y;
>+    return result;
>+}
>+short4 operator.xyxy(short3 v) {
>+    short4 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.x;
>+    result.w = v.y;
>+    return result;
>+}
>+short4 operator.xyxy(short4 v) {
>+    short4 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.x;
>+    result.w = v.y;
>+    return result;
>+}
>+int4 operator.xyxy(int2 v) {
>+    int4 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.x;
>+    result.w = v.y;
>+    return result;
>+}
>+int4 operator.xyxy(int3 v) {
>+    int4 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.x;
>+    result.w = v.y;
>+    return result;
>+}
>+int4 operator.xyxy(int4 v) {
>+    int4 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.x;
>+    result.w = v.y;
>+    return result;
>+}
>+half4 operator.xyxy(half2 v) {
>+    half4 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.x;
>+    result.w = v.y;
>+    return result;
>+}
>+half4 operator.xyxy(half3 v) {
>+    half4 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.x;
>+    result.w = v.y;
>+    return result;
>+}
>+half4 operator.xyxy(half4 v) {
>+    half4 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.x;
>+    result.w = v.y;
>+    return result;
>+}
>+float4 operator.xyxy(float2 v) {
>+    float4 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.x;
>+    result.w = v.y;
>+    return result;
>+}
>+float4 operator.xyxy(float3 v) {
>+    float4 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.x;
>+    result.w = v.y;
>+    return result;
>+}
>+float4 operator.xyxy(float4 v) {
>+    float4 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.x;
>+    result.w = v.y;
>+    return result;
>+}
>+
>+/* Functions named operator.yyyx */
>+bool4 operator.yyyx(bool2 v) {
>+    bool4 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.y;
>+    result.w = v.x;
>+    return result;
>+}
>+bool4 operator.yyyx(bool3 v) {
>+    bool4 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.y;
>+    result.w = v.x;
>+    return result;
>+}
>+bool4 operator.yyyx(bool4 v) {
>+    bool4 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.y;
>+    result.w = v.x;
>+    return result;
>+}
>+uchar4 operator.yyyx(uchar2 v) {
>+    uchar4 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.y;
>+    result.w = v.x;
>+    return result;
>+}
>+uchar4 operator.yyyx(uchar3 v) {
>+    uchar4 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.y;
>+    result.w = v.x;
>+    return result;
>+}
>+uchar4 operator.yyyx(uchar4 v) {
>+    uchar4 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.y;
>+    result.w = v.x;
>+    return result;
>+}
>+ushort4 operator.yyyx(ushort2 v) {
>+    ushort4 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.y;
>+    result.w = v.x;
>+    return result;
>+}
>+ushort4 operator.yyyx(ushort3 v) {
>+    ushort4 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.y;
>+    result.w = v.x;
>+    return result;
>+}
>+ushort4 operator.yyyx(ushort4 v) {
>+    ushort4 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.y;
>+    result.w = v.x;
>+    return result;
>+}
>+uint4 operator.yyyx(uint2 v) {
>+    uint4 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.y;
>+    result.w = v.x;
>+    return result;
>+}
>+uint4 operator.yyyx(uint3 v) {
>+    uint4 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.y;
>+    result.w = v.x;
>+    return result;
>+}
>+uint4 operator.yyyx(uint4 v) {
>+    uint4 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.y;
>+    result.w = v.x;
>+    return result;
>+}
>+char4 operator.yyyx(char2 v) {
>+    char4 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.y;
>+    result.w = v.x;
>+    return result;
>+}
>+char4 operator.yyyx(char3 v) {
>+    char4 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.y;
>+    result.w = v.x;
>+    return result;
>+}
>+char4 operator.yyyx(char4 v) {
>+    char4 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.y;
>+    result.w = v.x;
>+    return result;
>+}
>+short4 operator.yyyx(short2 v) {
>+    short4 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.y;
>+    result.w = v.x;
>+    return result;
>+}
>+short4 operator.yyyx(short3 v) {
>+    short4 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.y;
>+    result.w = v.x;
>+    return result;
>+}
>+short4 operator.yyyx(short4 v) {
>+    short4 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.y;
>+    result.w = v.x;
>+    return result;
>+}
>+int4 operator.yyyx(int2 v) {
>+    int4 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.y;
>+    result.w = v.x;
>+    return result;
>+}
>+int4 operator.yyyx(int3 v) {
>+    int4 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.y;
>+    result.w = v.x;
>+    return result;
>+}
>+int4 operator.yyyx(int4 v) {
>+    int4 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.y;
>+    result.w = v.x;
>+    return result;
>+}
>+half4 operator.yyyx(half2 v) {
>+    half4 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.y;
>+    result.w = v.x;
>+    return result;
>+}
>+half4 operator.yyyx(half3 v) {
>+    half4 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.y;
>+    result.w = v.x;
>+    return result;
>+}
>+half4 operator.yyyx(half4 v) {
>+    half4 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.y;
>+    result.w = v.x;
>+    return result;
>+}
>+float4 operator.yyyx(float2 v) {
>+    float4 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.y;
>+    result.w = v.x;
>+    return result;
>+}
>+float4 operator.yyyx(float3 v) {
>+    float4 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.y;
>+    result.w = v.x;
>+    return result;
>+}
>+float4 operator.yyyx(float4 v) {
>+    float4 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.y;
>+    result.w = v.x;
>+    return result;
>+}
>+
>+/* Functions named operator.yzzx */
>+bool4 operator.yzzx(bool3 v) {
>+    bool4 result;
>+    result.x = v.y;
>+    result.y = v.z;
>+    result.z = v.z;
>+    result.w = v.x;
>+    return result;
>+}
>+bool4 operator.yzzx(bool4 v) {
>+    bool4 result;
>+    result.x = v.y;
>+    result.y = v.z;
>+    result.z = v.z;
>+    result.w = v.x;
>+    return result;
>+}
>+uchar4 operator.yzzx(uchar3 v) {
>+    uchar4 result;
>+    result.x = v.y;
>+    result.y = v.z;
>+    result.z = v.z;
>+    result.w = v.x;
>+    return result;
>+}
>+uchar4 operator.yzzx(uchar4 v) {
>+    uchar4 result;
>+    result.x = v.y;
>+    result.y = v.z;
>+    result.z = v.z;
>+    result.w = v.x;
>+    return result;
>+}
>+ushort4 operator.yzzx(ushort3 v) {
>+    ushort4 result;
>+    result.x = v.y;
>+    result.y = v.z;
>+    result.z = v.z;
>+    result.w = v.x;
>+    return result;
>+}
>+ushort4 operator.yzzx(ushort4 v) {
>+    ushort4 result;
>+    result.x = v.y;
>+    result.y = v.z;
>+    result.z = v.z;
>+    result.w = v.x;
>+    return result;
>+}
>+uint4 operator.yzzx(uint3 v) {
>+    uint4 result;
>+    result.x = v.y;
>+    result.y = v.z;
>+    result.z = v.z;
>+    result.w = v.x;
>+    return result;
>+}
>+uint4 operator.yzzx(uint4 v) {
>+    uint4 result;
>+    result.x = v.y;
>+    result.y = v.z;
>+    result.z = v.z;
>+    result.w = v.x;
>+    return result;
>+}
>+char4 operator.yzzx(char3 v) {
>+    char4 result;
>+    result.x = v.y;
>+    result.y = v.z;
>+    result.z = v.z;
>+    result.w = v.x;
>+    return result;
>+}
>+char4 operator.yzzx(char4 v) {
>+    char4 result;
>+    result.x = v.y;
>+    result.y = v.z;
>+    result.z = v.z;
>+    result.w = v.x;
>+    return result;
>+}
>+short4 operator.yzzx(short3 v) {
>+    short4 result;
>+    result.x = v.y;
>+    result.y = v.z;
>+    result.z = v.z;
>+    result.w = v.x;
>+    return result;
>+}
>+short4 operator.yzzx(short4 v) {
>+    short4 result;
>+    result.x = v.y;
>+    result.y = v.z;
>+    result.z = v.z;
>+    result.w = v.x;
>+    return result;
>+}
>+int4 operator.yzzx(int3 v) {
>+    int4 result;
>+    result.x = v.y;
>+    result.y = v.z;
>+    result.z = v.z;
>+    result.w = v.x;
>+    return result;
>+}
>+int4 operator.yzzx(int4 v) {
>+    int4 result;
>+    result.x = v.y;
>+    result.y = v.z;
>+    result.z = v.z;
>+    result.w = v.x;
>+    return result;
>+}
>+half4 operator.yzzx(half3 v) {
>+    half4 result;
>+    result.x = v.y;
>+    result.y = v.z;
>+    result.z = v.z;
>+    result.w = v.x;
>+    return result;
>+}
>+half4 operator.yzzx(half4 v) {
>+    half4 result;
>+    result.x = v.y;
>+    result.y = v.z;
>+    result.z = v.z;
>+    result.w = v.x;
>+    return result;
>+}
>+float4 operator.yzzx(float3 v) {
>+    float4 result;
>+    result.x = v.y;
>+    result.y = v.z;
>+    result.z = v.z;
>+    result.w = v.x;
>+    return result;
>+}
>+float4 operator.yzzx(float4 v) {
>+    float4 result;
>+    result.x = v.y;
>+    result.y = v.z;
>+    result.z = v.z;
>+    result.w = v.x;
>+    return result;
>+}
>+
>+/* Functions named operator.xzz */
>+bool3 operator.xzz(bool3 v) {
>+    bool3 result;
>+    result.x = v.x;
>+    result.y = v.z;
>+    result.z = v.z;
>+    return result;
>+}
>+bool3 operator.xzz(bool4 v) {
>+    bool3 result;
>+    result.x = v.x;
>+    result.y = v.z;
>+    result.z = v.z;
>+    return result;
>+}
>+uchar3 operator.xzz(uchar3 v) {
>+    uchar3 result;
>+    result.x = v.x;
>+    result.y = v.z;
>+    result.z = v.z;
>+    return result;
>+}
>+uchar3 operator.xzz(uchar4 v) {
>+    uchar3 result;
>+    result.x = v.x;
>+    result.y = v.z;
>+    result.z = v.z;
>+    return result;
>+}
>+ushort3 operator.xzz(ushort3 v) {
>+    ushort3 result;
>+    result.x = v.x;
>+    result.y = v.z;
>+    result.z = v.z;
>+    return result;
>+}
>+ushort3 operator.xzz(ushort4 v) {
>+    ushort3 result;
>+    result.x = v.x;
>+    result.y = v.z;
>+    result.z = v.z;
>+    return result;
>+}
>+uint3 operator.xzz(uint3 v) {
>+    uint3 result;
>+    result.x = v.x;
>+    result.y = v.z;
>+    result.z = v.z;
>+    return result;
>+}
>+uint3 operator.xzz(uint4 v) {
>+    uint3 result;
>+    result.x = v.x;
>+    result.y = v.z;
>+    result.z = v.z;
>+    return result;
>+}
>+char3 operator.xzz(char3 v) {
>+    char3 result;
>+    result.x = v.x;
>+    result.y = v.z;
>+    result.z = v.z;
>+    return result;
>+}
>+char3 operator.xzz(char4 v) {
>+    char3 result;
>+    result.x = v.x;
>+    result.y = v.z;
>+    result.z = v.z;
>+    return result;
>+}
>+short3 operator.xzz(short3 v) {
>+    short3 result;
>+    result.x = v.x;
>+    result.y = v.z;
>+    result.z = v.z;
>+    return result;
>+}
>+short3 operator.xzz(short4 v) {
>+    short3 result;
>+    result.x = v.x;
>+    result.y = v.z;
>+    result.z = v.z;
>+    return result;
>+}
>+int3 operator.xzz(int3 v) {
>+    int3 result;
>+    result.x = v.x;
>+    result.y = v.z;
>+    result.z = v.z;
>+    return result;
>+}
>+int3 operator.xzz(int4 v) {
>+    int3 result;
>+    result.x = v.x;
>+    result.y = v.z;
>+    result.z = v.z;
>+    return result;
>+}
>+half3 operator.xzz(half3 v) {
>+    half3 result;
>+    result.x = v.x;
>+    result.y = v.z;
>+    result.z = v.z;
>+    return result;
>+}
>+half3 operator.xzz(half4 v) {
>+    half3 result;
>+    result.x = v.x;
>+    result.y = v.z;
>+    result.z = v.z;
>+    return result;
>+}
>+float3 operator.xzz(float3 v) {
>+    float3 result;
>+    result.x = v.x;
>+    result.y = v.z;
>+    result.z = v.z;
>+    return result;
>+}
>+float3 operator.xzz(float4 v) {
>+    float3 result;
>+    result.x = v.x;
>+    result.y = v.z;
>+    result.z = v.z;
>+    return result;
>+}
>+
>+/* Functions named operator.yxyz */
>+bool4 operator.yxyz(bool3 v) {
>+    bool4 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.y;
>+    result.w = v.z;
>+    return result;
>+}
>+bool4 operator.yxyz(bool4 v) {
>+    bool4 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.y;
>+    result.w = v.z;
>+    return result;
>+}
>+uchar4 operator.yxyz(uchar3 v) {
>+    uchar4 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.y;
>+    result.w = v.z;
>+    return result;
>+}
>+uchar4 operator.yxyz(uchar4 v) {
>+    uchar4 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.y;
>+    result.w = v.z;
>+    return result;
>+}
>+ushort4 operator.yxyz(ushort3 v) {
>+    ushort4 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.y;
>+    result.w = v.z;
>+    return result;
>+}
>+ushort4 operator.yxyz(ushort4 v) {
>+    ushort4 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.y;
>+    result.w = v.z;
>+    return result;
>+}
>+uint4 operator.yxyz(uint3 v) {
>+    uint4 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.y;
>+    result.w = v.z;
>+    return result;
>+}
>+uint4 operator.yxyz(uint4 v) {
>+    uint4 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.y;
>+    result.w = v.z;
>+    return result;
>+}
>+char4 operator.yxyz(char3 v) {
>+    char4 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.y;
>+    result.w = v.z;
>+    return result;
>+}
>+char4 operator.yxyz(char4 v) {
>+    char4 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.y;
>+    result.w = v.z;
>+    return result;
>+}
>+short4 operator.yxyz(short3 v) {
>+    short4 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.y;
>+    result.w = v.z;
>+    return result;
>+}
>+short4 operator.yxyz(short4 v) {
>+    short4 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.y;
>+    result.w = v.z;
>+    return result;
>+}
>+int4 operator.yxyz(int3 v) {
>+    int4 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.y;
>+    result.w = v.z;
>+    return result;
>+}
>+int4 operator.yxyz(int4 v) {
>+    int4 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.y;
>+    result.w = v.z;
>+    return result;
>+}
>+half4 operator.yxyz(half3 v) {
>+    half4 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.y;
>+    result.w = v.z;
>+    return result;
>+}
>+half4 operator.yxyz(half4 v) {
>+    half4 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.y;
>+    result.w = v.z;
>+    return result;
>+}
>+float4 operator.yxyz(float3 v) {
>+    float4 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.y;
>+    result.w = v.z;
>+    return result;
>+}
>+float4 operator.yxyz(float4 v) {
>+    float4 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.y;
>+    result.w = v.z;
>+    return result;
>+}
>+
>+/* Functions named operator.zzxx */
>+bool4 operator.zzxx(bool3 v) {
>+    bool4 result;
>+    result.x = v.z;
>+    result.y = v.z;
>+    result.z = v.x;
>+    result.w = v.x;
>+    return result;
>+}
>+bool4 operator.zzxx(bool4 v) {
>+    bool4 result;
>+    result.x = v.z;
>+    result.y = v.z;
>+    result.z = v.x;
>+    result.w = v.x;
>+    return result;
>+}
>+uchar4 operator.zzxx(uchar3 v) {
>+    uchar4 result;
>+    result.x = v.z;
>+    result.y = v.z;
>+    result.z = v.x;
>+    result.w = v.x;
>+    return result;
>+}
>+uchar4 operator.zzxx(uchar4 v) {
>+    uchar4 result;
>+    result.x = v.z;
>+    result.y = v.z;
>+    result.z = v.x;
>+    result.w = v.x;
>+    return result;
>+}
>+ushort4 operator.zzxx(ushort3 v) {
>+    ushort4 result;
>+    result.x = v.z;
>+    result.y = v.z;
>+    result.z = v.x;
>+    result.w = v.x;
>+    return result;
>+}
>+ushort4 operator.zzxx(ushort4 v) {
>+    ushort4 result;
>+    result.x = v.z;
>+    result.y = v.z;
>+    result.z = v.x;
>+    result.w = v.x;
>+    return result;
>+}
>+uint4 operator.zzxx(uint3 v) {
>+    uint4 result;
>+    result.x = v.z;
>+    result.y = v.z;
>+    result.z = v.x;
>+    result.w = v.x;
>+    return result;
>+}
>+uint4 operator.zzxx(uint4 v) {
>+    uint4 result;
>+    result.x = v.z;
>+    result.y = v.z;
>+    result.z = v.x;
>+    result.w = v.x;
>+    return result;
>+}
>+char4 operator.zzxx(char3 v) {
>+    char4 result;
>+    result.x = v.z;
>+    result.y = v.z;
>+    result.z = v.x;
>+    result.w = v.x;
>+    return result;
>+}
>+char4 operator.zzxx(char4 v) {
>+    char4 result;
>+    result.x = v.z;
>+    result.y = v.z;
>+    result.z = v.x;
>+    result.w = v.x;
>+    return result;
>+}
>+short4 operator.zzxx(short3 v) {
>+    short4 result;
>+    result.x = v.z;
>+    result.y = v.z;
>+    result.z = v.x;
>+    result.w = v.x;
>+    return result;
>+}
>+short4 operator.zzxx(short4 v) {
>+    short4 result;
>+    result.x = v.z;
>+    result.y = v.z;
>+    result.z = v.x;
>+    result.w = v.x;
>+    return result;
>+}
>+int4 operator.zzxx(int3 v) {
>+    int4 result;
>+    result.x = v.z;
>+    result.y = v.z;
>+    result.z = v.x;
>+    result.w = v.x;
>+    return result;
>+}
>+int4 operator.zzxx(int4 v) {
>+    int4 result;
>+    result.x = v.z;
>+    result.y = v.z;
>+    result.z = v.x;
>+    result.w = v.x;
>+    return result;
>+}
>+half4 operator.zzxx(half3 v) {
>+    half4 result;
>+    result.x = v.z;
>+    result.y = v.z;
>+    result.z = v.x;
>+    result.w = v.x;
>+    return result;
>+}
>+half4 operator.zzxx(half4 v) {
>+    half4 result;
>+    result.x = v.z;
>+    result.y = v.z;
>+    result.z = v.x;
>+    result.w = v.x;
>+    return result;
>+}
>+float4 operator.zzxx(float3 v) {
>+    float4 result;
>+    result.x = v.z;
>+    result.y = v.z;
>+    result.z = v.x;
>+    result.w = v.x;
>+    return result;
>+}
>+float4 operator.zzxx(float4 v) {
>+    float4 result;
>+    result.x = v.z;
>+    result.y = v.z;
>+    result.z = v.x;
>+    result.w = v.x;
>+    return result;
>+}
>+
>+/* Functions named operator.zzwx */
>+bool4 operator.zzwx(bool4 v) {
>+    bool4 result;
>+    result.x = v.z;
>+    result.y = v.z;
>+    result.z = v.w;
>+    result.w = v.x;
>+    return result;
>+}
>+uchar4 operator.zzwx(uchar4 v) {
>+    uchar4 result;
>+    result.x = v.z;
>+    result.y = v.z;
>+    result.z = v.w;
>+    result.w = v.x;
>+    return result;
>+}
>+ushort4 operator.zzwx(ushort4 v) {
>+    ushort4 result;
>+    result.x = v.z;
>+    result.y = v.z;
>+    result.z = v.w;
>+    result.w = v.x;
>+    return result;
>+}
>+uint4 operator.zzwx(uint4 v) {
>+    uint4 result;
>+    result.x = v.z;
>+    result.y = v.z;
>+    result.z = v.w;
>+    result.w = v.x;
>+    return result;
>+}
>+char4 operator.zzwx(char4 v) {
>+    char4 result;
>+    result.x = v.z;
>+    result.y = v.z;
>+    result.z = v.w;
>+    result.w = v.x;
>+    return result;
>+}
>+short4 operator.zzwx(short4 v) {
>+    short4 result;
>+    result.x = v.z;
>+    result.y = v.z;
>+    result.z = v.w;
>+    result.w = v.x;
>+    return result;
>+}
>+int4 operator.zzwx(int4 v) {
>+    int4 result;
>+    result.x = v.z;
>+    result.y = v.z;
>+    result.z = v.w;
>+    result.w = v.x;
>+    return result;
>+}
>+half4 operator.zzwx(half4 v) {
>+    half4 result;
>+    result.x = v.z;
>+    result.y = v.z;
>+    result.z = v.w;
>+    result.w = v.x;
>+    return result;
>+}
>+float4 operator.zzwx(float4 v) {
>+    float4 result;
>+    result.x = v.z;
>+    result.y = v.z;
>+    result.z = v.w;
>+    result.w = v.x;
>+    return result;
>+}
>+
>+/* Functions named operator.yxx */
>+bool3 operator.yxx(bool2 v) {
>+    bool3 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.x;
>+    return result;
>+}
>+bool3 operator.yxx(bool3 v) {
>+    bool3 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.x;
>+    return result;
>+}
>+bool3 operator.yxx(bool4 v) {
>+    bool3 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.x;
>+    return result;
>+}
>+uchar3 operator.yxx(uchar2 v) {
>+    uchar3 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.x;
>+    return result;
>+}
>+uchar3 operator.yxx(uchar3 v) {
>+    uchar3 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.x;
>+    return result;
>+}
>+uchar3 operator.yxx(uchar4 v) {
>+    uchar3 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.x;
>+    return result;
>+}
>+ushort3 operator.yxx(ushort2 v) {
>+    ushort3 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.x;
>+    return result;
>+}
>+ushort3 operator.yxx(ushort3 v) {
>+    ushort3 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.x;
>+    return result;
>+}
>+ushort3 operator.yxx(ushort4 v) {
>+    ushort3 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.x;
>+    return result;
>+}
>+uint3 operator.yxx(uint2 v) {
>+    uint3 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.x;
>+    return result;
>+}
>+uint3 operator.yxx(uint3 v) {
>+    uint3 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.x;
>+    return result;
>+}
>+uint3 operator.yxx(uint4 v) {
>+    uint3 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.x;
>+    return result;
>+}
>+char3 operator.yxx(char2 v) {
>+    char3 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.x;
>+    return result;
>+}
>+char3 operator.yxx(char3 v) {
>+    char3 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.x;
>+    return result;
>+}
>+char3 operator.yxx(char4 v) {
>+    char3 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.x;
>+    return result;
>+}
>+short3 operator.yxx(short2 v) {
>+    short3 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.x;
>+    return result;
>+}
>+short3 operator.yxx(short3 v) {
>+    short3 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.x;
>+    return result;
>+}
>+short3 operator.yxx(short4 v) {
>+    short3 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.x;
>+    return result;
>+}
>+int3 operator.yxx(int2 v) {
>+    int3 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.x;
>+    return result;
>+}
>+int3 operator.yxx(int3 v) {
>+    int3 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.x;
>+    return result;
>+}
>+int3 operator.yxx(int4 v) {
>+    int3 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.x;
>+    return result;
>+}
>+half3 operator.yxx(half2 v) {
>+    half3 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.x;
>+    return result;
>+}
>+half3 operator.yxx(half3 v) {
>+    half3 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.x;
>+    return result;
>+}
>+half3 operator.yxx(half4 v) {
>+    half3 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.x;
>+    return result;
>+}
>+float3 operator.yxx(float2 v) {
>+    float3 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.x;
>+    return result;
>+}
>+float3 operator.yxx(float3 v) {
>+    float3 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.x;
>+    return result;
>+}
>+float3 operator.yxx(float4 v) {
>+    float3 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.x;
>+    return result;
>+}
>+
>+/* Functions named DeviceMemoryBarrierWithGroupSync */
>+native void DeviceMemoryBarrierWithGroupSync();
>+
>+/* Functions named operator.zwww */
>+bool4 operator.zwww(bool4 v) {
>+    bool4 result;
>+    result.x = v.z;
>+    result.y = v.w;
>+    result.z = v.w;
>+    result.w = v.w;
>+    return result;
>+}
>+uchar4 operator.zwww(uchar4 v) {
>+    uchar4 result;
>+    result.x = v.z;
>+    result.y = v.w;
>+    result.z = v.w;
>+    result.w = v.w;
>+    return result;
>+}
>+ushort4 operator.zwww(ushort4 v) {
>+    ushort4 result;
>+    result.x = v.z;
>+    result.y = v.w;
>+    result.z = v.w;
>+    result.w = v.w;
>+    return result;
>+}
>+uint4 operator.zwww(uint4 v) {
>+    uint4 result;
>+    result.x = v.z;
>+    result.y = v.w;
>+    result.z = v.w;
>+    result.w = v.w;
>+    return result;
>+}
>+char4 operator.zwww(char4 v) {
>+    char4 result;
>+    result.x = v.z;
>+    result.y = v.w;
>+    result.z = v.w;
>+    result.w = v.w;
>+    return result;
>+}
>+short4 operator.zwww(short4 v) {
>+    short4 result;
>+    result.x = v.z;
>+    result.y = v.w;
>+    result.z = v.w;
>+    result.w = v.w;
>+    return result;
>+}
>+int4 operator.zwww(int4 v) {
>+    int4 result;
>+    result.x = v.z;
>+    result.y = v.w;
>+    result.z = v.w;
>+    result.w = v.w;
>+    return result;
>+}
>+half4 operator.zwww(half4 v) {
>+    half4 result;
>+    result.x = v.z;
>+    result.y = v.w;
>+    result.z = v.w;
>+    result.w = v.w;
>+    return result;
>+}
>+float4 operator.zwww(float4 v) {
>+    float4 result;
>+    result.x = v.z;
>+    result.y = v.w;
>+    result.z = v.w;
>+    result.w = v.w;
>+    return result;
>+}
>+
>+/* Functions named operator.wzz */
>+bool3 operator.wzz(bool4 v) {
>+    bool3 result;
>+    result.x = v.w;
>+    result.y = v.z;
>+    result.z = v.z;
>+    return result;
>+}
>+uchar3 operator.wzz(uchar4 v) {
>+    uchar3 result;
>+    result.x = v.w;
>+    result.y = v.z;
>+    result.z = v.z;
>+    return result;
>+}
>+ushort3 operator.wzz(ushort4 v) {
>+    ushort3 result;
>+    result.x = v.w;
>+    result.y = v.z;
>+    result.z = v.z;
>+    return result;
>+}
>+uint3 operator.wzz(uint4 v) {
>+    uint3 result;
>+    result.x = v.w;
>+    result.y = v.z;
>+    result.z = v.z;
>+    return result;
>+}
>+char3 operator.wzz(char4 v) {
>+    char3 result;
>+    result.x = v.w;
>+    result.y = v.z;
>+    result.z = v.z;
>+    return result;
>+}
>+short3 operator.wzz(short4 v) {
>+    short3 result;
>+    result.x = v.w;
>+    result.y = v.z;
>+    result.z = v.z;
>+    return result;
>+}
>+int3 operator.wzz(int4 v) {
>+    int3 result;
>+    result.x = v.w;
>+    result.y = v.z;
>+    result.z = v.z;
>+    return result;
>+}
>+half3 operator.wzz(half4 v) {
>+    half3 result;
>+    result.x = v.w;
>+    result.y = v.z;
>+    result.z = v.z;
>+    return result;
>+}
>+float3 operator.wzz(float4 v) {
>+    float3 result;
>+    result.x = v.w;
>+    result.y = v.z;
>+    result.z = v.z;
>+    return result;
>+}
>+
>+/* Functions named fmod */
>+half fmod(half x, half y) {
>+    uint whole = uint(x / y);
>+    half multiple = half(whole) * y;
>+    return x - multiple;
>+}
>+half2 fmod(half2 x, half2 y) {
>+    half2 result;
>+    result[0] = fmod(x[0], y[0]);
>+    result[1] = fmod(x[1], y[1]);
>+    return result;
>+}
>+half3 fmod(half3 x, half3 y) {
>+    half3 result;
>+    result[0] = fmod(x[0], y[0]);
>+    result[1] = fmod(x[1], y[1]);
>+    result[2] = fmod(x[2], y[2]);
>+    return result;
>+}
>+half4 fmod(half4 x, half4 y) {
>+    half4 result;
>+    result[0] = fmod(x[0], y[0]);
>+    result[1] = fmod(x[1], y[1]);
>+    result[2] = fmod(x[2], y[2]);
>+    result[3] = fmod(x[3], y[3]);
>+    return result;
>+}
>+half2x2 fmod(half2x2 x, half2x2 y) {
>+    half2x2 result;
>+    result[0][0] = fmod(x[0][0], y[0][0]);
>+    result[0][1] = fmod(x[0][1], y[0][1]);
>+    result[1][0] = fmod(x[1][0], y[1][0]);
>+    result[1][1] = fmod(x[1][1], y[1][1]);
>+    return result;
>+}
>+half2x3 fmod(half2x3 x, half2x3 y) {
>+    half2x3 result;
>+    result[0][0] = fmod(x[0][0], y[0][0]);
>+    result[0][1] = fmod(x[0][1], y[0][1]);
>+    result[0][2] = fmod(x[0][2], y[0][2]);
>+    result[1][0] = fmod(x[1][0], y[1][0]);
>+    result[1][1] = fmod(x[1][1], y[1][1]);
>+    result[1][2] = fmod(x[1][2], y[1][2]);
>+    return result;
>+}
>+half2x4 fmod(half2x4 x, half2x4 y) {
>+    half2x4 result;
>+    result[0][0] = fmod(x[0][0], y[0][0]);
>+    result[0][1] = fmod(x[0][1], y[0][1]);
>+    result[0][2] = fmod(x[0][2], y[0][2]);
>+    result[0][3] = fmod(x[0][3], y[0][3]);
>+    result[1][0] = fmod(x[1][0], y[1][0]);
>+    result[1][1] = fmod(x[1][1], y[1][1]);
>+    result[1][2] = fmod(x[1][2], y[1][2]);
>+    result[1][3] = fmod(x[1][3], y[1][3]);
>+    return result;
>+}
>+half3x2 fmod(half3x2 x, half3x2 y) {
>+    half3x2 result;
>+    result[0][0] = fmod(x[0][0], y[0][0]);
>+    result[0][1] = fmod(x[0][1], y[0][1]);
>+    result[1][0] = fmod(x[1][0], y[1][0]);
>+    result[1][1] = fmod(x[1][1], y[1][1]);
>+    result[2][0] = fmod(x[2][0], y[2][0]);
>+    result[2][1] = fmod(x[2][1], y[2][1]);
>+    return result;
>+}
>+half3x3 fmod(half3x3 x, half3x3 y) {
>+    half3x3 result;
>+    result[0][0] = fmod(x[0][0], y[0][0]);
>+    result[0][1] = fmod(x[0][1], y[0][1]);
>+    result[0][2] = fmod(x[0][2], y[0][2]);
>+    result[1][0] = fmod(x[1][0], y[1][0]);
>+    result[1][1] = fmod(x[1][1], y[1][1]);
>+    result[1][2] = fmod(x[1][2], y[1][2]);
>+    result[2][0] = fmod(x[2][0], y[2][0]);
>+    result[2][1] = fmod(x[2][1], y[2][1]);
>+    result[2][2] = fmod(x[2][2], y[2][2]);
>+    return result;
>+}
>+half3x4 fmod(half3x4 x, half3x4 y) {
>+    half3x4 result;
>+    result[0][0] = fmod(x[0][0], y[0][0]);
>+    result[0][1] = fmod(x[0][1], y[0][1]);
>+    result[0][2] = fmod(x[0][2], y[0][2]);
>+    result[0][3] = fmod(x[0][3], y[0][3]);
>+    result[1][0] = fmod(x[1][0], y[1][0]);
>+    result[1][1] = fmod(x[1][1], y[1][1]);
>+    result[1][2] = fmod(x[1][2], y[1][2]);
>+    result[1][3] = fmod(x[1][3], y[1][3]);
>+    result[2][0] = fmod(x[2][0], y[2][0]);
>+    result[2][1] = fmod(x[2][1], y[2][1]);
>+    result[2][2] = fmod(x[2][2], y[2][2]);
>+    result[2][3] = fmod(x[2][3], y[2][3]);
>+    return result;
>+}
>+half4x2 fmod(half4x2 x, half4x2 y) {
>+    half4x2 result;
>+    result[0][0] = fmod(x[0][0], y[0][0]);
>+    result[0][1] = fmod(x[0][1], y[0][1]);
>+    result[1][0] = fmod(x[1][0], y[1][0]);
>+    result[1][1] = fmod(x[1][1], y[1][1]);
>+    result[2][0] = fmod(x[2][0], y[2][0]);
>+    result[2][1] = fmod(x[2][1], y[2][1]);
>+    result[3][0] = fmod(x[3][0], y[3][0]);
>+    result[3][1] = fmod(x[3][1], y[3][1]);
>+    return result;
>+}
>+half4x3 fmod(half4x3 x, half4x3 y) {
>+    half4x3 result;
>+    result[0][0] = fmod(x[0][0], y[0][0]);
>+    result[0][1] = fmod(x[0][1], y[0][1]);
>+    result[0][2] = fmod(x[0][2], y[0][2]);
>+    result[1][0] = fmod(x[1][0], y[1][0]);
>+    result[1][1] = fmod(x[1][1], y[1][1]);
>+    result[1][2] = fmod(x[1][2], y[1][2]);
>+    result[2][0] = fmod(x[2][0], y[2][0]);
>+    result[2][1] = fmod(x[2][1], y[2][1]);
>+    result[2][2] = fmod(x[2][2], y[2][2]);
>+    result[3][0] = fmod(x[3][0], y[3][0]);
>+    result[3][1] = fmod(x[3][1], y[3][1]);
>+    result[3][2] = fmod(x[3][2], y[3][2]);
>+    return result;
>+}
>+half4x4 fmod(half4x4 x, half4x4 y) {
>+    half4x4 result;
>+    result[0][0] = fmod(x[0][0], y[0][0]);
>+    result[0][1] = fmod(x[0][1], y[0][1]);
>+    result[0][2] = fmod(x[0][2], y[0][2]);
>+    result[0][3] = fmod(x[0][3], y[0][3]);
>+    result[1][0] = fmod(x[1][0], y[1][0]);
>+    result[1][1] = fmod(x[1][1], y[1][1]);
>+    result[1][2] = fmod(x[1][2], y[1][2]);
>+    result[1][3] = fmod(x[1][3], y[1][3]);
>+    result[2][0] = fmod(x[2][0], y[2][0]);
>+    result[2][1] = fmod(x[2][1], y[2][1]);
>+    result[2][2] = fmod(x[2][2], y[2][2]);
>+    result[2][3] = fmod(x[2][3], y[2][3]);
>+    result[3][0] = fmod(x[3][0], y[3][0]);
>+    result[3][1] = fmod(x[3][1], y[3][1]);
>+    result[3][2] = fmod(x[3][2], y[3][2]);
>+    result[3][3] = fmod(x[3][3], y[3][3]);
>+    return result;
>+}
>+
>+float fmod(float x, float y) {
>+    uint whole = uint(x / y);
>+    float multiple = float(whole) * y;
>+    return x - multiple;
>+}
>+float2 fmod(float2 x, float2 y) {
>+    float2 result;
>+    result[0] = fmod(x[0], y[0]);
>+    result[1] = fmod(x[1], y[1]);
>+    return result;
>+}
>+float3 fmod(float3 x, float3 y) {
>+    float3 result;
>+    result[0] = fmod(x[0], y[0]);
>+    result[1] = fmod(x[1], y[1]);
>+    result[2] = fmod(x[2], y[2]);
>+    return result;
>+}
>+float4 fmod(float4 x, float4 y) {
>+    float4 result;
>+    result[0] = fmod(x[0], y[0]);
>+    result[1] = fmod(x[1], y[1]);
>+    result[2] = fmod(x[2], y[2]);
>+    result[3] = fmod(x[3], y[3]);
>+    return result;
>+}
>+float2x2 fmod(float2x2 x, float2x2 y) {
>+    float2x2 result;
>+    result[0][0] = fmod(x[0][0], y[0][0]);
>+    result[0][1] = fmod(x[0][1], y[0][1]);
>+    result[1][0] = fmod(x[1][0], y[1][0]);
>+    result[1][1] = fmod(x[1][1], y[1][1]);
>+    return result;
>+}
>+float2x3 fmod(float2x3 x, float2x3 y) {
>+    float2x3 result;
>+    result[0][0] = fmod(x[0][0], y[0][0]);
>+    result[0][1] = fmod(x[0][1], y[0][1]);
>+    result[0][2] = fmod(x[0][2], y[0][2]);
>+    result[1][0] = fmod(x[1][0], y[1][0]);
>+    result[1][1] = fmod(x[1][1], y[1][1]);
>+    result[1][2] = fmod(x[1][2], y[1][2]);
>+    return result;
>+}
>+float2x4 fmod(float2x4 x, float2x4 y) {
>+    float2x4 result;
>+    result[0][0] = fmod(x[0][0], y[0][0]);
>+    result[0][1] = fmod(x[0][1], y[0][1]);
>+    result[0][2] = fmod(x[0][2], y[0][2]);
>+    result[0][3] = fmod(x[0][3], y[0][3]);
>+    result[1][0] = fmod(x[1][0], y[1][0]);
>+    result[1][1] = fmod(x[1][1], y[1][1]);
>+    result[1][2] = fmod(x[1][2], y[1][2]);
>+    result[1][3] = fmod(x[1][3], y[1][3]);
>+    return result;
>+}
>+float3x2 fmod(float3x2 x, float3x2 y) {
>+    float3x2 result;
>+    result[0][0] = fmod(x[0][0], y[0][0]);
>+    result[0][1] = fmod(x[0][1], y[0][1]);
>+    result[1][0] = fmod(x[1][0], y[1][0]);
>+    result[1][1] = fmod(x[1][1], y[1][1]);
>+    result[2][0] = fmod(x[2][0], y[2][0]);
>+    result[2][1] = fmod(x[2][1], y[2][1]);
>+    return result;
>+}
>+float3x3 fmod(float3x3 x, float3x3 y) {
>+    float3x3 result;
>+    result[0][0] = fmod(x[0][0], y[0][0]);
>+    result[0][1] = fmod(x[0][1], y[0][1]);
>+    result[0][2] = fmod(x[0][2], y[0][2]);
>+    result[1][0] = fmod(x[1][0], y[1][0]);
>+    result[1][1] = fmod(x[1][1], y[1][1]);
>+    result[1][2] = fmod(x[1][2], y[1][2]);
>+    result[2][0] = fmod(x[2][0], y[2][0]);
>+    result[2][1] = fmod(x[2][1], y[2][1]);
>+    result[2][2] = fmod(x[2][2], y[2][2]);
>+    return result;
>+}
>+float3x4 fmod(float3x4 x, float3x4 y) {
>+    float3x4 result;
>+    result[0][0] = fmod(x[0][0], y[0][0]);
>+    result[0][1] = fmod(x[0][1], y[0][1]);
>+    result[0][2] = fmod(x[0][2], y[0][2]);
>+    result[0][3] = fmod(x[0][3], y[0][3]);
>+    result[1][0] = fmod(x[1][0], y[1][0]);
>+    result[1][1] = fmod(x[1][1], y[1][1]);
>+    result[1][2] = fmod(x[1][2], y[1][2]);
>+    result[1][3] = fmod(x[1][3], y[1][3]);
>+    result[2][0] = fmod(x[2][0], y[2][0]);
>+    result[2][1] = fmod(x[2][1], y[2][1]);
>+    result[2][2] = fmod(x[2][2], y[2][2]);
>+    result[2][3] = fmod(x[2][3], y[2][3]);
>+    return result;
>+}
>+float4x2 fmod(float4x2 x, float4x2 y) {
>+    float4x2 result;
>+    result[0][0] = fmod(x[0][0], y[0][0]);
>+    result[0][1] = fmod(x[0][1], y[0][1]);
>+    result[1][0] = fmod(x[1][0], y[1][0]);
>+    result[1][1] = fmod(x[1][1], y[1][1]);
>+    result[2][0] = fmod(x[2][0], y[2][0]);
>+    result[2][1] = fmod(x[2][1], y[2][1]);
>+    result[3][0] = fmod(x[3][0], y[3][0]);
>+    result[3][1] = fmod(x[3][1], y[3][1]);
>+    return result;
>+}
>+float4x3 fmod(float4x3 x, float4x3 y) {
>+    float4x3 result;
>+    result[0][0] = fmod(x[0][0], y[0][0]);
>+    result[0][1] = fmod(x[0][1], y[0][1]);
>+    result[0][2] = fmod(x[0][2], y[0][2]);
>+    result[1][0] = fmod(x[1][0], y[1][0]);
>+    result[1][1] = fmod(x[1][1], y[1][1]);
>+    result[1][2] = fmod(x[1][2], y[1][2]);
>+    result[2][0] = fmod(x[2][0], y[2][0]);
>+    result[2][1] = fmod(x[2][1], y[2][1]);
>+    result[2][2] = fmod(x[2][2], y[2][2]);
>+    result[3][0] = fmod(x[3][0], y[3][0]);
>+    result[3][1] = fmod(x[3][1], y[3][1]);
>+    result[3][2] = fmod(x[3][2], y[3][2]);
>+    return result;
>+}
>+float4x4 fmod(float4x4 x, float4x4 y) {
>+    float4x4 result;
>+    result[0][0] = fmod(x[0][0], y[0][0]);
>+    result[0][1] = fmod(x[0][1], y[0][1]);
>+    result[0][2] = fmod(x[0][2], y[0][2]);
>+    result[0][3] = fmod(x[0][3], y[0][3]);
>+    result[1][0] = fmod(x[1][0], y[1][0]);
>+    result[1][1] = fmod(x[1][1], y[1][1]);
>+    result[1][2] = fmod(x[1][2], y[1][2]);
>+    result[1][3] = fmod(x[1][3], y[1][3]);
>+    result[2][0] = fmod(x[2][0], y[2][0]);
>+    result[2][1] = fmod(x[2][1], y[2][1]);
>+    result[2][2] = fmod(x[2][2], y[2][2]);
>+    result[2][3] = fmod(x[2][3], y[2][3]);
>+    result[3][0] = fmod(x[3][0], y[3][0]);
>+    result[3][1] = fmod(x[3][1], y[3][1]);
>+    result[3][2] = fmod(x[3][2], y[3][2]);
>+    result[3][3] = fmod(x[3][3], y[3][3]);
>+    return result;
>+}
>+
>+
>+/* Functions named operator.xzzx */
>+bool4 operator.xzzx(bool3 v) {
>+    bool4 result;
>+    result.x = v.x;
>+    result.y = v.z;
>+    result.z = v.z;
>+    result.w = v.x;
>+    return result;
>+}
>+bool4 operator.xzzx(bool4 v) {
>+    bool4 result;
>+    result.x = v.x;
>+    result.y = v.z;
>+    result.z = v.z;
>+    result.w = v.x;
>+    return result;
>+}
>+uchar4 operator.xzzx(uchar3 v) {
>+    uchar4 result;
>+    result.x = v.x;
>+    result.y = v.z;
>+    result.z = v.z;
>+    result.w = v.x;
>+    return result;
>+}
>+uchar4 operator.xzzx(uchar4 v) {
>+    uchar4 result;
>+    result.x = v.x;
>+    result.y = v.z;
>+    result.z = v.z;
>+    result.w = v.x;
>+    return result;
>+}
>+ushort4 operator.xzzx(ushort3 v) {
>+    ushort4 result;
>+    result.x = v.x;
>+    result.y = v.z;
>+    result.z = v.z;
>+    result.w = v.x;
>+    return result;
>+}
>+ushort4 operator.xzzx(ushort4 v) {
>+    ushort4 result;
>+    result.x = v.x;
>+    result.y = v.z;
>+    result.z = v.z;
>+    result.w = v.x;
>+    return result;
>+}
>+uint4 operator.xzzx(uint3 v) {
>+    uint4 result;
>+    result.x = v.x;
>+    result.y = v.z;
>+    result.z = v.z;
>+    result.w = v.x;
>+    return result;
>+}
>+uint4 operator.xzzx(uint4 v) {
>+    uint4 result;
>+    result.x = v.x;
>+    result.y = v.z;
>+    result.z = v.z;
>+    result.w = v.x;
>+    return result;
>+}
>+char4 operator.xzzx(char3 v) {
>+    char4 result;
>+    result.x = v.x;
>+    result.y = v.z;
>+    result.z = v.z;
>+    result.w = v.x;
>+    return result;
>+}
>+char4 operator.xzzx(char4 v) {
>+    char4 result;
>+    result.x = v.x;
>+    result.y = v.z;
>+    result.z = v.z;
>+    result.w = v.x;
>+    return result;
>+}
>+short4 operator.xzzx(short3 v) {
>+    short4 result;
>+    result.x = v.x;
>+    result.y = v.z;
>+    result.z = v.z;
>+    result.w = v.x;
>+    return result;
>+}
>+short4 operator.xzzx(short4 v) {
>+    short4 result;
>+    result.x = v.x;
>+    result.y = v.z;
>+    result.z = v.z;
>+    result.w = v.x;
>+    return result;
>+}
>+int4 operator.xzzx(int3 v) {
>+    int4 result;
>+    result.x = v.x;
>+    result.y = v.z;
>+    result.z = v.z;
>+    result.w = v.x;
>+    return result;
>+}
>+int4 operator.xzzx(int4 v) {
>+    int4 result;
>+    result.x = v.x;
>+    result.y = v.z;
>+    result.z = v.z;
>+    result.w = v.x;
>+    return result;
>+}
>+half4 operator.xzzx(half3 v) {
>+    half4 result;
>+    result.x = v.x;
>+    result.y = v.z;
>+    result.z = v.z;
>+    result.w = v.x;
>+    return result;
>+}
>+half4 operator.xzzx(half4 v) {
>+    half4 result;
>+    result.x = v.x;
>+    result.y = v.z;
>+    result.z = v.z;
>+    result.w = v.x;
>+    return result;
>+}
>+float4 operator.xzzx(float3 v) {
>+    float4 result;
>+    result.x = v.x;
>+    result.y = v.z;
>+    result.z = v.z;
>+    result.w = v.x;
>+    return result;
>+}
>+float4 operator.xzzx(float4 v) {
>+    float4 result;
>+    result.x = v.x;
>+    result.y = v.z;
>+    result.z = v.z;
>+    result.w = v.x;
>+    return result;
>+}
>+
>+/* Functions named operator.yyzy */
>+bool4 operator.yyzy(bool3 v) {
>+    bool4 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.z;
>+    result.w = v.y;
>+    return result;
>+}
>+bool4 operator.yyzy(bool4 v) {
>+    bool4 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.z;
>+    result.w = v.y;
>+    return result;
>+}
>+uchar4 operator.yyzy(uchar3 v) {
>+    uchar4 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.z;
>+    result.w = v.y;
>+    return result;
>+}
>+uchar4 operator.yyzy(uchar4 v) {
>+    uchar4 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.z;
>+    result.w = v.y;
>+    return result;
>+}
>+ushort4 operator.yyzy(ushort3 v) {
>+    ushort4 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.z;
>+    result.w = v.y;
>+    return result;
>+}
>+ushort4 operator.yyzy(ushort4 v) {
>+    ushort4 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.z;
>+    result.w = v.y;
>+    return result;
>+}
>+uint4 operator.yyzy(uint3 v) {
>+    uint4 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.z;
>+    result.w = v.y;
>+    return result;
>+}
>+uint4 operator.yyzy(uint4 v) {
>+    uint4 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.z;
>+    result.w = v.y;
>+    return result;
>+}
>+char4 operator.yyzy(char3 v) {
>+    char4 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.z;
>+    result.w = v.y;
>+    return result;
>+}
>+char4 operator.yyzy(char4 v) {
>+    char4 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.z;
>+    result.w = v.y;
>+    return result;
>+}
>+short4 operator.yyzy(short3 v) {
>+    short4 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.z;
>+    result.w = v.y;
>+    return result;
>+}
>+short4 operator.yyzy(short4 v) {
>+    short4 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.z;
>+    result.w = v.y;
>+    return result;
>+}
>+int4 operator.yyzy(int3 v) {
>+    int4 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.z;
>+    result.w = v.y;
>+    return result;
>+}
>+int4 operator.yyzy(int4 v) {
>+    int4 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.z;
>+    result.w = v.y;
>+    return result;
>+}
>+half4 operator.yyzy(half3 v) {
>+    half4 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.z;
>+    result.w = v.y;
>+    return result;
>+}
>+half4 operator.yyzy(half4 v) {
>+    half4 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.z;
>+    result.w = v.y;
>+    return result;
>+}
>+float4 operator.yyzy(float3 v) {
>+    float4 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.z;
>+    result.w = v.y;
>+    return result;
>+}
>+float4 operator.yyzy(float4 v) {
>+    float4 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.z;
>+    result.w = v.y;
>+    return result;
>+}
>+
>+/* Functions named operator.wyy */
>+bool3 operator.wyy(bool4 v) {
>+    bool3 result;
>+    result.x = v.w;
>+    result.y = v.y;
>+    result.z = v.y;
>+    return result;
>+}
>+uchar3 operator.wyy(uchar4 v) {
>+    uchar3 result;
>+    result.x = v.w;
>+    result.y = v.y;
>+    result.z = v.y;
>+    return result;
>+}
>+ushort3 operator.wyy(ushort4 v) {
>+    ushort3 result;
>+    result.x = v.w;
>+    result.y = v.y;
>+    result.z = v.y;
>+    return result;
>+}
>+uint3 operator.wyy(uint4 v) {
>+    uint3 result;
>+    result.x = v.w;
>+    result.y = v.y;
>+    result.z = v.y;
>+    return result;
>+}
>+char3 operator.wyy(char4 v) {
>+    char3 result;
>+    result.x = v.w;
>+    result.y = v.y;
>+    result.z = v.y;
>+    return result;
>+}
>+short3 operator.wyy(short4 v) {
>+    short3 result;
>+    result.x = v.w;
>+    result.y = v.y;
>+    result.z = v.y;
>+    return result;
>+}
>+int3 operator.wyy(int4 v) {
>+    int3 result;
>+    result.x = v.w;
>+    result.y = v.y;
>+    result.z = v.y;
>+    return result;
>+}
>+half3 operator.wyy(half4 v) {
>+    half3 result;
>+    result.x = v.w;
>+    result.y = v.y;
>+    result.z = v.y;
>+    return result;
>+}
>+float3 operator.wyy(float4 v) {
>+    float3 result;
>+    result.x = v.w;
>+    result.y = v.y;
>+    result.z = v.y;
>+    return result;
>+}
>+
>+/* Functions named operator.yzyx */
>+bool4 operator.yzyx(bool3 v) {
>+    bool4 result;
>+    result.x = v.y;
>+    result.y = v.z;
>+    result.z = v.y;
>+    result.w = v.x;
>+    return result;
>+}
>+bool4 operator.yzyx(bool4 v) {
>+    bool4 result;
>+    result.x = v.y;
>+    result.y = v.z;
>+    result.z = v.y;
>+    result.w = v.x;
>+    return result;
>+}
>+uchar4 operator.yzyx(uchar3 v) {
>+    uchar4 result;
>+    result.x = v.y;
>+    result.y = v.z;
>+    result.z = v.y;
>+    result.w = v.x;
>+    return result;
>+}
>+uchar4 operator.yzyx(uchar4 v) {
>+    uchar4 result;
>+    result.x = v.y;
>+    result.y = v.z;
>+    result.z = v.y;
>+    result.w = v.x;
>+    return result;
>+}
>+ushort4 operator.yzyx(ushort3 v) {
>+    ushort4 result;
>+    result.x = v.y;
>+    result.y = v.z;
>+    result.z = v.y;
>+    result.w = v.x;
>+    return result;
>+}
>+ushort4 operator.yzyx(ushort4 v) {
>+    ushort4 result;
>+    result.x = v.y;
>+    result.y = v.z;
>+    result.z = v.y;
>+    result.w = v.x;
>+    return result;
>+}
>+uint4 operator.yzyx(uint3 v) {
>+    uint4 result;
>+    result.x = v.y;
>+    result.y = v.z;
>+    result.z = v.y;
>+    result.w = v.x;
>+    return result;
>+}
>+uint4 operator.yzyx(uint4 v) {
>+    uint4 result;
>+    result.x = v.y;
>+    result.y = v.z;
>+    result.z = v.y;
>+    result.w = v.x;
>+    return result;
>+}
>+char4 operator.yzyx(char3 v) {
>+    char4 result;
>+    result.x = v.y;
>+    result.y = v.z;
>+    result.z = v.y;
>+    result.w = v.x;
>+    return result;
>+}
>+char4 operator.yzyx(char4 v) {
>+    char4 result;
>+    result.x = v.y;
>+    result.y = v.z;
>+    result.z = v.y;
>+    result.w = v.x;
>+    return result;
>+}
>+short4 operator.yzyx(short3 v) {
>+    short4 result;
>+    result.x = v.y;
>+    result.y = v.z;
>+    result.z = v.y;
>+    result.w = v.x;
>+    return result;
>+}
>+short4 operator.yzyx(short4 v) {
>+    short4 result;
>+    result.x = v.y;
>+    result.y = v.z;
>+    result.z = v.y;
>+    result.w = v.x;
>+    return result;
>+}
>+int4 operator.yzyx(int3 v) {
>+    int4 result;
>+    result.x = v.y;
>+    result.y = v.z;
>+    result.z = v.y;
>+    result.w = v.x;
>+    return result;
>+}
>+int4 operator.yzyx(int4 v) {
>+    int4 result;
>+    result.x = v.y;
>+    result.y = v.z;
>+    result.z = v.y;
>+    result.w = v.x;
>+    return result;
>+}
>+half4 operator.yzyx(half3 v) {
>+    half4 result;
>+    result.x = v.y;
>+    result.y = v.z;
>+    result.z = v.y;
>+    result.w = v.x;
>+    return result;
>+}
>+half4 operator.yzyx(half4 v) {
>+    half4 result;
>+    result.x = v.y;
>+    result.y = v.z;
>+    result.z = v.y;
>+    result.w = v.x;
>+    return result;
>+}
>+float4 operator.yzyx(float3 v) {
>+    float4 result;
>+    result.x = v.y;
>+    result.y = v.z;
>+    result.z = v.y;
>+    result.w = v.x;
>+    return result;
>+}
>+float4 operator.yzyx(float4 v) {
>+    float4 result;
>+    result.x = v.y;
>+    result.y = v.z;
>+    result.z = v.y;
>+    result.w = v.x;
>+    return result;
>+}
>+
>+/* Functions named operator.ywzx= */
>+bool4 operator.ywzx=(bool4 v, bool4 c) {
>+    bool4 result = v;
>+    result.y = c.x;
>+    result.w = c.y;
>+    result.z = c.z;
>+    result.x = c.w;
>+    return result;
>+}
>+uchar4 operator.ywzx=(uchar4 v, uchar4 c) {
>+    uchar4 result = v;
>+    result.y = c.x;
>+    result.w = c.y;
>+    result.z = c.z;
>+    result.x = c.w;
>+    return result;
>+}
>+ushort4 operator.ywzx=(ushort4 v, ushort4 c) {
>+    ushort4 result = v;
>+    result.y = c.x;
>+    result.w = c.y;
>+    result.z = c.z;
>+    result.x = c.w;
>+    return result;
>+}
>+uint4 operator.ywzx=(uint4 v, uint4 c) {
>+    uint4 result = v;
>+    result.y = c.x;
>+    result.w = c.y;
>+    result.z = c.z;
>+    result.x = c.w;
>+    return result;
>+}
>+char4 operator.ywzx=(char4 v, char4 c) {
>+    char4 result = v;
>+    result.y = c.x;
>+    result.w = c.y;
>+    result.z = c.z;
>+    result.x = c.w;
>+    return result;
>+}
>+short4 operator.ywzx=(short4 v, short4 c) {
>+    short4 result = v;
>+    result.y = c.x;
>+    result.w = c.y;
>+    result.z = c.z;
>+    result.x = c.w;
>+    return result;
>+}
>+int4 operator.ywzx=(int4 v, int4 c) {
>+    int4 result = v;
>+    result.y = c.x;
>+    result.w = c.y;
>+    result.z = c.z;
>+    result.x = c.w;
>+    return result;
>+}
>+half4 operator.ywzx=(half4 v, half4 c) {
>+    half4 result = v;
>+    result.y = c.x;
>+    result.w = c.y;
>+    result.z = c.z;
>+    result.x = c.w;
>+    return result;
>+}
>+float4 operator.ywzx=(float4 v, float4 c) {
>+    float4 result = v;
>+    result.y = c.x;
>+    result.w = c.y;
>+    result.z = c.z;
>+    result.x = c.w;
>+    return result;
>+}
>+
>+/* Functions named operator.xxzw */
>+bool4 operator.xxzw(bool4 v) {
>+    bool4 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.z;
>+    result.w = v.w;
>+    return result;
>+}
>+uchar4 operator.xxzw(uchar4 v) {
>+    uchar4 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.z;
>+    result.w = v.w;
>+    return result;
>+}
>+ushort4 operator.xxzw(ushort4 v) {
>+    ushort4 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.z;
>+    result.w = v.w;
>+    return result;
>+}
>+uint4 operator.xxzw(uint4 v) {
>+    uint4 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.z;
>+    result.w = v.w;
>+    return result;
>+}
>+char4 operator.xxzw(char4 v) {
>+    char4 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.z;
>+    result.w = v.w;
>+    return result;
>+}
>+short4 operator.xxzw(short4 v) {
>+    short4 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.z;
>+    result.w = v.w;
>+    return result;
>+}
>+int4 operator.xxzw(int4 v) {
>+    int4 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.z;
>+    result.w = v.w;
>+    return result;
>+}
>+half4 operator.xxzw(half4 v) {
>+    half4 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.z;
>+    result.w = v.w;
>+    return result;
>+}
>+float4 operator.xxzw(float4 v) {
>+    float4 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.z;
>+    result.w = v.w;
>+    return result;
>+}
>+
>+/* Functions named operator.xyxx */
>+bool4 operator.xyxx(bool2 v) {
>+    bool4 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.x;
>+    result.w = v.x;
>+    return result;
>+}
>+bool4 operator.xyxx(bool3 v) {
>+    bool4 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.x;
>+    result.w = v.x;
>+    return result;
>+}
>+bool4 operator.xyxx(bool4 v) {
>+    bool4 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.x;
>+    result.w = v.x;
>+    return result;
>+}
>+uchar4 operator.xyxx(uchar2 v) {
>+    uchar4 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.x;
>+    result.w = v.x;
>+    return result;
>+}
>+uchar4 operator.xyxx(uchar3 v) {
>+    uchar4 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.x;
>+    result.w = v.x;
>+    return result;
>+}
>+uchar4 operator.xyxx(uchar4 v) {
>+    uchar4 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.x;
>+    result.w = v.x;
>+    return result;
>+}
>+ushort4 operator.xyxx(ushort2 v) {
>+    ushort4 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.x;
>+    result.w = v.x;
>+    return result;
>+}
>+ushort4 operator.xyxx(ushort3 v) {
>+    ushort4 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.x;
>+    result.w = v.x;
>+    return result;
>+}
>+ushort4 operator.xyxx(ushort4 v) {
>+    ushort4 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.x;
>+    result.w = v.x;
>+    return result;
>+}
>+uint4 operator.xyxx(uint2 v) {
>+    uint4 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.x;
>+    result.w = v.x;
>+    return result;
>+}
>+uint4 operator.xyxx(uint3 v) {
>+    uint4 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.x;
>+    result.w = v.x;
>+    return result;
>+}
>+uint4 operator.xyxx(uint4 v) {
>+    uint4 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.x;
>+    result.w = v.x;
>+    return result;
>+}
>+char4 operator.xyxx(char2 v) {
>+    char4 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.x;
>+    result.w = v.x;
>+    return result;
>+}
>+char4 operator.xyxx(char3 v) {
>+    char4 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.x;
>+    result.w = v.x;
>+    return result;
>+}
>+char4 operator.xyxx(char4 v) {
>+    char4 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.x;
>+    result.w = v.x;
>+    return result;
>+}
>+short4 operator.xyxx(short2 v) {
>+    short4 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.x;
>+    result.w = v.x;
>+    return result;
>+}
>+short4 operator.xyxx(short3 v) {
>+    short4 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.x;
>+    result.w = v.x;
>+    return result;
>+}
>+short4 operator.xyxx(short4 v) {
>+    short4 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.x;
>+    result.w = v.x;
>+    return result;
>+}
>+int4 operator.xyxx(int2 v) {
>+    int4 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.x;
>+    result.w = v.x;
>+    return result;
>+}
>+int4 operator.xyxx(int3 v) {
>+    int4 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.x;
>+    result.w = v.x;
>+    return result;
>+}
>+int4 operator.xyxx(int4 v) {
>+    int4 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.x;
>+    result.w = v.x;
>+    return result;
>+}
>+half4 operator.xyxx(half2 v) {
>+    half4 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.x;
>+    result.w = v.x;
>+    return result;
>+}
>+half4 operator.xyxx(half3 v) {
>+    half4 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.x;
>+    result.w = v.x;
>+    return result;
>+}
>+half4 operator.xyxx(half4 v) {
>+    half4 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.x;
>+    result.w = v.x;
>+    return result;
>+}
>+float4 operator.xyxx(float2 v) {
>+    float4 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.x;
>+    result.w = v.x;
>+    return result;
>+}
>+float4 operator.xyxx(float3 v) {
>+    float4 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.x;
>+    result.w = v.x;
>+    return result;
>+}
>+float4 operator.xyxx(float4 v) {
>+    float4 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.x;
>+    result.w = v.x;
>+    return result;
>+}
>+
>+/* Functions named operator.zyw= */
>+bool4 operator.zyw=(bool4 v, bool3 c) {
>+    bool4 result = v;
>+    result.z = c.x;
>+    result.y = c.y;
>+    result.w = c.z;
>+    return result;
>+}
>+uchar4 operator.zyw=(uchar4 v, uchar3 c) {
>+    uchar4 result = v;
>+    result.z = c.x;
>+    result.y = c.y;
>+    result.w = c.z;
>+    return result;
>+}
>+ushort4 operator.zyw=(ushort4 v, ushort3 c) {
>+    ushort4 result = v;
>+    result.z = c.x;
>+    result.y = c.y;
>+    result.w = c.z;
>+    return result;
>+}
>+uint4 operator.zyw=(uint4 v, uint3 c) {
>+    uint4 result = v;
>+    result.z = c.x;
>+    result.y = c.y;
>+    result.w = c.z;
>+    return result;
>+}
>+char4 operator.zyw=(char4 v, char3 c) {
>+    char4 result = v;
>+    result.z = c.x;
>+    result.y = c.y;
>+    result.w = c.z;
>+    return result;
>+}
>+short4 operator.zyw=(short4 v, short3 c) {
>+    short4 result = v;
>+    result.z = c.x;
>+    result.y = c.y;
>+    result.w = c.z;
>+    return result;
>+}
>+int4 operator.zyw=(int4 v, int3 c) {
>+    int4 result = v;
>+    result.z = c.x;
>+    result.y = c.y;
>+    result.w = c.z;
>+    return result;
>+}
>+half4 operator.zyw=(half4 v, half3 c) {
>+    half4 result = v;
>+    result.z = c.x;
>+    result.y = c.y;
>+    result.w = c.z;
>+    return result;
>+}
>+float4 operator.zyw=(float4 v, float3 c) {
>+    float4 result = v;
>+    result.z = c.x;
>+    result.y = c.y;
>+    result.w = c.z;
>+    return result;
>+}
>+
>+/* Functions named operator.wzxy */
>+bool4 operator.wzxy(bool4 v) {
>+    bool4 result;
>+    result.x = v.w;
>+    result.y = v.z;
>+    result.z = v.x;
>+    result.w = v.y;
>+    return result;
>+}
>+uchar4 operator.wzxy(uchar4 v) {
>+    uchar4 result;
>+    result.x = v.w;
>+    result.y = v.z;
>+    result.z = v.x;
>+    result.w = v.y;
>+    return result;
>+}
>+ushort4 operator.wzxy(ushort4 v) {
>+    ushort4 result;
>+    result.x = v.w;
>+    result.y = v.z;
>+    result.z = v.x;
>+    result.w = v.y;
>+    return result;
>+}
>+uint4 operator.wzxy(uint4 v) {
>+    uint4 result;
>+    result.x = v.w;
>+    result.y = v.z;
>+    result.z = v.x;
>+    result.w = v.y;
>+    return result;
>+}
>+char4 operator.wzxy(char4 v) {
>+    char4 result;
>+    result.x = v.w;
>+    result.y = v.z;
>+    result.z = v.x;
>+    result.w = v.y;
>+    return result;
>+}
>+short4 operator.wzxy(short4 v) {
>+    short4 result;
>+    result.x = v.w;
>+    result.y = v.z;
>+    result.z = v.x;
>+    result.w = v.y;
>+    return result;
>+}
>+int4 operator.wzxy(int4 v) {
>+    int4 result;
>+    result.x = v.w;
>+    result.y = v.z;
>+    result.z = v.x;
>+    result.w = v.y;
>+    return result;
>+}
>+half4 operator.wzxy(half4 v) {
>+    half4 result;
>+    result.x = v.w;
>+    result.y = v.z;
>+    result.z = v.x;
>+    result.w = v.y;
>+    return result;
>+}
>+float4 operator.wzxy(float4 v) {
>+    float4 result;
>+    result.x = v.w;
>+    result.y = v.z;
>+    result.z = v.x;
>+    result.w = v.y;
>+    return result;
>+}
>+
>+/* Functions named operator.zwx */
>+bool3 operator.zwx(bool4 v) {
>+    bool3 result;
>+    result.x = v.z;
>+    result.y = v.w;
>+    result.z = v.x;
>+    return result;
>+}
>+uchar3 operator.zwx(uchar4 v) {
>+    uchar3 result;
>+    result.x = v.z;
>+    result.y = v.w;
>+    result.z = v.x;
>+    return result;
>+}
>+ushort3 operator.zwx(ushort4 v) {
>+    ushort3 result;
>+    result.x = v.z;
>+    result.y = v.w;
>+    result.z = v.x;
>+    return result;
>+}
>+uint3 operator.zwx(uint4 v) {
>+    uint3 result;
>+    result.x = v.z;
>+    result.y = v.w;
>+    result.z = v.x;
>+    return result;
>+}
>+char3 operator.zwx(char4 v) {
>+    char3 result;
>+    result.x = v.z;
>+    result.y = v.w;
>+    result.z = v.x;
>+    return result;
>+}
>+short3 operator.zwx(short4 v) {
>+    short3 result;
>+    result.x = v.z;
>+    result.y = v.w;
>+    result.z = v.x;
>+    return result;
>+}
>+int3 operator.zwx(int4 v) {
>+    int3 result;
>+    result.x = v.z;
>+    result.y = v.w;
>+    result.z = v.x;
>+    return result;
>+}
>+half3 operator.zwx(half4 v) {
>+    half3 result;
>+    result.x = v.z;
>+    result.y = v.w;
>+    result.z = v.x;
>+    return result;
>+}
>+float3 operator.zwx(float4 v) {
>+    float3 result;
>+    result.x = v.z;
>+    result.y = v.w;
>+    result.z = v.x;
>+    return result;
>+}
>+
>+/* Functions named operator- */
>+native int operator-(int, int);
>+native uint operator-(uint, uint);
>+native float operator-(float, float);
>+uchar operator-(uchar a, uchar b) {
>+    return uchar(uint(a) - uint(b));
>+}
>+ushort operator-(ushort a, ushort b) {
>+    return ushort(uint(a) - uint(b));
>+}
>+char operator-(char a, char b) {
>+    return char(int(a) - int(b));
>+}
>+short operator-(short a, short b) {
>+    return short(int(a) - int(b));
>+}
>+half operator-(half a, half b) {
>+    return half(float(a) - float(b));
>+}
>+char operator-(char x) {
>+    return char(-int(x));
>+}
>+short operator-(short x) {
>+    return short(-int(x));
>+}
>+half operator-(half x) {
>+    return half(-float(x));
>+}
>+native int operator-(int);
>+native float operator-(float);
>+
>+uchar2 operator-(uchar2 a, uchar2 b) {
>+    uchar2 result;
>+    result[0] = a[0] - b[0];
>+    result[1] = a[1] - b[1];
>+    return result;
>+}
>+uchar3 operator-(uchar3 a, uchar3 b) {
>+    uchar3 result;
>+    result[0] = a[0] - b[0];
>+    result[1] = a[1] - b[1];
>+    result[2] = a[2] - b[2];
>+    return result;
>+}
>+uchar4 operator-(uchar4 a, uchar4 b) {
>+    uchar4 result;
>+    result[0] = a[0] - b[0];
>+    result[1] = a[1] - b[1];
>+    result[2] = a[2] - b[2];
>+    result[3] = a[3] - b[3];
>+    return result;
>+}
>+ushort2 operator-(ushort2 a, ushort2 b) {
>+    ushort2 result;
>+    result[0] = a[0] - b[0];
>+    result[1] = a[1] - b[1];
>+    return result;
>+}
>+ushort3 operator-(ushort3 a, ushort3 b) {
>+    ushort3 result;
>+    result[0] = a[0] - b[0];
>+    result[1] = a[1] - b[1];
>+    result[2] = a[2] - b[2];
>+    return result;
>+}
>+ushort4 operator-(ushort4 a, ushort4 b) {
>+    ushort4 result;
>+    result[0] = a[0] - b[0];
>+    result[1] = a[1] - b[1];
>+    result[2] = a[2] - b[2];
>+    result[3] = a[3] - b[3];
>+    return result;
>+}
>+uint2 operator-(uint2 a, uint2 b) {
>+    uint2 result;
>+    result[0] = a[0] - b[0];
>+    result[1] = a[1] - b[1];
>+    return result;
>+}
>+uint3 operator-(uint3 a, uint3 b) {
>+    uint3 result;
>+    result[0] = a[0] - b[0];
>+    result[1] = a[1] - b[1];
>+    result[2] = a[2] - b[2];
>+    return result;
>+}
>+uint4 operator-(uint4 a, uint4 b) {
>+    uint4 result;
>+    result[0] = a[0] - b[0];
>+    result[1] = a[1] - b[1];
>+    result[2] = a[2] - b[2];
>+    result[3] = a[3] - b[3];
>+    return result;
>+}
>+char2 operator-(char2 a, char2 b) {
>+    char2 result;
>+    result[0] = a[0] - b[0];
>+    result[1] = a[1] - b[1];
>+    return result;
>+}
>+char3 operator-(char3 a, char3 b) {
>+    char3 result;
>+    result[0] = a[0] - b[0];
>+    result[1] = a[1] - b[1];
>+    result[2] = a[2] - b[2];
>+    return result;
>+}
>+char4 operator-(char4 a, char4 b) {
>+    char4 result;
>+    result[0] = a[0] - b[0];
>+    result[1] = a[1] - b[1];
>+    result[2] = a[2] - b[2];
>+    result[3] = a[3] - b[3];
>+    return result;
>+}
>+short2 operator-(short2 a, short2 b) {
>+    short2 result;
>+    result[0] = a[0] - b[0];
>+    result[1] = a[1] - b[1];
>+    return result;
>+}
>+short3 operator-(short3 a, short3 b) {
>+    short3 result;
>+    result[0] = a[0] - b[0];
>+    result[1] = a[1] - b[1];
>+    result[2] = a[2] - b[2];
>+    return result;
>+}
>+short4 operator-(short4 a, short4 b) {
>+    short4 result;
>+    result[0] = a[0] - b[0];
>+    result[1] = a[1] - b[1];
>+    result[2] = a[2] - b[2];
>+    result[3] = a[3] - b[3];
>+    return result;
>+}
>+int2 operator-(int2 a, int2 b) {
>+    int2 result;
>+    result[0] = a[0] - b[0];
>+    result[1] = a[1] - b[1];
>+    return result;
>+}
>+int3 operator-(int3 a, int3 b) {
>+    int3 result;
>+    result[0] = a[0] - b[0];
>+    result[1] = a[1] - b[1];
>+    result[2] = a[2] - b[2];
>+    return result;
>+}
>+int4 operator-(int4 a, int4 b) {
>+    int4 result;
>+    result[0] = a[0] - b[0];
>+    result[1] = a[1] - b[1];
>+    result[2] = a[2] - b[2];
>+    result[3] = a[3] - b[3];
>+    return result;
>+}
>+half2 operator-(half2 a, half2 b) {
>+    half2 result;
>+    result[0] = a[0] - b[0];
>+    result[1] = a[1] - b[1];
>+    return result;
>+}
>+half3 operator-(half3 a, half3 b) {
>+    half3 result;
>+    result[0] = a[0] - b[0];
>+    result[1] = a[1] - b[1];
>+    result[2] = a[2] - b[2];
>+    return result;
>+}
>+half4 operator-(half4 a, half4 b) {
>+    half4 result;
>+    result[0] = a[0] - b[0];
>+    result[1] = a[1] - b[1];
>+    result[2] = a[2] - b[2];
>+    result[3] = a[3] - b[3];
>+    return result;
>+}
>+float2 operator-(float2 a, float2 b) {
>+    float2 result;
>+    result[0] = a[0] - b[0];
>+    result[1] = a[1] - b[1];
>+    return result;
>+}
>+float3 operator-(float3 a, float3 b) {
>+    float3 result;
>+    result[0] = a[0] - b[0];
>+    result[1] = a[1] - b[1];
>+    result[2] = a[2] - b[2];
>+    return result;
>+}
>+float4 operator-(float4 a, float4 b) {
>+    float4 result;
>+    result[0] = a[0] - b[0];
>+    result[1] = a[1] - b[1];
>+    result[2] = a[2] - b[2];
>+    result[3] = a[3] - b[3];
>+    return result;
>+}
>+char2 operator-(char2 a) {
>+    char2 result;
>+    result[0] = -a[0];
>+    result[1] = -a[1];
>+    return result;
>+}
>+char3 operator-(char3 a) {
>+    char3 result;
>+    result[0] = -a[0];
>+    result[1] = -a[1];
>+    result[2] = -a[2];
>+    return result;
>+}
>+char4 operator-(char4 a) {
>+    char4 result;
>+    result[0] = -a[0];
>+    result[1] = -a[1];
>+    result[2] = -a[2];
>+    result[3] = -a[3];
>+    return result;
>+}
>+short2 operator-(short2 a) {
>+    short2 result;
>+    result[0] = -a[0];
>+    result[1] = -a[1];
>+    return result;
>+}
>+short3 operator-(short3 a) {
>+    short3 result;
>+    result[0] = -a[0];
>+    result[1] = -a[1];
>+    result[2] = -a[2];
>+    return result;
>+}
>+short4 operator-(short4 a) {
>+    short4 result;
>+    result[0] = -a[0];
>+    result[1] = -a[1];
>+    result[2] = -a[2];
>+    result[3] = -a[3];
>+    return result;
>+}
>+int2 operator-(int2 a) {
>+    int2 result;
>+    result[0] = -a[0];
>+    result[1] = -a[1];
>+    return result;
>+}
>+int3 operator-(int3 a) {
>+    int3 result;
>+    result[0] = -a[0];
>+    result[1] = -a[1];
>+    result[2] = -a[2];
>+    return result;
>+}
>+int4 operator-(int4 a) {
>+    int4 result;
>+    result[0] = -a[0];
>+    result[1] = -a[1];
>+    result[2] = -a[2];
>+    result[3] = -a[3];
>+    return result;
>+}
>+half2 operator-(half2 a) {
>+    half2 result;
>+    result[0] = -a[0];
>+    result[1] = -a[1];
>+    return result;
>+}
>+half3 operator-(half3 a) {
>+    half3 result;
>+    result[0] = -a[0];
>+    result[1] = -a[1];
>+    result[2] = -a[2];
>+    return result;
>+}
>+half4 operator-(half4 a) {
>+    half4 result;
>+    result[0] = -a[0];
>+    result[1] = -a[1];
>+    result[2] = -a[2];
>+    result[3] = -a[3];
>+    return result;
>+}
>+float2 operator-(float2 a) {
>+    float2 result;
>+    result[0] = -a[0];
>+    result[1] = -a[1];
>+    return result;
>+}
>+float3 operator-(float3 a) {
>+    float3 result;
>+    result[0] = -a[0];
>+    result[1] = -a[1];
>+    result[2] = -a[2];
>+    return result;
>+}
>+float4 operator-(float4 a) {
>+    float4 result;
>+    result[0] = -a[0];
>+    result[1] = -a[1];
>+    result[2] = -a[2];
>+    result[3] = -a[3];
>+    return result;
>+}
>+half2x2 operator-(half2x2 a, half2x2 b) {
>+    half2x2 result;
>+    result[0][0] = a[0][0] - b[0][0];
>+    result[0][1] = a[0][1] - b[0][1];
>+    result[1][0] = a[1][0] - b[1][0];
>+    result[1][1] = a[1][1] - b[1][1];
>+    return result;
>+}
>+half2x2 operator-(half2x2 a) {
>+    half2x2 result;
>+    result[0][0] = -a[0][0];
>+    result[0][1] = -a[0][1];
>+    result[1][0] = -a[1][0];
>+    result[1][1] = -a[1][1];
>+    return result;
>+}
>+half2x3 operator-(half2x3 a, half2x3 b) {
>+    half2x3 result;
>+    result[0][0] = a[0][0] - b[0][0];
>+    result[0][1] = a[0][1] - b[0][1];
>+    result[0][2] = a[0][2] - b[0][2];
>+    result[1][0] = a[1][0] - b[1][0];
>+    result[1][1] = a[1][1] - b[1][1];
>+    result[1][2] = a[1][2] - b[1][2];
>+    return result;
>+}
>+half2x3 operator-(half2x3 a) {
>+    half2x3 result;
>+    result[0][0] = -a[0][0];
>+    result[0][1] = -a[0][1];
>+    result[0][2] = -a[0][2];
>+    result[1][0] = -a[1][0];
>+    result[1][1] = -a[1][1];
>+    result[1][2] = -a[1][2];
>+    return result;
>+}
>+half2x4 operator-(half2x4 a, half2x4 b) {
>+    half2x4 result;
>+    result[0][0] = a[0][0] - b[0][0];
>+    result[0][1] = a[0][1] - b[0][1];
>+    result[0][2] = a[0][2] - b[0][2];
>+    result[0][3] = a[0][3] - b[0][3];
>+    result[1][0] = a[1][0] - b[1][0];
>+    result[1][1] = a[1][1] - b[1][1];
>+    result[1][2] = a[1][2] - b[1][2];
>+    result[1][3] = a[1][3] - b[1][3];
>+    return result;
>+}
>+half2x4 operator-(half2x4 a) {
>+    half2x4 result;
>+    result[0][0] = -a[0][0];
>+    result[0][1] = -a[0][1];
>+    result[0][2] = -a[0][2];
>+    result[0][3] = -a[0][3];
>+    result[1][0] = -a[1][0];
>+    result[1][1] = -a[1][1];
>+    result[1][2] = -a[1][2];
>+    result[1][3] = -a[1][3];
>+    return result;
>+}
>+half3x2 operator-(half3x2 a, half3x2 b) {
>+    half3x2 result;
>+    result[0][0] = a[0][0] - b[0][0];
>+    result[0][1] = a[0][1] - b[0][1];
>+    result[1][0] = a[1][0] - b[1][0];
>+    result[1][1] = a[1][1] - b[1][1];
>+    result[2][0] = a[2][0] - b[2][0];
>+    result[2][1] = a[2][1] - b[2][1];
>+    return result;
>+}
>+half3x2 operator-(half3x2 a) {
>+    half3x2 result;
>+    result[0][0] = -a[0][0];
>+    result[0][1] = -a[0][1];
>+    result[1][0] = -a[1][0];
>+    result[1][1] = -a[1][1];
>+    result[2][0] = -a[2][0];
>+    result[2][1] = -a[2][1];
>+    return result;
>+}
>+half3x3 operator-(half3x3 a, half3x3 b) {
>+    half3x3 result;
>+    result[0][0] = a[0][0] - b[0][0];
>+    result[0][1] = a[0][1] - b[0][1];
>+    result[0][2] = a[0][2] - b[0][2];
>+    result[1][0] = a[1][0] - b[1][0];
>+    result[1][1] = a[1][1] - b[1][1];
>+    result[1][2] = a[1][2] - b[1][2];
>+    result[2][0] = a[2][0] - b[2][0];
>+    result[2][1] = a[2][1] - b[2][1];
>+    result[2][2] = a[2][2] - b[2][2];
>+    return result;
>+}
>+half3x3 operator-(half3x3 a) {
>+    half3x3 result;
>+    result[0][0] = -a[0][0];
>+    result[0][1] = -a[0][1];
>+    result[0][2] = -a[0][2];
>+    result[1][0] = -a[1][0];
>+    result[1][1] = -a[1][1];
>+    result[1][2] = -a[1][2];
>+    result[2][0] = -a[2][0];
>+    result[2][1] = -a[2][1];
>+    result[2][2] = -a[2][2];
>+    return result;
>+}
>+half3x4 operator-(half3x4 a, half3x4 b) {
>+    half3x4 result;
>+    result[0][0] = a[0][0] - b[0][0];
>+    result[0][1] = a[0][1] - b[0][1];
>+    result[0][2] = a[0][2] - b[0][2];
>+    result[0][3] = a[0][3] - b[0][3];
>+    result[1][0] = a[1][0] - b[1][0];
>+    result[1][1] = a[1][1] - b[1][1];
>+    result[1][2] = a[1][2] - b[1][2];
>+    result[1][3] = a[1][3] - b[1][3];
>+    result[2][0] = a[2][0] - b[2][0];
>+    result[2][1] = a[2][1] - b[2][1];
>+    result[2][2] = a[2][2] - b[2][2];
>+    result[2][3] = a[2][3] - b[2][3];
>+    return result;
>+}
>+half3x4 operator-(half3x4 a) {
>+    half3x4 result;
>+    result[0][0] = -a[0][0];
>+    result[0][1] = -a[0][1];
>+    result[0][2] = -a[0][2];
>+    result[0][3] = -a[0][3];
>+    result[1][0] = -a[1][0];
>+    result[1][1] = -a[1][1];
>+    result[1][2] = -a[1][2];
>+    result[1][3] = -a[1][3];
>+    result[2][0] = -a[2][0];
>+    result[2][1] = -a[2][1];
>+    result[2][2] = -a[2][2];
>+    result[2][3] = -a[2][3];
>+    return result;
>+}
>+half4x2 operator-(half4x2 a, half4x2 b) {
>+    half4x2 result;
>+    result[0][0] = a[0][0] - b[0][0];
>+    result[0][1] = a[0][1] - b[0][1];
>+    result[1][0] = a[1][0] - b[1][0];
>+    result[1][1] = a[1][1] - b[1][1];
>+    result[2][0] = a[2][0] - b[2][0];
>+    result[2][1] = a[2][1] - b[2][1];
>+    result[3][0] = a[3][0] - b[3][0];
>+    result[3][1] = a[3][1] - b[3][1];
>+    return result;
>+}
>+half4x2 operator-(half4x2 a) {
>+    half4x2 result;
>+    result[0][0] = -a[0][0];
>+    result[0][1] = -a[0][1];
>+    result[1][0] = -a[1][0];
>+    result[1][1] = -a[1][1];
>+    result[2][0] = -a[2][0];
>+    result[2][1] = -a[2][1];
>+    result[3][0] = -a[3][0];
>+    result[3][1] = -a[3][1];
>+    return result;
>+}
>+half4x3 operator-(half4x3 a, half4x3 b) {
>+    half4x3 result;
>+    result[0][0] = a[0][0] - b[0][0];
>+    result[0][1] = a[0][1] - b[0][1];
>+    result[0][2] = a[0][2] - b[0][2];
>+    result[1][0] = a[1][0] - b[1][0];
>+    result[1][1] = a[1][1] - b[1][1];
>+    result[1][2] = a[1][2] - b[1][2];
>+    result[2][0] = a[2][0] - b[2][0];
>+    result[2][1] = a[2][1] - b[2][1];
>+    result[2][2] = a[2][2] - b[2][2];
>+    result[3][0] = a[3][0] - b[3][0];
>+    result[3][1] = a[3][1] - b[3][1];
>+    result[3][2] = a[3][2] - b[3][2];
>+    return result;
>+}
>+half4x3 operator-(half4x3 a) {
>+    half4x3 result;
>+    result[0][0] = -a[0][0];
>+    result[0][1] = -a[0][1];
>+    result[0][2] = -a[0][2];
>+    result[1][0] = -a[1][0];
>+    result[1][1] = -a[1][1];
>+    result[1][2] = -a[1][2];
>+    result[2][0] = -a[2][0];
>+    result[2][1] = -a[2][1];
>+    result[2][2] = -a[2][2];
>+    result[3][0] = -a[3][0];
>+    result[3][1] = -a[3][1];
>+    result[3][2] = -a[3][2];
>+    return result;
>+}
>+half4x4 operator-(half4x4 a, half4x4 b) {
>+    half4x4 result;
>+    result[0][0] = a[0][0] - b[0][0];
>+    result[0][1] = a[0][1] - b[0][1];
>+    result[0][2] = a[0][2] - b[0][2];
>+    result[0][3] = a[0][3] - b[0][3];
>+    result[1][0] = a[1][0] - b[1][0];
>+    result[1][1] = a[1][1] - b[1][1];
>+    result[1][2] = a[1][2] - b[1][2];
>+    result[1][3] = a[1][3] - b[1][3];
>+    result[2][0] = a[2][0] - b[2][0];
>+    result[2][1] = a[2][1] - b[2][1];
>+    result[2][2] = a[2][2] - b[2][2];
>+    result[2][3] = a[2][3] - b[2][3];
>+    result[3][0] = a[3][0] - b[3][0];
>+    result[3][1] = a[3][1] - b[3][1];
>+    result[3][2] = a[3][2] - b[3][2];
>+    result[3][3] = a[3][3] - b[3][3];
>+    return result;
>+}
>+half4x4 operator-(half4x4 a) {
>+    half4x4 result;
>+    result[0][0] = -a[0][0];
>+    result[0][1] = -a[0][1];
>+    result[0][2] = -a[0][2];
>+    result[0][3] = -a[0][3];
>+    result[1][0] = -a[1][0];
>+    result[1][1] = -a[1][1];
>+    result[1][2] = -a[1][2];
>+    result[1][3] = -a[1][3];
>+    result[2][0] = -a[2][0];
>+    result[2][1] = -a[2][1];
>+    result[2][2] = -a[2][2];
>+    result[2][3] = -a[2][3];
>+    result[3][0] = -a[3][0];
>+    result[3][1] = -a[3][1];
>+    result[3][2] = -a[3][2];
>+    result[3][3] = -a[3][3];
>+    return result;
>+}
>+float2x2 operator-(float2x2 a, float2x2 b) {
>+    float2x2 result;
>+    result[0][0] = a[0][0] - b[0][0];
>+    result[0][1] = a[0][1] - b[0][1];
>+    result[1][0] = a[1][0] - b[1][0];
>+    result[1][1] = a[1][1] - b[1][1];
>+    return result;
>+}
>+float2x2 operator-(float2x2 a) {
>+    float2x2 result;
>+    result[0][0] = -a[0][0];
>+    result[0][1] = -a[0][1];
>+    result[1][0] = -a[1][0];
>+    result[1][1] = -a[1][1];
>+    return result;
>+}
>+float2x3 operator-(float2x3 a, float2x3 b) {
>+    float2x3 result;
>+    result[0][0] = a[0][0] - b[0][0];
>+    result[0][1] = a[0][1] - b[0][1];
>+    result[0][2] = a[0][2] - b[0][2];
>+    result[1][0] = a[1][0] - b[1][0];
>+    result[1][1] = a[1][1] - b[1][1];
>+    result[1][2] = a[1][2] - b[1][2];
>+    return result;
>+}
>+float2x3 operator-(float2x3 a) {
>+    float2x3 result;
>+    result[0][0] = -a[0][0];
>+    result[0][1] = -a[0][1];
>+    result[0][2] = -a[0][2];
>+    result[1][0] = -a[1][0];
>+    result[1][1] = -a[1][1];
>+    result[1][2] = -a[1][2];
>+    return result;
>+}
>+float2x4 operator-(float2x4 a, float2x4 b) {
>+    float2x4 result;
>+    result[0][0] = a[0][0] - b[0][0];
>+    result[0][1] = a[0][1] - b[0][1];
>+    result[0][2] = a[0][2] - b[0][2];
>+    result[0][3] = a[0][3] - b[0][3];
>+    result[1][0] = a[1][0] - b[1][0];
>+    result[1][1] = a[1][1] - b[1][1];
>+    result[1][2] = a[1][2] - b[1][2];
>+    result[1][3] = a[1][3] - b[1][3];
>+    return result;
>+}
>+float2x4 operator-(float2x4 a) {
>+    float2x4 result;
>+    result[0][0] = -a[0][0];
>+    result[0][1] = -a[0][1];
>+    result[0][2] = -a[0][2];
>+    result[0][3] = -a[0][3];
>+    result[1][0] = -a[1][0];
>+    result[1][1] = -a[1][1];
>+    result[1][2] = -a[1][2];
>+    result[1][3] = -a[1][3];
>+    return result;
>+}
>+float3x2 operator-(float3x2 a, float3x2 b) {
>+    float3x2 result;
>+    result[0][0] = a[0][0] - b[0][0];
>+    result[0][1] = a[0][1] - b[0][1];
>+    result[1][0] = a[1][0] - b[1][0];
>+    result[1][1] = a[1][1] - b[1][1];
>+    result[2][0] = a[2][0] - b[2][0];
>+    result[2][1] = a[2][1] - b[2][1];
>+    return result;
>+}
>+float3x2 operator-(float3x2 a) {
>+    float3x2 result;
>+    result[0][0] = -a[0][0];
>+    result[0][1] = -a[0][1];
>+    result[1][0] = -a[1][0];
>+    result[1][1] = -a[1][1];
>+    result[2][0] = -a[2][0];
>+    result[2][1] = -a[2][1];
>+    return result;
>+}
>+float3x3 operator-(float3x3 a, float3x3 b) {
>+    float3x3 result;
>+    result[0][0] = a[0][0] - b[0][0];
>+    result[0][1] = a[0][1] - b[0][1];
>+    result[0][2] = a[0][2] - b[0][2];
>+    result[1][0] = a[1][0] - b[1][0];
>+    result[1][1] = a[1][1] - b[1][1];
>+    result[1][2] = a[1][2] - b[1][2];
>+    result[2][0] = a[2][0] - b[2][0];
>+    result[2][1] = a[2][1] - b[2][1];
>+    result[2][2] = a[2][2] - b[2][2];
>+    return result;
>+}
>+float3x3 operator-(float3x3 a) {
>+    float3x3 result;
>+    result[0][0] = -a[0][0];
>+    result[0][1] = -a[0][1];
>+    result[0][2] = -a[0][2];
>+    result[1][0] = -a[1][0];
>+    result[1][1] = -a[1][1];
>+    result[1][2] = -a[1][2];
>+    result[2][0] = -a[2][0];
>+    result[2][1] = -a[2][1];
>+    result[2][2] = -a[2][2];
>+    return result;
>+}
>+float3x4 operator-(float3x4 a, float3x4 b) {
>+    float3x4 result;
>+    result[0][0] = a[0][0] - b[0][0];
>+    result[0][1] = a[0][1] - b[0][1];
>+    result[0][2] = a[0][2] - b[0][2];
>+    result[0][3] = a[0][3] - b[0][3];
>+    result[1][0] = a[1][0] - b[1][0];
>+    result[1][1] = a[1][1] - b[1][1];
>+    result[1][2] = a[1][2] - b[1][2];
>+    result[1][3] = a[1][3] - b[1][3];
>+    result[2][0] = a[2][0] - b[2][0];
>+    result[2][1] = a[2][1] - b[2][1];
>+    result[2][2] = a[2][2] - b[2][2];
>+    result[2][3] = a[2][3] - b[2][3];
>+    return result;
>+}
>+float3x4 operator-(float3x4 a) {
>+    float3x4 result;
>+    result[0][0] = -a[0][0];
>+    result[0][1] = -a[0][1];
>+    result[0][2] = -a[0][2];
>+    result[0][3] = -a[0][3];
>+    result[1][0] = -a[1][0];
>+    result[1][1] = -a[1][1];
>+    result[1][2] = -a[1][2];
>+    result[1][3] = -a[1][3];
>+    result[2][0] = -a[2][0];
>+    result[2][1] = -a[2][1];
>+    result[2][2] = -a[2][2];
>+    result[2][3] = -a[2][3];
>+    return result;
>+}
>+float4x2 operator-(float4x2 a, float4x2 b) {
>+    float4x2 result;
>+    result[0][0] = a[0][0] - b[0][0];
>+    result[0][1] = a[0][1] - b[0][1];
>+    result[1][0] = a[1][0] - b[1][0];
>+    result[1][1] = a[1][1] - b[1][1];
>+    result[2][0] = a[2][0] - b[2][0];
>+    result[2][1] = a[2][1] - b[2][1];
>+    result[3][0] = a[3][0] - b[3][0];
>+    result[3][1] = a[3][1] - b[3][1];
>+    return result;
>+}
>+float4x2 operator-(float4x2 a) {
>+    float4x2 result;
>+    result[0][0] = -a[0][0];
>+    result[0][1] = -a[0][1];
>+    result[1][0] = -a[1][0];
>+    result[1][1] = -a[1][1];
>+    result[2][0] = -a[2][0];
>+    result[2][1] = -a[2][1];
>+    result[3][0] = -a[3][0];
>+    result[3][1] = -a[3][1];
>+    return result;
>+}
>+float4x3 operator-(float4x3 a, float4x3 b) {
>+    float4x3 result;
>+    result[0][0] = a[0][0] - b[0][0];
>+    result[0][1] = a[0][1] - b[0][1];
>+    result[0][2] = a[0][2] - b[0][2];
>+    result[1][0] = a[1][0] - b[1][0];
>+    result[1][1] = a[1][1] - b[1][1];
>+    result[1][2] = a[1][2] - b[1][2];
>+    result[2][0] = a[2][0] - b[2][0];
>+    result[2][1] = a[2][1] - b[2][1];
>+    result[2][2] = a[2][2] - b[2][2];
>+    result[3][0] = a[3][0] - b[3][0];
>+    result[3][1] = a[3][1] - b[3][1];
>+    result[3][2] = a[3][2] - b[3][2];
>+    return result;
>+}
>+float4x3 operator-(float4x3 a) {
>+    float4x3 result;
>+    result[0][0] = -a[0][0];
>+    result[0][1] = -a[0][1];
>+    result[0][2] = -a[0][2];
>+    result[1][0] = -a[1][0];
>+    result[1][1] = -a[1][1];
>+    result[1][2] = -a[1][2];
>+    result[2][0] = -a[2][0];
>+    result[2][1] = -a[2][1];
>+    result[2][2] = -a[2][2];
>+    result[3][0] = -a[3][0];
>+    result[3][1] = -a[3][1];
>+    result[3][2] = -a[3][2];
>+    return result;
>+}
>+float4x4 operator-(float4x4 a, float4x4 b) {
>+    float4x4 result;
>+    result[0][0] = a[0][0] - b[0][0];
>+    result[0][1] = a[0][1] - b[0][1];
>+    result[0][2] = a[0][2] - b[0][2];
>+    result[0][3] = a[0][3] - b[0][3];
>+    result[1][0] = a[1][0] - b[1][0];
>+    result[1][1] = a[1][1] - b[1][1];
>+    result[1][2] = a[1][2] - b[1][2];
>+    result[1][3] = a[1][3] - b[1][3];
>+    result[2][0] = a[2][0] - b[2][0];
>+    result[2][1] = a[2][1] - b[2][1];
>+    result[2][2] = a[2][2] - b[2][2];
>+    result[2][3] = a[2][3] - b[2][3];
>+    result[3][0] = a[3][0] - b[3][0];
>+    result[3][1] = a[3][1] - b[3][1];
>+    result[3][2] = a[3][2] - b[3][2];
>+    result[3][3] = a[3][3] - b[3][3];
>+    return result;
>+}
>+float4x4 operator-(float4x4 a) {
>+    float4x4 result;
>+    result[0][0] = -a[0][0];
>+    result[0][1] = -a[0][1];
>+    result[0][2] = -a[0][2];
>+    result[0][3] = -a[0][3];
>+    result[1][0] = -a[1][0];
>+    result[1][1] = -a[1][1];
>+    result[1][2] = -a[1][2];
>+    result[1][3] = -a[1][3];
>+    result[2][0] = -a[2][0];
>+    result[2][1] = -a[2][1];
>+    result[2][2] = -a[2][2];
>+    result[2][3] = -a[2][3];
>+    result[3][0] = -a[3][0];
>+    result[3][1] = -a[3][1];
>+    result[3][2] = -a[3][2];
>+    result[3][3] = -a[3][3];
>+    return result;
>+}
>+
>+/* Functions named min */
>+uchar min(uchar x, uchar y) {
>+    return x > y ? y : x;
>+}
>+uchar2 min(uchar2 x, uchar2 y) {
>+    uchar2 result;
>+    result[0] = min(x[0], y[0]);
>+    result[1] = min(x[1], y[1]);
>+    return result;
>+}
>+uchar3 min(uchar3 x, uchar3 y) {
>+    uchar3 result;
>+    result[0] = min(x[0], y[0]);
>+    result[1] = min(x[1], y[1]);
>+    result[2] = min(x[2], y[2]);
>+    return result;
>+}
>+uchar4 min(uchar4 x, uchar4 y) {
>+    uchar4 result;
>+    result[0] = min(x[0], y[0]);
>+    result[1] = min(x[1], y[1]);
>+    result[2] = min(x[2], y[2]);
>+    result[3] = min(x[3], y[3]);
>+    return result;
>+}
>+ushort min(ushort x, ushort y) {
>+    return x > y ? y : x;
>+}
>+ushort2 min(ushort2 x, ushort2 y) {
>+    ushort2 result;
>+    result[0] = min(x[0], y[0]);
>+    result[1] = min(x[1], y[1]);
>+    return result;
>+}
>+ushort3 min(ushort3 x, ushort3 y) {
>+    ushort3 result;
>+    result[0] = min(x[0], y[0]);
>+    result[1] = min(x[1], y[1]);
>+    result[2] = min(x[2], y[2]);
>+    return result;
>+}
>+ushort4 min(ushort4 x, ushort4 y) {
>+    ushort4 result;
>+    result[0] = min(x[0], y[0]);
>+    result[1] = min(x[1], y[1]);
>+    result[2] = min(x[2], y[2]);
>+    result[3] = min(x[3], y[3]);
>+    return result;
>+}
>+uint min(uint x, uint y) {
>+    return x > y ? y : x;
>+}
>+uint2 min(uint2 x, uint2 y) {
>+    uint2 result;
>+    result[0] = min(x[0], y[0]);
>+    result[1] = min(x[1], y[1]);
>+    return result;
>+}
>+uint3 min(uint3 x, uint3 y) {
>+    uint3 result;
>+    result[0] = min(x[0], y[0]);
>+    result[1] = min(x[1], y[1]);
>+    result[2] = min(x[2], y[2]);
>+    return result;
>+}
>+uint4 min(uint4 x, uint4 y) {
>+    uint4 result;
>+    result[0] = min(x[0], y[0]);
>+    result[1] = min(x[1], y[1]);
>+    result[2] = min(x[2], y[2]);
>+    result[3] = min(x[3], y[3]);
>+    return result;
>+}
>+char min(char x, char y) {
>+    return x > y ? y : x;
>+}
>+char2 min(char2 x, char2 y) {
>+    char2 result;
>+    result[0] = min(x[0], y[0]);
>+    result[1] = min(x[1], y[1]);
>+    return result;
>+}
>+char3 min(char3 x, char3 y) {
>+    char3 result;
>+    result[0] = min(x[0], y[0]);
>+    result[1] = min(x[1], y[1]);
>+    result[2] = min(x[2], y[2]);
>+    return result;
>+}
>+char4 min(char4 x, char4 y) {
>+    char4 result;
>+    result[0] = min(x[0], y[0]);
>+    result[1] = min(x[1], y[1]);
>+    result[2] = min(x[2], y[2]);
>+    result[3] = min(x[3], y[3]);
>+    return result;
>+}
>+short min(short x, short y) {
>+    return x > y ? y : x;
>+}
>+short2 min(short2 x, short2 y) {
>+    short2 result;
>+    result[0] = min(x[0], y[0]);
>+    result[1] = min(x[1], y[1]);
>+    return result;
>+}
>+short3 min(short3 x, short3 y) {
>+    short3 result;
>+    result[0] = min(x[0], y[0]);
>+    result[1] = min(x[1], y[1]);
>+    result[2] = min(x[2], y[2]);
>+    return result;
>+}
>+short4 min(short4 x, short4 y) {
>+    short4 result;
>+    result[0] = min(x[0], y[0]);
>+    result[1] = min(x[1], y[1]);
>+    result[2] = min(x[2], y[2]);
>+    result[3] = min(x[3], y[3]);
>+    return result;
>+}
>+int min(int x, int y) {
>+    return x > y ? y : x;
>+}
>+int2 min(int2 x, int2 y) {
>+    int2 result;
>+    result[0] = min(x[0], y[0]);
>+    result[1] = min(x[1], y[1]);
>+    return result;
>+}
>+int3 min(int3 x, int3 y) {
>+    int3 result;
>+    result[0] = min(x[0], y[0]);
>+    result[1] = min(x[1], y[1]);
>+    result[2] = min(x[2], y[2]);
>+    return result;
>+}
>+int4 min(int4 x, int4 y) {
>+    int4 result;
>+    result[0] = min(x[0], y[0]);
>+    result[1] = min(x[1], y[1]);
>+    result[2] = min(x[2], y[2]);
>+    result[3] = min(x[3], y[3]);
>+    return result;
>+}
>+half min(half x, half y) {
>+    return x > y ? y : x;
>+}
>+half2 min(half2 x, half2 y) {
>+    half2 result;
>+    result[0] = min(x[0], y[0]);
>+    result[1] = min(x[1], y[1]);
>+    return result;
>+}
>+half3 min(half3 x, half3 y) {
>+    half3 result;
>+    result[0] = min(x[0], y[0]);
>+    result[1] = min(x[1], y[1]);
>+    result[2] = min(x[2], y[2]);
>+    return result;
>+}
>+half4 min(half4 x, half4 y) {
>+    half4 result;
>+    result[0] = min(x[0], y[0]);
>+    result[1] = min(x[1], y[1]);
>+    result[2] = min(x[2], y[2]);
>+    result[3] = min(x[3], y[3]);
>+    return result;
>+}
>+half2x2 min(half2x2 x, half2x2 y) {
>+    half2x2 result;
>+    result[0][0] = min(x[0][0], y[0][0]);
>+    result[0][1] = min(x[0][1], y[0][1]);
>+    result[1][0] = min(x[1][0], y[1][0]);
>+    result[1][1] = min(x[1][1], y[1][1]);
>+    return result;
>+}
>+half2x3 min(half2x3 x, half2x3 y) {
>+    half2x3 result;
>+    result[0][0] = min(x[0][0], y[0][0]);
>+    result[0][1] = min(x[0][1], y[0][1]);
>+    result[0][2] = min(x[0][2], y[0][2]);
>+    result[1][0] = min(x[1][0], y[1][0]);
>+    result[1][1] = min(x[1][1], y[1][1]);
>+    result[1][2] = min(x[1][2], y[1][2]);
>+    return result;
>+}
>+half2x4 min(half2x4 x, half2x4 y) {
>+    half2x4 result;
>+    result[0][0] = min(x[0][0], y[0][0]);
>+    result[0][1] = min(x[0][1], y[0][1]);
>+    result[0][2] = min(x[0][2], y[0][2]);
>+    result[0][3] = min(x[0][3], y[0][3]);
>+    result[1][0] = min(x[1][0], y[1][0]);
>+    result[1][1] = min(x[1][1], y[1][1]);
>+    result[1][2] = min(x[1][2], y[1][2]);
>+    result[1][3] = min(x[1][3], y[1][3]);
>+    return result;
>+}
>+half3x2 min(half3x2 x, half3x2 y) {
>+    half3x2 result;
>+    result[0][0] = min(x[0][0], y[0][0]);
>+    result[0][1] = min(x[0][1], y[0][1]);
>+    result[1][0] = min(x[1][0], y[1][0]);
>+    result[1][1] = min(x[1][1], y[1][1]);
>+    result[2][0] = min(x[2][0], y[2][0]);
>+    result[2][1] = min(x[2][1], y[2][1]);
>+    return result;
>+}
>+half3x3 min(half3x3 x, half3x3 y) {
>+    half3x3 result;
>+    result[0][0] = min(x[0][0], y[0][0]);
>+    result[0][1] = min(x[0][1], y[0][1]);
>+    result[0][2] = min(x[0][2], y[0][2]);
>+    result[1][0] = min(x[1][0], y[1][0]);
>+    result[1][1] = min(x[1][1], y[1][1]);
>+    result[1][2] = min(x[1][2], y[1][2]);
>+    result[2][0] = min(x[2][0], y[2][0]);
>+    result[2][1] = min(x[2][1], y[2][1]);
>+    result[2][2] = min(x[2][2], y[2][2]);
>+    return result;
>+}
>+half3x4 min(half3x4 x, half3x4 y) {
>+    half3x4 result;
>+    result[0][0] = min(x[0][0], y[0][0]);
>+    result[0][1] = min(x[0][1], y[0][1]);
>+    result[0][2] = min(x[0][2], y[0][2]);
>+    result[0][3] = min(x[0][3], y[0][3]);
>+    result[1][0] = min(x[1][0], y[1][0]);
>+    result[1][1] = min(x[1][1], y[1][1]);
>+    result[1][2] = min(x[1][2], y[1][2]);
>+    result[1][3] = min(x[1][3], y[1][3]);
>+    result[2][0] = min(x[2][0], y[2][0]);
>+    result[2][1] = min(x[2][1], y[2][1]);
>+    result[2][2] = min(x[2][2], y[2][2]);
>+    result[2][3] = min(x[2][3], y[2][3]);
>+    return result;
>+}
>+half4x2 min(half4x2 x, half4x2 y) {
>+    half4x2 result;
>+    result[0][0] = min(x[0][0], y[0][0]);
>+    result[0][1] = min(x[0][1], y[0][1]);
>+    result[1][0] = min(x[1][0], y[1][0]);
>+    result[1][1] = min(x[1][1], y[1][1]);
>+    result[2][0] = min(x[2][0], y[2][0]);
>+    result[2][1] = min(x[2][1], y[2][1]);
>+    result[3][0] = min(x[3][0], y[3][0]);
>+    result[3][1] = min(x[3][1], y[3][1]);
>+    return result;
>+}
>+half4x3 min(half4x3 x, half4x3 y) {
>+    half4x3 result;
>+    result[0][0] = min(x[0][0], y[0][0]);
>+    result[0][1] = min(x[0][1], y[0][1]);
>+    result[0][2] = min(x[0][2], y[0][2]);
>+    result[1][0] = min(x[1][0], y[1][0]);
>+    result[1][1] = min(x[1][1], y[1][1]);
>+    result[1][2] = min(x[1][2], y[1][2]);
>+    result[2][0] = min(x[2][0], y[2][0]);
>+    result[2][1] = min(x[2][1], y[2][1]);
>+    result[2][2] = min(x[2][2], y[2][2]);
>+    result[3][0] = min(x[3][0], y[3][0]);
>+    result[3][1] = min(x[3][1], y[3][1]);
>+    result[3][2] = min(x[3][2], y[3][2]);
>+    return result;
>+}
>+half4x4 min(half4x4 x, half4x4 y) {
>+    half4x4 result;
>+    result[0][0] = min(x[0][0], y[0][0]);
>+    result[0][1] = min(x[0][1], y[0][1]);
>+    result[0][2] = min(x[0][2], y[0][2]);
>+    result[0][3] = min(x[0][3], y[0][3]);
>+    result[1][0] = min(x[1][0], y[1][0]);
>+    result[1][1] = min(x[1][1], y[1][1]);
>+    result[1][2] = min(x[1][2], y[1][2]);
>+    result[1][3] = min(x[1][3], y[1][3]);
>+    result[2][0] = min(x[2][0], y[2][0]);
>+    result[2][1] = min(x[2][1], y[2][1]);
>+    result[2][2] = min(x[2][2], y[2][2]);
>+    result[2][3] = min(x[2][3], y[2][3]);
>+    result[3][0] = min(x[3][0], y[3][0]);
>+    result[3][1] = min(x[3][1], y[3][1]);
>+    result[3][2] = min(x[3][2], y[3][2]);
>+    result[3][3] = min(x[3][3], y[3][3]);
>+    return result;
>+}
>+float min(float x, float y) {
>+    return x > y ? y : x;
>+}
>+float2 min(float2 x, float2 y) {
>+    float2 result;
>+    result[0] = min(x[0], y[0]);
>+    result[1] = min(x[1], y[1]);
>+    return result;
>+}
>+float3 min(float3 x, float3 y) {
>+    float3 result;
>+    result[0] = min(x[0], y[0]);
>+    result[1] = min(x[1], y[1]);
>+    result[2] = min(x[2], y[2]);
>+    return result;
>+}
>+float4 min(float4 x, float4 y) {
>+    float4 result;
>+    result[0] = min(x[0], y[0]);
>+    result[1] = min(x[1], y[1]);
>+    result[2] = min(x[2], y[2]);
>+    result[3] = min(x[3], y[3]);
>+    return result;
>+}
>+float2x2 min(float2x2 x, float2x2 y) {
>+    float2x2 result;
>+    result[0][0] = min(x[0][0], y[0][0]);
>+    result[0][1] = min(x[0][1], y[0][1]);
>+    result[1][0] = min(x[1][0], y[1][0]);
>+    result[1][1] = min(x[1][1], y[1][1]);
>+    return result;
>+}
>+float2x3 min(float2x3 x, float2x3 y) {
>+    float2x3 result;
>+    result[0][0] = min(x[0][0], y[0][0]);
>+    result[0][1] = min(x[0][1], y[0][1]);
>+    result[0][2] = min(x[0][2], y[0][2]);
>+    result[1][0] = min(x[1][0], y[1][0]);
>+    result[1][1] = min(x[1][1], y[1][1]);
>+    result[1][2] = min(x[1][2], y[1][2]);
>+    return result;
>+}
>+float2x4 min(float2x4 x, float2x4 y) {
>+    float2x4 result;
>+    result[0][0] = min(x[0][0], y[0][0]);
>+    result[0][1] = min(x[0][1], y[0][1]);
>+    result[0][2] = min(x[0][2], y[0][2]);
>+    result[0][3] = min(x[0][3], y[0][3]);
>+    result[1][0] = min(x[1][0], y[1][0]);
>+    result[1][1] = min(x[1][1], y[1][1]);
>+    result[1][2] = min(x[1][2], y[1][2]);
>+    result[1][3] = min(x[1][3], y[1][3]);
>+    return result;
>+}
>+float3x2 min(float3x2 x, float3x2 y) {
>+    float3x2 result;
>+    result[0][0] = min(x[0][0], y[0][0]);
>+    result[0][1] = min(x[0][1], y[0][1]);
>+    result[1][0] = min(x[1][0], y[1][0]);
>+    result[1][1] = min(x[1][1], y[1][1]);
>+    result[2][0] = min(x[2][0], y[2][0]);
>+    result[2][1] = min(x[2][1], y[2][1]);
>+    return result;
>+}
>+float3x3 min(float3x3 x, float3x3 y) {
>+    float3x3 result;
>+    result[0][0] = min(x[0][0], y[0][0]);
>+    result[0][1] = min(x[0][1], y[0][1]);
>+    result[0][2] = min(x[0][2], y[0][2]);
>+    result[1][0] = min(x[1][0], y[1][0]);
>+    result[1][1] = min(x[1][1], y[1][1]);
>+    result[1][2] = min(x[1][2], y[1][2]);
>+    result[2][0] = min(x[2][0], y[2][0]);
>+    result[2][1] = min(x[2][1], y[2][1]);
>+    result[2][2] = min(x[2][2], y[2][2]);
>+    return result;
>+}
>+float3x4 min(float3x4 x, float3x4 y) {
>+    float3x4 result;
>+    result[0][0] = min(x[0][0], y[0][0]);
>+    result[0][1] = min(x[0][1], y[0][1]);
>+    result[0][2] = min(x[0][2], y[0][2]);
>+    result[0][3] = min(x[0][3], y[0][3]);
>+    result[1][0] = min(x[1][0], y[1][0]);
>+    result[1][1] = min(x[1][1], y[1][1]);
>+    result[1][2] = min(x[1][2], y[1][2]);
>+    result[1][3] = min(x[1][3], y[1][3]);
>+    result[2][0] = min(x[2][0], y[2][0]);
>+    result[2][1] = min(x[2][1], y[2][1]);
>+    result[2][2] = min(x[2][2], y[2][2]);
>+    result[2][3] = min(x[2][3], y[2][3]);
>+    return result;
>+}
>+float4x2 min(float4x2 x, float4x2 y) {
>+    float4x2 result;
>+    result[0][0] = min(x[0][0], y[0][0]);
>+    result[0][1] = min(x[0][1], y[0][1]);
>+    result[1][0] = min(x[1][0], y[1][0]);
>+    result[1][1] = min(x[1][1], y[1][1]);
>+    result[2][0] = min(x[2][0], y[2][0]);
>+    result[2][1] = min(x[2][1], y[2][1]);
>+    result[3][0] = min(x[3][0], y[3][0]);
>+    result[3][1] = min(x[3][1], y[3][1]);
>+    return result;
>+}
>+float4x3 min(float4x3 x, float4x3 y) {
>+    float4x3 result;
>+    result[0][0] = min(x[0][0], y[0][0]);
>+    result[0][1] = min(x[0][1], y[0][1]);
>+    result[0][2] = min(x[0][2], y[0][2]);
>+    result[1][0] = min(x[1][0], y[1][0]);
>+    result[1][1] = min(x[1][1], y[1][1]);
>+    result[1][2] = min(x[1][2], y[1][2]);
>+    result[2][0] = min(x[2][0], y[2][0]);
>+    result[2][1] = min(x[2][1], y[2][1]);
>+    result[2][2] = min(x[2][2], y[2][2]);
>+    result[3][0] = min(x[3][0], y[3][0]);
>+    result[3][1] = min(x[3][1], y[3][1]);
>+    result[3][2] = min(x[3][2], y[3][2]);
>+    return result;
>+}
>+float4x4 min(float4x4 x, float4x4 y) {
>+    float4x4 result;
>+    result[0][0] = min(x[0][0], y[0][0]);
>+    result[0][1] = min(x[0][1], y[0][1]);
>+    result[0][2] = min(x[0][2], y[0][2]);
>+    result[0][3] = min(x[0][3], y[0][3]);
>+    result[1][0] = min(x[1][0], y[1][0]);
>+    result[1][1] = min(x[1][1], y[1][1]);
>+    result[1][2] = min(x[1][2], y[1][2]);
>+    result[1][3] = min(x[1][3], y[1][3]);
>+    result[2][0] = min(x[2][0], y[2][0]);
>+    result[2][1] = min(x[2][1], y[2][1]);
>+    result[2][2] = min(x[2][2], y[2][2]);
>+    result[2][3] = min(x[2][3], y[2][3]);
>+    result[3][0] = min(x[3][0], y[3][0]);
>+    result[3][1] = min(x[3][1], y[3][1]);
>+    result[3][2] = min(x[3][2], y[3][2]);
>+    result[3][3] = min(x[3][3], y[3][3]);
>+    return result;
>+}
>+
>+/* Functions named operator.xyz */
>+bool3 operator.xyz(bool3 v) {
>+    bool3 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.z;
>+    return result;
>+}
>+bool3 operator.xyz(bool4 v) {
>+    bool3 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.z;
>+    return result;
>+}
>+uchar3 operator.xyz(uchar3 v) {
>+    uchar3 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.z;
>+    return result;
>+}
>+uchar3 operator.xyz(uchar4 v) {
>+    uchar3 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.z;
>+    return result;
>+}
>+ushort3 operator.xyz(ushort3 v) {
>+    ushort3 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.z;
>+    return result;
>+}
>+ushort3 operator.xyz(ushort4 v) {
>+    ushort3 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.z;
>+    return result;
>+}
>+uint3 operator.xyz(uint3 v) {
>+    uint3 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.z;
>+    return result;
>+}
>+uint3 operator.xyz(uint4 v) {
>+    uint3 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.z;
>+    return result;
>+}
>+char3 operator.xyz(char3 v) {
>+    char3 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.z;
>+    return result;
>+}
>+char3 operator.xyz(char4 v) {
>+    char3 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.z;
>+    return result;
>+}
>+short3 operator.xyz(short3 v) {
>+    short3 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.z;
>+    return result;
>+}
>+short3 operator.xyz(short4 v) {
>+    short3 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.z;
>+    return result;
>+}
>+int3 operator.xyz(int3 v) {
>+    int3 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.z;
>+    return result;
>+}
>+int3 operator.xyz(int4 v) {
>+    int3 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.z;
>+    return result;
>+}
>+half3 operator.xyz(half3 v) {
>+    half3 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.z;
>+    return result;
>+}
>+half3 operator.xyz(half4 v) {
>+    half3 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.z;
>+    return result;
>+}
>+float3 operator.xyz(float3 v) {
>+    float3 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.z;
>+    return result;
>+}
>+float3 operator.xyz(float4 v) {
>+    float3 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.z;
>+    return result;
>+}
>+
>+/* Functions named operator.wz= */
>+bool4 operator.wz=(bool4 v, bool2 c) {
>+    bool4 result = v;
>+    result.w = c.x;
>+    result.z = c.y;
>+    return result;
>+}
>+uchar4 operator.wz=(uchar4 v, uchar2 c) {
>+    uchar4 result = v;
>+    result.w = c.x;
>+    result.z = c.y;
>+    return result;
>+}
>+ushort4 operator.wz=(ushort4 v, ushort2 c) {
>+    ushort4 result = v;
>+    result.w = c.x;
>+    result.z = c.y;
>+    return result;
>+}
>+uint4 operator.wz=(uint4 v, uint2 c) {
>+    uint4 result = v;
>+    result.w = c.x;
>+    result.z = c.y;
>+    return result;
>+}
>+char4 operator.wz=(char4 v, char2 c) {
>+    char4 result = v;
>+    result.w = c.x;
>+    result.z = c.y;
>+    return result;
>+}
>+short4 operator.wz=(short4 v, short2 c) {
>+    short4 result = v;
>+    result.w = c.x;
>+    result.z = c.y;
>+    return result;
>+}
>+int4 operator.wz=(int4 v, int2 c) {
>+    int4 result = v;
>+    result.w = c.x;
>+    result.z = c.y;
>+    return result;
>+}
>+half4 operator.wz=(half4 v, half2 c) {
>+    half4 result = v;
>+    result.w = c.x;
>+    result.z = c.y;
>+    return result;
>+}
>+float4 operator.wz=(float4 v, float2 c) {
>+    float4 result = v;
>+    result.w = c.x;
>+    result.z = c.y;
>+    return result;
>+}
>+
>+/* Functions named operator.zyyy */
>+bool4 operator.zyyy(bool3 v) {
>+    bool4 result;
>+    result.x = v.z;
>+    result.y = v.y;
>+    result.z = v.y;
>+    result.w = v.y;
>+    return result;
>+}
>+bool4 operator.zyyy(bool4 v) {
>+    bool4 result;
>+    result.x = v.z;
>+    result.y = v.y;
>+    result.z = v.y;
>+    result.w = v.y;
>+    return result;
>+}
>+uchar4 operator.zyyy(uchar3 v) {
>+    uchar4 result;
>+    result.x = v.z;
>+    result.y = v.y;
>+    result.z = v.y;
>+    result.w = v.y;
>+    return result;
>+}
>+uchar4 operator.zyyy(uchar4 v) {
>+    uchar4 result;
>+    result.x = v.z;
>+    result.y = v.y;
>+    result.z = v.y;
>+    result.w = v.y;
>+    return result;
>+}
>+ushort4 operator.zyyy(ushort3 v) {
>+    ushort4 result;
>+    result.x = v.z;
>+    result.y = v.y;
>+    result.z = v.y;
>+    result.w = v.y;
>+    return result;
>+}
>+ushort4 operator.zyyy(ushort4 v) {
>+    ushort4 result;
>+    result.x = v.z;
>+    result.y = v.y;
>+    result.z = v.y;
>+    result.w = v.y;
>+    return result;
>+}
>+uint4 operator.zyyy(uint3 v) {
>+    uint4 result;
>+    result.x = v.z;
>+    result.y = v.y;
>+    result.z = v.y;
>+    result.w = v.y;
>+    return result;
>+}
>+uint4 operator.zyyy(uint4 v) {
>+    uint4 result;
>+    result.x = v.z;
>+    result.y = v.y;
>+    result.z = v.y;
>+    result.w = v.y;
>+    return result;
>+}
>+char4 operator.zyyy(char3 v) {
>+    char4 result;
>+    result.x = v.z;
>+    result.y = v.y;
>+    result.z = v.y;
>+    result.w = v.y;
>+    return result;
>+}
>+char4 operator.zyyy(char4 v) {
>+    char4 result;
>+    result.x = v.z;
>+    result.y = v.y;
>+    result.z = v.y;
>+    result.w = v.y;
>+    return result;
>+}
>+short4 operator.zyyy(short3 v) {
>+    short4 result;
>+    result.x = v.z;
>+    result.y = v.y;
>+    result.z = v.y;
>+    result.w = v.y;
>+    return result;
>+}
>+short4 operator.zyyy(short4 v) {
>+    short4 result;
>+    result.x = v.z;
>+    result.y = v.y;
>+    result.z = v.y;
>+    result.w = v.y;
>+    return result;
>+}
>+int4 operator.zyyy(int3 v) {
>+    int4 result;
>+    result.x = v.z;
>+    result.y = v.y;
>+    result.z = v.y;
>+    result.w = v.y;
>+    return result;
>+}
>+int4 operator.zyyy(int4 v) {
>+    int4 result;
>+    result.x = v.z;
>+    result.y = v.y;
>+    result.z = v.y;
>+    result.w = v.y;
>+    return result;
>+}
>+half4 operator.zyyy(half3 v) {
>+    half4 result;
>+    result.x = v.z;
>+    result.y = v.y;
>+    result.z = v.y;
>+    result.w = v.y;
>+    return result;
>+}
>+half4 operator.zyyy(half4 v) {
>+    half4 result;
>+    result.x = v.z;
>+    result.y = v.y;
>+    result.z = v.y;
>+    result.w = v.y;
>+    return result;
>+}
>+float4 operator.zyyy(float3 v) {
>+    float4 result;
>+    result.x = v.z;
>+    result.y = v.y;
>+    result.z = v.y;
>+    result.w = v.y;
>+    return result;
>+}
>+float4 operator.zyyy(float4 v) {
>+    float4 result;
>+    result.x = v.z;
>+    result.y = v.y;
>+    result.z = v.y;
>+    result.w = v.y;
>+    return result;
>+}
>+
>+/* Functions named InterlockedXor */
>+native void InterlockedXor(device atomic_uint*, uint, thread uint*);
>+native void InterlockedXor(device atomic_int*, int, thread int*);
>+native void InterlockedXor(device atomic_uint*, uint, device uint*);
>+native void InterlockedXor(device atomic_int*, int, device int*);
>+native void InterlockedXor(device atomic_uint*, uint, threadgroup uint*);
>+native void InterlockedXor(device atomic_int*, int, threadgroup int*);
>+native void InterlockedXor(threadgroup atomic_uint*, uint, thread uint*);
>+native void InterlockedXor(threadgroup atomic_int*, int, thread int*);
>+native void InterlockedXor(threadgroup atomic_uint*, uint, device uint*);
>+native void InterlockedXor(threadgroup atomic_int*, int, device int*);
>+native void InterlockedXor(threadgroup atomic_uint*, uint, threadgroup uint*);
>+native void InterlockedXor(threadgroup atomic_int*, int, threadgroup int*);
>+
>+/* Functions named operator.wzx= */
>+bool4 operator.wzx=(bool4 v, bool3 c) {
>+    bool4 result = v;
>+    result.w = c.x;
>+    result.z = c.y;
>+    result.x = c.z;
>+    return result;
>+}
>+uchar4 operator.wzx=(uchar4 v, uchar3 c) {
>+    uchar4 result = v;
>+    result.w = c.x;
>+    result.z = c.y;
>+    result.x = c.z;
>+    return result;
>+}
>+ushort4 operator.wzx=(ushort4 v, ushort3 c) {
>+    ushort4 result = v;
>+    result.w = c.x;
>+    result.z = c.y;
>+    result.x = c.z;
>+    return result;
>+}
>+uint4 operator.wzx=(uint4 v, uint3 c) {
>+    uint4 result = v;
>+    result.w = c.x;
>+    result.z = c.y;
>+    result.x = c.z;
>+    return result;
>+}
>+char4 operator.wzx=(char4 v, char3 c) {
>+    char4 result = v;
>+    result.w = c.x;
>+    result.z = c.y;
>+    result.x = c.z;
>+    return result;
>+}
>+short4 operator.wzx=(short4 v, short3 c) {
>+    short4 result = v;
>+    result.w = c.x;
>+    result.z = c.y;
>+    result.x = c.z;
>+    return result;
>+}
>+int4 operator.wzx=(int4 v, int3 c) {
>+    int4 result = v;
>+    result.w = c.x;
>+    result.z = c.y;
>+    result.x = c.z;
>+    return result;
>+}
>+half4 operator.wzx=(half4 v, half3 c) {
>+    half4 result = v;
>+    result.w = c.x;
>+    result.z = c.y;
>+    result.x = c.z;
>+    return result;
>+}
>+float4 operator.wzx=(float4 v, float3 c) {
>+    float4 result = v;
>+    result.w = c.x;
>+    result.z = c.y;
>+    result.x = c.z;
>+    return result;
>+}
>+
>+/* Functions named operator.zwzy */
>+bool4 operator.zwzy(bool4 v) {
>+    bool4 result;
>+    result.x = v.z;
>+    result.y = v.w;
>+    result.z = v.z;
>+    result.w = v.y;
>+    return result;
>+}
>+uchar4 operator.zwzy(uchar4 v) {
>+    uchar4 result;
>+    result.x = v.z;
>+    result.y = v.w;
>+    result.z = v.z;
>+    result.w = v.y;
>+    return result;
>+}
>+ushort4 operator.zwzy(ushort4 v) {
>+    ushort4 result;
>+    result.x = v.z;
>+    result.y = v.w;
>+    result.z = v.z;
>+    result.w = v.y;
>+    return result;
>+}
>+uint4 operator.zwzy(uint4 v) {
>+    uint4 result;
>+    result.x = v.z;
>+    result.y = v.w;
>+    result.z = v.z;
>+    result.w = v.y;
>+    return result;
>+}
>+char4 operator.zwzy(char4 v) {
>+    char4 result;
>+    result.x = v.z;
>+    result.y = v.w;
>+    result.z = v.z;
>+    result.w = v.y;
>+    return result;
>+}
>+short4 operator.zwzy(short4 v) {
>+    short4 result;
>+    result.x = v.z;
>+    result.y = v.w;
>+    result.z = v.z;
>+    result.w = v.y;
>+    return result;
>+}
>+int4 operator.zwzy(int4 v) {
>+    int4 result;
>+    result.x = v.z;
>+    result.y = v.w;
>+    result.z = v.z;
>+    result.w = v.y;
>+    return result;
>+}
>+half4 operator.zwzy(half4 v) {
>+    half4 result;
>+    result.x = v.z;
>+    result.y = v.w;
>+    result.z = v.z;
>+    result.w = v.y;
>+    return result;
>+}
>+float4 operator.zwzy(float4 v) {
>+    float4 result;
>+    result.x = v.z;
>+    result.y = v.w;
>+    result.z = v.z;
>+    result.w = v.y;
>+    return result;
>+}
>+
>+/* Functions named GroupMemoryBarrierWithGroupSync */
>+native void GroupMemoryBarrierWithGroupSync();
>+
>+
>+/* Functions named operator.xyzy */
>+bool4 operator.xyzy(bool3 v) {
>+    bool4 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.z;
>+    result.w = v.y;
>+    return result;
>+}
>+bool4 operator.xyzy(bool4 v) {
>+    bool4 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.z;
>+    result.w = v.y;
>+    return result;
>+}
>+uchar4 operator.xyzy(uchar3 v) {
>+    uchar4 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.z;
>+    result.w = v.y;
>+    return result;
>+}
>+uchar4 operator.xyzy(uchar4 v) {
>+    uchar4 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.z;
>+    result.w = v.y;
>+    return result;
>+}
>+ushort4 operator.xyzy(ushort3 v) {
>+    ushort4 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.z;
>+    result.w = v.y;
>+    return result;
>+}
>+ushort4 operator.xyzy(ushort4 v) {
>+    ushort4 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.z;
>+    result.w = v.y;
>+    return result;
>+}
>+uint4 operator.xyzy(uint3 v) {
>+    uint4 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.z;
>+    result.w = v.y;
>+    return result;
>+}
>+uint4 operator.xyzy(uint4 v) {
>+    uint4 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.z;
>+    result.w = v.y;
>+    return result;
>+}
>+char4 operator.xyzy(char3 v) {
>+    char4 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.z;
>+    result.w = v.y;
>+    return result;
>+}
>+char4 operator.xyzy(char4 v) {
>+    char4 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.z;
>+    result.w = v.y;
>+    return result;
>+}
>+short4 operator.xyzy(short3 v) {
>+    short4 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.z;
>+    result.w = v.y;
>+    return result;
>+}
>+short4 operator.xyzy(short4 v) {
>+    short4 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.z;
>+    result.w = v.y;
>+    return result;
>+}
>+int4 operator.xyzy(int3 v) {
>+    int4 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.z;
>+    result.w = v.y;
>+    return result;
>+}
>+int4 operator.xyzy(int4 v) {
>+    int4 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.z;
>+    result.w = v.y;
>+    return result;
>+}
>+half4 operator.xyzy(half3 v) {
>+    half4 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.z;
>+    result.w = v.y;
>+    return result;
>+}
>+half4 operator.xyzy(half4 v) {
>+    half4 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.z;
>+    result.w = v.y;
>+    return result;
>+}
>+float4 operator.xyzy(float3 v) {
>+    float4 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.z;
>+    result.w = v.y;
>+    return result;
>+}
>+float4 operator.xyzy(float4 v) {
>+    float4 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.z;
>+    result.w = v.y;
>+    return result;
>+}
>+
>+/* Functions named trunc */
>+native float trunc(float);
>+half trunc(half x) {
>+    return half(trunc(float(x)));
>+}
>+half2 trunc(half2 x) {
>+    half2 result;
>+    result[0] = trunc(x[0]);
>+    result[1] = trunc(x[1]);
>+    return result;
>+}
>+half3 trunc(half3 x) {
>+    half3 result;
>+    result[0] = trunc(x[0]);
>+    result[1] = trunc(x[1]);
>+    result[2] = trunc(x[2]);
>+    return result;
>+}
>+half4 trunc(half4 x) {
>+    half4 result;
>+    result[0] = trunc(x[0]);
>+    result[1] = trunc(x[1]);
>+    result[2] = trunc(x[2]);
>+    result[3] = trunc(x[3]);
>+    return result;
>+}
>+half2x2 trunc(half2x2 x) {
>+    half2x2 result;
>+    result[0][0] = trunc(x[0][0]);
>+    result[0][1] = trunc(x[0][1]);
>+    result[1][0] = trunc(x[1][0]);
>+    result[1][1] = trunc(x[1][1]);
>+    return result;
>+}
>+half2x3 trunc(half2x3 x) {
>+    half2x3 result;
>+    result[0][0] = trunc(x[0][0]);
>+    result[0][1] = trunc(x[0][1]);
>+    result[0][2] = trunc(x[0][2]);
>+    result[1][0] = trunc(x[1][0]);
>+    result[1][1] = trunc(x[1][1]);
>+    result[1][2] = trunc(x[1][2]);
>+    return result;
>+}
>+half2x4 trunc(half2x4 x) {
>+    half2x4 result;
>+    result[0][0] = trunc(x[0][0]);
>+    result[0][1] = trunc(x[0][1]);
>+    result[0][2] = trunc(x[0][2]);
>+    result[0][3] = trunc(x[0][3]);
>+    result[1][0] = trunc(x[1][0]);
>+    result[1][1] = trunc(x[1][1]);
>+    result[1][2] = trunc(x[1][2]);
>+    result[1][3] = trunc(x[1][3]);
>+    return result;
>+}
>+half3x2 trunc(half3x2 x) {
>+    half3x2 result;
>+    result[0][0] = trunc(x[0][0]);
>+    result[0][1] = trunc(x[0][1]);
>+    result[1][0] = trunc(x[1][0]);
>+    result[1][1] = trunc(x[1][1]);
>+    result[2][0] = trunc(x[2][0]);
>+    result[2][1] = trunc(x[2][1]);
>+    return result;
>+}
>+half3x3 trunc(half3x3 x) {
>+    half3x3 result;
>+    result[0][0] = trunc(x[0][0]);
>+    result[0][1] = trunc(x[0][1]);
>+    result[0][2] = trunc(x[0][2]);
>+    result[1][0] = trunc(x[1][0]);
>+    result[1][1] = trunc(x[1][1]);
>+    result[1][2] = trunc(x[1][2]);
>+    result[2][0] = trunc(x[2][0]);
>+    result[2][1] = trunc(x[2][1]);
>+    result[2][2] = trunc(x[2][2]);
>+    return result;
>+}
>+half3x4 trunc(half3x4 x) {
>+    half3x4 result;
>+    result[0][0] = trunc(x[0][0]);
>+    result[0][1] = trunc(x[0][1]);
>+    result[0][2] = trunc(x[0][2]);
>+    result[0][3] = trunc(x[0][3]);
>+    result[1][0] = trunc(x[1][0]);
>+    result[1][1] = trunc(x[1][1]);
>+    result[1][2] = trunc(x[1][2]);
>+    result[1][3] = trunc(x[1][3]);
>+    result[2][0] = trunc(x[2][0]);
>+    result[2][1] = trunc(x[2][1]);
>+    result[2][2] = trunc(x[2][2]);
>+    result[2][3] = trunc(x[2][3]);
>+    return result;
>+}
>+half4x2 trunc(half4x2 x) {
>+    half4x2 result;
>+    result[0][0] = trunc(x[0][0]);
>+    result[0][1] = trunc(x[0][1]);
>+    result[1][0] = trunc(x[1][0]);
>+    result[1][1] = trunc(x[1][1]);
>+    result[2][0] = trunc(x[2][0]);
>+    result[2][1] = trunc(x[2][1]);
>+    result[3][0] = trunc(x[3][0]);
>+    result[3][1] = trunc(x[3][1]);
>+    return result;
>+}
>+half4x3 trunc(half4x3 x) {
>+    half4x3 result;
>+    result[0][0] = trunc(x[0][0]);
>+    result[0][1] = trunc(x[0][1]);
>+    result[0][2] = trunc(x[0][2]);
>+    result[1][0] = trunc(x[1][0]);
>+    result[1][1] = trunc(x[1][1]);
>+    result[1][2] = trunc(x[1][2]);
>+    result[2][0] = trunc(x[2][0]);
>+    result[2][1] = trunc(x[2][1]);
>+    result[2][2] = trunc(x[2][2]);
>+    result[3][0] = trunc(x[3][0]);
>+    result[3][1] = trunc(x[3][1]);
>+    result[3][2] = trunc(x[3][2]);
>+    return result;
>+}
>+half4x4 trunc(half4x4 x) {
>+    half4x4 result;
>+    result[0][0] = trunc(x[0][0]);
>+    result[0][1] = trunc(x[0][1]);
>+    result[0][2] = trunc(x[0][2]);
>+    result[0][3] = trunc(x[0][3]);
>+    result[1][0] = trunc(x[1][0]);
>+    result[1][1] = trunc(x[1][1]);
>+    result[1][2] = trunc(x[1][2]);
>+    result[1][3] = trunc(x[1][3]);
>+    result[2][0] = trunc(x[2][0]);
>+    result[2][1] = trunc(x[2][1]);
>+    result[2][2] = trunc(x[2][2]);
>+    result[2][3] = trunc(x[2][3]);
>+    result[3][0] = trunc(x[3][0]);
>+    result[3][1] = trunc(x[3][1]);
>+    result[3][2] = trunc(x[3][2]);
>+    result[3][3] = trunc(x[3][3]);
>+    return result;
>+}
>+float2 trunc(float2 x) {
>+    float2 result;
>+    result[0] = trunc(x[0]);
>+    result[1] = trunc(x[1]);
>+    return result;
>+}
>+float3 trunc(float3 x) {
>+    float3 result;
>+    result[0] = trunc(x[0]);
>+    result[1] = trunc(x[1]);
>+    result[2] = trunc(x[2]);
>+    return result;
>+}
>+float4 trunc(float4 x) {
>+    float4 result;
>+    result[0] = trunc(x[0]);
>+    result[1] = trunc(x[1]);
>+    result[2] = trunc(x[2]);
>+    result[3] = trunc(x[3]);
>+    return result;
>+}
>+float2x2 trunc(float2x2 x) {
>+    float2x2 result;
>+    result[0][0] = trunc(x[0][0]);
>+    result[0][1] = trunc(x[0][1]);
>+    result[1][0] = trunc(x[1][0]);
>+    result[1][1] = trunc(x[1][1]);
>+    return result;
>+}
>+float2x3 trunc(float2x3 x) {
>+    float2x3 result;
>+    result[0][0] = trunc(x[0][0]);
>+    result[0][1] = trunc(x[0][1]);
>+    result[0][2] = trunc(x[0][2]);
>+    result[1][0] = trunc(x[1][0]);
>+    result[1][1] = trunc(x[1][1]);
>+    result[1][2] = trunc(x[1][2]);
>+    return result;
>+}
>+float2x4 trunc(float2x4 x) {
>+    float2x4 result;
>+    result[0][0] = trunc(x[0][0]);
>+    result[0][1] = trunc(x[0][1]);
>+    result[0][2] = trunc(x[0][2]);
>+    result[0][3] = trunc(x[0][3]);
>+    result[1][0] = trunc(x[1][0]);
>+    result[1][1] = trunc(x[1][1]);
>+    result[1][2] = trunc(x[1][2]);
>+    result[1][3] = trunc(x[1][3]);
>+    return result;
>+}
>+float3x2 trunc(float3x2 x) {
>+    float3x2 result;
>+    result[0][0] = trunc(x[0][0]);
>+    result[0][1] = trunc(x[0][1]);
>+    result[1][0] = trunc(x[1][0]);
>+    result[1][1] = trunc(x[1][1]);
>+    result[2][0] = trunc(x[2][0]);
>+    result[2][1] = trunc(x[2][1]);
>+    return result;
>+}
>+float3x3 trunc(float3x3 x) {
>+    float3x3 result;
>+    result[0][0] = trunc(x[0][0]);
>+    result[0][1] = trunc(x[0][1]);
>+    result[0][2] = trunc(x[0][2]);
>+    result[1][0] = trunc(x[1][0]);
>+    result[1][1] = trunc(x[1][1]);
>+    result[1][2] = trunc(x[1][2]);
>+    result[2][0] = trunc(x[2][0]);
>+    result[2][1] = trunc(x[2][1]);
>+    result[2][2] = trunc(x[2][2]);
>+    return result;
>+}
>+float3x4 trunc(float3x4 x) {
>+    float3x4 result;
>+    result[0][0] = trunc(x[0][0]);
>+    result[0][1] = trunc(x[0][1]);
>+    result[0][2] = trunc(x[0][2]);
>+    result[0][3] = trunc(x[0][3]);
>+    result[1][0] = trunc(x[1][0]);
>+    result[1][1] = trunc(x[1][1]);
>+    result[1][2] = trunc(x[1][2]);
>+    result[1][3] = trunc(x[1][3]);
>+    result[2][0] = trunc(x[2][0]);
>+    result[2][1] = trunc(x[2][1]);
>+    result[2][2] = trunc(x[2][2]);
>+    result[2][3] = trunc(x[2][3]);
>+    return result;
>+}
>+float4x2 trunc(float4x2 x) {
>+    float4x2 result;
>+    result[0][0] = trunc(x[0][0]);
>+    result[0][1] = trunc(x[0][1]);
>+    result[1][0] = trunc(x[1][0]);
>+    result[1][1] = trunc(x[1][1]);
>+    result[2][0] = trunc(x[2][0]);
>+    result[2][1] = trunc(x[2][1]);
>+    result[3][0] = trunc(x[3][0]);
>+    result[3][1] = trunc(x[3][1]);
>+    return result;
>+}
>+float4x3 trunc(float4x3 x) {
>+    float4x3 result;
>+    result[0][0] = trunc(x[0][0]);
>+    result[0][1] = trunc(x[0][1]);
>+    result[0][2] = trunc(x[0][2]);
>+    result[1][0] = trunc(x[1][0]);
>+    result[1][1] = trunc(x[1][1]);
>+    result[1][2] = trunc(x[1][2]);
>+    result[2][0] = trunc(x[2][0]);
>+    result[2][1] = trunc(x[2][1]);
>+    result[2][2] = trunc(x[2][2]);
>+    result[3][0] = trunc(x[3][0]);
>+    result[3][1] = trunc(x[3][1]);
>+    result[3][2] = trunc(x[3][2]);
>+    return result;
>+}
>+float4x4 trunc(float4x4 x) {
>+    float4x4 result;
>+    result[0][0] = trunc(x[0][0]);
>+    result[0][1] = trunc(x[0][1]);
>+    result[0][2] = trunc(x[0][2]);
>+    result[0][3] = trunc(x[0][3]);
>+    result[1][0] = trunc(x[1][0]);
>+    result[1][1] = trunc(x[1][1]);
>+    result[1][2] = trunc(x[1][2]);
>+    result[1][3] = trunc(x[1][3]);
>+    result[2][0] = trunc(x[2][0]);
>+    result[2][1] = trunc(x[2][1]);
>+    result[2][2] = trunc(x[2][2]);
>+    result[2][3] = trunc(x[2][3]);
>+    result[3][0] = trunc(x[3][0]);
>+    result[3][1] = trunc(x[3][1]);
>+    result[3][2] = trunc(x[3][2]);
>+    result[3][3] = trunc(x[3][3]);
>+    return result;
>+}
>+
>+/* Functions named operator.length */
>+uint operator.length(bool2) {
>+    return 2;
>+}
>+uint operator.length(bool3) {
>+    return 3;
>+}
>+uint operator.length(bool4) {
>+    return 4;
>+}
>+uint operator.length(uchar2) {
>+    return 2;
>+}
>+uint operator.length(uchar3) {
>+    return 3;
>+}
>+uint operator.length(uchar4) {
>+    return 4;
>+}
>+uint operator.length(ushort2) {
>+    return 2;
>+}
>+uint operator.length(ushort3) {
>+    return 3;
>+}
>+uint operator.length(ushort4) {
>+    return 4;
>+}
>+uint operator.length(uint2) {
>+    return 2;
>+}
>+uint operator.length(uint3) {
>+    return 3;
>+}
>+uint operator.length(uint4) {
>+    return 4;
>+}
>+uint operator.length(char2) {
>+    return 2;
>+}
>+uint operator.length(char3) {
>+    return 3;
>+}
>+uint operator.length(char4) {
>+    return 4;
>+}
>+uint operator.length(short2) {
>+    return 2;
>+}
>+uint operator.length(short3) {
>+    return 3;
>+}
>+uint operator.length(short4) {
>+    return 4;
>+}
>+uint operator.length(int2) {
>+    return 2;
>+}
>+uint operator.length(int3) {
>+    return 3;
>+}
>+uint operator.length(int4) {
>+    return 4;
>+}
>+uint operator.length(half2) {
>+    return 2;
>+}
>+uint operator.length(half3) {
>+    return 3;
>+}
>+uint operator.length(half4) {
>+    return 4;
>+}
>+uint operator.length(float2) {
>+    return 2;
>+}
>+uint operator.length(float3) {
>+    return 3;
>+}
>+uint operator.length(float4) {
>+    return 4;
>+}
>+
>+
>+/* Functions named operator.zwwx */
>+bool4 operator.zwwx(bool4 v) {
>+    bool4 result;
>+    result.x = v.z;
>+    result.y = v.w;
>+    result.z = v.w;
>+    result.w = v.x;
>+    return result;
>+}
>+uchar4 operator.zwwx(uchar4 v) {
>+    uchar4 result;
>+    result.x = v.z;
>+    result.y = v.w;
>+    result.z = v.w;
>+    result.w = v.x;
>+    return result;
>+}
>+ushort4 operator.zwwx(ushort4 v) {
>+    ushort4 result;
>+    result.x = v.z;
>+    result.y = v.w;
>+    result.z = v.w;
>+    result.w = v.x;
>+    return result;
>+}
>+uint4 operator.zwwx(uint4 v) {
>+    uint4 result;
>+    result.x = v.z;
>+    result.y = v.w;
>+    result.z = v.w;
>+    result.w = v.x;
>+    return result;
>+}
>+char4 operator.zwwx(char4 v) {
>+    char4 result;
>+    result.x = v.z;
>+    result.y = v.w;
>+    result.z = v.w;
>+    result.w = v.x;
>+    return result;
>+}
>+short4 operator.zwwx(short4 v) {
>+    short4 result;
>+    result.x = v.z;
>+    result.y = v.w;
>+    result.z = v.w;
>+    result.w = v.x;
>+    return result;
>+}
>+int4 operator.zwwx(int4 v) {
>+    int4 result;
>+    result.x = v.z;
>+    result.y = v.w;
>+    result.z = v.w;
>+    result.w = v.x;
>+    return result;
>+}
>+half4 operator.zwwx(half4 v) {
>+    half4 result;
>+    result.x = v.z;
>+    result.y = v.w;
>+    result.z = v.w;
>+    result.w = v.x;
>+    return result;
>+}
>+float4 operator.zwwx(float4 v) {
>+    float4 result;
>+    result.x = v.z;
>+    result.y = v.w;
>+    result.z = v.w;
>+    result.w = v.x;
>+    return result;
>+}
>+
>+/* Functions named operator.wyxx */
>+bool4 operator.wyxx(bool4 v) {
>+    bool4 result;
>+    result.x = v.w;
>+    result.y = v.y;
>+    result.z = v.x;
>+    result.w = v.x;
>+    return result;
>+}
>+uchar4 operator.wyxx(uchar4 v) {
>+    uchar4 result;
>+    result.x = v.w;
>+    result.y = v.y;
>+    result.z = v.x;
>+    result.w = v.x;
>+    return result;
>+}
>+ushort4 operator.wyxx(ushort4 v) {
>+    ushort4 result;
>+    result.x = v.w;
>+    result.y = v.y;
>+    result.z = v.x;
>+    result.w = v.x;
>+    return result;
>+}
>+uint4 operator.wyxx(uint4 v) {
>+    uint4 result;
>+    result.x = v.w;
>+    result.y = v.y;
>+    result.z = v.x;
>+    result.w = v.x;
>+    return result;
>+}
>+char4 operator.wyxx(char4 v) {
>+    char4 result;
>+    result.x = v.w;
>+    result.y = v.y;
>+    result.z = v.x;
>+    result.w = v.x;
>+    return result;
>+}
>+short4 operator.wyxx(short4 v) {
>+    short4 result;
>+    result.x = v.w;
>+    result.y = v.y;
>+    result.z = v.x;
>+    result.w = v.x;
>+    return result;
>+}
>+int4 operator.wyxx(int4 v) {
>+    int4 result;
>+    result.x = v.w;
>+    result.y = v.y;
>+    result.z = v.x;
>+    result.w = v.x;
>+    return result;
>+}
>+half4 operator.wyxx(half4 v) {
>+    half4 result;
>+    result.x = v.w;
>+    result.y = v.y;
>+    result.z = v.x;
>+    result.w = v.x;
>+    return result;
>+}
>+float4 operator.wyxx(float4 v) {
>+    float4 result;
>+    result.x = v.w;
>+    result.y = v.y;
>+    result.z = v.x;
>+    result.w = v.x;
>+    return result;
>+}
>+
>+/* Functions named operator.ywz= */
>+bool4 operator.ywz=(bool4 v, bool3 c) {
>+    bool4 result = v;
>+    result.y = c.x;
>+    result.w = c.y;
>+    result.z = c.z;
>+    return result;
>+}
>+uchar4 operator.ywz=(uchar4 v, uchar3 c) {
>+    uchar4 result = v;
>+    result.y = c.x;
>+    result.w = c.y;
>+    result.z = c.z;
>+    return result;
>+}
>+ushort4 operator.ywz=(ushort4 v, ushort3 c) {
>+    ushort4 result = v;
>+    result.y = c.x;
>+    result.w = c.y;
>+    result.z = c.z;
>+    return result;
>+}
>+uint4 operator.ywz=(uint4 v, uint3 c) {
>+    uint4 result = v;
>+    result.y = c.x;
>+    result.w = c.y;
>+    result.z = c.z;
>+    return result;
>+}
>+char4 operator.ywz=(char4 v, char3 c) {
>+    char4 result = v;
>+    result.y = c.x;
>+    result.w = c.y;
>+    result.z = c.z;
>+    return result;
>+}
>+short4 operator.ywz=(short4 v, short3 c) {
>+    short4 result = v;
>+    result.y = c.x;
>+    result.w = c.y;
>+    result.z = c.z;
>+    return result;
>+}
>+int4 operator.ywz=(int4 v, int3 c) {
>+    int4 result = v;
>+    result.y = c.x;
>+    result.w = c.y;
>+    result.z = c.z;
>+    return result;
>+}
>+half4 operator.ywz=(half4 v, half3 c) {
>+    half4 result = v;
>+    result.y = c.x;
>+    result.w = c.y;
>+    result.z = c.z;
>+    return result;
>+}
>+float4 operator.ywz=(float4 v, float3 c) {
>+    float4 result = v;
>+    result.y = c.x;
>+    result.w = c.y;
>+    result.z = c.z;
>+    return result;
>+}
>+
>+/* Functions named operator.xzyy */
>+bool4 operator.xzyy(bool3 v) {
>+    bool4 result;
>+    result.x = v.x;
>+    result.y = v.z;
>+    result.z = v.y;
>+    result.w = v.y;
>+    return result;
>+}
>+bool4 operator.xzyy(bool4 v) {
>+    bool4 result;
>+    result.x = v.x;
>+    result.y = v.z;
>+    result.z = v.y;
>+    result.w = v.y;
>+    return result;
>+}
>+uchar4 operator.xzyy(uchar3 v) {
>+    uchar4 result;
>+    result.x = v.x;
>+    result.y = v.z;
>+    result.z = v.y;
>+    result.w = v.y;
>+    return result;
>+}
>+uchar4 operator.xzyy(uchar4 v) {
>+    uchar4 result;
>+    result.x = v.x;
>+    result.y = v.z;
>+    result.z = v.y;
>+    result.w = v.y;
>+    return result;
>+}
>+ushort4 operator.xzyy(ushort3 v) {
>+    ushort4 result;
>+    result.x = v.x;
>+    result.y = v.z;
>+    result.z = v.y;
>+    result.w = v.y;
>+    return result;
>+}
>+ushort4 operator.xzyy(ushort4 v) {
>+    ushort4 result;
>+    result.x = v.x;
>+    result.y = v.z;
>+    result.z = v.y;
>+    result.w = v.y;
>+    return result;
>+}
>+uint4 operator.xzyy(uint3 v) {
>+    uint4 result;
>+    result.x = v.x;
>+    result.y = v.z;
>+    result.z = v.y;
>+    result.w = v.y;
>+    return result;
>+}
>+uint4 operator.xzyy(uint4 v) {
>+    uint4 result;
>+    result.x = v.x;
>+    result.y = v.z;
>+    result.z = v.y;
>+    result.w = v.y;
>+    return result;
>+}
>+char4 operator.xzyy(char3 v) {
>+    char4 result;
>+    result.x = v.x;
>+    result.y = v.z;
>+    result.z = v.y;
>+    result.w = v.y;
>+    return result;
>+}
>+char4 operator.xzyy(char4 v) {
>+    char4 result;
>+    result.x = v.x;
>+    result.y = v.z;
>+    result.z = v.y;
>+    result.w = v.y;
>+    return result;
>+}
>+short4 operator.xzyy(short3 v) {
>+    short4 result;
>+    result.x = v.x;
>+    result.y = v.z;
>+    result.z = v.y;
>+    result.w = v.y;
>+    return result;
>+}
>+short4 operator.xzyy(short4 v) {
>+    short4 result;
>+    result.x = v.x;
>+    result.y = v.z;
>+    result.z = v.y;
>+    result.w = v.y;
>+    return result;
>+}
>+int4 operator.xzyy(int3 v) {
>+    int4 result;
>+    result.x = v.x;
>+    result.y = v.z;
>+    result.z = v.y;
>+    result.w = v.y;
>+    return result;
>+}
>+int4 operator.xzyy(int4 v) {
>+    int4 result;
>+    result.x = v.x;
>+    result.y = v.z;
>+    result.z = v.y;
>+    result.w = v.y;
>+    return result;
>+}
>+half4 operator.xzyy(half3 v) {
>+    half4 result;
>+    result.x = v.x;
>+    result.y = v.z;
>+    result.z = v.y;
>+    result.w = v.y;
>+    return result;
>+}
>+half4 operator.xzyy(half4 v) {
>+    half4 result;
>+    result.x = v.x;
>+    result.y = v.z;
>+    result.z = v.y;
>+    result.w = v.y;
>+    return result;
>+}
>+float4 operator.xzyy(float3 v) {
>+    float4 result;
>+    result.x = v.x;
>+    result.y = v.z;
>+    result.z = v.y;
>+    result.w = v.y;
>+    return result;
>+}
>+float4 operator.xzyy(float4 v) {
>+    float4 result;
>+    result.x = v.x;
>+    result.y = v.z;
>+    result.z = v.y;
>+    result.w = v.y;
>+    return result;
>+}
>+
>+/* Functions named operator.xxxz */
>+bool4 operator.xxxz(bool3 v) {
>+    bool4 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.x;
>+    result.w = v.z;
>+    return result;
>+}
>+bool4 operator.xxxz(bool4 v) {
>+    bool4 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.x;
>+    result.w = v.z;
>+    return result;
>+}
>+uchar4 operator.xxxz(uchar3 v) {
>+    uchar4 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.x;
>+    result.w = v.z;
>+    return result;
>+}
>+uchar4 operator.xxxz(uchar4 v) {
>+    uchar4 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.x;
>+    result.w = v.z;
>+    return result;
>+}
>+ushort4 operator.xxxz(ushort3 v) {
>+    ushort4 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.x;
>+    result.w = v.z;
>+    return result;
>+}
>+ushort4 operator.xxxz(ushort4 v) {
>+    ushort4 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.x;
>+    result.w = v.z;
>+    return result;
>+}
>+uint4 operator.xxxz(uint3 v) {
>+    uint4 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.x;
>+    result.w = v.z;
>+    return result;
>+}
>+uint4 operator.xxxz(uint4 v) {
>+    uint4 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.x;
>+    result.w = v.z;
>+    return result;
>+}
>+char4 operator.xxxz(char3 v) {
>+    char4 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.x;
>+    result.w = v.z;
>+    return result;
>+}
>+char4 operator.xxxz(char4 v) {
>+    char4 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.x;
>+    result.w = v.z;
>+    return result;
>+}
>+short4 operator.xxxz(short3 v) {
>+    short4 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.x;
>+    result.w = v.z;
>+    return result;
>+}
>+short4 operator.xxxz(short4 v) {
>+    short4 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.x;
>+    result.w = v.z;
>+    return result;
>+}
>+int4 operator.xxxz(int3 v) {
>+    int4 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.x;
>+    result.w = v.z;
>+    return result;
>+}
>+int4 operator.xxxz(int4 v) {
>+    int4 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.x;
>+    result.w = v.z;
>+    return result;
>+}
>+half4 operator.xxxz(half3 v) {
>+    half4 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.x;
>+    result.w = v.z;
>+    return result;
>+}
>+half4 operator.xxxz(half4 v) {
>+    half4 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.x;
>+    result.w = v.z;
>+    return result;
>+}
>+float4 operator.xxxz(float3 v) {
>+    float4 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.x;
>+    result.w = v.z;
>+    return result;
>+}
>+float4 operator.xxxz(float4 v) {
>+    float4 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.x;
>+    result.w = v.z;
>+    return result;
>+}
>+
>+/* Functions named operator.wxwy */
>+bool4 operator.wxwy(bool4 v) {
>+    bool4 result;
>+    result.x = v.w;
>+    result.y = v.x;
>+    result.z = v.w;
>+    result.w = v.y;
>+    return result;
>+}
>+uchar4 operator.wxwy(uchar4 v) {
>+    uchar4 result;
>+    result.x = v.w;
>+    result.y = v.x;
>+    result.z = v.w;
>+    result.w = v.y;
>+    return result;
>+}
>+ushort4 operator.wxwy(ushort4 v) {
>+    ushort4 result;
>+    result.x = v.w;
>+    result.y = v.x;
>+    result.z = v.w;
>+    result.w = v.y;
>+    return result;
>+}
>+uint4 operator.wxwy(uint4 v) {
>+    uint4 result;
>+    result.x = v.w;
>+    result.y = v.x;
>+    result.z = v.w;
>+    result.w = v.y;
>+    return result;
>+}
>+char4 operator.wxwy(char4 v) {
>+    char4 result;
>+    result.x = v.w;
>+    result.y = v.x;
>+    result.z = v.w;
>+    result.w = v.y;
>+    return result;
>+}
>+short4 operator.wxwy(short4 v) {
>+    short4 result;
>+    result.x = v.w;
>+    result.y = v.x;
>+    result.z = v.w;
>+    result.w = v.y;
>+    return result;
>+}
>+int4 operator.wxwy(int4 v) {
>+    int4 result;
>+    result.x = v.w;
>+    result.y = v.x;
>+    result.z = v.w;
>+    result.w = v.y;
>+    return result;
>+}
>+half4 operator.wxwy(half4 v) {
>+    half4 result;
>+    result.x = v.w;
>+    result.y = v.x;
>+    result.z = v.w;
>+    result.w = v.y;
>+    return result;
>+}
>+float4 operator.wxwy(float4 v) {
>+    float4 result;
>+    result.x = v.w;
>+    result.y = v.x;
>+    result.z = v.w;
>+    result.w = v.y;
>+    return result;
>+}
>+
>+/* Functions named operator.yxwz */
>+bool4 operator.yxwz(bool4 v) {
>+    bool4 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.w;
>+    result.w = v.z;
>+    return result;
>+}
>+uchar4 operator.yxwz(uchar4 v) {
>+    uchar4 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.w;
>+    result.w = v.z;
>+    return result;
>+}
>+ushort4 operator.yxwz(ushort4 v) {
>+    ushort4 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.w;
>+    result.w = v.z;
>+    return result;
>+}
>+uint4 operator.yxwz(uint4 v) {
>+    uint4 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.w;
>+    result.w = v.z;
>+    return result;
>+}
>+char4 operator.yxwz(char4 v) {
>+    char4 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.w;
>+    result.w = v.z;
>+    return result;
>+}
>+short4 operator.yxwz(short4 v) {
>+    short4 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.w;
>+    result.w = v.z;
>+    return result;
>+}
>+int4 operator.yxwz(int4 v) {
>+    int4 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.w;
>+    result.w = v.z;
>+    return result;
>+}
>+half4 operator.yxwz(half4 v) {
>+    half4 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.w;
>+    result.w = v.z;
>+    return result;
>+}
>+float4 operator.yxwz(float4 v) {
>+    float4 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.w;
>+    result.w = v.z;
>+    return result;
>+}
>+
>+/* Functions named operator.ywww */
>+bool4 operator.ywww(bool4 v) {
>+    bool4 result;
>+    result.x = v.y;
>+    result.y = v.w;
>+    result.z = v.w;
>+    result.w = v.w;
>+    return result;
>+}
>+uchar4 operator.ywww(uchar4 v) {
>+    uchar4 result;
>+    result.x = v.y;
>+    result.y = v.w;
>+    result.z = v.w;
>+    result.w = v.w;
>+    return result;
>+}
>+ushort4 operator.ywww(ushort4 v) {
>+    ushort4 result;
>+    result.x = v.y;
>+    result.y = v.w;
>+    result.z = v.w;
>+    result.w = v.w;
>+    return result;
>+}
>+uint4 operator.ywww(uint4 v) {
>+    uint4 result;
>+    result.x = v.y;
>+    result.y = v.w;
>+    result.z = v.w;
>+    result.w = v.w;
>+    return result;
>+}
>+char4 operator.ywww(char4 v) {
>+    char4 result;
>+    result.x = v.y;
>+    result.y = v.w;
>+    result.z = v.w;
>+    result.w = v.w;
>+    return result;
>+}
>+short4 operator.ywww(short4 v) {
>+    short4 result;
>+    result.x = v.y;
>+    result.y = v.w;
>+    result.z = v.w;
>+    result.w = v.w;
>+    return result;
>+}
>+int4 operator.ywww(int4 v) {
>+    int4 result;
>+    result.x = v.y;
>+    result.y = v.w;
>+    result.z = v.w;
>+    result.w = v.w;
>+    return result;
>+}
>+half4 operator.ywww(half4 v) {
>+    half4 result;
>+    result.x = v.y;
>+    result.y = v.w;
>+    result.z = v.w;
>+    result.w = v.w;
>+    return result;
>+}
>+float4 operator.ywww(float4 v) {
>+    float4 result;
>+    result.x = v.y;
>+    result.y = v.w;
>+    result.z = v.w;
>+    result.w = v.w;
>+    return result;
>+}
>+
>+/* Functions named operator.xzw */
>+bool3 operator.xzw(bool4 v) {
>+    bool3 result;
>+    result.x = v.x;
>+    result.y = v.z;
>+    result.z = v.w;
>+    return result;
>+}
>+uchar3 operator.xzw(uchar4 v) {
>+    uchar3 result;
>+    result.x = v.x;
>+    result.y = v.z;
>+    result.z = v.w;
>+    return result;
>+}
>+ushort3 operator.xzw(ushort4 v) {
>+    ushort3 result;
>+    result.x = v.x;
>+    result.y = v.z;
>+    result.z = v.w;
>+    return result;
>+}
>+uint3 operator.xzw(uint4 v) {
>+    uint3 result;
>+    result.x = v.x;
>+    result.y = v.z;
>+    result.z = v.w;
>+    return result;
>+}
>+char3 operator.xzw(char4 v) {
>+    char3 result;
>+    result.x = v.x;
>+    result.y = v.z;
>+    result.z = v.w;
>+    return result;
>+}
>+short3 operator.xzw(short4 v) {
>+    short3 result;
>+    result.x = v.x;
>+    result.y = v.z;
>+    result.z = v.w;
>+    return result;
>+}
>+int3 operator.xzw(int4 v) {
>+    int3 result;
>+    result.x = v.x;
>+    result.y = v.z;
>+    result.z = v.w;
>+    return result;
>+}
>+half3 operator.xzw(half4 v) {
>+    half3 result;
>+    result.x = v.x;
>+    result.y = v.z;
>+    result.z = v.w;
>+    return result;
>+}
>+float3 operator.xzw(float4 v) {
>+    float3 result;
>+    result.x = v.x;
>+    result.y = v.z;
>+    result.z = v.w;
>+    return result;
>+}
>+
>+/* Functions named operator.wwwx */
>+bool4 operator.wwwx(bool4 v) {
>+    bool4 result;
>+    result.x = v.w;
>+    result.y = v.w;
>+    result.z = v.w;
>+    result.w = v.x;
>+    return result;
>+}
>+uchar4 operator.wwwx(uchar4 v) {
>+    uchar4 result;
>+    result.x = v.w;
>+    result.y = v.w;
>+    result.z = v.w;
>+    result.w = v.x;
>+    return result;
>+}
>+ushort4 operator.wwwx(ushort4 v) {
>+    ushort4 result;
>+    result.x = v.w;
>+    result.y = v.w;
>+    result.z = v.w;
>+    result.w = v.x;
>+    return result;
>+}
>+uint4 operator.wwwx(uint4 v) {
>+    uint4 result;
>+    result.x = v.w;
>+    result.y = v.w;
>+    result.z = v.w;
>+    result.w = v.x;
>+    return result;
>+}
>+char4 operator.wwwx(char4 v) {
>+    char4 result;
>+    result.x = v.w;
>+    result.y = v.w;
>+    result.z = v.w;
>+    result.w = v.x;
>+    return result;
>+}
>+short4 operator.wwwx(short4 v) {
>+    short4 result;
>+    result.x = v.w;
>+    result.y = v.w;
>+    result.z = v.w;
>+    result.w = v.x;
>+    return result;
>+}
>+int4 operator.wwwx(int4 v) {
>+    int4 result;
>+    result.x = v.w;
>+    result.y = v.w;
>+    result.z = v.w;
>+    result.w = v.x;
>+    return result;
>+}
>+half4 operator.wwwx(half4 v) {
>+    half4 result;
>+    result.x = v.w;
>+    result.y = v.w;
>+    result.z = v.w;
>+    result.w = v.x;
>+    return result;
>+}
>+float4 operator.wwwx(float4 v) {
>+    float4 result;
>+    result.x = v.w;
>+    result.y = v.w;
>+    result.z = v.w;
>+    result.w = v.x;
>+    return result;
>+}
>+
>+/* Functions named operator.wwxx */
>+bool4 operator.wwxx(bool4 v) {
>+    bool4 result;
>+    result.x = v.w;
>+    result.y = v.w;
>+    result.z = v.x;
>+    result.w = v.x;
>+    return result;
>+}
>+uchar4 operator.wwxx(uchar4 v) {
>+    uchar4 result;
>+    result.x = v.w;
>+    result.y = v.w;
>+    result.z = v.x;
>+    result.w = v.x;
>+    return result;
>+}
>+ushort4 operator.wwxx(ushort4 v) {
>+    ushort4 result;
>+    result.x = v.w;
>+    result.y = v.w;
>+    result.z = v.x;
>+    result.w = v.x;
>+    return result;
>+}
>+uint4 operator.wwxx(uint4 v) {
>+    uint4 result;
>+    result.x = v.w;
>+    result.y = v.w;
>+    result.z = v.x;
>+    result.w = v.x;
>+    return result;
>+}
>+char4 operator.wwxx(char4 v) {
>+    char4 result;
>+    result.x = v.w;
>+    result.y = v.w;
>+    result.z = v.x;
>+    result.w = v.x;
>+    return result;
>+}
>+short4 operator.wwxx(short4 v) {
>+    short4 result;
>+    result.x = v.w;
>+    result.y = v.w;
>+    result.z = v.x;
>+    result.w = v.x;
>+    return result;
>+}
>+int4 operator.wwxx(int4 v) {
>+    int4 result;
>+    result.x = v.w;
>+    result.y = v.w;
>+    result.z = v.x;
>+    result.w = v.x;
>+    return result;
>+}
>+half4 operator.wwxx(half4 v) {
>+    half4 result;
>+    result.x = v.w;
>+    result.y = v.w;
>+    result.z = v.x;
>+    result.w = v.x;
>+    return result;
>+}
>+float4 operator.wwxx(float4 v) {
>+    float4 result;
>+    result.x = v.w;
>+    result.y = v.w;
>+    result.z = v.x;
>+    result.w = v.x;
>+    return result;
>+}
>+
>+/* Functions named operator.xyw= */
>+bool4 operator.xyw=(bool4 v, bool3 c) {
>+    bool4 result = v;
>+    result.x = c.x;
>+    result.y = c.y;
>+    result.w = c.z;
>+    return result;
>+}
>+uchar4 operator.xyw=(uchar4 v, uchar3 c) {
>+    uchar4 result = v;
>+    result.x = c.x;
>+    result.y = c.y;
>+    result.w = c.z;
>+    return result;
>+}
>+ushort4 operator.xyw=(ushort4 v, ushort3 c) {
>+    ushort4 result = v;
>+    result.x = c.x;
>+    result.y = c.y;
>+    result.w = c.z;
>+    return result;
>+}
>+uint4 operator.xyw=(uint4 v, uint3 c) {
>+    uint4 result = v;
>+    result.x = c.x;
>+    result.y = c.y;
>+    result.w = c.z;
>+    return result;
>+}
>+char4 operator.xyw=(char4 v, char3 c) {
>+    char4 result = v;
>+    result.x = c.x;
>+    result.y = c.y;
>+    result.w = c.z;
>+    return result;
>+}
>+short4 operator.xyw=(short4 v, short3 c) {
>+    short4 result = v;
>+    result.x = c.x;
>+    result.y = c.y;
>+    result.w = c.z;
>+    return result;
>+}
>+int4 operator.xyw=(int4 v, int3 c) {
>+    int4 result = v;
>+    result.x = c.x;
>+    result.y = c.y;
>+    result.w = c.z;
>+    return result;
>+}
>+half4 operator.xyw=(half4 v, half3 c) {
>+    half4 result = v;
>+    result.x = c.x;
>+    result.y = c.y;
>+    result.w = c.z;
>+    return result;
>+}
>+float4 operator.xyw=(float4 v, float3 c) {
>+    float4 result = v;
>+    result.x = c.x;
>+    result.y = c.y;
>+    result.w = c.z;
>+    return result;
>+}
>+
>+/* Functions named operator.xzy */
>+bool3 operator.xzy(bool3 v) {
>+    bool3 result;
>+    result.x = v.x;
>+    result.y = v.z;
>+    result.z = v.y;
>+    return result;
>+}
>+bool3 operator.xzy(bool4 v) {
>+    bool3 result;
>+    result.x = v.x;
>+    result.y = v.z;
>+    result.z = v.y;
>+    return result;
>+}
>+uchar3 operator.xzy(uchar3 v) {
>+    uchar3 result;
>+    result.x = v.x;
>+    result.y = v.z;
>+    result.z = v.y;
>+    return result;
>+}
>+uchar3 operator.xzy(uchar4 v) {
>+    uchar3 result;
>+    result.x = v.x;
>+    result.y = v.z;
>+    result.z = v.y;
>+    return result;
>+}
>+ushort3 operator.xzy(ushort3 v) {
>+    ushort3 result;
>+    result.x = v.x;
>+    result.y = v.z;
>+    result.z = v.y;
>+    return result;
>+}
>+ushort3 operator.xzy(ushort4 v) {
>+    ushort3 result;
>+    result.x = v.x;
>+    result.y = v.z;
>+    result.z = v.y;
>+    return result;
>+}
>+uint3 operator.xzy(uint3 v) {
>+    uint3 result;
>+    result.x = v.x;
>+    result.y = v.z;
>+    result.z = v.y;
>+    return result;
>+}
>+uint3 operator.xzy(uint4 v) {
>+    uint3 result;
>+    result.x = v.x;
>+    result.y = v.z;
>+    result.z = v.y;
>+    return result;
>+}
>+char3 operator.xzy(char3 v) {
>+    char3 result;
>+    result.x = v.x;
>+    result.y = v.z;
>+    result.z = v.y;
>+    return result;
>+}
>+char3 operator.xzy(char4 v) {
>+    char3 result;
>+    result.x = v.x;
>+    result.y = v.z;
>+    result.z = v.y;
>+    return result;
>+}
>+short3 operator.xzy(short3 v) {
>+    short3 result;
>+    result.x = v.x;
>+    result.y = v.z;
>+    result.z = v.y;
>+    return result;
>+}
>+short3 operator.xzy(short4 v) {
>+    short3 result;
>+    result.x = v.x;
>+    result.y = v.z;
>+    result.z = v.y;
>+    return result;
>+}
>+int3 operator.xzy(int3 v) {
>+    int3 result;
>+    result.x = v.x;
>+    result.y = v.z;
>+    result.z = v.y;
>+    return result;
>+}
>+int3 operator.xzy(int4 v) {
>+    int3 result;
>+    result.x = v.x;
>+    result.y = v.z;
>+    result.z = v.y;
>+    return result;
>+}
>+half3 operator.xzy(half3 v) {
>+    half3 result;
>+    result.x = v.x;
>+    result.y = v.z;
>+    result.z = v.y;
>+    return result;
>+}
>+half3 operator.xzy(half4 v) {
>+    half3 result;
>+    result.x = v.x;
>+    result.y = v.z;
>+    result.z = v.y;
>+    return result;
>+}
>+float3 operator.xzy(float3 v) {
>+    float3 result;
>+    result.x = v.x;
>+    result.y = v.z;
>+    result.z = v.y;
>+    return result;
>+}
>+float3 operator.xzy(float4 v) {
>+    float3 result;
>+    result.x = v.x;
>+    result.y = v.z;
>+    result.z = v.y;
>+    return result;
>+}
>+
>+/* Functions named operator.zzzz */
>+bool4 operator.zzzz(bool3 v) {
>+    bool4 result;
>+    result.x = v.z;
>+    result.y = v.z;
>+    result.z = v.z;
>+    result.w = v.z;
>+    return result;
>+}
>+bool4 operator.zzzz(bool4 v) {
>+    bool4 result;
>+    result.x = v.z;
>+    result.y = v.z;
>+    result.z = v.z;
>+    result.w = v.z;
>+    return result;
>+}
>+uchar4 operator.zzzz(uchar3 v) {
>+    uchar4 result;
>+    result.x = v.z;
>+    result.y = v.z;
>+    result.z = v.z;
>+    result.w = v.z;
>+    return result;
>+}
>+uchar4 operator.zzzz(uchar4 v) {
>+    uchar4 result;
>+    result.x = v.z;
>+    result.y = v.z;
>+    result.z = v.z;
>+    result.w = v.z;
>+    return result;
>+}
>+ushort4 operator.zzzz(ushort3 v) {
>+    ushort4 result;
>+    result.x = v.z;
>+    result.y = v.z;
>+    result.z = v.z;
>+    result.w = v.z;
>+    return result;
>+}
>+ushort4 operator.zzzz(ushort4 v) {
>+    ushort4 result;
>+    result.x = v.z;
>+    result.y = v.z;
>+    result.z = v.z;
>+    result.w = v.z;
>+    return result;
>+}
>+uint4 operator.zzzz(uint3 v) {
>+    uint4 result;
>+    result.x = v.z;
>+    result.y = v.z;
>+    result.z = v.z;
>+    result.w = v.z;
>+    return result;
>+}
>+uint4 operator.zzzz(uint4 v) {
>+    uint4 result;
>+    result.x = v.z;
>+    result.y = v.z;
>+    result.z = v.z;
>+    result.w = v.z;
>+    return result;
>+}
>+char4 operator.zzzz(char3 v) {
>+    char4 result;
>+    result.x = v.z;
>+    result.y = v.z;
>+    result.z = v.z;
>+    result.w = v.z;
>+    return result;
>+}
>+char4 operator.zzzz(char4 v) {
>+    char4 result;
>+    result.x = v.z;
>+    result.y = v.z;
>+    result.z = v.z;
>+    result.w = v.z;
>+    return result;
>+}
>+short4 operator.zzzz(short3 v) {
>+    short4 result;
>+    result.x = v.z;
>+    result.y = v.z;
>+    result.z = v.z;
>+    result.w = v.z;
>+    return result;
>+}
>+short4 operator.zzzz(short4 v) {
>+    short4 result;
>+    result.x = v.z;
>+    result.y = v.z;
>+    result.z = v.z;
>+    result.w = v.z;
>+    return result;
>+}
>+int4 operator.zzzz(int3 v) {
>+    int4 result;
>+    result.x = v.z;
>+    result.y = v.z;
>+    result.z = v.z;
>+    result.w = v.z;
>+    return result;
>+}
>+int4 operator.zzzz(int4 v) {
>+    int4 result;
>+    result.x = v.z;
>+    result.y = v.z;
>+    result.z = v.z;
>+    result.w = v.z;
>+    return result;
>+}
>+half4 operator.zzzz(half3 v) {
>+    half4 result;
>+    result.x = v.z;
>+    result.y = v.z;
>+    result.z = v.z;
>+    result.w = v.z;
>+    return result;
>+}
>+half4 operator.zzzz(half4 v) {
>+    half4 result;
>+    result.x = v.z;
>+    result.y = v.z;
>+    result.z = v.z;
>+    result.w = v.z;
>+    return result;
>+}
>+float4 operator.zzzz(float3 v) {
>+    float4 result;
>+    result.x = v.z;
>+    result.y = v.z;
>+    result.z = v.z;
>+    result.w = v.z;
>+    return result;
>+}
>+float4 operator.zzzz(float4 v) {
>+    float4 result;
>+    result.x = v.z;
>+    result.y = v.z;
>+    result.z = v.z;
>+    result.w = v.z;
>+    return result;
>+}
>+
>+/* Functions named operator.zzzx */
>+bool4 operator.zzzx(bool3 v) {
>+    bool4 result;
>+    result.x = v.z;
>+    result.y = v.z;
>+    result.z = v.z;
>+    result.w = v.x;
>+    return result;
>+}
>+bool4 operator.zzzx(bool4 v) {
>+    bool4 result;
>+    result.x = v.z;
>+    result.y = v.z;
>+    result.z = v.z;
>+    result.w = v.x;
>+    return result;
>+}
>+uchar4 operator.zzzx(uchar3 v) {
>+    uchar4 result;
>+    result.x = v.z;
>+    result.y = v.z;
>+    result.z = v.z;
>+    result.w = v.x;
>+    return result;
>+}
>+uchar4 operator.zzzx(uchar4 v) {
>+    uchar4 result;
>+    result.x = v.z;
>+    result.y = v.z;
>+    result.z = v.z;
>+    result.w = v.x;
>+    return result;
>+}
>+ushort4 operator.zzzx(ushort3 v) {
>+    ushort4 result;
>+    result.x = v.z;
>+    result.y = v.z;
>+    result.z = v.z;
>+    result.w = v.x;
>+    return result;
>+}
>+ushort4 operator.zzzx(ushort4 v) {
>+    ushort4 result;
>+    result.x = v.z;
>+    result.y = v.z;
>+    result.z = v.z;
>+    result.w = v.x;
>+    return result;
>+}
>+uint4 operator.zzzx(uint3 v) {
>+    uint4 result;
>+    result.x = v.z;
>+    result.y = v.z;
>+    result.z = v.z;
>+    result.w = v.x;
>+    return result;
>+}
>+uint4 operator.zzzx(uint4 v) {
>+    uint4 result;
>+    result.x = v.z;
>+    result.y = v.z;
>+    result.z = v.z;
>+    result.w = v.x;
>+    return result;
>+}
>+char4 operator.zzzx(char3 v) {
>+    char4 result;
>+    result.x = v.z;
>+    result.y = v.z;
>+    result.z = v.z;
>+    result.w = v.x;
>+    return result;
>+}
>+char4 operator.zzzx(char4 v) {
>+    char4 result;
>+    result.x = v.z;
>+    result.y = v.z;
>+    result.z = v.z;
>+    result.w = v.x;
>+    return result;
>+}
>+short4 operator.zzzx(short3 v) {
>+    short4 result;
>+    result.x = v.z;
>+    result.y = v.z;
>+    result.z = v.z;
>+    result.w = v.x;
>+    return result;
>+}
>+short4 operator.zzzx(short4 v) {
>+    short4 result;
>+    result.x = v.z;
>+    result.y = v.z;
>+    result.z = v.z;
>+    result.w = v.x;
>+    return result;
>+}
>+int4 operator.zzzx(int3 v) {
>+    int4 result;
>+    result.x = v.z;
>+    result.y = v.z;
>+    result.z = v.z;
>+    result.w = v.x;
>+    return result;
>+}
>+int4 operator.zzzx(int4 v) {
>+    int4 result;
>+    result.x = v.z;
>+    result.y = v.z;
>+    result.z = v.z;
>+    result.w = v.x;
>+    return result;
>+}
>+half4 operator.zzzx(half3 v) {
>+    half4 result;
>+    result.x = v.z;
>+    result.y = v.z;
>+    result.z = v.z;
>+    result.w = v.x;
>+    return result;
>+}
>+half4 operator.zzzx(half4 v) {
>+    half4 result;
>+    result.x = v.z;
>+    result.y = v.z;
>+    result.z = v.z;
>+    result.w = v.x;
>+    return result;
>+}
>+float4 operator.zzzx(float3 v) {
>+    float4 result;
>+    result.x = v.z;
>+    result.y = v.z;
>+    result.z = v.z;
>+    result.w = v.x;
>+    return result;
>+}
>+float4 operator.zzzx(float4 v) {
>+    float4 result;
>+    result.x = v.z;
>+    result.y = v.z;
>+    result.z = v.z;
>+    result.w = v.x;
>+    return result;
>+}
>+
>+/* Functions named operator.xw */
>+bool2 operator.xw(bool4 v) {
>+    bool2 result;
>+    result.x = v.x;
>+    result.y = v.w;
>+    return result;
>+}
>+uchar2 operator.xw(uchar4 v) {
>+    uchar2 result;
>+    result.x = v.x;
>+    result.y = v.w;
>+    return result;
>+}
>+ushort2 operator.xw(ushort4 v) {
>+    ushort2 result;
>+    result.x = v.x;
>+    result.y = v.w;
>+    return result;
>+}
>+uint2 operator.xw(uint4 v) {
>+    uint2 result;
>+    result.x = v.x;
>+    result.y = v.w;
>+    return result;
>+}
>+char2 operator.xw(char4 v) {
>+    char2 result;
>+    result.x = v.x;
>+    result.y = v.w;
>+    return result;
>+}
>+short2 operator.xw(short4 v) {
>+    short2 result;
>+    result.x = v.x;
>+    result.y = v.w;
>+    return result;
>+}
>+int2 operator.xw(int4 v) {
>+    int2 result;
>+    result.x = v.x;
>+    result.y = v.w;
>+    return result;
>+}
>+half2 operator.xw(half4 v) {
>+    half2 result;
>+    result.x = v.x;
>+    result.y = v.w;
>+    return result;
>+}
>+float2 operator.xw(float4 v) {
>+    float2 result;
>+    result.x = v.x;
>+    result.y = v.w;
>+    return result;
>+}
>+
>+/* Functions named operator.wxyw */
>+bool4 operator.wxyw(bool4 v) {
>+    bool4 result;
>+    result.x = v.w;
>+    result.y = v.x;
>+    result.z = v.y;
>+    result.w = v.w;
>+    return result;
>+}
>+uchar4 operator.wxyw(uchar4 v) {
>+    uchar4 result;
>+    result.x = v.w;
>+    result.y = v.x;
>+    result.z = v.y;
>+    result.w = v.w;
>+    return result;
>+}
>+ushort4 operator.wxyw(ushort4 v) {
>+    ushort4 result;
>+    result.x = v.w;
>+    result.y = v.x;
>+    result.z = v.y;
>+    result.w = v.w;
>+    return result;
>+}
>+uint4 operator.wxyw(uint4 v) {
>+    uint4 result;
>+    result.x = v.w;
>+    result.y = v.x;
>+    result.z = v.y;
>+    result.w = v.w;
>+    return result;
>+}
>+char4 operator.wxyw(char4 v) {
>+    char4 result;
>+    result.x = v.w;
>+    result.y = v.x;
>+    result.z = v.y;
>+    result.w = v.w;
>+    return result;
>+}
>+short4 operator.wxyw(short4 v) {
>+    short4 result;
>+    result.x = v.w;
>+    result.y = v.x;
>+    result.z = v.y;
>+    result.w = v.w;
>+    return result;
>+}
>+int4 operator.wxyw(int4 v) {
>+    int4 result;
>+    result.x = v.w;
>+    result.y = v.x;
>+    result.z = v.y;
>+    result.w = v.w;
>+    return result;
>+}
>+half4 operator.wxyw(half4 v) {
>+    half4 result;
>+    result.x = v.w;
>+    result.y = v.x;
>+    result.z = v.y;
>+    result.w = v.w;
>+    return result;
>+}
>+float4 operator.wxyw(float4 v) {
>+    float4 result;
>+    result.x = v.w;
>+    result.y = v.x;
>+    result.z = v.y;
>+    result.w = v.w;
>+    return result;
>+}
>+
>+/* Functions named operator.yzww */
>+bool4 operator.yzww(bool4 v) {
>+    bool4 result;
>+    result.x = v.y;
>+    result.y = v.z;
>+    result.z = v.w;
>+    result.w = v.w;
>+    return result;
>+}
>+uchar4 operator.yzww(uchar4 v) {
>+    uchar4 result;
>+    result.x = v.y;
>+    result.y = v.z;
>+    result.z = v.w;
>+    result.w = v.w;
>+    return result;
>+}
>+ushort4 operator.yzww(ushort4 v) {
>+    ushort4 result;
>+    result.x = v.y;
>+    result.y = v.z;
>+    result.z = v.w;
>+    result.w = v.w;
>+    return result;
>+}
>+uint4 operator.yzww(uint4 v) {
>+    uint4 result;
>+    result.x = v.y;
>+    result.y = v.z;
>+    result.z = v.w;
>+    result.w = v.w;
>+    return result;
>+}
>+char4 operator.yzww(char4 v) {
>+    char4 result;
>+    result.x = v.y;
>+    result.y = v.z;
>+    result.z = v.w;
>+    result.w = v.w;
>+    return result;
>+}
>+short4 operator.yzww(short4 v) {
>+    short4 result;
>+    result.x = v.y;
>+    result.y = v.z;
>+    result.z = v.w;
>+    result.w = v.w;
>+    return result;
>+}
>+int4 operator.yzww(int4 v) {
>+    int4 result;
>+    result.x = v.y;
>+    result.y = v.z;
>+    result.z = v.w;
>+    result.w = v.w;
>+    return result;
>+}
>+half4 operator.yzww(half4 v) {
>+    half4 result;
>+    result.x = v.y;
>+    result.y = v.z;
>+    result.z = v.w;
>+    result.w = v.w;
>+    return result;
>+}
>+float4 operator.yzww(float4 v) {
>+    float4 result;
>+    result.x = v.y;
>+    result.y = v.z;
>+    result.z = v.w;
>+    result.w = v.w;
>+    return result;
>+}
>+
>+/* Functions named operator.wxw */
>+bool3 operator.wxw(bool4 v) {
>+    bool3 result;
>+    result.x = v.w;
>+    result.y = v.x;
>+    result.z = v.w;
>+    return result;
>+}
>+uchar3 operator.wxw(uchar4 v) {
>+    uchar3 result;
>+    result.x = v.w;
>+    result.y = v.x;
>+    result.z = v.w;
>+    return result;
>+}
>+ushort3 operator.wxw(ushort4 v) {
>+    ushort3 result;
>+    result.x = v.w;
>+    result.y = v.x;
>+    result.z = v.w;
>+    return result;
>+}
>+uint3 operator.wxw(uint4 v) {
>+    uint3 result;
>+    result.x = v.w;
>+    result.y = v.x;
>+    result.z = v.w;
>+    return result;
>+}
>+char3 operator.wxw(char4 v) {
>+    char3 result;
>+    result.x = v.w;
>+    result.y = v.x;
>+    result.z = v.w;
>+    return result;
>+}
>+short3 operator.wxw(short4 v) {
>+    short3 result;
>+    result.x = v.w;
>+    result.y = v.x;
>+    result.z = v.w;
>+    return result;
>+}
>+int3 operator.wxw(int4 v) {
>+    int3 result;
>+    result.x = v.w;
>+    result.y = v.x;
>+    result.z = v.w;
>+    return result;
>+}
>+half3 operator.wxw(half4 v) {
>+    half3 result;
>+    result.x = v.w;
>+    result.y = v.x;
>+    result.z = v.w;
>+    return result;
>+}
>+float3 operator.wxw(float4 v) {
>+    float3 result;
>+    result.x = v.w;
>+    result.y = v.x;
>+    result.z = v.w;
>+    return result;
>+}
>+
>+/* Functions named operator.xwwy */
>+bool4 operator.xwwy(bool4 v) {
>+    bool4 result;
>+    result.x = v.x;
>+    result.y = v.w;
>+    result.z = v.w;
>+    result.w = v.y;
>+    return result;
>+}
>+uchar4 operator.xwwy(uchar4 v) {
>+    uchar4 result;
>+    result.x = v.x;
>+    result.y = v.w;
>+    result.z = v.w;
>+    result.w = v.y;
>+    return result;
>+}
>+ushort4 operator.xwwy(ushort4 v) {
>+    ushort4 result;
>+    result.x = v.x;
>+    result.y = v.w;
>+    result.z = v.w;
>+    result.w = v.y;
>+    return result;
>+}
>+uint4 operator.xwwy(uint4 v) {
>+    uint4 result;
>+    result.x = v.x;
>+    result.y = v.w;
>+    result.z = v.w;
>+    result.w = v.y;
>+    return result;
>+}
>+char4 operator.xwwy(char4 v) {
>+    char4 result;
>+    result.x = v.x;
>+    result.y = v.w;
>+    result.z = v.w;
>+    result.w = v.y;
>+    return result;
>+}
>+short4 operator.xwwy(short4 v) {
>+    short4 result;
>+    result.x = v.x;
>+    result.y = v.w;
>+    result.z = v.w;
>+    result.w = v.y;
>+    return result;
>+}
>+int4 operator.xwwy(int4 v) {
>+    int4 result;
>+    result.x = v.x;
>+    result.y = v.w;
>+    result.z = v.w;
>+    result.w = v.y;
>+    return result;
>+}
>+half4 operator.xwwy(half4 v) {
>+    half4 result;
>+    result.x = v.x;
>+    result.y = v.w;
>+    result.z = v.w;
>+    result.w = v.y;
>+    return result;
>+}
>+float4 operator.xwwy(float4 v) {
>+    float4 result;
>+    result.x = v.x;
>+    result.y = v.w;
>+    result.z = v.w;
>+    result.w = v.y;
>+    return result;
>+}
>+
>+/* Functions named operator.wzzw */
>+bool4 operator.wzzw(bool4 v) {
>+    bool4 result;
>+    result.x = v.w;
>+    result.y = v.z;
>+    result.z = v.z;
>+    result.w = v.w;
>+    return result;
>+}
>+uchar4 operator.wzzw(uchar4 v) {
>+    uchar4 result;
>+    result.x = v.w;
>+    result.y = v.z;
>+    result.z = v.z;
>+    result.w = v.w;
>+    return result;
>+}
>+ushort4 operator.wzzw(ushort4 v) {
>+    ushort4 result;
>+    result.x = v.w;
>+    result.y = v.z;
>+    result.z = v.z;
>+    result.w = v.w;
>+    return result;
>+}
>+uint4 operator.wzzw(uint4 v) {
>+    uint4 result;
>+    result.x = v.w;
>+    result.y = v.z;
>+    result.z = v.z;
>+    result.w = v.w;
>+    return result;
>+}
>+char4 operator.wzzw(char4 v) {
>+    char4 result;
>+    result.x = v.w;
>+    result.y = v.z;
>+    result.z = v.z;
>+    result.w = v.w;
>+    return result;
>+}
>+short4 operator.wzzw(short4 v) {
>+    short4 result;
>+    result.x = v.w;
>+    result.y = v.z;
>+    result.z = v.z;
>+    result.w = v.w;
>+    return result;
>+}
>+int4 operator.wzzw(int4 v) {
>+    int4 result;
>+    result.x = v.w;
>+    result.y = v.z;
>+    result.z = v.z;
>+    result.w = v.w;
>+    return result;
>+}
>+half4 operator.wzzw(half4 v) {
>+    half4 result;
>+    result.x = v.w;
>+    result.y = v.z;
>+    result.z = v.z;
>+    result.w = v.w;
>+    return result;
>+}
>+float4 operator.wzzw(float4 v) {
>+    float4 result;
>+    result.x = v.w;
>+    result.y = v.z;
>+    result.z = v.z;
>+    result.w = v.w;
>+    return result;
>+}
>+
>+/* Functions named operator.wxww */
>+bool4 operator.wxww(bool4 v) {
>+    bool4 result;
>+    result.x = v.w;
>+    result.y = v.x;
>+    result.z = v.w;
>+    result.w = v.w;
>+    return result;
>+}
>+uchar4 operator.wxww(uchar4 v) {
>+    uchar4 result;
>+    result.x = v.w;
>+    result.y = v.x;
>+    result.z = v.w;
>+    result.w = v.w;
>+    return result;
>+}
>+ushort4 operator.wxww(ushort4 v) {
>+    ushort4 result;
>+    result.x = v.w;
>+    result.y = v.x;
>+    result.z = v.w;
>+    result.w = v.w;
>+    return result;
>+}
>+uint4 operator.wxww(uint4 v) {
>+    uint4 result;
>+    result.x = v.w;
>+    result.y = v.x;
>+    result.z = v.w;
>+    result.w = v.w;
>+    return result;
>+}
>+char4 operator.wxww(char4 v) {
>+    char4 result;
>+    result.x = v.w;
>+    result.y = v.x;
>+    result.z = v.w;
>+    result.w = v.w;
>+    return result;
>+}
>+short4 operator.wxww(short4 v) {
>+    short4 result;
>+    result.x = v.w;
>+    result.y = v.x;
>+    result.z = v.w;
>+    result.w = v.w;
>+    return result;
>+}
>+int4 operator.wxww(int4 v) {
>+    int4 result;
>+    result.x = v.w;
>+    result.y = v.x;
>+    result.z = v.w;
>+    result.w = v.w;
>+    return result;
>+}
>+half4 operator.wxww(half4 v) {
>+    half4 result;
>+    result.x = v.w;
>+    result.y = v.x;
>+    result.z = v.w;
>+    result.w = v.w;
>+    return result;
>+}
>+float4 operator.wxww(float4 v) {
>+    float4 result;
>+    result.x = v.w;
>+    result.y = v.x;
>+    result.z = v.w;
>+    result.w = v.w;
>+    return result;
>+}
>+
>+/* Functions named max */
>+uchar max(uchar x, uchar y) {
>+    return x > y ? x : y;
>+}
>+uchar2 max(uchar2 x, uchar2 y) {
>+    uchar2 result;
>+    result[0] = max(x[0], y[0]);
>+    result[1] = max(x[1], y[1]);
>+    return result;
>+}
>+uchar3 max(uchar3 x, uchar3 y) {
>+    uchar3 result;
>+    result[0] = max(x[0], y[0]);
>+    result[1] = max(x[1], y[1]);
>+    result[2] = max(x[2], y[2]);
>+    return result;
>+}
>+uchar4 max(uchar4 x, uchar4 y) {
>+    uchar4 result;
>+    result[0] = max(x[0], y[0]);
>+    result[1] = max(x[1], y[1]);
>+    result[2] = max(x[2], y[2]);
>+    result[3] = max(x[3], y[3]);
>+    return result;
>+}
>+
>+ushort max(ushort x, ushort y) {
>+    return x > y ? x : y;
>+}
>+ushort2 max(ushort2 x, ushort2 y) {
>+    ushort2 result;
>+    result[0] = max(x[0], y[0]);
>+    result[1] = max(x[1], y[1]);
>+    return result;
>+}
>+ushort3 max(ushort3 x, ushort3 y) {
>+    ushort3 result;
>+    result[0] = max(x[0], y[0]);
>+    result[1] = max(x[1], y[1]);
>+    result[2] = max(x[2], y[2]);
>+    return result;
>+}
>+ushort4 max(ushort4 x, ushort4 y) {
>+    ushort4 result;
>+    result[0] = max(x[0], y[0]);
>+    result[1] = max(x[1], y[1]);
>+    result[2] = max(x[2], y[2]);
>+    result[3] = max(x[3], y[3]);
>+    return result;
>+}
>+
>+uint max(uint x, uint y) {
>+    return x > y ? x : y;
>+}
>+uint2 max(uint2 x, uint2 y) {
>+    uint2 result;
>+    result[0] = max(x[0], y[0]);
>+    result[1] = max(x[1], y[1]);
>+    return result;
>+}
>+uint3 max(uint3 x, uint3 y) {
>+    uint3 result;
>+    result[0] = max(x[0], y[0]);
>+    result[1] = max(x[1], y[1]);
>+    result[2] = max(x[2], y[2]);
>+    return result;
>+}
>+uint4 max(uint4 x, uint4 y) {
>+    uint4 result;
>+    result[0] = max(x[0], y[0]);
>+    result[1] = max(x[1], y[1]);
>+    result[2] = max(x[2], y[2]);
>+    result[3] = max(x[3], y[3]);
>+    return result;
>+}
>+
>+char max(char x, char y) {
>+    return x > y ? x : y;
>+}
>+char2 max(char2 x, char2 y) {
>+    char2 result;
>+    result[0] = max(x[0], y[0]);
>+    result[1] = max(x[1], y[1]);
>+    return result;
>+}
>+char3 max(char3 x, char3 y) {
>+    char3 result;
>+    result[0] = max(x[0], y[0]);
>+    result[1] = max(x[1], y[1]);
>+    result[2] = max(x[2], y[2]);
>+    return result;
>+}
>+char4 max(char4 x, char4 y) {
>+    char4 result;
>+    result[0] = max(x[0], y[0]);
>+    result[1] = max(x[1], y[1]);
>+    result[2] = max(x[2], y[2]);
>+    result[3] = max(x[3], y[3]);
>+    return result;
>+}
>+
>+short max(short x, short y) {
>+    return x > y ? x : y;
>+}
>+short2 max(short2 x, short2 y) {
>+    short2 result;
>+    result[0] = max(x[0], y[0]);
>+    result[1] = max(x[1], y[1]);
>+    return result;
>+}
>+short3 max(short3 x, short3 y) {
>+    short3 result;
>+    result[0] = max(x[0], y[0]);
>+    result[1] = max(x[1], y[1]);
>+    result[2] = max(x[2], y[2]);
>+    return result;
>+}
>+short4 max(short4 x, short4 y) {
>+    short4 result;
>+    result[0] = max(x[0], y[0]);
>+    result[1] = max(x[1], y[1]);
>+    result[2] = max(x[2], y[2]);
>+    result[3] = max(x[3], y[3]);
>+    return result;
>+}
>+
>+int max(int x, int y) {
>+    return x > y ? x : y;
>+}
>+int2 max(int2 x, int2 y) {
>+    int2 result;
>+    result[0] = max(x[0], y[0]);
>+    result[1] = max(x[1], y[1]);
>+    return result;
>+}
>+int3 max(int3 x, int3 y) {
>+    int3 result;
>+    result[0] = max(x[0], y[0]);
>+    result[1] = max(x[1], y[1]);
>+    result[2] = max(x[2], y[2]);
>+    return result;
>+}
>+int4 max(int4 x, int4 y) {
>+    int4 result;
>+    result[0] = max(x[0], y[0]);
>+    result[1] = max(x[1], y[1]);
>+    result[2] = max(x[2], y[2]);
>+    result[3] = max(x[3], y[3]);
>+    return result;
>+}
>+
>+half max(half x, half y) {
>+    return x > y ? x : y;
>+}
>+half2 max(half2 x, half2 y) {
>+    half2 result;
>+    result[0] = max(x[0], y[0]);
>+    result[1] = max(x[1], y[1]);
>+    return result;
>+}
>+half3 max(half3 x, half3 y) {
>+    half3 result;
>+    result[0] = max(x[0], y[0]);
>+    result[1] = max(x[1], y[1]);
>+    result[2] = max(x[2], y[2]);
>+    return result;
>+}
>+half4 max(half4 x, half4 y) {
>+    half4 result;
>+    result[0] = max(x[0], y[0]);
>+    result[1] = max(x[1], y[1]);
>+    result[2] = max(x[2], y[2]);
>+    result[3] = max(x[3], y[3]);
>+    return result;
>+}
>+half2x2 max(half2x2 x, half2x2 y) {
>+    half2x2 result;
>+    result[0][0] = max(x[0][0], y[0][0]);
>+    result[0][1] = max(x[0][1], y[0][1]);
>+    result[1][0] = max(x[1][0], y[1][0]);
>+    result[1][1] = max(x[1][1], y[1][1]);
>+    return result;
>+}
>+half2x3 max(half2x3 x, half2x3 y) {
>+    half2x3 result;
>+    result[0][0] = max(x[0][0], y[0][0]);
>+    result[0][1] = max(x[0][1], y[0][1]);
>+    result[0][2] = max(x[0][2], y[0][2]);
>+    result[1][0] = max(x[1][0], y[1][0]);
>+    result[1][1] = max(x[1][1], y[1][1]);
>+    result[1][2] = max(x[1][2], y[1][2]);
>+    return result;
>+}
>+half2x4 max(half2x4 x, half2x4 y) {
>+    half2x4 result;
>+    result[0][0] = max(x[0][0], y[0][0]);
>+    result[0][1] = max(x[0][1], y[0][1]);
>+    result[0][2] = max(x[0][2], y[0][2]);
>+    result[0][3] = max(x[0][3], y[0][3]);
>+    result[1][0] = max(x[1][0], y[1][0]);
>+    result[1][1] = max(x[1][1], y[1][1]);
>+    result[1][2] = max(x[1][2], y[1][2]);
>+    result[1][3] = max(x[1][3], y[1][3]);
>+    return result;
>+}
>+half3x2 max(half3x2 x, half3x2 y) {
>+    half3x2 result;
>+    result[0][0] = max(x[0][0], y[0][0]);
>+    result[0][1] = max(x[0][1], y[0][1]);
>+    result[1][0] = max(x[1][0], y[1][0]);
>+    result[1][1] = max(x[1][1], y[1][1]);
>+    result[2][0] = max(x[2][0], y[2][0]);
>+    result[2][1] = max(x[2][1], y[2][1]);
>+    return result;
>+}
>+half3x3 max(half3x3 x, half3x3 y) {
>+    half3x3 result;
>+    result[0][0] = max(x[0][0], y[0][0]);
>+    result[0][1] = max(x[0][1], y[0][1]);
>+    result[0][2] = max(x[0][2], y[0][2]);
>+    result[1][0] = max(x[1][0], y[1][0]);
>+    result[1][1] = max(x[1][1], y[1][1]);
>+    result[1][2] = max(x[1][2], y[1][2]);
>+    result[2][0] = max(x[2][0], y[2][0]);
>+    result[2][1] = max(x[2][1], y[2][1]);
>+    result[2][2] = max(x[2][2], y[2][2]);
>+    return result;
>+}
>+half3x4 max(half3x4 x, half3x4 y) {
>+    half3x4 result;
>+    result[0][0] = max(x[0][0], y[0][0]);
>+    result[0][1] = max(x[0][1], y[0][1]);
>+    result[0][2] = max(x[0][2], y[0][2]);
>+    result[0][3] = max(x[0][3], y[0][3]);
>+    result[1][0] = max(x[1][0], y[1][0]);
>+    result[1][1] = max(x[1][1], y[1][1]);
>+    result[1][2] = max(x[1][2], y[1][2]);
>+    result[1][3] = max(x[1][3], y[1][3]);
>+    result[2][0] = max(x[2][0], y[2][0]);
>+    result[2][1] = max(x[2][1], y[2][1]);
>+    result[2][2] = max(x[2][2], y[2][2]);
>+    result[2][3] = max(x[2][3], y[2][3]);
>+    return result;
>+}
>+half4x2 max(half4x2 x, half4x2 y) {
>+    half4x2 result;
>+    result[0][0] = max(x[0][0], y[0][0]);
>+    result[0][1] = max(x[0][1], y[0][1]);
>+    result[1][0] = max(x[1][0], y[1][0]);
>+    result[1][1] = max(x[1][1], y[1][1]);
>+    result[2][0] = max(x[2][0], y[2][0]);
>+    result[2][1] = max(x[2][1], y[2][1]);
>+    result[3][0] = max(x[3][0], y[3][0]);
>+    result[3][1] = max(x[3][1], y[3][1]);
>+    return result;
>+}
>+half4x3 max(half4x3 x, half4x3 y) {
>+    half4x3 result;
>+    result[0][0] = max(x[0][0], y[0][0]);
>+    result[0][1] = max(x[0][1], y[0][1]);
>+    result[0][2] = max(x[0][2], y[0][2]);
>+    result[1][0] = max(x[1][0], y[1][0]);
>+    result[1][1] = max(x[1][1], y[1][1]);
>+    result[1][2] = max(x[1][2], y[1][2]);
>+    result[2][0] = max(x[2][0], y[2][0]);
>+    result[2][1] = max(x[2][1], y[2][1]);
>+    result[2][2] = max(x[2][2], y[2][2]);
>+    result[3][0] = max(x[3][0], y[3][0]);
>+    result[3][1] = max(x[3][1], y[3][1]);
>+    result[3][2] = max(x[3][2], y[3][2]);
>+    return result;
>+}
>+half4x4 max(half4x4 x, half4x4 y) {
>+    half4x4 result;
>+    result[0][0] = max(x[0][0], y[0][0]);
>+    result[0][1] = max(x[0][1], y[0][1]);
>+    result[0][2] = max(x[0][2], y[0][2]);
>+    result[0][3] = max(x[0][3], y[0][3]);
>+    result[1][0] = max(x[1][0], y[1][0]);
>+    result[1][1] = max(x[1][1], y[1][1]);
>+    result[1][2] = max(x[1][2], y[1][2]);
>+    result[1][3] = max(x[1][3], y[1][3]);
>+    result[2][0] = max(x[2][0], y[2][0]);
>+    result[2][1] = max(x[2][1], y[2][1]);
>+    result[2][2] = max(x[2][2], y[2][2]);
>+    result[2][3] = max(x[2][3], y[2][3]);
>+    result[3][0] = max(x[3][0], y[3][0]);
>+    result[3][1] = max(x[3][1], y[3][1]);
>+    result[3][2] = max(x[3][2], y[3][2]);
>+    result[3][3] = max(x[3][3], y[3][3]);
>+    return result;
>+}
>+
>+float max(float x, float y) {
>+    return x > y ? x : y;
>+}
>+float2 max(float2 x, float2 y) {
>+    float2 result;
>+    result[0] = max(x[0], y[0]);
>+    result[1] = max(x[1], y[1]);
>+    return result;
>+}
>+float3 max(float3 x, float3 y) {
>+    float3 result;
>+    result[0] = max(x[0], y[0]);
>+    result[1] = max(x[1], y[1]);
>+    result[2] = max(x[2], y[2]);
>+    return result;
>+}
>+float4 max(float4 x, float4 y) {
>+    float4 result;
>+    result[0] = max(x[0], y[0]);
>+    result[1] = max(x[1], y[1]);
>+    result[2] = max(x[2], y[2]);
>+    result[3] = max(x[3], y[3]);
>+    return result;
>+}
>+float2x2 max(float2x2 x, float2x2 y) {
>+    float2x2 result;
>+    result[0][0] = max(x[0][0], y[0][0]);
>+    result[0][1] = max(x[0][1], y[0][1]);
>+    result[1][0] = max(x[1][0], y[1][0]);
>+    result[1][1] = max(x[1][1], y[1][1]);
>+    return result;
>+}
>+float2x3 max(float2x3 x, float2x3 y) {
>+    float2x3 result;
>+    result[0][0] = max(x[0][0], y[0][0]);
>+    result[0][1] = max(x[0][1], y[0][1]);
>+    result[0][2] = max(x[0][2], y[0][2]);
>+    result[1][0] = max(x[1][0], y[1][0]);
>+    result[1][1] = max(x[1][1], y[1][1]);
>+    result[1][2] = max(x[1][2], y[1][2]);
>+    return result;
>+}
>+float2x4 max(float2x4 x, float2x4 y) {
>+    float2x4 result;
>+    result[0][0] = max(x[0][0], y[0][0]);
>+    result[0][1] = max(x[0][1], y[0][1]);
>+    result[0][2] = max(x[0][2], y[0][2]);
>+    result[0][3] = max(x[0][3], y[0][3]);
>+    result[1][0] = max(x[1][0], y[1][0]);
>+    result[1][1] = max(x[1][1], y[1][1]);
>+    result[1][2] = max(x[1][2], y[1][2]);
>+    result[1][3] = max(x[1][3], y[1][3]);
>+    return result;
>+}
>+float3x2 max(float3x2 x, float3x2 y) {
>+    float3x2 result;
>+    result[0][0] = max(x[0][0], y[0][0]);
>+    result[0][1] = max(x[0][1], y[0][1]);
>+    result[1][0] = max(x[1][0], y[1][0]);
>+    result[1][1] = max(x[1][1], y[1][1]);
>+    result[2][0] = max(x[2][0], y[2][0]);
>+    result[2][1] = max(x[2][1], y[2][1]);
>+    return result;
>+}
>+float3x3 max(float3x3 x, float3x3 y) {
>+    float3x3 result;
>+    result[0][0] = max(x[0][0], y[0][0]);
>+    result[0][1] = max(x[0][1], y[0][1]);
>+    result[0][2] = max(x[0][2], y[0][2]);
>+    result[1][0] = max(x[1][0], y[1][0]);
>+    result[1][1] = max(x[1][1], y[1][1]);
>+    result[1][2] = max(x[1][2], y[1][2]);
>+    result[2][0] = max(x[2][0], y[2][0]);
>+    result[2][1] = max(x[2][1], y[2][1]);
>+    result[2][2] = max(x[2][2], y[2][2]);
>+    return result;
>+}
>+float3x4 max(float3x4 x, float3x4 y) {
>+    float3x4 result;
>+    result[0][0] = max(x[0][0], y[0][0]);
>+    result[0][1] = max(x[0][1], y[0][1]);
>+    result[0][2] = max(x[0][2], y[0][2]);
>+    result[0][3] = max(x[0][3], y[0][3]);
>+    result[1][0] = max(x[1][0], y[1][0]);
>+    result[1][1] = max(x[1][1], y[1][1]);
>+    result[1][2] = max(x[1][2], y[1][2]);
>+    result[1][3] = max(x[1][3], y[1][3]);
>+    result[2][0] = max(x[2][0], y[2][0]);
>+    result[2][1] = max(x[2][1], y[2][1]);
>+    result[2][2] = max(x[2][2], y[2][2]);
>+    result[2][3] = max(x[2][3], y[2][3]);
>+    return result;
>+}
>+float4x2 max(float4x2 x, float4x2 y) {
>+    float4x2 result;
>+    result[0][0] = max(x[0][0], y[0][0]);
>+    result[0][1] = max(x[0][1], y[0][1]);
>+    result[1][0] = max(x[1][0], y[1][0]);
>+    result[1][1] = max(x[1][1], y[1][1]);
>+    result[2][0] = max(x[2][0], y[2][0]);
>+    result[2][1] = max(x[2][1], y[2][1]);
>+    result[3][0] = max(x[3][0], y[3][0]);
>+    result[3][1] = max(x[3][1], y[3][1]);
>+    return result;
>+}
>+float4x3 max(float4x3 x, float4x3 y) {
>+    float4x3 result;
>+    result[0][0] = max(x[0][0], y[0][0]);
>+    result[0][1] = max(x[0][1], y[0][1]);
>+    result[0][2] = max(x[0][2], y[0][2]);
>+    result[1][0] = max(x[1][0], y[1][0]);
>+    result[1][1] = max(x[1][1], y[1][1]);
>+    result[1][2] = max(x[1][2], y[1][2]);
>+    result[2][0] = max(x[2][0], y[2][0]);
>+    result[2][1] = max(x[2][1], y[2][1]);
>+    result[2][2] = max(x[2][2], y[2][2]);
>+    result[3][0] = max(x[3][0], y[3][0]);
>+    result[3][1] = max(x[3][1], y[3][1]);
>+    result[3][2] = max(x[3][2], y[3][2]);
>+    return result;
>+}
>+float4x4 max(float4x4 x, float4x4 y) {
>+    float4x4 result;
>+    result[0][0] = max(x[0][0], y[0][0]);
>+    result[0][1] = max(x[0][1], y[0][1]);
>+    result[0][2] = max(x[0][2], y[0][2]);
>+    result[0][3] = max(x[0][3], y[0][3]);
>+    result[1][0] = max(x[1][0], y[1][0]);
>+    result[1][1] = max(x[1][1], y[1][1]);
>+    result[1][2] = max(x[1][2], y[1][2]);
>+    result[1][3] = max(x[1][3], y[1][3]);
>+    result[2][0] = max(x[2][0], y[2][0]);
>+    result[2][1] = max(x[2][1], y[2][1]);
>+    result[2][2] = max(x[2][2], y[2][2]);
>+    result[2][3] = max(x[2][3], y[2][3]);
>+    result[3][0] = max(x[3][0], y[3][0]);
>+    result[3][1] = max(x[3][1], y[3][1]);
>+    result[3][2] = max(x[3][2], y[3][2]);
>+    result[3][3] = max(x[3][3], y[3][3]);
>+    return result;
>+}
>+
>+
>+/* Functions named operator.wwz */
>+bool3 operator.wwz(bool4 v) {
>+    bool3 result;
>+    result.x = v.w;
>+    result.y = v.w;
>+    result.z = v.z;
>+    return result;
>+}
>+uchar3 operator.wwz(uchar4 v) {
>+    uchar3 result;
>+    result.x = v.w;
>+    result.y = v.w;
>+    result.z = v.z;
>+    return result;
>+}
>+ushort3 operator.wwz(ushort4 v) {
>+    ushort3 result;
>+    result.x = v.w;
>+    result.y = v.w;
>+    result.z = v.z;
>+    return result;
>+}
>+uint3 operator.wwz(uint4 v) {
>+    uint3 result;
>+    result.x = v.w;
>+    result.y = v.w;
>+    result.z = v.z;
>+    return result;
>+}
>+char3 operator.wwz(char4 v) {
>+    char3 result;
>+    result.x = v.w;
>+    result.y = v.w;
>+    result.z = v.z;
>+    return result;
>+}
>+short3 operator.wwz(short4 v) {
>+    short3 result;
>+    result.x = v.w;
>+    result.y = v.w;
>+    result.z = v.z;
>+    return result;
>+}
>+int3 operator.wwz(int4 v) {
>+    int3 result;
>+    result.x = v.w;
>+    result.y = v.w;
>+    result.z = v.z;
>+    return result;
>+}
>+half3 operator.wwz(half4 v) {
>+    half3 result;
>+    result.x = v.w;
>+    result.y = v.w;
>+    result.z = v.z;
>+    return result;
>+}
>+float3 operator.wwz(float4 v) {
>+    float3 result;
>+    result.x = v.w;
>+    result.y = v.w;
>+    result.z = v.z;
>+    return result;
>+}
>+
>+/* Functions named operator.wyz= */
>+bool4 operator.wyz=(bool4 v, bool3 c) {
>+    bool4 result = v;
>+    result.w = c.x;
>+    result.y = c.y;
>+    result.z = c.z;
>+    return result;
>+}
>+uchar4 operator.wyz=(uchar4 v, uchar3 c) {
>+    uchar4 result = v;
>+    result.w = c.x;
>+    result.y = c.y;
>+    result.z = c.z;
>+    return result;
>+}
>+ushort4 operator.wyz=(ushort4 v, ushort3 c) {
>+    ushort4 result = v;
>+    result.w = c.x;
>+    result.y = c.y;
>+    result.z = c.z;
>+    return result;
>+}
>+uint4 operator.wyz=(uint4 v, uint3 c) {
>+    uint4 result = v;
>+    result.w = c.x;
>+    result.y = c.y;
>+    result.z = c.z;
>+    return result;
>+}
>+char4 operator.wyz=(char4 v, char3 c) {
>+    char4 result = v;
>+    result.w = c.x;
>+    result.y = c.y;
>+    result.z = c.z;
>+    return result;
>+}
>+short4 operator.wyz=(short4 v, short3 c) {
>+    short4 result = v;
>+    result.w = c.x;
>+    result.y = c.y;
>+    result.z = c.z;
>+    return result;
>+}
>+int4 operator.wyz=(int4 v, int3 c) {
>+    int4 result = v;
>+    result.w = c.x;
>+    result.y = c.y;
>+    result.z = c.z;
>+    return result;
>+}
>+half4 operator.wyz=(half4 v, half3 c) {
>+    half4 result = v;
>+    result.w = c.x;
>+    result.y = c.y;
>+    result.z = c.z;
>+    return result;
>+}
>+float4 operator.wyz=(float4 v, float3 c) {
>+    float4 result = v;
>+    result.w = c.x;
>+    result.y = c.y;
>+    result.z = c.z;
>+    return result;
>+}
>+
>+/* Functions named operator.ywyy */
>+bool4 operator.ywyy(bool4 v) {
>+    bool4 result;
>+    result.x = v.y;
>+    result.y = v.w;
>+    result.z = v.y;
>+    result.w = v.y;
>+    return result;
>+}
>+uchar4 operator.ywyy(uchar4 v) {
>+    uchar4 result;
>+    result.x = v.y;
>+    result.y = v.w;
>+    result.z = v.y;
>+    result.w = v.y;
>+    return result;
>+}
>+ushort4 operator.ywyy(ushort4 v) {
>+    ushort4 result;
>+    result.x = v.y;
>+    result.y = v.w;
>+    result.z = v.y;
>+    result.w = v.y;
>+    return result;
>+}
>+uint4 operator.ywyy(uint4 v) {
>+    uint4 result;
>+    result.x = v.y;
>+    result.y = v.w;
>+    result.z = v.y;
>+    result.w = v.y;
>+    return result;
>+}
>+char4 operator.ywyy(char4 v) {
>+    char4 result;
>+    result.x = v.y;
>+    result.y = v.w;
>+    result.z = v.y;
>+    result.w = v.y;
>+    return result;
>+}
>+short4 operator.ywyy(short4 v) {
>+    short4 result;
>+    result.x = v.y;
>+    result.y = v.w;
>+    result.z = v.y;
>+    result.w = v.y;
>+    return result;
>+}
>+int4 operator.ywyy(int4 v) {
>+    int4 result;
>+    result.x = v.y;
>+    result.y = v.w;
>+    result.z = v.y;
>+    result.w = v.y;
>+    return result;
>+}
>+half4 operator.ywyy(half4 v) {
>+    half4 result;
>+    result.x = v.y;
>+    result.y = v.w;
>+    result.z = v.y;
>+    result.w = v.y;
>+    return result;
>+}
>+float4 operator.ywyy(float4 v) {
>+    float4 result;
>+    result.x = v.y;
>+    result.y = v.w;
>+    result.z = v.y;
>+    result.w = v.y;
>+    return result;
>+}
>+
>+/* Functions named asint */
>+int asint(int x) {
>+    return x;
>+}
>+int2 asint(int2 x) {
>+    return x;
>+}
>+int3 asint(int3 x) {
>+    return x;
>+}
>+int4 asint(int4 x) {
>+    return x;
>+}
>+int asint(uint x) {
>+    return int(x);
>+}
>+int2 asint(uint2 x) {
>+    int2 result;
>+    result[0] = asint(x[0]);
>+    result[1] = asint(x[1]);
>+    return result;
>+}
>+int3 asint(uint3 x) {
>+    int3 result;
>+    result[0] = asint(x[0]);
>+    result[1] = asint(x[1]);
>+    result[2] = asint(x[2]);
>+    return result;
>+}
>+int4 asint(uint4 x) {
>+    int4 result;
>+    result[0] = asint(x[0]);
>+    result[1] = asint(x[1]);
>+    result[2] = asint(x[2]);
>+    result[3] = asint(x[3]);
>+    return result;
>+}
>+native int asint(float);
>+int2 asint(float2 x) {
>+    int2 result;
>+    result[0] = asint(x[0]);
>+    result[1] = asint(x[1]);
>+    return result;
>+}
>+int3 asint(float3 x) {
>+    int3 result;
>+    result[0] = asint(x[0]);
>+    result[1] = asint(x[1]);
>+    result[2] = asint(x[2]);
>+    return result;
>+}
>+int4 asint(float4 x) {
>+    int4 result;
>+    result[0] = asint(x[0]);
>+    result[1] = asint(x[1]);
>+    result[2] = asint(x[2]);
>+    result[3] = asint(x[3]);
>+    return result;
>+}
>+
>+/* Functions named operator.yzwz */
>+bool4 operator.yzwz(bool4 v) {
>+    bool4 result;
>+    result.x = v.y;
>+    result.y = v.z;
>+    result.z = v.w;
>+    result.w = v.z;
>+    return result;
>+}
>+uchar4 operator.yzwz(uchar4 v) {
>+    uchar4 result;
>+    result.x = v.y;
>+    result.y = v.z;
>+    result.z = v.w;
>+    result.w = v.z;
>+    return result;
>+}
>+ushort4 operator.yzwz(ushort4 v) {
>+    ushort4 result;
>+    result.x = v.y;
>+    result.y = v.z;
>+    result.z = v.w;
>+    result.w = v.z;
>+    return result;
>+}
>+uint4 operator.yzwz(uint4 v) {
>+    uint4 result;
>+    result.x = v.y;
>+    result.y = v.z;
>+    result.z = v.w;
>+    result.w = v.z;
>+    return result;
>+}
>+char4 operator.yzwz(char4 v) {
>+    char4 result;
>+    result.x = v.y;
>+    result.y = v.z;
>+    result.z = v.w;
>+    result.w = v.z;
>+    return result;
>+}
>+short4 operator.yzwz(short4 v) {
>+    short4 result;
>+    result.x = v.y;
>+    result.y = v.z;
>+    result.z = v.w;
>+    result.w = v.z;
>+    return result;
>+}
>+int4 operator.yzwz(int4 v) {
>+    int4 result;
>+    result.x = v.y;
>+    result.y = v.z;
>+    result.z = v.w;
>+    result.w = v.z;
>+    return result;
>+}
>+half4 operator.yzwz(half4 v) {
>+    half4 result;
>+    result.x = v.y;
>+    result.y = v.z;
>+    result.z = v.w;
>+    result.w = v.z;
>+    return result;
>+}
>+float4 operator.yzwz(float4 v) {
>+    float4 result;
>+    result.x = v.y;
>+    result.y = v.z;
>+    result.z = v.w;
>+    result.w = v.z;
>+    return result;
>+}
>+
>+/* Functions named operator.yxzy */
>+bool4 operator.yxzy(bool3 v) {
>+    bool4 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.z;
>+    result.w = v.y;
>+    return result;
>+}
>+bool4 operator.yxzy(bool4 v) {
>+    bool4 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.z;
>+    result.w = v.y;
>+    return result;
>+}
>+uchar4 operator.yxzy(uchar3 v) {
>+    uchar4 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.z;
>+    result.w = v.y;
>+    return result;
>+}
>+uchar4 operator.yxzy(uchar4 v) {
>+    uchar4 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.z;
>+    result.w = v.y;
>+    return result;
>+}
>+ushort4 operator.yxzy(ushort3 v) {
>+    ushort4 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.z;
>+    result.w = v.y;
>+    return result;
>+}
>+ushort4 operator.yxzy(ushort4 v) {
>+    ushort4 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.z;
>+    result.w = v.y;
>+    return result;
>+}
>+uint4 operator.yxzy(uint3 v) {
>+    uint4 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.z;
>+    result.w = v.y;
>+    return result;
>+}
>+uint4 operator.yxzy(uint4 v) {
>+    uint4 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.z;
>+    result.w = v.y;
>+    return result;
>+}
>+char4 operator.yxzy(char3 v) {
>+    char4 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.z;
>+    result.w = v.y;
>+    return result;
>+}
>+char4 operator.yxzy(char4 v) {
>+    char4 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.z;
>+    result.w = v.y;
>+    return result;
>+}
>+short4 operator.yxzy(short3 v) {
>+    short4 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.z;
>+    result.w = v.y;
>+    return result;
>+}
>+short4 operator.yxzy(short4 v) {
>+    short4 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.z;
>+    result.w = v.y;
>+    return result;
>+}
>+int4 operator.yxzy(int3 v) {
>+    int4 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.z;
>+    result.w = v.y;
>+    return result;
>+}
>+int4 operator.yxzy(int4 v) {
>+    int4 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.z;
>+    result.w = v.y;
>+    return result;
>+}
>+half4 operator.yxzy(half3 v) {
>+    half4 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.z;
>+    result.w = v.y;
>+    return result;
>+}
>+half4 operator.yxzy(half4 v) {
>+    half4 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.z;
>+    result.w = v.y;
>+    return result;
>+}
>+float4 operator.yxzy(float3 v) {
>+    float4 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.z;
>+    result.w = v.y;
>+    return result;
>+}
>+float4 operator.yxzy(float4 v) {
>+    float4 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.z;
>+    result.w = v.y;
>+    return result;
>+}
>+
>+/* Functions named operator.yzxz */
>+bool4 operator.yzxz(bool3 v) {
>+    bool4 result;
>+    result.x = v.y;
>+    result.y = v.z;
>+    result.z = v.x;
>+    result.w = v.z;
>+    return result;
>+}
>+bool4 operator.yzxz(bool4 v) {
>+    bool4 result;
>+    result.x = v.y;
>+    result.y = v.z;
>+    result.z = v.x;
>+    result.w = v.z;
>+    return result;
>+}
>+uchar4 operator.yzxz(uchar3 v) {
>+    uchar4 result;
>+    result.x = v.y;
>+    result.y = v.z;
>+    result.z = v.x;
>+    result.w = v.z;
>+    return result;
>+}
>+uchar4 operator.yzxz(uchar4 v) {
>+    uchar4 result;
>+    result.x = v.y;
>+    result.y = v.z;
>+    result.z = v.x;
>+    result.w = v.z;
>+    return result;
>+}
>+ushort4 operator.yzxz(ushort3 v) {
>+    ushort4 result;
>+    result.x = v.y;
>+    result.y = v.z;
>+    result.z = v.x;
>+    result.w = v.z;
>+    return result;
>+}
>+ushort4 operator.yzxz(ushort4 v) {
>+    ushort4 result;
>+    result.x = v.y;
>+    result.y = v.z;
>+    result.z = v.x;
>+    result.w = v.z;
>+    return result;
>+}
>+uint4 operator.yzxz(uint3 v) {
>+    uint4 result;
>+    result.x = v.y;
>+    result.y = v.z;
>+    result.z = v.x;
>+    result.w = v.z;
>+    return result;
>+}
>+uint4 operator.yzxz(uint4 v) {
>+    uint4 result;
>+    result.x = v.y;
>+    result.y = v.z;
>+    result.z = v.x;
>+    result.w = v.z;
>+    return result;
>+}
>+char4 operator.yzxz(char3 v) {
>+    char4 result;
>+    result.x = v.y;
>+    result.y = v.z;
>+    result.z = v.x;
>+    result.w = v.z;
>+    return result;
>+}
>+char4 operator.yzxz(char4 v) {
>+    char4 result;
>+    result.x = v.y;
>+    result.y = v.z;
>+    result.z = v.x;
>+    result.w = v.z;
>+    return result;
>+}
>+short4 operator.yzxz(short3 v) {
>+    short4 result;
>+    result.x = v.y;
>+    result.y = v.z;
>+    result.z = v.x;
>+    result.w = v.z;
>+    return result;
>+}
>+short4 operator.yzxz(short4 v) {
>+    short4 result;
>+    result.x = v.y;
>+    result.y = v.z;
>+    result.z = v.x;
>+    result.w = v.z;
>+    return result;
>+}
>+int4 operator.yzxz(int3 v) {
>+    int4 result;
>+    result.x = v.y;
>+    result.y = v.z;
>+    result.z = v.x;
>+    result.w = v.z;
>+    return result;
>+}
>+int4 operator.yzxz(int4 v) {
>+    int4 result;
>+    result.x = v.y;
>+    result.y = v.z;
>+    result.z = v.x;
>+    result.w = v.z;
>+    return result;
>+}
>+half4 operator.yzxz(half3 v) {
>+    half4 result;
>+    result.x = v.y;
>+    result.y = v.z;
>+    result.z = v.x;
>+    result.w = v.z;
>+    return result;
>+}
>+half4 operator.yzxz(half4 v) {
>+    half4 result;
>+    result.x = v.y;
>+    result.y = v.z;
>+    result.z = v.x;
>+    result.w = v.z;
>+    return result;
>+}
>+float4 operator.yzxz(float3 v) {
>+    float4 result;
>+    result.x = v.y;
>+    result.y = v.z;
>+    result.z = v.x;
>+    result.w = v.z;
>+    return result;
>+}
>+float4 operator.yzxz(float4 v) {
>+    float4 result;
>+    result.x = v.y;
>+    result.y = v.z;
>+    result.z = v.x;
>+    result.w = v.z;
>+    return result;
>+}
>+
>+/* Functions named operator.wzzx */
>+bool4 operator.wzzx(bool4 v) {
>+    bool4 result;
>+    result.x = v.w;
>+    result.y = v.z;
>+    result.z = v.z;
>+    result.w = v.x;
>+    return result;
>+}
>+uchar4 operator.wzzx(uchar4 v) {
>+    uchar4 result;
>+    result.x = v.w;
>+    result.y = v.z;
>+    result.z = v.z;
>+    result.w = v.x;
>+    return result;
>+}
>+ushort4 operator.wzzx(ushort4 v) {
>+    ushort4 result;
>+    result.x = v.w;
>+    result.y = v.z;
>+    result.z = v.z;
>+    result.w = v.x;
>+    return result;
>+}
>+uint4 operator.wzzx(uint4 v) {
>+    uint4 result;
>+    result.x = v.w;
>+    result.y = v.z;
>+    result.z = v.z;
>+    result.w = v.x;
>+    return result;
>+}
>+char4 operator.wzzx(char4 v) {
>+    char4 result;
>+    result.x = v.w;
>+    result.y = v.z;
>+    result.z = v.z;
>+    result.w = v.x;
>+    return result;
>+}
>+short4 operator.wzzx(short4 v) {
>+    short4 result;
>+    result.x = v.w;
>+    result.y = v.z;
>+    result.z = v.z;
>+    result.w = v.x;
>+    return result;
>+}
>+int4 operator.wzzx(int4 v) {
>+    int4 result;
>+    result.x = v.w;
>+    result.y = v.z;
>+    result.z = v.z;
>+    result.w = v.x;
>+    return result;
>+}
>+half4 operator.wzzx(half4 v) {
>+    half4 result;
>+    result.x = v.w;
>+    result.y = v.z;
>+    result.z = v.z;
>+    result.w = v.x;
>+    return result;
>+}
>+float4 operator.wzzx(float4 v) {
>+    float4 result;
>+    result.x = v.w;
>+    result.y = v.z;
>+    result.z = v.z;
>+    result.w = v.x;
>+    return result;
>+}
>+
>+/* Functions named operator.yzxw= */
>+bool4 operator.yzxw=(bool4 v, bool4 c) {
>+    bool4 result = v;
>+    result.y = c.x;
>+    result.z = c.y;
>+    result.x = c.z;
>+    result.w = c.w;
>+    return result;
>+}
>+uchar4 operator.yzxw=(uchar4 v, uchar4 c) {
>+    uchar4 result = v;
>+    result.y = c.x;
>+    result.z = c.y;
>+    result.x = c.z;
>+    result.w = c.w;
>+    return result;
>+}
>+ushort4 operator.yzxw=(ushort4 v, ushort4 c) {
>+    ushort4 result = v;
>+    result.y = c.x;
>+    result.z = c.y;
>+    result.x = c.z;
>+    result.w = c.w;
>+    return result;
>+}
>+uint4 operator.yzxw=(uint4 v, uint4 c) {
>+    uint4 result = v;
>+    result.y = c.x;
>+    result.z = c.y;
>+    result.x = c.z;
>+    result.w = c.w;
>+    return result;
>+}
>+char4 operator.yzxw=(char4 v, char4 c) {
>+    char4 result = v;
>+    result.y = c.x;
>+    result.z = c.y;
>+    result.x = c.z;
>+    result.w = c.w;
>+    return result;
>+}
>+short4 operator.yzxw=(short4 v, short4 c) {
>+    short4 result = v;
>+    result.y = c.x;
>+    result.z = c.y;
>+    result.x = c.z;
>+    result.w = c.w;
>+    return result;
>+}
>+int4 operator.yzxw=(int4 v, int4 c) {
>+    int4 result = v;
>+    result.y = c.x;
>+    result.z = c.y;
>+    result.x = c.z;
>+    result.w = c.w;
>+    return result;
>+}
>+half4 operator.yzxw=(half4 v, half4 c) {
>+    half4 result = v;
>+    result.y = c.x;
>+    result.z = c.y;
>+    result.x = c.z;
>+    result.w = c.w;
>+    return result;
>+}
>+float4 operator.yzxw=(float4 v, float4 c) {
>+    float4 result = v;
>+    result.y = c.x;
>+    result.z = c.y;
>+    result.x = c.z;
>+    result.w = c.w;
>+    return result;
>+}
>+
>+/* Functions named operator.zyxx */
>+bool4 operator.zyxx(bool3 v) {
>+    bool4 result;
>+    result.x = v.z;
>+    result.y = v.y;
>+    result.z = v.x;
>+    result.w = v.x;
>+    return result;
>+}
>+bool4 operator.zyxx(bool4 v) {
>+    bool4 result;
>+    result.x = v.z;
>+    result.y = v.y;
>+    result.z = v.x;
>+    result.w = v.x;
>+    return result;
>+}
>+uchar4 operator.zyxx(uchar3 v) {
>+    uchar4 result;
>+    result.x = v.z;
>+    result.y = v.y;
>+    result.z = v.x;
>+    result.w = v.x;
>+    return result;
>+}
>+uchar4 operator.zyxx(uchar4 v) {
>+    uchar4 result;
>+    result.x = v.z;
>+    result.y = v.y;
>+    result.z = v.x;
>+    result.w = v.x;
>+    return result;
>+}
>+ushort4 operator.zyxx(ushort3 v) {
>+    ushort4 result;
>+    result.x = v.z;
>+    result.y = v.y;
>+    result.z = v.x;
>+    result.w = v.x;
>+    return result;
>+}
>+ushort4 operator.zyxx(ushort4 v) {
>+    ushort4 result;
>+    result.x = v.z;
>+    result.y = v.y;
>+    result.z = v.x;
>+    result.w = v.x;
>+    return result;
>+}
>+uint4 operator.zyxx(uint3 v) {
>+    uint4 result;
>+    result.x = v.z;
>+    result.y = v.y;
>+    result.z = v.x;
>+    result.w = v.x;
>+    return result;
>+}
>+uint4 operator.zyxx(uint4 v) {
>+    uint4 result;
>+    result.x = v.z;
>+    result.y = v.y;
>+    result.z = v.x;
>+    result.w = v.x;
>+    return result;
>+}
>+char4 operator.zyxx(char3 v) {
>+    char4 result;
>+    result.x = v.z;
>+    result.y = v.y;
>+    result.z = v.x;
>+    result.w = v.x;
>+    return result;
>+}
>+char4 operator.zyxx(char4 v) {
>+    char4 result;
>+    result.x = v.z;
>+    result.y = v.y;
>+    result.z = v.x;
>+    result.w = v.x;
>+    return result;
>+}
>+short4 operator.zyxx(short3 v) {
>+    short4 result;
>+    result.x = v.z;
>+    result.y = v.y;
>+    result.z = v.x;
>+    result.w = v.x;
>+    return result;
>+}
>+short4 operator.zyxx(short4 v) {
>+    short4 result;
>+    result.x = v.z;
>+    result.y = v.y;
>+    result.z = v.x;
>+    result.w = v.x;
>+    return result;
>+}
>+int4 operator.zyxx(int3 v) {
>+    int4 result;
>+    result.x = v.z;
>+    result.y = v.y;
>+    result.z = v.x;
>+    result.w = v.x;
>+    return result;
>+}
>+int4 operator.zyxx(int4 v) {
>+    int4 result;
>+    result.x = v.z;
>+    result.y = v.y;
>+    result.z = v.x;
>+    result.w = v.x;
>+    return result;
>+}
>+half4 operator.zyxx(half3 v) {
>+    half4 result;
>+    result.x = v.z;
>+    result.y = v.y;
>+    result.z = v.x;
>+    result.w = v.x;
>+    return result;
>+}
>+half4 operator.zyxx(half4 v) {
>+    half4 result;
>+    result.x = v.z;
>+    result.y = v.y;
>+    result.z = v.x;
>+    result.w = v.x;
>+    return result;
>+}
>+float4 operator.zyxx(float3 v) {
>+    float4 result;
>+    result.x = v.z;
>+    result.y = v.y;
>+    result.z = v.x;
>+    result.w = v.x;
>+    return result;
>+}
>+float4 operator.zyxx(float4 v) {
>+    float4 result;
>+    result.x = v.z;
>+    result.y = v.y;
>+    result.z = v.x;
>+    result.w = v.x;
>+    return result;
>+}
>+
>+/* Functions named operator.xywz */
>+bool4 operator.xywz(bool4 v) {
>+    bool4 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.w;
>+    result.w = v.z;
>+    return result;
>+}
>+uchar4 operator.xywz(uchar4 v) {
>+    uchar4 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.w;
>+    result.w = v.z;
>+    return result;
>+}
>+ushort4 operator.xywz(ushort4 v) {
>+    ushort4 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.w;
>+    result.w = v.z;
>+    return result;
>+}
>+uint4 operator.xywz(uint4 v) {
>+    uint4 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.w;
>+    result.w = v.z;
>+    return result;
>+}
>+char4 operator.xywz(char4 v) {
>+    char4 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.w;
>+    result.w = v.z;
>+    return result;
>+}
>+short4 operator.xywz(short4 v) {
>+    short4 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.w;
>+    result.w = v.z;
>+    return result;
>+}
>+int4 operator.xywz(int4 v) {
>+    int4 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.w;
>+    result.w = v.z;
>+    return result;
>+}
>+half4 operator.xywz(half4 v) {
>+    half4 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.w;
>+    result.w = v.z;
>+    return result;
>+}
>+float4 operator.xywz(float4 v) {
>+    float4 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.w;
>+    result.w = v.z;
>+    return result;
>+}
>+
>+/* Functions named operator.wzwz */
>+bool4 operator.wzwz(bool4 v) {
>+    bool4 result;
>+    result.x = v.w;
>+    result.y = v.z;
>+    result.z = v.w;
>+    result.w = v.z;
>+    return result;
>+}
>+uchar4 operator.wzwz(uchar4 v) {
>+    uchar4 result;
>+    result.x = v.w;
>+    result.y = v.z;
>+    result.z = v.w;
>+    result.w = v.z;
>+    return result;
>+}
>+ushort4 operator.wzwz(ushort4 v) {
>+    ushort4 result;
>+    result.x = v.w;
>+    result.y = v.z;
>+    result.z = v.w;
>+    result.w = v.z;
>+    return result;
>+}
>+uint4 operator.wzwz(uint4 v) {
>+    uint4 result;
>+    result.x = v.w;
>+    result.y = v.z;
>+    result.z = v.w;
>+    result.w = v.z;
>+    return result;
>+}
>+char4 operator.wzwz(char4 v) {
>+    char4 result;
>+    result.x = v.w;
>+    result.y = v.z;
>+    result.z = v.w;
>+    result.w = v.z;
>+    return result;
>+}
>+short4 operator.wzwz(short4 v) {
>+    short4 result;
>+    result.x = v.w;
>+    result.y = v.z;
>+    result.z = v.w;
>+    result.w = v.z;
>+    return result;
>+}
>+int4 operator.wzwz(int4 v) {
>+    int4 result;
>+    result.x = v.w;
>+    result.y = v.z;
>+    result.z = v.w;
>+    result.w = v.z;
>+    return result;
>+}
>+half4 operator.wzwz(half4 v) {
>+    half4 result;
>+    result.x = v.w;
>+    result.y = v.z;
>+    result.z = v.w;
>+    result.w = v.z;
>+    return result;
>+}
>+float4 operator.wzwz(float4 v) {
>+    float4 result;
>+    result.x = v.w;
>+    result.y = v.z;
>+    result.z = v.w;
>+    result.w = v.z;
>+    return result;
>+}
>+
>+/* Functions named operator.xxxy */
>+bool4 operator.xxxy(bool2 v) {
>+    bool4 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.x;
>+    result.w = v.y;
>+    return result;
>+}
>+bool4 operator.xxxy(bool3 v) {
>+    bool4 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.x;
>+    result.w = v.y;
>+    return result;
>+}
>+bool4 operator.xxxy(bool4 v) {
>+    bool4 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.x;
>+    result.w = v.y;
>+    return result;
>+}
>+uchar4 operator.xxxy(uchar2 v) {
>+    uchar4 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.x;
>+    result.w = v.y;
>+    return result;
>+}
>+uchar4 operator.xxxy(uchar3 v) {
>+    uchar4 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.x;
>+    result.w = v.y;
>+    return result;
>+}
>+uchar4 operator.xxxy(uchar4 v) {
>+    uchar4 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.x;
>+    result.w = v.y;
>+    return result;
>+}
>+ushort4 operator.xxxy(ushort2 v) {
>+    ushort4 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.x;
>+    result.w = v.y;
>+    return result;
>+}
>+ushort4 operator.xxxy(ushort3 v) {
>+    ushort4 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.x;
>+    result.w = v.y;
>+    return result;
>+}
>+ushort4 operator.xxxy(ushort4 v) {
>+    ushort4 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.x;
>+    result.w = v.y;
>+    return result;
>+}
>+uint4 operator.xxxy(uint2 v) {
>+    uint4 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.x;
>+    result.w = v.y;
>+    return result;
>+}
>+uint4 operator.xxxy(uint3 v) {
>+    uint4 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.x;
>+    result.w = v.y;
>+    return result;
>+}
>+uint4 operator.xxxy(uint4 v) {
>+    uint4 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.x;
>+    result.w = v.y;
>+    return result;
>+}
>+char4 operator.xxxy(char2 v) {
>+    char4 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.x;
>+    result.w = v.y;
>+    return result;
>+}
>+char4 operator.xxxy(char3 v) {
>+    char4 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.x;
>+    result.w = v.y;
>+    return result;
>+}
>+char4 operator.xxxy(char4 v) {
>+    char4 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.x;
>+    result.w = v.y;
>+    return result;
>+}
>+short4 operator.xxxy(short2 v) {
>+    short4 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.x;
>+    result.w = v.y;
>+    return result;
>+}
>+short4 operator.xxxy(short3 v) {
>+    short4 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.x;
>+    result.w = v.y;
>+    return result;
>+}
>+short4 operator.xxxy(short4 v) {
>+    short4 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.x;
>+    result.w = v.y;
>+    return result;
>+}
>+int4 operator.xxxy(int2 v) {
>+    int4 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.x;
>+    result.w = v.y;
>+    return result;
>+}
>+int4 operator.xxxy(int3 v) {
>+    int4 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.x;
>+    result.w = v.y;
>+    return result;
>+}
>+int4 operator.xxxy(int4 v) {
>+    int4 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.x;
>+    result.w = v.y;
>+    return result;
>+}
>+half4 operator.xxxy(half2 v) {
>+    half4 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.x;
>+    result.w = v.y;
>+    return result;
>+}
>+half4 operator.xxxy(half3 v) {
>+    half4 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.x;
>+    result.w = v.y;
>+    return result;
>+}
>+half4 operator.xxxy(half4 v) {
>+    half4 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.x;
>+    result.w = v.y;
>+    return result;
>+}
>+float4 operator.xxxy(float2 v) {
>+    float4 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.x;
>+    result.w = v.y;
>+    return result;
>+}
>+float4 operator.xxxy(float3 v) {
>+    float4 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.x;
>+    result.w = v.y;
>+    return result;
>+}
>+float4 operator.xxxy(float4 v) {
>+    float4 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.x;
>+    result.w = v.y;
>+    return result;
>+}
>+
>+/* Functions named operator.zwxy= */
>+bool4 operator.zwxy=(bool4 v, bool4 c) {
>+    bool4 result = v;
>+    result.z = c.x;
>+    result.w = c.y;
>+    result.x = c.z;
>+    result.y = c.w;
>+    return result;
>+}
>+uchar4 operator.zwxy=(uchar4 v, uchar4 c) {
>+    uchar4 result = v;
>+    result.z = c.x;
>+    result.w = c.y;
>+    result.x = c.z;
>+    result.y = c.w;
>+    return result;
>+}
>+ushort4 operator.zwxy=(ushort4 v, ushort4 c) {
>+    ushort4 result = v;
>+    result.z = c.x;
>+    result.w = c.y;
>+    result.x = c.z;
>+    result.y = c.w;
>+    return result;
>+}
>+uint4 operator.zwxy=(uint4 v, uint4 c) {
>+    uint4 result = v;
>+    result.z = c.x;
>+    result.w = c.y;
>+    result.x = c.z;
>+    result.y = c.w;
>+    return result;
>+}
>+char4 operator.zwxy=(char4 v, char4 c) {
>+    char4 result = v;
>+    result.z = c.x;
>+    result.w = c.y;
>+    result.x = c.z;
>+    result.y = c.w;
>+    return result;
>+}
>+short4 operator.zwxy=(short4 v, short4 c) {
>+    short4 result = v;
>+    result.z = c.x;
>+    result.w = c.y;
>+    result.x = c.z;
>+    result.y = c.w;
>+    return result;
>+}
>+int4 operator.zwxy=(int4 v, int4 c) {
>+    int4 result = v;
>+    result.z = c.x;
>+    result.w = c.y;
>+    result.x = c.z;
>+    result.y = c.w;
>+    return result;
>+}
>+half4 operator.zwxy=(half4 v, half4 c) {
>+    half4 result = v;
>+    result.z = c.x;
>+    result.w = c.y;
>+    result.x = c.z;
>+    result.y = c.w;
>+    return result;
>+}
>+float4 operator.zwxy=(float4 v, float4 c) {
>+    float4 result = v;
>+    result.z = c.x;
>+    result.w = c.y;
>+    result.x = c.z;
>+    result.y = c.w;
>+    return result;
>+}
>+
>+/* Functions named operator.zwzw */
>+bool4 operator.zwzw(bool4 v) {
>+    bool4 result;
>+    result.x = v.z;
>+    result.y = v.w;
>+    result.z = v.z;
>+    result.w = v.w;
>+    return result;
>+}
>+uchar4 operator.zwzw(uchar4 v) {
>+    uchar4 result;
>+    result.x = v.z;
>+    result.y = v.w;
>+    result.z = v.z;
>+    result.w = v.w;
>+    return result;
>+}
>+ushort4 operator.zwzw(ushort4 v) {
>+    ushort4 result;
>+    result.x = v.z;
>+    result.y = v.w;
>+    result.z = v.z;
>+    result.w = v.w;
>+    return result;
>+}
>+uint4 operator.zwzw(uint4 v) {
>+    uint4 result;
>+    result.x = v.z;
>+    result.y = v.w;
>+    result.z = v.z;
>+    result.w = v.w;
>+    return result;
>+}
>+char4 operator.zwzw(char4 v) {
>+    char4 result;
>+    result.x = v.z;
>+    result.y = v.w;
>+    result.z = v.z;
>+    result.w = v.w;
>+    return result;
>+}
>+short4 operator.zwzw(short4 v) {
>+    short4 result;
>+    result.x = v.z;
>+    result.y = v.w;
>+    result.z = v.z;
>+    result.w = v.w;
>+    return result;
>+}
>+int4 operator.zwzw(int4 v) {
>+    int4 result;
>+    result.x = v.z;
>+    result.y = v.w;
>+    result.z = v.z;
>+    result.w = v.w;
>+    return result;
>+}
>+half4 operator.zwzw(half4 v) {
>+    half4 result;
>+    result.x = v.z;
>+    result.y = v.w;
>+    result.z = v.z;
>+    result.w = v.w;
>+    return result;
>+}
>+float4 operator.zwzw(float4 v) {
>+    float4 result;
>+    result.x = v.z;
>+    result.y = v.w;
>+    result.z = v.z;
>+    result.w = v.w;
>+    return result;
>+}
>+
>+/* Functions named operator.wwwy */
>+bool4 operator.wwwy(bool4 v) {
>+    bool4 result;
>+    result.x = v.w;
>+    result.y = v.w;
>+    result.z = v.w;
>+    result.w = v.y;
>+    return result;
>+}
>+uchar4 operator.wwwy(uchar4 v) {
>+    uchar4 result;
>+    result.x = v.w;
>+    result.y = v.w;
>+    result.z = v.w;
>+    result.w = v.y;
>+    return result;
>+}
>+ushort4 operator.wwwy(ushort4 v) {
>+    ushort4 result;
>+    result.x = v.w;
>+    result.y = v.w;
>+    result.z = v.w;
>+    result.w = v.y;
>+    return result;
>+}
>+uint4 operator.wwwy(uint4 v) {
>+    uint4 result;
>+    result.x = v.w;
>+    result.y = v.w;
>+    result.z = v.w;
>+    result.w = v.y;
>+    return result;
>+}
>+char4 operator.wwwy(char4 v) {
>+    char4 result;
>+    result.x = v.w;
>+    result.y = v.w;
>+    result.z = v.w;
>+    result.w = v.y;
>+    return result;
>+}
>+short4 operator.wwwy(short4 v) {
>+    short4 result;
>+    result.x = v.w;
>+    result.y = v.w;
>+    result.z = v.w;
>+    result.w = v.y;
>+    return result;
>+}
>+int4 operator.wwwy(int4 v) {
>+    int4 result;
>+    result.x = v.w;
>+    result.y = v.w;
>+    result.z = v.w;
>+    result.w = v.y;
>+    return result;
>+}
>+half4 operator.wwwy(half4 v) {
>+    half4 result;
>+    result.x = v.w;
>+    result.y = v.w;
>+    result.z = v.w;
>+    result.w = v.y;
>+    return result;
>+}
>+float4 operator.wwwy(float4 v) {
>+    float4 result;
>+    result.x = v.w;
>+    result.y = v.w;
>+    result.z = v.w;
>+    result.w = v.y;
>+    return result;
>+}
>+
>+/* Functions named operator.ywx */
>+bool3 operator.ywx(bool4 v) {
>+    bool3 result;
>+    result.x = v.y;
>+    result.y = v.w;
>+    result.z = v.x;
>+    return result;
>+}
>+uchar3 operator.ywx(uchar4 v) {
>+    uchar3 result;
>+    result.x = v.y;
>+    result.y = v.w;
>+    result.z = v.x;
>+    return result;
>+}
>+ushort3 operator.ywx(ushort4 v) {
>+    ushort3 result;
>+    result.x = v.y;
>+    result.y = v.w;
>+    result.z = v.x;
>+    return result;
>+}
>+uint3 operator.ywx(uint4 v) {
>+    uint3 result;
>+    result.x = v.y;
>+    result.y = v.w;
>+    result.z = v.x;
>+    return result;
>+}
>+char3 operator.ywx(char4 v) {
>+    char3 result;
>+    result.x = v.y;
>+    result.y = v.w;
>+    result.z = v.x;
>+    return result;
>+}
>+short3 operator.ywx(short4 v) {
>+    short3 result;
>+    result.x = v.y;
>+    result.y = v.w;
>+    result.z = v.x;
>+    return result;
>+}
>+int3 operator.ywx(int4 v) {
>+    int3 result;
>+    result.x = v.y;
>+    result.y = v.w;
>+    result.z = v.x;
>+    return result;
>+}
>+half3 operator.ywx(half4 v) {
>+    half3 result;
>+    result.x = v.y;
>+    result.y = v.w;
>+    result.z = v.x;
>+    return result;
>+}
>+float3 operator.ywx(float4 v) {
>+    float3 result;
>+    result.x = v.y;
>+    result.y = v.w;
>+    result.z = v.x;
>+    return result;
>+}
>+
>+/* Functions named operator.xxzz */
>+bool4 operator.xxzz(bool3 v) {
>+    bool4 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.z;
>+    result.w = v.z;
>+    return result;
>+}
>+bool4 operator.xxzz(bool4 v) {
>+    bool4 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.z;
>+    result.w = v.z;
>+    return result;
>+}
>+uchar4 operator.xxzz(uchar3 v) {
>+    uchar4 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.z;
>+    result.w = v.z;
>+    return result;
>+}
>+uchar4 operator.xxzz(uchar4 v) {
>+    uchar4 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.z;
>+    result.w = v.z;
>+    return result;
>+}
>+ushort4 operator.xxzz(ushort3 v) {
>+    ushort4 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.z;
>+    result.w = v.z;
>+    return result;
>+}
>+ushort4 operator.xxzz(ushort4 v) {
>+    ushort4 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.z;
>+    result.w = v.z;
>+    return result;
>+}
>+uint4 operator.xxzz(uint3 v) {
>+    uint4 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.z;
>+    result.w = v.z;
>+    return result;
>+}
>+uint4 operator.xxzz(uint4 v) {
>+    uint4 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.z;
>+    result.w = v.z;
>+    return result;
>+}
>+char4 operator.xxzz(char3 v) {
>+    char4 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.z;
>+    result.w = v.z;
>+    return result;
>+}
>+char4 operator.xxzz(char4 v) {
>+    char4 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.z;
>+    result.w = v.z;
>+    return result;
>+}
>+short4 operator.xxzz(short3 v) {
>+    short4 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.z;
>+    result.w = v.z;
>+    return result;
>+}
>+short4 operator.xxzz(short4 v) {
>+    short4 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.z;
>+    result.w = v.z;
>+    return result;
>+}
>+int4 operator.xxzz(int3 v) {
>+    int4 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.z;
>+    result.w = v.z;
>+    return result;
>+}
>+int4 operator.xxzz(int4 v) {
>+    int4 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.z;
>+    result.w = v.z;
>+    return result;
>+}
>+half4 operator.xxzz(half3 v) {
>+    half4 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.z;
>+    result.w = v.z;
>+    return result;
>+}
>+half4 operator.xxzz(half4 v) {
>+    half4 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.z;
>+    result.w = v.z;
>+    return result;
>+}
>+float4 operator.xxzz(float3 v) {
>+    float4 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.z;
>+    result.w = v.z;
>+    return result;
>+}
>+float4 operator.xxzz(float4 v) {
>+    float4 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.z;
>+    result.w = v.z;
>+    return result;
>+}
>+
>+/* Functions named operator.xwyz= */
>+bool4 operator.xwyz=(bool4 v, bool4 c) {
>+    bool4 result = v;
>+    result.x = c.x;
>+    result.w = c.y;
>+    result.y = c.z;
>+    result.z = c.w;
>+    return result;
>+}
>+uchar4 operator.xwyz=(uchar4 v, uchar4 c) {
>+    uchar4 result = v;
>+    result.x = c.x;
>+    result.w = c.y;
>+    result.y = c.z;
>+    result.z = c.w;
>+    return result;
>+}
>+ushort4 operator.xwyz=(ushort4 v, ushort4 c) {
>+    ushort4 result = v;
>+    result.x = c.x;
>+    result.w = c.y;
>+    result.y = c.z;
>+    result.z = c.w;
>+    return result;
>+}
>+uint4 operator.xwyz=(uint4 v, uint4 c) {
>+    uint4 result = v;
>+    result.x = c.x;
>+    result.w = c.y;
>+    result.y = c.z;
>+    result.z = c.w;
>+    return result;
>+}
>+char4 operator.xwyz=(char4 v, char4 c) {
>+    char4 result = v;
>+    result.x = c.x;
>+    result.w = c.y;
>+    result.y = c.z;
>+    result.z = c.w;
>+    return result;
>+}
>+short4 operator.xwyz=(short4 v, short4 c) {
>+    short4 result = v;
>+    result.x = c.x;
>+    result.w = c.y;
>+    result.y = c.z;
>+    result.z = c.w;
>+    return result;
>+}
>+int4 operator.xwyz=(int4 v, int4 c) {
>+    int4 result = v;
>+    result.x = c.x;
>+    result.w = c.y;
>+    result.y = c.z;
>+    result.z = c.w;
>+    return result;
>+}
>+half4 operator.xwyz=(half4 v, half4 c) {
>+    half4 result = v;
>+    result.x = c.x;
>+    result.w = c.y;
>+    result.y = c.z;
>+    result.z = c.w;
>+    return result;
>+}
>+float4 operator.xwyz=(float4 v, float4 c) {
>+    float4 result = v;
>+    result.x = c.x;
>+    result.w = c.y;
>+    result.y = c.z;
>+    result.z = c.w;
>+    return result;
>+}
>+
>+/* Functions named operator.yyx */
>+bool3 operator.yyx(bool2 v) {
>+    bool3 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.x;
>+    return result;
>+}
>+bool3 operator.yyx(bool3 v) {
>+    bool3 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.x;
>+    return result;
>+}
>+bool3 operator.yyx(bool4 v) {
>+    bool3 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.x;
>+    return result;
>+}
>+uchar3 operator.yyx(uchar2 v) {
>+    uchar3 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.x;
>+    return result;
>+}
>+uchar3 operator.yyx(uchar3 v) {
>+    uchar3 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.x;
>+    return result;
>+}
>+uchar3 operator.yyx(uchar4 v) {
>+    uchar3 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.x;
>+    return result;
>+}
>+ushort3 operator.yyx(ushort2 v) {
>+    ushort3 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.x;
>+    return result;
>+}
>+ushort3 operator.yyx(ushort3 v) {
>+    ushort3 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.x;
>+    return result;
>+}
>+ushort3 operator.yyx(ushort4 v) {
>+    ushort3 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.x;
>+    return result;
>+}
>+uint3 operator.yyx(uint2 v) {
>+    uint3 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.x;
>+    return result;
>+}
>+uint3 operator.yyx(uint3 v) {
>+    uint3 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.x;
>+    return result;
>+}
>+uint3 operator.yyx(uint4 v) {
>+    uint3 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.x;
>+    return result;
>+}
>+char3 operator.yyx(char2 v) {
>+    char3 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.x;
>+    return result;
>+}
>+char3 operator.yyx(char3 v) {
>+    char3 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.x;
>+    return result;
>+}
>+char3 operator.yyx(char4 v) {
>+    char3 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.x;
>+    return result;
>+}
>+short3 operator.yyx(short2 v) {
>+    short3 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.x;
>+    return result;
>+}
>+short3 operator.yyx(short3 v) {
>+    short3 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.x;
>+    return result;
>+}
>+short3 operator.yyx(short4 v) {
>+    short3 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.x;
>+    return result;
>+}
>+int3 operator.yyx(int2 v) {
>+    int3 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.x;
>+    return result;
>+}
>+int3 operator.yyx(int3 v) {
>+    int3 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.x;
>+    return result;
>+}
>+int3 operator.yyx(int4 v) {
>+    int3 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.x;
>+    return result;
>+}
>+half3 operator.yyx(half2 v) {
>+    half3 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.x;
>+    return result;
>+}
>+half3 operator.yyx(half3 v) {
>+    half3 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.x;
>+    return result;
>+}
>+half3 operator.yyx(half4 v) {
>+    half3 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.x;
>+    return result;
>+}
>+float3 operator.yyx(float2 v) {
>+    float3 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.x;
>+    return result;
>+}
>+float3 operator.yyx(float3 v) {
>+    float3 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.x;
>+    return result;
>+}
>+float3 operator.yyx(float4 v) {
>+    float3 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.x;
>+    return result;
>+}
>+
>+/* Functions named operator.zzwy */
>+bool4 operator.zzwy(bool4 v) {
>+    bool4 result;
>+    result.x = v.z;
>+    result.y = v.z;
>+    result.z = v.w;
>+    result.w = v.y;
>+    return result;
>+}
>+uchar4 operator.zzwy(uchar4 v) {
>+    uchar4 result;
>+    result.x = v.z;
>+    result.y = v.z;
>+    result.z = v.w;
>+    result.w = v.y;
>+    return result;
>+}
>+ushort4 operator.zzwy(ushort4 v) {
>+    ushort4 result;
>+    result.x = v.z;
>+    result.y = v.z;
>+    result.z = v.w;
>+    result.w = v.y;
>+    return result;
>+}
>+uint4 operator.zzwy(uint4 v) {
>+    uint4 result;
>+    result.x = v.z;
>+    result.y = v.z;
>+    result.z = v.w;
>+    result.w = v.y;
>+    return result;
>+}
>+char4 operator.zzwy(char4 v) {
>+    char4 result;
>+    result.x = v.z;
>+    result.y = v.z;
>+    result.z = v.w;
>+    result.w = v.y;
>+    return result;
>+}
>+short4 operator.zzwy(short4 v) {
>+    short4 result;
>+    result.x = v.z;
>+    result.y = v.z;
>+    result.z = v.w;
>+    result.w = v.y;
>+    return result;
>+}
>+int4 operator.zzwy(int4 v) {
>+    int4 result;
>+    result.x = v.z;
>+    result.y = v.z;
>+    result.z = v.w;
>+    result.w = v.y;
>+    return result;
>+}
>+half4 operator.zzwy(half4 v) {
>+    half4 result;
>+    result.x = v.z;
>+    result.y = v.z;
>+    result.z = v.w;
>+    result.w = v.y;
>+    return result;
>+}
>+float4 operator.zzwy(float4 v) {
>+    float4 result;
>+    result.x = v.z;
>+    result.y = v.z;
>+    result.z = v.w;
>+    result.w = v.y;
>+    return result;
>+}
>+
>+/* Functions named operator.wx= */
>+bool4 operator.wx=(bool4 v, bool2 c) {
>+    bool4 result = v;
>+    result.w = c.x;
>+    result.x = c.y;
>+    return result;
>+}
>+uchar4 operator.wx=(uchar4 v, uchar2 c) {
>+    uchar4 result = v;
>+    result.w = c.x;
>+    result.x = c.y;
>+    return result;
>+}
>+ushort4 operator.wx=(ushort4 v, ushort2 c) {
>+    ushort4 result = v;
>+    result.w = c.x;
>+    result.x = c.y;
>+    return result;
>+}
>+uint4 operator.wx=(uint4 v, uint2 c) {
>+    uint4 result = v;
>+    result.w = c.x;
>+    result.x = c.y;
>+    return result;
>+}
>+char4 operator.wx=(char4 v, char2 c) {
>+    char4 result = v;
>+    result.w = c.x;
>+    result.x = c.y;
>+    return result;
>+}
>+short4 operator.wx=(short4 v, short2 c) {
>+    short4 result = v;
>+    result.w = c.x;
>+    result.x = c.y;
>+    return result;
>+}
>+int4 operator.wx=(int4 v, int2 c) {
>+    int4 result = v;
>+    result.w = c.x;
>+    result.x = c.y;
>+    return result;
>+}
>+half4 operator.wx=(half4 v, half2 c) {
>+    half4 result = v;
>+    result.w = c.x;
>+    result.x = c.y;
>+    return result;
>+}
>+float4 operator.wx=(float4 v, float2 c) {
>+    float4 result = v;
>+    result.w = c.x;
>+    result.x = c.y;
>+    return result;
>+}
>+
>+/* Functions named operator.zzw */
>+bool3 operator.zzw(bool4 v) {
>+    bool3 result;
>+    result.x = v.z;
>+    result.y = v.z;
>+    result.z = v.w;
>+    return result;
>+}
>+uchar3 operator.zzw(uchar4 v) {
>+    uchar3 result;
>+    result.x = v.z;
>+    result.y = v.z;
>+    result.z = v.w;
>+    return result;
>+}
>+ushort3 operator.zzw(ushort4 v) {
>+    ushort3 result;
>+    result.x = v.z;
>+    result.y = v.z;
>+    result.z = v.w;
>+    return result;
>+}
>+uint3 operator.zzw(uint4 v) {
>+    uint3 result;
>+    result.x = v.z;
>+    result.y = v.z;
>+    result.z = v.w;
>+    return result;
>+}
>+char3 operator.zzw(char4 v) {
>+    char3 result;
>+    result.x = v.z;
>+    result.y = v.z;
>+    result.z = v.w;
>+    return result;
>+}
>+short3 operator.zzw(short4 v) {
>+    short3 result;
>+    result.x = v.z;
>+    result.y = v.z;
>+    result.z = v.w;
>+    return result;
>+}
>+int3 operator.zzw(int4 v) {
>+    int3 result;
>+    result.x = v.z;
>+    result.y = v.z;
>+    result.z = v.w;
>+    return result;
>+}
>+half3 operator.zzw(half4 v) {
>+    half3 result;
>+    result.x = v.z;
>+    result.y = v.z;
>+    result.z = v.w;
>+    return result;
>+}
>+float3 operator.zzw(float4 v) {
>+    float3 result;
>+    result.x = v.z;
>+    result.y = v.z;
>+    result.z = v.w;
>+    return result;
>+}
>+
>+/* Functions named operator.xxzy */
>+bool4 operator.xxzy(bool3 v) {
>+    bool4 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.z;
>+    result.w = v.y;
>+    return result;
>+}
>+bool4 operator.xxzy(bool4 v) {
>+    bool4 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.z;
>+    result.w = v.y;
>+    return result;
>+}
>+uchar4 operator.xxzy(uchar3 v) {
>+    uchar4 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.z;
>+    result.w = v.y;
>+    return result;
>+}
>+uchar4 operator.xxzy(uchar4 v) {
>+    uchar4 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.z;
>+    result.w = v.y;
>+    return result;
>+}
>+ushort4 operator.xxzy(ushort3 v) {
>+    ushort4 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.z;
>+    result.w = v.y;
>+    return result;
>+}
>+ushort4 operator.xxzy(ushort4 v) {
>+    ushort4 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.z;
>+    result.w = v.y;
>+    return result;
>+}
>+uint4 operator.xxzy(uint3 v) {
>+    uint4 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.z;
>+    result.w = v.y;
>+    return result;
>+}
>+uint4 operator.xxzy(uint4 v) {
>+    uint4 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.z;
>+    result.w = v.y;
>+    return result;
>+}
>+char4 operator.xxzy(char3 v) {
>+    char4 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.z;
>+    result.w = v.y;
>+    return result;
>+}
>+char4 operator.xxzy(char4 v) {
>+    char4 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.z;
>+    result.w = v.y;
>+    return result;
>+}
>+short4 operator.xxzy(short3 v) {
>+    short4 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.z;
>+    result.w = v.y;
>+    return result;
>+}
>+short4 operator.xxzy(short4 v) {
>+    short4 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.z;
>+    result.w = v.y;
>+    return result;
>+}
>+int4 operator.xxzy(int3 v) {
>+    int4 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.z;
>+    result.w = v.y;
>+    return result;
>+}
>+int4 operator.xxzy(int4 v) {
>+    int4 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.z;
>+    result.w = v.y;
>+    return result;
>+}
>+half4 operator.xxzy(half3 v) {
>+    half4 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.z;
>+    result.w = v.y;
>+    return result;
>+}
>+half4 operator.xxzy(half4 v) {
>+    half4 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.z;
>+    result.w = v.y;
>+    return result;
>+}
>+float4 operator.xxzy(float3 v) {
>+    float4 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.z;
>+    result.w = v.y;
>+    return result;
>+}
>+float4 operator.xxzy(float4 v) {
>+    float4 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.z;
>+    result.w = v.y;
>+    return result;
>+}
>+
>+/* Functions named operator.yxz */
>+bool3 operator.yxz(bool3 v) {
>+    bool3 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.z;
>+    return result;
>+}
>+bool3 operator.yxz(bool4 v) {
>+    bool3 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.z;
>+    return result;
>+}
>+uchar3 operator.yxz(uchar3 v) {
>+    uchar3 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.z;
>+    return result;
>+}
>+uchar3 operator.yxz(uchar4 v) {
>+    uchar3 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.z;
>+    return result;
>+}
>+ushort3 operator.yxz(ushort3 v) {
>+    ushort3 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.z;
>+    return result;
>+}
>+ushort3 operator.yxz(ushort4 v) {
>+    ushort3 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.z;
>+    return result;
>+}
>+uint3 operator.yxz(uint3 v) {
>+    uint3 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.z;
>+    return result;
>+}
>+uint3 operator.yxz(uint4 v) {
>+    uint3 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.z;
>+    return result;
>+}
>+char3 operator.yxz(char3 v) {
>+    char3 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.z;
>+    return result;
>+}
>+char3 operator.yxz(char4 v) {
>+    char3 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.z;
>+    return result;
>+}
>+short3 operator.yxz(short3 v) {
>+    short3 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.z;
>+    return result;
>+}
>+short3 operator.yxz(short4 v) {
>+    short3 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.z;
>+    return result;
>+}
>+int3 operator.yxz(int3 v) {
>+    int3 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.z;
>+    return result;
>+}
>+int3 operator.yxz(int4 v) {
>+    int3 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.z;
>+    return result;
>+}
>+half3 operator.yxz(half3 v) {
>+    half3 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.z;
>+    return result;
>+}
>+half3 operator.yxz(half4 v) {
>+    half3 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.z;
>+    return result;
>+}
>+float3 operator.yxz(float3 v) {
>+    float3 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.z;
>+    return result;
>+}
>+float3 operator.yxz(float4 v) {
>+    float3 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.z;
>+    return result;
>+}
>+
>+/* Functions named operator.yzy */
>+bool3 operator.yzy(bool3 v) {
>+    bool3 result;
>+    result.x = v.y;
>+    result.y = v.z;
>+    result.z = v.y;
>+    return result;
>+}
>+bool3 operator.yzy(bool4 v) {
>+    bool3 result;
>+    result.x = v.y;
>+    result.y = v.z;
>+    result.z = v.y;
>+    return result;
>+}
>+uchar3 operator.yzy(uchar3 v) {
>+    uchar3 result;
>+    result.x = v.y;
>+    result.y = v.z;
>+    result.z = v.y;
>+    return result;
>+}
>+uchar3 operator.yzy(uchar4 v) {
>+    uchar3 result;
>+    result.x = v.y;
>+    result.y = v.z;
>+    result.z = v.y;
>+    return result;
>+}
>+ushort3 operator.yzy(ushort3 v) {
>+    ushort3 result;
>+    result.x = v.y;
>+    result.y = v.z;
>+    result.z = v.y;
>+    return result;
>+}
>+ushort3 operator.yzy(ushort4 v) {
>+    ushort3 result;
>+    result.x = v.y;
>+    result.y = v.z;
>+    result.z = v.y;
>+    return result;
>+}
>+uint3 operator.yzy(uint3 v) {
>+    uint3 result;
>+    result.x = v.y;
>+    result.y = v.z;
>+    result.z = v.y;
>+    return result;
>+}
>+uint3 operator.yzy(uint4 v) {
>+    uint3 result;
>+    result.x = v.y;
>+    result.y = v.z;
>+    result.z = v.y;
>+    return result;
>+}
>+char3 operator.yzy(char3 v) {
>+    char3 result;
>+    result.x = v.y;
>+    result.y = v.z;
>+    result.z = v.y;
>+    return result;
>+}
>+char3 operator.yzy(char4 v) {
>+    char3 result;
>+    result.x = v.y;
>+    result.y = v.z;
>+    result.z = v.y;
>+    return result;
>+}
>+short3 operator.yzy(short3 v) {
>+    short3 result;
>+    result.x = v.y;
>+    result.y = v.z;
>+    result.z = v.y;
>+    return result;
>+}
>+short3 operator.yzy(short4 v) {
>+    short3 result;
>+    result.x = v.y;
>+    result.y = v.z;
>+    result.z = v.y;
>+    return result;
>+}
>+int3 operator.yzy(int3 v) {
>+    int3 result;
>+    result.x = v.y;
>+    result.y = v.z;
>+    result.z = v.y;
>+    return result;
>+}
>+int3 operator.yzy(int4 v) {
>+    int3 result;
>+    result.x = v.y;
>+    result.y = v.z;
>+    result.z = v.y;
>+    return result;
>+}
>+half3 operator.yzy(half3 v) {
>+    half3 result;
>+    result.x = v.y;
>+    result.y = v.z;
>+    result.z = v.y;
>+    return result;
>+}
>+half3 operator.yzy(half4 v) {
>+    half3 result;
>+    result.x = v.y;
>+    result.y = v.z;
>+    result.z = v.y;
>+    return result;
>+}
>+float3 operator.yzy(float3 v) {
>+    float3 result;
>+    result.x = v.y;
>+    result.y = v.z;
>+    result.z = v.y;
>+    return result;
>+}
>+float3 operator.yzy(float4 v) {
>+    float3 result;
>+    result.x = v.y;
>+    result.y = v.z;
>+    result.z = v.y;
>+    return result;
>+}
>+
>+/* Functions named operator.y= */
>+native bool2 operator.y=(bool2, bool);
>+native bool3 operator.y=(bool3, bool);
>+native bool4 operator.y=(bool4, bool);
>+native uchar2 operator.y=(uchar2, uchar);
>+native uchar3 operator.y=(uchar3, uchar);
>+native uchar4 operator.y=(uchar4, uchar);
>+native ushort2 operator.y=(ushort2, ushort);
>+native ushort3 operator.y=(ushort3, ushort);
>+native ushort4 operator.y=(ushort4, ushort);
>+native uint2 operator.y=(uint2, uint);
>+native uint3 operator.y=(uint3, uint);
>+native uint4 operator.y=(uint4, uint);
>+native char2 operator.y=(char2, char);
>+native char3 operator.y=(char3, char);
>+native char4 operator.y=(char4, char);
>+native short2 operator.y=(short2, short);
>+native short3 operator.y=(short3, short);
>+native short4 operator.y=(short4, short);
>+native int2 operator.y=(int2, int);
>+native int3 operator.y=(int3, int);
>+native int4 operator.y=(int4, int);
>+native half2 operator.y=(half2, half);
>+native half3 operator.y=(half3, half);
>+native half4 operator.y=(half4, half);
>+native float2 operator.y=(float2, float);
>+native float3 operator.y=(float3, float);
>+native float4 operator.y=(float4, float);
>+
>+/* Functions named operator.zxzz */
>+bool4 operator.zxzz(bool3 v) {
>+    bool4 result;
>+    result.x = v.z;
>+    result.y = v.x;
>+    result.z = v.z;
>+    result.w = v.z;
>+    return result;
>+}
>+bool4 operator.zxzz(bool4 v) {
>+    bool4 result;
>+    result.x = v.z;
>+    result.y = v.x;
>+    result.z = v.z;
>+    result.w = v.z;
>+    return result;
>+}
>+uchar4 operator.zxzz(uchar3 v) {
>+    uchar4 result;
>+    result.x = v.z;
>+    result.y = v.x;
>+    result.z = v.z;
>+    result.w = v.z;
>+    return result;
>+}
>+uchar4 operator.zxzz(uchar4 v) {
>+    uchar4 result;
>+    result.x = v.z;
>+    result.y = v.x;
>+    result.z = v.z;
>+    result.w = v.z;
>+    return result;
>+}
>+ushort4 operator.zxzz(ushort3 v) {
>+    ushort4 result;
>+    result.x = v.z;
>+    result.y = v.x;
>+    result.z = v.z;
>+    result.w = v.z;
>+    return result;
>+}
>+ushort4 operator.zxzz(ushort4 v) {
>+    ushort4 result;
>+    result.x = v.z;
>+    result.y = v.x;
>+    result.z = v.z;
>+    result.w = v.z;
>+    return result;
>+}
>+uint4 operator.zxzz(uint3 v) {
>+    uint4 result;
>+    result.x = v.z;
>+    result.y = v.x;
>+    result.z = v.z;
>+    result.w = v.z;
>+    return result;
>+}
>+uint4 operator.zxzz(uint4 v) {
>+    uint4 result;
>+    result.x = v.z;
>+    result.y = v.x;
>+    result.z = v.z;
>+    result.w = v.z;
>+    return result;
>+}
>+char4 operator.zxzz(char3 v) {
>+    char4 result;
>+    result.x = v.z;
>+    result.y = v.x;
>+    result.z = v.z;
>+    result.w = v.z;
>+    return result;
>+}
>+char4 operator.zxzz(char4 v) {
>+    char4 result;
>+    result.x = v.z;
>+    result.y = v.x;
>+    result.z = v.z;
>+    result.w = v.z;
>+    return result;
>+}
>+short4 operator.zxzz(short3 v) {
>+    short4 result;
>+    result.x = v.z;
>+    result.y = v.x;
>+    result.z = v.z;
>+    result.w = v.z;
>+    return result;
>+}
>+short4 operator.zxzz(short4 v) {
>+    short4 result;
>+    result.x = v.z;
>+    result.y = v.x;
>+    result.z = v.z;
>+    result.w = v.z;
>+    return result;
>+}
>+int4 operator.zxzz(int3 v) {
>+    int4 result;
>+    result.x = v.z;
>+    result.y = v.x;
>+    result.z = v.z;
>+    result.w = v.z;
>+    return result;
>+}
>+int4 operator.zxzz(int4 v) {
>+    int4 result;
>+    result.x = v.z;
>+    result.y = v.x;
>+    result.z = v.z;
>+    result.w = v.z;
>+    return result;
>+}
>+half4 operator.zxzz(half3 v) {
>+    half4 result;
>+    result.x = v.z;
>+    result.y = v.x;
>+    result.z = v.z;
>+    result.w = v.z;
>+    return result;
>+}
>+half4 operator.zxzz(half4 v) {
>+    half4 result;
>+    result.x = v.z;
>+    result.y = v.x;
>+    result.z = v.z;
>+    result.w = v.z;
>+    return result;
>+}
>+float4 operator.zxzz(float3 v) {
>+    float4 result;
>+    result.x = v.z;
>+    result.y = v.x;
>+    result.z = v.z;
>+    result.w = v.z;
>+    return result;
>+}
>+float4 operator.zxzz(float4 v) {
>+    float4 result;
>+    result.x = v.z;
>+    result.y = v.x;
>+    result.z = v.z;
>+    result.w = v.z;
>+    return result;
>+}
>+
>+/* Functions named operator.xyzw */
>+bool4 operator.xyzw(bool4 v) {
>+    bool4 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.z;
>+    result.w = v.w;
>+    return result;
>+}
>+uchar4 operator.xyzw(uchar4 v) {
>+    uchar4 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.z;
>+    result.w = v.w;
>+    return result;
>+}
>+ushort4 operator.xyzw(ushort4 v) {
>+    ushort4 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.z;
>+    result.w = v.w;
>+    return result;
>+}
>+uint4 operator.xyzw(uint4 v) {
>+    uint4 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.z;
>+    result.w = v.w;
>+    return result;
>+}
>+char4 operator.xyzw(char4 v) {
>+    char4 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.z;
>+    result.w = v.w;
>+    return result;
>+}
>+short4 operator.xyzw(short4 v) {
>+    short4 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.z;
>+    result.w = v.w;
>+    return result;
>+}
>+int4 operator.xyzw(int4 v) {
>+    int4 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.z;
>+    result.w = v.w;
>+    return result;
>+}
>+half4 operator.xyzw(half4 v) {
>+    half4 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.z;
>+    result.w = v.w;
>+    return result;
>+}
>+float4 operator.xyzw(float4 v) {
>+    float4 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.z;
>+    result.w = v.w;
>+    return result;
>+}
>+
>+/* Functions named operator.zwyw */
>+bool4 operator.zwyw(bool4 v) {
>+    bool4 result;
>+    result.x = v.z;
>+    result.y = v.w;
>+    result.z = v.y;
>+    result.w = v.w;
>+    return result;
>+}
>+uchar4 operator.zwyw(uchar4 v) {
>+    uchar4 result;
>+    result.x = v.z;
>+    result.y = v.w;
>+    result.z = v.y;
>+    result.w = v.w;
>+    return result;
>+}
>+ushort4 operator.zwyw(ushort4 v) {
>+    ushort4 result;
>+    result.x = v.z;
>+    result.y = v.w;
>+    result.z = v.y;
>+    result.w = v.w;
>+    return result;
>+}
>+uint4 operator.zwyw(uint4 v) {
>+    uint4 result;
>+    result.x = v.z;
>+    result.y = v.w;
>+    result.z = v.y;
>+    result.w = v.w;
>+    return result;
>+}
>+char4 operator.zwyw(char4 v) {
>+    char4 result;
>+    result.x = v.z;
>+    result.y = v.w;
>+    result.z = v.y;
>+    result.w = v.w;
>+    return result;
>+}
>+short4 operator.zwyw(short4 v) {
>+    short4 result;
>+    result.x = v.z;
>+    result.y = v.w;
>+    result.z = v.y;
>+    result.w = v.w;
>+    return result;
>+}
>+int4 operator.zwyw(int4 v) {
>+    int4 result;
>+    result.x = v.z;
>+    result.y = v.w;
>+    result.z = v.y;
>+    result.w = v.w;
>+    return result;
>+}
>+half4 operator.zwyw(half4 v) {
>+    half4 result;
>+    result.x = v.z;
>+    result.y = v.w;
>+    result.z = v.y;
>+    result.w = v.w;
>+    return result;
>+}
>+float4 operator.zwyw(float4 v) {
>+    float4 result;
>+    result.x = v.z;
>+    result.y = v.w;
>+    result.z = v.y;
>+    result.w = v.w;
>+    return result;
>+}
>+
>+/* Functions named operator.xyw */
>+bool3 operator.xyw(bool4 v) {
>+    bool3 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.w;
>+    return result;
>+}
>+uchar3 operator.xyw(uchar4 v) {
>+    uchar3 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.w;
>+    return result;
>+}
>+ushort3 operator.xyw(ushort4 v) {
>+    ushort3 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.w;
>+    return result;
>+}
>+uint3 operator.xyw(uint4 v) {
>+    uint3 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.w;
>+    return result;
>+}
>+char3 operator.xyw(char4 v) {
>+    char3 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.w;
>+    return result;
>+}
>+short3 operator.xyw(short4 v) {
>+    short3 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.w;
>+    return result;
>+}
>+int3 operator.xyw(int4 v) {
>+    int3 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.w;
>+    return result;
>+}
>+half3 operator.xyw(half4 v) {
>+    half3 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.w;
>+    return result;
>+}
>+float3 operator.xyw(float4 v) {
>+    float3 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.w;
>+    return result;
>+}
>+
>+/* Functions named operator.zzww */
>+bool4 operator.zzww(bool4 v) {
>+    bool4 result;
>+    result.x = v.z;
>+    result.y = v.z;
>+    result.z = v.w;
>+    result.w = v.w;
>+    return result;
>+}
>+uchar4 operator.zzww(uchar4 v) {
>+    uchar4 result;
>+    result.x = v.z;
>+    result.y = v.z;
>+    result.z = v.w;
>+    result.w = v.w;
>+    return result;
>+}
>+ushort4 operator.zzww(ushort4 v) {
>+    ushort4 result;
>+    result.x = v.z;
>+    result.y = v.z;
>+    result.z = v.w;
>+    result.w = v.w;
>+    return result;
>+}
>+uint4 operator.zzww(uint4 v) {
>+    uint4 result;
>+    result.x = v.z;
>+    result.y = v.z;
>+    result.z = v.w;
>+    result.w = v.w;
>+    return result;
>+}
>+char4 operator.zzww(char4 v) {
>+    char4 result;
>+    result.x = v.z;
>+    result.y = v.z;
>+    result.z = v.w;
>+    result.w = v.w;
>+    return result;
>+}
>+short4 operator.zzww(short4 v) {
>+    short4 result;
>+    result.x = v.z;
>+    result.y = v.z;
>+    result.z = v.w;
>+    result.w = v.w;
>+    return result;
>+}
>+int4 operator.zzww(int4 v) {
>+    int4 result;
>+    result.x = v.z;
>+    result.y = v.z;
>+    result.z = v.w;
>+    result.w = v.w;
>+    return result;
>+}
>+half4 operator.zzww(half4 v) {
>+    half4 result;
>+    result.x = v.z;
>+    result.y = v.z;
>+    result.z = v.w;
>+    result.w = v.w;
>+    return result;
>+}
>+float4 operator.zzww(float4 v) {
>+    float4 result;
>+    result.x = v.z;
>+    result.y = v.z;
>+    result.z = v.w;
>+    result.w = v.w;
>+    return result;
>+}
>+
>+/* Functions named operator.zyw */
>+bool3 operator.zyw(bool4 v) {
>+    bool3 result;
>+    result.x = v.z;
>+    result.y = v.y;
>+    result.z = v.w;
>+    return result;
>+}
>+uchar3 operator.zyw(uchar4 v) {
>+    uchar3 result;
>+    result.x = v.z;
>+    result.y = v.y;
>+    result.z = v.w;
>+    return result;
>+}
>+ushort3 operator.zyw(ushort4 v) {
>+    ushort3 result;
>+    result.x = v.z;
>+    result.y = v.y;
>+    result.z = v.w;
>+    return result;
>+}
>+uint3 operator.zyw(uint4 v) {
>+    uint3 result;
>+    result.x = v.z;
>+    result.y = v.y;
>+    result.z = v.w;
>+    return result;
>+}
>+char3 operator.zyw(char4 v) {
>+    char3 result;
>+    result.x = v.z;
>+    result.y = v.y;
>+    result.z = v.w;
>+    return result;
>+}
>+short3 operator.zyw(short4 v) {
>+    short3 result;
>+    result.x = v.z;
>+    result.y = v.y;
>+    result.z = v.w;
>+    return result;
>+}
>+int3 operator.zyw(int4 v) {
>+    int3 result;
>+    result.x = v.z;
>+    result.y = v.y;
>+    result.z = v.w;
>+    return result;
>+}
>+half3 operator.zyw(half4 v) {
>+    half3 result;
>+    result.x = v.z;
>+    result.y = v.y;
>+    result.z = v.w;
>+    return result;
>+}
>+float3 operator.zyw(float4 v) {
>+    float3 result;
>+    result.x = v.z;
>+    result.y = v.y;
>+    result.z = v.w;
>+    return result;
>+}
>+
>+/* Functions named clamp */
>+uchar clamp(uchar x, uchar lower, uchar upper) {
>+    return max(min(upper, x), lower);
>+}
>+uchar2 clamp(uchar2 x, uchar2 y, uchar2 z) {
>+    uchar2 result;
>+    result[0] = clamp(x[0], y[0], z[0]);
>+    result[1] = clamp(x[1], y[1], z[1]);
>+    return result;
>+}
>+uchar3 clamp(uchar3 x, uchar3 y, uchar3 z) {
>+    uchar3 result;
>+    result[0] = clamp(x[0], y[0], z[0]);
>+    result[1] = clamp(x[1], y[1], z[1]);
>+    result[2] = clamp(x[2], y[2], z[2]);
>+    return result;
>+}
>+uchar4 clamp(uchar4 x, uchar4 y, uchar4 z) {
>+    uchar4 result;
>+    result[0] = clamp(x[0], y[0], z[0]);
>+    result[1] = clamp(x[1], y[1], z[1]);
>+    result[2] = clamp(x[2], y[2], z[2]);
>+    result[3] = clamp(x[3], y[3], z[3]);
>+    return result;
>+}
>+
>+ushort clamp(ushort x, ushort lower, ushort upper) {
>+    return max(min(upper, x), lower);
>+}
>+ushort2 clamp(ushort2 x, ushort2 y, ushort2 z) {
>+    ushort2 result;
>+    result[0] = clamp(x[0], y[0], z[0]);
>+    result[1] = clamp(x[1], y[1], z[1]);
>+    return result;
>+}
>+ushort3 clamp(ushort3 x, ushort3 y, ushort3 z) {
>+    ushort3 result;
>+    result[0] = clamp(x[0], y[0], z[0]);
>+    result[1] = clamp(x[1], y[1], z[1]);
>+    result[2] = clamp(x[2], y[2], z[2]);
>+    return result;
>+}
>+ushort4 clamp(ushort4 x, ushort4 y, ushort4 z) {
>+    ushort4 result;
>+    result[0] = clamp(x[0], y[0], z[0]);
>+    result[1] = clamp(x[1], y[1], z[1]);
>+    result[2] = clamp(x[2], y[2], z[2]);
>+    result[3] = clamp(x[3], y[3], z[3]);
>+    return result;
>+}
>+
>+uint clamp(uint x, uint lower, uint upper) {
>+    return max(min(upper, x), lower);
>+}
>+uint2 clamp(uint2 x, uint2 y, uint2 z) {
>+    uint2 result;
>+    result[0] = clamp(x[0], y[0], z[0]);
>+    result[1] = clamp(x[1], y[1], z[1]);
>+    return result;
>+}
>+uint3 clamp(uint3 x, uint3 y, uint3 z) {
>+    uint3 result;
>+    result[0] = clamp(x[0], y[0], z[0]);
>+    result[1] = clamp(x[1], y[1], z[1]);
>+    result[2] = clamp(x[2], y[2], z[2]);
>+    return result;
>+}
>+uint4 clamp(uint4 x, uint4 y, uint4 z) {
>+    uint4 result;
>+    result[0] = clamp(x[0], y[0], z[0]);
>+    result[1] = clamp(x[1], y[1], z[1]);
>+    result[2] = clamp(x[2], y[2], z[2]);
>+    result[3] = clamp(x[3], y[3], z[3]);
>+    return result;
>+}
>+
>+char clamp(char x, char lower, char upper) {
>+    return max(min(upper, x), lower);
>+}
>+char2 clamp(char2 x, char2 y, char2 z) {
>+    char2 result;
>+    result[0] = clamp(x[0], y[0], z[0]);
>+    result[1] = clamp(x[1], y[1], z[1]);
>+    return result;
>+}
>+char3 clamp(char3 x, char3 y, char3 z) {
>+    char3 result;
>+    result[0] = clamp(x[0], y[0], z[0]);
>+    result[1] = clamp(x[1], y[1], z[1]);
>+    result[2] = clamp(x[2], y[2], z[2]);
>+    return result;
>+}
>+char4 clamp(char4 x, char4 y, char4 z) {
>+    char4 result;
>+    result[0] = clamp(x[0], y[0], z[0]);
>+    result[1] = clamp(x[1], y[1], z[1]);
>+    result[2] = clamp(x[2], y[2], z[2]);
>+    result[3] = clamp(x[3], y[3], z[3]);
>+    return result;
>+}
>+
>+short clamp(short x, short lower, short upper) {
>+    return max(min(upper, x), lower);
>+}
>+short2 clamp(short2 x, short2 y, short2 z) {
>+    short2 result;
>+    result[0] = clamp(x[0], y[0], z[0]);
>+    result[1] = clamp(x[1], y[1], z[1]);
>+    return result;
>+}
>+short3 clamp(short3 x, short3 y, short3 z) {
>+    short3 result;
>+    result[0] = clamp(x[0], y[0], z[0]);
>+    result[1] = clamp(x[1], y[1], z[1]);
>+    result[2] = clamp(x[2], y[2], z[2]);
>+    return result;
>+}
>+short4 clamp(short4 x, short4 y, short4 z) {
>+    short4 result;
>+    result[0] = clamp(x[0], y[0], z[0]);
>+    result[1] = clamp(x[1], y[1], z[1]);
>+    result[2] = clamp(x[2], y[2], z[2]);
>+    result[3] = clamp(x[3], y[3], z[3]);
>+    return result;
>+}
>+
>+int clamp(int x, int lower, int upper) {
>+    return max(min(upper, x), lower);
>+}
>+int2 clamp(int2 x, int2 y, int2 z) {
>+    int2 result;
>+    result[0] = clamp(x[0], y[0], z[0]);
>+    result[1] = clamp(x[1], y[1], z[1]);
>+    return result;
>+}
>+int3 clamp(int3 x, int3 y, int3 z) {
>+    int3 result;
>+    result[0] = clamp(x[0], y[0], z[0]);
>+    result[1] = clamp(x[1], y[1], z[1]);
>+    result[2] = clamp(x[2], y[2], z[2]);
>+    return result;
>+}
>+int4 clamp(int4 x, int4 y, int4 z) {
>+    int4 result;
>+    result[0] = clamp(x[0], y[0], z[0]);
>+    result[1] = clamp(x[1], y[1], z[1]);
>+    result[2] = clamp(x[2], y[2], z[2]);
>+    result[3] = clamp(x[3], y[3], z[3]);
>+    return result;
>+}
>+
>+half clamp(half x, half lower, half upper) {
>+    return max(min(upper, x), lower);
>+}
>+half2 clamp(half2 x, half2 y, half2 z) {
>+    half2 result;
>+    result[0] = clamp(x[0], y[0], z[0]);
>+    result[1] = clamp(x[1], y[1], z[1]);
>+    return result;
>+}
>+half3 clamp(half3 x, half3 y, half3 z) {
>+    half3 result;
>+    result[0] = clamp(x[0], y[0], z[0]);
>+    result[1] = clamp(x[1], y[1], z[1]);
>+    result[2] = clamp(x[2], y[2], z[2]);
>+    return result;
>+}
>+half4 clamp(half4 x, half4 y, half4 z) {
>+    half4 result;
>+    result[0] = clamp(x[0], y[0], z[0]);
>+    result[1] = clamp(x[1], y[1], z[1]);
>+    result[2] = clamp(x[2], y[2], z[2]);
>+    result[3] = clamp(x[3], y[3], z[3]);
>+    return result;
>+}
>+half2x2 clamp(half2x2 x, half2x2 y, half2x2 z) {
>+    half2x2 result;
>+    result[0][0] = clamp(x[0][0], y[0][0], z[0][0]);
>+    result[0][1] = clamp(x[0][1], y[0][1], z[0][1]);
>+    result[1][0] = clamp(x[1][0], y[1][0], z[1][0]);
>+    result[1][1] = clamp(x[1][1], y[1][1], z[1][1]);
>+    return result;
>+}
>+half2x3 clamp(half2x3 x, half2x3 y, half2x3 z) {
>+    half2x3 result;
>+    result[0][0] = clamp(x[0][0], y[0][0], z[0][0]);
>+    result[0][1] = clamp(x[0][1], y[0][1], z[0][1]);
>+    result[0][2] = clamp(x[0][2], y[0][2], z[0][2]);
>+    result[1][0] = clamp(x[1][0], y[1][0], z[1][0]);
>+    result[1][1] = clamp(x[1][1], y[1][1], z[1][1]);
>+    result[1][2] = clamp(x[1][2], y[1][2], z[1][2]);
>+    return result;
>+}
>+half2x4 clamp(half2x4 x, half2x4 y, half2x4 z) {
>+    half2x4 result;
>+    result[0][0] = clamp(x[0][0], y[0][0], z[0][0]);
>+    result[0][1] = clamp(x[0][1], y[0][1], z[0][1]);
>+    result[0][2] = clamp(x[0][2], y[0][2], z[0][2]);
>+    result[0][3] = clamp(x[0][3], y[0][3], z[0][3]);
>+    result[1][0] = clamp(x[1][0], y[1][0], z[1][0]);
>+    result[1][1] = clamp(x[1][1], y[1][1], z[1][1]);
>+    result[1][2] = clamp(x[1][2], y[1][2], z[1][2]);
>+    result[1][3] = clamp(x[1][3], y[1][3], z[1][3]);
>+    return result;
>+}
>+half3x2 clamp(half3x2 x, half3x2 y, half3x2 z) {
>+    half3x2 result;
>+    result[0][0] = clamp(x[0][0], y[0][0], z[0][0]);
>+    result[0][1] = clamp(x[0][1], y[0][1], z[0][1]);
>+    result[1][0] = clamp(x[1][0], y[1][0], z[1][0]);
>+    result[1][1] = clamp(x[1][1], y[1][1], z[1][1]);
>+    result[2][0] = clamp(x[2][0], y[2][0], z[2][0]);
>+    result[2][1] = clamp(x[2][1], y[2][1], z[2][1]);
>+    return result;
>+}
>+half3x3 clamp(half3x3 x, half3x3 y, half3x3 z) {
>+    half3x3 result;
>+    result[0][0] = clamp(x[0][0], y[0][0], z[0][0]);
>+    result[0][1] = clamp(x[0][1], y[0][1], z[0][1]);
>+    result[0][2] = clamp(x[0][2], y[0][2], z[0][2]);
>+    result[1][0] = clamp(x[1][0], y[1][0], z[1][0]);
>+    result[1][1] = clamp(x[1][1], y[1][1], z[1][1]);
>+    result[1][2] = clamp(x[1][2], y[1][2], z[1][2]);
>+    result[2][0] = clamp(x[2][0], y[2][0], z[2][0]);
>+    result[2][1] = clamp(x[2][1], y[2][1], z[2][1]);
>+    result[2][2] = clamp(x[2][2], y[2][2], z[2][2]);
>+    return result;
>+}
>+half3x4 clamp(half3x4 x, half3x4 y, half3x4 z) {
>+    half3x4 result;
>+    result[0][0] = clamp(x[0][0], y[0][0], z[0][0]);
>+    result[0][1] = clamp(x[0][1], y[0][1], z[0][1]);
>+    result[0][2] = clamp(x[0][2], y[0][2], z[0][2]);
>+    result[0][3] = clamp(x[0][3], y[0][3], z[0][3]);
>+    result[1][0] = clamp(x[1][0], y[1][0], z[1][0]);
>+    result[1][1] = clamp(x[1][1], y[1][1], z[1][1]);
>+    result[1][2] = clamp(x[1][2], y[1][2], z[1][2]);
>+    result[1][3] = clamp(x[1][3], y[1][3], z[1][3]);
>+    result[2][0] = clamp(x[2][0], y[2][0], z[2][0]);
>+    result[2][1] = clamp(x[2][1], y[2][1], z[2][1]);
>+    result[2][2] = clamp(x[2][2], y[2][2], z[2][2]);
>+    result[2][3] = clamp(x[2][3], y[2][3], z[2][3]);
>+    return result;
>+}
>+half4x2 clamp(half4x2 x, half4x2 y, half4x2 z) {
>+    half4x2 result;
>+    result[0][0] = clamp(x[0][0], y[0][0], z[0][0]);
>+    result[0][1] = clamp(x[0][1], y[0][1], z[0][1]);
>+    result[1][0] = clamp(x[1][0], y[1][0], z[1][0]);
>+    result[1][1] = clamp(x[1][1], y[1][1], z[1][1]);
>+    result[2][0] = clamp(x[2][0], y[2][0], z[2][0]);
>+    result[2][1] = clamp(x[2][1], y[2][1], z[2][1]);
>+    result[3][0] = clamp(x[3][0], y[3][0], z[3][0]);
>+    result[3][1] = clamp(x[3][1], y[3][1], z[3][1]);
>+    return result;
>+}
>+half4x3 clamp(half4x3 x, half4x3 y, half4x3 z) {
>+    half4x3 result;
>+    result[0][0] = clamp(x[0][0], y[0][0], z[0][0]);
>+    result[0][1] = clamp(x[0][1], y[0][1], z[0][1]);
>+    result[0][2] = clamp(x[0][2], y[0][2], z[0][2]);
>+    result[1][0] = clamp(x[1][0], y[1][0], z[1][0]);
>+    result[1][1] = clamp(x[1][1], y[1][1], z[1][1]);
>+    result[1][2] = clamp(x[1][2], y[1][2], z[1][2]);
>+    result[2][0] = clamp(x[2][0], y[2][0], z[2][0]);
>+    result[2][1] = clamp(x[2][1], y[2][1], z[2][1]);
>+    result[2][2] = clamp(x[2][2], y[2][2], z[2][2]);
>+    result[3][0] = clamp(x[3][0], y[3][0], z[3][0]);
>+    result[3][1] = clamp(x[3][1], y[3][1], z[3][1]);
>+    result[3][2] = clamp(x[3][2], y[3][2], z[3][2]);
>+    return result;
>+}
>+half4x4 clamp(half4x4 x, half4x4 y, half4x4 z) {
>+    half4x4 result;
>+    result[0][0] = clamp(x[0][0], y[0][0], z[0][0]);
>+    result[0][1] = clamp(x[0][1], y[0][1], z[0][1]);
>+    result[0][2] = clamp(x[0][2], y[0][2], z[0][2]);
>+    result[0][3] = clamp(x[0][3], y[0][3], z[0][3]);
>+    result[1][0] = clamp(x[1][0], y[1][0], z[1][0]);
>+    result[1][1] = clamp(x[1][1], y[1][1], z[1][1]);
>+    result[1][2] = clamp(x[1][2], y[1][2], z[1][2]);
>+    result[1][3] = clamp(x[1][3], y[1][3], z[1][3]);
>+    result[2][0] = clamp(x[2][0], y[2][0], z[2][0]);
>+    result[2][1] = clamp(x[2][1], y[2][1], z[2][1]);
>+    result[2][2] = clamp(x[2][2], y[2][2], z[2][2]);
>+    result[2][3] = clamp(x[2][3], y[2][3], z[2][3]);
>+    result[3][0] = clamp(x[3][0], y[3][0], z[3][0]);
>+    result[3][1] = clamp(x[3][1], y[3][1], z[3][1]);
>+    result[3][2] = clamp(x[3][2], y[3][2], z[3][2]);
>+    result[3][3] = clamp(x[3][3], y[3][3], z[3][3]);
>+    return result;
>+}
>+
>+float clamp(float x, float lower, float upper) {
>+    return max(min(upper, x), lower);
>+}
>+float2 clamp(float2 x, float2 y, float2 z) {
>+    float2 result;
>+    result[0] = clamp(x[0], y[0], z[0]);
>+    result[1] = clamp(x[1], y[1], z[1]);
>+    return result;
>+}
>+float3 clamp(float3 x, float3 y, float3 z) {
>+    float3 result;
>+    result[0] = clamp(x[0], y[0], z[0]);
>+    result[1] = clamp(x[1], y[1], z[1]);
>+    result[2] = clamp(x[2], y[2], z[2]);
>+    return result;
>+}
>+float4 clamp(float4 x, float4 y, float4 z) {
>+    float4 result;
>+    result[0] = clamp(x[0], y[0], z[0]);
>+    result[1] = clamp(x[1], y[1], z[1]);
>+    result[2] = clamp(x[2], y[2], z[2]);
>+    result[3] = clamp(x[3], y[3], z[3]);
>+    return result;
>+}
>+float2x2 clamp(float2x2 x, float2x2 y, float2x2 z) {
>+    float2x2 result;
>+    result[0][0] = clamp(x[0][0], y[0][0], z[0][0]);
>+    result[0][1] = clamp(x[0][1], y[0][1], z[0][1]);
>+    result[1][0] = clamp(x[1][0], y[1][0], z[1][0]);
>+    result[1][1] = clamp(x[1][1], y[1][1], z[1][1]);
>+    return result;
>+}
>+float2x3 clamp(float2x3 x, float2x3 y, float2x3 z) {
>+    float2x3 result;
>+    result[0][0] = clamp(x[0][0], y[0][0], z[0][0]);
>+    result[0][1] = clamp(x[0][1], y[0][1], z[0][1]);
>+    result[0][2] = clamp(x[0][2], y[0][2], z[0][2]);
>+    result[1][0] = clamp(x[1][0], y[1][0], z[1][0]);
>+    result[1][1] = clamp(x[1][1], y[1][1], z[1][1]);
>+    result[1][2] = clamp(x[1][2], y[1][2], z[1][2]);
>+    return result;
>+}
>+float2x4 clamp(float2x4 x, float2x4 y, float2x4 z) {
>+    float2x4 result;
>+    result[0][0] = clamp(x[0][0], y[0][0], z[0][0]);
>+    result[0][1] = clamp(x[0][1], y[0][1], z[0][1]);
>+    result[0][2] = clamp(x[0][2], y[0][2], z[0][2]);
>+    result[0][3] = clamp(x[0][3], y[0][3], z[0][3]);
>+    result[1][0] = clamp(x[1][0], y[1][0], z[1][0]);
>+    result[1][1] = clamp(x[1][1], y[1][1], z[1][1]);
>+    result[1][2] = clamp(x[1][2], y[1][2], z[1][2]);
>+    result[1][3] = clamp(x[1][3], y[1][3], z[1][3]);
>+    return result;
>+}
>+float3x2 clamp(float3x2 x, float3x2 y, float3x2 z) {
>+    float3x2 result;
>+    result[0][0] = clamp(x[0][0], y[0][0], z[0][0]);
>+    result[0][1] = clamp(x[0][1], y[0][1], z[0][1]);
>+    result[1][0] = clamp(x[1][0], y[1][0], z[1][0]);
>+    result[1][1] = clamp(x[1][1], y[1][1], z[1][1]);
>+    result[2][0] = clamp(x[2][0], y[2][0], z[2][0]);
>+    result[2][1] = clamp(x[2][1], y[2][1], z[2][1]);
>+    return result;
>+}
>+float3x3 clamp(float3x3 x, float3x3 y, float3x3 z) {
>+    float3x3 result;
>+    result[0][0] = clamp(x[0][0], y[0][0], z[0][0]);
>+    result[0][1] = clamp(x[0][1], y[0][1], z[0][1]);
>+    result[0][2] = clamp(x[0][2], y[0][2], z[0][2]);
>+    result[1][0] = clamp(x[1][0], y[1][0], z[1][0]);
>+    result[1][1] = clamp(x[1][1], y[1][1], z[1][1]);
>+    result[1][2] = clamp(x[1][2], y[1][2], z[1][2]);
>+    result[2][0] = clamp(x[2][0], y[2][0], z[2][0]);
>+    result[2][1] = clamp(x[2][1], y[2][1], z[2][1]);
>+    result[2][2] = clamp(x[2][2], y[2][2], z[2][2]);
>+    return result;
>+}
>+float3x4 clamp(float3x4 x, float3x4 y, float3x4 z) {
>+    float3x4 result;
>+    result[0][0] = clamp(x[0][0], y[0][0], z[0][0]);
>+    result[0][1] = clamp(x[0][1], y[0][1], z[0][1]);
>+    result[0][2] = clamp(x[0][2], y[0][2], z[0][2]);
>+    result[0][3] = clamp(x[0][3], y[0][3], z[0][3]);
>+    result[1][0] = clamp(x[1][0], y[1][0], z[1][0]);
>+    result[1][1] = clamp(x[1][1], y[1][1], z[1][1]);
>+    result[1][2] = clamp(x[1][2], y[1][2], z[1][2]);
>+    result[1][3] = clamp(x[1][3], y[1][3], z[1][3]);
>+    result[2][0] = clamp(x[2][0], y[2][0], z[2][0]);
>+    result[2][1] = clamp(x[2][1], y[2][1], z[2][1]);
>+    result[2][2] = clamp(x[2][2], y[2][2], z[2][2]);
>+    result[2][3] = clamp(x[2][3], y[2][3], z[2][3]);
>+    return result;
>+}
>+float4x2 clamp(float4x2 x, float4x2 y, float4x2 z) {
>+    float4x2 result;
>+    result[0][0] = clamp(x[0][0], y[0][0], z[0][0]);
>+    result[0][1] = clamp(x[0][1], y[0][1], z[0][1]);
>+    result[1][0] = clamp(x[1][0], y[1][0], z[1][0]);
>+    result[1][1] = clamp(x[1][1], y[1][1], z[1][1]);
>+    result[2][0] = clamp(x[2][0], y[2][0], z[2][0]);
>+    result[2][1] = clamp(x[2][1], y[2][1], z[2][1]);
>+    result[3][0] = clamp(x[3][0], y[3][0], z[3][0]);
>+    result[3][1] = clamp(x[3][1], y[3][1], z[3][1]);
>+    return result;
>+}
>+float4x3 clamp(float4x3 x, float4x3 y, float4x3 z) {
>+    float4x3 result;
>+    result[0][0] = clamp(x[0][0], y[0][0], z[0][0]);
>+    result[0][1] = clamp(x[0][1], y[0][1], z[0][1]);
>+    result[0][2] = clamp(x[0][2], y[0][2], z[0][2]);
>+    result[1][0] = clamp(x[1][0], y[1][0], z[1][0]);
>+    result[1][1] = clamp(x[1][1], y[1][1], z[1][1]);
>+    result[1][2] = clamp(x[1][2], y[1][2], z[1][2]);
>+    result[2][0] = clamp(x[2][0], y[2][0], z[2][0]);
>+    result[2][1] = clamp(x[2][1], y[2][1], z[2][1]);
>+    result[2][2] = clamp(x[2][2], y[2][2], z[2][2]);
>+    result[3][0] = clamp(x[3][0], y[3][0], z[3][0]);
>+    result[3][1] = clamp(x[3][1], y[3][1], z[3][1]);
>+    result[3][2] = clamp(x[3][2], y[3][2], z[3][2]);
>+    return result;
>+}
>+float4x4 clamp(float4x4 x, float4x4 y, float4x4 z) {
>+    float4x4 result;
>+    result[0][0] = clamp(x[0][0], y[0][0], z[0][0]);
>+    result[0][1] = clamp(x[0][1], y[0][1], z[0][1]);
>+    result[0][2] = clamp(x[0][2], y[0][2], z[0][2]);
>+    result[0][3] = clamp(x[0][3], y[0][3], z[0][3]);
>+    result[1][0] = clamp(x[1][0], y[1][0], z[1][0]);
>+    result[1][1] = clamp(x[1][1], y[1][1], z[1][1]);
>+    result[1][2] = clamp(x[1][2], y[1][2], z[1][2]);
>+    result[1][3] = clamp(x[1][3], y[1][3], z[1][3]);
>+    result[2][0] = clamp(x[2][0], y[2][0], z[2][0]);
>+    result[2][1] = clamp(x[2][1], y[2][1], z[2][1]);
>+    result[2][2] = clamp(x[2][2], y[2][2], z[2][2]);
>+    result[2][3] = clamp(x[2][3], y[2][3], z[2][3]);
>+    result[3][0] = clamp(x[3][0], y[3][0], z[3][0]);
>+    result[3][1] = clamp(x[3][1], y[3][1], z[3][1]);
>+    result[3][2] = clamp(x[3][2], y[3][2], z[3][2]);
>+    result[3][3] = clamp(x[3][3], y[3][3], z[3][3]);
>+    return result;
>+}
>+
>+
>+/* Functions named operator.wxxy */
>+bool4 operator.wxxy(bool4 v) {
>+    bool4 result;
>+    result.x = v.w;
>+    result.y = v.x;
>+    result.z = v.x;
>+    result.w = v.y;
>+    return result;
>+}
>+uchar4 operator.wxxy(uchar4 v) {
>+    uchar4 result;
>+    result.x = v.w;
>+    result.y = v.x;
>+    result.z = v.x;
>+    result.w = v.y;
>+    return result;
>+}
>+ushort4 operator.wxxy(ushort4 v) {
>+    ushort4 result;
>+    result.x = v.w;
>+    result.y = v.x;
>+    result.z = v.x;
>+    result.w = v.y;
>+    return result;
>+}
>+uint4 operator.wxxy(uint4 v) {
>+    uint4 result;
>+    result.x = v.w;
>+    result.y = v.x;
>+    result.z = v.x;
>+    result.w = v.y;
>+    return result;
>+}
>+char4 operator.wxxy(char4 v) {
>+    char4 result;
>+    result.x = v.w;
>+    result.y = v.x;
>+    result.z = v.x;
>+    result.w = v.y;
>+    return result;
>+}
>+short4 operator.wxxy(short4 v) {
>+    short4 result;
>+    result.x = v.w;
>+    result.y = v.x;
>+    result.z = v.x;
>+    result.w = v.y;
>+    return result;
>+}
>+int4 operator.wxxy(int4 v) {
>+    int4 result;
>+    result.x = v.w;
>+    result.y = v.x;
>+    result.z = v.x;
>+    result.w = v.y;
>+    return result;
>+}
>+half4 operator.wxxy(half4 v) {
>+    half4 result;
>+    result.x = v.w;
>+    result.y = v.x;
>+    result.z = v.x;
>+    result.w = v.y;
>+    return result;
>+}
>+float4 operator.wxxy(float4 v) {
>+    float4 result;
>+    result.x = v.w;
>+    result.y = v.x;
>+    result.z = v.x;
>+    result.w = v.y;
>+    return result;
>+}
>+
>+/* Functions named operator.yxwy */
>+bool4 operator.yxwy(bool4 v) {
>+    bool4 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.w;
>+    result.w = v.y;
>+    return result;
>+}
>+uchar4 operator.yxwy(uchar4 v) {
>+    uchar4 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.w;
>+    result.w = v.y;
>+    return result;
>+}
>+ushort4 operator.yxwy(ushort4 v) {
>+    ushort4 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.w;
>+    result.w = v.y;
>+    return result;
>+}
>+uint4 operator.yxwy(uint4 v) {
>+    uint4 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.w;
>+    result.w = v.y;
>+    return result;
>+}
>+char4 operator.yxwy(char4 v) {
>+    char4 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.w;
>+    result.w = v.y;
>+    return result;
>+}
>+short4 operator.yxwy(short4 v) {
>+    short4 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.w;
>+    result.w = v.y;
>+    return result;
>+}
>+int4 operator.yxwy(int4 v) {
>+    int4 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.w;
>+    result.w = v.y;
>+    return result;
>+}
>+half4 operator.yxwy(half4 v) {
>+    half4 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.w;
>+    result.w = v.y;
>+    return result;
>+}
>+float4 operator.yxwy(float4 v) {
>+    float4 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.w;
>+    result.w = v.y;
>+    return result;
>+}
>+
>+/* Functions named operator.xwy */
>+bool3 operator.xwy(bool4 v) {
>+    bool3 result;
>+    result.x = v.x;
>+    result.y = v.w;
>+    result.z = v.y;
>+    return result;
>+}
>+uchar3 operator.xwy(uchar4 v) {
>+    uchar3 result;
>+    result.x = v.x;
>+    result.y = v.w;
>+    result.z = v.y;
>+    return result;
>+}
>+ushort3 operator.xwy(ushort4 v) {
>+    ushort3 result;
>+    result.x = v.x;
>+    result.y = v.w;
>+    result.z = v.y;
>+    return result;
>+}
>+uint3 operator.xwy(uint4 v) {
>+    uint3 result;
>+    result.x = v.x;
>+    result.y = v.w;
>+    result.z = v.y;
>+    return result;
>+}
>+char3 operator.xwy(char4 v) {
>+    char3 result;
>+    result.x = v.x;
>+    result.y = v.w;
>+    result.z = v.y;
>+    return result;
>+}
>+short3 operator.xwy(short4 v) {
>+    short3 result;
>+    result.x = v.x;
>+    result.y = v.w;
>+    result.z = v.y;
>+    return result;
>+}
>+int3 operator.xwy(int4 v) {
>+    int3 result;
>+    result.x = v.x;
>+    result.y = v.w;
>+    result.z = v.y;
>+    return result;
>+}
>+half3 operator.xwy(half4 v) {
>+    half3 result;
>+    result.x = v.x;
>+    result.y = v.w;
>+    result.z = v.y;
>+    return result;
>+}
>+float3 operator.xwy(float4 v) {
>+    float3 result;
>+    result.x = v.x;
>+    result.y = v.w;
>+    result.z = v.y;
>+    return result;
>+}
>+
>+/* Functions named operator< */
>+native bool operator<(int, int);
>+native bool operator<(uint, uint);
>+native bool operator<(float, float);
>+bool operator<(uchar a, uchar b) {
>+    return uint(a) < uint(b);
>+}
>+bool operator<(ushort a, ushort b) {
>+    return uint(a) < uint(b);
>+}
>+bool operator<(char a, char b) {
>+    return int(a) < int(b);
>+}
>+bool operator<(short a, short b) {
>+    return int(a) < int(b);
>+}
>+bool operator<(half a, half b) {
>+    return float(a) < float(b);
>+}
>+
>+/* Functions named operator.wyw */
>+bool3 operator.wyw(bool4 v) {
>+    bool3 result;
>+    result.x = v.w;
>+    result.y = v.y;
>+    result.z = v.w;
>+    return result;
>+}
>+uchar3 operator.wyw(uchar4 v) {
>+    uchar3 result;
>+    result.x = v.w;
>+    result.y = v.y;
>+    result.z = v.w;
>+    return result;
>+}
>+ushort3 operator.wyw(ushort4 v) {
>+    ushort3 result;
>+    result.x = v.w;
>+    result.y = v.y;
>+    result.z = v.w;
>+    return result;
>+}
>+uint3 operator.wyw(uint4 v) {
>+    uint3 result;
>+    result.x = v.w;
>+    result.y = v.y;
>+    result.z = v.w;
>+    return result;
>+}
>+char3 operator.wyw(char4 v) {
>+    char3 result;
>+    result.x = v.w;
>+    result.y = v.y;
>+    result.z = v.w;
>+    return result;
>+}
>+short3 operator.wyw(short4 v) {
>+    short3 result;
>+    result.x = v.w;
>+    result.y = v.y;
>+    result.z = v.w;
>+    return result;
>+}
>+int3 operator.wyw(int4 v) {
>+    int3 result;
>+    result.x = v.w;
>+    result.y = v.y;
>+    result.z = v.w;
>+    return result;
>+}
>+half3 operator.wyw(half4 v) {
>+    half3 result;
>+    result.x = v.w;
>+    result.y = v.y;
>+    result.z = v.w;
>+    return result;
>+}
>+float3 operator.wyw(float4 v) {
>+    float3 result;
>+    result.x = v.w;
>+    result.y = v.y;
>+    result.z = v.w;
>+    return result;
>+}
>+
>+/* Functions named operator.zzyw */
>+bool4 operator.zzyw(bool4 v) {
>+    bool4 result;
>+    result.x = v.z;
>+    result.y = v.z;
>+    result.z = v.y;
>+    result.w = v.w;
>+    return result;
>+}
>+uchar4 operator.zzyw(uchar4 v) {
>+    uchar4 result;
>+    result.x = v.z;
>+    result.y = v.z;
>+    result.z = v.y;
>+    result.w = v.w;
>+    return result;
>+}
>+ushort4 operator.zzyw(ushort4 v) {
>+    ushort4 result;
>+    result.x = v.z;
>+    result.y = v.z;
>+    result.z = v.y;
>+    result.w = v.w;
>+    return result;
>+}
>+uint4 operator.zzyw(uint4 v) {
>+    uint4 result;
>+    result.x = v.z;
>+    result.y = v.z;
>+    result.z = v.y;
>+    result.w = v.w;
>+    return result;
>+}
>+char4 operator.zzyw(char4 v) {
>+    char4 result;
>+    result.x = v.z;
>+    result.y = v.z;
>+    result.z = v.y;
>+    result.w = v.w;
>+    return result;
>+}
>+short4 operator.zzyw(short4 v) {
>+    short4 result;
>+    result.x = v.z;
>+    result.y = v.z;
>+    result.z = v.y;
>+    result.w = v.w;
>+    return result;
>+}
>+int4 operator.zzyw(int4 v) {
>+    int4 result;
>+    result.x = v.z;
>+    result.y = v.z;
>+    result.z = v.y;
>+    result.w = v.w;
>+    return result;
>+}
>+half4 operator.zzyw(half4 v) {
>+    half4 result;
>+    result.x = v.z;
>+    result.y = v.z;
>+    result.z = v.y;
>+    result.w = v.w;
>+    return result;
>+}
>+float4 operator.zzyw(float4 v) {
>+    float4 result;
>+    result.x = v.z;
>+    result.y = v.z;
>+    result.z = v.y;
>+    result.w = v.w;
>+    return result;
>+}
>+
>+/* Functions named operator.zxz */
>+bool3 operator.zxz(bool3 v) {
>+    bool3 result;
>+    result.x = v.z;
>+    result.y = v.x;
>+    result.z = v.z;
>+    return result;
>+}
>+bool3 operator.zxz(bool4 v) {
>+    bool3 result;
>+    result.x = v.z;
>+    result.y = v.x;
>+    result.z = v.z;
>+    return result;
>+}
>+uchar3 operator.zxz(uchar3 v) {
>+    uchar3 result;
>+    result.x = v.z;
>+    result.y = v.x;
>+    result.z = v.z;
>+    return result;
>+}
>+uchar3 operator.zxz(uchar4 v) {
>+    uchar3 result;
>+    result.x = v.z;
>+    result.y = v.x;
>+    result.z = v.z;
>+    return result;
>+}
>+ushort3 operator.zxz(ushort3 v) {
>+    ushort3 result;
>+    result.x = v.z;
>+    result.y = v.x;
>+    result.z = v.z;
>+    return result;
>+}
>+ushort3 operator.zxz(ushort4 v) {
>+    ushort3 result;
>+    result.x = v.z;
>+    result.y = v.x;
>+    result.z = v.z;
>+    return result;
>+}
>+uint3 operator.zxz(uint3 v) {
>+    uint3 result;
>+    result.x = v.z;
>+    result.y = v.x;
>+    result.z = v.z;
>+    return result;
>+}
>+uint3 operator.zxz(uint4 v) {
>+    uint3 result;
>+    result.x = v.z;
>+    result.y = v.x;
>+    result.z = v.z;
>+    return result;
>+}
>+char3 operator.zxz(char3 v) {
>+    char3 result;
>+    result.x = v.z;
>+    result.y = v.x;
>+    result.z = v.z;
>+    return result;
>+}
>+char3 operator.zxz(char4 v) {
>+    char3 result;
>+    result.x = v.z;
>+    result.y = v.x;
>+    result.z = v.z;
>+    return result;
>+}
>+short3 operator.zxz(short3 v) {
>+    short3 result;
>+    result.x = v.z;
>+    result.y = v.x;
>+    result.z = v.z;
>+    return result;
>+}
>+short3 operator.zxz(short4 v) {
>+    short3 result;
>+    result.x = v.z;
>+    result.y = v.x;
>+    result.z = v.z;
>+    return result;
>+}
>+int3 operator.zxz(int3 v) {
>+    int3 result;
>+    result.x = v.z;
>+    result.y = v.x;
>+    result.z = v.z;
>+    return result;
>+}
>+int3 operator.zxz(int4 v) {
>+    int3 result;
>+    result.x = v.z;
>+    result.y = v.x;
>+    result.z = v.z;
>+    return result;
>+}
>+half3 operator.zxz(half3 v) {
>+    half3 result;
>+    result.x = v.z;
>+    result.y = v.x;
>+    result.z = v.z;
>+    return result;
>+}
>+half3 operator.zxz(half4 v) {
>+    half3 result;
>+    result.x = v.z;
>+    result.y = v.x;
>+    result.z = v.z;
>+    return result;
>+}
>+float3 operator.zxz(float3 v) {
>+    float3 result;
>+    result.x = v.z;
>+    result.y = v.x;
>+    result.z = v.z;
>+    return result;
>+}
>+float3 operator.zxz(float4 v) {
>+    float3 result;
>+    result.x = v.z;
>+    result.y = v.x;
>+    result.z = v.z;
>+    return result;
>+}
>+
>+/* Functions named operator.ywzx */
>+bool4 operator.ywzx(bool4 v) {
>+    bool4 result;
>+    result.x = v.y;
>+    result.y = v.w;
>+    result.z = v.z;
>+    result.w = v.x;
>+    return result;
>+}
>+uchar4 operator.ywzx(uchar4 v) {
>+    uchar4 result;
>+    result.x = v.y;
>+    result.y = v.w;
>+    result.z = v.z;
>+    result.w = v.x;
>+    return result;
>+}
>+ushort4 operator.ywzx(ushort4 v) {
>+    ushort4 result;
>+    result.x = v.y;
>+    result.y = v.w;
>+    result.z = v.z;
>+    result.w = v.x;
>+    return result;
>+}
>+uint4 operator.ywzx(uint4 v) {
>+    uint4 result;
>+    result.x = v.y;
>+    result.y = v.w;
>+    result.z = v.z;
>+    result.w = v.x;
>+    return result;
>+}
>+char4 operator.ywzx(char4 v) {
>+    char4 result;
>+    result.x = v.y;
>+    result.y = v.w;
>+    result.z = v.z;
>+    result.w = v.x;
>+    return result;
>+}
>+short4 operator.ywzx(short4 v) {
>+    short4 result;
>+    result.x = v.y;
>+    result.y = v.w;
>+    result.z = v.z;
>+    result.w = v.x;
>+    return result;
>+}
>+int4 operator.ywzx(int4 v) {
>+    int4 result;
>+    result.x = v.y;
>+    result.y = v.w;
>+    result.z = v.z;
>+    result.w = v.x;
>+    return result;
>+}
>+half4 operator.ywzx(half4 v) {
>+    half4 result;
>+    result.x = v.y;
>+    result.y = v.w;
>+    result.z = v.z;
>+    result.w = v.x;
>+    return result;
>+}
>+float4 operator.ywzx(float4 v) {
>+    float4 result;
>+    result.x = v.y;
>+    result.y = v.w;
>+    result.z = v.z;
>+    result.w = v.x;
>+    return result;
>+}
>+
>+/* Functions named operator.zxxy */
>+bool4 operator.zxxy(bool3 v) {
>+    bool4 result;
>+    result.x = v.z;
>+    result.y = v.x;
>+    result.z = v.x;
>+    result.w = v.y;
>+    return result;
>+}
>+bool4 operator.zxxy(bool4 v) {
>+    bool4 result;
>+    result.x = v.z;
>+    result.y = v.x;
>+    result.z = v.x;
>+    result.w = v.y;
>+    return result;
>+}
>+uchar4 operator.zxxy(uchar3 v) {
>+    uchar4 result;
>+    result.x = v.z;
>+    result.y = v.x;
>+    result.z = v.x;
>+    result.w = v.y;
>+    return result;
>+}
>+uchar4 operator.zxxy(uchar4 v) {
>+    uchar4 result;
>+    result.x = v.z;
>+    result.y = v.x;
>+    result.z = v.x;
>+    result.w = v.y;
>+    return result;
>+}
>+ushort4 operator.zxxy(ushort3 v) {
>+    ushort4 result;
>+    result.x = v.z;
>+    result.y = v.x;
>+    result.z = v.x;
>+    result.w = v.y;
>+    return result;
>+}
>+ushort4 operator.zxxy(ushort4 v) {
>+    ushort4 result;
>+    result.x = v.z;
>+    result.y = v.x;
>+    result.z = v.x;
>+    result.w = v.y;
>+    return result;
>+}
>+uint4 operator.zxxy(uint3 v) {
>+    uint4 result;
>+    result.x = v.z;
>+    result.y = v.x;
>+    result.z = v.x;
>+    result.w = v.y;
>+    return result;
>+}
>+uint4 operator.zxxy(uint4 v) {
>+    uint4 result;
>+    result.x = v.z;
>+    result.y = v.x;
>+    result.z = v.x;
>+    result.w = v.y;
>+    return result;
>+}
>+char4 operator.zxxy(char3 v) {
>+    char4 result;
>+    result.x = v.z;
>+    result.y = v.x;
>+    result.z = v.x;
>+    result.w = v.y;
>+    return result;
>+}
>+char4 operator.zxxy(char4 v) {
>+    char4 result;
>+    result.x = v.z;
>+    result.y = v.x;
>+    result.z = v.x;
>+    result.w = v.y;
>+    return result;
>+}
>+short4 operator.zxxy(short3 v) {
>+    short4 result;
>+    result.x = v.z;
>+    result.y = v.x;
>+    result.z = v.x;
>+    result.w = v.y;
>+    return result;
>+}
>+short4 operator.zxxy(short4 v) {
>+    short4 result;
>+    result.x = v.z;
>+    result.y = v.x;
>+    result.z = v.x;
>+    result.w = v.y;
>+    return result;
>+}
>+int4 operator.zxxy(int3 v) {
>+    int4 result;
>+    result.x = v.z;
>+    result.y = v.x;
>+    result.z = v.x;
>+    result.w = v.y;
>+    return result;
>+}
>+int4 operator.zxxy(int4 v) {
>+    int4 result;
>+    result.x = v.z;
>+    result.y = v.x;
>+    result.z = v.x;
>+    result.w = v.y;
>+    return result;
>+}
>+half4 operator.zxxy(half3 v) {
>+    half4 result;
>+    result.x = v.z;
>+    result.y = v.x;
>+    result.z = v.x;
>+    result.w = v.y;
>+    return result;
>+}
>+half4 operator.zxxy(half4 v) {
>+    half4 result;
>+    result.x = v.z;
>+    result.y = v.x;
>+    result.z = v.x;
>+    result.w = v.y;
>+    return result;
>+}
>+float4 operator.zxxy(float3 v) {
>+    float4 result;
>+    result.x = v.z;
>+    result.y = v.x;
>+    result.z = v.x;
>+    result.w = v.y;
>+    return result;
>+}
>+float4 operator.zxxy(float4 v) {
>+    float4 result;
>+    result.x = v.z;
>+    result.y = v.x;
>+    result.z = v.x;
>+    result.w = v.y;
>+    return result;
>+}
>+
>+/* Functions named isnan */
>+native bool isnan(float);
>+bool isnan(half x) {
>+    return isnan(float(x));
>+}
>+bool2 isnan(half2 x) {
>+    bool2 result;
>+    result[0] = isnan(x[0]);
>+    result[1] = isnan(x[1]);
>+    return result;
>+}
>+bool3 isnan(half3 x) {
>+    bool3 result;
>+    result[0] = isnan(x[0]);
>+    result[1] = isnan(x[1]);
>+    result[2] = isnan(x[2]);
>+    return result;
>+}
>+bool4 isnan(half4 x) {
>+    bool4 result;
>+    result[0] = isnan(x[0]);
>+    result[1] = isnan(x[1]);
>+    result[2] = isnan(x[2]);
>+    result[3] = isnan(x[3]);
>+    return result;
>+}
>+
>+bool2 isnan(float2 x) {
>+    bool2 result;
>+    result[0] = isnan(x[0]);
>+    result[1] = isnan(x[1]);
>+    return result;
>+}
>+bool3 isnan(float3 x) {
>+    bool3 result;
>+    result[0] = isnan(x[0]);
>+    result[1] = isnan(x[1]);
>+    result[2] = isnan(x[2]);
>+    return result;
>+}
>+bool4 isnan(float4 x) {
>+    bool4 result;
>+    result[0] = isnan(x[0]);
>+    result[1] = isnan(x[1]);
>+    result[2] = isnan(x[2]);
>+    result[3] = isnan(x[3]);
>+    return result;
>+}
>+
>+
>+/* Functions named operator.xxww */
>+bool4 operator.xxww(bool4 v) {
>+    bool4 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.w;
>+    result.w = v.w;
>+    return result;
>+}
>+uchar4 operator.xxww(uchar4 v) {
>+    uchar4 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.w;
>+    result.w = v.w;
>+    return result;
>+}
>+ushort4 operator.xxww(ushort4 v) {
>+    ushort4 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.w;
>+    result.w = v.w;
>+    return result;
>+}
>+uint4 operator.xxww(uint4 v) {
>+    uint4 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.w;
>+    result.w = v.w;
>+    return result;
>+}
>+char4 operator.xxww(char4 v) {
>+    char4 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.w;
>+    result.w = v.w;
>+    return result;
>+}
>+short4 operator.xxww(short4 v) {
>+    short4 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.w;
>+    result.w = v.w;
>+    return result;
>+}
>+int4 operator.xxww(int4 v) {
>+    int4 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.w;
>+    result.w = v.w;
>+    return result;
>+}
>+half4 operator.xxww(half4 v) {
>+    half4 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.w;
>+    result.w = v.w;
>+    return result;
>+}
>+float4 operator.xxww(float4 v) {
>+    float4 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.w;
>+    result.w = v.w;
>+    return result;
>+}
>+
>+/* Functions named operator.xwy= */
>+bool4 operator.xwy=(bool4 v, bool3 c) {
>+    bool4 result = v;
>+    result.x = c.x;
>+    result.w = c.y;
>+    result.y = c.z;
>+    return result;
>+}
>+uchar4 operator.xwy=(uchar4 v, uchar3 c) {
>+    uchar4 result = v;
>+    result.x = c.x;
>+    result.w = c.y;
>+    result.y = c.z;
>+    return result;
>+}
>+ushort4 operator.xwy=(ushort4 v, ushort3 c) {
>+    ushort4 result = v;
>+    result.x = c.x;
>+    result.w = c.y;
>+    result.y = c.z;
>+    return result;
>+}
>+uint4 operator.xwy=(uint4 v, uint3 c) {
>+    uint4 result = v;
>+    result.x = c.x;
>+    result.w = c.y;
>+    result.y = c.z;
>+    return result;
>+}
>+char4 operator.xwy=(char4 v, char3 c) {
>+    char4 result = v;
>+    result.x = c.x;
>+    result.w = c.y;
>+    result.y = c.z;
>+    return result;
>+}
>+short4 operator.xwy=(short4 v, short3 c) {
>+    short4 result = v;
>+    result.x = c.x;
>+    result.w = c.y;
>+    result.y = c.z;
>+    return result;
>+}
>+int4 operator.xwy=(int4 v, int3 c) {
>+    int4 result = v;
>+    result.x = c.x;
>+    result.w = c.y;
>+    result.y = c.z;
>+    return result;
>+}
>+half4 operator.xwy=(half4 v, half3 c) {
>+    half4 result = v;
>+    result.x = c.x;
>+    result.w = c.y;
>+    result.y = c.z;
>+    return result;
>+}
>+float4 operator.xwy=(float4 v, float3 c) {
>+    float4 result = v;
>+    result.x = c.x;
>+    result.w = c.y;
>+    result.y = c.z;
>+    return result;
>+}
>+
>+/* Functions named AllMemoryBarrierWithGroupSync */
>+native void AllMemoryBarrierWithGroupSync();
>+
>+/* Functions named operator.yx= */
>+bool2 operator.yx=(bool2 v, bool2 c) {
>+    bool2 result = v;
>+    result.y = c.x;
>+    result.x = c.y;
>+    return result;
>+}
>+bool3 operator.yx=(bool3 v, bool2 c) {
>+    bool3 result = v;
>+    result.y = c.x;
>+    result.x = c.y;
>+    return result;
>+}
>+bool4 operator.yx=(bool4 v, bool2 c) {
>+    bool4 result = v;
>+    result.y = c.x;
>+    result.x = c.y;
>+    return result;
>+}
>+uchar2 operator.yx=(uchar2 v, uchar2 c) {
>+    uchar2 result = v;
>+    result.y = c.x;
>+    result.x = c.y;
>+    return result;
>+}
>+uchar3 operator.yx=(uchar3 v, uchar2 c) {
>+    uchar3 result = v;
>+    result.y = c.x;
>+    result.x = c.y;
>+    return result;
>+}
>+uchar4 operator.yx=(uchar4 v, uchar2 c) {
>+    uchar4 result = v;
>+    result.y = c.x;
>+    result.x = c.y;
>+    return result;
>+}
>+ushort2 operator.yx=(ushort2 v, ushort2 c) {
>+    ushort2 result = v;
>+    result.y = c.x;
>+    result.x = c.y;
>+    return result;
>+}
>+ushort3 operator.yx=(ushort3 v, ushort2 c) {
>+    ushort3 result = v;
>+    result.y = c.x;
>+    result.x = c.y;
>+    return result;
>+}
>+ushort4 operator.yx=(ushort4 v, ushort2 c) {
>+    ushort4 result = v;
>+    result.y = c.x;
>+    result.x = c.y;
>+    return result;
>+}
>+uint2 operator.yx=(uint2 v, uint2 c) {
>+    uint2 result = v;
>+    result.y = c.x;
>+    result.x = c.y;
>+    return result;
>+}
>+uint3 operator.yx=(uint3 v, uint2 c) {
>+    uint3 result = v;
>+    result.y = c.x;
>+    result.x = c.y;
>+    return result;
>+}
>+uint4 operator.yx=(uint4 v, uint2 c) {
>+    uint4 result = v;
>+    result.y = c.x;
>+    result.x = c.y;
>+    return result;
>+}
>+char2 operator.yx=(char2 v, char2 c) {
>+    char2 result = v;
>+    result.y = c.x;
>+    result.x = c.y;
>+    return result;
>+}
>+char3 operator.yx=(char3 v, char2 c) {
>+    char3 result = v;
>+    result.y = c.x;
>+    result.x = c.y;
>+    return result;
>+}
>+char4 operator.yx=(char4 v, char2 c) {
>+    char4 result = v;
>+    result.y = c.x;
>+    result.x = c.y;
>+    return result;
>+}
>+short2 operator.yx=(short2 v, short2 c) {
>+    short2 result = v;
>+    result.y = c.x;
>+    result.x = c.y;
>+    return result;
>+}
>+short3 operator.yx=(short3 v, short2 c) {
>+    short3 result = v;
>+    result.y = c.x;
>+    result.x = c.y;
>+    return result;
>+}
>+short4 operator.yx=(short4 v, short2 c) {
>+    short4 result = v;
>+    result.y = c.x;
>+    result.x = c.y;
>+    return result;
>+}
>+int2 operator.yx=(int2 v, int2 c) {
>+    int2 result = v;
>+    result.y = c.x;
>+    result.x = c.y;
>+    return result;
>+}
>+int3 operator.yx=(int3 v, int2 c) {
>+    int3 result = v;
>+    result.y = c.x;
>+    result.x = c.y;
>+    return result;
>+}
>+int4 operator.yx=(int4 v, int2 c) {
>+    int4 result = v;
>+    result.y = c.x;
>+    result.x = c.y;
>+    return result;
>+}
>+half2 operator.yx=(half2 v, half2 c) {
>+    half2 result = v;
>+    result.y = c.x;
>+    result.x = c.y;
>+    return result;
>+}
>+half3 operator.yx=(half3 v, half2 c) {
>+    half3 result = v;
>+    result.y = c.x;
>+    result.x = c.y;
>+    return result;
>+}
>+half4 operator.yx=(half4 v, half2 c) {
>+    half4 result = v;
>+    result.y = c.x;
>+    result.x = c.y;
>+    return result;
>+}
>+float2 operator.yx=(float2 v, float2 c) {
>+    float2 result = v;
>+    result.y = c.x;
>+    result.x = c.y;
>+    return result;
>+}
>+float3 operator.yx=(float3 v, float2 c) {
>+    float3 result = v;
>+    result.y = c.x;
>+    result.x = c.y;
>+    return result;
>+}
>+float4 operator.yx=(float4 v, float2 c) {
>+    float4 result = v;
>+    result.y = c.x;
>+    result.x = c.y;
>+    return result;
>+}
>+
>+/* Functions named operator^ */
>+bool operator^(bool a, bool b) {
>+    if (a)
>+        return !b;
>+    return b;
>+}
>+native int operator^(int, int);
>+native uint operator^(uint, uint);
>+uchar operator^(uchar a, uchar b) {
>+    return uchar(uint(a) ^ uint(b));
>+}
>+ushort operator^(ushort a, ushort b) {
>+    return ushort(uint(a) ^ uint(b));
>+}
>+char operator^(char a, char b) {
>+    return char(int(a) ^ int(b));
>+}
>+short operator^(short a, short b) {
>+    return short(int(a) ^ int(b));
>+}
>+
>+/* Functions named operator.yzyw */
>+bool4 operator.yzyw(bool4 v) {
>+    bool4 result;
>+    result.x = v.y;
>+    result.y = v.z;
>+    result.z = v.y;
>+    result.w = v.w;
>+    return result;
>+}
>+uchar4 operator.yzyw(uchar4 v) {
>+    uchar4 result;
>+    result.x = v.y;
>+    result.y = v.z;
>+    result.z = v.y;
>+    result.w = v.w;
>+    return result;
>+}
>+ushort4 operator.yzyw(ushort4 v) {
>+    ushort4 result;
>+    result.x = v.y;
>+    result.y = v.z;
>+    result.z = v.y;
>+    result.w = v.w;
>+    return result;
>+}
>+uint4 operator.yzyw(uint4 v) {
>+    uint4 result;
>+    result.x = v.y;
>+    result.y = v.z;
>+    result.z = v.y;
>+    result.w = v.w;
>+    return result;
>+}
>+char4 operator.yzyw(char4 v) {
>+    char4 result;
>+    result.x = v.y;
>+    result.y = v.z;
>+    result.z = v.y;
>+    result.w = v.w;
>+    return result;
>+}
>+short4 operator.yzyw(short4 v) {
>+    short4 result;
>+    result.x = v.y;
>+    result.y = v.z;
>+    result.z = v.y;
>+    result.w = v.w;
>+    return result;
>+}
>+int4 operator.yzyw(int4 v) {
>+    int4 result;
>+    result.x = v.y;
>+    result.y = v.z;
>+    result.z = v.y;
>+    result.w = v.w;
>+    return result;
>+}
>+half4 operator.yzyw(half4 v) {
>+    half4 result;
>+    result.x = v.y;
>+    result.y = v.z;
>+    result.z = v.y;
>+    result.w = v.w;
>+    return result;
>+}
>+float4 operator.yzyw(float4 v) {
>+    float4 result;
>+    result.x = v.y;
>+    result.y = v.z;
>+    result.z = v.y;
>+    result.w = v.w;
>+    return result;
>+}
>+
>+/* Functions named operator.xwwz */
>+bool4 operator.xwwz(bool4 v) {
>+    bool4 result;
>+    result.x = v.x;
>+    result.y = v.w;
>+    result.z = v.w;
>+    result.w = v.z;
>+    return result;
>+}
>+uchar4 operator.xwwz(uchar4 v) {
>+    uchar4 result;
>+    result.x = v.x;
>+    result.y = v.w;
>+    result.z = v.w;
>+    result.w = v.z;
>+    return result;
>+}
>+ushort4 operator.xwwz(ushort4 v) {
>+    ushort4 result;
>+    result.x = v.x;
>+    result.y = v.w;
>+    result.z = v.w;
>+    result.w = v.z;
>+    return result;
>+}
>+uint4 operator.xwwz(uint4 v) {
>+    uint4 result;
>+    result.x = v.x;
>+    result.y = v.w;
>+    result.z = v.w;
>+    result.w = v.z;
>+    return result;
>+}
>+char4 operator.xwwz(char4 v) {
>+    char4 result;
>+    result.x = v.x;
>+    result.y = v.w;
>+    result.z = v.w;
>+    result.w = v.z;
>+    return result;
>+}
>+short4 operator.xwwz(short4 v) {
>+    short4 result;
>+    result.x = v.x;
>+    result.y = v.w;
>+    result.z = v.w;
>+    result.w = v.z;
>+    return result;
>+}
>+int4 operator.xwwz(int4 v) {
>+    int4 result;
>+    result.x = v.x;
>+    result.y = v.w;
>+    result.z = v.w;
>+    result.w = v.z;
>+    return result;
>+}
>+half4 operator.xwwz(half4 v) {
>+    half4 result;
>+    result.x = v.x;
>+    result.y = v.w;
>+    result.z = v.w;
>+    result.w = v.z;
>+    return result;
>+}
>+float4 operator.xwwz(float4 v) {
>+    float4 result;
>+    result.x = v.x;
>+    result.y = v.w;
>+    result.z = v.w;
>+    result.w = v.z;
>+    return result;
>+}
>+
>+/* Functions named isinf */
>+native bool isinf(float);
>+bool isinf(half x) {
>+    return isinf(float(x));
>+}
>+bool2 isinf(half2 x) {
>+    bool2 result;
>+    result[0] = isinf(x[0]);
>+    result[1] = isinf(x[1]);
>+    return result;
>+}
>+bool3 isinf(half3 x) {
>+    bool3 result;
>+    result[0] = isinf(x[0]);
>+    result[1] = isinf(x[1]);
>+    result[2] = isinf(x[2]);
>+    return result;
>+}
>+bool4 isinf(half4 x) {
>+    bool4 result;
>+    result[0] = isinf(x[0]);
>+    result[1] = isinf(x[1]);
>+    result[2] = isinf(x[2]);
>+    result[3] = isinf(x[3]);
>+    return result;
>+}
>+bool2 isinf(float2 x) {
>+    bool2 result;
>+    result[0] = isinf(x[0]);
>+    result[1] = isinf(x[1]);
>+    return result;
>+}
>+bool3 isinf(float3 x) {
>+    bool3 result;
>+    result[0] = isinf(x[0]);
>+    result[1] = isinf(x[1]);
>+    result[2] = isinf(x[2]);
>+    return result;
>+}
>+bool4 isinf(float4 x) {
>+    bool4 result;
>+    result[0] = isinf(x[0]);
>+    result[1] = isinf(x[1]);
>+    result[2] = isinf(x[2]);
>+    result[3] = isinf(x[3]);
>+    return result;
>+}
>+
>+/* Functions named operator| */
>+bool operator|(bool a, bool b) {
>+    return a || b;
>+}
>+native int operator|(int, int);
>+native uint operator|(uint, uint);
>+uchar operator|(uchar a, uchar b) {
>+    return uchar(uint(a) | uint(b));
>+}
>+ushort operator|(ushort a, ushort b) {
>+    return ushort(uint(a) | uint(b));
>+}
>+char operator|(char a, char b) {
>+    return char(int(a) | int(b));
>+}
>+short operator|(short a, short b) {
>+    return short(int(a) | int(b));
>+}
>+
>+/* Functions named operator.zwy */
>+bool3 operator.zwy(bool4 v) {
>+    bool3 result;
>+    result.x = v.z;
>+    result.y = v.w;
>+    result.z = v.y;
>+    return result;
>+}
>+uchar3 operator.zwy(uchar4 v) {
>+    uchar3 result;
>+    result.x = v.z;
>+    result.y = v.w;
>+    result.z = v.y;
>+    return result;
>+}
>+ushort3 operator.zwy(ushort4 v) {
>+    ushort3 result;
>+    result.x = v.z;
>+    result.y = v.w;
>+    result.z = v.y;
>+    return result;
>+}
>+uint3 operator.zwy(uint4 v) {
>+    uint3 result;
>+    result.x = v.z;
>+    result.y = v.w;
>+    result.z = v.y;
>+    return result;
>+}
>+char3 operator.zwy(char4 v) {
>+    char3 result;
>+    result.x = v.z;
>+    result.y = v.w;
>+    result.z = v.y;
>+    return result;
>+}
>+short3 operator.zwy(short4 v) {
>+    short3 result;
>+    result.x = v.z;
>+    result.y = v.w;
>+    result.z = v.y;
>+    return result;
>+}
>+int3 operator.zwy(int4 v) {
>+    int3 result;
>+    result.x = v.z;
>+    result.y = v.w;
>+    result.z = v.y;
>+    return result;
>+}
>+half3 operator.zwy(half4 v) {
>+    half3 result;
>+    result.x = v.z;
>+    result.y = v.w;
>+    result.z = v.y;
>+    return result;
>+}
>+float3 operator.zwy(float4 v) {
>+    float3 result;
>+    result.x = v.z;
>+    result.y = v.w;
>+    result.z = v.y;
>+    return result;
>+}
>+
>+/* Functions named operator.yzxx */
>+bool4 operator.yzxx(bool3 v) {
>+    bool4 result;
>+    result.x = v.y;
>+    result.y = v.z;
>+    result.z = v.x;
>+    result.w = v.x;
>+    return result;
>+}
>+bool4 operator.yzxx(bool4 v) {
>+    bool4 result;
>+    result.x = v.y;
>+    result.y = v.z;
>+    result.z = v.x;
>+    result.w = v.x;
>+    return result;
>+}
>+uchar4 operator.yzxx(uchar3 v) {
>+    uchar4 result;
>+    result.x = v.y;
>+    result.y = v.z;
>+    result.z = v.x;
>+    result.w = v.x;
>+    return result;
>+}
>+uchar4 operator.yzxx(uchar4 v) {
>+    uchar4 result;
>+    result.x = v.y;
>+    result.y = v.z;
>+    result.z = v.x;
>+    result.w = v.x;
>+    return result;
>+}
>+ushort4 operator.yzxx(ushort3 v) {
>+    ushort4 result;
>+    result.x = v.y;
>+    result.y = v.z;
>+    result.z = v.x;
>+    result.w = v.x;
>+    return result;
>+}
>+ushort4 operator.yzxx(ushort4 v) {
>+    ushort4 result;
>+    result.x = v.y;
>+    result.y = v.z;
>+    result.z = v.x;
>+    result.w = v.x;
>+    return result;
>+}
>+uint4 operator.yzxx(uint3 v) {
>+    uint4 result;
>+    result.x = v.y;
>+    result.y = v.z;
>+    result.z = v.x;
>+    result.w = v.x;
>+    return result;
>+}
>+uint4 operator.yzxx(uint4 v) {
>+    uint4 result;
>+    result.x = v.y;
>+    result.y = v.z;
>+    result.z = v.x;
>+    result.w = v.x;
>+    return result;
>+}
>+char4 operator.yzxx(char3 v) {
>+    char4 result;
>+    result.x = v.y;
>+    result.y = v.z;
>+    result.z = v.x;
>+    result.w = v.x;
>+    return result;
>+}
>+char4 operator.yzxx(char4 v) {
>+    char4 result;
>+    result.x = v.y;
>+    result.y = v.z;
>+    result.z = v.x;
>+    result.w = v.x;
>+    return result;
>+}
>+short4 operator.yzxx(short3 v) {
>+    short4 result;
>+    result.x = v.y;
>+    result.y = v.z;
>+    result.z = v.x;
>+    result.w = v.x;
>+    return result;
>+}
>+short4 operator.yzxx(short4 v) {
>+    short4 result;
>+    result.x = v.y;
>+    result.y = v.z;
>+    result.z = v.x;
>+    result.w = v.x;
>+    return result;
>+}
>+int4 operator.yzxx(int3 v) {
>+    int4 result;
>+    result.x = v.y;
>+    result.y = v.z;
>+    result.z = v.x;
>+    result.w = v.x;
>+    return result;
>+}
>+int4 operator.yzxx(int4 v) {
>+    int4 result;
>+    result.x = v.y;
>+    result.y = v.z;
>+    result.z = v.x;
>+    result.w = v.x;
>+    return result;
>+}
>+half4 operator.yzxx(half3 v) {
>+    half4 result;
>+    result.x = v.y;
>+    result.y = v.z;
>+    result.z = v.x;
>+    result.w = v.x;
>+    return result;
>+}
>+half4 operator.yzxx(half4 v) {
>+    half4 result;
>+    result.x = v.y;
>+    result.y = v.z;
>+    result.z = v.x;
>+    result.w = v.x;
>+    return result;
>+}
>+float4 operator.yzxx(float3 v) {
>+    float4 result;
>+    result.x = v.y;
>+    result.y = v.z;
>+    result.z = v.x;
>+    result.w = v.x;
>+    return result;
>+}
>+float4 operator.yzxx(float4 v) {
>+    float4 result;
>+    result.x = v.y;
>+    result.y = v.z;
>+    result.z = v.x;
>+    result.w = v.x;
>+    return result;
>+}
>+
>+/* Functions named operator.zyyx */
>+bool4 operator.zyyx(bool3 v) {
>+    bool4 result;
>+    result.x = v.z;
>+    result.y = v.y;
>+    result.z = v.y;
>+    result.w = v.x;
>+    return result;
>+}
>+bool4 operator.zyyx(bool4 v) {
>+    bool4 result;
>+    result.x = v.z;
>+    result.y = v.y;
>+    result.z = v.y;
>+    result.w = v.x;
>+    return result;
>+}
>+uchar4 operator.zyyx(uchar3 v) {
>+    uchar4 result;
>+    result.x = v.z;
>+    result.y = v.y;
>+    result.z = v.y;
>+    result.w = v.x;
>+    return result;
>+}
>+uchar4 operator.zyyx(uchar4 v) {
>+    uchar4 result;
>+    result.x = v.z;
>+    result.y = v.y;
>+    result.z = v.y;
>+    result.w = v.x;
>+    return result;
>+}
>+ushort4 operator.zyyx(ushort3 v) {
>+    ushort4 result;
>+    result.x = v.z;
>+    result.y = v.y;
>+    result.z = v.y;
>+    result.w = v.x;
>+    return result;
>+}
>+ushort4 operator.zyyx(ushort4 v) {
>+    ushort4 result;
>+    result.x = v.z;
>+    result.y = v.y;
>+    result.z = v.y;
>+    result.w = v.x;
>+    return result;
>+}
>+uint4 operator.zyyx(uint3 v) {
>+    uint4 result;
>+    result.x = v.z;
>+    result.y = v.y;
>+    result.z = v.y;
>+    result.w = v.x;
>+    return result;
>+}
>+uint4 operator.zyyx(uint4 v) {
>+    uint4 result;
>+    result.x = v.z;
>+    result.y = v.y;
>+    result.z = v.y;
>+    result.w = v.x;
>+    return result;
>+}
>+char4 operator.zyyx(char3 v) {
>+    char4 result;
>+    result.x = v.z;
>+    result.y = v.y;
>+    result.z = v.y;
>+    result.w = v.x;
>+    return result;
>+}
>+char4 operator.zyyx(char4 v) {
>+    char4 result;
>+    result.x = v.z;
>+    result.y = v.y;
>+    result.z = v.y;
>+    result.w = v.x;
>+    return result;
>+}
>+short4 operator.zyyx(short3 v) {
>+    short4 result;
>+    result.x = v.z;
>+    result.y = v.y;
>+    result.z = v.y;
>+    result.w = v.x;
>+    return result;
>+}
>+short4 operator.zyyx(short4 v) {
>+    short4 result;
>+    result.x = v.z;
>+    result.y = v.y;
>+    result.z = v.y;
>+    result.w = v.x;
>+    return result;
>+}
>+int4 operator.zyyx(int3 v) {
>+    int4 result;
>+    result.x = v.z;
>+    result.y = v.y;
>+    result.z = v.y;
>+    result.w = v.x;
>+    return result;
>+}
>+int4 operator.zyyx(int4 v) {
>+    int4 result;
>+    result.x = v.z;
>+    result.y = v.y;
>+    result.z = v.y;
>+    result.w = v.x;
>+    return result;
>+}
>+half4 operator.zyyx(half3 v) {
>+    half4 result;
>+    result.x = v.z;
>+    result.y = v.y;
>+    result.z = v.y;
>+    result.w = v.x;
>+    return result;
>+}
>+half4 operator.zyyx(half4 v) {
>+    half4 result;
>+    result.x = v.z;
>+    result.y = v.y;
>+    result.z = v.y;
>+    result.w = v.x;
>+    return result;
>+}
>+float4 operator.zyyx(float3 v) {
>+    float4 result;
>+    result.x = v.z;
>+    result.y = v.y;
>+    result.z = v.y;
>+    result.w = v.x;
>+    return result;
>+}
>+float4 operator.zyyx(float4 v) {
>+    float4 result;
>+    result.x = v.z;
>+    result.y = v.y;
>+    result.z = v.y;
>+    result.w = v.x;
>+    return result;
>+}
>+
>+/* Functions named operator.zywy */
>+bool4 operator.zywy(bool4 v) {
>+    bool4 result;
>+    result.x = v.z;
>+    result.y = v.y;
>+    result.z = v.w;
>+    result.w = v.y;
>+    return result;
>+}
>+uchar4 operator.zywy(uchar4 v) {
>+    uchar4 result;
>+    result.x = v.z;
>+    result.y = v.y;
>+    result.z = v.w;
>+    result.w = v.y;
>+    return result;
>+}
>+ushort4 operator.zywy(ushort4 v) {
>+    ushort4 result;
>+    result.x = v.z;
>+    result.y = v.y;
>+    result.z = v.w;
>+    result.w = v.y;
>+    return result;
>+}
>+uint4 operator.zywy(uint4 v) {
>+    uint4 result;
>+    result.x = v.z;
>+    result.y = v.y;
>+    result.z = v.w;
>+    result.w = v.y;
>+    return result;
>+}
>+char4 operator.zywy(char4 v) {
>+    char4 result;
>+    result.x = v.z;
>+    result.y = v.y;
>+    result.z = v.w;
>+    result.w = v.y;
>+    return result;
>+}
>+short4 operator.zywy(short4 v) {
>+    short4 result;
>+    result.x = v.z;
>+    result.y = v.y;
>+    result.z = v.w;
>+    result.w = v.y;
>+    return result;
>+}
>+int4 operator.zywy(int4 v) {
>+    int4 result;
>+    result.x = v.z;
>+    result.y = v.y;
>+    result.z = v.w;
>+    result.w = v.y;
>+    return result;
>+}
>+half4 operator.zywy(half4 v) {
>+    half4 result;
>+    result.x = v.z;
>+    result.y = v.y;
>+    result.z = v.w;
>+    result.w = v.y;
>+    return result;
>+}
>+float4 operator.zywy(float4 v) {
>+    float4 result;
>+    result.x = v.z;
>+    result.y = v.y;
>+    result.z = v.w;
>+    result.w = v.y;
>+    return result;
>+}
>+
>+/* Functions named operator.ywyx */
>+bool4 operator.ywyx(bool4 v) {
>+    bool4 result;
>+    result.x = v.y;
>+    result.y = v.w;
>+    result.z = v.y;
>+    result.w = v.x;
>+    return result;
>+}
>+uchar4 operator.ywyx(uchar4 v) {
>+    uchar4 result;
>+    result.x = v.y;
>+    result.y = v.w;
>+    result.z = v.y;
>+    result.w = v.x;
>+    return result;
>+}
>+ushort4 operator.ywyx(ushort4 v) {
>+    ushort4 result;
>+    result.x = v.y;
>+    result.y = v.w;
>+    result.z = v.y;
>+    result.w = v.x;
>+    return result;
>+}
>+uint4 operator.ywyx(uint4 v) {
>+    uint4 result;
>+    result.x = v.y;
>+    result.y = v.w;
>+    result.z = v.y;
>+    result.w = v.x;
>+    return result;
>+}
>+char4 operator.ywyx(char4 v) {
>+    char4 result;
>+    result.x = v.y;
>+    result.y = v.w;
>+    result.z = v.y;
>+    result.w = v.x;
>+    return result;
>+}
>+short4 operator.ywyx(short4 v) {
>+    short4 result;
>+    result.x = v.y;
>+    result.y = v.w;
>+    result.z = v.y;
>+    result.w = v.x;
>+    return result;
>+}
>+int4 operator.ywyx(int4 v) {
>+    int4 result;
>+    result.x = v.y;
>+    result.y = v.w;
>+    result.z = v.y;
>+    result.w = v.x;
>+    return result;
>+}
>+half4 operator.ywyx(half4 v) {
>+    half4 result;
>+    result.x = v.y;
>+    result.y = v.w;
>+    result.z = v.y;
>+    result.w = v.x;
>+    return result;
>+}
>+float4 operator.ywyx(float4 v) {
>+    float4 result;
>+    result.x = v.y;
>+    result.y = v.w;
>+    result.z = v.y;
>+    result.w = v.x;
>+    return result;
>+}
>+
>+/* Functions named operator.yxxx */
>+bool4 operator.yxxx(bool2 v) {
>+    bool4 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.x;
>+    result.w = v.x;
>+    return result;
>+}
>+bool4 operator.yxxx(bool3 v) {
>+    bool4 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.x;
>+    result.w = v.x;
>+    return result;
>+}
>+bool4 operator.yxxx(bool4 v) {
>+    bool4 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.x;
>+    result.w = v.x;
>+    return result;
>+}
>+uchar4 operator.yxxx(uchar2 v) {
>+    uchar4 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.x;
>+    result.w = v.x;
>+    return result;
>+}
>+uchar4 operator.yxxx(uchar3 v) {
>+    uchar4 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.x;
>+    result.w = v.x;
>+    return result;
>+}
>+uchar4 operator.yxxx(uchar4 v) {
>+    uchar4 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.x;
>+    result.w = v.x;
>+    return result;
>+}
>+ushort4 operator.yxxx(ushort2 v) {
>+    ushort4 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.x;
>+    result.w = v.x;
>+    return result;
>+}
>+ushort4 operator.yxxx(ushort3 v) {
>+    ushort4 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.x;
>+    result.w = v.x;
>+    return result;
>+}
>+ushort4 operator.yxxx(ushort4 v) {
>+    ushort4 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.x;
>+    result.w = v.x;
>+    return result;
>+}
>+uint4 operator.yxxx(uint2 v) {
>+    uint4 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.x;
>+    result.w = v.x;
>+    return result;
>+}
>+uint4 operator.yxxx(uint3 v) {
>+    uint4 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.x;
>+    result.w = v.x;
>+    return result;
>+}
>+uint4 operator.yxxx(uint4 v) {
>+    uint4 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.x;
>+    result.w = v.x;
>+    return result;
>+}
>+char4 operator.yxxx(char2 v) {
>+    char4 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.x;
>+    result.w = v.x;
>+    return result;
>+}
>+char4 operator.yxxx(char3 v) {
>+    char4 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.x;
>+    result.w = v.x;
>+    return result;
>+}
>+char4 operator.yxxx(char4 v) {
>+    char4 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.x;
>+    result.w = v.x;
>+    return result;
>+}
>+short4 operator.yxxx(short2 v) {
>+    short4 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.x;
>+    result.w = v.x;
>+    return result;
>+}
>+short4 operator.yxxx(short3 v) {
>+    short4 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.x;
>+    result.w = v.x;
>+    return result;
>+}
>+short4 operator.yxxx(short4 v) {
>+    short4 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.x;
>+    result.w = v.x;
>+    return result;
>+}
>+int4 operator.yxxx(int2 v) {
>+    int4 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.x;
>+    result.w = v.x;
>+    return result;
>+}
>+int4 operator.yxxx(int3 v) {
>+    int4 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.x;
>+    result.w = v.x;
>+    return result;
>+}
>+int4 operator.yxxx(int4 v) {
>+    int4 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.x;
>+    result.w = v.x;
>+    return result;
>+}
>+half4 operator.yxxx(half2 v) {
>+    half4 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.x;
>+    result.w = v.x;
>+    return result;
>+}
>+half4 operator.yxxx(half3 v) {
>+    half4 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.x;
>+    result.w = v.x;
>+    return result;
>+}
>+half4 operator.yxxx(half4 v) {
>+    half4 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.x;
>+    result.w = v.x;
>+    return result;
>+}
>+float4 operator.yxxx(float2 v) {
>+    float4 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.x;
>+    result.w = v.x;
>+    return result;
>+}
>+float4 operator.yxxx(float3 v) {
>+    float4 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.x;
>+    result.w = v.x;
>+    return result;
>+}
>+float4 operator.yxxx(float4 v) {
>+    float4 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.x;
>+    result.w = v.x;
>+    return result;
>+}
>+
>+/* Functions named operator.xyyz */
>+bool4 operator.xyyz(bool3 v) {
>+    bool4 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.y;
>+    result.w = v.z;
>+    return result;
>+}
>+bool4 operator.xyyz(bool4 v) {
>+    bool4 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.y;
>+    result.w = v.z;
>+    return result;
>+}
>+uchar4 operator.xyyz(uchar3 v) {
>+    uchar4 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.y;
>+    result.w = v.z;
>+    return result;
>+}
>+uchar4 operator.xyyz(uchar4 v) {
>+    uchar4 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.y;
>+    result.w = v.z;
>+    return result;
>+}
>+ushort4 operator.xyyz(ushort3 v) {
>+    ushort4 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.y;
>+    result.w = v.z;
>+    return result;
>+}
>+ushort4 operator.xyyz(ushort4 v) {
>+    ushort4 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.y;
>+    result.w = v.z;
>+    return result;
>+}
>+uint4 operator.xyyz(uint3 v) {
>+    uint4 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.y;
>+    result.w = v.z;
>+    return result;
>+}
>+uint4 operator.xyyz(uint4 v) {
>+    uint4 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.y;
>+    result.w = v.z;
>+    return result;
>+}
>+char4 operator.xyyz(char3 v) {
>+    char4 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.y;
>+    result.w = v.z;
>+    return result;
>+}
>+char4 operator.xyyz(char4 v) {
>+    char4 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.y;
>+    result.w = v.z;
>+    return result;
>+}
>+short4 operator.xyyz(short3 v) {
>+    short4 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.y;
>+    result.w = v.z;
>+    return result;
>+}
>+short4 operator.xyyz(short4 v) {
>+    short4 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.y;
>+    result.w = v.z;
>+    return result;
>+}
>+int4 operator.xyyz(int3 v) {
>+    int4 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.y;
>+    result.w = v.z;
>+    return result;
>+}
>+int4 operator.xyyz(int4 v) {
>+    int4 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.y;
>+    result.w = v.z;
>+    return result;
>+}
>+half4 operator.xyyz(half3 v) {
>+    half4 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.y;
>+    result.w = v.z;
>+    return result;
>+}
>+half4 operator.xyyz(half4 v) {
>+    half4 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.y;
>+    result.w = v.z;
>+    return result;
>+}
>+float4 operator.xyyz(float3 v) {
>+    float4 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.y;
>+    result.w = v.z;
>+    return result;
>+}
>+float4 operator.xyyz(float4 v) {
>+    float4 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.y;
>+    result.w = v.z;
>+    return result;
>+}
>+
>+/* Functions named operator.xxyw */
>+bool4 operator.xxyw(bool4 v) {
>+    bool4 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.y;
>+    result.w = v.w;
>+    return result;
>+}
>+uchar4 operator.xxyw(uchar4 v) {
>+    uchar4 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.y;
>+    result.w = v.w;
>+    return result;
>+}
>+ushort4 operator.xxyw(ushort4 v) {
>+    ushort4 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.y;
>+    result.w = v.w;
>+    return result;
>+}
>+uint4 operator.xxyw(uint4 v) {
>+    uint4 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.y;
>+    result.w = v.w;
>+    return result;
>+}
>+char4 operator.xxyw(char4 v) {
>+    char4 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.y;
>+    result.w = v.w;
>+    return result;
>+}
>+short4 operator.xxyw(short4 v) {
>+    short4 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.y;
>+    result.w = v.w;
>+    return result;
>+}
>+int4 operator.xxyw(int4 v) {
>+    int4 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.y;
>+    result.w = v.w;
>+    return result;
>+}
>+half4 operator.xxyw(half4 v) {
>+    half4 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.y;
>+    result.w = v.w;
>+    return result;
>+}
>+float4 operator.xxyw(float4 v) {
>+    float4 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.y;
>+    result.w = v.w;
>+    return result;
>+}
>+
>+/* Functions named operator.wzxx */
>+bool4 operator.wzxx(bool4 v) {
>+    bool4 result;
>+    result.x = v.w;
>+    result.y = v.z;
>+    result.z = v.x;
>+    result.w = v.x;
>+    return result;
>+}
>+uchar4 operator.wzxx(uchar4 v) {
>+    uchar4 result;
>+    result.x = v.w;
>+    result.y = v.z;
>+    result.z = v.x;
>+    result.w = v.x;
>+    return result;
>+}
>+ushort4 operator.wzxx(ushort4 v) {
>+    ushort4 result;
>+    result.x = v.w;
>+    result.y = v.z;
>+    result.z = v.x;
>+    result.w = v.x;
>+    return result;
>+}
>+uint4 operator.wzxx(uint4 v) {
>+    uint4 result;
>+    result.x = v.w;
>+    result.y = v.z;
>+    result.z = v.x;
>+    result.w = v.x;
>+    return result;
>+}
>+char4 operator.wzxx(char4 v) {
>+    char4 result;
>+    result.x = v.w;
>+    result.y = v.z;
>+    result.z = v.x;
>+    result.w = v.x;
>+    return result;
>+}
>+short4 operator.wzxx(short4 v) {
>+    short4 result;
>+    result.x = v.w;
>+    result.y = v.z;
>+    result.z = v.x;
>+    result.w = v.x;
>+    return result;
>+}
>+int4 operator.wzxx(int4 v) {
>+    int4 result;
>+    result.x = v.w;
>+    result.y = v.z;
>+    result.z = v.x;
>+    result.w = v.x;
>+    return result;
>+}
>+half4 operator.wzxx(half4 v) {
>+    half4 result;
>+    result.x = v.w;
>+    result.y = v.z;
>+    result.z = v.x;
>+    result.w = v.x;
>+    return result;
>+}
>+float4 operator.wzxx(float4 v) {
>+    float4 result;
>+    result.x = v.w;
>+    result.y = v.z;
>+    result.z = v.x;
>+    result.w = v.x;
>+    return result;
>+}
>+
>+/* Functions named operator.zxwz */
>+bool4 operator.zxwz(bool4 v) {
>+    bool4 result;
>+    result.x = v.z;
>+    result.y = v.x;
>+    result.z = v.w;
>+    result.w = v.z;
>+    return result;
>+}
>+uchar4 operator.zxwz(uchar4 v) {
>+    uchar4 result;
>+    result.x = v.z;
>+    result.y = v.x;
>+    result.z = v.w;
>+    result.w = v.z;
>+    return result;
>+}
>+ushort4 operator.zxwz(ushort4 v) {
>+    ushort4 result;
>+    result.x = v.z;
>+    result.y = v.x;
>+    result.z = v.w;
>+    result.w = v.z;
>+    return result;
>+}
>+uint4 operator.zxwz(uint4 v) {
>+    uint4 result;
>+    result.x = v.z;
>+    result.y = v.x;
>+    result.z = v.w;
>+    result.w = v.z;
>+    return result;
>+}
>+char4 operator.zxwz(char4 v) {
>+    char4 result;
>+    result.x = v.z;
>+    result.y = v.x;
>+    result.z = v.w;
>+    result.w = v.z;
>+    return result;
>+}
>+short4 operator.zxwz(short4 v) {
>+    short4 result;
>+    result.x = v.z;
>+    result.y = v.x;
>+    result.z = v.w;
>+    result.w = v.z;
>+    return result;
>+}
>+int4 operator.zxwz(int4 v) {
>+    int4 result;
>+    result.x = v.z;
>+    result.y = v.x;
>+    result.z = v.w;
>+    result.w = v.z;
>+    return result;
>+}
>+half4 operator.zxwz(half4 v) {
>+    half4 result;
>+    result.x = v.z;
>+    result.y = v.x;
>+    result.z = v.w;
>+    result.w = v.z;
>+    return result;
>+}
>+float4 operator.zxwz(float4 v) {
>+    float4 result;
>+    result.x = v.z;
>+    result.y = v.x;
>+    result.z = v.w;
>+    result.w = v.z;
>+    return result;
>+}
>+
>+/* Functions named operator.wxyz */
>+bool4 operator.wxyz(bool4 v) {
>+    bool4 result;
>+    result.x = v.w;
>+    result.y = v.x;
>+    result.z = v.y;
>+    result.w = v.z;
>+    return result;
>+}
>+uchar4 operator.wxyz(uchar4 v) {
>+    uchar4 result;
>+    result.x = v.w;
>+    result.y = v.x;
>+    result.z = v.y;
>+    result.w = v.z;
>+    return result;
>+}
>+ushort4 operator.wxyz(ushort4 v) {
>+    ushort4 result;
>+    result.x = v.w;
>+    result.y = v.x;
>+    result.z = v.y;
>+    result.w = v.z;
>+    return result;
>+}
>+uint4 operator.wxyz(uint4 v) {
>+    uint4 result;
>+    result.x = v.w;
>+    result.y = v.x;
>+    result.z = v.y;
>+    result.w = v.z;
>+    return result;
>+}
>+char4 operator.wxyz(char4 v) {
>+    char4 result;
>+    result.x = v.w;
>+    result.y = v.x;
>+    result.z = v.y;
>+    result.w = v.z;
>+    return result;
>+}
>+short4 operator.wxyz(short4 v) {
>+    short4 result;
>+    result.x = v.w;
>+    result.y = v.x;
>+    result.z = v.y;
>+    result.w = v.z;
>+    return result;
>+}
>+int4 operator.wxyz(int4 v) {
>+    int4 result;
>+    result.x = v.w;
>+    result.y = v.x;
>+    result.z = v.y;
>+    result.w = v.z;
>+    return result;
>+}
>+half4 operator.wxyz(half4 v) {
>+    half4 result;
>+    result.x = v.w;
>+    result.y = v.x;
>+    result.z = v.y;
>+    result.w = v.z;
>+    return result;
>+}
>+float4 operator.wxyz(float4 v) {
>+    float4 result;
>+    result.x = v.w;
>+    result.y = v.x;
>+    result.z = v.y;
>+    result.w = v.z;
>+    return result;
>+}
>+
>+/* Functions named operator.xwyy */
>+bool4 operator.xwyy(bool4 v) {
>+    bool4 result;
>+    result.x = v.x;
>+    result.y = v.w;
>+    result.z = v.y;
>+    result.w = v.y;
>+    return result;
>+}
>+uchar4 operator.xwyy(uchar4 v) {
>+    uchar4 result;
>+    result.x = v.x;
>+    result.y = v.w;
>+    result.z = v.y;
>+    result.w = v.y;
>+    return result;
>+}
>+ushort4 operator.xwyy(ushort4 v) {
>+    ushort4 result;
>+    result.x = v.x;
>+    result.y = v.w;
>+    result.z = v.y;
>+    result.w = v.y;
>+    return result;
>+}
>+uint4 operator.xwyy(uint4 v) {
>+    uint4 result;
>+    result.x = v.x;
>+    result.y = v.w;
>+    result.z = v.y;
>+    result.w = v.y;
>+    return result;
>+}
>+char4 operator.xwyy(char4 v) {
>+    char4 result;
>+    result.x = v.x;
>+    result.y = v.w;
>+    result.z = v.y;
>+    result.w = v.y;
>+    return result;
>+}
>+short4 operator.xwyy(short4 v) {
>+    short4 result;
>+    result.x = v.x;
>+    result.y = v.w;
>+    result.z = v.y;
>+    result.w = v.y;
>+    return result;
>+}
>+int4 operator.xwyy(int4 v) {
>+    int4 result;
>+    result.x = v.x;
>+    result.y = v.w;
>+    result.z = v.y;
>+    result.w = v.y;
>+    return result;
>+}
>+half4 operator.xwyy(half4 v) {
>+    half4 result;
>+    result.x = v.x;
>+    result.y = v.w;
>+    result.z = v.y;
>+    result.w = v.y;
>+    return result;
>+}
>+float4 operator.xwyy(float4 v) {
>+    float4 result;
>+    result.x = v.x;
>+    result.y = v.w;
>+    result.z = v.y;
>+    result.w = v.y;
>+    return result;
>+}
>+
>+/* Functions named operator.wzww */
>+bool4 operator.wzww(bool4 v) {
>+    bool4 result;
>+    result.x = v.w;
>+    result.y = v.z;
>+    result.z = v.w;
>+    result.w = v.w;
>+    return result;
>+}
>+uchar4 operator.wzww(uchar4 v) {
>+    uchar4 result;
>+    result.x = v.w;
>+    result.y = v.z;
>+    result.z = v.w;
>+    result.w = v.w;
>+    return result;
>+}
>+ushort4 operator.wzww(ushort4 v) {
>+    ushort4 result;
>+    result.x = v.w;
>+    result.y = v.z;
>+    result.z = v.w;
>+    result.w = v.w;
>+    return result;
>+}
>+uint4 operator.wzww(uint4 v) {
>+    uint4 result;
>+    result.x = v.w;
>+    result.y = v.z;
>+    result.z = v.w;
>+    result.w = v.w;
>+    return result;
>+}
>+char4 operator.wzww(char4 v) {
>+    char4 result;
>+    result.x = v.w;
>+    result.y = v.z;
>+    result.z = v.w;
>+    result.w = v.w;
>+    return result;
>+}
>+short4 operator.wzww(short4 v) {
>+    short4 result;
>+    result.x = v.w;
>+    result.y = v.z;
>+    result.z = v.w;
>+    result.w = v.w;
>+    return result;
>+}
>+int4 operator.wzww(int4 v) {
>+    int4 result;
>+    result.x = v.w;
>+    result.y = v.z;
>+    result.z = v.w;
>+    result.w = v.w;
>+    return result;
>+}
>+half4 operator.wzww(half4 v) {
>+    half4 result;
>+    result.x = v.w;
>+    result.y = v.z;
>+    result.z = v.w;
>+    result.w = v.w;
>+    return result;
>+}
>+float4 operator.wzww(float4 v) {
>+    float4 result;
>+    result.x = v.w;
>+    result.y = v.z;
>+    result.z = v.w;
>+    result.w = v.w;
>+    return result;
>+}
>+
>+/* Functions named degrees */
>+half degrees(half x) {
>+    return x * 180 / 3.14159;
>+}
>+half2 degrees(half2 x) {
>+    half2 result;
>+    result[0] = degrees(x[0]);
>+    result[1] = degrees(x[1]);
>+    return result;
>+}
>+half3 degrees(half3 x) {
>+    half3 result;
>+    result[0] = degrees(x[0]);
>+    result[1] = degrees(x[1]);
>+    result[2] = degrees(x[2]);
>+    return result;
>+}
>+half4 degrees(half4 x) {
>+    half4 result;
>+    result[0] = degrees(x[0]);
>+    result[1] = degrees(x[1]);
>+    result[2] = degrees(x[2]);
>+    result[3] = degrees(x[3]);
>+    return result;
>+}
>+half2x2 degrees(half2x2 x) {
>+    half2x2 result;
>+    result[0][0] = degrees(x[0][0]);
>+    result[0][1] = degrees(x[0][1]);
>+    result[1][0] = degrees(x[1][0]);
>+    result[1][1] = degrees(x[1][1]);
>+    return result;
>+}
>+half2x3 degrees(half2x3 x) {
>+    half2x3 result;
>+    result[0][0] = degrees(x[0][0]);
>+    result[0][1] = degrees(x[0][1]);
>+    result[0][2] = degrees(x[0][2]);
>+    result[1][0] = degrees(x[1][0]);
>+    result[1][1] = degrees(x[1][1]);
>+    result[1][2] = degrees(x[1][2]);
>+    return result;
>+}
>+half2x4 degrees(half2x4 x) {
>+    half2x4 result;
>+    result[0][0] = degrees(x[0][0]);
>+    result[0][1] = degrees(x[0][1]);
>+    result[0][2] = degrees(x[0][2]);
>+    result[0][3] = degrees(x[0][3]);
>+    result[1][0] = degrees(x[1][0]);
>+    result[1][1] = degrees(x[1][1]);
>+    result[1][2] = degrees(x[1][2]);
>+    result[1][3] = degrees(x[1][3]);
>+    return result;
>+}
>+half3x2 degrees(half3x2 x) {
>+    half3x2 result;
>+    result[0][0] = degrees(x[0][0]);
>+    result[0][1] = degrees(x[0][1]);
>+    result[1][0] = degrees(x[1][0]);
>+    result[1][1] = degrees(x[1][1]);
>+    result[2][0] = degrees(x[2][0]);
>+    result[2][1] = degrees(x[2][1]);
>+    return result;
>+}
>+half3x3 degrees(half3x3 x) {
>+    half3x3 result;
>+    result[0][0] = degrees(x[0][0]);
>+    result[0][1] = degrees(x[0][1]);
>+    result[0][2] = degrees(x[0][2]);
>+    result[1][0] = degrees(x[1][0]);
>+    result[1][1] = degrees(x[1][1]);
>+    result[1][2] = degrees(x[1][2]);
>+    result[2][0] = degrees(x[2][0]);
>+    result[2][1] = degrees(x[2][1]);
>+    result[2][2] = degrees(x[2][2]);
>+    return result;
>+}
>+half3x4 degrees(half3x4 x) {
>+    half3x4 result;
>+    result[0][0] = degrees(x[0][0]);
>+    result[0][1] = degrees(x[0][1]);
>+    result[0][2] = degrees(x[0][2]);
>+    result[0][3] = degrees(x[0][3]);
>+    result[1][0] = degrees(x[1][0]);
>+    result[1][1] = degrees(x[1][1]);
>+    result[1][2] = degrees(x[1][2]);
>+    result[1][3] = degrees(x[1][3]);
>+    result[2][0] = degrees(x[2][0]);
>+    result[2][1] = degrees(x[2][1]);
>+    result[2][2] = degrees(x[2][2]);
>+    result[2][3] = degrees(x[2][3]);
>+    return result;
>+}
>+half4x2 degrees(half4x2 x) {
>+    half4x2 result;
>+    result[0][0] = degrees(x[0][0]);
>+    result[0][1] = degrees(x[0][1]);
>+    result[1][0] = degrees(x[1][0]);
>+    result[1][1] = degrees(x[1][1]);
>+    result[2][0] = degrees(x[2][0]);
>+    result[2][1] = degrees(x[2][1]);
>+    result[3][0] = degrees(x[3][0]);
>+    result[3][1] = degrees(x[3][1]);
>+    return result;
>+}
>+half4x3 degrees(half4x3 x) {
>+    half4x3 result;
>+    result[0][0] = degrees(x[0][0]);
>+    result[0][1] = degrees(x[0][1]);
>+    result[0][2] = degrees(x[0][2]);
>+    result[1][0] = degrees(x[1][0]);
>+    result[1][1] = degrees(x[1][1]);
>+    result[1][2] = degrees(x[1][2]);
>+    result[2][0] = degrees(x[2][0]);
>+    result[2][1] = degrees(x[2][1]);
>+    result[2][2] = degrees(x[2][2]);
>+    result[3][0] = degrees(x[3][0]);
>+    result[3][1] = degrees(x[3][1]);
>+    result[3][2] = degrees(x[3][2]);
>+    return result;
>+}
>+half4x4 degrees(half4x4 x) {
>+    half4x4 result;
>+    result[0][0] = degrees(x[0][0]);
>+    result[0][1] = degrees(x[0][1]);
>+    result[0][2] = degrees(x[0][2]);
>+    result[0][3] = degrees(x[0][3]);
>+    result[1][0] = degrees(x[1][0]);
>+    result[1][1] = degrees(x[1][1]);
>+    result[1][2] = degrees(x[1][2]);
>+    result[1][3] = degrees(x[1][3]);
>+    result[2][0] = degrees(x[2][0]);
>+    result[2][1] = degrees(x[2][1]);
>+    result[2][2] = degrees(x[2][2]);
>+    result[2][3] = degrees(x[2][3]);
>+    result[3][0] = degrees(x[3][0]);
>+    result[3][1] = degrees(x[3][1]);
>+    result[3][2] = degrees(x[3][2]);
>+    result[3][3] = degrees(x[3][3]);
>+    return result;
>+}
>+float degrees(float x) {
>+    return x * 180 / 3.14159;
>+}
>+float2 degrees(float2 x) {
>+    float2 result;
>+    result[0] = degrees(x[0]);
>+    result[1] = degrees(x[1]);
>+    return result;
>+}
>+float3 degrees(float3 x) {
>+    float3 result;
>+    result[0] = degrees(x[0]);
>+    result[1] = degrees(x[1]);
>+    result[2] = degrees(x[2]);
>+    return result;
>+}
>+float4 degrees(float4 x) {
>+    float4 result;
>+    result[0] = degrees(x[0]);
>+    result[1] = degrees(x[1]);
>+    result[2] = degrees(x[2]);
>+    result[3] = degrees(x[3]);
>+    return result;
>+}
>+float2x2 degrees(float2x2 x) {
>+    float2x2 result;
>+    result[0][0] = degrees(x[0][0]);
>+    result[0][1] = degrees(x[0][1]);
>+    result[1][0] = degrees(x[1][0]);
>+    result[1][1] = degrees(x[1][1]);
>+    return result;
>+}
>+float2x3 degrees(float2x3 x) {
>+    float2x3 result;
>+    result[0][0] = degrees(x[0][0]);
>+    result[0][1] = degrees(x[0][1]);
>+    result[0][2] = degrees(x[0][2]);
>+    result[1][0] = degrees(x[1][0]);
>+    result[1][1] = degrees(x[1][1]);
>+    result[1][2] = degrees(x[1][2]);
>+    return result;
>+}
>+float2x4 degrees(float2x4 x) {
>+    float2x4 result;
>+    result[0][0] = degrees(x[0][0]);
>+    result[0][1] = degrees(x[0][1]);
>+    result[0][2] = degrees(x[0][2]);
>+    result[0][3] = degrees(x[0][3]);
>+    result[1][0] = degrees(x[1][0]);
>+    result[1][1] = degrees(x[1][1]);
>+    result[1][2] = degrees(x[1][2]);
>+    result[1][3] = degrees(x[1][3]);
>+    return result;
>+}
>+float3x2 degrees(float3x2 x) {
>+    float3x2 result;
>+    result[0][0] = degrees(x[0][0]);
>+    result[0][1] = degrees(x[0][1]);
>+    result[1][0] = degrees(x[1][0]);
>+    result[1][1] = degrees(x[1][1]);
>+    result[2][0] = degrees(x[2][0]);
>+    result[2][1] = degrees(x[2][1]);
>+    return result;
>+}
>+float3x3 degrees(float3x3 x) {
>+    float3x3 result;
>+    result[0][0] = degrees(x[0][0]);
>+    result[0][1] = degrees(x[0][1]);
>+    result[0][2] = degrees(x[0][2]);
>+    result[1][0] = degrees(x[1][0]);
>+    result[1][1] = degrees(x[1][1]);
>+    result[1][2] = degrees(x[1][2]);
>+    result[2][0] = degrees(x[2][0]);
>+    result[2][1] = degrees(x[2][1]);
>+    result[2][2] = degrees(x[2][2]);
>+    return result;
>+}
>+float3x4 degrees(float3x4 x) {
>+    float3x4 result;
>+    result[0][0] = degrees(x[0][0]);
>+    result[0][1] = degrees(x[0][1]);
>+    result[0][2] = degrees(x[0][2]);
>+    result[0][3] = degrees(x[0][3]);
>+    result[1][0] = degrees(x[1][0]);
>+    result[1][1] = degrees(x[1][1]);
>+    result[1][2] = degrees(x[1][2]);
>+    result[1][3] = degrees(x[1][3]);
>+    result[2][0] = degrees(x[2][0]);
>+    result[2][1] = degrees(x[2][1]);
>+    result[2][2] = degrees(x[2][2]);
>+    result[2][3] = degrees(x[2][3]);
>+    return result;
>+}
>+float4x2 degrees(float4x2 x) {
>+    float4x2 result;
>+    result[0][0] = degrees(x[0][0]);
>+    result[0][1] = degrees(x[0][1]);
>+    result[1][0] = degrees(x[1][0]);
>+    result[1][1] = degrees(x[1][1]);
>+    result[2][0] = degrees(x[2][0]);
>+    result[2][1] = degrees(x[2][1]);
>+    result[3][0] = degrees(x[3][0]);
>+    result[3][1] = degrees(x[3][1]);
>+    return result;
>+}
>+float4x3 degrees(float4x3 x) {
>+    float4x3 result;
>+    result[0][0] = degrees(x[0][0]);
>+    result[0][1] = degrees(x[0][1]);
>+    result[0][2] = degrees(x[0][2]);
>+    result[1][0] = degrees(x[1][0]);
>+    result[1][1] = degrees(x[1][1]);
>+    result[1][2] = degrees(x[1][2]);
>+    result[2][0] = degrees(x[2][0]);
>+    result[2][1] = degrees(x[2][1]);
>+    result[2][2] = degrees(x[2][2]);
>+    result[3][0] = degrees(x[3][0]);
>+    result[3][1] = degrees(x[3][1]);
>+    result[3][2] = degrees(x[3][2]);
>+    return result;
>+}
>+float4x4 degrees(float4x4 x) {
>+    float4x4 result;
>+    result[0][0] = degrees(x[0][0]);
>+    result[0][1] = degrees(x[0][1]);
>+    result[0][2] = degrees(x[0][2]);
>+    result[0][3] = degrees(x[0][3]);
>+    result[1][0] = degrees(x[1][0]);
>+    result[1][1] = degrees(x[1][1]);
>+    result[1][2] = degrees(x[1][2]);
>+    result[1][3] = degrees(x[1][3]);
>+    result[2][0] = degrees(x[2][0]);
>+    result[2][1] = degrees(x[2][1]);
>+    result[2][2] = degrees(x[2][2]);
>+    result[2][3] = degrees(x[2][3]);
>+    result[3][0] = degrees(x[3][0]);
>+    result[3][1] = degrees(x[3][1]);
>+    result[3][2] = degrees(x[3][2]);
>+    result[3][3] = degrees(x[3][3]);
>+    return result;
>+}
>+
>+/* Functions named operator.yyy */
>+bool3 operator.yyy(bool2 v) {
>+    bool3 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.y;
>+    return result;
>+}
>+bool3 operator.yyy(bool3 v) {
>+    bool3 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.y;
>+    return result;
>+}
>+bool3 operator.yyy(bool4 v) {
>+    bool3 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.y;
>+    return result;
>+}
>+uchar3 operator.yyy(uchar2 v) {
>+    uchar3 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.y;
>+    return result;
>+}
>+uchar3 operator.yyy(uchar3 v) {
>+    uchar3 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.y;
>+    return result;
>+}
>+uchar3 operator.yyy(uchar4 v) {
>+    uchar3 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.y;
>+    return result;
>+}
>+ushort3 operator.yyy(ushort2 v) {
>+    ushort3 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.y;
>+    return result;
>+}
>+ushort3 operator.yyy(ushort3 v) {
>+    ushort3 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.y;
>+    return result;
>+}
>+ushort3 operator.yyy(ushort4 v) {
>+    ushort3 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.y;
>+    return result;
>+}
>+uint3 operator.yyy(uint2 v) {
>+    uint3 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.y;
>+    return result;
>+}
>+uint3 operator.yyy(uint3 v) {
>+    uint3 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.y;
>+    return result;
>+}
>+uint3 operator.yyy(uint4 v) {
>+    uint3 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.y;
>+    return result;
>+}
>+char3 operator.yyy(char2 v) {
>+    char3 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.y;
>+    return result;
>+}
>+char3 operator.yyy(char3 v) {
>+    char3 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.y;
>+    return result;
>+}
>+char3 operator.yyy(char4 v) {
>+    char3 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.y;
>+    return result;
>+}
>+short3 operator.yyy(short2 v) {
>+    short3 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.y;
>+    return result;
>+}
>+short3 operator.yyy(short3 v) {
>+    short3 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.y;
>+    return result;
>+}
>+short3 operator.yyy(short4 v) {
>+    short3 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.y;
>+    return result;
>+}
>+int3 operator.yyy(int2 v) {
>+    int3 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.y;
>+    return result;
>+}
>+int3 operator.yyy(int3 v) {
>+    int3 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.y;
>+    return result;
>+}
>+int3 operator.yyy(int4 v) {
>+    int3 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.y;
>+    return result;
>+}
>+half3 operator.yyy(half2 v) {
>+    half3 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.y;
>+    return result;
>+}
>+half3 operator.yyy(half3 v) {
>+    half3 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.y;
>+    return result;
>+}
>+half3 operator.yyy(half4 v) {
>+    half3 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.y;
>+    return result;
>+}
>+float3 operator.yyy(float2 v) {
>+    float3 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.y;
>+    return result;
>+}
>+float3 operator.yyy(float3 v) {
>+    float3 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.y;
>+    return result;
>+}
>+float3 operator.yyy(float4 v) {
>+    float3 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.y;
>+    return result;
>+}
>+
>+/* Functions named operator.wzzy */
>+bool4 operator.wzzy(bool4 v) {
>+    bool4 result;
>+    result.x = v.w;
>+    result.y = v.z;
>+    result.z = v.z;
>+    result.w = v.y;
>+    return result;
>+}
>+uchar4 operator.wzzy(uchar4 v) {
>+    uchar4 result;
>+    result.x = v.w;
>+    result.y = v.z;
>+    result.z = v.z;
>+    result.w = v.y;
>+    return result;
>+}
>+ushort4 operator.wzzy(ushort4 v) {
>+    ushort4 result;
>+    result.x = v.w;
>+    result.y = v.z;
>+    result.z = v.z;
>+    result.w = v.y;
>+    return result;
>+}
>+uint4 operator.wzzy(uint4 v) {
>+    uint4 result;
>+    result.x = v.w;
>+    result.y = v.z;
>+    result.z = v.z;
>+    result.w = v.y;
>+    return result;
>+}
>+char4 operator.wzzy(char4 v) {
>+    char4 result;
>+    result.x = v.w;
>+    result.y = v.z;
>+    result.z = v.z;
>+    result.w = v.y;
>+    return result;
>+}
>+short4 operator.wzzy(short4 v) {
>+    short4 result;
>+    result.x = v.w;
>+    result.y = v.z;
>+    result.z = v.z;
>+    result.w = v.y;
>+    return result;
>+}
>+int4 operator.wzzy(int4 v) {
>+    int4 result;
>+    result.x = v.w;
>+    result.y = v.z;
>+    result.z = v.z;
>+    result.w = v.y;
>+    return result;
>+}
>+half4 operator.wzzy(half4 v) {
>+    half4 result;
>+    result.x = v.w;
>+    result.y = v.z;
>+    result.z = v.z;
>+    result.w = v.y;
>+    return result;
>+}
>+float4 operator.wzzy(float4 v) {
>+    float4 result;
>+    result.x = v.w;
>+    result.y = v.z;
>+    result.z = v.z;
>+    result.w = v.y;
>+    return result;
>+}
>+
>+/* Functions named operator.zzwz */
>+bool4 operator.zzwz(bool4 v) {
>+    bool4 result;
>+    result.x = v.z;
>+    result.y = v.z;
>+    result.z = v.w;
>+    result.w = v.z;
>+    return result;
>+}
>+uchar4 operator.zzwz(uchar4 v) {
>+    uchar4 result;
>+    result.x = v.z;
>+    result.y = v.z;
>+    result.z = v.w;
>+    result.w = v.z;
>+    return result;
>+}
>+ushort4 operator.zzwz(ushort4 v) {
>+    ushort4 result;
>+    result.x = v.z;
>+    result.y = v.z;
>+    result.z = v.w;
>+    result.w = v.z;
>+    return result;
>+}
>+uint4 operator.zzwz(uint4 v) {
>+    uint4 result;
>+    result.x = v.z;
>+    result.y = v.z;
>+    result.z = v.w;
>+    result.w = v.z;
>+    return result;
>+}
>+char4 operator.zzwz(char4 v) {
>+    char4 result;
>+    result.x = v.z;
>+    result.y = v.z;
>+    result.z = v.w;
>+    result.w = v.z;
>+    return result;
>+}
>+short4 operator.zzwz(short4 v) {
>+    short4 result;
>+    result.x = v.z;
>+    result.y = v.z;
>+    result.z = v.w;
>+    result.w = v.z;
>+    return result;
>+}
>+int4 operator.zzwz(int4 v) {
>+    int4 result;
>+    result.x = v.z;
>+    result.y = v.z;
>+    result.z = v.w;
>+    result.w = v.z;
>+    return result;
>+}
>+half4 operator.zzwz(half4 v) {
>+    half4 result;
>+    result.x = v.z;
>+    result.y = v.z;
>+    result.z = v.w;
>+    result.w = v.z;
>+    return result;
>+}
>+float4 operator.zzwz(float4 v) {
>+    float4 result;
>+    result.x = v.z;
>+    result.y = v.z;
>+    result.z = v.w;
>+    result.w = v.z;
>+    return result;
>+}
>+
>+/* Functions named operator.zzyy */
>+bool4 operator.zzyy(bool3 v) {
>+    bool4 result;
>+    result.x = v.z;
>+    result.y = v.z;
>+    result.z = v.y;
>+    result.w = v.y;
>+    return result;
>+}
>+bool4 operator.zzyy(bool4 v) {
>+    bool4 result;
>+    result.x = v.z;
>+    result.y = v.z;
>+    result.z = v.y;
>+    result.w = v.y;
>+    return result;
>+}
>+uchar4 operator.zzyy(uchar3 v) {
>+    uchar4 result;
>+    result.x = v.z;
>+    result.y = v.z;
>+    result.z = v.y;
>+    result.w = v.y;
>+    return result;
>+}
>+uchar4 operator.zzyy(uchar4 v) {
>+    uchar4 result;
>+    result.x = v.z;
>+    result.y = v.z;
>+    result.z = v.y;
>+    result.w = v.y;
>+    return result;
>+}
>+ushort4 operator.zzyy(ushort3 v) {
>+    ushort4 result;
>+    result.x = v.z;
>+    result.y = v.z;
>+    result.z = v.y;
>+    result.w = v.y;
>+    return result;
>+}
>+ushort4 operator.zzyy(ushort4 v) {
>+    ushort4 result;
>+    result.x = v.z;
>+    result.y = v.z;
>+    result.z = v.y;
>+    result.w = v.y;
>+    return result;
>+}
>+uint4 operator.zzyy(uint3 v) {
>+    uint4 result;
>+    result.x = v.z;
>+    result.y = v.z;
>+    result.z = v.y;
>+    result.w = v.y;
>+    return result;
>+}
>+uint4 operator.zzyy(uint4 v) {
>+    uint4 result;
>+    result.x = v.z;
>+    result.y = v.z;
>+    result.z = v.y;
>+    result.w = v.y;
>+    return result;
>+}
>+char4 operator.zzyy(char3 v) {
>+    char4 result;
>+    result.x = v.z;
>+    result.y = v.z;
>+    result.z = v.y;
>+    result.w = v.y;
>+    return result;
>+}
>+char4 operator.zzyy(char4 v) {
>+    char4 result;
>+    result.x = v.z;
>+    result.y = v.z;
>+    result.z = v.y;
>+    result.w = v.y;
>+    return result;
>+}
>+short4 operator.zzyy(short3 v) {
>+    short4 result;
>+    result.x = v.z;
>+    result.y = v.z;
>+    result.z = v.y;
>+    result.w = v.y;
>+    return result;
>+}
>+short4 operator.zzyy(short4 v) {
>+    short4 result;
>+    result.x = v.z;
>+    result.y = v.z;
>+    result.z = v.y;
>+    result.w = v.y;
>+    return result;
>+}
>+int4 operator.zzyy(int3 v) {
>+    int4 result;
>+    result.x = v.z;
>+    result.y = v.z;
>+    result.z = v.y;
>+    result.w = v.y;
>+    return result;
>+}
>+int4 operator.zzyy(int4 v) {
>+    int4 result;
>+    result.x = v.z;
>+    result.y = v.z;
>+    result.z = v.y;
>+    result.w = v.y;
>+    return result;
>+}
>+half4 operator.zzyy(half3 v) {
>+    half4 result;
>+    result.x = v.z;
>+    result.y = v.z;
>+    result.z = v.y;
>+    result.w = v.y;
>+    return result;
>+}
>+half4 operator.zzyy(half4 v) {
>+    half4 result;
>+    result.x = v.z;
>+    result.y = v.z;
>+    result.z = v.y;
>+    result.w = v.y;
>+    return result;
>+}
>+float4 operator.zzyy(float3 v) {
>+    float4 result;
>+    result.x = v.z;
>+    result.y = v.z;
>+    result.z = v.y;
>+    result.w = v.y;
>+    return result;
>+}
>+float4 operator.zzyy(float4 v) {
>+    float4 result;
>+    result.x = v.z;
>+    result.y = v.z;
>+    result.z = v.y;
>+    result.w = v.y;
>+    return result;
>+}
>+
>+/* Functions named Sample */
>+native ushort Sample(Texture1D<ushort>, sampler, float location);
>+native ushort Sample(Texture1DArray<ushort>, sampler, float2 location);
>+native ushort Sample(Texture2D<ushort>, sampler, float2 location);
>+native ushort Sample(Texture2D<ushort>, sampler, float2 location, int2 offset);
>+native ushort Sample(Texture2DArray<ushort>, sampler, float3 location);
>+native ushort Sample(Texture2DArray<ushort>, sampler, float3 location, int2 offset);
>+native ushort Sample(Texture3D<ushort>, sampler, float3 location);
>+native ushort Sample(Texture3D<ushort>, sampler, float3 location, int3 offset);
>+native ushort Sample(TextureCube<ushort>, sampler, float3 location);
>+native ushort2 Sample(Texture1D<ushort2>, sampler, float location);
>+native ushort2 Sample(Texture1DArray<ushort2>, sampler, float2 location);
>+native ushort2 Sample(Texture2D<ushort2>, sampler, float2 location);
>+native ushort2 Sample(Texture2D<ushort2>, sampler, float2 location, int2 offset);
>+native ushort2 Sample(Texture2DArray<ushort2>, sampler, float3 location);
>+native ushort2 Sample(Texture2DArray<ushort2>, sampler, float3 location, int2 offset);
>+native ushort2 Sample(Texture3D<ushort2>, sampler, float3 location);
>+native ushort2 Sample(Texture3D<ushort2>, sampler, float3 location, int3 offset);
>+native ushort2 Sample(TextureCube<ushort2>, sampler, float3 location);
>+native ushort3 Sample(Texture1D<ushort3>, sampler, float location);
>+native ushort3 Sample(Texture1DArray<ushort3>, sampler, float2 location);
>+native ushort3 Sample(Texture2D<ushort3>, sampler, float2 location);
>+native ushort3 Sample(Texture2D<ushort3>, sampler, float2 location, int2 offset);
>+native ushort3 Sample(Texture2DArray<ushort3>, sampler, float3 location);
>+native ushort3 Sample(Texture2DArray<ushort3>, sampler, float3 location, int2 offset);
>+native ushort3 Sample(Texture3D<ushort3>, sampler, float3 location);
>+native ushort3 Sample(Texture3D<ushort3>, sampler, float3 location, int3 offset);
>+native ushort3 Sample(TextureCube<ushort3>, sampler, float3 location);
>+native ushort4 Sample(Texture1D<ushort4>, sampler, float location);
>+native ushort4 Sample(Texture1DArray<ushort4>, sampler, float2 location);
>+native ushort4 Sample(Texture2D<ushort4>, sampler, float2 location);
>+native ushort4 Sample(Texture2D<ushort4>, sampler, float2 location, int2 offset);
>+native ushort4 Sample(Texture2DArray<ushort4>, sampler, float3 location);
>+native ushort4 Sample(Texture2DArray<ushort4>, sampler, float3 location, int2 offset);
>+native ushort4 Sample(Texture3D<ushort4>, sampler, float3 location);
>+native ushort4 Sample(Texture3D<ushort4>, sampler, float3 location, int3 offset);
>+native ushort4 Sample(TextureCube<ushort4>, sampler, float3 location);
>+native uint Sample(Texture1D<uint>, sampler, float location);
>+native uint Sample(Texture1DArray<uint>, sampler, float2 location);
>+native uint Sample(Texture2D<uint>, sampler, float2 location);
>+native uint Sample(Texture2D<uint>, sampler, float2 location, int2 offset);
>+native uint Sample(Texture2DArray<uint>, sampler, float3 location);
>+native uint Sample(Texture2DArray<uint>, sampler, float3 location, int2 offset);
>+native uint Sample(Texture3D<uint>, sampler, float3 location);
>+native uint Sample(Texture3D<uint>, sampler, float3 location, int3 offset);
>+native uint Sample(TextureCube<uint>, sampler, float3 location);
>+native uint2 Sample(Texture1D<uint2>, sampler, float location);
>+native uint2 Sample(Texture1DArray<uint2>, sampler, float2 location);
>+native uint2 Sample(Texture2D<uint2>, sampler, float2 location);
>+native uint2 Sample(Texture2D<uint2>, sampler, float2 location, int2 offset);
>+native uint2 Sample(Texture2DArray<uint2>, sampler, float3 location);
>+native uint2 Sample(Texture2DArray<uint2>, sampler, float3 location, int2 offset);
>+native uint2 Sample(Texture3D<uint2>, sampler, float3 location);
>+native uint2 Sample(Texture3D<uint2>, sampler, float3 location, int3 offset);
>+native uint2 Sample(TextureCube<uint2>, sampler, float3 location);
>+native uint3 Sample(Texture1D<uint3>, sampler, float location);
>+native uint3 Sample(Texture1DArray<uint3>, sampler, float2 location);
>+native uint3 Sample(Texture2D<uint3>, sampler, float2 location);
>+native uint3 Sample(Texture2D<uint3>, sampler, float2 location, int2 offset);
>+native uint3 Sample(Texture2DArray<uint3>, sampler, float3 location);
>+native uint3 Sample(Texture2DArray<uint3>, sampler, float3 location, int2 offset);
>+native uint3 Sample(Texture3D<uint3>, sampler, float3 location);
>+native uint3 Sample(Texture3D<uint3>, sampler, float3 location, int3 offset);
>+native uint3 Sample(TextureCube<uint3>, sampler, float3 location);
>+native uint4 Sample(Texture1D<uint4>, sampler, float location);
>+native uint4 Sample(Texture1DArray<uint4>, sampler, float2 location);
>+native uint4 Sample(Texture2D<uint4>, sampler, float2 location);
>+native uint4 Sample(Texture2D<uint4>, sampler, float2 location, int2 offset);
>+native uint4 Sample(Texture2DArray<uint4>, sampler, float3 location);
>+native uint4 Sample(Texture2DArray<uint4>, sampler, float3 location, int2 offset);
>+native uint4 Sample(Texture3D<uint4>, sampler, float3 location);
>+native uint4 Sample(Texture3D<uint4>, sampler, float3 location, int3 offset);
>+native uint4 Sample(TextureCube<uint4>, sampler, float3 location);
>+native short Sample(Texture1D<short>, sampler, float location);
>+native short Sample(Texture1DArray<short>, sampler, float2 location);
>+native short Sample(Texture2D<short>, sampler, float2 location);
>+native short Sample(Texture2D<short>, sampler, float2 location, int2 offset);
>+native short Sample(Texture2DArray<short>, sampler, float3 location);
>+native short Sample(Texture2DArray<short>, sampler, float3 location, int2 offset);
>+native short Sample(Texture3D<short>, sampler, float3 location);
>+native short Sample(Texture3D<short>, sampler, float3 location, int3 offset);
>+native short Sample(TextureCube<short>, sampler, float3 location);
>+native short2 Sample(Texture1D<short2>, sampler, float location);
>+native short2 Sample(Texture1DArray<short2>, sampler, float2 location);
>+native short2 Sample(Texture2D<short2>, sampler, float2 location);
>+native short2 Sample(Texture2D<short2>, sampler, float2 location, int2 offset);
>+native short2 Sample(Texture2DArray<short2>, sampler, float3 location);
>+native short2 Sample(Texture2DArray<short2>, sampler, float3 location, int2 offset);
>+native short2 Sample(Texture3D<short2>, sampler, float3 location);
>+native short2 Sample(Texture3D<short2>, sampler, float3 location, int3 offset);
>+native short2 Sample(TextureCube<short2>, sampler, float3 location);
>+native short3 Sample(Texture1D<short3>, sampler, float location);
>+native short3 Sample(Texture1DArray<short3>, sampler, float2 location);
>+native short3 Sample(Texture2D<short3>, sampler, float2 location);
>+native short3 Sample(Texture2D<short3>, sampler, float2 location, int2 offset);
>+native short3 Sample(Texture2DArray<short3>, sampler, float3 location);
>+native short3 Sample(Texture2DArray<short3>, sampler, float3 location, int2 offset);
>+native short3 Sample(Texture3D<short3>, sampler, float3 location);
>+native short3 Sample(Texture3D<short3>, sampler, float3 location, int3 offset);
>+native short3 Sample(TextureCube<short3>, sampler, float3 location);
>+native short4 Sample(Texture1D<short4>, sampler, float location);
>+native short4 Sample(Texture1DArray<short4>, sampler, float2 location);
>+native short4 Sample(Texture2D<short4>, sampler, float2 location);
>+native short4 Sample(Texture2D<short4>, sampler, float2 location, int2 offset);
>+native short4 Sample(Texture2DArray<short4>, sampler, float3 location);
>+native short4 Sample(Texture2DArray<short4>, sampler, float3 location, int2 offset);
>+native short4 Sample(Texture3D<short4>, sampler, float3 location);
>+native short4 Sample(Texture3D<short4>, sampler, float3 location, int3 offset);
>+native short4 Sample(TextureCube<short4>, sampler, float3 location);
>+native int Sample(Texture1D<int>, sampler, float location);
>+native int Sample(Texture1DArray<int>, sampler, float2 location);
>+native int Sample(Texture2D<int>, sampler, float2 location);
>+native int Sample(Texture2D<int>, sampler, float2 location, int2 offset);
>+native int Sample(Texture2DArray<int>, sampler, float3 location);
>+native int Sample(Texture2DArray<int>, sampler, float3 location, int2 offset);
>+native int Sample(Texture3D<int>, sampler, float3 location);
>+native int Sample(Texture3D<int>, sampler, float3 location, int3 offset);
>+native int Sample(TextureCube<int>, sampler, float3 location);
>+native int2 Sample(Texture1D<int2>, sampler, float location);
>+native int2 Sample(Texture1DArray<int2>, sampler, float2 location);
>+native int2 Sample(Texture2D<int2>, sampler, float2 location);
> native int2 Sample(Texture2D<int2>, sampler, float2 location, int2 offset);
> native int2 Sample(Texture2DArray<int2>, sampler, float3 location);
> native int2 Sample(Texture2DArray<int2>, sampler, float3 location, int2 offset);
>@@ -1021,155 +62309,20719 @@ native float Sample(TextureDepth2DArray<float>, sampler, float3 location);
> native float Sample(TextureDepth2DArray<float>, sampler, float3 location, int2 offset);
> native float Sample(TextureDepthCube<float>, sampler, float3 location);
> 
>-native ushort Load(Texture1D<ushort>, int location);
>-native ushort Load(Texture1DArray<ushort>, int2 location);
>-native ushort Load(Texture2D<ushort>, int2 location);
>-native ushort Load(Texture2DArray<ushort>, int3 location);
>-native ushort Load(Texture3D<ushort>, int3 location);
>-native ushort2 Load(Texture1D<ushort2>, int location);
>-native ushort2 Load(Texture1DArray<ushort2>, int2 location);
>-native ushort2 Load(Texture2D<ushort2>, int2 location);
>-native ushort2 Load(Texture2DArray<ushort2>, int3 location);
>-native ushort2 Load(Texture3D<ushort2>, int3 location);
>-native ushort3 Load(Texture1D<ushort3>, int location);
>-native ushort3 Load(Texture1DArray<ushort3>, int2 location);
>-native ushort3 Load(Texture2D<ushort3>, int2 location);
>-native ushort3 Load(Texture2DArray<ushort3>, int3 location);
>-native ushort3 Load(Texture3D<ushort3>, int3 location);
>-native ushort4 Load(Texture1D<ushort4>, int location);
>-native ushort4 Load(Texture1DArray<ushort4>, int2 location);
>-native ushort4 Load(Texture2D<ushort4>, int2 location);
>-native ushort4 Load(Texture2DArray<ushort4>, int3 location);
>-native ushort4 Load(Texture3D<ushort4>, int3 location);
>-native uint Load(Texture1D<uint>, int location);
>-native uint Load(Texture1DArray<uint>, int2 location);
>-native uint Load(Texture2D<uint>, int2 location);
>-native uint Load(Texture2DArray<uint>, int3 location);
>-native uint Load(Texture3D<uint>, int3 location);
>-native uint2 Load(Texture1D<uint2>, int location);
>-native uint2 Load(Texture1DArray<uint2>, int2 location);
>-native uint2 Load(Texture2D<uint2>, int2 location);
>-native uint2 Load(Texture2DArray<uint2>, int3 location);
>-native uint2 Load(Texture3D<uint2>, int3 location);
>-native uint3 Load(Texture1D<uint3>, int location);
>-native uint3 Load(Texture1DArray<uint3>, int2 location);
>-native uint3 Load(Texture2D<uint3>, int2 location);
>-native uint3 Load(Texture2DArray<uint3>, int3 location);
>-native uint3 Load(Texture3D<uint3>, int3 location);
>-native uint4 Load(Texture1D<uint4>, int location);
>-native uint4 Load(Texture1DArray<uint4>, int2 location);
>-native uint4 Load(Texture2D<uint4>, int2 location);
>-native uint4 Load(Texture2DArray<uint4>, int3 location);
>-native uint4 Load(Texture3D<uint4>, int3 location);
>-native short Load(Texture1D<short>, int location);
>-native short Load(Texture1DArray<short>, int2 location);
>-native short Load(Texture2D<short>, int2 location);
>-native short Load(Texture2DArray<short>, int3 location);
>-native short Load(Texture3D<short>, int3 location);
>-native short2 Load(Texture1D<short2>, int location);
>-native short2 Load(Texture1DArray<short2>, int2 location);
>-native short2 Load(Texture2D<short2>, int2 location);
>-native short2 Load(Texture2DArray<short2>, int3 location);
>-native short2 Load(Texture3D<short2>, int3 location);
>-native short3 Load(Texture1D<short3>, int location);
>-native short3 Load(Texture1DArray<short3>, int2 location);
>-native short3 Load(Texture2D<short3>, int2 location);
>-native short3 Load(Texture2DArray<short3>, int3 location);
>-native short3 Load(Texture3D<short3>, int3 location);
>-native short4 Load(Texture1D<short4>, int location);
>-native short4 Load(Texture1DArray<short4>, int2 location);
>-native short4 Load(Texture2D<short4>, int2 location);
>-native short4 Load(Texture2DArray<short4>, int3 location);
>-native short4 Load(Texture3D<short4>, int3 location);
>-native int Load(Texture1D<int>, int location);
>-native int Load(Texture1DArray<int>, int2 location);
>-native int Load(Texture2D<int>, int2 location);
>-native int Load(Texture2DArray<int>, int3 location);
>-native int Load(Texture3D<int>, int3 location);
>-native int2 Load(Texture1D<int2>, int location);
>-native int2 Load(Texture1DArray<int2>, int2 location);
>-native int2 Load(Texture2D<int2>, int2 location);
>-native int2 Load(Texture2DArray<int2>, int3 location);
>-native int2 Load(Texture3D<int2>, int3 location);
>-native int3 Load(Texture1D<int3>, int location);
>-native int3 Load(Texture1DArray<int3>, int2 location);
>-native int3 Load(Texture2D<int3>, int2 location);
>-native int3 Load(Texture2DArray<int3>, int3 location);
>-native int3 Load(Texture3D<int3>, int3 location);
>-native int4 Load(Texture1D<int4>, int location);
>-native int4 Load(Texture1DArray<int4>, int2 location);
>-native int4 Load(Texture2D<int4>, int2 location);
>-native int4 Load(Texture2DArray<int4>, int3 location);
>-native int4 Load(Texture3D<int4>, int3 location);
>-native half Load(Texture1D<half>, int location);
>-native half Load(Texture1DArray<half>, int2 location);
>-native half Load(Texture2D<half>, int2 location);
>-native half Load(Texture2DArray<half>, int3 location);
>-native half Load(Texture3D<half>, int3 location);
>-native half2 Load(Texture1D<half2>, int location);
>-native half2 Load(Texture1DArray<half2>, int2 location);
>-native half2 Load(Texture2D<half2>, int2 location);
>-native half2 Load(Texture2DArray<half2>, int3 location);
>-native half2 Load(Texture3D<half2>, int3 location);
>-native half3 Load(Texture1D<half3>, int location);
>-native half3 Load(Texture1DArray<half3>, int2 location);
>-native half3 Load(Texture2D<half3>, int2 location);
>-native half3 Load(Texture2DArray<half3>, int3 location);
>-native half3 Load(Texture3D<half3>, int3 location);
>-native half4 Load(Texture1D<half4>, int location);
>-native half4 Load(Texture1DArray<half4>, int2 location);
>-native half4 Load(Texture2D<half4>, int2 location);
>-native half4 Load(Texture2DArray<half4>, int3 location);
>-native half4 Load(Texture3D<half4>, int3 location);
>-native float Load(Texture1D<float>, int location);
>-native float Load(Texture1DArray<float>, int2 location);
>-native float Load(Texture2D<float>, int2 location);
>-native float Load(Texture2DArray<float>, int3 location);
>-native float Load(Texture3D<float>, int3 location);
>-native float2 Load(Texture1D<float2>, int location);
>-native float2 Load(Texture1DArray<float2>, int2 location);
>-native float2 Load(Texture2D<float2>, int2 location);
>-native float2 Load(Texture2DArray<float2>, int3 location);
>-native float2 Load(Texture3D<float2>, int3 location);
>-native float3 Load(Texture1D<float3>, int location);
>-native float3 Load(Texture1DArray<float3>, int2 location);
>-native float3 Load(Texture2D<float3>, int2 location);
>-native float3 Load(Texture2DArray<float3>, int3 location);
>-native float3 Load(Texture3D<float3>, int3 location);
>-native float4 Load(Texture1D<float4>, int location);
>-native float4 Load(Texture1DArray<float4>, int2 location);
>-native float4 Load(Texture2D<float4>, int2 location);
>-native float4 Load(Texture2DArray<float4>, int3 location);
>-native float4 Load(Texture3D<float4>, int3 location);
>-native float Load(TextureDepth2D<float>, int2 location);
>-native float Load(TextureDepth2DArray<float>, int3 location);
>+/* Functions named operator.zwx= */
>+bool4 operator.zwx=(bool4 v, bool3 c) {
>+    bool4 result = v;
>+    result.z = c.x;
>+    result.w = c.y;
>+    result.x = c.z;
>+    return result;
>+}
>+uchar4 operator.zwx=(uchar4 v, uchar3 c) {
>+    uchar4 result = v;
>+    result.z = c.x;
>+    result.w = c.y;
>+    result.x = c.z;
>+    return result;
>+}
>+ushort4 operator.zwx=(ushort4 v, ushort3 c) {
>+    ushort4 result = v;
>+    result.z = c.x;
>+    result.w = c.y;
>+    result.x = c.z;
>+    return result;
>+}
>+uint4 operator.zwx=(uint4 v, uint3 c) {
>+    uint4 result = v;
>+    result.z = c.x;
>+    result.w = c.y;
>+    result.x = c.z;
>+    return result;
>+}
>+char4 operator.zwx=(char4 v, char3 c) {
>+    char4 result = v;
>+    result.z = c.x;
>+    result.w = c.y;
>+    result.x = c.z;
>+    return result;
>+}
>+short4 operator.zwx=(short4 v, short3 c) {
>+    short4 result = v;
>+    result.z = c.x;
>+    result.w = c.y;
>+    result.x = c.z;
>+    return result;
>+}
>+int4 operator.zwx=(int4 v, int3 c) {
>+    int4 result = v;
>+    result.z = c.x;
>+    result.w = c.y;
>+    result.x = c.z;
>+    return result;
>+}
>+half4 operator.zwx=(half4 v, half3 c) {
>+    half4 result = v;
>+    result.z = c.x;
>+    result.w = c.y;
>+    result.x = c.z;
>+    return result;
>+}
>+float4 operator.zwx=(float4 v, float3 c) {
>+    float4 result = v;
>+    result.z = c.x;
>+    result.w = c.y;
>+    result.x = c.z;
>+    return result;
>+}
>+
>+/* Functions named operator.zzy */
>+bool3 operator.zzy(bool3 v) {
>+    bool3 result;
>+    result.x = v.z;
>+    result.y = v.z;
>+    result.z = v.y;
>+    return result;
>+}
>+bool3 operator.zzy(bool4 v) {
>+    bool3 result;
>+    result.x = v.z;
>+    result.y = v.z;
>+    result.z = v.y;
>+    return result;
>+}
>+uchar3 operator.zzy(uchar3 v) {
>+    uchar3 result;
>+    result.x = v.z;
>+    result.y = v.z;
>+    result.z = v.y;
>+    return result;
>+}
>+uchar3 operator.zzy(uchar4 v) {
>+    uchar3 result;
>+    result.x = v.z;
>+    result.y = v.z;
>+    result.z = v.y;
>+    return result;
>+}
>+ushort3 operator.zzy(ushort3 v) {
>+    ushort3 result;
>+    result.x = v.z;
>+    result.y = v.z;
>+    result.z = v.y;
>+    return result;
>+}
>+ushort3 operator.zzy(ushort4 v) {
>+    ushort3 result;
>+    result.x = v.z;
>+    result.y = v.z;
>+    result.z = v.y;
>+    return result;
>+}
>+uint3 operator.zzy(uint3 v) {
>+    uint3 result;
>+    result.x = v.z;
>+    result.y = v.z;
>+    result.z = v.y;
>+    return result;
>+}
>+uint3 operator.zzy(uint4 v) {
>+    uint3 result;
>+    result.x = v.z;
>+    result.y = v.z;
>+    result.z = v.y;
>+    return result;
>+}
>+char3 operator.zzy(char3 v) {
>+    char3 result;
>+    result.x = v.z;
>+    result.y = v.z;
>+    result.z = v.y;
>+    return result;
>+}
>+char3 operator.zzy(char4 v) {
>+    char3 result;
>+    result.x = v.z;
>+    result.y = v.z;
>+    result.z = v.y;
>+    return result;
>+}
>+short3 operator.zzy(short3 v) {
>+    short3 result;
>+    result.x = v.z;
>+    result.y = v.z;
>+    result.z = v.y;
>+    return result;
>+}
>+short3 operator.zzy(short4 v) {
>+    short3 result;
>+    result.x = v.z;
>+    result.y = v.z;
>+    result.z = v.y;
>+    return result;
>+}
>+int3 operator.zzy(int3 v) {
>+    int3 result;
>+    result.x = v.z;
>+    result.y = v.z;
>+    result.z = v.y;
>+    return result;
>+}
>+int3 operator.zzy(int4 v) {
>+    int3 result;
>+    result.x = v.z;
>+    result.y = v.z;
>+    result.z = v.y;
>+    return result;
>+}
>+half3 operator.zzy(half3 v) {
>+    half3 result;
>+    result.x = v.z;
>+    result.y = v.z;
>+    result.z = v.y;
>+    return result;
>+}
>+half3 operator.zzy(half4 v) {
>+    half3 result;
>+    result.x = v.z;
>+    result.y = v.z;
>+    result.z = v.y;
>+    return result;
>+}
>+float3 operator.zzy(float3 v) {
>+    float3 result;
>+    result.x = v.z;
>+    result.y = v.z;
>+    result.z = v.y;
>+    return result;
>+}
>+float3 operator.zzy(float4 v) {
>+    float3 result;
>+    result.x = v.z;
>+    result.y = v.z;
>+    result.z = v.y;
>+    return result;
>+}
>+
>+/* Functions named operator.wywy */
>+bool4 operator.wywy(bool4 v) {
>+    bool4 result;
>+    result.x = v.w;
>+    result.y = v.y;
>+    result.z = v.w;
>+    result.w = v.y;
>+    return result;
>+}
>+uchar4 operator.wywy(uchar4 v) {
>+    uchar4 result;
>+    result.x = v.w;
>+    result.y = v.y;
>+    result.z = v.w;
>+    result.w = v.y;
>+    return result;
>+}
>+ushort4 operator.wywy(ushort4 v) {
>+    ushort4 result;
>+    result.x = v.w;
>+    result.y = v.y;
>+    result.z = v.w;
>+    result.w = v.y;
>+    return result;
>+}
>+uint4 operator.wywy(uint4 v) {
>+    uint4 result;
>+    result.x = v.w;
>+    result.y = v.y;
>+    result.z = v.w;
>+    result.w = v.y;
>+    return result;
>+}
>+char4 operator.wywy(char4 v) {
>+    char4 result;
>+    result.x = v.w;
>+    result.y = v.y;
>+    result.z = v.w;
>+    result.w = v.y;
>+    return result;
>+}
>+short4 operator.wywy(short4 v) {
>+    short4 result;
>+    result.x = v.w;
>+    result.y = v.y;
>+    result.z = v.w;
>+    result.w = v.y;
>+    return result;
>+}
>+int4 operator.wywy(int4 v) {
>+    int4 result;
>+    result.x = v.w;
>+    result.y = v.y;
>+    result.z = v.w;
>+    result.w = v.y;
>+    return result;
>+}
>+half4 operator.wywy(half4 v) {
>+    half4 result;
>+    result.x = v.w;
>+    result.y = v.y;
>+    result.z = v.w;
>+    result.w = v.y;
>+    return result;
>+}
>+float4 operator.wywy(float4 v) {
>+    float4 result;
>+    result.x = v.w;
>+    result.y = v.y;
>+    result.z = v.w;
>+    result.w = v.y;
>+    return result;
>+}
>+
>+/* Functions named operator.wxxx */
>+bool4 operator.wxxx(bool4 v) {
>+    bool4 result;
>+    result.x = v.w;
>+    result.y = v.x;
>+    result.z = v.x;
>+    result.w = v.x;
>+    return result;
>+}
>+uchar4 operator.wxxx(uchar4 v) {
>+    uchar4 result;
>+    result.x = v.w;
>+    result.y = v.x;
>+    result.z = v.x;
>+    result.w = v.x;
>+    return result;
>+}
>+ushort4 operator.wxxx(ushort4 v) {
>+    ushort4 result;
>+    result.x = v.w;
>+    result.y = v.x;
>+    result.z = v.x;
>+    result.w = v.x;
>+    return result;
>+}
>+uint4 operator.wxxx(uint4 v) {
>+    uint4 result;
>+    result.x = v.w;
>+    result.y = v.x;
>+    result.z = v.x;
>+    result.w = v.x;
>+    return result;
>+}
>+char4 operator.wxxx(char4 v) {
>+    char4 result;
>+    result.x = v.w;
>+    result.y = v.x;
>+    result.z = v.x;
>+    result.w = v.x;
>+    return result;
>+}
>+short4 operator.wxxx(short4 v) {
>+    short4 result;
>+    result.x = v.w;
>+    result.y = v.x;
>+    result.z = v.x;
>+    result.w = v.x;
>+    return result;
>+}
>+int4 operator.wxxx(int4 v) {
>+    int4 result;
>+    result.x = v.w;
>+    result.y = v.x;
>+    result.z = v.x;
>+    result.w = v.x;
>+    return result;
>+}
>+half4 operator.wxxx(half4 v) {
>+    half4 result;
>+    result.x = v.w;
>+    result.y = v.x;
>+    result.z = v.x;
>+    result.w = v.x;
>+    return result;
>+}
>+float4 operator.wxxx(float4 v) {
>+    float4 result;
>+    result.x = v.w;
>+    result.y = v.x;
>+    result.z = v.x;
>+    result.w = v.x;
>+    return result;
>+}
>+
>+/* Functions named sinh */
>+native float sinh(float);
>+half sinh(half x) {
>+    return half(sinh(float(x)));
>+}
>+half2 sinh(half2 x) {
>+    half2 result;
>+    result[0] = sinh(x[0]);
>+    result[1] = sinh(x[1]);
>+    return result;
>+}
>+half3 sinh(half3 x) {
>+    half3 result;
>+    result[0] = sinh(x[0]);
>+    result[1] = sinh(x[1]);
>+    result[2] = sinh(x[2]);
>+    return result;
>+}
>+half4 sinh(half4 x) {
>+    half4 result;
>+    result[0] = sinh(x[0]);
>+    result[1] = sinh(x[1]);
>+    result[2] = sinh(x[2]);
>+    result[3] = sinh(x[3]);
>+    return result;
>+}
>+half2x2 sinh(half2x2 x) {
>+    half2x2 result;
>+    result[0][0] = sinh(x[0][0]);
>+    result[0][1] = sinh(x[0][1]);
>+    result[1][0] = sinh(x[1][0]);
>+    result[1][1] = sinh(x[1][1]);
>+    return result;
>+}
>+half2x3 sinh(half2x3 x) {
>+    half2x3 result;
>+    result[0][0] = sinh(x[0][0]);
>+    result[0][1] = sinh(x[0][1]);
>+    result[0][2] = sinh(x[0][2]);
>+    result[1][0] = sinh(x[1][0]);
>+    result[1][1] = sinh(x[1][1]);
>+    result[1][2] = sinh(x[1][2]);
>+    return result;
>+}
>+half2x4 sinh(half2x4 x) {
>+    half2x4 result;
>+    result[0][0] = sinh(x[0][0]);
>+    result[0][1] = sinh(x[0][1]);
>+    result[0][2] = sinh(x[0][2]);
>+    result[0][3] = sinh(x[0][3]);
>+    result[1][0] = sinh(x[1][0]);
>+    result[1][1] = sinh(x[1][1]);
>+    result[1][2] = sinh(x[1][2]);
>+    result[1][3] = sinh(x[1][3]);
>+    return result;
>+}
>+half3x2 sinh(half3x2 x) {
>+    half3x2 result;
>+    result[0][0] = sinh(x[0][0]);
>+    result[0][1] = sinh(x[0][1]);
>+    result[1][0] = sinh(x[1][0]);
>+    result[1][1] = sinh(x[1][1]);
>+    result[2][0] = sinh(x[2][0]);
>+    result[2][1] = sinh(x[2][1]);
>+    return result;
>+}
>+half3x3 sinh(half3x3 x) {
>+    half3x3 result;
>+    result[0][0] = sinh(x[0][0]);
>+    result[0][1] = sinh(x[0][1]);
>+    result[0][2] = sinh(x[0][2]);
>+    result[1][0] = sinh(x[1][0]);
>+    result[1][1] = sinh(x[1][1]);
>+    result[1][2] = sinh(x[1][2]);
>+    result[2][0] = sinh(x[2][0]);
>+    result[2][1] = sinh(x[2][1]);
>+    result[2][2] = sinh(x[2][2]);
>+    return result;
>+}
>+half3x4 sinh(half3x4 x) {
>+    half3x4 result;
>+    result[0][0] = sinh(x[0][0]);
>+    result[0][1] = sinh(x[0][1]);
>+    result[0][2] = sinh(x[0][2]);
>+    result[0][3] = sinh(x[0][3]);
>+    result[1][0] = sinh(x[1][0]);
>+    result[1][1] = sinh(x[1][1]);
>+    result[1][2] = sinh(x[1][2]);
>+    result[1][3] = sinh(x[1][3]);
>+    result[2][0] = sinh(x[2][0]);
>+    result[2][1] = sinh(x[2][1]);
>+    result[2][2] = sinh(x[2][2]);
>+    result[2][3] = sinh(x[2][3]);
>+    return result;
>+}
>+half4x2 sinh(half4x2 x) {
>+    half4x2 result;
>+    result[0][0] = sinh(x[0][0]);
>+    result[0][1] = sinh(x[0][1]);
>+    result[1][0] = sinh(x[1][0]);
>+    result[1][1] = sinh(x[1][1]);
>+    result[2][0] = sinh(x[2][0]);
>+    result[2][1] = sinh(x[2][1]);
>+    result[3][0] = sinh(x[3][0]);
>+    result[3][1] = sinh(x[3][1]);
>+    return result;
>+}
>+half4x3 sinh(half4x3 x) {
>+    half4x3 result;
>+    result[0][0] = sinh(x[0][0]);
>+    result[0][1] = sinh(x[0][1]);
>+    result[0][2] = sinh(x[0][2]);
>+    result[1][0] = sinh(x[1][0]);
>+    result[1][1] = sinh(x[1][1]);
>+    result[1][2] = sinh(x[1][2]);
>+    result[2][0] = sinh(x[2][0]);
>+    result[2][1] = sinh(x[2][1]);
>+    result[2][2] = sinh(x[2][2]);
>+    result[3][0] = sinh(x[3][0]);
>+    result[3][1] = sinh(x[3][1]);
>+    result[3][2] = sinh(x[3][2]);
>+    return result;
>+}
>+half4x4 sinh(half4x4 x) {
>+    half4x4 result;
>+    result[0][0] = sinh(x[0][0]);
>+    result[0][1] = sinh(x[0][1]);
>+    result[0][2] = sinh(x[0][2]);
>+    result[0][3] = sinh(x[0][3]);
>+    result[1][0] = sinh(x[1][0]);
>+    result[1][1] = sinh(x[1][1]);
>+    result[1][2] = sinh(x[1][2]);
>+    result[1][3] = sinh(x[1][3]);
>+    result[2][0] = sinh(x[2][0]);
>+    result[2][1] = sinh(x[2][1]);
>+    result[2][2] = sinh(x[2][2]);
>+    result[2][3] = sinh(x[2][3]);
>+    result[3][0] = sinh(x[3][0]);
>+    result[3][1] = sinh(x[3][1]);
>+    result[3][2] = sinh(x[3][2]);
>+    result[3][3] = sinh(x[3][3]);
>+    return result;
>+}
>+float2 sinh(float2 x) {
>+    float2 result;
>+    result[0] = sinh(x[0]);
>+    result[1] = sinh(x[1]);
>+    return result;
>+}
>+float3 sinh(float3 x) {
>+    float3 result;
>+    result[0] = sinh(x[0]);
>+    result[1] = sinh(x[1]);
>+    result[2] = sinh(x[2]);
>+    return result;
>+}
>+float4 sinh(float4 x) {
>+    float4 result;
>+    result[0] = sinh(x[0]);
>+    result[1] = sinh(x[1]);
>+    result[2] = sinh(x[2]);
>+    result[3] = sinh(x[3]);
>+    return result;
>+}
>+float2x2 sinh(float2x2 x) {
>+    float2x2 result;
>+    result[0][0] = sinh(x[0][0]);
>+    result[0][1] = sinh(x[0][1]);
>+    result[1][0] = sinh(x[1][0]);
>+    result[1][1] = sinh(x[1][1]);
>+    return result;
>+}
>+float2x3 sinh(float2x3 x) {
>+    float2x3 result;
>+    result[0][0] = sinh(x[0][0]);
>+    result[0][1] = sinh(x[0][1]);
>+    result[0][2] = sinh(x[0][2]);
>+    result[1][0] = sinh(x[1][0]);
>+    result[1][1] = sinh(x[1][1]);
>+    result[1][2] = sinh(x[1][2]);
>+    return result;
>+}
>+float2x4 sinh(float2x4 x) {
>+    float2x4 result;
>+    result[0][0] = sinh(x[0][0]);
>+    result[0][1] = sinh(x[0][1]);
>+    result[0][2] = sinh(x[0][2]);
>+    result[0][3] = sinh(x[0][3]);
>+    result[1][0] = sinh(x[1][0]);
>+    result[1][1] = sinh(x[1][1]);
>+    result[1][2] = sinh(x[1][2]);
>+    result[1][3] = sinh(x[1][3]);
>+    return result;
>+}
>+float3x2 sinh(float3x2 x) {
>+    float3x2 result;
>+    result[0][0] = sinh(x[0][0]);
>+    result[0][1] = sinh(x[0][1]);
>+    result[1][0] = sinh(x[1][0]);
>+    result[1][1] = sinh(x[1][1]);
>+    result[2][0] = sinh(x[2][0]);
>+    result[2][1] = sinh(x[2][1]);
>+    return result;
>+}
>+float3x3 sinh(float3x3 x) {
>+    float3x3 result;
>+    result[0][0] = sinh(x[0][0]);
>+    result[0][1] = sinh(x[0][1]);
>+    result[0][2] = sinh(x[0][2]);
>+    result[1][0] = sinh(x[1][0]);
>+    result[1][1] = sinh(x[1][1]);
>+    result[1][2] = sinh(x[1][2]);
>+    result[2][0] = sinh(x[2][0]);
>+    result[2][1] = sinh(x[2][1]);
>+    result[2][2] = sinh(x[2][2]);
>+    return result;
>+}
>+float3x4 sinh(float3x4 x) {
>+    float3x4 result;
>+    result[0][0] = sinh(x[0][0]);
>+    result[0][1] = sinh(x[0][1]);
>+    result[0][2] = sinh(x[0][2]);
>+    result[0][3] = sinh(x[0][3]);
>+    result[1][0] = sinh(x[1][0]);
>+    result[1][1] = sinh(x[1][1]);
>+    result[1][2] = sinh(x[1][2]);
>+    result[1][3] = sinh(x[1][3]);
>+    result[2][0] = sinh(x[2][0]);
>+    result[2][1] = sinh(x[2][1]);
>+    result[2][2] = sinh(x[2][2]);
>+    result[2][3] = sinh(x[2][3]);
>+    return result;
>+}
>+float4x2 sinh(float4x2 x) {
>+    float4x2 result;
>+    result[0][0] = sinh(x[0][0]);
>+    result[0][1] = sinh(x[0][1]);
>+    result[1][0] = sinh(x[1][0]);
>+    result[1][1] = sinh(x[1][1]);
>+    result[2][0] = sinh(x[2][0]);
>+    result[2][1] = sinh(x[2][1]);
>+    result[3][0] = sinh(x[3][0]);
>+    result[3][1] = sinh(x[3][1]);
>+    return result;
>+}
>+float4x3 sinh(float4x3 x) {
>+    float4x3 result;
>+    result[0][0] = sinh(x[0][0]);
>+    result[0][1] = sinh(x[0][1]);
>+    result[0][2] = sinh(x[0][2]);
>+    result[1][0] = sinh(x[1][0]);
>+    result[1][1] = sinh(x[1][1]);
>+    result[1][2] = sinh(x[1][2]);
>+    result[2][0] = sinh(x[2][0]);
>+    result[2][1] = sinh(x[2][1]);
>+    result[2][2] = sinh(x[2][2]);
>+    result[3][0] = sinh(x[3][0]);
>+    result[3][1] = sinh(x[3][1]);
>+    result[3][2] = sinh(x[3][2]);
>+    return result;
>+}
>+float4x4 sinh(float4x4 x) {
>+    float4x4 result;
>+    result[0][0] = sinh(x[0][0]);
>+    result[0][1] = sinh(x[0][1]);
>+    result[0][2] = sinh(x[0][2]);
>+    result[0][3] = sinh(x[0][3]);
>+    result[1][0] = sinh(x[1][0]);
>+    result[1][1] = sinh(x[1][1]);
>+    result[1][2] = sinh(x[1][2]);
>+    result[1][3] = sinh(x[1][3]);
>+    result[2][0] = sinh(x[2][0]);
>+    result[2][1] = sinh(x[2][1]);
>+    result[2][2] = sinh(x[2][2]);
>+    result[2][3] = sinh(x[2][3]);
>+    result[3][0] = sinh(x[3][0]);
>+    result[3][1] = sinh(x[3][1]);
>+    result[3][2] = sinh(x[3][2]);
>+    result[3][3] = sinh(x[3][3]);
>+    return result;
>+}
>+
>+/* Functions named ddy */
>+native float ddy(float);
>+half ddy(half x) {
>+    return half(ddy(float(x)));
>+}
>+half2 ddy(half2 x) {
>+    half2 result;
>+    result[0] = ddy(x[0]);
>+    result[1] = ddy(x[1]);
>+    return result;
>+}
>+half3 ddy(half3 x) {
>+    half3 result;
>+    result[0] = ddy(x[0]);
>+    result[1] = ddy(x[1]);
>+    result[2] = ddy(x[2]);
>+    return result;
>+}
>+half4 ddy(half4 x) {
>+    half4 result;
>+    result[0] = ddy(x[0]);
>+    result[1] = ddy(x[1]);
>+    result[2] = ddy(x[2]);
>+    result[3] = ddy(x[3]);
>+    return result;
>+}
>+half2x2 ddy(half2x2 x) {
>+    half2x2 result;
>+    result[0][0] = ddy(x[0][0]);
>+    result[0][1] = ddy(x[0][1]);
>+    result[1][0] = ddy(x[1][0]);
>+    result[1][1] = ddy(x[1][1]);
>+    return result;
>+}
>+half2x3 ddy(half2x3 x) {
>+    half2x3 result;
>+    result[0][0] = ddy(x[0][0]);
>+    result[0][1] = ddy(x[0][1]);
>+    result[0][2] = ddy(x[0][2]);
>+    result[1][0] = ddy(x[1][0]);
>+    result[1][1] = ddy(x[1][1]);
>+    result[1][2] = ddy(x[1][2]);
>+    return result;
>+}
>+half2x4 ddy(half2x4 x) {
>+    half2x4 result;
>+    result[0][0] = ddy(x[0][0]);
>+    result[0][1] = ddy(x[0][1]);
>+    result[0][2] = ddy(x[0][2]);
>+    result[0][3] = ddy(x[0][3]);
>+    result[1][0] = ddy(x[1][0]);
>+    result[1][1] = ddy(x[1][1]);
>+    result[1][2] = ddy(x[1][2]);
>+    result[1][3] = ddy(x[1][3]);
>+    return result;
>+}
>+half3x2 ddy(half3x2 x) {
>+    half3x2 result;
>+    result[0][0] = ddy(x[0][0]);
>+    result[0][1] = ddy(x[0][1]);
>+    result[1][0] = ddy(x[1][0]);
>+    result[1][1] = ddy(x[1][1]);
>+    result[2][0] = ddy(x[2][0]);
>+    result[2][1] = ddy(x[2][1]);
>+    return result;
>+}
>+half3x3 ddy(half3x3 x) {
>+    half3x3 result;
>+    result[0][0] = ddy(x[0][0]);
>+    result[0][1] = ddy(x[0][1]);
>+    result[0][2] = ddy(x[0][2]);
>+    result[1][0] = ddy(x[1][0]);
>+    result[1][1] = ddy(x[1][1]);
>+    result[1][2] = ddy(x[1][2]);
>+    result[2][0] = ddy(x[2][0]);
>+    result[2][1] = ddy(x[2][1]);
>+    result[2][2] = ddy(x[2][2]);
>+    return result;
>+}
>+half3x4 ddy(half3x4 x) {
>+    half3x4 result;
>+    result[0][0] = ddy(x[0][0]);
>+    result[0][1] = ddy(x[0][1]);
>+    result[0][2] = ddy(x[0][2]);
>+    result[0][3] = ddy(x[0][3]);
>+    result[1][0] = ddy(x[1][0]);
>+    result[1][1] = ddy(x[1][1]);
>+    result[1][2] = ddy(x[1][2]);
>+    result[1][3] = ddy(x[1][3]);
>+    result[2][0] = ddy(x[2][0]);
>+    result[2][1] = ddy(x[2][1]);
>+    result[2][2] = ddy(x[2][2]);
>+    result[2][3] = ddy(x[2][3]);
>+    return result;
>+}
>+half4x2 ddy(half4x2 x) {
>+    half4x2 result;
>+    result[0][0] = ddy(x[0][0]);
>+    result[0][1] = ddy(x[0][1]);
>+    result[1][0] = ddy(x[1][0]);
>+    result[1][1] = ddy(x[1][1]);
>+    result[2][0] = ddy(x[2][0]);
>+    result[2][1] = ddy(x[2][1]);
>+    result[3][0] = ddy(x[3][0]);
>+    result[3][1] = ddy(x[3][1]);
>+    return result;
>+}
>+half4x3 ddy(half4x3 x) {
>+    half4x3 result;
>+    result[0][0] = ddy(x[0][0]);
>+    result[0][1] = ddy(x[0][1]);
>+    result[0][2] = ddy(x[0][2]);
>+    result[1][0] = ddy(x[1][0]);
>+    result[1][1] = ddy(x[1][1]);
>+    result[1][2] = ddy(x[1][2]);
>+    result[2][0] = ddy(x[2][0]);
>+    result[2][1] = ddy(x[2][1]);
>+    result[2][2] = ddy(x[2][2]);
>+    result[3][0] = ddy(x[3][0]);
>+    result[3][1] = ddy(x[3][1]);
>+    result[3][2] = ddy(x[3][2]);
>+    return result;
>+}
>+half4x4 ddy(half4x4 x) {
>+    half4x4 result;
>+    result[0][0] = ddy(x[0][0]);
>+    result[0][1] = ddy(x[0][1]);
>+    result[0][2] = ddy(x[0][2]);
>+    result[0][3] = ddy(x[0][3]);
>+    result[1][0] = ddy(x[1][0]);
>+    result[1][1] = ddy(x[1][1]);
>+    result[1][2] = ddy(x[1][2]);
>+    result[1][3] = ddy(x[1][3]);
>+    result[2][0] = ddy(x[2][0]);
>+    result[2][1] = ddy(x[2][1]);
>+    result[2][2] = ddy(x[2][2]);
>+    result[2][3] = ddy(x[2][3]);
>+    result[3][0] = ddy(x[3][0]);
>+    result[3][1] = ddy(x[3][1]);
>+    result[3][2] = ddy(x[3][2]);
>+    result[3][3] = ddy(x[3][3]);
>+    return result;
>+}
>+float2 ddy(float2 x) {
>+    float2 result;
>+    result[0] = ddy(x[0]);
>+    result[1] = ddy(x[1]);
>+    return result;
>+}
>+float3 ddy(float3 x) {
>+    float3 result;
>+    result[0] = ddy(x[0]);
>+    result[1] = ddy(x[1]);
>+    result[2] = ddy(x[2]);
>+    return result;
>+}
>+float4 ddy(float4 x) {
>+    float4 result;
>+    result[0] = ddy(x[0]);
>+    result[1] = ddy(x[1]);
>+    result[2] = ddy(x[2]);
>+    result[3] = ddy(x[3]);
>+    return result;
>+}
>+float2x2 ddy(float2x2 x) {
>+    float2x2 result;
>+    result[0][0] = ddy(x[0][0]);
>+    result[0][1] = ddy(x[0][1]);
>+    result[1][0] = ddy(x[1][0]);
>+    result[1][1] = ddy(x[1][1]);
>+    return result;
>+}
>+float2x3 ddy(float2x3 x) {
>+    float2x3 result;
>+    result[0][0] = ddy(x[0][0]);
>+    result[0][1] = ddy(x[0][1]);
>+    result[0][2] = ddy(x[0][2]);
>+    result[1][0] = ddy(x[1][0]);
>+    result[1][1] = ddy(x[1][1]);
>+    result[1][2] = ddy(x[1][2]);
>+    return result;
>+}
>+float2x4 ddy(float2x4 x) {
>+    float2x4 result;
>+    result[0][0] = ddy(x[0][0]);
>+    result[0][1] = ddy(x[0][1]);
>+    result[0][2] = ddy(x[0][2]);
>+    result[0][3] = ddy(x[0][3]);
>+    result[1][0] = ddy(x[1][0]);
>+    result[1][1] = ddy(x[1][1]);
>+    result[1][2] = ddy(x[1][2]);
>+    result[1][3] = ddy(x[1][3]);
>+    return result;
>+}
>+float3x2 ddy(float3x2 x) {
>+    float3x2 result;
>+    result[0][0] = ddy(x[0][0]);
>+    result[0][1] = ddy(x[0][1]);
>+    result[1][0] = ddy(x[1][0]);
>+    result[1][1] = ddy(x[1][1]);
>+    result[2][0] = ddy(x[2][0]);
>+    result[2][1] = ddy(x[2][1]);
>+    return result;
>+}
>+float3x3 ddy(float3x3 x) {
>+    float3x3 result;
>+    result[0][0] = ddy(x[0][0]);
>+    result[0][1] = ddy(x[0][1]);
>+    result[0][2] = ddy(x[0][2]);
>+    result[1][0] = ddy(x[1][0]);
>+    result[1][1] = ddy(x[1][1]);
>+    result[1][2] = ddy(x[1][2]);
>+    result[2][0] = ddy(x[2][0]);
>+    result[2][1] = ddy(x[2][1]);
>+    result[2][2] = ddy(x[2][2]);
>+    return result;
>+}
>+float3x4 ddy(float3x4 x) {
>+    float3x4 result;
>+    result[0][0] = ddy(x[0][0]);
>+    result[0][1] = ddy(x[0][1]);
>+    result[0][2] = ddy(x[0][2]);
>+    result[0][3] = ddy(x[0][3]);
>+    result[1][0] = ddy(x[1][0]);
>+    result[1][1] = ddy(x[1][1]);
>+    result[1][2] = ddy(x[1][2]);
>+    result[1][3] = ddy(x[1][3]);
>+    result[2][0] = ddy(x[2][0]);
>+    result[2][1] = ddy(x[2][1]);
>+    result[2][2] = ddy(x[2][2]);
>+    result[2][3] = ddy(x[2][3]);
>+    return result;
>+}
>+float4x2 ddy(float4x2 x) {
>+    float4x2 result;
>+    result[0][0] = ddy(x[0][0]);
>+    result[0][1] = ddy(x[0][1]);
>+    result[1][0] = ddy(x[1][0]);
>+    result[1][1] = ddy(x[1][1]);
>+    result[2][0] = ddy(x[2][0]);
>+    result[2][1] = ddy(x[2][1]);
>+    result[3][0] = ddy(x[3][0]);
>+    result[3][1] = ddy(x[3][1]);
>+    return result;
>+}
>+float4x3 ddy(float4x3 x) {
>+    float4x3 result;
>+    result[0][0] = ddy(x[0][0]);
>+    result[0][1] = ddy(x[0][1]);
>+    result[0][2] = ddy(x[0][2]);
>+    result[1][0] = ddy(x[1][0]);
>+    result[1][1] = ddy(x[1][1]);
>+    result[1][2] = ddy(x[1][2]);
>+    result[2][0] = ddy(x[2][0]);
>+    result[2][1] = ddy(x[2][1]);
>+    result[2][2] = ddy(x[2][2]);
>+    result[3][0] = ddy(x[3][0]);
>+    result[3][1] = ddy(x[3][1]);
>+    result[3][2] = ddy(x[3][2]);
>+    return result;
>+}
>+float4x4 ddy(float4x4 x) {
>+    float4x4 result;
>+    result[0][0] = ddy(x[0][0]);
>+    result[0][1] = ddy(x[0][1]);
>+    result[0][2] = ddy(x[0][2]);
>+    result[0][3] = ddy(x[0][3]);
>+    result[1][0] = ddy(x[1][0]);
>+    result[1][1] = ddy(x[1][1]);
>+    result[1][2] = ddy(x[1][2]);
>+    result[1][3] = ddy(x[1][3]);
>+    result[2][0] = ddy(x[2][0]);
>+    result[2][1] = ddy(x[2][1]);
>+    result[2][2] = ddy(x[2][2]);
>+    result[2][3] = ddy(x[2][3]);
>+    result[3][0] = ddy(x[3][0]);
>+    result[3][1] = ddy(x[3][1]);
>+    result[3][2] = ddy(x[3][2]);
>+    result[3][3] = ddy(x[3][3]);
>+    return result;
>+}
>+
>+/* Functions named operator>= */
>+native bool operator>=(int, int);
>+native bool operator>=(uint, uint);
>+native bool operator>=(float, float);
>+bool operator>=(uchar a, uchar b) {
>+    return uint(a) >= uint(b);
>+}
>+bool operator>=(ushort a, ushort b) {
>+    return uint(a) >= uint(b);
>+}
>+bool operator>=(char a, char b) {
>+    return int(a) >= int(b);
>+}
>+bool operator>=(short a, short b) {
>+    return int(a) >= int(b);
>+}
>+bool operator>=(half a, half b) {
>+    return float(a) <= float(b);
>+}
>+
>+/* Functions named dst */
>+uchar4 dst(uchar4 src0, uchar4 src1) {
>+    uchar4 result;
>+    result.x = 1;
>+    result.y = src0.y * src1.y;
>+    result.z = src0.z;
>+    result.w = src1.w;
>+    return result;
>+}
>+ushort4 dst(ushort4 src0, ushort4 src1) {
>+    ushort4 result;
>+    result.x = 1;
>+    result.y = src0.y * src1.y;
>+    result.z = src0.z;
>+    result.w = src1.w;
>+    return result;
>+}
>+uint4 dst(uint4 src0, uint4 src1) {
>+    uint4 result;
>+    result.x = 1;
>+    result.y = src0.y * src1.y;
>+    result.z = src0.z;
>+    result.w = src1.w;
>+    return result;
>+}
>+char4 dst(char4 src0, char4 src1) {
>+    char4 result;
>+    result.x = 1;
>+    result.y = src0.y * src1.y;
>+    result.z = src0.z;
>+    result.w = src1.w;
>+    return result;
>+}
>+short4 dst(short4 src0, short4 src1) {
>+    short4 result;
>+    result.x = 1;
>+    result.y = src0.y * src1.y;
>+    result.z = src0.z;
>+    result.w = src1.w;
>+    return result;
>+}
>+int4 dst(int4 src0, int4 src1) {
>+    int4 result;
>+    result.x = 1;
>+    result.y = src0.y * src1.y;
>+    result.z = src0.z;
>+    result.w = src1.w;
>+    return result;
>+}
>+half4 dst(half4 src0, half4 src1) {
>+    half4 result;
>+    result.x = 1;
>+    result.y = src0.y * src1.y;
>+    result.z = src0.z;
>+    result.w = src1.w;
>+    return result;
>+}
>+float4 dst(float4 src0, float4 src1) {
>+    float4 result;
>+    result.x = 1;
>+    result.y = src0.y * src1.y;
>+    result.z = src0.z;
>+    result.w = src1.w;
>+    return result;
>+}
>+
>+
>+/* Functions named operator.xyz= */
>+bool3 operator.xyz=(bool3 v, bool3 c) {
>+    bool3 result = v;
>+    result.x = c.x;
>+    result.y = c.y;
>+    result.z = c.z;
>+    return result;
>+}
>+bool4 operator.xyz=(bool4 v, bool3 c) {
>+    bool4 result = v;
>+    result.x = c.x;
>+    result.y = c.y;
>+    result.z = c.z;
>+    return result;
>+}
>+uchar3 operator.xyz=(uchar3 v, uchar3 c) {
>+    uchar3 result = v;
>+    result.x = c.x;
>+    result.y = c.y;
>+    result.z = c.z;
>+    return result;
>+}
>+uchar4 operator.xyz=(uchar4 v, uchar3 c) {
>+    uchar4 result = v;
>+    result.x = c.x;
>+    result.y = c.y;
>+    result.z = c.z;
>+    return result;
>+}
>+ushort3 operator.xyz=(ushort3 v, ushort3 c) {
>+    ushort3 result = v;
>+    result.x = c.x;
>+    result.y = c.y;
>+    result.z = c.z;
>+    return result;
>+}
>+ushort4 operator.xyz=(ushort4 v, ushort3 c) {
>+    ushort4 result = v;
>+    result.x = c.x;
>+    result.y = c.y;
>+    result.z = c.z;
>+    return result;
>+}
>+uint3 operator.xyz=(uint3 v, uint3 c) {
>+    uint3 result = v;
>+    result.x = c.x;
>+    result.y = c.y;
>+    result.z = c.z;
>+    return result;
>+}
>+uint4 operator.xyz=(uint4 v, uint3 c) {
>+    uint4 result = v;
>+    result.x = c.x;
>+    result.y = c.y;
>+    result.z = c.z;
>+    return result;
>+}
>+char3 operator.xyz=(char3 v, char3 c) {
>+    char3 result = v;
>+    result.x = c.x;
>+    result.y = c.y;
>+    result.z = c.z;
>+    return result;
>+}
>+char4 operator.xyz=(char4 v, char3 c) {
>+    char4 result = v;
>+    result.x = c.x;
>+    result.y = c.y;
>+    result.z = c.z;
>+    return result;
>+}
>+short3 operator.xyz=(short3 v, short3 c) {
>+    short3 result = v;
>+    result.x = c.x;
>+    result.y = c.y;
>+    result.z = c.z;
>+    return result;
>+}
>+short4 operator.xyz=(short4 v, short3 c) {
>+    short4 result = v;
>+    result.x = c.x;
>+    result.y = c.y;
>+    result.z = c.z;
>+    return result;
>+}
>+int3 operator.xyz=(int3 v, int3 c) {
>+    int3 result = v;
>+    result.x = c.x;
>+    result.y = c.y;
>+    result.z = c.z;
>+    return result;
>+}
>+int4 operator.xyz=(int4 v, int3 c) {
>+    int4 result = v;
>+    result.x = c.x;
>+    result.y = c.y;
>+    result.z = c.z;
>+    return result;
>+}
>+half3 operator.xyz=(half3 v, half3 c) {
>+    half3 result = v;
>+    result.x = c.x;
>+    result.y = c.y;
>+    result.z = c.z;
>+    return result;
>+}
>+half4 operator.xyz=(half4 v, half3 c) {
>+    half4 result = v;
>+    result.x = c.x;
>+    result.y = c.y;
>+    result.z = c.z;
>+    return result;
>+}
>+float3 operator.xyz=(float3 v, float3 c) {
>+    float3 result = v;
>+    result.x = c.x;
>+    result.y = c.y;
>+    result.z = c.z;
>+    return result;
>+}
>+float4 operator.xyz=(float4 v, float3 c) {
>+    float4 result = v;
>+    result.x = c.x;
>+    result.y = c.y;
>+    result.z = c.z;
>+    return result;
>+}
>+
>+/* Functions named operator.yxxw */
>+bool4 operator.yxxw(bool4 v) {
>+    bool4 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.x;
>+    result.w = v.w;
>+    return result;
>+}
>+uchar4 operator.yxxw(uchar4 v) {
>+    uchar4 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.x;
>+    result.w = v.w;
>+    return result;
>+}
>+ushort4 operator.yxxw(ushort4 v) {
>+    ushort4 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.x;
>+    result.w = v.w;
>+    return result;
>+}
>+uint4 operator.yxxw(uint4 v) {
>+    uint4 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.x;
>+    result.w = v.w;
>+    return result;
>+}
>+char4 operator.yxxw(char4 v) {
>+    char4 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.x;
>+    result.w = v.w;
>+    return result;
>+}
>+short4 operator.yxxw(short4 v) {
>+    short4 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.x;
>+    result.w = v.w;
>+    return result;
>+}
>+int4 operator.yxxw(int4 v) {
>+    int4 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.x;
>+    result.w = v.w;
>+    return result;
>+}
>+half4 operator.yxxw(half4 v) {
>+    half4 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.x;
>+    result.w = v.w;
>+    return result;
>+}
>+float4 operator.yxxw(float4 v) {
>+    float4 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.x;
>+    result.w = v.w;
>+    return result;
>+}
>+
>+/* Functions named operator.wxy */
>+bool3 operator.wxy(bool4 v) {
>+    bool3 result;
>+    result.x = v.w;
>+    result.y = v.x;
>+    result.z = v.y;
>+    return result;
>+}
>+uchar3 operator.wxy(uchar4 v) {
>+    uchar3 result;
>+    result.x = v.w;
>+    result.y = v.x;
>+    result.z = v.y;
>+    return result;
>+}
>+ushort3 operator.wxy(ushort4 v) {
>+    ushort3 result;
>+    result.x = v.w;
>+    result.y = v.x;
>+    result.z = v.y;
>+    return result;
>+}
>+uint3 operator.wxy(uint4 v) {
>+    uint3 result;
>+    result.x = v.w;
>+    result.y = v.x;
>+    result.z = v.y;
>+    return result;
>+}
>+char3 operator.wxy(char4 v) {
>+    char3 result;
>+    result.x = v.w;
>+    result.y = v.x;
>+    result.z = v.y;
>+    return result;
>+}
>+short3 operator.wxy(short4 v) {
>+    short3 result;
>+    result.x = v.w;
>+    result.y = v.x;
>+    result.z = v.y;
>+    return result;
>+}
>+int3 operator.wxy(int4 v) {
>+    int3 result;
>+    result.x = v.w;
>+    result.y = v.x;
>+    result.z = v.y;
>+    return result;
>+}
>+half3 operator.wxy(half4 v) {
>+    half3 result;
>+    result.x = v.w;
>+    result.y = v.x;
>+    result.z = v.y;
>+    return result;
>+}
>+float3 operator.wxy(float4 v) {
>+    float3 result;
>+    result.x = v.w;
>+    result.y = v.x;
>+    result.z = v.y;
>+    return result;
>+}
>+
>+/* Functions named dot */
>+uchar dot(uchar a, uchar b) {
>+    return a * b;
>+}
>+uchar dot(uchar2 a, uchar2 b) {
>+    uchar result = 0;
>+    result = result + a[0] * b[0];
>+    result = result + a[1] * b[1];
>+    return result;
>+}
>+uchar dot(uchar3 a, uchar3 b) {
>+    uchar result = 0;
>+    result = result + a[0] * b[0];
>+    result = result + a[1] * b[1];
>+    result = result + a[2] * b[2];
>+    return result;
>+}
>+uchar dot(uchar4 a, uchar4 b) {
>+    uchar result = 0;
>+    result = result + a[0] * b[0];
>+    result = result + a[1] * b[1];
>+    result = result + a[2] * b[2];
>+    result = result + a[3] * b[3];
>+    return result;
>+}
>+ushort dot(ushort a, ushort b) {
>+    return a * b;
>+}
>+ushort dot(ushort2 a, ushort2 b) {
>+    ushort result = 0;
>+    result = result + a[0] * b[0];
>+    result = result + a[1] * b[1];
>+    return result;
>+}
>+ushort dot(ushort3 a, ushort3 b) {
>+    ushort result = 0;
>+    result = result + a[0] * b[0];
>+    result = result + a[1] * b[1];
>+    result = result + a[2] * b[2];
>+    return result;
>+}
>+ushort dot(ushort4 a, ushort4 b) {
>+    ushort result = 0;
>+    result = result + a[0] * b[0];
>+    result = result + a[1] * b[1];
>+    result = result + a[2] * b[2];
>+    result = result + a[3] * b[3];
>+    return result;
>+}
>+uint dot(uint a, uint b) {
>+    return a * b;
>+}
>+uint dot(uint2 a, uint2 b) {
>+    uint result = 0;
>+    result = result + a[0] * b[0];
>+    result = result + a[1] * b[1];
>+    return result;
>+}
>+uint dot(uint3 a, uint3 b) {
>+    uint result = 0;
>+    result = result + a[0] * b[0];
>+    result = result + a[1] * b[1];
>+    result = result + a[2] * b[2];
>+    return result;
>+}
>+uint dot(uint4 a, uint4 b) {
>+    uint result = 0;
>+    result = result + a[0] * b[0];
>+    result = result + a[1] * b[1];
>+    result = result + a[2] * b[2];
>+    result = result + a[3] * b[3];
>+    return result;
>+}
>+char dot(char a, char b) {
>+    return a * b;
>+}
>+char dot(char2 a, char2 b) {
>+    char result = 0;
>+    result = result + a[0] * b[0];
>+    result = result + a[1] * b[1];
>+    return result;
>+}
>+char dot(char3 a, char3 b) {
>+    char result = 0;
>+    result = result + a[0] * b[0];
>+    result = result + a[1] * b[1];
>+    result = result + a[2] * b[2];
>+    return result;
>+}
>+char dot(char4 a, char4 b) {
>+    char result = 0;
>+    result = result + a[0] * b[0];
>+    result = result + a[1] * b[1];
>+    result = result + a[2] * b[2];
>+    result = result + a[3] * b[3];
>+    return result;
>+}
>+short dot(short a, short b) {
>+    return a * b;
>+}
>+short dot(short2 a, short2 b) {
>+    short result = 0;
>+    result = result + a[0] * b[0];
>+    result = result + a[1] * b[1];
>+    return result;
>+}
>+short dot(short3 a, short3 b) {
>+    short result = 0;
>+    result = result + a[0] * b[0];
>+    result = result + a[1] * b[1];
>+    result = result + a[2] * b[2];
>+    return result;
>+}
>+short dot(short4 a, short4 b) {
>+    short result = 0;
>+    result = result + a[0] * b[0];
>+    result = result + a[1] * b[1];
>+    result = result + a[2] * b[2];
>+    result = result + a[3] * b[3];
>+    return result;
>+}
>+int dot(int a, int b) {
>+    return a * b;
>+}
>+int dot(int2 a, int2 b) {
>+    int result = 0;
>+    result = result + a[0] * b[0];
>+    result = result + a[1] * b[1];
>+    return result;
>+}
>+int dot(int3 a, int3 b) {
>+    int result = 0;
>+    result = result + a[0] * b[0];
>+    result = result + a[1] * b[1];
>+    result = result + a[2] * b[2];
>+    return result;
>+}
>+int dot(int4 a, int4 b) {
>+    int result = 0;
>+    result = result + a[0] * b[0];
>+    result = result + a[1] * b[1];
>+    result = result + a[2] * b[2];
>+    result = result + a[3] * b[3];
>+    return result;
>+}
>+half dot(half a, half b) {
>+    return a * b;
>+}
>+half dot(half2 a, half2 b) {
>+    half result = 0;
>+    result = result + a[0] * b[0];
>+    result = result + a[1] * b[1];
>+    return result;
>+}
>+half dot(half3 a, half3 b) {
>+    half result = 0;
>+    result = result + a[0] * b[0];
>+    result = result + a[1] * b[1];
>+    result = result + a[2] * b[2];
>+    return result;
>+}
>+half dot(half4 a, half4 b) {
>+    half result = 0;
>+    result = result + a[0] * b[0];
>+    result = result + a[1] * b[1];
>+    result = result + a[2] * b[2];
>+    result = result + a[3] * b[3];
>+    return result;
>+}
>+float dot(float a, float b) {
>+    return a * b;
>+}
>+float dot(float2 a, float2 b) {
>+    float result = 0;
>+    result = result + a[0] * b[0];
>+    result = result + a[1] * b[1];
>+    return result;
>+}
>+float dot(float3 a, float3 b) {
>+    float result = 0;
>+    result = result + a[0] * b[0];
>+    result = result + a[1] * b[1];
>+    result = result + a[2] * b[2];
>+    return result;
>+}
>+float dot(float4 a, float4 b) {
>+    float result = 0;
>+    result = result + a[0] * b[0];
>+    result = result + a[1] * b[1];
>+    result = result + a[2] * b[2];
>+    result = result + a[3] * b[3];
>+    return result;
>+}
>+
>+
>+/* Functions named operator.zxyw= */
>+bool4 operator.zxyw=(bool4 v, bool4 c) {
>+    bool4 result = v;
>+    result.z = c.x;
>+    result.x = c.y;
>+    result.y = c.z;
>+    result.w = c.w;
>+    return result;
>+}
>+uchar4 operator.zxyw=(uchar4 v, uchar4 c) {
>+    uchar4 result = v;
>+    result.z = c.x;
>+    result.x = c.y;
>+    result.y = c.z;
>+    result.w = c.w;
>+    return result;
>+}
>+ushort4 operator.zxyw=(ushort4 v, ushort4 c) {
>+    ushort4 result = v;
>+    result.z = c.x;
>+    result.x = c.y;
>+    result.y = c.z;
>+    result.w = c.w;
>+    return result;
>+}
>+uint4 operator.zxyw=(uint4 v, uint4 c) {
>+    uint4 result = v;
>+    result.z = c.x;
>+    result.x = c.y;
>+    result.y = c.z;
>+    result.w = c.w;
>+    return result;
>+}
>+char4 operator.zxyw=(char4 v, char4 c) {
>+    char4 result = v;
>+    result.z = c.x;
>+    result.x = c.y;
>+    result.y = c.z;
>+    result.w = c.w;
>+    return result;
>+}
>+short4 operator.zxyw=(short4 v, short4 c) {
>+    short4 result = v;
>+    result.z = c.x;
>+    result.x = c.y;
>+    result.y = c.z;
>+    result.w = c.w;
>+    return result;
>+}
>+int4 operator.zxyw=(int4 v, int4 c) {
>+    int4 result = v;
>+    result.z = c.x;
>+    result.x = c.y;
>+    result.y = c.z;
>+    result.w = c.w;
>+    return result;
>+}
>+half4 operator.zxyw=(half4 v, half4 c) {
>+    half4 result = v;
>+    result.z = c.x;
>+    result.x = c.y;
>+    result.y = c.z;
>+    result.w = c.w;
>+    return result;
>+}
>+float4 operator.zxyw=(float4 v, float4 c) {
>+    float4 result = v;
>+    result.z = c.x;
>+    result.x = c.y;
>+    result.y = c.z;
>+    result.w = c.w;
>+    return result;
>+}
>+
>+/* Functions named operator.yyw */
>+bool3 operator.yyw(bool4 v) {
>+    bool3 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.w;
>+    return result;
>+}
>+uchar3 operator.yyw(uchar4 v) {
>+    uchar3 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.w;
>+    return result;
>+}
>+ushort3 operator.yyw(ushort4 v) {
>+    ushort3 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.w;
>+    return result;
>+}
>+uint3 operator.yyw(uint4 v) {
>+    uint3 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.w;
>+    return result;
>+}
>+char3 operator.yyw(char4 v) {
>+    char3 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.w;
>+    return result;
>+}
>+short3 operator.yyw(short4 v) {
>+    short3 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.w;
>+    return result;
>+}
>+int3 operator.yyw(int4 v) {
>+    int3 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.w;
>+    return result;
>+}
>+half3 operator.yyw(half4 v) {
>+    half3 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.w;
>+    return result;
>+}
>+float3 operator.yyw(float4 v) {
>+    float3 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.w;
>+    return result;
>+}
>+
>+/* Functions named operator.ywx= */
>+bool4 operator.ywx=(bool4 v, bool3 c) {
>+    bool4 result = v;
>+    result.y = c.x;
>+    result.w = c.y;
>+    result.x = c.z;
>+    return result;
>+}
>+uchar4 operator.ywx=(uchar4 v, uchar3 c) {
>+    uchar4 result = v;
>+    result.y = c.x;
>+    result.w = c.y;
>+    result.x = c.z;
>+    return result;
>+}
>+ushort4 operator.ywx=(ushort4 v, ushort3 c) {
>+    ushort4 result = v;
>+    result.y = c.x;
>+    result.w = c.y;
>+    result.x = c.z;
>+    return result;
>+}
>+uint4 operator.ywx=(uint4 v, uint3 c) {
>+    uint4 result = v;
>+    result.y = c.x;
>+    result.w = c.y;
>+    result.x = c.z;
>+    return result;
>+}
>+char4 operator.ywx=(char4 v, char3 c) {
>+    char4 result = v;
>+    result.y = c.x;
>+    result.w = c.y;
>+    result.x = c.z;
>+    return result;
>+}
>+short4 operator.ywx=(short4 v, short3 c) {
>+    short4 result = v;
>+    result.y = c.x;
>+    result.w = c.y;
>+    result.x = c.z;
>+    return result;
>+}
>+int4 operator.ywx=(int4 v, int3 c) {
>+    int4 result = v;
>+    result.y = c.x;
>+    result.w = c.y;
>+    result.x = c.z;
>+    return result;
>+}
>+half4 operator.ywx=(half4 v, half3 c) {
>+    half4 result = v;
>+    result.y = c.x;
>+    result.w = c.y;
>+    result.x = c.z;
>+    return result;
>+}
>+float4 operator.ywx=(float4 v, float3 c) {
>+    float4 result = v;
>+    result.y = c.x;
>+    result.w = c.y;
>+    result.x = c.z;
>+    return result;
>+}
>+
>+/* Functions named operator.xzxx */
>+bool4 operator.xzxx(bool3 v) {
>+    bool4 result;
>+    result.x = v.x;
>+    result.y = v.z;
>+    result.z = v.x;
>+    result.w = v.x;
>+    return result;
>+}
>+bool4 operator.xzxx(bool4 v) {
>+    bool4 result;
>+    result.x = v.x;
>+    result.y = v.z;
>+    result.z = v.x;
>+    result.w = v.x;
>+    return result;
>+}
>+uchar4 operator.xzxx(uchar3 v) {
>+    uchar4 result;
>+    result.x = v.x;
>+    result.y = v.z;
>+    result.z = v.x;
>+    result.w = v.x;
>+    return result;
>+}
>+uchar4 operator.xzxx(uchar4 v) {
>+    uchar4 result;
>+    result.x = v.x;
>+    result.y = v.z;
>+    result.z = v.x;
>+    result.w = v.x;
>+    return result;
>+}
>+ushort4 operator.xzxx(ushort3 v) {
>+    ushort4 result;
>+    result.x = v.x;
>+    result.y = v.z;
>+    result.z = v.x;
>+    result.w = v.x;
>+    return result;
>+}
>+ushort4 operator.xzxx(ushort4 v) {
>+    ushort4 result;
>+    result.x = v.x;
>+    result.y = v.z;
>+    result.z = v.x;
>+    result.w = v.x;
>+    return result;
>+}
>+uint4 operator.xzxx(uint3 v) {
>+    uint4 result;
>+    result.x = v.x;
>+    result.y = v.z;
>+    result.z = v.x;
>+    result.w = v.x;
>+    return result;
>+}
>+uint4 operator.xzxx(uint4 v) {
>+    uint4 result;
>+    result.x = v.x;
>+    result.y = v.z;
>+    result.z = v.x;
>+    result.w = v.x;
>+    return result;
>+}
>+char4 operator.xzxx(char3 v) {
>+    char4 result;
>+    result.x = v.x;
>+    result.y = v.z;
>+    result.z = v.x;
>+    result.w = v.x;
>+    return result;
>+}
>+char4 operator.xzxx(char4 v) {
>+    char4 result;
>+    result.x = v.x;
>+    result.y = v.z;
>+    result.z = v.x;
>+    result.w = v.x;
>+    return result;
>+}
>+short4 operator.xzxx(short3 v) {
>+    short4 result;
>+    result.x = v.x;
>+    result.y = v.z;
>+    result.z = v.x;
>+    result.w = v.x;
>+    return result;
>+}
>+short4 operator.xzxx(short4 v) {
>+    short4 result;
>+    result.x = v.x;
>+    result.y = v.z;
>+    result.z = v.x;
>+    result.w = v.x;
>+    return result;
>+}
>+int4 operator.xzxx(int3 v) {
>+    int4 result;
>+    result.x = v.x;
>+    result.y = v.z;
>+    result.z = v.x;
>+    result.w = v.x;
>+    return result;
>+}
>+int4 operator.xzxx(int4 v) {
>+    int4 result;
>+    result.x = v.x;
>+    result.y = v.z;
>+    result.z = v.x;
>+    result.w = v.x;
>+    return result;
>+}
>+half4 operator.xzxx(half3 v) {
>+    half4 result;
>+    result.x = v.x;
>+    result.y = v.z;
>+    result.z = v.x;
>+    result.w = v.x;
>+    return result;
>+}
>+half4 operator.xzxx(half4 v) {
>+    half4 result;
>+    result.x = v.x;
>+    result.y = v.z;
>+    result.z = v.x;
>+    result.w = v.x;
>+    return result;
>+}
>+float4 operator.xzxx(float3 v) {
>+    float4 result;
>+    result.x = v.x;
>+    result.y = v.z;
>+    result.z = v.x;
>+    result.w = v.x;
>+    return result;
>+}
>+float4 operator.xzxx(float4 v) {
>+    float4 result;
>+    result.x = v.x;
>+    result.y = v.z;
>+    result.z = v.x;
>+    result.w = v.x;
>+    return result;
>+}
>+
>+/* Functions named operator.yxzw= */
>+bool4 operator.yxzw=(bool4 v, bool4 c) {
>+    bool4 result = v;
>+    result.y = c.x;
>+    result.x = c.y;
>+    result.z = c.z;
>+    result.w = c.w;
>+    return result;
>+}
>+uchar4 operator.yxzw=(uchar4 v, uchar4 c) {
>+    uchar4 result = v;
>+    result.y = c.x;
>+    result.x = c.y;
>+    result.z = c.z;
>+    result.w = c.w;
>+    return result;
>+}
>+ushort4 operator.yxzw=(ushort4 v, ushort4 c) {
>+    ushort4 result = v;
>+    result.y = c.x;
>+    result.x = c.y;
>+    result.z = c.z;
>+    result.w = c.w;
>+    return result;
>+}
>+uint4 operator.yxzw=(uint4 v, uint4 c) {
>+    uint4 result = v;
>+    result.y = c.x;
>+    result.x = c.y;
>+    result.z = c.z;
>+    result.w = c.w;
>+    return result;
>+}
>+char4 operator.yxzw=(char4 v, char4 c) {
>+    char4 result = v;
>+    result.y = c.x;
>+    result.x = c.y;
>+    result.z = c.z;
>+    result.w = c.w;
>+    return result;
>+}
>+short4 operator.yxzw=(short4 v, short4 c) {
>+    short4 result = v;
>+    result.y = c.x;
>+    result.x = c.y;
>+    result.z = c.z;
>+    result.w = c.w;
>+    return result;
>+}
>+int4 operator.yxzw=(int4 v, int4 c) {
>+    int4 result = v;
>+    result.y = c.x;
>+    result.x = c.y;
>+    result.z = c.z;
>+    result.w = c.w;
>+    return result;
>+}
>+half4 operator.yxzw=(half4 v, half4 c) {
>+    half4 result = v;
>+    result.y = c.x;
>+    result.x = c.y;
>+    result.z = c.z;
>+    result.w = c.w;
>+    return result;
>+}
>+float4 operator.yxzw=(float4 v, float4 c) {
>+    float4 result = v;
>+    result.y = c.x;
>+    result.x = c.y;
>+    result.z = c.z;
>+    result.w = c.w;
>+    return result;
>+}
>+
>+/* Functions named operator.wxz */
>+bool3 operator.wxz(bool4 v) {
>+    bool3 result;
>+    result.x = v.w;
>+    result.y = v.x;
>+    result.z = v.z;
>+    return result;
>+}
>+uchar3 operator.wxz(uchar4 v) {
>+    uchar3 result;
>+    result.x = v.w;
>+    result.y = v.x;
>+    result.z = v.z;
>+    return result;
>+}
>+ushort3 operator.wxz(ushort4 v) {
>+    ushort3 result;
>+    result.x = v.w;
>+    result.y = v.x;
>+    result.z = v.z;
>+    return result;
>+}
>+uint3 operator.wxz(uint4 v) {
>+    uint3 result;
>+    result.x = v.w;
>+    result.y = v.x;
>+    result.z = v.z;
>+    return result;
>+}
>+char3 operator.wxz(char4 v) {
>+    char3 result;
>+    result.x = v.w;
>+    result.y = v.x;
>+    result.z = v.z;
>+    return result;
>+}
>+short3 operator.wxz(short4 v) {
>+    short3 result;
>+    result.x = v.w;
>+    result.y = v.x;
>+    result.z = v.z;
>+    return result;
>+}
>+int3 operator.wxz(int4 v) {
>+    int3 result;
>+    result.x = v.w;
>+    result.y = v.x;
>+    result.z = v.z;
>+    return result;
>+}
>+half3 operator.wxz(half4 v) {
>+    half3 result;
>+    result.x = v.w;
>+    result.y = v.x;
>+    result.z = v.z;
>+    return result;
>+}
>+float3 operator.wxz(float4 v) {
>+    float3 result;
>+    result.x = v.w;
>+    result.y = v.x;
>+    result.z = v.z;
>+    return result;
>+}
>+
>+/* Functions named operator.wwzy */
>+bool4 operator.wwzy(bool4 v) {
>+    bool4 result;
>+    result.x = v.w;
>+    result.y = v.w;
>+    result.z = v.z;
>+    result.w = v.y;
>+    return result;
>+}
>+uchar4 operator.wwzy(uchar4 v) {
>+    uchar4 result;
>+    result.x = v.w;
>+    result.y = v.w;
>+    result.z = v.z;
>+    result.w = v.y;
>+    return result;
>+}
>+ushort4 operator.wwzy(ushort4 v) {
>+    ushort4 result;
>+    result.x = v.w;
>+    result.y = v.w;
>+    result.z = v.z;
>+    result.w = v.y;
>+    return result;
>+}
>+uint4 operator.wwzy(uint4 v) {
>+    uint4 result;
>+    result.x = v.w;
>+    result.y = v.w;
>+    result.z = v.z;
>+    result.w = v.y;
>+    return result;
>+}
>+char4 operator.wwzy(char4 v) {
>+    char4 result;
>+    result.x = v.w;
>+    result.y = v.w;
>+    result.z = v.z;
>+    result.w = v.y;
>+    return result;
>+}
>+short4 operator.wwzy(short4 v) {
>+    short4 result;
>+    result.x = v.w;
>+    result.y = v.w;
>+    result.z = v.z;
>+    result.w = v.y;
>+    return result;
>+}
>+int4 operator.wwzy(int4 v) {
>+    int4 result;
>+    result.x = v.w;
>+    result.y = v.w;
>+    result.z = v.z;
>+    result.w = v.y;
>+    return result;
>+}
>+half4 operator.wwzy(half4 v) {
>+    half4 result;
>+    result.x = v.w;
>+    result.y = v.w;
>+    result.z = v.z;
>+    result.w = v.y;
>+    return result;
>+}
>+float4 operator.wwzy(float4 v) {
>+    float4 result;
>+    result.x = v.w;
>+    result.y = v.w;
>+    result.z = v.z;
>+    result.w = v.y;
>+    return result;
>+}
>+
>+/* Functions named operator.xwxz */
>+bool4 operator.xwxz(bool4 v) {
>+    bool4 result;
>+    result.x = v.x;
>+    result.y = v.w;
>+    result.z = v.x;
>+    result.w = v.z;
>+    return result;
>+}
>+uchar4 operator.xwxz(uchar4 v) {
>+    uchar4 result;
>+    result.x = v.x;
>+    result.y = v.w;
>+    result.z = v.x;
>+    result.w = v.z;
>+    return result;
>+}
>+ushort4 operator.xwxz(ushort4 v) {
>+    ushort4 result;
>+    result.x = v.x;
>+    result.y = v.w;
>+    result.z = v.x;
>+    result.w = v.z;
>+    return result;
>+}
>+uint4 operator.xwxz(uint4 v) {
>+    uint4 result;
>+    result.x = v.x;
>+    result.y = v.w;
>+    result.z = v.x;
>+    result.w = v.z;
>+    return result;
>+}
>+char4 operator.xwxz(char4 v) {
>+    char4 result;
>+    result.x = v.x;
>+    result.y = v.w;
>+    result.z = v.x;
>+    result.w = v.z;
>+    return result;
>+}
>+short4 operator.xwxz(short4 v) {
>+    short4 result;
>+    result.x = v.x;
>+    result.y = v.w;
>+    result.z = v.x;
>+    result.w = v.z;
>+    return result;
>+}
>+int4 operator.xwxz(int4 v) {
>+    int4 result;
>+    result.x = v.x;
>+    result.y = v.w;
>+    result.z = v.x;
>+    result.w = v.z;
>+    return result;
>+}
>+half4 operator.xwxz(half4 v) {
>+    half4 result;
>+    result.x = v.x;
>+    result.y = v.w;
>+    result.z = v.x;
>+    result.w = v.z;
>+    return result;
>+}
>+float4 operator.xwxz(float4 v) {
>+    float4 result;
>+    result.x = v.x;
>+    result.y = v.w;
>+    result.z = v.x;
>+    result.w = v.z;
>+    return result;
>+}
>+
>+/* Functions named operator.wwzz */
>+bool4 operator.wwzz(bool4 v) {
>+    bool4 result;
>+    result.x = v.w;
>+    result.y = v.w;
>+    result.z = v.z;
>+    result.w = v.z;
>+    return result;
>+}
>+uchar4 operator.wwzz(uchar4 v) {
>+    uchar4 result;
>+    result.x = v.w;
>+    result.y = v.w;
>+    result.z = v.z;
>+    result.w = v.z;
>+    return result;
>+}
>+ushort4 operator.wwzz(ushort4 v) {
>+    ushort4 result;
>+    result.x = v.w;
>+    result.y = v.w;
>+    result.z = v.z;
>+    result.w = v.z;
>+    return result;
>+}
>+uint4 operator.wwzz(uint4 v) {
>+    uint4 result;
>+    result.x = v.w;
>+    result.y = v.w;
>+    result.z = v.z;
>+    result.w = v.z;
>+    return result;
>+}
>+char4 operator.wwzz(char4 v) {
>+    char4 result;
>+    result.x = v.w;
>+    result.y = v.w;
>+    result.z = v.z;
>+    result.w = v.z;
>+    return result;
>+}
>+short4 operator.wwzz(short4 v) {
>+    short4 result;
>+    result.x = v.w;
>+    result.y = v.w;
>+    result.z = v.z;
>+    result.w = v.z;
>+    return result;
>+}
>+int4 operator.wwzz(int4 v) {
>+    int4 result;
>+    result.x = v.w;
>+    result.y = v.w;
>+    result.z = v.z;
>+    result.w = v.z;
>+    return result;
>+}
>+half4 operator.wwzz(half4 v) {
>+    half4 result;
>+    result.x = v.w;
>+    result.y = v.w;
>+    result.z = v.z;
>+    result.w = v.z;
>+    return result;
>+}
>+float4 operator.wwzz(float4 v) {
>+    float4 result;
>+    result.x = v.w;
>+    result.y = v.w;
>+    result.z = v.z;
>+    result.w = v.z;
>+    return result;
>+}
>+
>+/* Functions named operator.zxxx */
>+bool4 operator.zxxx(bool3 v) {
>+    bool4 result;
>+    result.x = v.z;
>+    result.y = v.x;
>+    result.z = v.x;
>+    result.w = v.x;
>+    return result;
>+}
>+bool4 operator.zxxx(bool4 v) {
>+    bool4 result;
>+    result.x = v.z;
>+    result.y = v.x;
>+    result.z = v.x;
>+    result.w = v.x;
>+    return result;
>+}
>+uchar4 operator.zxxx(uchar3 v) {
>+    uchar4 result;
>+    result.x = v.z;
>+    result.y = v.x;
>+    result.z = v.x;
>+    result.w = v.x;
>+    return result;
>+}
>+uchar4 operator.zxxx(uchar4 v) {
>+    uchar4 result;
>+    result.x = v.z;
>+    result.y = v.x;
>+    result.z = v.x;
>+    result.w = v.x;
>+    return result;
>+}
>+ushort4 operator.zxxx(ushort3 v) {
>+    ushort4 result;
>+    result.x = v.z;
>+    result.y = v.x;
>+    result.z = v.x;
>+    result.w = v.x;
>+    return result;
>+}
>+ushort4 operator.zxxx(ushort4 v) {
>+    ushort4 result;
>+    result.x = v.z;
>+    result.y = v.x;
>+    result.z = v.x;
>+    result.w = v.x;
>+    return result;
>+}
>+uint4 operator.zxxx(uint3 v) {
>+    uint4 result;
>+    result.x = v.z;
>+    result.y = v.x;
>+    result.z = v.x;
>+    result.w = v.x;
>+    return result;
>+}
>+uint4 operator.zxxx(uint4 v) {
>+    uint4 result;
>+    result.x = v.z;
>+    result.y = v.x;
>+    result.z = v.x;
>+    result.w = v.x;
>+    return result;
>+}
>+char4 operator.zxxx(char3 v) {
>+    char4 result;
>+    result.x = v.z;
>+    result.y = v.x;
>+    result.z = v.x;
>+    result.w = v.x;
>+    return result;
>+}
>+char4 operator.zxxx(char4 v) {
>+    char4 result;
>+    result.x = v.z;
>+    result.y = v.x;
>+    result.z = v.x;
>+    result.w = v.x;
>+    return result;
>+}
>+short4 operator.zxxx(short3 v) {
>+    short4 result;
>+    result.x = v.z;
>+    result.y = v.x;
>+    result.z = v.x;
>+    result.w = v.x;
>+    return result;
>+}
>+short4 operator.zxxx(short4 v) {
>+    short4 result;
>+    result.x = v.z;
>+    result.y = v.x;
>+    result.z = v.x;
>+    result.w = v.x;
>+    return result;
>+}
>+int4 operator.zxxx(int3 v) {
>+    int4 result;
>+    result.x = v.z;
>+    result.y = v.x;
>+    result.z = v.x;
>+    result.w = v.x;
>+    return result;
>+}
>+int4 operator.zxxx(int4 v) {
>+    int4 result;
>+    result.x = v.z;
>+    result.y = v.x;
>+    result.z = v.x;
>+    result.w = v.x;
>+    return result;
>+}
>+half4 operator.zxxx(half3 v) {
>+    half4 result;
>+    result.x = v.z;
>+    result.y = v.x;
>+    result.z = v.x;
>+    result.w = v.x;
>+    return result;
>+}
>+half4 operator.zxxx(half4 v) {
>+    half4 result;
>+    result.x = v.z;
>+    result.y = v.x;
>+    result.z = v.x;
>+    result.w = v.x;
>+    return result;
>+}
>+float4 operator.zxxx(float3 v) {
>+    float4 result;
>+    result.x = v.z;
>+    result.y = v.x;
>+    result.z = v.x;
>+    result.w = v.x;
>+    return result;
>+}
>+float4 operator.zxxx(float4 v) {
>+    float4 result;
>+    result.x = v.z;
>+    result.y = v.x;
>+    result.z = v.x;
>+    result.w = v.x;
>+    return result;
>+}
>+
>+/* Functions named asfloat */
>+native float asfloat(int);
>+float2 asfloat(int2 x) {
>+    float2 result;
>+    result[0] = asfloat(x[0]);
>+    result[1] = asfloat(x[1]);
>+    return result;
>+}
>+float3 asfloat(int3 x) {
>+    float3 result;
>+    result[0] = asfloat(x[0]);
>+    result[1] = asfloat(x[1]);
>+    result[2] = asfloat(x[2]);
>+    return result;
>+}
>+float4 asfloat(int4 x) {
>+    float4 result;
>+    result[0] = asfloat(x[0]);
>+    result[1] = asfloat(x[1]);
>+    result[2] = asfloat(x[2]);
>+    result[3] = asfloat(x[3]);
>+    return result;
>+}
>+native float asfloat(uint);
>+float2 asfloat(uint2 x) {
>+    float2 result;
>+    result[0] = asfloat(x[0]);
>+    result[1] = asfloat(x[1]);
>+    return result;
>+}
>+float3 asfloat(uint3 x) {
>+    float3 result;
>+    result[0] = asfloat(x[0]);
>+    result[1] = asfloat(x[1]);
>+    result[2] = asfloat(x[2]);
>+    return result;
>+}
>+float4 asfloat(uint4 x) {
>+    float4 result;
>+    result[0] = asfloat(x[0]);
>+    result[1] = asfloat(x[1]);
>+    result[2] = asfloat(x[2]);
>+    result[3] = asfloat(x[3]);
>+    return result;
>+}
>+float asfloat(float x) {
>+    return x;
>+}
>+float2 asfloat(float2 x) {
>+    return x;
>+}
>+float3 asfloat(float3 x) {
>+    return x;
>+}
>+float4 asfloat(float4 x) {
>+    return x;
>+}
>+float2x2 asfloat(float2x2 x) {
>+    return x;
>+}
>+float2x3 asfloat(float2x3 x) {
>+    return x;
>+}
>+float2x4 asfloat(float2x4 x) {
>+    return x;
>+}
>+float3x2 asfloat(float3x2 x) {
>+    return x;
>+}
>+float3x3 asfloat(float3x3 x) {
>+    return x;
>+}
>+float3x4 asfloat(float3x4 x) {
>+    return x;
>+}
>+float4x2 asfloat(float4x2 x) {
>+    return x;
>+}
>+float4x3 asfloat(float4x3 x) {
>+    return x;
>+}
>+float4x4 asfloat(float4x4 x) {
>+    return x;
>+}
>+
>+
>+/* Functions named operator.zwyx */
>+bool4 operator.zwyx(bool4 v) {
>+    bool4 result;
>+    result.x = v.z;
>+    result.y = v.w;
>+    result.z = v.y;
>+    result.w = v.x;
>+    return result;
>+}
>+uchar4 operator.zwyx(uchar4 v) {
>+    uchar4 result;
>+    result.x = v.z;
>+    result.y = v.w;
>+    result.z = v.y;
>+    result.w = v.x;
>+    return result;
>+}
>+ushort4 operator.zwyx(ushort4 v) {
>+    ushort4 result;
>+    result.x = v.z;
>+    result.y = v.w;
>+    result.z = v.y;
>+    result.w = v.x;
>+    return result;
>+}
>+uint4 operator.zwyx(uint4 v) {
>+    uint4 result;
>+    result.x = v.z;
>+    result.y = v.w;
>+    result.z = v.y;
>+    result.w = v.x;
>+    return result;
>+}
>+char4 operator.zwyx(char4 v) {
>+    char4 result;
>+    result.x = v.z;
>+    result.y = v.w;
>+    result.z = v.y;
>+    result.w = v.x;
>+    return result;
>+}
>+short4 operator.zwyx(short4 v) {
>+    short4 result;
>+    result.x = v.z;
>+    result.y = v.w;
>+    result.z = v.y;
>+    result.w = v.x;
>+    return result;
>+}
>+int4 operator.zwyx(int4 v) {
>+    int4 result;
>+    result.x = v.z;
>+    result.y = v.w;
>+    result.z = v.y;
>+    result.w = v.x;
>+    return result;
>+}
>+half4 operator.zwyx(half4 v) {
>+    half4 result;
>+    result.x = v.z;
>+    result.y = v.w;
>+    result.z = v.y;
>+    result.w = v.x;
>+    return result;
>+}
>+float4 operator.zwyx(float4 v) {
>+    float4 result;
>+    result.x = v.z;
>+    result.y = v.w;
>+    result.z = v.y;
>+    result.w = v.x;
>+    return result;
>+}
>+
>+/* Functions named isnormal */
>+native bool isnormal(half);
>+native bool isnormal(float);
>+bool2 isnormal(half2 x) {
>+    bool2 result;
>+    result[0] = isnormal(x[0]);
>+    result[1] = isnormal(x[1]);
>+    return result;
>+}
>+bool3 isnormal(half3 x) {
>+    bool3 result;
>+    result[0] = isnormal(x[0]);
>+    result[1] = isnormal(x[1]);
>+    result[2] = isnormal(x[2]);
>+    return result;
>+}
>+bool4 isnormal(half4 x) {
>+    bool4 result;
>+    result[0] = isnormal(x[0]);
>+    result[1] = isnormal(x[1]);
>+    result[2] = isnormal(x[2]);
>+    result[3] = isnormal(x[3]);
>+    return result;
>+}
>+
>+bool2 isnormal(float2 x) {
>+    bool2 result;
>+    result[0] = isnormal(x[0]);
>+    result[1] = isnormal(x[1]);
>+    return result;
>+}
>+bool3 isnormal(float3 x) {
>+    bool3 result;
>+    result[0] = isnormal(x[0]);
>+    result[1] = isnormal(x[1]);
>+    result[2] = isnormal(x[2]);
>+    return result;
>+}
>+bool4 isnormal(float4 x) {
>+    bool4 result;
>+    result[0] = isnormal(x[0]);
>+    result[1] = isnormal(x[1]);
>+    result[2] = isnormal(x[2]);
>+    result[3] = isnormal(x[3]);
>+    return result;
>+}
>+
>+
>+/* Functions named InterlockedExchange */
>+native void InterlockedExchange(device atomic_uint*, uint, thread uint*);
>+native void InterlockedExchange(device atomic_int*, int, thread int*);
>+native void InterlockedExchange(device atomic_uint*, uint, device uint*);
>+native void InterlockedExchange(device atomic_int*, int, device int*);
>+native void InterlockedExchange(device atomic_uint*, uint, threadgroup uint*);
>+native void InterlockedExchange(device atomic_int*, int, threadgroup int*);
>+native void InterlockedExchange(threadgroup atomic_uint*, uint, thread uint*);
>+native void InterlockedExchange(threadgroup atomic_int*, int, thread int*);
>+native void InterlockedExchange(threadgroup atomic_uint*, uint, device uint*);
>+native void InterlockedExchange(threadgroup atomic_int*, int, device int*);
>+native void InterlockedExchange(threadgroup atomic_uint*, uint, threadgroup uint*);
>+native void InterlockedExchange(threadgroup atomic_int*, int, threadgroup int*);
>+
>+/* Functions named operator.xzx */
>+bool3 operator.xzx(bool3 v) {
>+    bool3 result;
>+    result.x = v.x;
>+    result.y = v.z;
>+    result.z = v.x;
>+    return result;
>+}
>+bool3 operator.xzx(bool4 v) {
>+    bool3 result;
>+    result.x = v.x;
>+    result.y = v.z;
>+    result.z = v.x;
>+    return result;
>+}
>+uchar3 operator.xzx(uchar3 v) {
>+    uchar3 result;
>+    result.x = v.x;
>+    result.y = v.z;
>+    result.z = v.x;
>+    return result;
>+}
>+uchar3 operator.xzx(uchar4 v) {
>+    uchar3 result;
>+    result.x = v.x;
>+    result.y = v.z;
>+    result.z = v.x;
>+    return result;
>+}
>+ushort3 operator.xzx(ushort3 v) {
>+    ushort3 result;
>+    result.x = v.x;
>+    result.y = v.z;
>+    result.z = v.x;
>+    return result;
>+}
>+ushort3 operator.xzx(ushort4 v) {
>+    ushort3 result;
>+    result.x = v.x;
>+    result.y = v.z;
>+    result.z = v.x;
>+    return result;
>+}
>+uint3 operator.xzx(uint3 v) {
>+    uint3 result;
>+    result.x = v.x;
>+    result.y = v.z;
>+    result.z = v.x;
>+    return result;
>+}
>+uint3 operator.xzx(uint4 v) {
>+    uint3 result;
>+    result.x = v.x;
>+    result.y = v.z;
>+    result.z = v.x;
>+    return result;
>+}
>+char3 operator.xzx(char3 v) {
>+    char3 result;
>+    result.x = v.x;
>+    result.y = v.z;
>+    result.z = v.x;
>+    return result;
>+}
>+char3 operator.xzx(char4 v) {
>+    char3 result;
>+    result.x = v.x;
>+    result.y = v.z;
>+    result.z = v.x;
>+    return result;
>+}
>+short3 operator.xzx(short3 v) {
>+    short3 result;
>+    result.x = v.x;
>+    result.y = v.z;
>+    result.z = v.x;
>+    return result;
>+}
>+short3 operator.xzx(short4 v) {
>+    short3 result;
>+    result.x = v.x;
>+    result.y = v.z;
>+    result.z = v.x;
>+    return result;
>+}
>+int3 operator.xzx(int3 v) {
>+    int3 result;
>+    result.x = v.x;
>+    result.y = v.z;
>+    result.z = v.x;
>+    return result;
>+}
>+int3 operator.xzx(int4 v) {
>+    int3 result;
>+    result.x = v.x;
>+    result.y = v.z;
>+    result.z = v.x;
>+    return result;
>+}
>+half3 operator.xzx(half3 v) {
>+    half3 result;
>+    result.x = v.x;
>+    result.y = v.z;
>+    result.z = v.x;
>+    return result;
>+}
>+half3 operator.xzx(half4 v) {
>+    half3 result;
>+    result.x = v.x;
>+    result.y = v.z;
>+    result.z = v.x;
>+    return result;
>+}
>+float3 operator.xzx(float3 v) {
>+    float3 result;
>+    result.x = v.x;
>+    result.y = v.z;
>+    result.z = v.x;
>+    return result;
>+}
>+float3 operator.xzx(float4 v) {
>+    float3 result;
>+    result.x = v.x;
>+    result.y = v.z;
>+    result.z = v.x;
>+    return result;
>+}
>+
>+/* Functions named GetDimensions */
>+native void GetDimensions(Texture1D<ushort>, thread uint* Width);
>+native void GetDimensions(Texture1D<ushort>, thread uint* Width);
>+native void GetDimensions(Texture1D<ushort>, thread uint* Width);
>+native void GetDimensions(Texture1D<ushort>, device uint* Width);
>+native void GetDimensions(Texture1D<ushort>, device uint* Width);
>+native void GetDimensions(Texture1D<ushort>, device uint* Width);
>+native void GetDimensions(Texture1D<ushort>, threadgroup uint* Width);
>+native void GetDimensions(Texture1D<ushort>, threadgroup uint* Width);
>+native void GetDimensions(Texture1D<ushort>, threadgroup uint* Width);
>+
>+native void GetDimensions(Texture1DArray<ushort>, thread uint* Width, thread uint* Elements);
>+native void GetDimensions(Texture1DArray<ushort>, thread uint* Width, thread uint* Elements);
>+native void GetDimensions(Texture1DArray<ushort>, thread uint* Width, thread uint* Elements);
>+native void GetDimensions(Texture1DArray<ushort>, thread uint* Width, device uint* Elements);
>+native void GetDimensions(Texture1DArray<ushort>, thread uint* Width, device uint* Elements);
>+native void GetDimensions(Texture1DArray<ushort>, thread uint* Width, device uint* Elements);
>+native void GetDimensions(Texture1DArray<ushort>, thread uint* Width, threadgroup uint* Elements);
>+native void GetDimensions(Texture1DArray<ushort>, thread uint* Width, threadgroup uint* Elements);
>+native void GetDimensions(Texture1DArray<ushort>, thread uint* Width, threadgroup uint* Elements);
>+native void GetDimensions(Texture1DArray<ushort>, device uint* Width, thread uint* Elements);
>+native void GetDimensions(Texture1DArray<ushort>, device uint* Width, thread uint* Elements);
>+native void GetDimensions(Texture1DArray<ushort>, device uint* Width, thread uint* Elements);
>+native void GetDimensions(Texture1DArray<ushort>, device uint* Width, device uint* Elements);
>+native void GetDimensions(Texture1DArray<ushort>, device uint* Width, device uint* Elements);
>+native void GetDimensions(Texture1DArray<ushort>, device uint* Width, device uint* Elements);
>+native void GetDimensions(Texture1DArray<ushort>, device uint* Width, threadgroup uint* Elements);
>+native void GetDimensions(Texture1DArray<ushort>, device uint* Width, threadgroup uint* Elements);
>+native void GetDimensions(Texture1DArray<ushort>, device uint* Width, threadgroup uint* Elements);
>+native void GetDimensions(Texture1DArray<ushort>, threadgroup uint* Width, thread uint* Elements);
>+native void GetDimensions(Texture1DArray<ushort>, threadgroup uint* Width, thread uint* Elements);
>+native void GetDimensions(Texture1DArray<ushort>, threadgroup uint* Width, thread uint* Elements);
>+native void GetDimensions(Texture1DArray<ushort>, threadgroup uint* Width, device uint* Elements);
>+native void GetDimensions(Texture1DArray<ushort>, threadgroup uint* Width, device uint* Elements);
>+native void GetDimensions(Texture1DArray<ushort>, threadgroup uint* Width, device uint* Elements);
>+native void GetDimensions(Texture1DArray<ushort>, threadgroup uint* Width, threadgroup uint* Elements);
>+native void GetDimensions(Texture1DArray<ushort>, threadgroup uint* Width, threadgroup uint* Elements);
>+native void GetDimensions(Texture1DArray<ushort>, threadgroup uint* Width, threadgroup uint* Elements);
>+
>+native void GetDimensions(Texture2D<ushort>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<ushort>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<ushort>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<ushort>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<ushort>, uint MipLevel, thread uint* Width, device uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<ushort>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<ushort>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<ushort>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<ushort>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<ushort>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<ushort>, uint MipLevel, device uint* Width, thread uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<ushort>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<ushort>, uint MipLevel, device uint* Width, device uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<ushort>, uint MipLevel, device uint* Width, device uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<ushort>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<ushort>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<ushort>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<ushort>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<ushort>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<ushort>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<ushort>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<ushort>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<ushort>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<ushort>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<ushort>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<ushort>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<ushort>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels);
>+
>+native void GetDimensions(Texture2DArray<ushort>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort>, uint MipLevel, device uint* Width, device uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort>, uint MipLevel, device uint* Width, device uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort>, uint MipLevel, device uint* Width, device uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+
>+native void GetDimensions(Texture3D<ushort>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort>, uint MipLevel, device uint* Width, device uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort>, uint MipLevel, device uint* Width, device uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort>, uint MipLevel, device uint* Width, device uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+
>+native void GetDimensions(TextureCube<ushort>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<ushort>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<ushort>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<ushort>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<ushort>, uint MipLevel, thread uint* Width, device uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<ushort>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<ushort>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<ushort>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<ushort>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<ushort>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<ushort>, uint MipLevel, device uint* Width, thread uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<ushort>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<ushort>, uint MipLevel, device uint* Width, device uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<ushort>, uint MipLevel, device uint* Width, device uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<ushort>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<ushort>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<ushort>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<ushort>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<ushort>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<ushort>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<ushort>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<ushort>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<ushort>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<ushort>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<ushort>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<ushort>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<ushort>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels);
>+
>+
>+
>+
>+
>+
>+native void GetDimensions(Texture1D<ushort2>, thread uint* Width);
>+native void GetDimensions(Texture1D<ushort2>, thread uint* Width);
>+native void GetDimensions(Texture1D<ushort2>, thread uint* Width);
>+native void GetDimensions(Texture1D<ushort2>, device uint* Width);
>+native void GetDimensions(Texture1D<ushort2>, device uint* Width);
>+native void GetDimensions(Texture1D<ushort2>, device uint* Width);
>+native void GetDimensions(Texture1D<ushort2>, threadgroup uint* Width);
>+native void GetDimensions(Texture1D<ushort2>, threadgroup uint* Width);
>+native void GetDimensions(Texture1D<ushort2>, threadgroup uint* Width);
>+
>+native void GetDimensions(Texture1DArray<ushort2>, thread uint* Width, thread uint* Elements);
>+native void GetDimensions(Texture1DArray<ushort2>, thread uint* Width, thread uint* Elements);
>+native void GetDimensions(Texture1DArray<ushort2>, thread uint* Width, thread uint* Elements);
>+native void GetDimensions(Texture1DArray<ushort2>, thread uint* Width, device uint* Elements);
>+native void GetDimensions(Texture1DArray<ushort2>, thread uint* Width, device uint* Elements);
>+native void GetDimensions(Texture1DArray<ushort2>, thread uint* Width, device uint* Elements);
>+native void GetDimensions(Texture1DArray<ushort2>, thread uint* Width, threadgroup uint* Elements);
>+native void GetDimensions(Texture1DArray<ushort2>, thread uint* Width, threadgroup uint* Elements);
>+native void GetDimensions(Texture1DArray<ushort2>, thread uint* Width, threadgroup uint* Elements);
>+native void GetDimensions(Texture1DArray<ushort2>, device uint* Width, thread uint* Elements);
>+native void GetDimensions(Texture1DArray<ushort2>, device uint* Width, thread uint* Elements);
>+native void GetDimensions(Texture1DArray<ushort2>, device uint* Width, thread uint* Elements);
>+native void GetDimensions(Texture1DArray<ushort2>, device uint* Width, device uint* Elements);
>+native void GetDimensions(Texture1DArray<ushort2>, device uint* Width, device uint* Elements);
>+native void GetDimensions(Texture1DArray<ushort2>, device uint* Width, device uint* Elements);
>+native void GetDimensions(Texture1DArray<ushort2>, device uint* Width, threadgroup uint* Elements);
>+native void GetDimensions(Texture1DArray<ushort2>, device uint* Width, threadgroup uint* Elements);
>+native void GetDimensions(Texture1DArray<ushort2>, device uint* Width, threadgroup uint* Elements);
>+native void GetDimensions(Texture1DArray<ushort2>, threadgroup uint* Width, thread uint* Elements);
>+native void GetDimensions(Texture1DArray<ushort2>, threadgroup uint* Width, thread uint* Elements);
>+native void GetDimensions(Texture1DArray<ushort2>, threadgroup uint* Width, thread uint* Elements);
>+native void GetDimensions(Texture1DArray<ushort2>, threadgroup uint* Width, device uint* Elements);
>+native void GetDimensions(Texture1DArray<ushort2>, threadgroup uint* Width, device uint* Elements);
>+native void GetDimensions(Texture1DArray<ushort2>, threadgroup uint* Width, device uint* Elements);
>+native void GetDimensions(Texture1DArray<ushort2>, threadgroup uint* Width, threadgroup uint* Elements);
>+native void GetDimensions(Texture1DArray<ushort2>, threadgroup uint* Width, threadgroup uint* Elements);
>+native void GetDimensions(Texture1DArray<ushort2>, threadgroup uint* Width, threadgroup uint* Elements);
>+
>+native void GetDimensions(Texture2D<ushort2>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<ushort2>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<ushort2>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<ushort2>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<ushort2>, uint MipLevel, thread uint* Width, device uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<ushort2>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<ushort2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<ushort2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<ushort2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<ushort2>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<ushort2>, uint MipLevel, device uint* Width, thread uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<ushort2>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<ushort2>, uint MipLevel, device uint* Width, device uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<ushort2>, uint MipLevel, device uint* Width, device uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<ushort2>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<ushort2>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<ushort2>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<ushort2>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<ushort2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<ushort2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<ushort2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<ushort2>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<ushort2>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<ushort2>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<ushort2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<ushort2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<ushort2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels);
>+
>+native void GetDimensions(Texture2DArray<ushort2>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort2>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort2>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort2>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort2>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort2>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort2>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort2>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort2>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort2>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort2>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort2>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort2>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort2>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort2>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort2>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort2>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort2>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort2>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort2>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort2>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort2>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort2>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort2>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort2>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort2>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort2>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort2>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort2>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort2>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort2>, uint MipLevel, device uint* Width, device uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort2>, uint MipLevel, device uint* Width, device uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort2>, uint MipLevel, device uint* Width, device uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort2>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort2>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort2>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort2>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort2>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort2>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort2>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort2>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort2>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort2>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort2>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort2>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort2>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort2>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort2>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort2>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort2>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort2>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort2>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort2>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort2>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+
>+native void GetDimensions(Texture3D<ushort2>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort2>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort2>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort2>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort2>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort2>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort2>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort2>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort2>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort2>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort2>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort2>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort2>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort2>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort2>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort2>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort2>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort2>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort2>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort2>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort2>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort2>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort2>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort2>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort2>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort2>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort2>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort2>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort2>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort2>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort2>, uint MipLevel, device uint* Width, device uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort2>, uint MipLevel, device uint* Width, device uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort2>, uint MipLevel, device uint* Width, device uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort2>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort2>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort2>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort2>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort2>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort2>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort2>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort2>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort2>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort2>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort2>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort2>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort2>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort2>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort2>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort2>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort2>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort2>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort2>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort2>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort2>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+
>+native void GetDimensions(TextureCube<ushort2>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<ushort2>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<ushort2>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<ushort2>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<ushort2>, uint MipLevel, thread uint* Width, device uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<ushort2>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<ushort2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<ushort2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<ushort2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<ushort2>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<ushort2>, uint MipLevel, device uint* Width, thread uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<ushort2>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<ushort2>, uint MipLevel, device uint* Width, device uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<ushort2>, uint MipLevel, device uint* Width, device uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<ushort2>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<ushort2>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<ushort2>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<ushort2>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<ushort2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<ushort2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<ushort2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<ushort2>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<ushort2>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<ushort2>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<ushort2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<ushort2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<ushort2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels);
>+
>+
>+
>+
>+
>+
>+native void GetDimensions(Texture1D<ushort3>, thread uint* Width);
>+native void GetDimensions(Texture1D<ushort3>, thread uint* Width);
>+native void GetDimensions(Texture1D<ushort3>, thread uint* Width);
>+native void GetDimensions(Texture1D<ushort3>, device uint* Width);
>+native void GetDimensions(Texture1D<ushort3>, device uint* Width);
>+native void GetDimensions(Texture1D<ushort3>, device uint* Width);
>+native void GetDimensions(Texture1D<ushort3>, threadgroup uint* Width);
>+native void GetDimensions(Texture1D<ushort3>, threadgroup uint* Width);
>+native void GetDimensions(Texture1D<ushort3>, threadgroup uint* Width);
>+
>+native void GetDimensions(Texture1DArray<ushort3>, thread uint* Width, thread uint* Elements);
>+native void GetDimensions(Texture1DArray<ushort3>, thread uint* Width, thread uint* Elements);
>+native void GetDimensions(Texture1DArray<ushort3>, thread uint* Width, thread uint* Elements);
>+native void GetDimensions(Texture1DArray<ushort3>, thread uint* Width, device uint* Elements);
>+native void GetDimensions(Texture1DArray<ushort3>, thread uint* Width, device uint* Elements);
>+native void GetDimensions(Texture1DArray<ushort3>, thread uint* Width, device uint* Elements);
>+native void GetDimensions(Texture1DArray<ushort3>, thread uint* Width, threadgroup uint* Elements);
>+native void GetDimensions(Texture1DArray<ushort3>, thread uint* Width, threadgroup uint* Elements);
>+native void GetDimensions(Texture1DArray<ushort3>, thread uint* Width, threadgroup uint* Elements);
>+native void GetDimensions(Texture1DArray<ushort3>, device uint* Width, thread uint* Elements);
>+native void GetDimensions(Texture1DArray<ushort3>, device uint* Width, thread uint* Elements);
>+native void GetDimensions(Texture1DArray<ushort3>, device uint* Width, thread uint* Elements);
>+native void GetDimensions(Texture1DArray<ushort3>, device uint* Width, device uint* Elements);
>+native void GetDimensions(Texture1DArray<ushort3>, device uint* Width, device uint* Elements);
>+native void GetDimensions(Texture1DArray<ushort3>, device uint* Width, device uint* Elements);
>+native void GetDimensions(Texture1DArray<ushort3>, device uint* Width, threadgroup uint* Elements);
>+native void GetDimensions(Texture1DArray<ushort3>, device uint* Width, threadgroup uint* Elements);
>+native void GetDimensions(Texture1DArray<ushort3>, device uint* Width, threadgroup uint* Elements);
>+native void GetDimensions(Texture1DArray<ushort3>, threadgroup uint* Width, thread uint* Elements);
>+native void GetDimensions(Texture1DArray<ushort3>, threadgroup uint* Width, thread uint* Elements);
>+native void GetDimensions(Texture1DArray<ushort3>, threadgroup uint* Width, thread uint* Elements);
>+native void GetDimensions(Texture1DArray<ushort3>, threadgroup uint* Width, device uint* Elements);
>+native void GetDimensions(Texture1DArray<ushort3>, threadgroup uint* Width, device uint* Elements);
>+native void GetDimensions(Texture1DArray<ushort3>, threadgroup uint* Width, device uint* Elements);
>+native void GetDimensions(Texture1DArray<ushort3>, threadgroup uint* Width, threadgroup uint* Elements);
>+native void GetDimensions(Texture1DArray<ushort3>, threadgroup uint* Width, threadgroup uint* Elements);
>+native void GetDimensions(Texture1DArray<ushort3>, threadgroup uint* Width, threadgroup uint* Elements);
>+
>+native void GetDimensions(Texture2D<ushort3>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<ushort3>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<ushort3>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<ushort3>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<ushort3>, uint MipLevel, thread uint* Width, device uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<ushort3>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<ushort3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<ushort3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<ushort3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<ushort3>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<ushort3>, uint MipLevel, device uint* Width, thread uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<ushort3>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<ushort3>, uint MipLevel, device uint* Width, device uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<ushort3>, uint MipLevel, device uint* Width, device uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<ushort3>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<ushort3>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<ushort3>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<ushort3>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<ushort3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<ushort3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<ushort3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<ushort3>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<ushort3>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<ushort3>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<ushort3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<ushort3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<ushort3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels);
>+
>+native void GetDimensions(Texture2DArray<ushort3>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort3>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort3>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort3>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort3>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort3>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort3>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort3>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort3>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort3>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort3>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort3>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort3>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort3>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort3>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort3>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort3>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort3>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort3>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort3>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort3>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort3>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort3>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort3>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort3>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort3>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort3>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort3>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort3>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort3>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort3>, uint MipLevel, device uint* Width, device uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort3>, uint MipLevel, device uint* Width, device uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort3>, uint MipLevel, device uint* Width, device uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort3>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort3>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort3>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort3>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort3>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort3>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort3>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort3>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort3>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort3>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort3>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort3>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort3>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort3>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort3>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort3>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort3>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort3>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort3>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort3>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort3>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+
>+native void GetDimensions(Texture3D<ushort3>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort3>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort3>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort3>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort3>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort3>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort3>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort3>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort3>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort3>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort3>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort3>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort3>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort3>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort3>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort3>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort3>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort3>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort3>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort3>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort3>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort3>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort3>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort3>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort3>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort3>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort3>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort3>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort3>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort3>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort3>, uint MipLevel, device uint* Width, device uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort3>, uint MipLevel, device uint* Width, device uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort3>, uint MipLevel, device uint* Width, device uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort3>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort3>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort3>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort3>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort3>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort3>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort3>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort3>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort3>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort3>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort3>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort3>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort3>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort3>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort3>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort3>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort3>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort3>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort3>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort3>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort3>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+
>+native void GetDimensions(TextureCube<ushort3>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<ushort3>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<ushort3>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<ushort3>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<ushort3>, uint MipLevel, thread uint* Width, device uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<ushort3>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<ushort3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<ushort3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<ushort3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<ushort3>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<ushort3>, uint MipLevel, device uint* Width, thread uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<ushort3>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<ushort3>, uint MipLevel, device uint* Width, device uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<ushort3>, uint MipLevel, device uint* Width, device uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<ushort3>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<ushort3>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<ushort3>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<ushort3>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<ushort3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<ushort3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<ushort3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<ushort3>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<ushort3>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<ushort3>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<ushort3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<ushort3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<ushort3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels);
>+
>+
>+
>+
>+
>+
>+native void GetDimensions(Texture1D<ushort4>, thread uint* Width);
>+native void GetDimensions(Texture1D<ushort4>, thread uint* Width);
>+native void GetDimensions(Texture1D<ushort4>, thread uint* Width);
>+native void GetDimensions(Texture1D<ushort4>, device uint* Width);
>+native void GetDimensions(Texture1D<ushort4>, device uint* Width);
>+native void GetDimensions(Texture1D<ushort4>, device uint* Width);
>+native void GetDimensions(Texture1D<ushort4>, threadgroup uint* Width);
>+native void GetDimensions(Texture1D<ushort4>, threadgroup uint* Width);
>+native void GetDimensions(Texture1D<ushort4>, threadgroup uint* Width);
>+
>+native void GetDimensions(Texture1DArray<ushort4>, thread uint* Width, thread uint* Elements);
>+native void GetDimensions(Texture1DArray<ushort4>, thread uint* Width, thread uint* Elements);
>+native void GetDimensions(Texture1DArray<ushort4>, thread uint* Width, thread uint* Elements);
>+native void GetDimensions(Texture1DArray<ushort4>, thread uint* Width, device uint* Elements);
>+native void GetDimensions(Texture1DArray<ushort4>, thread uint* Width, device uint* Elements);
>+native void GetDimensions(Texture1DArray<ushort4>, thread uint* Width, device uint* Elements);
>+native void GetDimensions(Texture1DArray<ushort4>, thread uint* Width, threadgroup uint* Elements);
>+native void GetDimensions(Texture1DArray<ushort4>, thread uint* Width, threadgroup uint* Elements);
>+native void GetDimensions(Texture1DArray<ushort4>, thread uint* Width, threadgroup uint* Elements);
>+native void GetDimensions(Texture1DArray<ushort4>, device uint* Width, thread uint* Elements);
>+native void GetDimensions(Texture1DArray<ushort4>, device uint* Width, thread uint* Elements);
>+native void GetDimensions(Texture1DArray<ushort4>, device uint* Width, thread uint* Elements);
>+native void GetDimensions(Texture1DArray<ushort4>, device uint* Width, device uint* Elements);
>+native void GetDimensions(Texture1DArray<ushort4>, device uint* Width, device uint* Elements);
>+native void GetDimensions(Texture1DArray<ushort4>, device uint* Width, device uint* Elements);
>+native void GetDimensions(Texture1DArray<ushort4>, device uint* Width, threadgroup uint* Elements);
>+native void GetDimensions(Texture1DArray<ushort4>, device uint* Width, threadgroup uint* Elements);
>+native void GetDimensions(Texture1DArray<ushort4>, device uint* Width, threadgroup uint* Elements);
>+native void GetDimensions(Texture1DArray<ushort4>, threadgroup uint* Width, thread uint* Elements);
>+native void GetDimensions(Texture1DArray<ushort4>, threadgroup uint* Width, thread uint* Elements);
>+native void GetDimensions(Texture1DArray<ushort4>, threadgroup uint* Width, thread uint* Elements);
>+native void GetDimensions(Texture1DArray<ushort4>, threadgroup uint* Width, device uint* Elements);
>+native void GetDimensions(Texture1DArray<ushort4>, threadgroup uint* Width, device uint* Elements);
>+native void GetDimensions(Texture1DArray<ushort4>, threadgroup uint* Width, device uint* Elements);
>+native void GetDimensions(Texture1DArray<ushort4>, threadgroup uint* Width, threadgroup uint* Elements);
>+native void GetDimensions(Texture1DArray<ushort4>, threadgroup uint* Width, threadgroup uint* Elements);
>+native void GetDimensions(Texture1DArray<ushort4>, threadgroup uint* Width, threadgroup uint* Elements);
>+
>+native void GetDimensions(Texture2D<ushort4>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<ushort4>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<ushort4>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<ushort4>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<ushort4>, uint MipLevel, thread uint* Width, device uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<ushort4>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<ushort4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<ushort4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<ushort4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<ushort4>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<ushort4>, uint MipLevel, device uint* Width, thread uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<ushort4>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<ushort4>, uint MipLevel, device uint* Width, device uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<ushort4>, uint MipLevel, device uint* Width, device uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<ushort4>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<ushort4>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<ushort4>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<ushort4>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<ushort4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<ushort4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<ushort4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<ushort4>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<ushort4>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<ushort4>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<ushort4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<ushort4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<ushort4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels);
>+
>+native void GetDimensions(Texture2DArray<ushort4>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort4>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort4>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort4>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort4>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort4>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort4>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort4>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort4>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort4>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort4>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort4>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort4>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort4>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort4>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort4>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort4>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort4>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort4>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort4>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort4>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort4>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort4>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort4>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort4>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort4>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort4>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort4>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort4>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort4>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort4>, uint MipLevel, device uint* Width, device uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort4>, uint MipLevel, device uint* Width, device uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort4>, uint MipLevel, device uint* Width, device uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort4>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort4>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort4>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort4>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort4>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort4>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort4>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort4>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort4>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort4>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort4>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort4>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort4>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort4>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort4>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort4>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort4>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort4>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort4>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort4>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort4>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+
>+native void GetDimensions(Texture3D<ushort4>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort4>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort4>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort4>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort4>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort4>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort4>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort4>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort4>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort4>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort4>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort4>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort4>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort4>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort4>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort4>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort4>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort4>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort4>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort4>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort4>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort4>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort4>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort4>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort4>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort4>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort4>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort4>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort4>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort4>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort4>, uint MipLevel, device uint* Width, device uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort4>, uint MipLevel, device uint* Width, device uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort4>, uint MipLevel, device uint* Width, device uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort4>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort4>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort4>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort4>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort4>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort4>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort4>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort4>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort4>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort4>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort4>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort4>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort4>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort4>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort4>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort4>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort4>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort4>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort4>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort4>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort4>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+
>+native void GetDimensions(TextureCube<ushort4>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<ushort4>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<ushort4>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<ushort4>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<ushort4>, uint MipLevel, thread uint* Width, device uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<ushort4>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<ushort4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<ushort4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<ushort4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<ushort4>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<ushort4>, uint MipLevel, device uint* Width, thread uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<ushort4>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<ushort4>, uint MipLevel, device uint* Width, device uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<ushort4>, uint MipLevel, device uint* Width, device uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<ushort4>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<ushort4>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<ushort4>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<ushort4>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<ushort4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<ushort4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<ushort4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<ushort4>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<ushort4>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<ushort4>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<ushort4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<ushort4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<ushort4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels);
>+
>+
>+
>+
>+
>+
>+native void GetDimensions(Texture1D<uint>, thread uint* Width);
>+native void GetDimensions(Texture1D<uint>, thread uint* Width);
>+native void GetDimensions(Texture1D<uint>, thread uint* Width);
>+native void GetDimensions(Texture1D<uint>, device uint* Width);
>+native void GetDimensions(Texture1D<uint>, device uint* Width);
>+native void GetDimensions(Texture1D<uint>, device uint* Width);
>+native void GetDimensions(Texture1D<uint>, threadgroup uint* Width);
>+native void GetDimensions(Texture1D<uint>, threadgroup uint* Width);
>+native void GetDimensions(Texture1D<uint>, threadgroup uint* Width);
>+
>+native void GetDimensions(Texture1DArray<uint>, thread uint* Width, thread uint* Elements);
>+native void GetDimensions(Texture1DArray<uint>, thread uint* Width, thread uint* Elements);
>+native void GetDimensions(Texture1DArray<uint>, thread uint* Width, thread uint* Elements);
>+native void GetDimensions(Texture1DArray<uint>, thread uint* Width, device uint* Elements);
>+native void GetDimensions(Texture1DArray<uint>, thread uint* Width, device uint* Elements);
>+native void GetDimensions(Texture1DArray<uint>, thread uint* Width, device uint* Elements);
>+native void GetDimensions(Texture1DArray<uint>, thread uint* Width, threadgroup uint* Elements);
>+native void GetDimensions(Texture1DArray<uint>, thread uint* Width, threadgroup uint* Elements);
>+native void GetDimensions(Texture1DArray<uint>, thread uint* Width, threadgroup uint* Elements);
>+native void GetDimensions(Texture1DArray<uint>, device uint* Width, thread uint* Elements);
>+native void GetDimensions(Texture1DArray<uint>, device uint* Width, thread uint* Elements);
>+native void GetDimensions(Texture1DArray<uint>, device uint* Width, thread uint* Elements);
>+native void GetDimensions(Texture1DArray<uint>, device uint* Width, device uint* Elements);
>+native void GetDimensions(Texture1DArray<uint>, device uint* Width, device uint* Elements);
>+native void GetDimensions(Texture1DArray<uint>, device uint* Width, device uint* Elements);
>+native void GetDimensions(Texture1DArray<uint>, device uint* Width, threadgroup uint* Elements);
>+native void GetDimensions(Texture1DArray<uint>, device uint* Width, threadgroup uint* Elements);
>+native void GetDimensions(Texture1DArray<uint>, device uint* Width, threadgroup uint* Elements);
>+native void GetDimensions(Texture1DArray<uint>, threadgroup uint* Width, thread uint* Elements);
>+native void GetDimensions(Texture1DArray<uint>, threadgroup uint* Width, thread uint* Elements);
>+native void GetDimensions(Texture1DArray<uint>, threadgroup uint* Width, thread uint* Elements);
>+native void GetDimensions(Texture1DArray<uint>, threadgroup uint* Width, device uint* Elements);
>+native void GetDimensions(Texture1DArray<uint>, threadgroup uint* Width, device uint* Elements);
>+native void GetDimensions(Texture1DArray<uint>, threadgroup uint* Width, device uint* Elements);
>+native void GetDimensions(Texture1DArray<uint>, threadgroup uint* Width, threadgroup uint* Elements);
>+native void GetDimensions(Texture1DArray<uint>, threadgroup uint* Width, threadgroup uint* Elements);
>+native void GetDimensions(Texture1DArray<uint>, threadgroup uint* Width, threadgroup uint* Elements);
>+
>+native void GetDimensions(Texture2D<uint>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<uint>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<uint>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<uint>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<uint>, uint MipLevel, thread uint* Width, device uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<uint>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<uint>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<uint>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<uint>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<uint>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<uint>, uint MipLevel, device uint* Width, thread uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<uint>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<uint>, uint MipLevel, device uint* Width, device uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<uint>, uint MipLevel, device uint* Width, device uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<uint>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<uint>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<uint>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<uint>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<uint>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<uint>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<uint>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<uint>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<uint>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<uint>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<uint>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<uint>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<uint>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels);
>+
>+native void GetDimensions(Texture2DArray<uint>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint>, uint MipLevel, device uint* Width, device uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint>, uint MipLevel, device uint* Width, device uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint>, uint MipLevel, device uint* Width, device uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+
>+native void GetDimensions(Texture3D<uint>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint>, uint MipLevel, device uint* Width, device uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint>, uint MipLevel, device uint* Width, device uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint>, uint MipLevel, device uint* Width, device uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+
>+native void GetDimensions(TextureCube<uint>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<uint>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<uint>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<uint>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<uint>, uint MipLevel, thread uint* Width, device uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<uint>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<uint>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<uint>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<uint>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<uint>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<uint>, uint MipLevel, device uint* Width, thread uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<uint>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<uint>, uint MipLevel, device uint* Width, device uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<uint>, uint MipLevel, device uint* Width, device uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<uint>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<uint>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<uint>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<uint>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<uint>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<uint>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<uint>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<uint>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<uint>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<uint>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<uint>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<uint>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<uint>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels);
>+
>+
>+
>+
>+
>+
>+native void GetDimensions(Texture1D<uint2>, thread uint* Width);
>+native void GetDimensions(Texture1D<uint2>, thread uint* Width);
>+native void GetDimensions(Texture1D<uint2>, thread uint* Width);
>+native void GetDimensions(Texture1D<uint2>, device uint* Width);
>+native void GetDimensions(Texture1D<uint2>, device uint* Width);
>+native void GetDimensions(Texture1D<uint2>, device uint* Width);
>+native void GetDimensions(Texture1D<uint2>, threadgroup uint* Width);
>+native void GetDimensions(Texture1D<uint2>, threadgroup uint* Width);
>+native void GetDimensions(Texture1D<uint2>, threadgroup uint* Width);
>+
>+native void GetDimensions(Texture1DArray<uint2>, thread uint* Width, thread uint* Elements);
>+native void GetDimensions(Texture1DArray<uint2>, thread uint* Width, thread uint* Elements);
>+native void GetDimensions(Texture1DArray<uint2>, thread uint* Width, thread uint* Elements);
>+native void GetDimensions(Texture1DArray<uint2>, thread uint* Width, device uint* Elements);
>+native void GetDimensions(Texture1DArray<uint2>, thread uint* Width, device uint* Elements);
>+native void GetDimensions(Texture1DArray<uint2>, thread uint* Width, device uint* Elements);
>+native void GetDimensions(Texture1DArray<uint2>, thread uint* Width, threadgroup uint* Elements);
>+native void GetDimensions(Texture1DArray<uint2>, thread uint* Width, threadgroup uint* Elements);
>+native void GetDimensions(Texture1DArray<uint2>, thread uint* Width, threadgroup uint* Elements);
>+native void GetDimensions(Texture1DArray<uint2>, device uint* Width, thread uint* Elements);
>+native void GetDimensions(Texture1DArray<uint2>, device uint* Width, thread uint* Elements);
>+native void GetDimensions(Texture1DArray<uint2>, device uint* Width, thread uint* Elements);
>+native void GetDimensions(Texture1DArray<uint2>, device uint* Width, device uint* Elements);
>+native void GetDimensions(Texture1DArray<uint2>, device uint* Width, device uint* Elements);
>+native void GetDimensions(Texture1DArray<uint2>, device uint* Width, device uint* Elements);
>+native void GetDimensions(Texture1DArray<uint2>, device uint* Width, threadgroup uint* Elements);
>+native void GetDimensions(Texture1DArray<uint2>, device uint* Width, threadgroup uint* Elements);
>+native void GetDimensions(Texture1DArray<uint2>, device uint* Width, threadgroup uint* Elements);
>+native void GetDimensions(Texture1DArray<uint2>, threadgroup uint* Width, thread uint* Elements);
>+native void GetDimensions(Texture1DArray<uint2>, threadgroup uint* Width, thread uint* Elements);
>+native void GetDimensions(Texture1DArray<uint2>, threadgroup uint* Width, thread uint* Elements);
>+native void GetDimensions(Texture1DArray<uint2>, threadgroup uint* Width, device uint* Elements);
>+native void GetDimensions(Texture1DArray<uint2>, threadgroup uint* Width, device uint* Elements);
>+native void GetDimensions(Texture1DArray<uint2>, threadgroup uint* Width, device uint* Elements);
>+native void GetDimensions(Texture1DArray<uint2>, threadgroup uint* Width, threadgroup uint* Elements);
>+native void GetDimensions(Texture1DArray<uint2>, threadgroup uint* Width, threadgroup uint* Elements);
>+native void GetDimensions(Texture1DArray<uint2>, threadgroup uint* Width, threadgroup uint* Elements);
>+
>+native void GetDimensions(Texture2D<uint2>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<uint2>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<uint2>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<uint2>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<uint2>, uint MipLevel, thread uint* Width, device uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<uint2>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<uint2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<uint2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<uint2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<uint2>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<uint2>, uint MipLevel, device uint* Width, thread uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<uint2>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<uint2>, uint MipLevel, device uint* Width, device uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<uint2>, uint MipLevel, device uint* Width, device uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<uint2>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<uint2>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<uint2>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<uint2>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<uint2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<uint2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<uint2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<uint2>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<uint2>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<uint2>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<uint2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<uint2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<uint2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels);
>+
>+native void GetDimensions(Texture2DArray<uint2>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint2>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint2>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint2>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint2>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint2>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint2>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint2>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint2>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint2>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint2>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint2>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint2>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint2>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint2>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint2>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint2>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint2>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint2>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint2>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint2>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint2>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint2>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint2>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint2>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint2>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint2>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint2>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint2>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint2>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint2>, uint MipLevel, device uint* Width, device uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint2>, uint MipLevel, device uint* Width, device uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint2>, uint MipLevel, device uint* Width, device uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint2>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint2>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint2>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint2>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint2>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint2>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint2>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint2>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint2>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint2>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint2>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint2>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint2>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint2>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint2>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint2>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint2>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint2>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint2>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint2>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint2>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+
>+native void GetDimensions(Texture3D<uint2>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint2>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint2>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint2>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint2>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint2>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint2>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint2>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint2>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint2>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint2>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint2>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint2>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint2>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint2>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint2>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint2>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint2>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint2>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint2>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint2>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint2>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint2>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint2>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint2>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint2>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint2>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint2>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint2>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint2>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint2>, uint MipLevel, device uint* Width, device uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint2>, uint MipLevel, device uint* Width, device uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint2>, uint MipLevel, device uint* Width, device uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint2>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint2>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint2>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint2>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint2>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint2>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint2>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint2>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint2>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint2>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint2>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint2>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint2>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint2>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint2>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint2>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint2>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint2>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint2>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint2>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint2>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+
>+native void GetDimensions(TextureCube<uint2>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<uint2>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<uint2>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<uint2>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<uint2>, uint MipLevel, thread uint* Width, device uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<uint2>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<uint2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<uint2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<uint2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<uint2>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<uint2>, uint MipLevel, device uint* Width, thread uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<uint2>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<uint2>, uint MipLevel, device uint* Width, device uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<uint2>, uint MipLevel, device uint* Width, device uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<uint2>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<uint2>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<uint2>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<uint2>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<uint2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<uint2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<uint2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<uint2>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<uint2>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<uint2>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<uint2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<uint2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<uint2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels);
>+
>+
>+
>+
>+
>+
>+native void GetDimensions(Texture1D<uint3>, thread uint* Width);
>+native void GetDimensions(Texture1D<uint3>, thread uint* Width);
>+native void GetDimensions(Texture1D<uint3>, thread uint* Width);
>+native void GetDimensions(Texture1D<uint3>, device uint* Width);
>+native void GetDimensions(Texture1D<uint3>, device uint* Width);
>+native void GetDimensions(Texture1D<uint3>, device uint* Width);
>+native void GetDimensions(Texture1D<uint3>, threadgroup uint* Width);
>+native void GetDimensions(Texture1D<uint3>, threadgroup uint* Width);
>+native void GetDimensions(Texture1D<uint3>, threadgroup uint* Width);
>+
>+native void GetDimensions(Texture1DArray<uint3>, thread uint* Width, thread uint* Elements);
>+native void GetDimensions(Texture1DArray<uint3>, thread uint* Width, thread uint* Elements);
>+native void GetDimensions(Texture1DArray<uint3>, thread uint* Width, thread uint* Elements);
>+native void GetDimensions(Texture1DArray<uint3>, thread uint* Width, device uint* Elements);
>+native void GetDimensions(Texture1DArray<uint3>, thread uint* Width, device uint* Elements);
>+native void GetDimensions(Texture1DArray<uint3>, thread uint* Width, device uint* Elements);
>+native void GetDimensions(Texture1DArray<uint3>, thread uint* Width, threadgroup uint* Elements);
>+native void GetDimensions(Texture1DArray<uint3>, thread uint* Width, threadgroup uint* Elements);
>+native void GetDimensions(Texture1DArray<uint3>, thread uint* Width, threadgroup uint* Elements);
>+native void GetDimensions(Texture1DArray<uint3>, device uint* Width, thread uint* Elements);
>+native void GetDimensions(Texture1DArray<uint3>, device uint* Width, thread uint* Elements);
>+native void GetDimensions(Texture1DArray<uint3>, device uint* Width, thread uint* Elements);
>+native void GetDimensions(Texture1DArray<uint3>, device uint* Width, device uint* Elements);
>+native void GetDimensions(Texture1DArray<uint3>, device uint* Width, device uint* Elements);
>+native void GetDimensions(Texture1DArray<uint3>, device uint* Width, device uint* Elements);
>+native void GetDimensions(Texture1DArray<uint3>, device uint* Width, threadgroup uint* Elements);
>+native void GetDimensions(Texture1DArray<uint3>, device uint* Width, threadgroup uint* Elements);
>+native void GetDimensions(Texture1DArray<uint3>, device uint* Width, threadgroup uint* Elements);
>+native void GetDimensions(Texture1DArray<uint3>, threadgroup uint* Width, thread uint* Elements);
>+native void GetDimensions(Texture1DArray<uint3>, threadgroup uint* Width, thread uint* Elements);
>+native void GetDimensions(Texture1DArray<uint3>, threadgroup uint* Width, thread uint* Elements);
>+native void GetDimensions(Texture1DArray<uint3>, threadgroup uint* Width, device uint* Elements);
>+native void GetDimensions(Texture1DArray<uint3>, threadgroup uint* Width, device uint* Elements);
>+native void GetDimensions(Texture1DArray<uint3>, threadgroup uint* Width, device uint* Elements);
>+native void GetDimensions(Texture1DArray<uint3>, threadgroup uint* Width, threadgroup uint* Elements);
>+native void GetDimensions(Texture1DArray<uint3>, threadgroup uint* Width, threadgroup uint* Elements);
>+native void GetDimensions(Texture1DArray<uint3>, threadgroup uint* Width, threadgroup uint* Elements);
>+
>+native void GetDimensions(Texture2D<uint3>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<uint3>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<uint3>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<uint3>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<uint3>, uint MipLevel, thread uint* Width, device uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<uint3>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<uint3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<uint3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<uint3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<uint3>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<uint3>, uint MipLevel, device uint* Width, thread uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<uint3>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<uint3>, uint MipLevel, device uint* Width, device uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<uint3>, uint MipLevel, device uint* Width, device uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<uint3>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<uint3>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<uint3>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<uint3>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<uint3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<uint3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<uint3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<uint3>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<uint3>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<uint3>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<uint3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<uint3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<uint3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels);
>+
>+native void GetDimensions(Texture2DArray<uint3>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint3>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint3>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint3>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint3>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint3>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint3>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint3>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint3>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint3>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint3>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint3>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint3>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint3>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint3>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint3>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint3>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint3>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint3>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint3>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint3>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint3>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint3>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint3>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint3>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint3>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint3>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint3>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint3>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint3>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint3>, uint MipLevel, device uint* Width, device uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint3>, uint MipLevel, device uint* Width, device uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint3>, uint MipLevel, device uint* Width, device uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint3>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint3>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint3>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint3>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint3>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint3>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint3>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint3>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint3>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint3>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint3>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint3>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint3>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint3>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint3>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint3>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint3>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint3>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint3>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint3>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint3>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+
>+native void GetDimensions(Texture3D<uint3>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint3>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint3>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint3>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint3>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint3>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint3>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint3>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint3>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint3>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint3>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint3>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint3>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint3>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint3>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint3>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint3>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint3>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint3>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint3>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint3>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint3>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint3>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint3>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint3>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint3>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint3>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint3>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint3>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint3>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint3>, uint MipLevel, device uint* Width, device uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint3>, uint MipLevel, device uint* Width, device uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint3>, uint MipLevel, device uint* Width, device uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint3>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint3>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint3>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint3>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint3>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint3>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint3>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint3>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint3>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint3>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint3>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint3>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint3>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint3>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint3>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint3>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint3>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint3>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint3>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint3>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint3>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+
>+native void GetDimensions(TextureCube<uint3>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<uint3>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<uint3>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<uint3>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<uint3>, uint MipLevel, thread uint* Width, device uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<uint3>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<uint3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<uint3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<uint3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<uint3>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<uint3>, uint MipLevel, device uint* Width, thread uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<uint3>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<uint3>, uint MipLevel, device uint* Width, device uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<uint3>, uint MipLevel, device uint* Width, device uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<uint3>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<uint3>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<uint3>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<uint3>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<uint3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<uint3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<uint3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<uint3>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<uint3>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<uint3>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<uint3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<uint3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<uint3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels);
>+
>+
>+
>+
>+
>+
>+native void GetDimensions(Texture1D<uint4>, thread uint* Width);
>+native void GetDimensions(Texture1D<uint4>, thread uint* Width);
>+native void GetDimensions(Texture1D<uint4>, thread uint* Width);
>+native void GetDimensions(Texture1D<uint4>, device uint* Width);
>+native void GetDimensions(Texture1D<uint4>, device uint* Width);
>+native void GetDimensions(Texture1D<uint4>, device uint* Width);
>+native void GetDimensions(Texture1D<uint4>, threadgroup uint* Width);
>+native void GetDimensions(Texture1D<uint4>, threadgroup uint* Width);
>+native void GetDimensions(Texture1D<uint4>, threadgroup uint* Width);
>+
>+native void GetDimensions(Texture1DArray<uint4>, thread uint* Width, thread uint* Elements);
>+native void GetDimensions(Texture1DArray<uint4>, thread uint* Width, thread uint* Elements);
>+native void GetDimensions(Texture1DArray<uint4>, thread uint* Width, thread uint* Elements);
>+native void GetDimensions(Texture1DArray<uint4>, thread uint* Width, device uint* Elements);
>+native void GetDimensions(Texture1DArray<uint4>, thread uint* Width, device uint* Elements);
>+native void GetDimensions(Texture1DArray<uint4>, thread uint* Width, device uint* Elements);
>+native void GetDimensions(Texture1DArray<uint4>, thread uint* Width, threadgroup uint* Elements);
>+native void GetDimensions(Texture1DArray<uint4>, thread uint* Width, threadgroup uint* Elements);
>+native void GetDimensions(Texture1DArray<uint4>, thread uint* Width, threadgroup uint* Elements);
>+native void GetDimensions(Texture1DArray<uint4>, device uint* Width, thread uint* Elements);
>+native void GetDimensions(Texture1DArray<uint4>, device uint* Width, thread uint* Elements);
>+native void GetDimensions(Texture1DArray<uint4>, device uint* Width, thread uint* Elements);
>+native void GetDimensions(Texture1DArray<uint4>, device uint* Width, device uint* Elements);
>+native void GetDimensions(Texture1DArray<uint4>, device uint* Width, device uint* Elements);
>+native void GetDimensions(Texture1DArray<uint4>, device uint* Width, device uint* Elements);
>+native void GetDimensions(Texture1DArray<uint4>, device uint* Width, threadgroup uint* Elements);
>+native void GetDimensions(Texture1DArray<uint4>, device uint* Width, threadgroup uint* Elements);
>+native void GetDimensions(Texture1DArray<uint4>, device uint* Width, threadgroup uint* Elements);
>+native void GetDimensions(Texture1DArray<uint4>, threadgroup uint* Width, thread uint* Elements);
>+native void GetDimensions(Texture1DArray<uint4>, threadgroup uint* Width, thread uint* Elements);
>+native void GetDimensions(Texture1DArray<uint4>, threadgroup uint* Width, thread uint* Elements);
>+native void GetDimensions(Texture1DArray<uint4>, threadgroup uint* Width, device uint* Elements);
>+native void GetDimensions(Texture1DArray<uint4>, threadgroup uint* Width, device uint* Elements);
>+native void GetDimensions(Texture1DArray<uint4>, threadgroup uint* Width, device uint* Elements);
>+native void GetDimensions(Texture1DArray<uint4>, threadgroup uint* Width, threadgroup uint* Elements);
>+native void GetDimensions(Texture1DArray<uint4>, threadgroup uint* Width, threadgroup uint* Elements);
>+native void GetDimensions(Texture1DArray<uint4>, threadgroup uint* Width, threadgroup uint* Elements);
>+
>+native void GetDimensions(Texture2D<uint4>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<uint4>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<uint4>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<uint4>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<uint4>, uint MipLevel, thread uint* Width, device uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<uint4>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<uint4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<uint4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<uint4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<uint4>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<uint4>, uint MipLevel, device uint* Width, thread uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<uint4>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<uint4>, uint MipLevel, device uint* Width, device uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<uint4>, uint MipLevel, device uint* Width, device uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<uint4>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<uint4>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<uint4>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<uint4>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<uint4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<uint4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<uint4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<uint4>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<uint4>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<uint4>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<uint4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<uint4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<uint4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels);
>+
>+native void GetDimensions(Texture2DArray<uint4>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint4>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint4>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint4>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint4>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint4>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint4>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint4>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint4>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint4>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint4>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint4>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint4>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint4>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint4>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint4>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint4>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint4>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint4>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint4>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint4>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint4>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint4>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint4>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint4>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint4>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint4>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint4>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint4>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint4>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint4>, uint MipLevel, device uint* Width, device uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint4>, uint MipLevel, device uint* Width, device uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint4>, uint MipLevel, device uint* Width, device uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint4>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint4>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint4>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint4>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint4>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint4>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint4>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint4>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint4>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint4>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint4>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint4>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint4>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint4>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint4>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint4>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint4>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint4>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint4>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint4>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint4>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+
>+native void GetDimensions(Texture3D<uint4>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint4>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint4>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint4>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint4>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint4>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint4>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint4>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint4>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint4>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint4>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint4>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint4>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint4>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint4>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint4>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint4>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint4>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint4>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint4>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint4>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint4>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint4>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint4>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint4>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint4>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint4>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint4>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint4>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint4>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint4>, uint MipLevel, device uint* Width, device uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint4>, uint MipLevel, device uint* Width, device uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint4>, uint MipLevel, device uint* Width, device uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint4>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint4>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint4>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint4>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint4>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint4>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint4>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint4>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint4>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint4>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint4>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint4>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint4>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint4>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint4>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint4>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint4>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint4>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint4>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint4>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint4>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+
>+native void GetDimensions(TextureCube<uint4>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<uint4>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<uint4>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<uint4>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<uint4>, uint MipLevel, thread uint* Width, device uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<uint4>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<uint4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<uint4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<uint4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<uint4>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<uint4>, uint MipLevel, device uint* Width, thread uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<uint4>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<uint4>, uint MipLevel, device uint* Width, device uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<uint4>, uint MipLevel, device uint* Width, device uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<uint4>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<uint4>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<uint4>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<uint4>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<uint4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<uint4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<uint4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<uint4>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<uint4>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<uint4>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<uint4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<uint4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<uint4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels);
>+
>+
>+
>+
>+
>+
>+native void GetDimensions(Texture1D<short>, thread uint* Width);
>+native void GetDimensions(Texture1D<short>, thread uint* Width);
>+native void GetDimensions(Texture1D<short>, thread uint* Width);
>+native void GetDimensions(Texture1D<short>, device uint* Width);
>+native void GetDimensions(Texture1D<short>, device uint* Width);
>+native void GetDimensions(Texture1D<short>, device uint* Width);
>+native void GetDimensions(Texture1D<short>, threadgroup uint* Width);
>+native void GetDimensions(Texture1D<short>, threadgroup uint* Width);
>+native void GetDimensions(Texture1D<short>, threadgroup uint* Width);
>+
>+native void GetDimensions(Texture1DArray<short>, thread uint* Width, thread uint* Elements);
>+native void GetDimensions(Texture1DArray<short>, thread uint* Width, thread uint* Elements);
>+native void GetDimensions(Texture1DArray<short>, thread uint* Width, thread uint* Elements);
>+native void GetDimensions(Texture1DArray<short>, thread uint* Width, device uint* Elements);
>+native void GetDimensions(Texture1DArray<short>, thread uint* Width, device uint* Elements);
>+native void GetDimensions(Texture1DArray<short>, thread uint* Width, device uint* Elements);
>+native void GetDimensions(Texture1DArray<short>, thread uint* Width, threadgroup uint* Elements);
>+native void GetDimensions(Texture1DArray<short>, thread uint* Width, threadgroup uint* Elements);
>+native void GetDimensions(Texture1DArray<short>, thread uint* Width, threadgroup uint* Elements);
>+native void GetDimensions(Texture1DArray<short>, device uint* Width, thread uint* Elements);
>+native void GetDimensions(Texture1DArray<short>, device uint* Width, thread uint* Elements);
>+native void GetDimensions(Texture1DArray<short>, device uint* Width, thread uint* Elements);
>+native void GetDimensions(Texture1DArray<short>, device uint* Width, device uint* Elements);
>+native void GetDimensions(Texture1DArray<short>, device uint* Width, device uint* Elements);
>+native void GetDimensions(Texture1DArray<short>, device uint* Width, device uint* Elements);
>+native void GetDimensions(Texture1DArray<short>, device uint* Width, threadgroup uint* Elements);
>+native void GetDimensions(Texture1DArray<short>, device uint* Width, threadgroup uint* Elements);
>+native void GetDimensions(Texture1DArray<short>, device uint* Width, threadgroup uint* Elements);
>+native void GetDimensions(Texture1DArray<short>, threadgroup uint* Width, thread uint* Elements);
>+native void GetDimensions(Texture1DArray<short>, threadgroup uint* Width, thread uint* Elements);
>+native void GetDimensions(Texture1DArray<short>, threadgroup uint* Width, thread uint* Elements);
>+native void GetDimensions(Texture1DArray<short>, threadgroup uint* Width, device uint* Elements);
>+native void GetDimensions(Texture1DArray<short>, threadgroup uint* Width, device uint* Elements);
>+native void GetDimensions(Texture1DArray<short>, threadgroup uint* Width, device uint* Elements);
>+native void GetDimensions(Texture1DArray<short>, threadgroup uint* Width, threadgroup uint* Elements);
>+native void GetDimensions(Texture1DArray<short>, threadgroup uint* Width, threadgroup uint* Elements);
>+native void GetDimensions(Texture1DArray<short>, threadgroup uint* Width, threadgroup uint* Elements);
>+
>+native void GetDimensions(Texture2D<short>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<short>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<short>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<short>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<short>, uint MipLevel, thread uint* Width, device uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<short>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<short>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<short>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<short>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<short>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<short>, uint MipLevel, device uint* Width, thread uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<short>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<short>, uint MipLevel, device uint* Width, device uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<short>, uint MipLevel, device uint* Width, device uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<short>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<short>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<short>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<short>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<short>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<short>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<short>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<short>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<short>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<short>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<short>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<short>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<short>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels);
>+
>+native void GetDimensions(Texture2DArray<short>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short>, uint MipLevel, device uint* Width, device uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short>, uint MipLevel, device uint* Width, device uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short>, uint MipLevel, device uint* Width, device uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+
>+native void GetDimensions(Texture3D<short>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short>, uint MipLevel, device uint* Width, device uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short>, uint MipLevel, device uint* Width, device uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short>, uint MipLevel, device uint* Width, device uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+
>+native void GetDimensions(TextureCube<short>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<short>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<short>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<short>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<short>, uint MipLevel, thread uint* Width, device uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<short>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<short>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<short>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<short>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<short>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<short>, uint MipLevel, device uint* Width, thread uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<short>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<short>, uint MipLevel, device uint* Width, device uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<short>, uint MipLevel, device uint* Width, device uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<short>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<short>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<short>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<short>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<short>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<short>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<short>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<short>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<short>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<short>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<short>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<short>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<short>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels);
>+
>+
>+
>+
>+
>+
>+native void GetDimensions(Texture1D<short2>, thread uint* Width);
>+native void GetDimensions(Texture1D<short2>, thread uint* Width);
>+native void GetDimensions(Texture1D<short2>, thread uint* Width);
>+native void GetDimensions(Texture1D<short2>, device uint* Width);
>+native void GetDimensions(Texture1D<short2>, device uint* Width);
>+native void GetDimensions(Texture1D<short2>, device uint* Width);
>+native void GetDimensions(Texture1D<short2>, threadgroup uint* Width);
>+native void GetDimensions(Texture1D<short2>, threadgroup uint* Width);
>+native void GetDimensions(Texture1D<short2>, threadgroup uint* Width);
>+
>+native void GetDimensions(Texture1DArray<short2>, thread uint* Width, thread uint* Elements);
>+native void GetDimensions(Texture1DArray<short2>, thread uint* Width, thread uint* Elements);
>+native void GetDimensions(Texture1DArray<short2>, thread uint* Width, thread uint* Elements);
>+native void GetDimensions(Texture1DArray<short2>, thread uint* Width, device uint* Elements);
>+native void GetDimensions(Texture1DArray<short2>, thread uint* Width, device uint* Elements);
>+native void GetDimensions(Texture1DArray<short2>, thread uint* Width, device uint* Elements);
>+native void GetDimensions(Texture1DArray<short2>, thread uint* Width, threadgroup uint* Elements);
>+native void GetDimensions(Texture1DArray<short2>, thread uint* Width, threadgroup uint* Elements);
>+native void GetDimensions(Texture1DArray<short2>, thread uint* Width, threadgroup uint* Elements);
>+native void GetDimensions(Texture1DArray<short2>, device uint* Width, thread uint* Elements);
>+native void GetDimensions(Texture1DArray<short2>, device uint* Width, thread uint* Elements);
>+native void GetDimensions(Texture1DArray<short2>, device uint* Width, thread uint* Elements);
>+native void GetDimensions(Texture1DArray<short2>, device uint* Width, device uint* Elements);
>+native void GetDimensions(Texture1DArray<short2>, device uint* Width, device uint* Elements);
>+native void GetDimensions(Texture1DArray<short2>, device uint* Width, device uint* Elements);
>+native void GetDimensions(Texture1DArray<short2>, device uint* Width, threadgroup uint* Elements);
>+native void GetDimensions(Texture1DArray<short2>, device uint* Width, threadgroup uint* Elements);
>+native void GetDimensions(Texture1DArray<short2>, device uint* Width, threadgroup uint* Elements);
>+native void GetDimensions(Texture1DArray<short2>, threadgroup uint* Width, thread uint* Elements);
>+native void GetDimensions(Texture1DArray<short2>, threadgroup uint* Width, thread uint* Elements);
>+native void GetDimensions(Texture1DArray<short2>, threadgroup uint* Width, thread uint* Elements);
>+native void GetDimensions(Texture1DArray<short2>, threadgroup uint* Width, device uint* Elements);
>+native void GetDimensions(Texture1DArray<short2>, threadgroup uint* Width, device uint* Elements);
>+native void GetDimensions(Texture1DArray<short2>, threadgroup uint* Width, device uint* Elements);
>+native void GetDimensions(Texture1DArray<short2>, threadgroup uint* Width, threadgroup uint* Elements);
>+native void GetDimensions(Texture1DArray<short2>, threadgroup uint* Width, threadgroup uint* Elements);
>+native void GetDimensions(Texture1DArray<short2>, threadgroup uint* Width, threadgroup uint* Elements);
>+
>+native void GetDimensions(Texture2D<short2>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<short2>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<short2>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<short2>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<short2>, uint MipLevel, thread uint* Width, device uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<short2>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<short2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<short2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<short2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<short2>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<short2>, uint MipLevel, device uint* Width, thread uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<short2>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<short2>, uint MipLevel, device uint* Width, device uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<short2>, uint MipLevel, device uint* Width, device uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<short2>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<short2>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<short2>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<short2>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<short2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<short2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<short2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<short2>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<short2>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<short2>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<short2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<short2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<short2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels);
>+
>+native void GetDimensions(Texture2DArray<short2>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short2>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short2>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short2>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short2>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short2>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short2>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short2>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short2>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short2>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short2>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short2>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short2>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short2>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short2>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short2>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short2>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short2>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short2>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short2>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short2>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short2>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short2>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short2>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short2>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short2>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short2>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short2>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short2>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short2>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short2>, uint MipLevel, device uint* Width, device uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short2>, uint MipLevel, device uint* Width, device uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short2>, uint MipLevel, device uint* Width, device uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short2>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short2>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short2>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short2>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short2>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short2>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short2>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short2>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short2>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short2>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short2>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short2>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short2>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short2>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short2>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short2>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short2>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short2>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short2>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short2>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short2>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+
>+native void GetDimensions(Texture3D<short2>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short2>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short2>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short2>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short2>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short2>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short2>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short2>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short2>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short2>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short2>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short2>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short2>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short2>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short2>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short2>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short2>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short2>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short2>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short2>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short2>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short2>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short2>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short2>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short2>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short2>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short2>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short2>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short2>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short2>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short2>, uint MipLevel, device uint* Width, device uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short2>, uint MipLevel, device uint* Width, device uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short2>, uint MipLevel, device uint* Width, device uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short2>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short2>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short2>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short2>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short2>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short2>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short2>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short2>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short2>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short2>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short2>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short2>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short2>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short2>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short2>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short2>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short2>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short2>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short2>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short2>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short2>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+
>+native void GetDimensions(TextureCube<short2>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<short2>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<short2>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<short2>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<short2>, uint MipLevel, thread uint* Width, device uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<short2>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<short2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<short2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<short2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<short2>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<short2>, uint MipLevel, device uint* Width, thread uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<short2>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<short2>, uint MipLevel, device uint* Width, device uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<short2>, uint MipLevel, device uint* Width, device uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<short2>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<short2>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<short2>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<short2>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<short2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<short2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<short2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<short2>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<short2>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<short2>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<short2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<short2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<short2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels);
>+
>+
>+
>+
>+
>+
>+native void GetDimensions(Texture1D<short3>, thread uint* Width);
>+native void GetDimensions(Texture1D<short3>, thread uint* Width);
>+native void GetDimensions(Texture1D<short3>, thread uint* Width);
>+native void GetDimensions(Texture1D<short3>, device uint* Width);
>+native void GetDimensions(Texture1D<short3>, device uint* Width);
>+native void GetDimensions(Texture1D<short3>, device uint* Width);
>+native void GetDimensions(Texture1D<short3>, threadgroup uint* Width);
>+native void GetDimensions(Texture1D<short3>, threadgroup uint* Width);
>+native void GetDimensions(Texture1D<short3>, threadgroup uint* Width);
>+
>+native void GetDimensions(Texture1DArray<short3>, thread uint* Width, thread uint* Elements);
>+native void GetDimensions(Texture1DArray<short3>, thread uint* Width, thread uint* Elements);
>+native void GetDimensions(Texture1DArray<short3>, thread uint* Width, thread uint* Elements);
>+native void GetDimensions(Texture1DArray<short3>, thread uint* Width, device uint* Elements);
>+native void GetDimensions(Texture1DArray<short3>, thread uint* Width, device uint* Elements);
>+native void GetDimensions(Texture1DArray<short3>, thread uint* Width, device uint* Elements);
>+native void GetDimensions(Texture1DArray<short3>, thread uint* Width, threadgroup uint* Elements);
>+native void GetDimensions(Texture1DArray<short3>, thread uint* Width, threadgroup uint* Elements);
>+native void GetDimensions(Texture1DArray<short3>, thread uint* Width, threadgroup uint* Elements);
>+native void GetDimensions(Texture1DArray<short3>, device uint* Width, thread uint* Elements);
>+native void GetDimensions(Texture1DArray<short3>, device uint* Width, thread uint* Elements);
>+native void GetDimensions(Texture1DArray<short3>, device uint* Width, thread uint* Elements);
>+native void GetDimensions(Texture1DArray<short3>, device uint* Width, device uint* Elements);
>+native void GetDimensions(Texture1DArray<short3>, device uint* Width, device uint* Elements);
>+native void GetDimensions(Texture1DArray<short3>, device uint* Width, device uint* Elements);
>+native void GetDimensions(Texture1DArray<short3>, device uint* Width, threadgroup uint* Elements);
>+native void GetDimensions(Texture1DArray<short3>, device uint* Width, threadgroup uint* Elements);
>+native void GetDimensions(Texture1DArray<short3>, device uint* Width, threadgroup uint* Elements);
>+native void GetDimensions(Texture1DArray<short3>, threadgroup uint* Width, thread uint* Elements);
>+native void GetDimensions(Texture1DArray<short3>, threadgroup uint* Width, thread uint* Elements);
>+native void GetDimensions(Texture1DArray<short3>, threadgroup uint* Width, thread uint* Elements);
>+native void GetDimensions(Texture1DArray<short3>, threadgroup uint* Width, device uint* Elements);
>+native void GetDimensions(Texture1DArray<short3>, threadgroup uint* Width, device uint* Elements);
>+native void GetDimensions(Texture1DArray<short3>, threadgroup uint* Width, device uint* Elements);
>+native void GetDimensions(Texture1DArray<short3>, threadgroup uint* Width, threadgroup uint* Elements);
>+native void GetDimensions(Texture1DArray<short3>, threadgroup uint* Width, threadgroup uint* Elements);
>+native void GetDimensions(Texture1DArray<short3>, threadgroup uint* Width, threadgroup uint* Elements);
>+
>+native void GetDimensions(Texture2D<short3>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<short3>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<short3>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<short3>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<short3>, uint MipLevel, thread uint* Width, device uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<short3>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<short3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<short3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<short3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<short3>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<short3>, uint MipLevel, device uint* Width, thread uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<short3>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<short3>, uint MipLevel, device uint* Width, device uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<short3>, uint MipLevel, device uint* Width, device uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<short3>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<short3>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<short3>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<short3>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<short3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<short3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<short3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<short3>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<short3>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<short3>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<short3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<short3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<short3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels);
>+
>+native void GetDimensions(Texture2DArray<short3>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short3>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short3>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short3>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short3>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short3>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short3>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short3>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short3>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short3>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short3>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short3>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short3>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short3>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short3>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short3>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short3>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short3>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short3>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short3>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short3>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short3>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short3>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short3>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short3>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short3>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short3>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short3>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short3>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short3>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short3>, uint MipLevel, device uint* Width, device uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short3>, uint MipLevel, device uint* Width, device uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short3>, uint MipLevel, device uint* Width, device uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short3>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short3>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short3>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short3>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short3>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short3>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short3>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short3>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short3>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short3>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short3>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short3>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short3>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short3>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short3>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short3>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short3>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short3>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short3>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short3>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short3>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+
>+native void GetDimensions(Texture3D<short3>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short3>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short3>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short3>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short3>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short3>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short3>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short3>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short3>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short3>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short3>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short3>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short3>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short3>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short3>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short3>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short3>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short3>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short3>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short3>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short3>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short3>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short3>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short3>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short3>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short3>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short3>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short3>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short3>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short3>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short3>, uint MipLevel, device uint* Width, device uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short3>, uint MipLevel, device uint* Width, device uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short3>, uint MipLevel, device uint* Width, device uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short3>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short3>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short3>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short3>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short3>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short3>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short3>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short3>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short3>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short3>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short3>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short3>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short3>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short3>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short3>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short3>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short3>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short3>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short3>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short3>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short3>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+
>+native void GetDimensions(TextureCube<short3>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<short3>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<short3>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<short3>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<short3>, uint MipLevel, thread uint* Width, device uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<short3>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<short3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<short3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<short3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<short3>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<short3>, uint MipLevel, device uint* Width, thread uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<short3>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<short3>, uint MipLevel, device uint* Width, device uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<short3>, uint MipLevel, device uint* Width, device uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<short3>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<short3>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<short3>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<short3>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<short3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<short3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<short3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<short3>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<short3>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<short3>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<short3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<short3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<short3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels);
>+
>+
>+
>+
>+
>+
>+native void GetDimensions(Texture1D<short4>, thread uint* Width);
>+native void GetDimensions(Texture1D<short4>, thread uint* Width);
>+native void GetDimensions(Texture1D<short4>, thread uint* Width);
>+native void GetDimensions(Texture1D<short4>, device uint* Width);
>+native void GetDimensions(Texture1D<short4>, device uint* Width);
>+native void GetDimensions(Texture1D<short4>, device uint* Width);
>+native void GetDimensions(Texture1D<short4>, threadgroup uint* Width);
>+native void GetDimensions(Texture1D<short4>, threadgroup uint* Width);
>+native void GetDimensions(Texture1D<short4>, threadgroup uint* Width);
>+
>+native void GetDimensions(Texture1DArray<short4>, thread uint* Width, thread uint* Elements);
>+native void GetDimensions(Texture1DArray<short4>, thread uint* Width, thread uint* Elements);
>+native void GetDimensions(Texture1DArray<short4>, thread uint* Width, thread uint* Elements);
>+native void GetDimensions(Texture1DArray<short4>, thread uint* Width, device uint* Elements);
>+native void GetDimensions(Texture1DArray<short4>, thread uint* Width, device uint* Elements);
>+native void GetDimensions(Texture1DArray<short4>, thread uint* Width, device uint* Elements);
>+native void GetDimensions(Texture1DArray<short4>, thread uint* Width, threadgroup uint* Elements);
>+native void GetDimensions(Texture1DArray<short4>, thread uint* Width, threadgroup uint* Elements);
>+native void GetDimensions(Texture1DArray<short4>, thread uint* Width, threadgroup uint* Elements);
>+native void GetDimensions(Texture1DArray<short4>, device uint* Width, thread uint* Elements);
>+native void GetDimensions(Texture1DArray<short4>, device uint* Width, thread uint* Elements);
>+native void GetDimensions(Texture1DArray<short4>, device uint* Width, thread uint* Elements);
>+native void GetDimensions(Texture1DArray<short4>, device uint* Width, device uint* Elements);
>+native void GetDimensions(Texture1DArray<short4>, device uint* Width, device uint* Elements);
>+native void GetDimensions(Texture1DArray<short4>, device uint* Width, device uint* Elements);
>+native void GetDimensions(Texture1DArray<short4>, device uint* Width, threadgroup uint* Elements);
>+native void GetDimensions(Texture1DArray<short4>, device uint* Width, threadgroup uint* Elements);
>+native void GetDimensions(Texture1DArray<short4>, device uint* Width, threadgroup uint* Elements);
>+native void GetDimensions(Texture1DArray<short4>, threadgroup uint* Width, thread uint* Elements);
>+native void GetDimensions(Texture1DArray<short4>, threadgroup uint* Width, thread uint* Elements);
>+native void GetDimensions(Texture1DArray<short4>, threadgroup uint* Width, thread uint* Elements);
>+native void GetDimensions(Texture1DArray<short4>, threadgroup uint* Width, device uint* Elements);
>+native void GetDimensions(Texture1DArray<short4>, threadgroup uint* Width, device uint* Elements);
>+native void GetDimensions(Texture1DArray<short4>, threadgroup uint* Width, device uint* Elements);
>+native void GetDimensions(Texture1DArray<short4>, threadgroup uint* Width, threadgroup uint* Elements);
>+native void GetDimensions(Texture1DArray<short4>, threadgroup uint* Width, threadgroup uint* Elements);
>+native void GetDimensions(Texture1DArray<short4>, threadgroup uint* Width, threadgroup uint* Elements);
>+
>+native void GetDimensions(Texture2D<short4>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<short4>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<short4>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<short4>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<short4>, uint MipLevel, thread uint* Width, device uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<short4>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<short4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<short4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<short4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<short4>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<short4>, uint MipLevel, device uint* Width, thread uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<short4>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<short4>, uint MipLevel, device uint* Width, device uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<short4>, uint MipLevel, device uint* Width, device uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<short4>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<short4>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<short4>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<short4>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<short4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<short4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<short4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<short4>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<short4>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<short4>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<short4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<short4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<short4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels);
>+
>+native void GetDimensions(Texture2DArray<short4>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short4>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short4>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short4>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short4>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short4>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short4>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short4>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short4>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short4>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short4>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short4>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short4>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short4>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short4>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short4>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short4>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short4>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short4>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short4>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short4>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short4>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short4>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short4>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short4>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short4>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short4>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short4>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short4>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short4>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short4>, uint MipLevel, device uint* Width, device uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short4>, uint MipLevel, device uint* Width, device uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short4>, uint MipLevel, device uint* Width, device uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short4>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short4>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short4>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short4>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short4>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short4>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short4>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short4>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short4>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short4>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short4>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short4>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short4>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short4>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short4>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short4>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short4>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short4>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short4>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short4>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short4>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+
>+native void GetDimensions(Texture3D<short4>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short4>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short4>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short4>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short4>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short4>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short4>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short4>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short4>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short4>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short4>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short4>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short4>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short4>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short4>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short4>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short4>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short4>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short4>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short4>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short4>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short4>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short4>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short4>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short4>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short4>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short4>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short4>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short4>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short4>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short4>, uint MipLevel, device uint* Width, device uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short4>, uint MipLevel, device uint* Width, device uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short4>, uint MipLevel, device uint* Width, device uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short4>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short4>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short4>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short4>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short4>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short4>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short4>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short4>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short4>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short4>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short4>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short4>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short4>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short4>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short4>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short4>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short4>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short4>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short4>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short4>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short4>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+
>+native void GetDimensions(TextureCube<short4>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<short4>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<short4>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<short4>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<short4>, uint MipLevel, thread uint* Width, device uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<short4>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<short4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<short4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<short4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<short4>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<short4>, uint MipLevel, device uint* Width, thread uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<short4>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<short4>, uint MipLevel, device uint* Width, device uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<short4>, uint MipLevel, device uint* Width, device uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<short4>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<short4>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<short4>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<short4>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<short4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<short4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<short4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<short4>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<short4>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<short4>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<short4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<short4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<short4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels);
>+
>+
>+
>+
>+
>+
>+native void GetDimensions(Texture1D<int>, thread uint* Width);
>+native void GetDimensions(Texture1D<int>, thread uint* Width);
>+native void GetDimensions(Texture1D<int>, thread uint* Width);
>+native void GetDimensions(Texture1D<int>, device uint* Width);
>+native void GetDimensions(Texture1D<int>, device uint* Width);
>+native void GetDimensions(Texture1D<int>, device uint* Width);
>+native void GetDimensions(Texture1D<int>, threadgroup uint* Width);
>+native void GetDimensions(Texture1D<int>, threadgroup uint* Width);
>+native void GetDimensions(Texture1D<int>, threadgroup uint* Width);
>+
>+native void GetDimensions(Texture1DArray<int>, thread uint* Width, thread uint* Elements);
>+native void GetDimensions(Texture1DArray<int>, thread uint* Width, thread uint* Elements);
>+native void GetDimensions(Texture1DArray<int>, thread uint* Width, thread uint* Elements);
>+native void GetDimensions(Texture1DArray<int>, thread uint* Width, device uint* Elements);
>+native void GetDimensions(Texture1DArray<int>, thread uint* Width, device uint* Elements);
>+native void GetDimensions(Texture1DArray<int>, thread uint* Width, device uint* Elements);
>+native void GetDimensions(Texture1DArray<int>, thread uint* Width, threadgroup uint* Elements);
>+native void GetDimensions(Texture1DArray<int>, thread uint* Width, threadgroup uint* Elements);
>+native void GetDimensions(Texture1DArray<int>, thread uint* Width, threadgroup uint* Elements);
>+native void GetDimensions(Texture1DArray<int>, device uint* Width, thread uint* Elements);
>+native void GetDimensions(Texture1DArray<int>, device uint* Width, thread uint* Elements);
>+native void GetDimensions(Texture1DArray<int>, device uint* Width, thread uint* Elements);
>+native void GetDimensions(Texture1DArray<int>, device uint* Width, device uint* Elements);
>+native void GetDimensions(Texture1DArray<int>, device uint* Width, device uint* Elements);
>+native void GetDimensions(Texture1DArray<int>, device uint* Width, device uint* Elements);
>+native void GetDimensions(Texture1DArray<int>, device uint* Width, threadgroup uint* Elements);
>+native void GetDimensions(Texture1DArray<int>, device uint* Width, threadgroup uint* Elements);
>+native void GetDimensions(Texture1DArray<int>, device uint* Width, threadgroup uint* Elements);
>+native void GetDimensions(Texture1DArray<int>, threadgroup uint* Width, thread uint* Elements);
>+native void GetDimensions(Texture1DArray<int>, threadgroup uint* Width, thread uint* Elements);
>+native void GetDimensions(Texture1DArray<int>, threadgroup uint* Width, thread uint* Elements);
>+native void GetDimensions(Texture1DArray<int>, threadgroup uint* Width, device uint* Elements);
>+native void GetDimensions(Texture1DArray<int>, threadgroup uint* Width, device uint* Elements);
>+native void GetDimensions(Texture1DArray<int>, threadgroup uint* Width, device uint* Elements);
>+native void GetDimensions(Texture1DArray<int>, threadgroup uint* Width, threadgroup uint* Elements);
>+native void GetDimensions(Texture1DArray<int>, threadgroup uint* Width, threadgroup uint* Elements);
>+native void GetDimensions(Texture1DArray<int>, threadgroup uint* Width, threadgroup uint* Elements);
>+
>+native void GetDimensions(Texture2D<int>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<int>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<int>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<int>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<int>, uint MipLevel, thread uint* Width, device uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<int>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<int>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<int>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<int>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<int>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<int>, uint MipLevel, device uint* Width, thread uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<int>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<int>, uint MipLevel, device uint* Width, device uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<int>, uint MipLevel, device uint* Width, device uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<int>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<int>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<int>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<int>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<int>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<int>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<int>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<int>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<int>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<int>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<int>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<int>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<int>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels);
>+
>+native void GetDimensions(Texture2DArray<int>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int>, uint MipLevel, device uint* Width, device uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int>, uint MipLevel, device uint* Width, device uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int>, uint MipLevel, device uint* Width, device uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+
>+native void GetDimensions(Texture3D<int>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int>, uint MipLevel, device uint* Width, device uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int>, uint MipLevel, device uint* Width, device uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int>, uint MipLevel, device uint* Width, device uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+
>+native void GetDimensions(TextureCube<int>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<int>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<int>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<int>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<int>, uint MipLevel, thread uint* Width, device uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<int>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<int>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<int>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<int>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<int>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<int>, uint MipLevel, device uint* Width, thread uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<int>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<int>, uint MipLevel, device uint* Width, device uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<int>, uint MipLevel, device uint* Width, device uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<int>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<int>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<int>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<int>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<int>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<int>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<int>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<int>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<int>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<int>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<int>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<int>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<int>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels);
>+
>+
>+
>+
>+
>+
>+native void GetDimensions(Texture1D<int2>, thread uint* Width);
>+native void GetDimensions(Texture1D<int2>, thread uint* Width);
>+native void GetDimensions(Texture1D<int2>, thread uint* Width);
>+native void GetDimensions(Texture1D<int2>, device uint* Width);
>+native void GetDimensions(Texture1D<int2>, device uint* Width);
>+native void GetDimensions(Texture1D<int2>, device uint* Width);
>+native void GetDimensions(Texture1D<int2>, threadgroup uint* Width);
>+native void GetDimensions(Texture1D<int2>, threadgroup uint* Width);
>+native void GetDimensions(Texture1D<int2>, threadgroup uint* Width);
>+
>+native void GetDimensions(Texture1DArray<int2>, thread uint* Width, thread uint* Elements);
>+native void GetDimensions(Texture1DArray<int2>, thread uint* Width, thread uint* Elements);
>+native void GetDimensions(Texture1DArray<int2>, thread uint* Width, thread uint* Elements);
>+native void GetDimensions(Texture1DArray<int2>, thread uint* Width, device uint* Elements);
>+native void GetDimensions(Texture1DArray<int2>, thread uint* Width, device uint* Elements);
>+native void GetDimensions(Texture1DArray<int2>, thread uint* Width, device uint* Elements);
>+native void GetDimensions(Texture1DArray<int2>, thread uint* Width, threadgroup uint* Elements);
>+native void GetDimensions(Texture1DArray<int2>, thread uint* Width, threadgroup uint* Elements);
>+native void GetDimensions(Texture1DArray<int2>, thread uint* Width, threadgroup uint* Elements);
>+native void GetDimensions(Texture1DArray<int2>, device uint* Width, thread uint* Elements);
>+native void GetDimensions(Texture1DArray<int2>, device uint* Width, thread uint* Elements);
>+native void GetDimensions(Texture1DArray<int2>, device uint* Width, thread uint* Elements);
>+native void GetDimensions(Texture1DArray<int2>, device uint* Width, device uint* Elements);
>+native void GetDimensions(Texture1DArray<int2>, device uint* Width, device uint* Elements);
>+native void GetDimensions(Texture1DArray<int2>, device uint* Width, device uint* Elements);
>+native void GetDimensions(Texture1DArray<int2>, device uint* Width, threadgroup uint* Elements);
>+native void GetDimensions(Texture1DArray<int2>, device uint* Width, threadgroup uint* Elements);
>+native void GetDimensions(Texture1DArray<int2>, device uint* Width, threadgroup uint* Elements);
>+native void GetDimensions(Texture1DArray<int2>, threadgroup uint* Width, thread uint* Elements);
>+native void GetDimensions(Texture1DArray<int2>, threadgroup uint* Width, thread uint* Elements);
>+native void GetDimensions(Texture1DArray<int2>, threadgroup uint* Width, thread uint* Elements);
>+native void GetDimensions(Texture1DArray<int2>, threadgroup uint* Width, device uint* Elements);
>+native void GetDimensions(Texture1DArray<int2>, threadgroup uint* Width, device uint* Elements);
>+native void GetDimensions(Texture1DArray<int2>, threadgroup uint* Width, device uint* Elements);
>+native void GetDimensions(Texture1DArray<int2>, threadgroup uint* Width, threadgroup uint* Elements);
>+native void GetDimensions(Texture1DArray<int2>, threadgroup uint* Width, threadgroup uint* Elements);
>+native void GetDimensions(Texture1DArray<int2>, threadgroup uint* Width, threadgroup uint* Elements);
>+
>+native void GetDimensions(Texture2D<int2>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<int2>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<int2>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<int2>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<int2>, uint MipLevel, thread uint* Width, device uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<int2>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<int2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<int2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<int2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<int2>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<int2>, uint MipLevel, device uint* Width, thread uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<int2>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<int2>, uint MipLevel, device uint* Width, device uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<int2>, uint MipLevel, device uint* Width, device uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<int2>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<int2>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<int2>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<int2>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<int2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<int2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<int2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<int2>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<int2>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<int2>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<int2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<int2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<int2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels);
>+
>+native void GetDimensions(Texture2DArray<int2>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int2>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int2>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int2>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int2>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int2>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int2>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int2>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int2>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int2>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int2>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int2>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int2>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int2>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int2>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int2>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int2>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int2>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int2>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int2>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int2>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int2>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int2>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int2>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int2>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int2>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int2>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int2>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int2>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int2>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int2>, uint MipLevel, device uint* Width, device uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int2>, uint MipLevel, device uint* Width, device uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int2>, uint MipLevel, device uint* Width, device uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int2>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int2>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int2>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int2>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int2>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int2>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int2>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int2>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int2>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int2>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int2>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int2>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int2>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int2>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int2>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int2>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int2>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int2>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int2>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int2>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int2>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+
>+native void GetDimensions(Texture3D<int2>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int2>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int2>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int2>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int2>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int2>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int2>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int2>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int2>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int2>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int2>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int2>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int2>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int2>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int2>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int2>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int2>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int2>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int2>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int2>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int2>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int2>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int2>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int2>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int2>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int2>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int2>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int2>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int2>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int2>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int2>, uint MipLevel, device uint* Width, device uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int2>, uint MipLevel, device uint* Width, device uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int2>, uint MipLevel, device uint* Width, device uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int2>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int2>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int2>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int2>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int2>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int2>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int2>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int2>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int2>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int2>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int2>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int2>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int2>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int2>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int2>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int2>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int2>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int2>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int2>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int2>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int2>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+
>+native void GetDimensions(TextureCube<int2>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<int2>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<int2>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<int2>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<int2>, uint MipLevel, thread uint* Width, device uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<int2>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<int2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<int2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<int2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<int2>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<int2>, uint MipLevel, device uint* Width, thread uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<int2>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<int2>, uint MipLevel, device uint* Width, device uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<int2>, uint MipLevel, device uint* Width, device uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<int2>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<int2>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<int2>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<int2>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<int2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<int2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<int2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<int2>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<int2>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<int2>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<int2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<int2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<int2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels);
>+
>+
>+
>+
>+
>+
>+native void GetDimensions(Texture1D<int3>, thread uint* Width);
>+native void GetDimensions(Texture1D<int3>, thread uint* Width);
>+native void GetDimensions(Texture1D<int3>, thread uint* Width);
>+native void GetDimensions(Texture1D<int3>, device uint* Width);
>+native void GetDimensions(Texture1D<int3>, device uint* Width);
>+native void GetDimensions(Texture1D<int3>, device uint* Width);
>+native void GetDimensions(Texture1D<int3>, threadgroup uint* Width);
>+native void GetDimensions(Texture1D<int3>, threadgroup uint* Width);
>+native void GetDimensions(Texture1D<int3>, threadgroup uint* Width);
>+
>+native void GetDimensions(Texture1DArray<int3>, thread uint* Width, thread uint* Elements);
>+native void GetDimensions(Texture1DArray<int3>, thread uint* Width, thread uint* Elements);
>+native void GetDimensions(Texture1DArray<int3>, thread uint* Width, thread uint* Elements);
>+native void GetDimensions(Texture1DArray<int3>, thread uint* Width, device uint* Elements);
>+native void GetDimensions(Texture1DArray<int3>, thread uint* Width, device uint* Elements);
>+native void GetDimensions(Texture1DArray<int3>, thread uint* Width, device uint* Elements);
>+native void GetDimensions(Texture1DArray<int3>, thread uint* Width, threadgroup uint* Elements);
>+native void GetDimensions(Texture1DArray<int3>, thread uint* Width, threadgroup uint* Elements);
>+native void GetDimensions(Texture1DArray<int3>, thread uint* Width, threadgroup uint* Elements);
>+native void GetDimensions(Texture1DArray<int3>, device uint* Width, thread uint* Elements);
>+native void GetDimensions(Texture1DArray<int3>, device uint* Width, thread uint* Elements);
>+native void GetDimensions(Texture1DArray<int3>, device uint* Width, thread uint* Elements);
>+native void GetDimensions(Texture1DArray<int3>, device uint* Width, device uint* Elements);
>+native void GetDimensions(Texture1DArray<int3>, device uint* Width, device uint* Elements);
>+native void GetDimensions(Texture1DArray<int3>, device uint* Width, device uint* Elements);
>+native void GetDimensions(Texture1DArray<int3>, device uint* Width, threadgroup uint* Elements);
>+native void GetDimensions(Texture1DArray<int3>, device uint* Width, threadgroup uint* Elements);
>+native void GetDimensions(Texture1DArray<int3>, device uint* Width, threadgroup uint* Elements);
>+native void GetDimensions(Texture1DArray<int3>, threadgroup uint* Width, thread uint* Elements);
>+native void GetDimensions(Texture1DArray<int3>, threadgroup uint* Width, thread uint* Elements);
>+native void GetDimensions(Texture1DArray<int3>, threadgroup uint* Width, thread uint* Elements);
>+native void GetDimensions(Texture1DArray<int3>, threadgroup uint* Width, device uint* Elements);
>+native void GetDimensions(Texture1DArray<int3>, threadgroup uint* Width, device uint* Elements);
>+native void GetDimensions(Texture1DArray<int3>, threadgroup uint* Width, device uint* Elements);
>+native void GetDimensions(Texture1DArray<int3>, threadgroup uint* Width, threadgroup uint* Elements);
>+native void GetDimensions(Texture1DArray<int3>, threadgroup uint* Width, threadgroup uint* Elements);
>+native void GetDimensions(Texture1DArray<int3>, threadgroup uint* Width, threadgroup uint* Elements);
>+
>+native void GetDimensions(Texture2D<int3>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<int3>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<int3>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<int3>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<int3>, uint MipLevel, thread uint* Width, device uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<int3>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<int3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<int3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<int3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<int3>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<int3>, uint MipLevel, device uint* Width, thread uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<int3>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<int3>, uint MipLevel, device uint* Width, device uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<int3>, uint MipLevel, device uint* Width, device uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<int3>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<int3>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<int3>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<int3>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<int3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<int3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<int3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<int3>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<int3>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<int3>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<int3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<int3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<int3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels);
>+
>+native void GetDimensions(Texture2DArray<int3>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int3>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int3>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int3>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int3>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int3>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int3>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int3>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int3>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int3>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int3>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int3>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int3>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int3>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int3>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int3>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int3>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int3>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int3>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int3>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int3>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int3>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int3>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int3>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int3>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int3>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int3>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int3>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int3>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int3>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int3>, uint MipLevel, device uint* Width, device uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int3>, uint MipLevel, device uint* Width, device uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int3>, uint MipLevel, device uint* Width, device uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int3>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int3>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int3>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int3>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int3>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int3>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int3>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int3>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int3>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int3>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int3>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int3>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int3>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int3>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int3>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int3>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int3>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int3>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int3>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int3>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int3>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+
>+native void GetDimensions(Texture3D<int3>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int3>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int3>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int3>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int3>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int3>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int3>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int3>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int3>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int3>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int3>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int3>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int3>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int3>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int3>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int3>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int3>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int3>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int3>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int3>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int3>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int3>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int3>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int3>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int3>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int3>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int3>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int3>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int3>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int3>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int3>, uint MipLevel, device uint* Width, device uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int3>, uint MipLevel, device uint* Width, device uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int3>, uint MipLevel, device uint* Width, device uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int3>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int3>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int3>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int3>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int3>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int3>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int3>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int3>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int3>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int3>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int3>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int3>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int3>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int3>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int3>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int3>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int3>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int3>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int3>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int3>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int3>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+
>+native void GetDimensions(TextureCube<int3>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<int3>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<int3>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<int3>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<int3>, uint MipLevel, thread uint* Width, device uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<int3>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<int3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<int3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<int3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<int3>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<int3>, uint MipLevel, device uint* Width, thread uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<int3>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<int3>, uint MipLevel, device uint* Width, device uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<int3>, uint MipLevel, device uint* Width, device uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<int3>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<int3>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<int3>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<int3>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<int3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<int3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<int3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<int3>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<int3>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<int3>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<int3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<int3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<int3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels);
>+
>+
>+
>+
>+
>+
>+native void GetDimensions(Texture1D<int4>, thread uint* Width);
>+native void GetDimensions(Texture1D<int4>, thread uint* Width);
>+native void GetDimensions(Texture1D<int4>, thread uint* Width);
>+native void GetDimensions(Texture1D<int4>, device uint* Width);
>+native void GetDimensions(Texture1D<int4>, device uint* Width);
>+native void GetDimensions(Texture1D<int4>, device uint* Width);
>+native void GetDimensions(Texture1D<int4>, threadgroup uint* Width);
>+native void GetDimensions(Texture1D<int4>, threadgroup uint* Width);
>+native void GetDimensions(Texture1D<int4>, threadgroup uint* Width);
>+
>+native void GetDimensions(Texture1DArray<int4>, thread uint* Width, thread uint* Elements);
>+native void GetDimensions(Texture1DArray<int4>, thread uint* Width, thread uint* Elements);
>+native void GetDimensions(Texture1DArray<int4>, thread uint* Width, thread uint* Elements);
>+native void GetDimensions(Texture1DArray<int4>, thread uint* Width, device uint* Elements);
>+native void GetDimensions(Texture1DArray<int4>, thread uint* Width, device uint* Elements);
>+native void GetDimensions(Texture1DArray<int4>, thread uint* Width, device uint* Elements);
>+native void GetDimensions(Texture1DArray<int4>, thread uint* Width, threadgroup uint* Elements);
>+native void GetDimensions(Texture1DArray<int4>, thread uint* Width, threadgroup uint* Elements);
>+native void GetDimensions(Texture1DArray<int4>, thread uint* Width, threadgroup uint* Elements);
>+native void GetDimensions(Texture1DArray<int4>, device uint* Width, thread uint* Elements);
>+native void GetDimensions(Texture1DArray<int4>, device uint* Width, thread uint* Elements);
>+native void GetDimensions(Texture1DArray<int4>, device uint* Width, thread uint* Elements);
>+native void GetDimensions(Texture1DArray<int4>, device uint* Width, device uint* Elements);
>+native void GetDimensions(Texture1DArray<int4>, device uint* Width, device uint* Elements);
>+native void GetDimensions(Texture1DArray<int4>, device uint* Width, device uint* Elements);
>+native void GetDimensions(Texture1DArray<int4>, device uint* Width, threadgroup uint* Elements);
>+native void GetDimensions(Texture1DArray<int4>, device uint* Width, threadgroup uint* Elements);
>+native void GetDimensions(Texture1DArray<int4>, device uint* Width, threadgroup uint* Elements);
>+native void GetDimensions(Texture1DArray<int4>, threadgroup uint* Width, thread uint* Elements);
>+native void GetDimensions(Texture1DArray<int4>, threadgroup uint* Width, thread uint* Elements);
>+native void GetDimensions(Texture1DArray<int4>, threadgroup uint* Width, thread uint* Elements);
>+native void GetDimensions(Texture1DArray<int4>, threadgroup uint* Width, device uint* Elements);
>+native void GetDimensions(Texture1DArray<int4>, threadgroup uint* Width, device uint* Elements);
>+native void GetDimensions(Texture1DArray<int4>, threadgroup uint* Width, device uint* Elements);
>+native void GetDimensions(Texture1DArray<int4>, threadgroup uint* Width, threadgroup uint* Elements);
>+native void GetDimensions(Texture1DArray<int4>, threadgroup uint* Width, threadgroup uint* Elements);
>+native void GetDimensions(Texture1DArray<int4>, threadgroup uint* Width, threadgroup uint* Elements);
>+
>+native void GetDimensions(Texture2D<int4>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<int4>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<int4>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<int4>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<int4>, uint MipLevel, thread uint* Width, device uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<int4>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<int4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<int4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<int4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<int4>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<int4>, uint MipLevel, device uint* Width, thread uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<int4>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<int4>, uint MipLevel, device uint* Width, device uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<int4>, uint MipLevel, device uint* Width, device uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<int4>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<int4>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<int4>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<int4>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<int4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<int4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<int4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<int4>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<int4>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<int4>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<int4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<int4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<int4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels);
>+
>+native void GetDimensions(Texture2DArray<int4>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int4>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int4>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int4>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int4>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int4>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int4>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int4>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int4>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int4>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int4>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int4>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int4>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int4>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int4>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int4>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int4>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int4>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int4>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int4>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int4>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int4>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int4>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int4>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int4>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int4>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int4>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int4>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int4>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int4>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int4>, uint MipLevel, device uint* Width, device uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int4>, uint MipLevel, device uint* Width, device uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int4>, uint MipLevel, device uint* Width, device uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int4>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int4>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int4>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int4>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int4>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int4>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int4>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int4>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int4>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int4>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int4>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int4>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int4>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int4>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int4>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int4>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int4>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int4>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int4>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int4>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int4>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+
>+native void GetDimensions(Texture3D<int4>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int4>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int4>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int4>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int4>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int4>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int4>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int4>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int4>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int4>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int4>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int4>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int4>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int4>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int4>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int4>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int4>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int4>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int4>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int4>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int4>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int4>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int4>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int4>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int4>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int4>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int4>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int4>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int4>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int4>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int4>, uint MipLevel, device uint* Width, device uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int4>, uint MipLevel, device uint* Width, device uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int4>, uint MipLevel, device uint* Width, device uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int4>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int4>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int4>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int4>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int4>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int4>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int4>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int4>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int4>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int4>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int4>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int4>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int4>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int4>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int4>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int4>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int4>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int4>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int4>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int4>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int4>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+
>+native void GetDimensions(TextureCube<int4>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<int4>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<int4>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<int4>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<int4>, uint MipLevel, thread uint* Width, device uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<int4>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<int4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<int4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<int4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<int4>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<int4>, uint MipLevel, device uint* Width, thread uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<int4>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<int4>, uint MipLevel, device uint* Width, device uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<int4>, uint MipLevel, device uint* Width, device uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<int4>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<int4>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<int4>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<int4>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<int4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<int4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<int4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<int4>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<int4>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<int4>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<int4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<int4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<int4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels);
>+
>+
>+
>+
>+
>+
>+native void GetDimensions(Texture1D<half>, thread uint* Width);
>+native void GetDimensions(Texture1D<half>, thread uint* Width);
>+native void GetDimensions(Texture1D<half>, thread uint* Width);
>+native void GetDimensions(Texture1D<half>, device uint* Width);
>+native void GetDimensions(Texture1D<half>, device uint* Width);
>+native void GetDimensions(Texture1D<half>, device uint* Width);
>+native void GetDimensions(Texture1D<half>, threadgroup uint* Width);
>+native void GetDimensions(Texture1D<half>, threadgroup uint* Width);
>+native void GetDimensions(Texture1D<half>, threadgroup uint* Width);
>+
>+native void GetDimensions(Texture1DArray<half>, thread uint* Width, thread uint* Elements);
>+native void GetDimensions(Texture1DArray<half>, thread uint* Width, thread uint* Elements);
>+native void GetDimensions(Texture1DArray<half>, thread uint* Width, thread uint* Elements);
>+native void GetDimensions(Texture1DArray<half>, thread uint* Width, device uint* Elements);
>+native void GetDimensions(Texture1DArray<half>, thread uint* Width, device uint* Elements);
>+native void GetDimensions(Texture1DArray<half>, thread uint* Width, device uint* Elements);
>+native void GetDimensions(Texture1DArray<half>, thread uint* Width, threadgroup uint* Elements);
>+native void GetDimensions(Texture1DArray<half>, thread uint* Width, threadgroup uint* Elements);
>+native void GetDimensions(Texture1DArray<half>, thread uint* Width, threadgroup uint* Elements);
>+native void GetDimensions(Texture1DArray<half>, device uint* Width, thread uint* Elements);
>+native void GetDimensions(Texture1DArray<half>, device uint* Width, thread uint* Elements);
>+native void GetDimensions(Texture1DArray<half>, device uint* Width, thread uint* Elements);
>+native void GetDimensions(Texture1DArray<half>, device uint* Width, device uint* Elements);
>+native void GetDimensions(Texture1DArray<half>, device uint* Width, device uint* Elements);
>+native void GetDimensions(Texture1DArray<half>, device uint* Width, device uint* Elements);
>+native void GetDimensions(Texture1DArray<half>, device uint* Width, threadgroup uint* Elements);
>+native void GetDimensions(Texture1DArray<half>, device uint* Width, threadgroup uint* Elements);
>+native void GetDimensions(Texture1DArray<half>, device uint* Width, threadgroup uint* Elements);
>+native void GetDimensions(Texture1DArray<half>, threadgroup uint* Width, thread uint* Elements);
>+native void GetDimensions(Texture1DArray<half>, threadgroup uint* Width, thread uint* Elements);
>+native void GetDimensions(Texture1DArray<half>, threadgroup uint* Width, thread uint* Elements);
>+native void GetDimensions(Texture1DArray<half>, threadgroup uint* Width, device uint* Elements);
>+native void GetDimensions(Texture1DArray<half>, threadgroup uint* Width, device uint* Elements);
>+native void GetDimensions(Texture1DArray<half>, threadgroup uint* Width, device uint* Elements);
>+native void GetDimensions(Texture1DArray<half>, threadgroup uint* Width, threadgroup uint* Elements);
>+native void GetDimensions(Texture1DArray<half>, threadgroup uint* Width, threadgroup uint* Elements);
>+native void GetDimensions(Texture1DArray<half>, threadgroup uint* Width, threadgroup uint* Elements);
>+
>+native void GetDimensions(Texture2D<half>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<half>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<half>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<half>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<half>, uint MipLevel, thread uint* Width, device uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<half>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<half>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<half>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<half>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<half>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<half>, uint MipLevel, device uint* Width, thread uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<half>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<half>, uint MipLevel, device uint* Width, device uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<half>, uint MipLevel, device uint* Width, device uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<half>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<half>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<half>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<half>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<half>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<half>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<half>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<half>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<half>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<half>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<half>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<half>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<half>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels);
>+
>+native void GetDimensions(Texture2DArray<half>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half>, uint MipLevel, device uint* Width, device uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half>, uint MipLevel, device uint* Width, device uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half>, uint MipLevel, device uint* Width, device uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+
>+native void GetDimensions(Texture3D<half>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half>, uint MipLevel, device uint* Width, device uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half>, uint MipLevel, device uint* Width, device uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half>, uint MipLevel, device uint* Width, device uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+
>+native void GetDimensions(TextureCube<half>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<half>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<half>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<half>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<half>, uint MipLevel, thread uint* Width, device uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<half>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<half>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<half>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<half>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<half>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<half>, uint MipLevel, device uint* Width, thread uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<half>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<half>, uint MipLevel, device uint* Width, device uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<half>, uint MipLevel, device uint* Width, device uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<half>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<half>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<half>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<half>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<half>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<half>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<half>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<half>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<half>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<half>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<half>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<half>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<half>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels);
>+
>+
>+
>+
>+
>+
>+native void GetDimensions(Texture1D<half2>, thread uint* Width);
>+native void GetDimensions(Texture1D<half2>, thread uint* Width);
>+native void GetDimensions(Texture1D<half2>, thread uint* Width);
>+native void GetDimensions(Texture1D<half2>, device uint* Width);
>+native void GetDimensions(Texture1D<half2>, device uint* Width);
>+native void GetDimensions(Texture1D<half2>, device uint* Width);
>+native void GetDimensions(Texture1D<half2>, threadgroup uint* Width);
>+native void GetDimensions(Texture1D<half2>, threadgroup uint* Width);
>+native void GetDimensions(Texture1D<half2>, threadgroup uint* Width);
>+
>+native void GetDimensions(Texture1DArray<half2>, thread uint* Width, thread uint* Elements);
>+native void GetDimensions(Texture1DArray<half2>, thread uint* Width, thread uint* Elements);
>+native void GetDimensions(Texture1DArray<half2>, thread uint* Width, thread uint* Elements);
>+native void GetDimensions(Texture1DArray<half2>, thread uint* Width, device uint* Elements);
>+native void GetDimensions(Texture1DArray<half2>, thread uint* Width, device uint* Elements);
>+native void GetDimensions(Texture1DArray<half2>, thread uint* Width, device uint* Elements);
>+native void GetDimensions(Texture1DArray<half2>, thread uint* Width, threadgroup uint* Elements);
>+native void GetDimensions(Texture1DArray<half2>, thread uint* Width, threadgroup uint* Elements);
>+native void GetDimensions(Texture1DArray<half2>, thread uint* Width, threadgroup uint* Elements);
>+native void GetDimensions(Texture1DArray<half2>, device uint* Width, thread uint* Elements);
>+native void GetDimensions(Texture1DArray<half2>, device uint* Width, thread uint* Elements);
>+native void GetDimensions(Texture1DArray<half2>, device uint* Width, thread uint* Elements);
>+native void GetDimensions(Texture1DArray<half2>, device uint* Width, device uint* Elements);
>+native void GetDimensions(Texture1DArray<half2>, device uint* Width, device uint* Elements);
>+native void GetDimensions(Texture1DArray<half2>, device uint* Width, device uint* Elements);
>+native void GetDimensions(Texture1DArray<half2>, device uint* Width, threadgroup uint* Elements);
>+native void GetDimensions(Texture1DArray<half2>, device uint* Width, threadgroup uint* Elements);
>+native void GetDimensions(Texture1DArray<half2>, device uint* Width, threadgroup uint* Elements);
>+native void GetDimensions(Texture1DArray<half2>, threadgroup uint* Width, thread uint* Elements);
>+native void GetDimensions(Texture1DArray<half2>, threadgroup uint* Width, thread uint* Elements);
>+native void GetDimensions(Texture1DArray<half2>, threadgroup uint* Width, thread uint* Elements);
>+native void GetDimensions(Texture1DArray<half2>, threadgroup uint* Width, device uint* Elements);
>+native void GetDimensions(Texture1DArray<half2>, threadgroup uint* Width, device uint* Elements);
>+native void GetDimensions(Texture1DArray<half2>, threadgroup uint* Width, device uint* Elements);
>+native void GetDimensions(Texture1DArray<half2>, threadgroup uint* Width, threadgroup uint* Elements);
>+native void GetDimensions(Texture1DArray<half2>, threadgroup uint* Width, threadgroup uint* Elements);
>+native void GetDimensions(Texture1DArray<half2>, threadgroup uint* Width, threadgroup uint* Elements);
>+
>+native void GetDimensions(Texture2D<half2>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<half2>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<half2>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<half2>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<half2>, uint MipLevel, thread uint* Width, device uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<half2>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<half2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<half2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<half2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<half2>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<half2>, uint MipLevel, device uint* Width, thread uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<half2>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<half2>, uint MipLevel, device uint* Width, device uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<half2>, uint MipLevel, device uint* Width, device uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<half2>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<half2>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<half2>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<half2>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<half2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<half2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<half2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<half2>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<half2>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<half2>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<half2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<half2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<half2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels);
>+
>+native void GetDimensions(Texture2DArray<half2>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half2>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half2>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half2>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half2>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half2>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half2>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half2>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half2>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half2>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half2>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half2>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half2>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half2>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half2>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half2>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half2>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half2>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half2>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half2>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half2>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half2>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half2>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half2>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half2>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half2>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half2>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half2>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half2>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half2>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half2>, uint MipLevel, device uint* Width, device uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half2>, uint MipLevel, device uint* Width, device uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half2>, uint MipLevel, device uint* Width, device uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half2>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half2>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half2>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half2>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half2>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half2>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half2>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half2>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half2>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half2>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half2>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half2>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half2>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half2>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half2>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half2>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half2>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half2>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half2>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half2>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half2>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+
>+native void GetDimensions(Texture3D<half2>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half2>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half2>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half2>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half2>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half2>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half2>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half2>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half2>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half2>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half2>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half2>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half2>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half2>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half2>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half2>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half2>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half2>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half2>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half2>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half2>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half2>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half2>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half2>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half2>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half2>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half2>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half2>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half2>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half2>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half2>, uint MipLevel, device uint* Width, device uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half2>, uint MipLevel, device uint* Width, device uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half2>, uint MipLevel, device uint* Width, device uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half2>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half2>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half2>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half2>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half2>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half2>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half2>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half2>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half2>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half2>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half2>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half2>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half2>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half2>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half2>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half2>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half2>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half2>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half2>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half2>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half2>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+
>+native void GetDimensions(TextureCube<half2>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<half2>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<half2>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<half2>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<half2>, uint MipLevel, thread uint* Width, device uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<half2>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<half2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<half2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<half2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<half2>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<half2>, uint MipLevel, device uint* Width, thread uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<half2>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<half2>, uint MipLevel, device uint* Width, device uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<half2>, uint MipLevel, device uint* Width, device uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<half2>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<half2>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<half2>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<half2>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<half2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<half2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<half2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<half2>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<half2>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<half2>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<half2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<half2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<half2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels);
>+
>+
>+
>+
>+
>+
>+native void GetDimensions(Texture1D<half3>, thread uint* Width);
>+native void GetDimensions(Texture1D<half3>, thread uint* Width);
>+native void GetDimensions(Texture1D<half3>, thread uint* Width);
>+native void GetDimensions(Texture1D<half3>, device uint* Width);
>+native void GetDimensions(Texture1D<half3>, device uint* Width);
>+native void GetDimensions(Texture1D<half3>, device uint* Width);
>+native void GetDimensions(Texture1D<half3>, threadgroup uint* Width);
>+native void GetDimensions(Texture1D<half3>, threadgroup uint* Width);
>+native void GetDimensions(Texture1D<half3>, threadgroup uint* Width);
>+
>+native void GetDimensions(Texture1DArray<half3>, thread uint* Width, thread uint* Elements);
>+native void GetDimensions(Texture1DArray<half3>, thread uint* Width, thread uint* Elements);
>+native void GetDimensions(Texture1DArray<half3>, thread uint* Width, thread uint* Elements);
>+native void GetDimensions(Texture1DArray<half3>, thread uint* Width, device uint* Elements);
>+native void GetDimensions(Texture1DArray<half3>, thread uint* Width, device uint* Elements);
>+native void GetDimensions(Texture1DArray<half3>, thread uint* Width, device uint* Elements);
>+native void GetDimensions(Texture1DArray<half3>, thread uint* Width, threadgroup uint* Elements);
>+native void GetDimensions(Texture1DArray<half3>, thread uint* Width, threadgroup uint* Elements);
>+native void GetDimensions(Texture1DArray<half3>, thread uint* Width, threadgroup uint* Elements);
>+native void GetDimensions(Texture1DArray<half3>, device uint* Width, thread uint* Elements);
>+native void GetDimensions(Texture1DArray<half3>, device uint* Width, thread uint* Elements);
>+native void GetDimensions(Texture1DArray<half3>, device uint* Width, thread uint* Elements);
>+native void GetDimensions(Texture1DArray<half3>, device uint* Width, device uint* Elements);
>+native void GetDimensions(Texture1DArray<half3>, device uint* Width, device uint* Elements);
>+native void GetDimensions(Texture1DArray<half3>, device uint* Width, device uint* Elements);
>+native void GetDimensions(Texture1DArray<half3>, device uint* Width, threadgroup uint* Elements);
>+native void GetDimensions(Texture1DArray<half3>, device uint* Width, threadgroup uint* Elements);
>+native void GetDimensions(Texture1DArray<half3>, device uint* Width, threadgroup uint* Elements);
>+native void GetDimensions(Texture1DArray<half3>, threadgroup uint* Width, thread uint* Elements);
>+native void GetDimensions(Texture1DArray<half3>, threadgroup uint* Width, thread uint* Elements);
>+native void GetDimensions(Texture1DArray<half3>, threadgroup uint* Width, thread uint* Elements);
>+native void GetDimensions(Texture1DArray<half3>, threadgroup uint* Width, device uint* Elements);
>+native void GetDimensions(Texture1DArray<half3>, threadgroup uint* Width, device uint* Elements);
>+native void GetDimensions(Texture1DArray<half3>, threadgroup uint* Width, device uint* Elements);
>+native void GetDimensions(Texture1DArray<half3>, threadgroup uint* Width, threadgroup uint* Elements);
>+native void GetDimensions(Texture1DArray<half3>, threadgroup uint* Width, threadgroup uint* Elements);
>+native void GetDimensions(Texture1DArray<half3>, threadgroup uint* Width, threadgroup uint* Elements);
>+
>+native void GetDimensions(Texture2D<half3>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<half3>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<half3>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<half3>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<half3>, uint MipLevel, thread uint* Width, device uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<half3>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<half3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<half3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<half3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<half3>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<half3>, uint MipLevel, device uint* Width, thread uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<half3>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<half3>, uint MipLevel, device uint* Width, device uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<half3>, uint MipLevel, device uint* Width, device uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<half3>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<half3>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<half3>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<half3>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<half3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<half3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<half3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<half3>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<half3>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<half3>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<half3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<half3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<half3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels);
>+
>+native void GetDimensions(Texture2DArray<half3>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half3>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half3>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half3>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half3>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half3>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half3>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half3>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half3>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half3>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half3>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half3>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half3>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half3>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half3>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half3>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half3>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half3>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half3>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half3>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half3>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half3>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half3>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half3>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half3>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half3>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half3>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half3>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half3>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half3>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half3>, uint MipLevel, device uint* Width, device uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half3>, uint MipLevel, device uint* Width, device uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half3>, uint MipLevel, device uint* Width, device uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half3>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half3>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half3>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half3>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half3>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half3>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half3>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half3>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half3>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half3>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half3>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half3>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half3>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half3>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half3>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half3>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half3>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half3>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half3>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half3>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half3>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+
>+native void GetDimensions(Texture3D<half3>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half3>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half3>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half3>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half3>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half3>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half3>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half3>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half3>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half3>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half3>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half3>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half3>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half3>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half3>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half3>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half3>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half3>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half3>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half3>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half3>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half3>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half3>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half3>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half3>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half3>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half3>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half3>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half3>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half3>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half3>, uint MipLevel, device uint* Width, device uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half3>, uint MipLevel, device uint* Width, device uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half3>, uint MipLevel, device uint* Width, device uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half3>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half3>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half3>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half3>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half3>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half3>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half3>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half3>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half3>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half3>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half3>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half3>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half3>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half3>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half3>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half3>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half3>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half3>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half3>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half3>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half3>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+
>+native void GetDimensions(TextureCube<half3>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<half3>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<half3>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<half3>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<half3>, uint MipLevel, thread uint* Width, device uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<half3>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<half3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<half3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<half3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<half3>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<half3>, uint MipLevel, device uint* Width, thread uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<half3>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<half3>, uint MipLevel, device uint* Width, device uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<half3>, uint MipLevel, device uint* Width, device uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<half3>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<half3>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<half3>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<half3>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<half3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<half3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<half3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<half3>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<half3>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<half3>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<half3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<half3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<half3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels);
>+
>+
>+
>+
>+
>+
>+native void GetDimensions(Texture1D<half4>, thread uint* Width);
>+native void GetDimensions(Texture1D<half4>, thread uint* Width);
>+native void GetDimensions(Texture1D<half4>, thread uint* Width);
>+native void GetDimensions(Texture1D<half4>, device uint* Width);
>+native void GetDimensions(Texture1D<half4>, device uint* Width);
>+native void GetDimensions(Texture1D<half4>, device uint* Width);
>+native void GetDimensions(Texture1D<half4>, threadgroup uint* Width);
>+native void GetDimensions(Texture1D<half4>, threadgroup uint* Width);
>+native void GetDimensions(Texture1D<half4>, threadgroup uint* Width);
>+
>+native void GetDimensions(Texture1DArray<half4>, thread uint* Width, thread uint* Elements);
>+native void GetDimensions(Texture1DArray<half4>, thread uint* Width, thread uint* Elements);
>+native void GetDimensions(Texture1DArray<half4>, thread uint* Width, thread uint* Elements);
>+native void GetDimensions(Texture1DArray<half4>, thread uint* Width, device uint* Elements);
>+native void GetDimensions(Texture1DArray<half4>, thread uint* Width, device uint* Elements);
>+native void GetDimensions(Texture1DArray<half4>, thread uint* Width, device uint* Elements);
>+native void GetDimensions(Texture1DArray<half4>, thread uint* Width, threadgroup uint* Elements);
>+native void GetDimensions(Texture1DArray<half4>, thread uint* Width, threadgroup uint* Elements);
>+native void GetDimensions(Texture1DArray<half4>, thread uint* Width, threadgroup uint* Elements);
>+native void GetDimensions(Texture1DArray<half4>, device uint* Width, thread uint* Elements);
>+native void GetDimensions(Texture1DArray<half4>, device uint* Width, thread uint* Elements);
>+native void GetDimensions(Texture1DArray<half4>, device uint* Width, thread uint* Elements);
>+native void GetDimensions(Texture1DArray<half4>, device uint* Width, device uint* Elements);
>+native void GetDimensions(Texture1DArray<half4>, device uint* Width, device uint* Elements);
>+native void GetDimensions(Texture1DArray<half4>, device uint* Width, device uint* Elements);
>+native void GetDimensions(Texture1DArray<half4>, device uint* Width, threadgroup uint* Elements);
>+native void GetDimensions(Texture1DArray<half4>, device uint* Width, threadgroup uint* Elements);
>+native void GetDimensions(Texture1DArray<half4>, device uint* Width, threadgroup uint* Elements);
>+native void GetDimensions(Texture1DArray<half4>, threadgroup uint* Width, thread uint* Elements);
>+native void GetDimensions(Texture1DArray<half4>, threadgroup uint* Width, thread uint* Elements);
>+native void GetDimensions(Texture1DArray<half4>, threadgroup uint* Width, thread uint* Elements);
>+native void GetDimensions(Texture1DArray<half4>, threadgroup uint* Width, device uint* Elements);
>+native void GetDimensions(Texture1DArray<half4>, threadgroup uint* Width, device uint* Elements);
>+native void GetDimensions(Texture1DArray<half4>, threadgroup uint* Width, device uint* Elements);
>+native void GetDimensions(Texture1DArray<half4>, threadgroup uint* Width, threadgroup uint* Elements);
>+native void GetDimensions(Texture1DArray<half4>, threadgroup uint* Width, threadgroup uint* Elements);
>+native void GetDimensions(Texture1DArray<half4>, threadgroup uint* Width, threadgroup uint* Elements);
>+
>+native void GetDimensions(Texture2D<half4>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<half4>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<half4>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<half4>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<half4>, uint MipLevel, thread uint* Width, device uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<half4>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<half4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<half4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<half4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<half4>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<half4>, uint MipLevel, device uint* Width, thread uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<half4>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<half4>, uint MipLevel, device uint* Width, device uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<half4>, uint MipLevel, device uint* Width, device uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<half4>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<half4>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<half4>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<half4>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<half4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<half4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<half4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<half4>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<half4>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<half4>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<half4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<half4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<half4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels);
>+
>+native void GetDimensions(Texture2DArray<half4>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half4>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half4>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half4>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half4>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half4>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half4>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half4>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half4>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half4>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half4>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half4>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half4>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half4>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half4>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half4>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half4>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half4>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half4>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half4>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half4>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half4>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half4>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half4>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half4>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half4>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half4>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half4>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half4>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half4>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half4>, uint MipLevel, device uint* Width, device uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half4>, uint MipLevel, device uint* Width, device uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half4>, uint MipLevel, device uint* Width, device uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half4>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half4>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half4>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half4>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half4>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half4>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half4>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half4>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half4>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half4>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half4>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half4>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half4>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half4>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half4>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half4>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half4>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half4>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half4>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half4>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half4>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+
>+native void GetDimensions(Texture3D<half4>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half4>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half4>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half4>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half4>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half4>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half4>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half4>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half4>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half4>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half4>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half4>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half4>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half4>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half4>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half4>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half4>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half4>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half4>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half4>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half4>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half4>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half4>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half4>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half4>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half4>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half4>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half4>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half4>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half4>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half4>, uint MipLevel, device uint* Width, device uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half4>, uint MipLevel, device uint* Width, device uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half4>, uint MipLevel, device uint* Width, device uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half4>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half4>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half4>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half4>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half4>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half4>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half4>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half4>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half4>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half4>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half4>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half4>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half4>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half4>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half4>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half4>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half4>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half4>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half4>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half4>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half4>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+
>+native void GetDimensions(TextureCube<half4>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<half4>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<half4>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<half4>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<half4>, uint MipLevel, thread uint* Width, device uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<half4>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<half4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<half4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<half4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<half4>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<half4>, uint MipLevel, device uint* Width, thread uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<half4>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<half4>, uint MipLevel, device uint* Width, device uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<half4>, uint MipLevel, device uint* Width, device uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<half4>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<half4>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<half4>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<half4>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<half4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<half4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<half4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<half4>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<half4>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<half4>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<half4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<half4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<half4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels);
>+
>+
>+
>+
>+
>+
>+native void GetDimensions(Texture1D<float>, thread uint* Width);
>+native void GetDimensions(Texture1D<float>, thread uint* Width);
>+native void GetDimensions(Texture1D<float>, thread uint* Width);
>+native void GetDimensions(Texture1D<float>, device uint* Width);
>+native void GetDimensions(Texture1D<float>, device uint* Width);
>+native void GetDimensions(Texture1D<float>, device uint* Width);
>+native void GetDimensions(Texture1D<float>, threadgroup uint* Width);
>+native void GetDimensions(Texture1D<float>, threadgroup uint* Width);
>+native void GetDimensions(Texture1D<float>, threadgroup uint* Width);
>+
>+native void GetDimensions(Texture1DArray<float>, thread uint* Width, thread uint* Elements);
>+native void GetDimensions(Texture1DArray<float>, thread uint* Width, thread uint* Elements);
>+native void GetDimensions(Texture1DArray<float>, thread uint* Width, thread uint* Elements);
>+native void GetDimensions(Texture1DArray<float>, thread uint* Width, device uint* Elements);
>+native void GetDimensions(Texture1DArray<float>, thread uint* Width, device uint* Elements);
>+native void GetDimensions(Texture1DArray<float>, thread uint* Width, device uint* Elements);
>+native void GetDimensions(Texture1DArray<float>, thread uint* Width, threadgroup uint* Elements);
>+native void GetDimensions(Texture1DArray<float>, thread uint* Width, threadgroup uint* Elements);
>+native void GetDimensions(Texture1DArray<float>, thread uint* Width, threadgroup uint* Elements);
>+native void GetDimensions(Texture1DArray<float>, device uint* Width, thread uint* Elements);
>+native void GetDimensions(Texture1DArray<float>, device uint* Width, thread uint* Elements);
>+native void GetDimensions(Texture1DArray<float>, device uint* Width, thread uint* Elements);
>+native void GetDimensions(Texture1DArray<float>, device uint* Width, device uint* Elements);
>+native void GetDimensions(Texture1DArray<float>, device uint* Width, device uint* Elements);
>+native void GetDimensions(Texture1DArray<float>, device uint* Width, device uint* Elements);
>+native void GetDimensions(Texture1DArray<float>, device uint* Width, threadgroup uint* Elements);
>+native void GetDimensions(Texture1DArray<float>, device uint* Width, threadgroup uint* Elements);
>+native void GetDimensions(Texture1DArray<float>, device uint* Width, threadgroup uint* Elements);
>+native void GetDimensions(Texture1DArray<float>, threadgroup uint* Width, thread uint* Elements);
>+native void GetDimensions(Texture1DArray<float>, threadgroup uint* Width, thread uint* Elements);
>+native void GetDimensions(Texture1DArray<float>, threadgroup uint* Width, thread uint* Elements);
>+native void GetDimensions(Texture1DArray<float>, threadgroup uint* Width, device uint* Elements);
>+native void GetDimensions(Texture1DArray<float>, threadgroup uint* Width, device uint* Elements);
>+native void GetDimensions(Texture1DArray<float>, threadgroup uint* Width, device uint* Elements);
>+native void GetDimensions(Texture1DArray<float>, threadgroup uint* Width, threadgroup uint* Elements);
>+native void GetDimensions(Texture1DArray<float>, threadgroup uint* Width, threadgroup uint* Elements);
>+native void GetDimensions(Texture1DArray<float>, threadgroup uint* Width, threadgroup uint* Elements);
>+
>+native void GetDimensions(Texture2D<float>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<float>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<float>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<float>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<float>, uint MipLevel, thread uint* Width, device uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<float>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<float>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<float>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<float>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<float>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<float>, uint MipLevel, device uint* Width, thread uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<float>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<float>, uint MipLevel, device uint* Width, device uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<float>, uint MipLevel, device uint* Width, device uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<float>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<float>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<float>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<float>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<float>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<float>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<float>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<float>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<float>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<float>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<float>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<float>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<float>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels);
>+
>+native void GetDimensions(Texture2DArray<float>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float>, uint MipLevel, device uint* Width, device uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float>, uint MipLevel, device uint* Width, device uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float>, uint MipLevel, device uint* Width, device uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+
>+native void GetDimensions(Texture3D<float>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float>, uint MipLevel, device uint* Width, device uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float>, uint MipLevel, device uint* Width, device uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float>, uint MipLevel, device uint* Width, device uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+
>+native void GetDimensions(TextureCube<float>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<float>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<float>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<float>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<float>, uint MipLevel, thread uint* Width, device uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<float>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<float>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<float>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<float>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<float>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<float>, uint MipLevel, device uint* Width, thread uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<float>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<float>, uint MipLevel, device uint* Width, device uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<float>, uint MipLevel, device uint* Width, device uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<float>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<float>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<float>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<float>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<float>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<float>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<float>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<float>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<float>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<float>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<float>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<float>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<float>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels);
>+
>+
>+
>+
>+
>+
>+native void GetDimensions(Texture1D<float2>, thread uint* Width);
>+native void GetDimensions(Texture1D<float2>, thread uint* Width);
>+native void GetDimensions(Texture1D<float2>, thread uint* Width);
>+native void GetDimensions(Texture1D<float2>, device uint* Width);
>+native void GetDimensions(Texture1D<float2>, device uint* Width);
>+native void GetDimensions(Texture1D<float2>, device uint* Width);
>+native void GetDimensions(Texture1D<float2>, threadgroup uint* Width);
>+native void GetDimensions(Texture1D<float2>, threadgroup uint* Width);
>+native void GetDimensions(Texture1D<float2>, threadgroup uint* Width);
>+
>+native void GetDimensions(Texture1DArray<float2>, thread uint* Width, thread uint* Elements);
>+native void GetDimensions(Texture1DArray<float2>, thread uint* Width, thread uint* Elements);
>+native void GetDimensions(Texture1DArray<float2>, thread uint* Width, thread uint* Elements);
>+native void GetDimensions(Texture1DArray<float2>, thread uint* Width, device uint* Elements);
>+native void GetDimensions(Texture1DArray<float2>, thread uint* Width, device uint* Elements);
>+native void GetDimensions(Texture1DArray<float2>, thread uint* Width, device uint* Elements);
>+native void GetDimensions(Texture1DArray<float2>, thread uint* Width, threadgroup uint* Elements);
>+native void GetDimensions(Texture1DArray<float2>, thread uint* Width, threadgroup uint* Elements);
>+native void GetDimensions(Texture1DArray<float2>, thread uint* Width, threadgroup uint* Elements);
>+native void GetDimensions(Texture1DArray<float2>, device uint* Width, thread uint* Elements);
>+native void GetDimensions(Texture1DArray<float2>, device uint* Width, thread uint* Elements);
>+native void GetDimensions(Texture1DArray<float2>, device uint* Width, thread uint* Elements);
>+native void GetDimensions(Texture1DArray<float2>, device uint* Width, device uint* Elements);
>+native void GetDimensions(Texture1DArray<float2>, device uint* Width, device uint* Elements);
>+native void GetDimensions(Texture1DArray<float2>, device uint* Width, device uint* Elements);
>+native void GetDimensions(Texture1DArray<float2>, device uint* Width, threadgroup uint* Elements);
>+native void GetDimensions(Texture1DArray<float2>, device uint* Width, threadgroup uint* Elements);
>+native void GetDimensions(Texture1DArray<float2>, device uint* Width, threadgroup uint* Elements);
>+native void GetDimensions(Texture1DArray<float2>, threadgroup uint* Width, thread uint* Elements);
>+native void GetDimensions(Texture1DArray<float2>, threadgroup uint* Width, thread uint* Elements);
>+native void GetDimensions(Texture1DArray<float2>, threadgroup uint* Width, thread uint* Elements);
>+native void GetDimensions(Texture1DArray<float2>, threadgroup uint* Width, device uint* Elements);
>+native void GetDimensions(Texture1DArray<float2>, threadgroup uint* Width, device uint* Elements);
>+native void GetDimensions(Texture1DArray<float2>, threadgroup uint* Width, device uint* Elements);
>+native void GetDimensions(Texture1DArray<float2>, threadgroup uint* Width, threadgroup uint* Elements);
>+native void GetDimensions(Texture1DArray<float2>, threadgroup uint* Width, threadgroup uint* Elements);
>+native void GetDimensions(Texture1DArray<float2>, threadgroup uint* Width, threadgroup uint* Elements);
>+
>+native void GetDimensions(Texture2D<float2>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<float2>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<float2>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<float2>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<float2>, uint MipLevel, thread uint* Width, device uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<float2>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<float2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<float2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<float2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<float2>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<float2>, uint MipLevel, device uint* Width, thread uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<float2>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<float2>, uint MipLevel, device uint* Width, device uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<float2>, uint MipLevel, device uint* Width, device uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<float2>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<float2>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<float2>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<float2>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<float2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<float2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<float2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<float2>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<float2>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<float2>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<float2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<float2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<float2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels);
>+
>+native void GetDimensions(Texture2DArray<float2>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float2>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float2>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float2>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float2>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float2>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float2>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float2>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float2>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float2>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float2>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float2>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float2>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float2>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float2>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float2>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float2>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float2>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float2>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float2>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float2>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float2>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float2>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float2>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float2>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float2>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float2>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float2>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float2>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float2>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float2>, uint MipLevel, device uint* Width, device uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float2>, uint MipLevel, device uint* Width, device uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float2>, uint MipLevel, device uint* Width, device uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float2>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float2>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float2>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float2>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float2>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float2>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float2>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float2>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float2>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float2>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float2>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float2>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float2>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float2>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float2>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float2>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float2>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float2>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float2>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float2>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float2>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+
>+native void GetDimensions(Texture3D<float2>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float2>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float2>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float2>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float2>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float2>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float2>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float2>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float2>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float2>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float2>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float2>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float2>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float2>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float2>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float2>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float2>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float2>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float2>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float2>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float2>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float2>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float2>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float2>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float2>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float2>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float2>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float2>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float2>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float2>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float2>, uint MipLevel, device uint* Width, device uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float2>, uint MipLevel, device uint* Width, device uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float2>, uint MipLevel, device uint* Width, device uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float2>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float2>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float2>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float2>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float2>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float2>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float2>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float2>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float2>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float2>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float2>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float2>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float2>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float2>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float2>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float2>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float2>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float2>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float2>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float2>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float2>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+
>+native void GetDimensions(TextureCube<float2>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<float2>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<float2>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<float2>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<float2>, uint MipLevel, thread uint* Width, device uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<float2>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<float2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<float2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<float2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<float2>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<float2>, uint MipLevel, device uint* Width, thread uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<float2>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<float2>, uint MipLevel, device uint* Width, device uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<float2>, uint MipLevel, device uint* Width, device uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<float2>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<float2>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<float2>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<float2>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<float2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<float2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<float2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<float2>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<float2>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<float2>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<float2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<float2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<float2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels);
>+
>+
>+
>+
>+
>+
>+native void GetDimensions(Texture1D<float3>, thread uint* Width);
>+native void GetDimensions(Texture1D<float3>, thread uint* Width);
>+native void GetDimensions(Texture1D<float3>, thread uint* Width);
>+native void GetDimensions(Texture1D<float3>, device uint* Width);
>+native void GetDimensions(Texture1D<float3>, device uint* Width);
>+native void GetDimensions(Texture1D<float3>, device uint* Width);
>+native void GetDimensions(Texture1D<float3>, threadgroup uint* Width);
>+native void GetDimensions(Texture1D<float3>, threadgroup uint* Width);
>+native void GetDimensions(Texture1D<float3>, threadgroup uint* Width);
>+
>+native void GetDimensions(Texture1DArray<float3>, thread uint* Width, thread uint* Elements);
>+native void GetDimensions(Texture1DArray<float3>, thread uint* Width, thread uint* Elements);
>+native void GetDimensions(Texture1DArray<float3>, thread uint* Width, thread uint* Elements);
>+native void GetDimensions(Texture1DArray<float3>, thread uint* Width, device uint* Elements);
>+native void GetDimensions(Texture1DArray<float3>, thread uint* Width, device uint* Elements);
>+native void GetDimensions(Texture1DArray<float3>, thread uint* Width, device uint* Elements);
>+native void GetDimensions(Texture1DArray<float3>, thread uint* Width, threadgroup uint* Elements);
>+native void GetDimensions(Texture1DArray<float3>, thread uint* Width, threadgroup uint* Elements);
>+native void GetDimensions(Texture1DArray<float3>, thread uint* Width, threadgroup uint* Elements);
>+native void GetDimensions(Texture1DArray<float3>, device uint* Width, thread uint* Elements);
>+native void GetDimensions(Texture1DArray<float3>, device uint* Width, thread uint* Elements);
>+native void GetDimensions(Texture1DArray<float3>, device uint* Width, thread uint* Elements);
>+native void GetDimensions(Texture1DArray<float3>, device uint* Width, device uint* Elements);
>+native void GetDimensions(Texture1DArray<float3>, device uint* Width, device uint* Elements);
>+native void GetDimensions(Texture1DArray<float3>, device uint* Width, device uint* Elements);
>+native void GetDimensions(Texture1DArray<float3>, device uint* Width, threadgroup uint* Elements);
>+native void GetDimensions(Texture1DArray<float3>, device uint* Width, threadgroup uint* Elements);
>+native void GetDimensions(Texture1DArray<float3>, device uint* Width, threadgroup uint* Elements);
>+native void GetDimensions(Texture1DArray<float3>, threadgroup uint* Width, thread uint* Elements);
>+native void GetDimensions(Texture1DArray<float3>, threadgroup uint* Width, thread uint* Elements);
>+native void GetDimensions(Texture1DArray<float3>, threadgroup uint* Width, thread uint* Elements);
>+native void GetDimensions(Texture1DArray<float3>, threadgroup uint* Width, device uint* Elements);
>+native void GetDimensions(Texture1DArray<float3>, threadgroup uint* Width, device uint* Elements);
>+native void GetDimensions(Texture1DArray<float3>, threadgroup uint* Width, device uint* Elements);
>+native void GetDimensions(Texture1DArray<float3>, threadgroup uint* Width, threadgroup uint* Elements);
>+native void GetDimensions(Texture1DArray<float3>, threadgroup uint* Width, threadgroup uint* Elements);
>+native void GetDimensions(Texture1DArray<float3>, threadgroup uint* Width, threadgroup uint* Elements);
>+
>+native void GetDimensions(Texture2D<float3>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<float3>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<float3>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<float3>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<float3>, uint MipLevel, thread uint* Width, device uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<float3>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<float3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<float3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<float3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<float3>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<float3>, uint MipLevel, device uint* Width, thread uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<float3>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<float3>, uint MipLevel, device uint* Width, device uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<float3>, uint MipLevel, device uint* Width, device uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<float3>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<float3>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<float3>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<float3>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<float3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<float3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<float3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<float3>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<float3>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<float3>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<float3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<float3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<float3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels);
>+
>+native void GetDimensions(Texture2DArray<float3>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float3>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float3>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float3>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float3>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float3>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float3>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float3>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float3>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float3>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float3>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float3>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float3>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float3>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float3>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float3>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float3>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float3>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float3>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float3>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float3>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float3>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float3>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float3>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float3>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float3>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float3>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float3>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float3>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float3>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float3>, uint MipLevel, device uint* Width, device uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float3>, uint MipLevel, device uint* Width, device uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float3>, uint MipLevel, device uint* Width, device uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float3>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float3>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float3>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float3>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float3>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float3>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float3>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float3>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float3>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float3>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float3>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float3>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float3>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float3>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float3>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float3>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float3>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float3>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float3>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float3>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float3>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+
>+native void GetDimensions(Texture3D<float3>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float3>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float3>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float3>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float3>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float3>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float3>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float3>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float3>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float3>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float3>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float3>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float3>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float3>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float3>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float3>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float3>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float3>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float3>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float3>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float3>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float3>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float3>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float3>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float3>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float3>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float3>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float3>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float3>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float3>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float3>, uint MipLevel, device uint* Width, device uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float3>, uint MipLevel, device uint* Width, device uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float3>, uint MipLevel, device uint* Width, device uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float3>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float3>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float3>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float3>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float3>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float3>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float3>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float3>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float3>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float3>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float3>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float3>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float3>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float3>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float3>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float3>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float3>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float3>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float3>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float3>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float3>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+
>+native void GetDimensions(TextureCube<float3>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<float3>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<float3>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<float3>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<float3>, uint MipLevel, thread uint* Width, device uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<float3>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<float3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<float3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<float3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<float3>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<float3>, uint MipLevel, device uint* Width, thread uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<float3>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<float3>, uint MipLevel, device uint* Width, device uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<float3>, uint MipLevel, device uint* Width, device uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<float3>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<float3>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<float3>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<float3>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<float3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<float3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<float3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<float3>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<float3>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<float3>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<float3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<float3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<float3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels);
>+
>+
>+
>+
>+
>+
>+native void GetDimensions(Texture1D<float4>, thread uint* Width);
>+native void GetDimensions(Texture1D<float4>, thread uint* Width);
>+native void GetDimensions(Texture1D<float4>, thread uint* Width);
>+native void GetDimensions(Texture1D<float4>, device uint* Width);
>+native void GetDimensions(Texture1D<float4>, device uint* Width);
>+native void GetDimensions(Texture1D<float4>, device uint* Width);
>+native void GetDimensions(Texture1D<float4>, threadgroup uint* Width);
>+native void GetDimensions(Texture1D<float4>, threadgroup uint* Width);
>+native void GetDimensions(Texture1D<float4>, threadgroup uint* Width);
>+
>+native void GetDimensions(Texture1DArray<float4>, thread uint* Width, thread uint* Elements);
>+native void GetDimensions(Texture1DArray<float4>, thread uint* Width, thread uint* Elements);
>+native void GetDimensions(Texture1DArray<float4>, thread uint* Width, thread uint* Elements);
>+native void GetDimensions(Texture1DArray<float4>, thread uint* Width, device uint* Elements);
>+native void GetDimensions(Texture1DArray<float4>, thread uint* Width, device uint* Elements);
>+native void GetDimensions(Texture1DArray<float4>, thread uint* Width, device uint* Elements);
>+native void GetDimensions(Texture1DArray<float4>, thread uint* Width, threadgroup uint* Elements);
>+native void GetDimensions(Texture1DArray<float4>, thread uint* Width, threadgroup uint* Elements);
>+native void GetDimensions(Texture1DArray<float4>, thread uint* Width, threadgroup uint* Elements);
>+native void GetDimensions(Texture1DArray<float4>, device uint* Width, thread uint* Elements);
>+native void GetDimensions(Texture1DArray<float4>, device uint* Width, thread uint* Elements);
>+native void GetDimensions(Texture1DArray<float4>, device uint* Width, thread uint* Elements);
>+native void GetDimensions(Texture1DArray<float4>, device uint* Width, device uint* Elements);
>+native void GetDimensions(Texture1DArray<float4>, device uint* Width, device uint* Elements);
>+native void GetDimensions(Texture1DArray<float4>, device uint* Width, device uint* Elements);
>+native void GetDimensions(Texture1DArray<float4>, device uint* Width, threadgroup uint* Elements);
>+native void GetDimensions(Texture1DArray<float4>, device uint* Width, threadgroup uint* Elements);
>+native void GetDimensions(Texture1DArray<float4>, device uint* Width, threadgroup uint* Elements);
>+native void GetDimensions(Texture1DArray<float4>, threadgroup uint* Width, thread uint* Elements);
>+native void GetDimensions(Texture1DArray<float4>, threadgroup uint* Width, thread uint* Elements);
>+native void GetDimensions(Texture1DArray<float4>, threadgroup uint* Width, thread uint* Elements);
>+native void GetDimensions(Texture1DArray<float4>, threadgroup uint* Width, device uint* Elements);
>+native void GetDimensions(Texture1DArray<float4>, threadgroup uint* Width, device uint* Elements);
>+native void GetDimensions(Texture1DArray<float4>, threadgroup uint* Width, device uint* Elements);
>+native void GetDimensions(Texture1DArray<float4>, threadgroup uint* Width, threadgroup uint* Elements);
>+native void GetDimensions(Texture1DArray<float4>, threadgroup uint* Width, threadgroup uint* Elements);
>+native void GetDimensions(Texture1DArray<float4>, threadgroup uint* Width, threadgroup uint* Elements);
>+
>+native void GetDimensions(Texture2D<float4>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<float4>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<float4>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<float4>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<float4>, uint MipLevel, thread uint* Width, device uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<float4>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<float4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<float4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<float4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<float4>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<float4>, uint MipLevel, device uint* Width, thread uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<float4>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<float4>, uint MipLevel, device uint* Width, device uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<float4>, uint MipLevel, device uint* Width, device uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<float4>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<float4>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<float4>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<float4>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<float4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<float4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<float4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<float4>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<float4>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<float4>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<float4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<float4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<float4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels);
>+
>+native void GetDimensions(Texture2DArray<float4>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float4>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float4>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float4>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float4>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float4>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float4>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float4>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float4>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float4>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float4>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float4>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float4>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float4>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float4>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float4>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float4>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float4>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float4>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float4>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float4>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float4>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float4>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float4>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float4>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float4>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float4>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float4>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float4>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float4>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float4>, uint MipLevel, device uint* Width, device uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float4>, uint MipLevel, device uint* Width, device uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float4>, uint MipLevel, device uint* Width, device uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float4>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float4>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float4>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float4>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float4>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float4>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float4>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float4>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float4>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float4>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float4>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float4>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float4>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float4>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float4>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float4>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float4>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float4>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float4>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float4>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float4>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+
>+native void GetDimensions(Texture3D<float4>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float4>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float4>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float4>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float4>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float4>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float4>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float4>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float4>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float4>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float4>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float4>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float4>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float4>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float4>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float4>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float4>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float4>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float4>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float4>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float4>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float4>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float4>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float4>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float4>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float4>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float4>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float4>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float4>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float4>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float4>, uint MipLevel, device uint* Width, device uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float4>, uint MipLevel, device uint* Width, device uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float4>, uint MipLevel, device uint* Width, device uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float4>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float4>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float4>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float4>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float4>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float4>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float4>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float4>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float4>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float4>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float4>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float4>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float4>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float4>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float4>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float4>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float4>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float4>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float4>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float4>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float4>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+
>+native void GetDimensions(TextureCube<float4>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<float4>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<float4>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<float4>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<float4>, uint MipLevel, thread uint* Width, device uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<float4>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<float4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<float4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<float4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<float4>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<float4>, uint MipLevel, device uint* Width, thread uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<float4>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<float4>, uint MipLevel, device uint* Width, device uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<float4>, uint MipLevel, device uint* Width, device uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<float4>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<float4>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<float4>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<float4>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<float4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<float4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<float4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<float4>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<float4>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<float4>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<float4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<float4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<float4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels);
>+
>+
>+
>+
>+
>+
>+native void GetDimensions(TextureDepth2D<float>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureDepth2D<float>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureDepth2D<float>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureDepth2D<float>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureDepth2D<float>, uint MipLevel, thread uint* Width, device uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureDepth2D<float>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureDepth2D<float>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureDepth2D<float>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureDepth2D<float>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureDepth2D<float>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureDepth2D<float>, uint MipLevel, device uint* Width, thread uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureDepth2D<float>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureDepth2D<float>, uint MipLevel, device uint* Width, device uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureDepth2D<float>, uint MipLevel, device uint* Width, device uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureDepth2D<float>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureDepth2D<float>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureDepth2D<float>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureDepth2D<float>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureDepth2D<float>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureDepth2D<float>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureDepth2D<float>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureDepth2D<float>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureDepth2D<float>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureDepth2D<float>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureDepth2D<float>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureDepth2D<float>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureDepth2D<float>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels);
>+
>+native void GetDimensions(TextureDepth2DArray<float>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureDepth2DArray<float>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(TextureDepth2DArray<float>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureDepth2DArray<float>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureDepth2DArray<float>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(TextureDepth2DArray<float>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureDepth2DArray<float>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureDepth2DArray<float>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(TextureDepth2DArray<float>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureDepth2DArray<float>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureDepth2DArray<float>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(TextureDepth2DArray<float>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureDepth2DArray<float>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureDepth2DArray<float>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(TextureDepth2DArray<float>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureDepth2DArray<float>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureDepth2DArray<float>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(TextureDepth2DArray<float>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureDepth2DArray<float>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureDepth2DArray<float>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(TextureDepth2DArray<float>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureDepth2DArray<float>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureDepth2DArray<float>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(TextureDepth2DArray<float>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureDepth2DArray<float>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureDepth2DArray<float>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(TextureDepth2DArray<float>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureDepth2DArray<float>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureDepth2DArray<float>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(TextureDepth2DArray<float>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureDepth2DArray<float>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureDepth2DArray<float>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(TextureDepth2DArray<float>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureDepth2DArray<float>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureDepth2DArray<float>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(TextureDepth2DArray<float>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureDepth2DArray<float>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureDepth2DArray<float>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(TextureDepth2DArray<float>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureDepth2DArray<float>, uint MipLevel, device uint* Width, device uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureDepth2DArray<float>, uint MipLevel, device uint* Width, device uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(TextureDepth2DArray<float>, uint MipLevel, device uint* Width, device uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureDepth2DArray<float>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureDepth2DArray<float>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(TextureDepth2DArray<float>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureDepth2DArray<float>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureDepth2DArray<float>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(TextureDepth2DArray<float>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureDepth2DArray<float>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureDepth2DArray<float>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(TextureDepth2DArray<float>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureDepth2DArray<float>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureDepth2DArray<float>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(TextureDepth2DArray<float>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureDepth2DArray<float>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureDepth2DArray<float>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(TextureDepth2DArray<float>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureDepth2DArray<float>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureDepth2DArray<float>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(TextureDepth2DArray<float>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureDepth2DArray<float>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureDepth2DArray<float>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(TextureDepth2DArray<float>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureDepth2DArray<float>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureDepth2DArray<float>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(TextureDepth2DArray<float>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureDepth2DArray<float>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureDepth2DArray<float>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(TextureDepth2DArray<float>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureDepth2DArray<float>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureDepth2DArray<float>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(TextureDepth2DArray<float>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureDepth2DArray<float>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureDepth2DArray<float>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(TextureDepth2DArray<float>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureDepth2DArray<float>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureDepth2DArray<float>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(TextureDepth2DArray<float>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureDepth2DArray<float>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureDepth2DArray<float>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(TextureDepth2DArray<float>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+
>+native void GetDimensions(TextureDepthCube<float>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureDepthCube<float>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureDepthCube<float>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureDepthCube<float>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureDepthCube<float>, uint MipLevel, thread uint* Width, device uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureDepthCube<float>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureDepthCube<float>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureDepthCube<float>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureDepthCube<float>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureDepthCube<float>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureDepthCube<float>, uint MipLevel, device uint* Width, thread uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureDepthCube<float>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureDepthCube<float>, uint MipLevel, device uint* Width, device uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureDepthCube<float>, uint MipLevel, device uint* Width, device uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureDepthCube<float>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureDepthCube<float>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureDepthCube<float>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureDepthCube<float>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureDepthCube<float>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureDepthCube<float>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureDepthCube<float>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureDepthCube<float>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureDepthCube<float>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureDepthCube<float>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureDepthCube<float>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureDepthCube<float>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureDepthCube<float>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels);
>+
>+
>+/* Functions named operator.xwyw */
>+bool4 operator.xwyw(bool4 v) {
>+    bool4 result;
>+    result.x = v.x;
>+    result.y = v.w;
>+    result.z = v.y;
>+    result.w = v.w;
>+    return result;
>+}
>+uchar4 operator.xwyw(uchar4 v) {
>+    uchar4 result;
>+    result.x = v.x;
>+    result.y = v.w;
>+    result.z = v.y;
>+    result.w = v.w;
>+    return result;
>+}
>+ushort4 operator.xwyw(ushort4 v) {
>+    ushort4 result;
>+    result.x = v.x;
>+    result.y = v.w;
>+    result.z = v.y;
>+    result.w = v.w;
>+    return result;
>+}
>+uint4 operator.xwyw(uint4 v) {
>+    uint4 result;
>+    result.x = v.x;
>+    result.y = v.w;
>+    result.z = v.y;
>+    result.w = v.w;
>+    return result;
>+}
>+char4 operator.xwyw(char4 v) {
>+    char4 result;
>+    result.x = v.x;
>+    result.y = v.w;
>+    result.z = v.y;
>+    result.w = v.w;
>+    return result;
>+}
>+short4 operator.xwyw(short4 v) {
>+    short4 result;
>+    result.x = v.x;
>+    result.y = v.w;
>+    result.z = v.y;
>+    result.w = v.w;
>+    return result;
>+}
>+int4 operator.xwyw(int4 v) {
>+    int4 result;
>+    result.x = v.x;
>+    result.y = v.w;
>+    result.z = v.y;
>+    result.w = v.w;
>+    return result;
>+}
>+half4 operator.xwyw(half4 v) {
>+    half4 result;
>+    result.x = v.x;
>+    result.y = v.w;
>+    result.z = v.y;
>+    result.w = v.w;
>+    return result;
>+}
>+float4 operator.xwyw(float4 v) {
>+    float4 result;
>+    result.x = v.x;
>+    result.y = v.w;
>+    result.z = v.y;
>+    result.w = v.w;
>+    return result;
>+}
>+
>+/* Functions named operator+ */
>+native int operator+(int, int);
>+native uint operator+(uint, uint);
>+native float operator+(float, float);
>+uchar operator+(uchar a, uchar b) {
>+    return uchar(uint(a) + uint(b));
>+}
>+ushort operator+(ushort a, ushort b) {
>+    return ushort(uint(a) + uint(b));
>+}
>+char operator+(char a, char b) {
>+    return char(int(a) + int(b));
>+}
>+short operator+(short a, short b) {
>+    return short(int(a) + int(b));
>+}
>+half operator+(half a, half b) {
>+    return half(float(a) + float(b));
>+}
>+uchar2 operator+(uchar2 a, uchar2 b) {
>+    uchar2 result;
>+    result[0] = a[0] + b[0];
>+    result[1] = a[1] + b[1];
>+    return result;
>+}
>+uchar3 operator+(uchar3 a, uchar3 b) {
>+    uchar3 result;
>+    result[0] = a[0] + b[0];
>+    result[1] = a[1] + b[1];
>+    result[2] = a[2] + b[2];
>+    return result;
>+}
>+uchar4 operator+(uchar4 a, uchar4 b) {
>+    uchar4 result;
>+    result[0] = a[0] + b[0];
>+    result[1] = a[1] + b[1];
>+    result[2] = a[2] + b[2];
>+    result[3] = a[3] + b[3];
>+    return result;
>+}
>+ushort2 operator+(ushort2 a, ushort2 b) {
>+    ushort2 result;
>+    result[0] = a[0] + b[0];
>+    result[1] = a[1] + b[1];
>+    return result;
>+}
>+ushort3 operator+(ushort3 a, ushort3 b) {
>+    ushort3 result;
>+    result[0] = a[0] + b[0];
>+    result[1] = a[1] + b[1];
>+    result[2] = a[2] + b[2];
>+    return result;
>+}
>+ushort4 operator+(ushort4 a, ushort4 b) {
>+    ushort4 result;
>+    result[0] = a[0] + b[0];
>+    result[1] = a[1] + b[1];
>+    result[2] = a[2] + b[2];
>+    result[3] = a[3] + b[3];
>+    return result;
>+}
>+uint2 operator+(uint2 a, uint2 b) {
>+    uint2 result;
>+    result[0] = a[0] + b[0];
>+    result[1] = a[1] + b[1];
>+    return result;
>+}
>+uint3 operator+(uint3 a, uint3 b) {
>+    uint3 result;
>+    result[0] = a[0] + b[0];
>+    result[1] = a[1] + b[1];
>+    result[2] = a[2] + b[2];
>+    return result;
>+}
>+uint4 operator+(uint4 a, uint4 b) {
>+    uint4 result;
>+    result[0] = a[0] + b[0];
>+    result[1] = a[1] + b[1];
>+    result[2] = a[2] + b[2];
>+    result[3] = a[3] + b[3];
>+    return result;
>+}
>+char2 operator+(char2 a, char2 b) {
>+    char2 result;
>+    result[0] = a[0] + b[0];
>+    result[1] = a[1] + b[1];
>+    return result;
>+}
>+char3 operator+(char3 a, char3 b) {
>+    char3 result;
>+    result[0] = a[0] + b[0];
>+    result[1] = a[1] + b[1];
>+    result[2] = a[2] + b[2];
>+    return result;
>+}
>+char4 operator+(char4 a, char4 b) {
>+    char4 result;
>+    result[0] = a[0] + b[0];
>+    result[1] = a[1] + b[1];
>+    result[2] = a[2] + b[2];
>+    result[3] = a[3] + b[3];
>+    return result;
>+}
>+short2 operator+(short2 a, short2 b) {
>+    short2 result;
>+    result[0] = a[0] + b[0];
>+    result[1] = a[1] + b[1];
>+    return result;
>+}
>+short3 operator+(short3 a, short3 b) {
>+    short3 result;
>+    result[0] = a[0] + b[0];
>+    result[1] = a[1] + b[1];
>+    result[2] = a[2] + b[2];
>+    return result;
>+}
>+short4 operator+(short4 a, short4 b) {
>+    short4 result;
>+    result[0] = a[0] + b[0];
>+    result[1] = a[1] + b[1];
>+    result[2] = a[2] + b[2];
>+    result[3] = a[3] + b[3];
>+    return result;
>+}
>+int2 operator+(int2 a, int2 b) {
>+    int2 result;
>+    result[0] = a[0] + b[0];
>+    result[1] = a[1] + b[1];
>+    return result;
>+}
>+int3 operator+(int3 a, int3 b) {
>+    int3 result;
>+    result[0] = a[0] + b[0];
>+    result[1] = a[1] + b[1];
>+    result[2] = a[2] + b[2];
>+    return result;
>+}
>+int4 operator+(int4 a, int4 b) {
>+    int4 result;
>+    result[0] = a[0] + b[0];
>+    result[1] = a[1] + b[1];
>+    result[2] = a[2] + b[2];
>+    result[3] = a[3] + b[3];
>+    return result;
>+}
>+half2 operator+(half2 a, half2 b) {
>+    half2 result;
>+    result[0] = a[0] + b[0];
>+    result[1] = a[1] + b[1];
>+    return result;
>+}
>+half3 operator+(half3 a, half3 b) {
>+    half3 result;
>+    result[0] = a[0] + b[0];
>+    result[1] = a[1] + b[1];
>+    result[2] = a[2] + b[2];
>+    return result;
>+}
>+half4 operator+(half4 a, half4 b) {
>+    half4 result;
>+    result[0] = a[0] + b[0];
>+    result[1] = a[1] + b[1];
>+    result[2] = a[2] + b[2];
>+    result[3] = a[3] + b[3];
>+    return result;
>+}
>+float2 operator+(float2 a, float2 b) {
>+    float2 result;
>+    result[0] = a[0] + b[0];
>+    result[1] = a[1] + b[1];
>+    return result;
>+}
>+float3 operator+(float3 a, float3 b) {
>+    float3 result;
>+    result[0] = a[0] + b[0];
>+    result[1] = a[1] + b[1];
>+    result[2] = a[2] + b[2];
>+    return result;
>+}
>+float4 operator+(float4 a, float4 b) {
>+    float4 result;
>+    result[0] = a[0] + b[0];
>+    result[1] = a[1] + b[1];
>+    result[2] = a[2] + b[2];
>+    result[3] = a[3] + b[3];
>+    return result;
>+}
>+half2x2 operator+(half2x2 a, half2x2 b) {
>+    half2x2 result;
>+    result[0][0] = a[0][0] + b[0][0];
>+    result[0][1] = a[0][1] + b[0][1];
>+    result[1][0] = a[1][0] + b[1][0];
>+    result[1][1] = a[1][1] + b[1][1];
>+    return result;
>+}
>+half2x3 operator+(half2x3 a, half2x3 b) {
>+    half2x3 result;
>+    result[0][0] = a[0][0] + b[0][0];
>+    result[0][1] = a[0][1] + b[0][1];
>+    result[0][2] = a[0][2] + b[0][2];
>+    result[1][0] = a[1][0] + b[1][0];
>+    result[1][1] = a[1][1] + b[1][1];
>+    result[1][2] = a[1][2] + b[1][2];
>+    return result;
>+}
>+half2x4 operator+(half2x4 a, half2x4 b) {
>+    half2x4 result;
>+    result[0][0] = a[0][0] + b[0][0];
>+    result[0][1] = a[0][1] + b[0][1];
>+    result[0][2] = a[0][2] + b[0][2];
>+    result[0][3] = a[0][3] + b[0][3];
>+    result[1][0] = a[1][0] + b[1][0];
>+    result[1][1] = a[1][1] + b[1][1];
>+    result[1][2] = a[1][2] + b[1][2];
>+    result[1][3] = a[1][3] + b[1][3];
>+    return result;
>+}
>+half3x2 operator+(half3x2 a, half3x2 b) {
>+    half3x2 result;
>+    result[0][0] = a[0][0] + b[0][0];
>+    result[0][1] = a[0][1] + b[0][1];
>+    result[1][0] = a[1][0] + b[1][0];
>+    result[1][1] = a[1][1] + b[1][1];
>+    result[2][0] = a[2][0] + b[2][0];
>+    result[2][1] = a[2][1] + b[2][1];
>+    return result;
>+}
>+half3x3 operator+(half3x3 a, half3x3 b) {
>+    half3x3 result;
>+    result[0][0] = a[0][0] + b[0][0];
>+    result[0][1] = a[0][1] + b[0][1];
>+    result[0][2] = a[0][2] + b[0][2];
>+    result[1][0] = a[1][0] + b[1][0];
>+    result[1][1] = a[1][1] + b[1][1];
>+    result[1][2] = a[1][2] + b[1][2];
>+    result[2][0] = a[2][0] + b[2][0];
>+    result[2][1] = a[2][1] + b[2][1];
>+    result[2][2] = a[2][2] + b[2][2];
>+    return result;
>+}
>+half3x4 operator+(half3x4 a, half3x4 b) {
>+    half3x4 result;
>+    result[0][0] = a[0][0] + b[0][0];
>+    result[0][1] = a[0][1] + b[0][1];
>+    result[0][2] = a[0][2] + b[0][2];
>+    result[0][3] = a[0][3] + b[0][3];
>+    result[1][0] = a[1][0] + b[1][0];
>+    result[1][1] = a[1][1] + b[1][1];
>+    result[1][2] = a[1][2] + b[1][2];
>+    result[1][3] = a[1][3] + b[1][3];
>+    result[2][0] = a[2][0] + b[2][0];
>+    result[2][1] = a[2][1] + b[2][1];
>+    result[2][2] = a[2][2] + b[2][2];
>+    result[2][3] = a[2][3] + b[2][3];
>+    return result;
>+}
>+half4x2 operator+(half4x2 a, half4x2 b) {
>+    half4x2 result;
>+    result[0][0] = a[0][0] + b[0][0];
>+    result[0][1] = a[0][1] + b[0][1];
>+    result[1][0] = a[1][0] + b[1][0];
>+    result[1][1] = a[1][1] + b[1][1];
>+    result[2][0] = a[2][0] + b[2][0];
>+    result[2][1] = a[2][1] + b[2][1];
>+    result[3][0] = a[3][0] + b[3][0];
>+    result[3][1] = a[3][1] + b[3][1];
>+    return result;
>+}
>+half4x3 operator+(half4x3 a, half4x3 b) {
>+    half4x3 result;
>+    result[0][0] = a[0][0] + b[0][0];
>+    result[0][1] = a[0][1] + b[0][1];
>+    result[0][2] = a[0][2] + b[0][2];
>+    result[1][0] = a[1][0] + b[1][0];
>+    result[1][1] = a[1][1] + b[1][1];
>+    result[1][2] = a[1][2] + b[1][2];
>+    result[2][0] = a[2][0] + b[2][0];
>+    result[2][1] = a[2][1] + b[2][1];
>+    result[2][2] = a[2][2] + b[2][2];
>+    result[3][0] = a[3][0] + b[3][0];
>+    result[3][1] = a[3][1] + b[3][1];
>+    result[3][2] = a[3][2] + b[3][2];
>+    return result;
>+}
>+half4x4 operator+(half4x4 a, half4x4 b) {
>+    half4x4 result;
>+    result[0][0] = a[0][0] + b[0][0];
>+    result[0][1] = a[0][1] + b[0][1];
>+    result[0][2] = a[0][2] + b[0][2];
>+    result[0][3] = a[0][3] + b[0][3];
>+    result[1][0] = a[1][0] + b[1][0];
>+    result[1][1] = a[1][1] + b[1][1];
>+    result[1][2] = a[1][2] + b[1][2];
>+    result[1][3] = a[1][3] + b[1][3];
>+    result[2][0] = a[2][0] + b[2][0];
>+    result[2][1] = a[2][1] + b[2][1];
>+    result[2][2] = a[2][2] + b[2][2];
>+    result[2][3] = a[2][3] + b[2][3];
>+    result[3][0] = a[3][0] + b[3][0];
>+    result[3][1] = a[3][1] + b[3][1];
>+    result[3][2] = a[3][2] + b[3][2];
>+    result[3][3] = a[3][3] + b[3][3];
>+    return result;
>+}
>+float2x2 operator+(float2x2 a, float2x2 b) {
>+    float2x2 result;
>+    result[0][0] = a[0][0] + b[0][0];
>+    result[0][1] = a[0][1] + b[0][1];
>+    result[1][0] = a[1][0] + b[1][0];
>+    result[1][1] = a[1][1] + b[1][1];
>+    return result;
>+}
>+float2x3 operator+(float2x3 a, float2x3 b) {
>+    float2x3 result;
>+    result[0][0] = a[0][0] + b[0][0];
>+    result[0][1] = a[0][1] + b[0][1];
>+    result[0][2] = a[0][2] + b[0][2];
>+    result[1][0] = a[1][0] + b[1][0];
>+    result[1][1] = a[1][1] + b[1][1];
>+    result[1][2] = a[1][2] + b[1][2];
>+    return result;
>+}
>+float2x4 operator+(float2x4 a, float2x4 b) {
>+    float2x4 result;
>+    result[0][0] = a[0][0] + b[0][0];
>+    result[0][1] = a[0][1] + b[0][1];
>+    result[0][2] = a[0][2] + b[0][2];
>+    result[0][3] = a[0][3] + b[0][3];
>+    result[1][0] = a[1][0] + b[1][0];
>+    result[1][1] = a[1][1] + b[1][1];
>+    result[1][2] = a[1][2] + b[1][2];
>+    result[1][3] = a[1][3] + b[1][3];
>+    return result;
>+}
>+float3x2 operator+(float3x2 a, float3x2 b) {
>+    float3x2 result;
>+    result[0][0] = a[0][0] + b[0][0];
>+    result[0][1] = a[0][1] + b[0][1];
>+    result[1][0] = a[1][0] + b[1][0];
>+    result[1][1] = a[1][1] + b[1][1];
>+    result[2][0] = a[2][0] + b[2][0];
>+    result[2][1] = a[2][1] + b[2][1];
>+    return result;
>+}
>+float3x3 operator+(float3x3 a, float3x3 b) {
>+    float3x3 result;
>+    result[0][0] = a[0][0] + b[0][0];
>+    result[0][1] = a[0][1] + b[0][1];
>+    result[0][2] = a[0][2] + b[0][2];
>+    result[1][0] = a[1][0] + b[1][0];
>+    result[1][1] = a[1][1] + b[1][1];
>+    result[1][2] = a[1][2] + b[1][2];
>+    result[2][0] = a[2][0] + b[2][0];
>+    result[2][1] = a[2][1] + b[2][1];
>+    result[2][2] = a[2][2] + b[2][2];
>+    return result;
>+}
>+float3x4 operator+(float3x4 a, float3x4 b) {
>+    float3x4 result;
>+    result[0][0] = a[0][0] + b[0][0];
>+    result[0][1] = a[0][1] + b[0][1];
>+    result[0][2] = a[0][2] + b[0][2];
>+    result[0][3] = a[0][3] + b[0][3];
>+    result[1][0] = a[1][0] + b[1][0];
>+    result[1][1] = a[1][1] + b[1][1];
>+    result[1][2] = a[1][2] + b[1][2];
>+    result[1][3] = a[1][3] + b[1][3];
>+    result[2][0] = a[2][0] + b[2][0];
>+    result[2][1] = a[2][1] + b[2][1];
>+    result[2][2] = a[2][2] + b[2][2];
>+    result[2][3] = a[2][3] + b[2][3];
>+    return result;
>+}
>+float4x2 operator+(float4x2 a, float4x2 b) {
>+    float4x2 result;
>+    result[0][0] = a[0][0] + b[0][0];
>+    result[0][1] = a[0][1] + b[0][1];
>+    result[1][0] = a[1][0] + b[1][0];
>+    result[1][1] = a[1][1] + b[1][1];
>+    result[2][0] = a[2][0] + b[2][0];
>+    result[2][1] = a[2][1] + b[2][1];
>+    result[3][0] = a[3][0] + b[3][0];
>+    result[3][1] = a[3][1] + b[3][1];
>+    return result;
>+}
>+float4x3 operator+(float4x3 a, float4x3 b) {
>+    float4x3 result;
>+    result[0][0] = a[0][0] + b[0][0];
>+    result[0][1] = a[0][1] + b[0][1];
>+    result[0][2] = a[0][2] + b[0][2];
>+    result[1][0] = a[1][0] + b[1][0];
>+    result[1][1] = a[1][1] + b[1][1];
>+    result[1][2] = a[1][2] + b[1][2];
>+    result[2][0] = a[2][0] + b[2][0];
>+    result[2][1] = a[2][1] + b[2][1];
>+    result[2][2] = a[2][2] + b[2][2];
>+    result[3][0] = a[3][0] + b[3][0];
>+    result[3][1] = a[3][1] + b[3][1];
>+    result[3][2] = a[3][2] + b[3][2];
>+    return result;
>+}
>+float4x4 operator+(float4x4 a, float4x4 b) {
>+    float4x4 result;
>+    result[0][0] = a[0][0] + b[0][0];
>+    result[0][1] = a[0][1] + b[0][1];
>+    result[0][2] = a[0][2] + b[0][2];
>+    result[0][3] = a[0][3] + b[0][3];
>+    result[1][0] = a[1][0] + b[1][0];
>+    result[1][1] = a[1][1] + b[1][1];
>+    result[1][2] = a[1][2] + b[1][2];
>+    result[1][3] = a[1][3] + b[1][3];
>+    result[2][0] = a[2][0] + b[2][0];
>+    result[2][1] = a[2][1] + b[2][1];
>+    result[2][2] = a[2][2] + b[2][2];
>+    result[2][3] = a[2][3] + b[2][3];
>+    result[3][0] = a[3][0] + b[3][0];
>+    result[3][1] = a[3][1] + b[3][1];
>+    result[3][2] = a[3][2] + b[3][2];
>+    result[3][3] = a[3][3] + b[3][3];
>+    return result;
>+}
>+
>+/* Functions named operator.zxx */
>+bool3 operator.zxx(bool3 v) {
>+    bool3 result;
>+    result.x = v.z;
>+    result.y = v.x;
>+    result.z = v.x;
>+    return result;
>+}
>+bool3 operator.zxx(bool4 v) {
>+    bool3 result;
>+    result.x = v.z;
>+    result.y = v.x;
>+    result.z = v.x;
>+    return result;
>+}
>+uchar3 operator.zxx(uchar3 v) {
>+    uchar3 result;
>+    result.x = v.z;
>+    result.y = v.x;
>+    result.z = v.x;
>+    return result;
>+}
>+uchar3 operator.zxx(uchar4 v) {
>+    uchar3 result;
>+    result.x = v.z;
>+    result.y = v.x;
>+    result.z = v.x;
>+    return result;
>+}
>+ushort3 operator.zxx(ushort3 v) {
>+    ushort3 result;
>+    result.x = v.z;
>+    result.y = v.x;
>+    result.z = v.x;
>+    return result;
>+}
>+ushort3 operator.zxx(ushort4 v) {
>+    ushort3 result;
>+    result.x = v.z;
>+    result.y = v.x;
>+    result.z = v.x;
>+    return result;
>+}
>+uint3 operator.zxx(uint3 v) {
>+    uint3 result;
>+    result.x = v.z;
>+    result.y = v.x;
>+    result.z = v.x;
>+    return result;
>+}
>+uint3 operator.zxx(uint4 v) {
>+    uint3 result;
>+    result.x = v.z;
>+    result.y = v.x;
>+    result.z = v.x;
>+    return result;
>+}
>+char3 operator.zxx(char3 v) {
>+    char3 result;
>+    result.x = v.z;
>+    result.y = v.x;
>+    result.z = v.x;
>+    return result;
>+}
>+char3 operator.zxx(char4 v) {
>+    char3 result;
>+    result.x = v.z;
>+    result.y = v.x;
>+    result.z = v.x;
>+    return result;
>+}
>+short3 operator.zxx(short3 v) {
>+    short3 result;
>+    result.x = v.z;
>+    result.y = v.x;
>+    result.z = v.x;
>+    return result;
>+}
>+short3 operator.zxx(short4 v) {
>+    short3 result;
>+    result.x = v.z;
>+    result.y = v.x;
>+    result.z = v.x;
>+    return result;
>+}
>+int3 operator.zxx(int3 v) {
>+    int3 result;
>+    result.x = v.z;
>+    result.y = v.x;
>+    result.z = v.x;
>+    return result;
>+}
>+int3 operator.zxx(int4 v) {
>+    int3 result;
>+    result.x = v.z;
>+    result.y = v.x;
>+    result.z = v.x;
>+    return result;
>+}
>+half3 operator.zxx(half3 v) {
>+    half3 result;
>+    result.x = v.z;
>+    result.y = v.x;
>+    result.z = v.x;
>+    return result;
>+}
>+half3 operator.zxx(half4 v) {
>+    half3 result;
>+    result.x = v.z;
>+    result.y = v.x;
>+    result.z = v.x;
>+    return result;
>+}
>+float3 operator.zxx(float3 v) {
>+    float3 result;
>+    result.x = v.z;
>+    result.y = v.x;
>+    result.z = v.x;
>+    return result;
>+}
>+float3 operator.zxx(float4 v) {
>+    float3 result;
>+    result.x = v.z;
>+    result.y = v.x;
>+    result.z = v.x;
>+    return result;
>+}
>+
>+/* Functions named operator.xxyx */
>+bool4 operator.xxyx(bool2 v) {
>+    bool4 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.y;
>+    result.w = v.x;
>+    return result;
>+}
>+bool4 operator.xxyx(bool3 v) {
>+    bool4 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.y;
>+    result.w = v.x;
>+    return result;
>+}
>+bool4 operator.xxyx(bool4 v) {
>+    bool4 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.y;
>+    result.w = v.x;
>+    return result;
>+}
>+uchar4 operator.xxyx(uchar2 v) {
>+    uchar4 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.y;
>+    result.w = v.x;
>+    return result;
>+}
>+uchar4 operator.xxyx(uchar3 v) {
>+    uchar4 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.y;
>+    result.w = v.x;
>+    return result;
>+}
>+uchar4 operator.xxyx(uchar4 v) {
>+    uchar4 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.y;
>+    result.w = v.x;
>+    return result;
>+}
>+ushort4 operator.xxyx(ushort2 v) {
>+    ushort4 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.y;
>+    result.w = v.x;
>+    return result;
>+}
>+ushort4 operator.xxyx(ushort3 v) {
>+    ushort4 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.y;
>+    result.w = v.x;
>+    return result;
>+}
>+ushort4 operator.xxyx(ushort4 v) {
>+    ushort4 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.y;
>+    result.w = v.x;
>+    return result;
>+}
>+uint4 operator.xxyx(uint2 v) {
>+    uint4 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.y;
>+    result.w = v.x;
>+    return result;
>+}
>+uint4 operator.xxyx(uint3 v) {
>+    uint4 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.y;
>+    result.w = v.x;
>+    return result;
>+}
>+uint4 operator.xxyx(uint4 v) {
>+    uint4 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.y;
>+    result.w = v.x;
>+    return result;
>+}
>+char4 operator.xxyx(char2 v) {
>+    char4 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.y;
>+    result.w = v.x;
>+    return result;
>+}
>+char4 operator.xxyx(char3 v) {
>+    char4 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.y;
>+    result.w = v.x;
>+    return result;
>+}
>+char4 operator.xxyx(char4 v) {
>+    char4 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.y;
>+    result.w = v.x;
>+    return result;
>+}
>+short4 operator.xxyx(short2 v) {
>+    short4 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.y;
>+    result.w = v.x;
>+    return result;
>+}
>+short4 operator.xxyx(short3 v) {
>+    short4 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.y;
>+    result.w = v.x;
>+    return result;
>+}
>+short4 operator.xxyx(short4 v) {
>+    short4 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.y;
>+    result.w = v.x;
>+    return result;
>+}
>+int4 operator.xxyx(int2 v) {
>+    int4 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.y;
>+    result.w = v.x;
>+    return result;
>+}
>+int4 operator.xxyx(int3 v) {
>+    int4 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.y;
>+    result.w = v.x;
>+    return result;
>+}
>+int4 operator.xxyx(int4 v) {
>+    int4 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.y;
>+    result.w = v.x;
>+    return result;
>+}
>+half4 operator.xxyx(half2 v) {
>+    half4 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.y;
>+    result.w = v.x;
>+    return result;
>+}
>+half4 operator.xxyx(half3 v) {
>+    half4 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.y;
>+    result.w = v.x;
>+    return result;
>+}
>+half4 operator.xxyx(half4 v) {
>+    half4 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.y;
>+    result.w = v.x;
>+    return result;
>+}
>+float4 operator.xxyx(float2 v) {
>+    float4 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.y;
>+    result.w = v.x;
>+    return result;
>+}
>+float4 operator.xxyx(float3 v) {
>+    float4 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.y;
>+    result.w = v.x;
>+    return result;
>+}
>+float4 operator.xxyx(float4 v) {
>+    float4 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.y;
>+    result.w = v.x;
>+    return result;
>+}
>+
>+/* Functions named operator.xzzw */
>+bool4 operator.xzzw(bool4 v) {
>+    bool4 result;
>+    result.x = v.x;
>+    result.y = v.z;
>+    result.z = v.z;
>+    result.w = v.w;
>+    return result;
>+}
>+uchar4 operator.xzzw(uchar4 v) {
>+    uchar4 result;
>+    result.x = v.x;
>+    result.y = v.z;
>+    result.z = v.z;
>+    result.w = v.w;
>+    return result;
>+}
>+ushort4 operator.xzzw(ushort4 v) {
>+    ushort4 result;
>+    result.x = v.x;
>+    result.y = v.z;
>+    result.z = v.z;
>+    result.w = v.w;
>+    return result;
>+}
>+uint4 operator.xzzw(uint4 v) {
>+    uint4 result;
>+    result.x = v.x;
>+    result.y = v.z;
>+    result.z = v.z;
>+    result.w = v.w;
>+    return result;
>+}
>+char4 operator.xzzw(char4 v) {
>+    char4 result;
>+    result.x = v.x;
>+    result.y = v.z;
>+    result.z = v.z;
>+    result.w = v.w;
>+    return result;
>+}
>+short4 operator.xzzw(short4 v) {
>+    short4 result;
>+    result.x = v.x;
>+    result.y = v.z;
>+    result.z = v.z;
>+    result.w = v.w;
>+    return result;
>+}
>+int4 operator.xzzw(int4 v) {
>+    int4 result;
>+    result.x = v.x;
>+    result.y = v.z;
>+    result.z = v.z;
>+    result.w = v.w;
>+    return result;
>+}
>+half4 operator.xzzw(half4 v) {
>+    half4 result;
>+    result.x = v.x;
>+    result.y = v.z;
>+    result.z = v.z;
>+    result.w = v.w;
>+    return result;
>+}
>+float4 operator.xzzw(float4 v) {
>+    float4 result;
>+    result.x = v.x;
>+    result.y = v.z;
>+    result.z = v.z;
>+    result.w = v.w;
>+    return result;
>+}
>+
>+/* Functions named operator.xywz= */
>+bool4 operator.xywz=(bool4 v, bool4 c) {
>+    bool4 result = v;
>+    result.x = c.x;
>+    result.y = c.y;
>+    result.w = c.z;
>+    result.z = c.w;
>+    return result;
>+}
>+uchar4 operator.xywz=(uchar4 v, uchar4 c) {
>+    uchar4 result = v;
>+    result.x = c.x;
>+    result.y = c.y;
>+    result.w = c.z;
>+    result.z = c.w;
>+    return result;
>+}
>+ushort4 operator.xywz=(ushort4 v, ushort4 c) {
>+    ushort4 result = v;
>+    result.x = c.x;
>+    result.y = c.y;
>+    result.w = c.z;
>+    result.z = c.w;
>+    return result;
>+}
>+uint4 operator.xywz=(uint4 v, uint4 c) {
>+    uint4 result = v;
>+    result.x = c.x;
>+    result.y = c.y;
>+    result.w = c.z;
>+    result.z = c.w;
>+    return result;
>+}
>+char4 operator.xywz=(char4 v, char4 c) {
>+    char4 result = v;
>+    result.x = c.x;
>+    result.y = c.y;
>+    result.w = c.z;
>+    result.z = c.w;
>+    return result;
>+}
>+short4 operator.xywz=(short4 v, short4 c) {
>+    short4 result = v;
>+    result.x = c.x;
>+    result.y = c.y;
>+    result.w = c.z;
>+    result.z = c.w;
>+    return result;
>+}
>+int4 operator.xywz=(int4 v, int4 c) {
>+    int4 result = v;
>+    result.x = c.x;
>+    result.y = c.y;
>+    result.w = c.z;
>+    result.z = c.w;
>+    return result;
>+}
>+half4 operator.xywz=(half4 v, half4 c) {
>+    half4 result = v;
>+    result.x = c.x;
>+    result.y = c.y;
>+    result.w = c.z;
>+    result.z = c.w;
>+    return result;
>+}
>+float4 operator.xywz=(float4 v, float4 c) {
>+    float4 result = v;
>+    result.x = c.x;
>+    result.y = c.y;
>+    result.w = c.z;
>+    result.z = c.w;
>+    return result;
>+}
>+
>+/* Functions named operator.wxxw */
>+bool4 operator.wxxw(bool4 v) {
>+    bool4 result;
>+    result.x = v.w;
>+    result.y = v.x;
>+    result.z = v.x;
>+    result.w = v.w;
>+    return result;
>+}
>+uchar4 operator.wxxw(uchar4 v) {
>+    uchar4 result;
>+    result.x = v.w;
>+    result.y = v.x;
>+    result.z = v.x;
>+    result.w = v.w;
>+    return result;
>+}
>+ushort4 operator.wxxw(ushort4 v) {
>+    ushort4 result;
>+    result.x = v.w;
>+    result.y = v.x;
>+    result.z = v.x;
>+    result.w = v.w;
>+    return result;
>+}
>+uint4 operator.wxxw(uint4 v) {
>+    uint4 result;
>+    result.x = v.w;
>+    result.y = v.x;
>+    result.z = v.x;
>+    result.w = v.w;
>+    return result;
>+}
>+char4 operator.wxxw(char4 v) {
>+    char4 result;
>+    result.x = v.w;
>+    result.y = v.x;
>+    result.z = v.x;
>+    result.w = v.w;
>+    return result;
>+}
>+short4 operator.wxxw(short4 v) {
>+    short4 result;
>+    result.x = v.w;
>+    result.y = v.x;
>+    result.z = v.x;
>+    result.w = v.w;
>+    return result;
>+}
>+int4 operator.wxxw(int4 v) {
>+    int4 result;
>+    result.x = v.w;
>+    result.y = v.x;
>+    result.z = v.x;
>+    result.w = v.w;
>+    return result;
>+}
>+half4 operator.wxxw(half4 v) {
>+    half4 result;
>+    result.x = v.w;
>+    result.y = v.x;
>+    result.z = v.x;
>+    result.w = v.w;
>+    return result;
>+}
>+float4 operator.wxxw(float4 v) {
>+    float4 result;
>+    result.x = v.w;
>+    result.y = v.x;
>+    result.z = v.x;
>+    result.w = v.w;
>+    return result;
>+}
>+
>+/* Functions named operator.wzyx */
>+bool4 operator.wzyx(bool4 v) {
>+    bool4 result;
>+    result.x = v.w;
>+    result.y = v.z;
>+    result.z = v.y;
>+    result.w = v.x;
>+    return result;
>+}
>+uchar4 operator.wzyx(uchar4 v) {
>+    uchar4 result;
>+    result.x = v.w;
>+    result.y = v.z;
>+    result.z = v.y;
>+    result.w = v.x;
>+    return result;
>+}
>+ushort4 operator.wzyx(ushort4 v) {
>+    ushort4 result;
>+    result.x = v.w;
>+    result.y = v.z;
>+    result.z = v.y;
>+    result.w = v.x;
>+    return result;
>+}
>+uint4 operator.wzyx(uint4 v) {
>+    uint4 result;
>+    result.x = v.w;
>+    result.y = v.z;
>+    result.z = v.y;
>+    result.w = v.x;
>+    return result;
>+}
>+char4 operator.wzyx(char4 v) {
>+    char4 result;
>+    result.x = v.w;
>+    result.y = v.z;
>+    result.z = v.y;
>+    result.w = v.x;
>+    return result;
>+}
>+short4 operator.wzyx(short4 v) {
>+    short4 result;
>+    result.x = v.w;
>+    result.y = v.z;
>+    result.z = v.y;
>+    result.w = v.x;
>+    return result;
>+}
>+int4 operator.wzyx(int4 v) {
>+    int4 result;
>+    result.x = v.w;
>+    result.y = v.z;
>+    result.z = v.y;
>+    result.w = v.x;
>+    return result;
>+}
>+half4 operator.wzyx(half4 v) {
>+    half4 result;
>+    result.x = v.w;
>+    result.y = v.z;
>+    result.z = v.y;
>+    result.w = v.x;
>+    return result;
>+}
>+float4 operator.wzyx(float4 v) {
>+    float4 result;
>+    result.x = v.w;
>+    result.y = v.z;
>+    result.z = v.y;
>+    result.w = v.x;
>+    return result;
>+}
>+
>+/* Functions named frac */
>+half frac(half x) {
>+    return x - floor(x);
>+}
>+half2 frac(half2 x) {
>+    half2 result;
>+    result[0] = frac(x[0]);
>+    result[1] = frac(x[1]);
>+    return result;
>+}
>+half3 frac(half3 x) {
>+    half3 result;
>+    result[0] = frac(x[0]);
>+    result[1] = frac(x[1]);
>+    result[2] = frac(x[2]);
>+    return result;
>+}
>+half4 frac(half4 x) {
>+    half4 result;
>+    result[0] = frac(x[0]);
>+    result[1] = frac(x[1]);
>+    result[2] = frac(x[2]);
>+    result[3] = frac(x[3]);
>+    return result;
>+}
>+half2x2 frac(half2x2 x) {
>+    half2x2 result;
>+    result[0][0] = frac(x[0][0]);
>+    result[0][1] = frac(x[0][1]);
>+    result[1][0] = frac(x[1][0]);
>+    result[1][1] = frac(x[1][1]);
>+    return result;
>+}
>+half2x3 frac(half2x3 x) {
>+    half2x3 result;
>+    result[0][0] = frac(x[0][0]);
>+    result[0][1] = frac(x[0][1]);
>+    result[0][2] = frac(x[0][2]);
>+    result[1][0] = frac(x[1][0]);
>+    result[1][1] = frac(x[1][1]);
>+    result[1][2] = frac(x[1][2]);
>+    return result;
>+}
>+half2x4 frac(half2x4 x) {
>+    half2x4 result;
>+    result[0][0] = frac(x[0][0]);
>+    result[0][1] = frac(x[0][1]);
>+    result[0][2] = frac(x[0][2]);
>+    result[0][3] = frac(x[0][3]);
>+    result[1][0] = frac(x[1][0]);
>+    result[1][1] = frac(x[1][1]);
>+    result[1][2] = frac(x[1][2]);
>+    result[1][3] = frac(x[1][3]);
>+    return result;
>+}
>+half3x2 frac(half3x2 x) {
>+    half3x2 result;
>+    result[0][0] = frac(x[0][0]);
>+    result[0][1] = frac(x[0][1]);
>+    result[1][0] = frac(x[1][0]);
>+    result[1][1] = frac(x[1][1]);
>+    result[2][0] = frac(x[2][0]);
>+    result[2][1] = frac(x[2][1]);
>+    return result;
>+}
>+half3x3 frac(half3x3 x) {
>+    half3x3 result;
>+    result[0][0] = frac(x[0][0]);
>+    result[0][1] = frac(x[0][1]);
>+    result[0][2] = frac(x[0][2]);
>+    result[1][0] = frac(x[1][0]);
>+    result[1][1] = frac(x[1][1]);
>+    result[1][2] = frac(x[1][2]);
>+    result[2][0] = frac(x[2][0]);
>+    result[2][1] = frac(x[2][1]);
>+    result[2][2] = frac(x[2][2]);
>+    return result;
>+}
>+half3x4 frac(half3x4 x) {
>+    half3x4 result;
>+    result[0][0] = frac(x[0][0]);
>+    result[0][1] = frac(x[0][1]);
>+    result[0][2] = frac(x[0][2]);
>+    result[0][3] = frac(x[0][3]);
>+    result[1][0] = frac(x[1][0]);
>+    result[1][1] = frac(x[1][1]);
>+    result[1][2] = frac(x[1][2]);
>+    result[1][3] = frac(x[1][3]);
>+    result[2][0] = frac(x[2][0]);
>+    result[2][1] = frac(x[2][1]);
>+    result[2][2] = frac(x[2][2]);
>+    result[2][3] = frac(x[2][3]);
>+    return result;
>+}
>+half4x2 frac(half4x2 x) {
>+    half4x2 result;
>+    result[0][0] = frac(x[0][0]);
>+    result[0][1] = frac(x[0][1]);
>+    result[1][0] = frac(x[1][0]);
>+    result[1][1] = frac(x[1][1]);
>+    result[2][0] = frac(x[2][0]);
>+    result[2][1] = frac(x[2][1]);
>+    result[3][0] = frac(x[3][0]);
>+    result[3][1] = frac(x[3][1]);
>+    return result;
>+}
>+half4x3 frac(half4x3 x) {
>+    half4x3 result;
>+    result[0][0] = frac(x[0][0]);
>+    result[0][1] = frac(x[0][1]);
>+    result[0][2] = frac(x[0][2]);
>+    result[1][0] = frac(x[1][0]);
>+    result[1][1] = frac(x[1][1]);
>+    result[1][2] = frac(x[1][2]);
>+    result[2][0] = frac(x[2][0]);
>+    result[2][1] = frac(x[2][1]);
>+    result[2][2] = frac(x[2][2]);
>+    result[3][0] = frac(x[3][0]);
>+    result[3][1] = frac(x[3][1]);
>+    result[3][2] = frac(x[3][2]);
>+    return result;
>+}
>+half4x4 frac(half4x4 x) {
>+    half4x4 result;
>+    result[0][0] = frac(x[0][0]);
>+    result[0][1] = frac(x[0][1]);
>+    result[0][2] = frac(x[0][2]);
>+    result[0][3] = frac(x[0][3]);
>+    result[1][0] = frac(x[1][0]);
>+    result[1][1] = frac(x[1][1]);
>+    result[1][2] = frac(x[1][2]);
>+    result[1][3] = frac(x[1][3]);
>+    result[2][0] = frac(x[2][0]);
>+    result[2][1] = frac(x[2][1]);
>+    result[2][2] = frac(x[2][2]);
>+    result[2][3] = frac(x[2][3]);
>+    result[3][0] = frac(x[3][0]);
>+    result[3][1] = frac(x[3][1]);
>+    result[3][2] = frac(x[3][2]);
>+    result[3][3] = frac(x[3][3]);
>+    return result;
>+}
>+float frac(float x) {
>+    return x - floor(x);
>+}
>+float2 frac(float2 x) {
>+    float2 result;
>+    result[0] = frac(x[0]);
>+    result[1] = frac(x[1]);
>+    return result;
>+}
>+float3 frac(float3 x) {
>+    float3 result;
>+    result[0] = frac(x[0]);
>+    result[1] = frac(x[1]);
>+    result[2] = frac(x[2]);
>+    return result;
>+}
>+float4 frac(float4 x) {
>+    float4 result;
>+    result[0] = frac(x[0]);
>+    result[1] = frac(x[1]);
>+    result[2] = frac(x[2]);
>+    result[3] = frac(x[3]);
>+    return result;
>+}
>+float2x2 frac(float2x2 x) {
>+    float2x2 result;
>+    result[0][0] = frac(x[0][0]);
>+    result[0][1] = frac(x[0][1]);
>+    result[1][0] = frac(x[1][0]);
>+    result[1][1] = frac(x[1][1]);
>+    return result;
>+}
>+float2x3 frac(float2x3 x) {
>+    float2x3 result;
>+    result[0][0] = frac(x[0][0]);
>+    result[0][1] = frac(x[0][1]);
>+    result[0][2] = frac(x[0][2]);
>+    result[1][0] = frac(x[1][0]);
>+    result[1][1] = frac(x[1][1]);
>+    result[1][2] = frac(x[1][2]);
>+    return result;
>+}
>+float2x4 frac(float2x4 x) {
>+    float2x4 result;
>+    result[0][0] = frac(x[0][0]);
>+    result[0][1] = frac(x[0][1]);
>+    result[0][2] = frac(x[0][2]);
>+    result[0][3] = frac(x[0][3]);
>+    result[1][0] = frac(x[1][0]);
>+    result[1][1] = frac(x[1][1]);
>+    result[1][2] = frac(x[1][2]);
>+    result[1][3] = frac(x[1][3]);
>+    return result;
>+}
>+float3x2 frac(float3x2 x) {
>+    float3x2 result;
>+    result[0][0] = frac(x[0][0]);
>+    result[0][1] = frac(x[0][1]);
>+    result[1][0] = frac(x[1][0]);
>+    result[1][1] = frac(x[1][1]);
>+    result[2][0] = frac(x[2][0]);
>+    result[2][1] = frac(x[2][1]);
>+    return result;
>+}
>+float3x3 frac(float3x3 x) {
>+    float3x3 result;
>+    result[0][0] = frac(x[0][0]);
>+    result[0][1] = frac(x[0][1]);
>+    result[0][2] = frac(x[0][2]);
>+    result[1][0] = frac(x[1][0]);
>+    result[1][1] = frac(x[1][1]);
>+    result[1][2] = frac(x[1][2]);
>+    result[2][0] = frac(x[2][0]);
>+    result[2][1] = frac(x[2][1]);
>+    result[2][2] = frac(x[2][2]);
>+    return result;
>+}
>+float3x4 frac(float3x4 x) {
>+    float3x4 result;
>+    result[0][0] = frac(x[0][0]);
>+    result[0][1] = frac(x[0][1]);
>+    result[0][2] = frac(x[0][2]);
>+    result[0][3] = frac(x[0][3]);
>+    result[1][0] = frac(x[1][0]);
>+    result[1][1] = frac(x[1][1]);
>+    result[1][2] = frac(x[1][2]);
>+    result[1][3] = frac(x[1][3]);
>+    result[2][0] = frac(x[2][0]);
>+    result[2][1] = frac(x[2][1]);
>+    result[2][2] = frac(x[2][2]);
>+    result[2][3] = frac(x[2][3]);
>+    return result;
>+}
>+float4x2 frac(float4x2 x) {
>+    float4x2 result;
>+    result[0][0] = frac(x[0][0]);
>+    result[0][1] = frac(x[0][1]);
>+    result[1][0] = frac(x[1][0]);
>+    result[1][1] = frac(x[1][1]);
>+    result[2][0] = frac(x[2][0]);
>+    result[2][1] = frac(x[2][1]);
>+    result[3][0] = frac(x[3][0]);
>+    result[3][1] = frac(x[3][1]);
>+    return result;
>+}
>+float4x3 frac(float4x3 x) {
>+    float4x3 result;
>+    result[0][0] = frac(x[0][0]);
>+    result[0][1] = frac(x[0][1]);
>+    result[0][2] = frac(x[0][2]);
>+    result[1][0] = frac(x[1][0]);
>+    result[1][1] = frac(x[1][1]);
>+    result[1][2] = frac(x[1][2]);
>+    result[2][0] = frac(x[2][0]);
>+    result[2][1] = frac(x[2][1]);
>+    result[2][2] = frac(x[2][2]);
>+    result[3][0] = frac(x[3][0]);
>+    result[3][1] = frac(x[3][1]);
>+    result[3][2] = frac(x[3][2]);
>+    return result;
>+}
>+float4x4 frac(float4x4 x) {
>+    float4x4 result;
>+    result[0][0] = frac(x[0][0]);
>+    result[0][1] = frac(x[0][1]);
>+    result[0][2] = frac(x[0][2]);
>+    result[0][3] = frac(x[0][3]);
>+    result[1][0] = frac(x[1][0]);
>+    result[1][1] = frac(x[1][1]);
>+    result[1][2] = frac(x[1][2]);
>+    result[1][3] = frac(x[1][3]);
>+    result[2][0] = frac(x[2][0]);
>+    result[2][1] = frac(x[2][1]);
>+    result[2][2] = frac(x[2][2]);
>+    result[2][3] = frac(x[2][3]);
>+    result[3][0] = frac(x[3][0]);
>+    result[3][1] = frac(x[3][1]);
>+    result[3][2] = frac(x[3][2]);
>+    result[3][3] = frac(x[3][3]);
>+    return result;
>+}
>+
>+/* Functions named store */
>+native void store(device atomic_int*, int);
>+native void store(device atomic_uint*, uint);
>+native void store(threadgroup atomic_int*, int);
>+native void store(threadgroup atomic_uint*, uint);
>+
>+
>+/* Functions named operator.zww */
>+bool3 operator.zww(bool4 v) {
>+    bool3 result;
>+    result.x = v.z;
>+    result.y = v.w;
>+    result.z = v.w;
>+    return result;
>+}
>+uchar3 operator.zww(uchar4 v) {
>+    uchar3 result;
>+    result.x = v.z;
>+    result.y = v.w;
>+    result.z = v.w;
>+    return result;
>+}
>+ushort3 operator.zww(ushort4 v) {
>+    ushort3 result;
>+    result.x = v.z;
>+    result.y = v.w;
>+    result.z = v.w;
>+    return result;
>+}
>+uint3 operator.zww(uint4 v) {
>+    uint3 result;
>+    result.x = v.z;
>+    result.y = v.w;
>+    result.z = v.w;
>+    return result;
>+}
>+char3 operator.zww(char4 v) {
>+    char3 result;
>+    result.x = v.z;
>+    result.y = v.w;
>+    result.z = v.w;
>+    return result;
>+}
>+short3 operator.zww(short4 v) {
>+    short3 result;
>+    result.x = v.z;
>+    result.y = v.w;
>+    result.z = v.w;
>+    return result;
>+}
>+int3 operator.zww(int4 v) {
>+    int3 result;
>+    result.x = v.z;
>+    result.y = v.w;
>+    result.z = v.w;
>+    return result;
>+}
>+half3 operator.zww(half4 v) {
>+    half3 result;
>+    result.x = v.z;
>+    result.y = v.w;
>+    result.z = v.w;
>+    return result;
>+}
>+float3 operator.zww(float4 v) {
>+    float3 result;
>+    result.x = v.z;
>+    result.y = v.w;
>+    result.z = v.w;
>+    return result;
>+}
>+
>+/* Functions named operator.yzzz */
>+bool4 operator.yzzz(bool3 v) {
>+    bool4 result;
>+    result.x = v.y;
>+    result.y = v.z;
>+    result.z = v.z;
>+    result.w = v.z;
>+    return result;
>+}
>+bool4 operator.yzzz(bool4 v) {
>+    bool4 result;
>+    result.x = v.y;
>+    result.y = v.z;
>+    result.z = v.z;
>+    result.w = v.z;
>+    return result;
>+}
>+uchar4 operator.yzzz(uchar3 v) {
>+    uchar4 result;
>+    result.x = v.y;
>+    result.y = v.z;
>+    result.z = v.z;
>+    result.w = v.z;
>+    return result;
>+}
>+uchar4 operator.yzzz(uchar4 v) {
>+    uchar4 result;
>+    result.x = v.y;
>+    result.y = v.z;
>+    result.z = v.z;
>+    result.w = v.z;
>+    return result;
>+}
>+ushort4 operator.yzzz(ushort3 v) {
>+    ushort4 result;
>+    result.x = v.y;
>+    result.y = v.z;
>+    result.z = v.z;
>+    result.w = v.z;
>+    return result;
>+}
>+ushort4 operator.yzzz(ushort4 v) {
>+    ushort4 result;
>+    result.x = v.y;
>+    result.y = v.z;
>+    result.z = v.z;
>+    result.w = v.z;
>+    return result;
>+}
>+uint4 operator.yzzz(uint3 v) {
>+    uint4 result;
>+    result.x = v.y;
>+    result.y = v.z;
>+    result.z = v.z;
>+    result.w = v.z;
>+    return result;
>+}
>+uint4 operator.yzzz(uint4 v) {
>+    uint4 result;
>+    result.x = v.y;
>+    result.y = v.z;
>+    result.z = v.z;
>+    result.w = v.z;
>+    return result;
>+}
>+char4 operator.yzzz(char3 v) {
>+    char4 result;
>+    result.x = v.y;
>+    result.y = v.z;
>+    result.z = v.z;
>+    result.w = v.z;
>+    return result;
>+}
>+char4 operator.yzzz(char4 v) {
>+    char4 result;
>+    result.x = v.y;
>+    result.y = v.z;
>+    result.z = v.z;
>+    result.w = v.z;
>+    return result;
>+}
>+short4 operator.yzzz(short3 v) {
>+    short4 result;
>+    result.x = v.y;
>+    result.y = v.z;
>+    result.z = v.z;
>+    result.w = v.z;
>+    return result;
>+}
>+short4 operator.yzzz(short4 v) {
>+    short4 result;
>+    result.x = v.y;
>+    result.y = v.z;
>+    result.z = v.z;
>+    result.w = v.z;
>+    return result;
>+}
>+int4 operator.yzzz(int3 v) {
>+    int4 result;
>+    result.x = v.y;
>+    result.y = v.z;
>+    result.z = v.z;
>+    result.w = v.z;
>+    return result;
>+}
>+int4 operator.yzzz(int4 v) {
>+    int4 result;
>+    result.x = v.y;
>+    result.y = v.z;
>+    result.z = v.z;
>+    result.w = v.z;
>+    return result;
>+}
>+half4 operator.yzzz(half3 v) {
>+    half4 result;
>+    result.x = v.y;
>+    result.y = v.z;
>+    result.z = v.z;
>+    result.w = v.z;
>+    return result;
>+}
>+half4 operator.yzzz(half4 v) {
>+    half4 result;
>+    result.x = v.y;
>+    result.y = v.z;
>+    result.z = v.z;
>+    result.w = v.z;
>+    return result;
>+}
>+float4 operator.yzzz(float3 v) {
>+    float4 result;
>+    result.x = v.y;
>+    result.y = v.z;
>+    result.z = v.z;
>+    result.w = v.z;
>+    return result;
>+}
>+float4 operator.yzzz(float4 v) {
>+    float4 result;
>+    result.x = v.y;
>+    result.y = v.z;
>+    result.z = v.z;
>+    result.w = v.z;
>+    return result;
>+}
>+
>+/* Functions named refract */
>+half refract(half i, half n, half eta) {
>+    half result;
>+    half k = 1 - eta * eta * (1 - dot(n, i) * dot(n, i));
>+    if (k < 0)
>+        return result;
>+    return eta * i - (eta * dot(n, i) + sqrt(k)) * n;
>+}
>+half2 refract(half2 i, half2 n, half eta) {
>+    half2 result;
>+    half k = 1 - eta * eta * (1 - dot(n, i) * dot(n, i));
>+    if (k < 0)
>+        return result;
>+    return eta * i - (eta * dot(n, i) + sqrt(k)) * n;
>+}
>+half3 refract(half3 i, half3 n, half eta) {
>+    half3 result;
>+    half k = 1 - eta * eta * (1 - dot(n, i) * dot(n, i));
>+    if (k < 0)
>+        return result;
>+    return eta * i - (eta * dot(n, i) + sqrt(k)) * n;
>+}
>+half4 refract(half4 i, half4 n, half eta) {
>+    half4 result;
>+    half k = 1 - eta * eta * (1 - dot(n, i) * dot(n, i));
>+    if (k < 0)
>+        return result;
>+    return eta * i - (eta * dot(n, i) + sqrt(k)) * n;
>+}
>+float refract(float i, float n, float eta) {
>+    float result;
>+    float k = 1 - eta * eta * (1 - dot(n, i) * dot(n, i));
>+    if (k < 0)
>+        return result;
>+    return eta * i - (eta * dot(n, i) + sqrt(k)) * n;
>+}
>+float2 refract(float2 i, float2 n, float eta) {
>+    float2 result;
>+    float k = 1 - eta * eta * (1 - dot(n, i) * dot(n, i));
>+    if (k < 0)
>+        return result;
>+    return eta * i - (eta * dot(n, i) + sqrt(k)) * n;
>+}
>+float3 refract(float3 i, float3 n, float eta) {
>+    float3 result;
>+    float k = 1 - eta * eta * (1 - dot(n, i) * dot(n, i));
>+    if (k < 0)
>+        return result;
>+    return eta * i - (eta * dot(n, i) + sqrt(k)) * n;
>+}
>+float4 refract(float4 i, float4 n, float eta) {
>+    float4 result;
>+    float k = 1 - eta * eta * (1 - dot(n, i) * dot(n, i));
>+    if (k < 0)
>+        return result;
>+    return eta * i - (eta * dot(n, i) + sqrt(k)) * n;
>+}
>+
>+
>+/* Functions named operator.zxyw */
>+bool4 operator.zxyw(bool4 v) {
>+    bool4 result;
>+    result.x = v.z;
>+    result.y = v.x;
>+    result.z = v.y;
>+    result.w = v.w;
>+    return result;
>+}
>+uchar4 operator.zxyw(uchar4 v) {
>+    uchar4 result;
>+    result.x = v.z;
>+    result.y = v.x;
>+    result.z = v.y;
>+    result.w = v.w;
>+    return result;
>+}
>+ushort4 operator.zxyw(ushort4 v) {
>+    ushort4 result;
>+    result.x = v.z;
>+    result.y = v.x;
>+    result.z = v.y;
>+    result.w = v.w;
>+    return result;
>+}
>+uint4 operator.zxyw(uint4 v) {
>+    uint4 result;
>+    result.x = v.z;
>+    result.y = v.x;
>+    result.z = v.y;
>+    result.w = v.w;
>+    return result;
>+}
>+char4 operator.zxyw(char4 v) {
>+    char4 result;
>+    result.x = v.z;
>+    result.y = v.x;
>+    result.z = v.y;
>+    result.w = v.w;
>+    return result;
>+}
>+short4 operator.zxyw(short4 v) {
>+    short4 result;
>+    result.x = v.z;
>+    result.y = v.x;
>+    result.z = v.y;
>+    result.w = v.w;
>+    return result;
>+}
>+int4 operator.zxyw(int4 v) {
>+    int4 result;
>+    result.x = v.z;
>+    result.y = v.x;
>+    result.z = v.y;
>+    result.w = v.w;
>+    return result;
>+}
>+half4 operator.zxyw(half4 v) {
>+    half4 result;
>+    result.x = v.z;
>+    result.y = v.x;
>+    result.z = v.y;
>+    result.w = v.w;
>+    return result;
>+}
>+float4 operator.zxyw(float4 v) {
>+    float4 result;
>+    result.x = v.z;
>+    result.y = v.x;
>+    result.z = v.y;
>+    result.w = v.w;
>+    return result;
>+}
>+
>+/* Functions named operator.wzw */
>+bool3 operator.wzw(bool4 v) {
>+    bool3 result;
>+    result.x = v.w;
>+    result.y = v.z;
>+    result.z = v.w;
>+    return result;
>+}
>+uchar3 operator.wzw(uchar4 v) {
>+    uchar3 result;
>+    result.x = v.w;
>+    result.y = v.z;
>+    result.z = v.w;
>+    return result;
>+}
>+ushort3 operator.wzw(ushort4 v) {
>+    ushort3 result;
>+    result.x = v.w;
>+    result.y = v.z;
>+    result.z = v.w;
>+    return result;
>+}
>+uint3 operator.wzw(uint4 v) {
>+    uint3 result;
>+    result.x = v.w;
>+    result.y = v.z;
>+    result.z = v.w;
>+    return result;
>+}
>+char3 operator.wzw(char4 v) {
>+    char3 result;
>+    result.x = v.w;
>+    result.y = v.z;
>+    result.z = v.w;
>+    return result;
>+}
>+short3 operator.wzw(short4 v) {
>+    short3 result;
>+    result.x = v.w;
>+    result.y = v.z;
>+    result.z = v.w;
>+    return result;
>+}
>+int3 operator.wzw(int4 v) {
>+    int3 result;
>+    result.x = v.w;
>+    result.y = v.z;
>+    result.z = v.w;
>+    return result;
>+}
>+half3 operator.wzw(half4 v) {
>+    half3 result;
>+    result.x = v.w;
>+    result.y = v.z;
>+    result.z = v.w;
>+    return result;
>+}
>+float3 operator.wzw(float4 v) {
>+    float3 result;
>+    result.x = v.w;
>+    result.y = v.z;
>+    result.z = v.w;
>+    return result;
>+}
>+
>+/* Functions named operator.zwzz */
>+bool4 operator.zwzz(bool4 v) {
>+    bool4 result;
>+    result.x = v.z;
>+    result.y = v.w;
>+    result.z = v.z;
>+    result.w = v.z;
>+    return result;
>+}
>+uchar4 operator.zwzz(uchar4 v) {
>+    uchar4 result;
>+    result.x = v.z;
>+    result.y = v.w;
>+    result.z = v.z;
>+    result.w = v.z;
>+    return result;
>+}
>+ushort4 operator.zwzz(ushort4 v) {
>+    ushort4 result;
>+    result.x = v.z;
>+    result.y = v.w;
>+    result.z = v.z;
>+    result.w = v.z;
>+    return result;
>+}
>+uint4 operator.zwzz(uint4 v) {
>+    uint4 result;
>+    result.x = v.z;
>+    result.y = v.w;
>+    result.z = v.z;
>+    result.w = v.z;
>+    return result;
>+}
>+char4 operator.zwzz(char4 v) {
>+    char4 result;
>+    result.x = v.z;
>+    result.y = v.w;
>+    result.z = v.z;
>+    result.w = v.z;
>+    return result;
>+}
>+short4 operator.zwzz(short4 v) {
>+    short4 result;
>+    result.x = v.z;
>+    result.y = v.w;
>+    result.z = v.z;
>+    result.w = v.z;
>+    return result;
>+}
>+int4 operator.zwzz(int4 v) {
>+    int4 result;
>+    result.x = v.z;
>+    result.y = v.w;
>+    result.z = v.z;
>+    result.w = v.z;
>+    return result;
>+}
>+half4 operator.zwzz(half4 v) {
>+    half4 result;
>+    result.x = v.z;
>+    result.y = v.w;
>+    result.z = v.z;
>+    result.w = v.z;
>+    return result;
>+}
>+float4 operator.zwzz(float4 v) {
>+    float4 result;
>+    result.x = v.z;
>+    result.y = v.w;
>+    result.z = v.z;
>+    result.w = v.z;
>+    return result;
>+}
>+
>+/* Functions named log10 */
>+half log10(half x) {
>+    return log(x) / log(half(10));
>+}
>+half2 log10(half2 x) {
>+    half2 result;
>+    result[0] = log10(x[0]);
>+    result[1] = log10(x[1]);
>+    return result;
>+}
>+half3 log10(half3 x) {
>+    half3 result;
>+    result[0] = log10(x[0]);
>+    result[1] = log10(x[1]);
>+    result[2] = log10(x[2]);
>+    return result;
>+}
>+half4 log10(half4 x) {
>+    half4 result;
>+    result[0] = log10(x[0]);
>+    result[1] = log10(x[1]);
>+    result[2] = log10(x[2]);
>+    result[3] = log10(x[3]);
>+    return result;
>+}
>+half2x2 log10(half2x2 x) {
>+    half2x2 result;
>+    result[0][0] = log10(x[0][0]);
>+    result[0][1] = log10(x[0][1]);
>+    result[1][0] = log10(x[1][0]);
>+    result[1][1] = log10(x[1][1]);
>+    return result;
>+}
>+half2x3 log10(half2x3 x) {
>+    half2x3 result;
>+    result[0][0] = log10(x[0][0]);
>+    result[0][1] = log10(x[0][1]);
>+    result[0][2] = log10(x[0][2]);
>+    result[1][0] = log10(x[1][0]);
>+    result[1][1] = log10(x[1][1]);
>+    result[1][2] = log10(x[1][2]);
>+    return result;
>+}
>+half2x4 log10(half2x4 x) {
>+    half2x4 result;
>+    result[0][0] = log10(x[0][0]);
>+    result[0][1] = log10(x[0][1]);
>+    result[0][2] = log10(x[0][2]);
>+    result[0][3] = log10(x[0][3]);
>+    result[1][0] = log10(x[1][0]);
>+    result[1][1] = log10(x[1][1]);
>+    result[1][2] = log10(x[1][2]);
>+    result[1][3] = log10(x[1][3]);
>+    return result;
>+}
>+half3x2 log10(half3x2 x) {
>+    half3x2 result;
>+    result[0][0] = log10(x[0][0]);
>+    result[0][1] = log10(x[0][1]);
>+    result[1][0] = log10(x[1][0]);
>+    result[1][1] = log10(x[1][1]);
>+    result[2][0] = log10(x[2][0]);
>+    result[2][1] = log10(x[2][1]);
>+    return result;
>+}
>+half3x3 log10(half3x3 x) {
>+    half3x3 result;
>+    result[0][0] = log10(x[0][0]);
>+    result[0][1] = log10(x[0][1]);
>+    result[0][2] = log10(x[0][2]);
>+    result[1][0] = log10(x[1][0]);
>+    result[1][1] = log10(x[1][1]);
>+    result[1][2] = log10(x[1][2]);
>+    result[2][0] = log10(x[2][0]);
>+    result[2][1] = log10(x[2][1]);
>+    result[2][2] = log10(x[2][2]);
>+    return result;
>+}
>+half3x4 log10(half3x4 x) {
>+    half3x4 result;
>+    result[0][0] = log10(x[0][0]);
>+    result[0][1] = log10(x[0][1]);
>+    result[0][2] = log10(x[0][2]);
>+    result[0][3] = log10(x[0][3]);
>+    result[1][0] = log10(x[1][0]);
>+    result[1][1] = log10(x[1][1]);
>+    result[1][2] = log10(x[1][2]);
>+    result[1][3] = log10(x[1][3]);
>+    result[2][0] = log10(x[2][0]);
>+    result[2][1] = log10(x[2][1]);
>+    result[2][2] = log10(x[2][2]);
>+    result[2][3] = log10(x[2][3]);
>+    return result;
>+}
>+half4x2 log10(half4x2 x) {
>+    half4x2 result;
>+    result[0][0] = log10(x[0][0]);
>+    result[0][1] = log10(x[0][1]);
>+    result[1][0] = log10(x[1][0]);
>+    result[1][1] = log10(x[1][1]);
>+    result[2][0] = log10(x[2][0]);
>+    result[2][1] = log10(x[2][1]);
>+    result[3][0] = log10(x[3][0]);
>+    result[3][1] = log10(x[3][1]);
>+    return result;
>+}
>+half4x3 log10(half4x3 x) {
>+    half4x3 result;
>+    result[0][0] = log10(x[0][0]);
>+    result[0][1] = log10(x[0][1]);
>+    result[0][2] = log10(x[0][2]);
>+    result[1][0] = log10(x[1][0]);
>+    result[1][1] = log10(x[1][1]);
>+    result[1][2] = log10(x[1][2]);
>+    result[2][0] = log10(x[2][0]);
>+    result[2][1] = log10(x[2][1]);
>+    result[2][2] = log10(x[2][2]);
>+    result[3][0] = log10(x[3][0]);
>+    result[3][1] = log10(x[3][1]);
>+    result[3][2] = log10(x[3][2]);
>+    return result;
>+}
>+half4x4 log10(half4x4 x) {
>+    half4x4 result;
>+    result[0][0] = log10(x[0][0]);
>+    result[0][1] = log10(x[0][1]);
>+    result[0][2] = log10(x[0][2]);
>+    result[0][3] = log10(x[0][3]);
>+    result[1][0] = log10(x[1][0]);
>+    result[1][1] = log10(x[1][1]);
>+    result[1][2] = log10(x[1][2]);
>+    result[1][3] = log10(x[1][3]);
>+    result[2][0] = log10(x[2][0]);
>+    result[2][1] = log10(x[2][1]);
>+    result[2][2] = log10(x[2][2]);
>+    result[2][3] = log10(x[2][3]);
>+    result[3][0] = log10(x[3][0]);
>+    result[3][1] = log10(x[3][1]);
>+    result[3][2] = log10(x[3][2]);
>+    result[3][3] = log10(x[3][3]);
>+    return result;
>+}
>+float log10(float x) {
>+    return log(x) / log(float(10));
>+}
>+float2 log10(float2 x) {
>+    float2 result;
>+    result[0] = log10(x[0]);
>+    result[1] = log10(x[1]);
>+    return result;
>+}
>+float3 log10(float3 x) {
>+    float3 result;
>+    result[0] = log10(x[0]);
>+    result[1] = log10(x[1]);
>+    result[2] = log10(x[2]);
>+    return result;
>+}
>+float4 log10(float4 x) {
>+    float4 result;
>+    result[0] = log10(x[0]);
>+    result[1] = log10(x[1]);
>+    result[2] = log10(x[2]);
>+    result[3] = log10(x[3]);
>+    return result;
>+}
>+float2x2 log10(float2x2 x) {
>+    float2x2 result;
>+    result[0][0] = log10(x[0][0]);
>+    result[0][1] = log10(x[0][1]);
>+    result[1][0] = log10(x[1][0]);
>+    result[1][1] = log10(x[1][1]);
>+    return result;
>+}
>+float2x3 log10(float2x3 x) {
>+    float2x3 result;
>+    result[0][0] = log10(x[0][0]);
>+    result[0][1] = log10(x[0][1]);
>+    result[0][2] = log10(x[0][2]);
>+    result[1][0] = log10(x[1][0]);
>+    result[1][1] = log10(x[1][1]);
>+    result[1][2] = log10(x[1][2]);
>+    return result;
>+}
>+float2x4 log10(float2x4 x) {
>+    float2x4 result;
>+    result[0][0] = log10(x[0][0]);
>+    result[0][1] = log10(x[0][1]);
>+    result[0][2] = log10(x[0][2]);
>+    result[0][3] = log10(x[0][3]);
>+    result[1][0] = log10(x[1][0]);
>+    result[1][1] = log10(x[1][1]);
>+    result[1][2] = log10(x[1][2]);
>+    result[1][3] = log10(x[1][3]);
>+    return result;
>+}
>+float3x2 log10(float3x2 x) {
>+    float3x2 result;
>+    result[0][0] = log10(x[0][0]);
>+    result[0][1] = log10(x[0][1]);
>+    result[1][0] = log10(x[1][0]);
>+    result[1][1] = log10(x[1][1]);
>+    result[2][0] = log10(x[2][0]);
>+    result[2][1] = log10(x[2][1]);
>+    return result;
>+}
>+float3x3 log10(float3x3 x) {
>+    float3x3 result;
>+    result[0][0] = log10(x[0][0]);
>+    result[0][1] = log10(x[0][1]);
>+    result[0][2] = log10(x[0][2]);
>+    result[1][0] = log10(x[1][0]);
>+    result[1][1] = log10(x[1][1]);
>+    result[1][2] = log10(x[1][2]);
>+    result[2][0] = log10(x[2][0]);
>+    result[2][1] = log10(x[2][1]);
>+    result[2][2] = log10(x[2][2]);
>+    return result;
>+}
>+float3x4 log10(float3x4 x) {
>+    float3x4 result;
>+    result[0][0] = log10(x[0][0]);
>+    result[0][1] = log10(x[0][1]);
>+    result[0][2] = log10(x[0][2]);
>+    result[0][3] = log10(x[0][3]);
>+    result[1][0] = log10(x[1][0]);
>+    result[1][1] = log10(x[1][1]);
>+    result[1][2] = log10(x[1][2]);
>+    result[1][3] = log10(x[1][3]);
>+    result[2][0] = log10(x[2][0]);
>+    result[2][1] = log10(x[2][1]);
>+    result[2][2] = log10(x[2][2]);
>+    result[2][3] = log10(x[2][3]);
>+    return result;
>+}
>+float4x2 log10(float4x2 x) {
>+    float4x2 result;
>+    result[0][0] = log10(x[0][0]);
>+    result[0][1] = log10(x[0][1]);
>+    result[1][0] = log10(x[1][0]);
>+    result[1][1] = log10(x[1][1]);
>+    result[2][0] = log10(x[2][0]);
>+    result[2][1] = log10(x[2][1]);
>+    result[3][0] = log10(x[3][0]);
>+    result[3][1] = log10(x[3][1]);
>+    return result;
>+}
>+float4x3 log10(float4x3 x) {
>+    float4x3 result;
>+    result[0][0] = log10(x[0][0]);
>+    result[0][1] = log10(x[0][1]);
>+    result[0][2] = log10(x[0][2]);
>+    result[1][0] = log10(x[1][0]);
>+    result[1][1] = log10(x[1][1]);
>+    result[1][2] = log10(x[1][2]);
>+    result[2][0] = log10(x[2][0]);
>+    result[2][1] = log10(x[2][1]);
>+    result[2][2] = log10(x[2][2]);
>+    result[3][0] = log10(x[3][0]);
>+    result[3][1] = log10(x[3][1]);
>+    result[3][2] = log10(x[3][2]);
>+    return result;
>+}
>+float4x4 log10(float4x4 x) {
>+    float4x4 result;
>+    result[0][0] = log10(x[0][0]);
>+    result[0][1] = log10(x[0][1]);
>+    result[0][2] = log10(x[0][2]);
>+    result[0][3] = log10(x[0][3]);
>+    result[1][0] = log10(x[1][0]);
>+    result[1][1] = log10(x[1][1]);
>+    result[1][2] = log10(x[1][2]);
>+    result[1][3] = log10(x[1][3]);
>+    result[2][0] = log10(x[2][0]);
>+    result[2][1] = log10(x[2][1]);
>+    result[2][2] = log10(x[2][2]);
>+    result[2][3] = log10(x[2][3]);
>+    result[3][0] = log10(x[3][0]);
>+    result[3][1] = log10(x[3][1]);
>+    result[3][2] = log10(x[3][2]);
>+    result[3][3] = log10(x[3][3]);
>+    return result;
>+}
>+
>+/* Functions named operator/ */
>+native int operator/(int, int);
>+native uint operator/(uint, uint);
>+native float operator/(float, float);
>+uchar operator/(uchar a, uchar b) {
>+    return uchar(uint(a) / uint(b));
>+}
>+ushort operator/(ushort a, ushort b) {
>+    return ushort(uint(a) / uint(b));
>+}
>+char operator/(char a, char b) {
>+    return char(int(a) / int(b));
>+}
>+short operator/(short a, short b) {
>+    return short(int(a) / int(b));
>+}
>+half operator/(half a, half b) {
>+    return half(float(a) / float(b));
>+}
>+uchar2 operator/(uchar2 a, uchar2 b) {
>+    uchar2 result;
>+    result[0] = a[0] / b[0];
>+    result[1] = a[1] / b[1];
>+    return result;
>+}
>+uchar2 operator/(uchar2 a, uchar b) {
>+    uchar2 result;
>+    result[0] = a[0] / b;
>+    result[1] = a[1] / b;
>+    return result;
>+}
>+uchar2 operator/(uchar a, uchar2 b) {
>+    uchar2 result;
>+    result[0] = a / b[0];
>+    result[1] = a / b[1];
>+    return result;
>+}
>+uchar3 operator/(uchar3 a, uchar3 b) {
>+    uchar3 result;
>+    result[0] = a[0] / b[0];
>+    result[1] = a[1] / b[1];
>+    result[2] = a[2] / b[2];
>+    return result;
>+}
>+uchar3 operator/(uchar3 a, uchar b) {
>+    uchar3 result;
>+    result[0] = a[0] / b;
>+    result[1] = a[1] / b;
>+    result[2] = a[2] / b;
>+    return result;
>+}
>+uchar3 operator/(uchar a, uchar3 b) {
>+    uchar3 result;
>+    result[0] = a / b[0];
>+    result[1] = a / b[1];
>+    result[2] = a / b[2];
>+    return result;
>+}
>+uchar4 operator/(uchar4 a, uchar4 b) {
>+    uchar4 result;
>+    result[0] = a[0] / b[0];
>+    result[1] = a[1] / b[1];
>+    result[2] = a[2] / b[2];
>+    result[3] = a[3] / b[3];
>+    return result;
>+}
>+uchar4 operator/(uchar4 a, uchar b) {
>+    uchar4 result;
>+    result[0] = a[0] / b;
>+    result[1] = a[1] / b;
>+    result[2] = a[2] / b;
>+    result[3] = a[3] / b;
>+    return result;
>+}
>+uchar4 operator/(uchar a, uchar4 b) {
>+    uchar4 result;
>+    result[0] = a / b[0];
>+    result[1] = a / b[1];
>+    result[2] = a / b[2];
>+    result[3] = a / b[3];
>+    return result;
>+}
>+ushort2 operator/(ushort2 a, ushort2 b) {
>+    ushort2 result;
>+    result[0] = a[0] / b[0];
>+    result[1] = a[1] / b[1];
>+    return result;
>+}
>+ushort2 operator/(ushort2 a, ushort b) {
>+    ushort2 result;
>+    result[0] = a[0] / b;
>+    result[1] = a[1] / b;
>+    return result;
>+}
>+ushort2 operator/(ushort a, ushort2 b) {
>+    ushort2 result;
>+    result[0] = a / b[0];
>+    result[1] = a / b[1];
>+    return result;
>+}
>+ushort3 operator/(ushort3 a, ushort3 b) {
>+    ushort3 result;
>+    result[0] = a[0] / b[0];
>+    result[1] = a[1] / b[1];
>+    result[2] = a[2] / b[2];
>+    return result;
>+}
>+ushort3 operator/(ushort3 a, ushort b) {
>+    ushort3 result;
>+    result[0] = a[0] / b;
>+    result[1] = a[1] / b;
>+    result[2] = a[2] / b;
>+    return result;
>+}
>+ushort3 operator/(ushort a, ushort3 b) {
>+    ushort3 result;
>+    result[0] = a / b[0];
>+    result[1] = a / b[1];
>+    result[2] = a / b[2];
>+    return result;
>+}
>+ushort4 operator/(ushort4 a, ushort4 b) {
>+    ushort4 result;
>+    result[0] = a[0] / b[0];
>+    result[1] = a[1] / b[1];
>+    result[2] = a[2] / b[2];
>+    result[3] = a[3] / b[3];
>+    return result;
>+}
>+ushort4 operator/(ushort4 a, ushort b) {
>+    ushort4 result;
>+    result[0] = a[0] / b;
>+    result[1] = a[1] / b;
>+    result[2] = a[2] / b;
>+    result[3] = a[3] / b;
>+    return result;
>+}
>+ushort4 operator/(ushort a, ushort4 b) {
>+    ushort4 result;
>+    result[0] = a / b[0];
>+    result[1] = a / b[1];
>+    result[2] = a / b[2];
>+    result[3] = a / b[3];
>+    return result;
>+}
>+uint2 operator/(uint2 a, uint2 b) {
>+    uint2 result;
>+    result[0] = a[0] / b[0];
>+    result[1] = a[1] / b[1];
>+    return result;
>+}
>+uint2 operator/(uint2 a, uint b) {
>+    uint2 result;
>+    result[0] = a[0] / b;
>+    result[1] = a[1] / b;
>+    return result;
>+}
>+uint2 operator/(uint a, uint2 b) {
>+    uint2 result;
>+    result[0] = a / b[0];
>+    result[1] = a / b[1];
>+    return result;
>+}
>+uint3 operator/(uint3 a, uint3 b) {
>+    uint3 result;
>+    result[0] = a[0] / b[0];
>+    result[1] = a[1] / b[1];
>+    result[2] = a[2] / b[2];
>+    return result;
>+}
>+uint3 operator/(uint3 a, uint b) {
>+    uint3 result;
>+    result[0] = a[0] / b;
>+    result[1] = a[1] / b;
>+    result[2] = a[2] / b;
>+    return result;
>+}
>+uint3 operator/(uint a, uint3 b) {
>+    uint3 result;
>+    result[0] = a / b[0];
>+    result[1] = a / b[1];
>+    result[2] = a / b[2];
>+    return result;
>+}
>+uint4 operator/(uint4 a, uint4 b) {
>+    uint4 result;
>+    result[0] = a[0] / b[0];
>+    result[1] = a[1] / b[1];
>+    result[2] = a[2] / b[2];
>+    result[3] = a[3] / b[3];
>+    return result;
>+}
>+uint4 operator/(uint4 a, uint b) {
>+    uint4 result;
>+    result[0] = a[0] / b;
>+    result[1] = a[1] / b;
>+    result[2] = a[2] / b;
>+    result[3] = a[3] / b;
>+    return result;
>+}
>+uint4 operator/(uint a, uint4 b) {
>+    uint4 result;
>+    result[0] = a / b[0];
>+    result[1] = a / b[1];
>+    result[2] = a / b[2];
>+    result[3] = a / b[3];
>+    return result;
>+}
>+char2 operator/(char2 a, char2 b) {
>+    char2 result;
>+    result[0] = a[0] / b[0];
>+    result[1] = a[1] / b[1];
>+    return result;
>+}
>+char2 operator/(char2 a, char b) {
>+    char2 result;
>+    result[0] = a[0] / b;
>+    result[1] = a[1] / b;
>+    return result;
>+}
>+char2 operator/(char a, char2 b) {
>+    char2 result;
>+    result[0] = a / b[0];
>+    result[1] = a / b[1];
>+    return result;
>+}
>+char3 operator/(char3 a, char3 b) {
>+    char3 result;
>+    result[0] = a[0] / b[0];
>+    result[1] = a[1] / b[1];
>+    result[2] = a[2] / b[2];
>+    return result;
>+}
>+char3 operator/(char3 a, char b) {
>+    char3 result;
>+    result[0] = a[0] / b;
>+    result[1] = a[1] / b;
>+    result[2] = a[2] / b;
>+    return result;
>+}
>+char3 operator/(char a, char3 b) {
>+    char3 result;
>+    result[0] = a / b[0];
>+    result[1] = a / b[1];
>+    result[2] = a / b[2];
>+    return result;
>+}
>+char4 operator/(char4 a, char4 b) {
>+    char4 result;
>+    result[0] = a[0] / b[0];
>+    result[1] = a[1] / b[1];
>+    result[2] = a[2] / b[2];
>+    result[3] = a[3] / b[3];
>+    return result;
>+}
>+char4 operator/(char4 a, char b) {
>+    char4 result;
>+    result[0] = a[0] / b;
>+    result[1] = a[1] / b;
>+    result[2] = a[2] / b;
>+    result[3] = a[3] / b;
>+    return result;
>+}
>+char4 operator/(char a, char4 b) {
>+    char4 result;
>+    result[0] = a / b[0];
>+    result[1] = a / b[1];
>+    result[2] = a / b[2];
>+    result[3] = a / b[3];
>+    return result;
>+}
>+short2 operator/(short2 a, short2 b) {
>+    short2 result;
>+    result[0] = a[0] / b[0];
>+    result[1] = a[1] / b[1];
>+    return result;
>+}
>+short2 operator/(short2 a, short b) {
>+    short2 result;
>+    result[0] = a[0] / b;
>+    result[1] = a[1] / b;
>+    return result;
>+}
>+short2 operator/(short a, short2 b) {
>+    short2 result;
>+    result[0] = a / b[0];
>+    result[1] = a / b[1];
>+    return result;
>+}
>+short3 operator/(short3 a, short3 b) {
>+    short3 result;
>+    result[0] = a[0] / b[0];
>+    result[1] = a[1] / b[1];
>+    result[2] = a[2] / b[2];
>+    return result;
>+}
>+short3 operator/(short3 a, short b) {
>+    short3 result;
>+    result[0] = a[0] / b;
>+    result[1] = a[1] / b;
>+    result[2] = a[2] / b;
>+    return result;
>+}
>+short3 operator/(short a, short3 b) {
>+    short3 result;
>+    result[0] = a / b[0];
>+    result[1] = a / b[1];
>+    result[2] = a / b[2];
>+    return result;
>+}
>+short4 operator/(short4 a, short4 b) {
>+    short4 result;
>+    result[0] = a[0] / b[0];
>+    result[1] = a[1] / b[1];
>+    result[2] = a[2] / b[2];
>+    result[3] = a[3] / b[3];
>+    return result;
>+}
>+short4 operator/(short4 a, short b) {
>+    short4 result;
>+    result[0] = a[0] / b;
>+    result[1] = a[1] / b;
>+    result[2] = a[2] / b;
>+    result[3] = a[3] / b;
>+    return result;
>+}
>+short4 operator/(short a, short4 b) {
>+    short4 result;
>+    result[0] = a / b[0];
>+    result[1] = a / b[1];
>+    result[2] = a / b[2];
>+    result[3] = a / b[3];
>+    return result;
>+}
>+int2 operator/(int2 a, int2 b) {
>+    int2 result;
>+    result[0] = a[0] / b[0];
>+    result[1] = a[1] / b[1];
>+    return result;
>+}
>+int2 operator/(int2 a, int b) {
>+    int2 result;
>+    result[0] = a[0] / b;
>+    result[1] = a[1] / b;
>+    return result;
>+}
>+int2 operator/(int a, int2 b) {
>+    int2 result;
>+    result[0] = a / b[0];
>+    result[1] = a / b[1];
>+    return result;
>+}
>+int3 operator/(int3 a, int3 b) {
>+    int3 result;
>+    result[0] = a[0] / b[0];
>+    result[1] = a[1] / b[1];
>+    result[2] = a[2] / b[2];
>+    return result;
>+}
>+int3 operator/(int3 a, int b) {
>+    int3 result;
>+    result[0] = a[0] / b;
>+    result[1] = a[1] / b;
>+    result[2] = a[2] / b;
>+    return result;
>+}
>+int3 operator/(int a, int3 b) {
>+    int3 result;
>+    result[0] = a / b[0];
>+    result[1] = a / b[1];
>+    result[2] = a / b[2];
>+    return result;
>+}
>+int4 operator/(int4 a, int4 b) {
>+    int4 result;
>+    result[0] = a[0] / b[0];
>+    result[1] = a[1] / b[1];
>+    result[2] = a[2] / b[2];
>+    result[3] = a[3] / b[3];
>+    return result;
>+}
>+int4 operator/(int4 a, int b) {
>+    int4 result;
>+    result[0] = a[0] / b;
>+    result[1] = a[1] / b;
>+    result[2] = a[2] / b;
>+    result[3] = a[3] / b;
>+    return result;
>+}
>+int4 operator/(int a, int4 b) {
>+    int4 result;
>+    result[0] = a / b[0];
>+    result[1] = a / b[1];
>+    result[2] = a / b[2];
>+    result[3] = a / b[3];
>+    return result;
>+}
>+half2 operator/(half2 a, half2 b) {
>+    half2 result;
>+    result[0] = a[0] / b[0];
>+    result[1] = a[1] / b[1];
>+    return result;
>+}
>+half2 operator/(half2 a, half b) {
>+    half2 result;
>+    result[0] = a[0] / b;
>+    result[1] = a[1] / b;
>+    return result;
>+}
>+half2 operator/(half a, half2 b) {
>+    half2 result;
>+    result[0] = a / b[0];
>+    result[1] = a / b[1];
>+    return result;
>+}
>+half3 operator/(half3 a, half3 b) {
>+    half3 result;
>+    result[0] = a[0] / b[0];
>+    result[1] = a[1] / b[1];
>+    result[2] = a[2] / b[2];
>+    return result;
>+}
>+half3 operator/(half3 a, half b) {
>+    half3 result;
>+    result[0] = a[0] / b;
>+    result[1] = a[1] / b;
>+    result[2] = a[2] / b;
>+    return result;
>+}
>+half3 operator/(half a, half3 b) {
>+    half3 result;
>+    result[0] = a / b[0];
>+    result[1] = a / b[1];
>+    result[2] = a / b[2];
>+    return result;
>+}
>+half4 operator/(half4 a, half4 b) {
>+    half4 result;
>+    result[0] = a[0] / b[0];
>+    result[1] = a[1] / b[1];
>+    result[2] = a[2] / b[2];
>+    result[3] = a[3] / b[3];
>+    return result;
>+}
>+half4 operator/(half4 a, half b) {
>+    half4 result;
>+    result[0] = a[0] / b;
>+    result[1] = a[1] / b;
>+    result[2] = a[2] / b;
>+    result[3] = a[3] / b;
>+    return result;
>+}
>+half4 operator/(half a, half4 b) {
>+    half4 result;
>+    result[0] = a / b[0];
>+    result[1] = a / b[1];
>+    result[2] = a / b[2];
>+    result[3] = a / b[3];
>+    return result;
>+}
>+float2 operator/(float2 a, float2 b) {
>+    float2 result;
>+    result[0] = a[0] / b[0];
>+    result[1] = a[1] / b[1];
>+    return result;
>+}
>+float2 operator/(float2 a, float b) {
>+    float2 result;
>+    result[0] = a[0] / b;
>+    result[1] = a[1] / b;
>+    return result;
>+}
>+float2 operator/(float a, float2 b) {
>+    float2 result;
>+    result[0] = a / b[0];
>+    result[1] = a / b[1];
>+    return result;
>+}
>+float3 operator/(float3 a, float3 b) {
>+    float3 result;
>+    result[0] = a[0] / b[0];
>+    result[1] = a[1] / b[1];
>+    result[2] = a[2] / b[2];
>+    return result;
>+}
>+float3 operator/(float3 a, float b) {
>+    float3 result;
>+    result[0] = a[0] / b;
>+    result[1] = a[1] / b;
>+    result[2] = a[2] / b;
>+    return result;
>+}
>+float3 operator/(float a, float3 b) {
>+    float3 result;
>+    result[0] = a / b[0];
>+    result[1] = a / b[1];
>+    result[2] = a / b[2];
>+    return result;
>+}
>+float4 operator/(float4 a, float4 b) {
>+    float4 result;
>+    result[0] = a[0] / b[0];
>+    result[1] = a[1] / b[1];
>+    result[2] = a[2] / b[2];
>+    result[3] = a[3] / b[3];
>+    return result;
>+}
>+float4 operator/(float4 a, float b) {
>+    float4 result;
>+    result[0] = a[0] / b;
>+    result[1] = a[1] / b;
>+    result[2] = a[2] / b;
>+    result[3] = a[3] / b;
>+    return result;
>+}
>+float4 operator/(float a, float4 b) {
>+    float4 result;
>+    result[0] = a / b[0];
>+    result[1] = a / b[1];
>+    result[2] = a / b[2];
>+    result[3] = a / b[3];
>+    return result;
>+}
>+half2x2 operator/(half2x2 a, half2x2 b) {
>+    half2x2 result;
>+    result[0][0] = a[0][0] / b[0][0];
>+    result[0][1] = a[0][1] / b[0][1];
>+    result[1][0] = a[1][0] / b[1][0];
>+    result[1][1] = a[1][1] / b[1][1];
>+    return result;
>+}
>+half2x2 operator/(half2x2 a, half b) {
>+    half2x2 result;
>+    result[0][0] = a[0][0] / b;
>+    result[0][1] = a[0][1] / b;
>+    result[1][0] = a[1][0] / b;
>+    result[1][1] = a[1][1] / b;
>+    return result;
>+}
>+half2x2 operator/(half a, half2x2 b) {
>+    half2x2 result;
>+    result[0][0] = a / b[0][0];
>+    result[0][1] = a / b[0][1];
>+    result[1][0] = a / b[1][0];
>+    result[1][1] = a / b[1][1];
>+    return result;
>+}
>+half2x3 operator/(half2x3 a, half2x3 b) {
>+    half2x3 result;
>+    result[0][0] = a[0][0] / b[0][0];
>+    result[0][1] = a[0][1] / b[0][1];
>+    result[0][2] = a[0][2] / b[0][2];
>+    result[1][0] = a[1][0] / b[1][0];
>+    result[1][1] = a[1][1] / b[1][1];
>+    result[1][2] = a[1][2] / b[1][2];
>+    return result;
>+}
>+half2x3 operator/(half2x3 a, half b) {
>+    half2x3 result;
>+    result[0][0] = a[0][0] / b;
>+    result[0][1] = a[0][1] / b;
>+    result[0][2] = a[0][2] / b;
>+    result[1][0] = a[1][0] / b;
>+    result[1][1] = a[1][1] / b;
>+    result[1][2] = a[1][2] / b;
>+    return result;
>+}
>+half2x3 operator/(half a, half2x3 b) {
>+    half2x3 result;
>+    result[0][0] = a / b[0][0];
>+    result[0][1] = a / b[0][1];
>+    result[0][2] = a / b[0][2];
>+    result[1][0] = a / b[1][0];
>+    result[1][1] = a / b[1][1];
>+    result[1][2] = a / b[1][2];
>+    return result;
>+}
>+half2x4 operator/(half2x4 a, half2x4 b) {
>+    half2x4 result;
>+    result[0][0] = a[0][0] / b[0][0];
>+    result[0][1] = a[0][1] / b[0][1];
>+    result[0][2] = a[0][2] / b[0][2];
>+    result[0][3] = a[0][3] / b[0][3];
>+    result[1][0] = a[1][0] / b[1][0];
>+    result[1][1] = a[1][1] / b[1][1];
>+    result[1][2] = a[1][2] / b[1][2];
>+    result[1][3] = a[1][3] / b[1][3];
>+    return result;
>+}
>+half2x4 operator/(half2x4 a, half b) {
>+    half2x4 result;
>+    result[0][0] = a[0][0] / b;
>+    result[0][1] = a[0][1] / b;
>+    result[0][2] = a[0][2] / b;
>+    result[0][3] = a[0][3] / b;
>+    result[1][0] = a[1][0] / b;
>+    result[1][1] = a[1][1] / b;
>+    result[1][2] = a[1][2] / b;
>+    result[1][3] = a[1][3] / b;
>+    return result;
>+}
>+half2x4 operator/(half a, half2x4 b) {
>+    half2x4 result;
>+    result[0][0] = a / b[0][0];
>+    result[0][1] = a / b[0][1];
>+    result[0][2] = a / b[0][2];
>+    result[0][3] = a / b[0][3];
>+    result[1][0] = a / b[1][0];
>+    result[1][1] = a / b[1][1];
>+    result[1][2] = a / b[1][2];
>+    result[1][3] = a / b[1][3];
>+    return result;
>+}
>+half3x2 operator/(half3x2 a, half3x2 b) {
>+    half3x2 result;
>+    result[0][0] = a[0][0] / b[0][0];
>+    result[0][1] = a[0][1] / b[0][1];
>+    result[1][0] = a[1][0] / b[1][0];
>+    result[1][1] = a[1][1] / b[1][1];
>+    result[2][0] = a[2][0] / b[2][0];
>+    result[2][1] = a[2][1] / b[2][1];
>+    return result;
>+}
>+half3x2 operator/(half3x2 a, half b) {
>+    half3x2 result;
>+    result[0][0] = a[0][0] / b;
>+    result[0][1] = a[0][1] / b;
>+    result[1][0] = a[1][0] / b;
>+    result[1][1] = a[1][1] / b;
>+    result[2][0] = a[2][0] / b;
>+    result[2][1] = a[2][1] / b;
>+    return result;
>+}
>+half3x2 operator/(half a, half3x2 b) {
>+    half3x2 result;
>+    result[0][0] = a / b[0][0];
>+    result[0][1] = a / b[0][1];
>+    result[1][0] = a / b[1][0];
>+    result[1][1] = a / b[1][1];
>+    result[2][0] = a / b[2][0];
>+    result[2][1] = a / b[2][1];
>+    return result;
>+}
>+half3x3 operator/(half3x3 a, half3x3 b) {
>+    half3x3 result;
>+    result[0][0] = a[0][0] / b[0][0];
>+    result[0][1] = a[0][1] / b[0][1];
>+    result[0][2] = a[0][2] / b[0][2];
>+    result[1][0] = a[1][0] / b[1][0];
>+    result[1][1] = a[1][1] / b[1][1];
>+    result[1][2] = a[1][2] / b[1][2];
>+    result[2][0] = a[2][0] / b[2][0];
>+    result[2][1] = a[2][1] / b[2][1];
>+    result[2][2] = a[2][2] / b[2][2];
>+    return result;
>+}
>+half3x3 operator/(half3x3 a, half b) {
>+    half3x3 result;
>+    result[0][0] = a[0][0] / b;
>+    result[0][1] = a[0][1] / b;
>+    result[0][2] = a[0][2] / b;
>+    result[1][0] = a[1][0] / b;
>+    result[1][1] = a[1][1] / b;
>+    result[1][2] = a[1][2] / b;
>+    result[2][0] = a[2][0] / b;
>+    result[2][1] = a[2][1] / b;
>+    result[2][2] = a[2][2] / b;
>+    return result;
>+}
>+half3x3 operator/(half a, half3x3 b) {
>+    half3x3 result;
>+    result[0][0] = a / b[0][0];
>+    result[0][1] = a / b[0][1];
>+    result[0][2] = a / b[0][2];
>+    result[1][0] = a / b[1][0];
>+    result[1][1] = a / b[1][1];
>+    result[1][2] = a / b[1][2];
>+    result[2][0] = a / b[2][0];
>+    result[2][1] = a / b[2][1];
>+    result[2][2] = a / b[2][2];
>+    return result;
>+}
>+half3x4 operator/(half3x4 a, half3x4 b) {
>+    half3x4 result;
>+    result[0][0] = a[0][0] / b[0][0];
>+    result[0][1] = a[0][1] / b[0][1];
>+    result[0][2] = a[0][2] / b[0][2];
>+    result[0][3] = a[0][3] / b[0][3];
>+    result[1][0] = a[1][0] / b[1][0];
>+    result[1][1] = a[1][1] / b[1][1];
>+    result[1][2] = a[1][2] / b[1][2];
>+    result[1][3] = a[1][3] / b[1][3];
>+    result[2][0] = a[2][0] / b[2][0];
>+    result[2][1] = a[2][1] / b[2][1];
>+    result[2][2] = a[2][2] / b[2][2];
>+    result[2][3] = a[2][3] / b[2][3];
>+    return result;
>+}
>+half3x4 operator/(half3x4 a, half b) {
>+    half3x4 result;
>+    result[0][0] = a[0][0] / b;
>+    result[0][1] = a[0][1] / b;
>+    result[0][2] = a[0][2] / b;
>+    result[0][3] = a[0][3] / b;
>+    result[1][0] = a[1][0] / b;
>+    result[1][1] = a[1][1] / b;
>+    result[1][2] = a[1][2] / b;
>+    result[1][3] = a[1][3] / b;
>+    result[2][0] = a[2][0] / b;
>+    result[2][1] = a[2][1] / b;
>+    result[2][2] = a[2][2] / b;
>+    result[2][3] = a[2][3] / b;
>+    return result;
>+}
>+half3x4 operator/(half a, half3x4 b) {
>+    half3x4 result;
>+    result[0][0] = a / b[0][0];
>+    result[0][1] = a / b[0][1];
>+    result[0][2] = a / b[0][2];
>+    result[0][3] = a / b[0][3];
>+    result[1][0] = a / b[1][0];
>+    result[1][1] = a / b[1][1];
>+    result[1][2] = a / b[1][2];
>+    result[1][3] = a / b[1][3];
>+    result[2][0] = a / b[2][0];
>+    result[2][1] = a / b[2][1];
>+    result[2][2] = a / b[2][2];
>+    result[2][3] = a / b[2][3];
>+    return result;
>+}
>+half4x2 operator/(half4x2 a, half4x2 b) {
>+    half4x2 result;
>+    result[0][0] = a[0][0] / b[0][0];
>+    result[0][1] = a[0][1] / b[0][1];
>+    result[1][0] = a[1][0] / b[1][0];
>+    result[1][1] = a[1][1] / b[1][1];
>+    result[2][0] = a[2][0] / b[2][0];
>+    result[2][1] = a[2][1] / b[2][1];
>+    result[3][0] = a[3][0] / b[3][0];
>+    result[3][1] = a[3][1] / b[3][1];
>+    return result;
>+}
>+half4x2 operator/(half4x2 a, half b) {
>+    half4x2 result;
>+    result[0][0] = a[0][0] / b;
>+    result[0][1] = a[0][1] / b;
>+    result[1][0] = a[1][0] / b;
>+    result[1][1] = a[1][1] / b;
>+    result[2][0] = a[2][0] / b;
>+    result[2][1] = a[2][1] / b;
>+    result[3][0] = a[3][0] / b;
>+    result[3][1] = a[3][1] / b;
>+    return result;
>+}
>+half4x2 operator/(half a, half4x2 b) {
>+    half4x2 result;
>+    result[0][0] = a / b[0][0];
>+    result[0][1] = a / b[0][1];
>+    result[1][0] = a / b[1][0];
>+    result[1][1] = a / b[1][1];
>+    result[2][0] = a / b[2][0];
>+    result[2][1] = a / b[2][1];
>+    result[3][0] = a / b[3][0];
>+    result[3][1] = a / b[3][1];
>+    return result;
>+}
>+half4x3 operator/(half4x3 a, half4x3 b) {
>+    half4x3 result;
>+    result[0][0] = a[0][0] / b[0][0];
>+    result[0][1] = a[0][1] / b[0][1];
>+    result[0][2] = a[0][2] / b[0][2];
>+    result[1][0] = a[1][0] / b[1][0];
>+    result[1][1] = a[1][1] / b[1][1];
>+    result[1][2] = a[1][2] / b[1][2];
>+    result[2][0] = a[2][0] / b[2][0];
>+    result[2][1] = a[2][1] / b[2][1];
>+    result[2][2] = a[2][2] / b[2][2];
>+    result[3][0] = a[3][0] / b[3][0];
>+    result[3][1] = a[3][1] / b[3][1];
>+    result[3][2] = a[3][2] / b[3][2];
>+    return result;
>+}
>+half4x3 operator/(half4x3 a, half b) {
>+    half4x3 result;
>+    result[0][0] = a[0][0] / b;
>+    result[0][1] = a[0][1] / b;
>+    result[0][2] = a[0][2] / b;
>+    result[1][0] = a[1][0] / b;
>+    result[1][1] = a[1][1] / b;
>+    result[1][2] = a[1][2] / b;
>+    result[2][0] = a[2][0] / b;
>+    result[2][1] = a[2][1] / b;
>+    result[2][2] = a[2][2] / b;
>+    result[3][0] = a[3][0] / b;
>+    result[3][1] = a[3][1] / b;
>+    result[3][2] = a[3][2] / b;
>+    return result;
>+}
>+half4x3 operator/(half a, half4x3 b) {
>+    half4x3 result;
>+    result[0][0] = a / b[0][0];
>+    result[0][1] = a / b[0][1];
>+    result[0][2] = a / b[0][2];
>+    result[1][0] = a / b[1][0];
>+    result[1][1] = a / b[1][1];
>+    result[1][2] = a / b[1][2];
>+    result[2][0] = a / b[2][0];
>+    result[2][1] = a / b[2][1];
>+    result[2][2] = a / b[2][2];
>+    result[3][0] = a / b[3][0];
>+    result[3][1] = a / b[3][1];
>+    result[3][2] = a / b[3][2];
>+    return result;
>+}
>+half4x4 operator/(half4x4 a, half4x4 b) {
>+    half4x4 result;
>+    result[0][0] = a[0][0] / b[0][0];
>+    result[0][1] = a[0][1] / b[0][1];
>+    result[0][2] = a[0][2] / b[0][2];
>+    result[0][3] = a[0][3] / b[0][3];
>+    result[1][0] = a[1][0] / b[1][0];
>+    result[1][1] = a[1][1] / b[1][1];
>+    result[1][2] = a[1][2] / b[1][2];
>+    result[1][3] = a[1][3] / b[1][3];
>+    result[2][0] = a[2][0] / b[2][0];
>+    result[2][1] = a[2][1] / b[2][1];
>+    result[2][2] = a[2][2] / b[2][2];
>+    result[2][3] = a[2][3] / b[2][3];
>+    result[3][0] = a[3][0] / b[3][0];
>+    result[3][1] = a[3][1] / b[3][1];
>+    result[3][2] = a[3][2] / b[3][2];
>+    result[3][3] = a[3][3] / b[3][3];
>+    return result;
>+}
>+half4x4 operator/(half4x4 a, half b) {
>+    half4x4 result;
>+    result[0][0] = a[0][0] / b;
>+    result[0][1] = a[0][1] / b;
>+    result[0][2] = a[0][2] / b;
>+    result[0][3] = a[0][3] / b;
>+    result[1][0] = a[1][0] / b;
>+    result[1][1] = a[1][1] / b;
>+    result[1][2] = a[1][2] / b;
>+    result[1][3] = a[1][3] / b;
>+    result[2][0] = a[2][0] / b;
>+    result[2][1] = a[2][1] / b;
>+    result[2][2] = a[2][2] / b;
>+    result[2][3] = a[2][3] / b;
>+    result[3][0] = a[3][0] / b;
>+    result[3][1] = a[3][1] / b;
>+    result[3][2] = a[3][2] / b;
>+    result[3][3] = a[3][3] / b;
>+    return result;
>+}
>+half4x4 operator/(half a, half4x4 b) {
>+    half4x4 result;
>+    result[0][0] = a / b[0][0];
>+    result[0][1] = a / b[0][1];
>+    result[0][2] = a / b[0][2];
>+    result[0][3] = a / b[0][3];
>+    result[1][0] = a / b[1][0];
>+    result[1][1] = a / b[1][1];
>+    result[1][2] = a / b[1][2];
>+    result[1][3] = a / b[1][3];
>+    result[2][0] = a / b[2][0];
>+    result[2][1] = a / b[2][1];
>+    result[2][2] = a / b[2][2];
>+    result[2][3] = a / b[2][3];
>+    result[3][0] = a / b[3][0];
>+    result[3][1] = a / b[3][1];
>+    result[3][2] = a / b[3][2];
>+    result[3][3] = a / b[3][3];
>+    return result;
>+}
>+float2x2 operator/(float2x2 a, float2x2 b) {
>+    float2x2 result;
>+    result[0][0] = a[0][0] / b[0][0];
>+    result[0][1] = a[0][1] / b[0][1];
>+    result[1][0] = a[1][0] / b[1][0];
>+    result[1][1] = a[1][1] / b[1][1];
>+    return result;
>+}
>+float2x2 operator/(float2x2 a, float b) {
>+    float2x2 result;
>+    result[0][0] = a[0][0] / b;
>+    result[0][1] = a[0][1] / b;
>+    result[1][0] = a[1][0] / b;
>+    result[1][1] = a[1][1] / b;
>+    return result;
>+}
>+float2x2 operator/(float a, float2x2 b) {
>+    float2x2 result;
>+    result[0][0] = a / b[0][0];
>+    result[0][1] = a / b[0][1];
>+    result[1][0] = a / b[1][0];
>+    result[1][1] = a / b[1][1];
>+    return result;
>+}
>+float2x3 operator/(float2x3 a, float2x3 b) {
>+    float2x3 result;
>+    result[0][0] = a[0][0] / b[0][0];
>+    result[0][1] = a[0][1] / b[0][1];
>+    result[0][2] = a[0][2] / b[0][2];
>+    result[1][0] = a[1][0] / b[1][0];
>+    result[1][1] = a[1][1] / b[1][1];
>+    result[1][2] = a[1][2] / b[1][2];
>+    return result;
>+}
>+float2x3 operator/(float2x3 a, float b) {
>+    float2x3 result;
>+    result[0][0] = a[0][0] / b;
>+    result[0][1] = a[0][1] / b;
>+    result[0][2] = a[0][2] / b;
>+    result[1][0] = a[1][0] / b;
>+    result[1][1] = a[1][1] / b;
>+    result[1][2] = a[1][2] / b;
>+    return result;
>+}
>+float2x3 operator/(float a, float2x3 b) {
>+    float2x3 result;
>+    result[0][0] = a / b[0][0];
>+    result[0][1] = a / b[0][1];
>+    result[0][2] = a / b[0][2];
>+    result[1][0] = a / b[1][0];
>+    result[1][1] = a / b[1][1];
>+    result[1][2] = a / b[1][2];
>+    return result;
>+}
>+float2x4 operator/(float2x4 a, float2x4 b) {
>+    float2x4 result;
>+    result[0][0] = a[0][0] / b[0][0];
>+    result[0][1] = a[0][1] / b[0][1];
>+    result[0][2] = a[0][2] / b[0][2];
>+    result[0][3] = a[0][3] / b[0][3];
>+    result[1][0] = a[1][0] / b[1][0];
>+    result[1][1] = a[1][1] / b[1][1];
>+    result[1][2] = a[1][2] / b[1][2];
>+    result[1][3] = a[1][3] / b[1][3];
>+    return result;
>+}
>+float2x4 operator/(float2x4 a, float b) {
>+    float2x4 result;
>+    result[0][0] = a[0][0] / b;
>+    result[0][1] = a[0][1] / b;
>+    result[0][2] = a[0][2] / b;
>+    result[0][3] = a[0][3] / b;
>+    result[1][0] = a[1][0] / b;
>+    result[1][1] = a[1][1] / b;
>+    result[1][2] = a[1][2] / b;
>+    result[1][3] = a[1][3] / b;
>+    return result;
>+}
>+float2x4 operator/(float a, float2x4 b) {
>+    float2x4 result;
>+    result[0][0] = a / b[0][0];
>+    result[0][1] = a / b[0][1];
>+    result[0][2] = a / b[0][2];
>+    result[0][3] = a / b[0][3];
>+    result[1][0] = a / b[1][0];
>+    result[1][1] = a / b[1][1];
>+    result[1][2] = a / b[1][2];
>+    result[1][3] = a / b[1][3];
>+    return result;
>+}
>+float3x2 operator/(float3x2 a, float3x2 b) {
>+    float3x2 result;
>+    result[0][0] = a[0][0] / b[0][0];
>+    result[0][1] = a[0][1] / b[0][1];
>+    result[1][0] = a[1][0] / b[1][0];
>+    result[1][1] = a[1][1] / b[1][1];
>+    result[2][0] = a[2][0] / b[2][0];
>+    result[2][1] = a[2][1] / b[2][1];
>+    return result;
>+}
>+float3x2 operator/(float3x2 a, float b) {
>+    float3x2 result;
>+    result[0][0] = a[0][0] / b;
>+    result[0][1] = a[0][1] / b;
>+    result[1][0] = a[1][0] / b;
>+    result[1][1] = a[1][1] / b;
>+    result[2][0] = a[2][0] / b;
>+    result[2][1] = a[2][1] / b;
>+    return result;
>+}
>+float3x2 operator/(float a, float3x2 b) {
>+    float3x2 result;
>+    result[0][0] = a / b[0][0];
>+    result[0][1] = a / b[0][1];
>+    result[1][0] = a / b[1][0];
>+    result[1][1] = a / b[1][1];
>+    result[2][0] = a / b[2][0];
>+    result[2][1] = a / b[2][1];
>+    return result;
>+}
>+float3x3 operator/(float3x3 a, float3x3 b) {
>+    float3x3 result;
>+    result[0][0] = a[0][0] / b[0][0];
>+    result[0][1] = a[0][1] / b[0][1];
>+    result[0][2] = a[0][2] / b[0][2];
>+    result[1][0] = a[1][0] / b[1][0];
>+    result[1][1] = a[1][1] / b[1][1];
>+    result[1][2] = a[1][2] / b[1][2];
>+    result[2][0] = a[2][0] / b[2][0];
>+    result[2][1] = a[2][1] / b[2][1];
>+    result[2][2] = a[2][2] / b[2][2];
>+    return result;
>+}
>+float3x3 operator/(float3x3 a, float b) {
>+    float3x3 result;
>+    result[0][0] = a[0][0] / b;
>+    result[0][1] = a[0][1] / b;
>+    result[0][2] = a[0][2] / b;
>+    result[1][0] = a[1][0] / b;
>+    result[1][1] = a[1][1] / b;
>+    result[1][2] = a[1][2] / b;
>+    result[2][0] = a[2][0] / b;
>+    result[2][1] = a[2][1] / b;
>+    result[2][2] = a[2][2] / b;
>+    return result;
>+}
>+float3x3 operator/(float a, float3x3 b) {
>+    float3x3 result;
>+    result[0][0] = a / b[0][0];
>+    result[0][1] = a / b[0][1];
>+    result[0][2] = a / b[0][2];
>+    result[1][0] = a / b[1][0];
>+    result[1][1] = a / b[1][1];
>+    result[1][2] = a / b[1][2];
>+    result[2][0] = a / b[2][0];
>+    result[2][1] = a / b[2][1];
>+    result[2][2] = a / b[2][2];
>+    return result;
>+}
>+float3x4 operator/(float3x4 a, float3x4 b) {
>+    float3x4 result;
>+    result[0][0] = a[0][0] / b[0][0];
>+    result[0][1] = a[0][1] / b[0][1];
>+    result[0][2] = a[0][2] / b[0][2];
>+    result[0][3] = a[0][3] / b[0][3];
>+    result[1][0] = a[1][0] / b[1][0];
>+    result[1][1] = a[1][1] / b[1][1];
>+    result[1][2] = a[1][2] / b[1][2];
>+    result[1][3] = a[1][3] / b[1][3];
>+    result[2][0] = a[2][0] / b[2][0];
>+    result[2][1] = a[2][1] / b[2][1];
>+    result[2][2] = a[2][2] / b[2][2];
>+    result[2][3] = a[2][3] / b[2][3];
>+    return result;
>+}
>+float3x4 operator/(float3x4 a, float b) {
>+    float3x4 result;
>+    result[0][0] = a[0][0] / b;
>+    result[0][1] = a[0][1] / b;
>+    result[0][2] = a[0][2] / b;
>+    result[0][3] = a[0][3] / b;
>+    result[1][0] = a[1][0] / b;
>+    result[1][1] = a[1][1] / b;
>+    result[1][2] = a[1][2] / b;
>+    result[1][3] = a[1][3] / b;
>+    result[2][0] = a[2][0] / b;
>+    result[2][1] = a[2][1] / b;
>+    result[2][2] = a[2][2] / b;
>+    result[2][3] = a[2][3] / b;
>+    return result;
>+}
>+float3x4 operator/(float a, float3x4 b) {
>+    float3x4 result;
>+    result[0][0] = a / b[0][0];
>+    result[0][1] = a / b[0][1];
>+    result[0][2] = a / b[0][2];
>+    result[0][3] = a / b[0][3];
>+    result[1][0] = a / b[1][0];
>+    result[1][1] = a / b[1][1];
>+    result[1][2] = a / b[1][2];
>+    result[1][3] = a / b[1][3];
>+    result[2][0] = a / b[2][0];
>+    result[2][1] = a / b[2][1];
>+    result[2][2] = a / b[2][2];
>+    result[2][3] = a / b[2][3];
>+    return result;
>+}
>+float4x2 operator/(float4x2 a, float4x2 b) {
>+    float4x2 result;
>+    result[0][0] = a[0][0] / b[0][0];
>+    result[0][1] = a[0][1] / b[0][1];
>+    result[1][0] = a[1][0] / b[1][0];
>+    result[1][1] = a[1][1] / b[1][1];
>+    result[2][0] = a[2][0] / b[2][0];
>+    result[2][1] = a[2][1] / b[2][1];
>+    result[3][0] = a[3][0] / b[3][0];
>+    result[3][1] = a[3][1] / b[3][1];
>+    return result;
>+}
>+float4x2 operator/(float4x2 a, float b) {
>+    float4x2 result;
>+    result[0][0] = a[0][0] / b;
>+    result[0][1] = a[0][1] / b;
>+    result[1][0] = a[1][0] / b;
>+    result[1][1] = a[1][1] / b;
>+    result[2][0] = a[2][0] / b;
>+    result[2][1] = a[2][1] / b;
>+    result[3][0] = a[3][0] / b;
>+    result[3][1] = a[3][1] / b;
>+    return result;
>+}
>+float4x2 operator/(float a, float4x2 b) {
>+    float4x2 result;
>+    result[0][0] = a / b[0][0];
>+    result[0][1] = a / b[0][1];
>+    result[1][0] = a / b[1][0];
>+    result[1][1] = a / b[1][1];
>+    result[2][0] = a / b[2][0];
>+    result[2][1] = a / b[2][1];
>+    result[3][0] = a / b[3][0];
>+    result[3][1] = a / b[3][1];
>+    return result;
>+}
>+float4x3 operator/(float4x3 a, float4x3 b) {
>+    float4x3 result;
>+    result[0][0] = a[0][0] / b[0][0];
>+    result[0][1] = a[0][1] / b[0][1];
>+    result[0][2] = a[0][2] / b[0][2];
>+    result[1][0] = a[1][0] / b[1][0];
>+    result[1][1] = a[1][1] / b[1][1];
>+    result[1][2] = a[1][2] / b[1][2];
>+    result[2][0] = a[2][0] / b[2][0];
>+    result[2][1] = a[2][1] / b[2][1];
>+    result[2][2] = a[2][2] / b[2][2];
>+    result[3][0] = a[3][0] / b[3][0];
>+    result[3][1] = a[3][1] / b[3][1];
>+    result[3][2] = a[3][2] / b[3][2];
>+    return result;
>+}
>+float4x3 operator/(float4x3 a, float b) {
>+    float4x3 result;
>+    result[0][0] = a[0][0] / b;
>+    result[0][1] = a[0][1] / b;
>+    result[0][2] = a[0][2] / b;
>+    result[1][0] = a[1][0] / b;
>+    result[1][1] = a[1][1] / b;
>+    result[1][2] = a[1][2] / b;
>+    result[2][0] = a[2][0] / b;
>+    result[2][1] = a[2][1] / b;
>+    result[2][2] = a[2][2] / b;
>+    result[3][0] = a[3][0] / b;
>+    result[3][1] = a[3][1] / b;
>+    result[3][2] = a[3][2] / b;
>+    return result;
>+}
>+float4x3 operator/(float a, float4x3 b) {
>+    float4x3 result;
>+    result[0][0] = a / b[0][0];
>+    result[0][1] = a / b[0][1];
>+    result[0][2] = a / b[0][2];
>+    result[1][0] = a / b[1][0];
>+    result[1][1] = a / b[1][1];
>+    result[1][2] = a / b[1][2];
>+    result[2][0] = a / b[2][0];
>+    result[2][1] = a / b[2][1];
>+    result[2][2] = a / b[2][2];
>+    result[3][0] = a / b[3][0];
>+    result[3][1] = a / b[3][1];
>+    result[3][2] = a / b[3][2];
>+    return result;
>+}
>+float4x4 operator/(float4x4 a, float4x4 b) {
>+    float4x4 result;
>+    result[0][0] = a[0][0] / b[0][0];
>+    result[0][1] = a[0][1] / b[0][1];
>+    result[0][2] = a[0][2] / b[0][2];
>+    result[0][3] = a[0][3] / b[0][3];
>+    result[1][0] = a[1][0] / b[1][0];
>+    result[1][1] = a[1][1] / b[1][1];
>+    result[1][2] = a[1][2] / b[1][2];
>+    result[1][3] = a[1][3] / b[1][3];
>+    result[2][0] = a[2][0] / b[2][0];
>+    result[2][1] = a[2][1] / b[2][1];
>+    result[2][2] = a[2][2] / b[2][2];
>+    result[2][3] = a[2][3] / b[2][3];
>+    result[3][0] = a[3][0] / b[3][0];
>+    result[3][1] = a[3][1] / b[3][1];
>+    result[3][2] = a[3][2] / b[3][2];
>+    result[3][3] = a[3][3] / b[3][3];
>+    return result;
>+}
>+float4x4 operator/(float4x4 a, float b) {
>+    float4x4 result;
>+    result[0][0] = a[0][0] / b;
>+    result[0][1] = a[0][1] / b;
>+    result[0][2] = a[0][2] / b;
>+    result[0][3] = a[0][3] / b;
>+    result[1][0] = a[1][0] / b;
>+    result[1][1] = a[1][1] / b;
>+    result[1][2] = a[1][2] / b;
>+    result[1][3] = a[1][3] / b;
>+    result[2][0] = a[2][0] / b;
>+    result[2][1] = a[2][1] / b;
>+    result[2][2] = a[2][2] / b;
>+    result[2][3] = a[2][3] / b;
>+    result[3][0] = a[3][0] / b;
>+    result[3][1] = a[3][1] / b;
>+    result[3][2] = a[3][2] / b;
>+    result[3][3] = a[3][3] / b;
>+    return result;
>+}
>+float4x4 operator/(float a, float4x4 b) {
>+    float4x4 result;
>+    result[0][0] = a / b[0][0];
>+    result[0][1] = a / b[0][1];
>+    result[0][2] = a / b[0][2];
>+    result[0][3] = a / b[0][3];
>+    result[1][0] = a / b[1][0];
>+    result[1][1] = a / b[1][1];
>+    result[1][2] = a / b[1][2];
>+    result[1][3] = a / b[1][3];
>+    result[2][0] = a / b[2][0];
>+    result[2][1] = a / b[2][1];
>+    result[2][2] = a / b[2][2];
>+    result[2][3] = a / b[2][3];
>+    result[3][0] = a / b[3][0];
>+    result[3][1] = a / b[3][1];
>+    result[3][2] = a / b[3][2];
>+    result[3][3] = a / b[3][3];
>+    return result;
>+}
>+
>+/* Functions named operator.xwzx */
>+bool4 operator.xwzx(bool4 v) {
>+    bool4 result;
>+    result.x = v.x;
>+    result.y = v.w;
>+    result.z = v.z;
>+    result.w = v.x;
>+    return result;
>+}
>+uchar4 operator.xwzx(uchar4 v) {
>+    uchar4 result;
>+    result.x = v.x;
>+    result.y = v.w;
>+    result.z = v.z;
>+    result.w = v.x;
>+    return result;
>+}
>+ushort4 operator.xwzx(ushort4 v) {
>+    ushort4 result;
>+    result.x = v.x;
>+    result.y = v.w;
>+    result.z = v.z;
>+    result.w = v.x;
>+    return result;
>+}
>+uint4 operator.xwzx(uint4 v) {
>+    uint4 result;
>+    result.x = v.x;
>+    result.y = v.w;
>+    result.z = v.z;
>+    result.w = v.x;
>+    return result;
>+}
>+char4 operator.xwzx(char4 v) {
>+    char4 result;
>+    result.x = v.x;
>+    result.y = v.w;
>+    result.z = v.z;
>+    result.w = v.x;
>+    return result;
>+}
>+short4 operator.xwzx(short4 v) {
>+    short4 result;
>+    result.x = v.x;
>+    result.y = v.w;
>+    result.z = v.z;
>+    result.w = v.x;
>+    return result;
>+}
>+int4 operator.xwzx(int4 v) {
>+    int4 result;
>+    result.x = v.x;
>+    result.y = v.w;
>+    result.z = v.z;
>+    result.w = v.x;
>+    return result;
>+}
>+half4 operator.xwzx(half4 v) {
>+    half4 result;
>+    result.x = v.x;
>+    result.y = v.w;
>+    result.z = v.z;
>+    result.w = v.x;
>+    return result;
>+}
>+float4 operator.xwzx(float4 v) {
>+    float4 result;
>+    result.x = v.x;
>+    result.y = v.w;
>+    result.z = v.z;
>+    result.w = v.x;
>+    return result;
>+}
>+
>+/* Functions named operator.zxww */
>+bool4 operator.zxww(bool4 v) {
>+    bool4 result;
>+    result.x = v.z;
>+    result.y = v.x;
>+    result.z = v.w;
>+    result.w = v.w;
>+    return result;
>+}
>+uchar4 operator.zxww(uchar4 v) {
>+    uchar4 result;
>+    result.x = v.z;
>+    result.y = v.x;
>+    result.z = v.w;
>+    result.w = v.w;
>+    return result;
>+}
>+ushort4 operator.zxww(ushort4 v) {
>+    ushort4 result;
>+    result.x = v.z;
>+    result.y = v.x;
>+    result.z = v.w;
>+    result.w = v.w;
>+    return result;
>+}
>+uint4 operator.zxww(uint4 v) {
>+    uint4 result;
>+    result.x = v.z;
>+    result.y = v.x;
>+    result.z = v.w;
>+    result.w = v.w;
>+    return result;
>+}
>+char4 operator.zxww(char4 v) {
>+    char4 result;
>+    result.x = v.z;
>+    result.y = v.x;
>+    result.z = v.w;
>+    result.w = v.w;
>+    return result;
>+}
>+short4 operator.zxww(short4 v) {
>+    short4 result;
>+    result.x = v.z;
>+    result.y = v.x;
>+    result.z = v.w;
>+    result.w = v.w;
>+    return result;
>+}
>+int4 operator.zxww(int4 v) {
>+    int4 result;
>+    result.x = v.z;
>+    result.y = v.x;
>+    result.z = v.w;
>+    result.w = v.w;
>+    return result;
>+}
>+half4 operator.zxww(half4 v) {
>+    half4 result;
>+    result.x = v.z;
>+    result.y = v.x;
>+    result.z = v.w;
>+    result.w = v.w;
>+    return result;
>+}
>+float4 operator.zxww(float4 v) {
>+    float4 result;
>+    result.x = v.z;
>+    result.y = v.x;
>+    result.z = v.w;
>+    result.w = v.w;
>+    return result;
>+}
>+
>+/* Functions named operator.wyzx */
>+bool4 operator.wyzx(bool4 v) {
>+    bool4 result;
>+    result.x = v.w;
>+    result.y = v.y;
>+    result.z = v.z;
>+    result.w = v.x;
>+    return result;
>+}
>+uchar4 operator.wyzx(uchar4 v) {
>+    uchar4 result;
>+    result.x = v.w;
>+    result.y = v.y;
>+    result.z = v.z;
>+    result.w = v.x;
>+    return result;
>+}
>+ushort4 operator.wyzx(ushort4 v) {
>+    ushort4 result;
>+    result.x = v.w;
>+    result.y = v.y;
>+    result.z = v.z;
>+    result.w = v.x;
>+    return result;
>+}
>+uint4 operator.wyzx(uint4 v) {
>+    uint4 result;
>+    result.x = v.w;
>+    result.y = v.y;
>+    result.z = v.z;
>+    result.w = v.x;
>+    return result;
>+}
>+char4 operator.wyzx(char4 v) {
>+    char4 result;
>+    result.x = v.w;
>+    result.y = v.y;
>+    result.z = v.z;
>+    result.w = v.x;
>+    return result;
>+}
>+short4 operator.wyzx(short4 v) {
>+    short4 result;
>+    result.x = v.w;
>+    result.y = v.y;
>+    result.z = v.z;
>+    result.w = v.x;
>+    return result;
>+}
>+int4 operator.wyzx(int4 v) {
>+    int4 result;
>+    result.x = v.w;
>+    result.y = v.y;
>+    result.z = v.z;
>+    result.w = v.x;
>+    return result;
>+}
>+half4 operator.wyzx(half4 v) {
>+    half4 result;
>+    result.x = v.w;
>+    result.y = v.y;
>+    result.z = v.z;
>+    result.w = v.x;
>+    return result;
>+}
>+float4 operator.wyzx(float4 v) {
>+    float4 result;
>+    result.x = v.w;
>+    result.y = v.y;
>+    result.z = v.z;
>+    result.w = v.x;
>+    return result;
>+}
>+
>+/* Functions named operator.wy */
>+bool2 operator.wy(bool4 v) {
>+    bool2 result;
>+    result.x = v.w;
>+    result.y = v.y;
>+    return result;
>+}
>+uchar2 operator.wy(uchar4 v) {
>+    uchar2 result;
>+    result.x = v.w;
>+    result.y = v.y;
>+    return result;
>+}
>+ushort2 operator.wy(ushort4 v) {
>+    ushort2 result;
>+    result.x = v.w;
>+    result.y = v.y;
>+    return result;
>+}
>+uint2 operator.wy(uint4 v) {
>+    uint2 result;
>+    result.x = v.w;
>+    result.y = v.y;
>+    return result;
>+}
>+char2 operator.wy(char4 v) {
>+    char2 result;
>+    result.x = v.w;
>+    result.y = v.y;
>+    return result;
>+}
>+short2 operator.wy(short4 v) {
>+    short2 result;
>+    result.x = v.w;
>+    result.y = v.y;
>+    return result;
>+}
>+int2 operator.wy(int4 v) {
>+    int2 result;
>+    result.x = v.w;
>+    result.y = v.y;
>+    return result;
>+}
>+half2 operator.wy(half4 v) {
>+    half2 result;
>+    result.x = v.w;
>+    result.y = v.y;
>+    return result;
>+}
>+float2 operator.wy(float4 v) {
>+    float2 result;
>+    result.x = v.w;
>+    result.y = v.y;
>+    return result;
>+}
>+
>+/* Functions named operator.wzyz */
>+bool4 operator.wzyz(bool4 v) {
>+    bool4 result;
>+    result.x = v.w;
>+    result.y = v.z;
>+    result.z = v.y;
>+    result.w = v.z;
>+    return result;
>+}
>+uchar4 operator.wzyz(uchar4 v) {
>+    uchar4 result;
>+    result.x = v.w;
>+    result.y = v.z;
>+    result.z = v.y;
>+    result.w = v.z;
>+    return result;
>+}
>+ushort4 operator.wzyz(ushort4 v) {
>+    ushort4 result;
>+    result.x = v.w;
>+    result.y = v.z;
>+    result.z = v.y;
>+    result.w = v.z;
>+    return result;
>+}
>+uint4 operator.wzyz(uint4 v) {
>+    uint4 result;
>+    result.x = v.w;
>+    result.y = v.z;
>+    result.z = v.y;
>+    result.w = v.z;
>+    return result;
>+}
>+char4 operator.wzyz(char4 v) {
>+    char4 result;
>+    result.x = v.w;
>+    result.y = v.z;
>+    result.z = v.y;
>+    result.w = v.z;
>+    return result;
>+}
>+short4 operator.wzyz(short4 v) {
>+    short4 result;
>+    result.x = v.w;
>+    result.y = v.z;
>+    result.z = v.y;
>+    result.w = v.z;
>+    return result;
>+}
>+int4 operator.wzyz(int4 v) {
>+    int4 result;
>+    result.x = v.w;
>+    result.y = v.z;
>+    result.z = v.y;
>+    result.w = v.z;
>+    return result;
>+}
>+half4 operator.wzyz(half4 v) {
>+    half4 result;
>+    result.x = v.w;
>+    result.y = v.z;
>+    result.z = v.y;
>+    result.w = v.z;
>+    return result;
>+}
>+float4 operator.wzyz(float4 v) {
>+    float4 result;
>+    result.x = v.w;
>+    result.y = v.z;
>+    result.z = v.y;
>+    result.w = v.z;
>+    return result;
>+}
>+
>+/* Functions named ddy_fine */
>+half ddy_fine(half x) {
>+    return ddy(x);
>+}
>+half2 ddy_fine(half2 x) {
>+    half2 result;
>+    result[0] = ddy_fine(x[0]);
>+    result[1] = ddy_fine(x[1]);
>+    return result;
>+}
>+half3 ddy_fine(half3 x) {
>+    half3 result;
>+    result[0] = ddy_fine(x[0]);
>+    result[1] = ddy_fine(x[1]);
>+    result[2] = ddy_fine(x[2]);
>+    return result;
>+}
>+half4 ddy_fine(half4 x) {
>+    half4 result;
>+    result[0] = ddy_fine(x[0]);
>+    result[1] = ddy_fine(x[1]);
>+    result[2] = ddy_fine(x[2]);
>+    result[3] = ddy_fine(x[3]);
>+    return result;
>+}
>+half2x2 ddy_fine(half2x2 x) {
>+    half2x2 result;
>+    result[0][0] = ddy_fine(x[0][0]);
>+    result[0][1] = ddy_fine(x[0][1]);
>+    result[1][0] = ddy_fine(x[1][0]);
>+    result[1][1] = ddy_fine(x[1][1]);
>+    return result;
>+}
>+half2x3 ddy_fine(half2x3 x) {
>+    half2x3 result;
>+    result[0][0] = ddy_fine(x[0][0]);
>+    result[0][1] = ddy_fine(x[0][1]);
>+    result[0][2] = ddy_fine(x[0][2]);
>+    result[1][0] = ddy_fine(x[1][0]);
>+    result[1][1] = ddy_fine(x[1][1]);
>+    result[1][2] = ddy_fine(x[1][2]);
>+    return result;
>+}
>+half2x4 ddy_fine(half2x4 x) {
>+    half2x4 result;
>+    result[0][0] = ddy_fine(x[0][0]);
>+    result[0][1] = ddy_fine(x[0][1]);
>+    result[0][2] = ddy_fine(x[0][2]);
>+    result[0][3] = ddy_fine(x[0][3]);
>+    result[1][0] = ddy_fine(x[1][0]);
>+    result[1][1] = ddy_fine(x[1][1]);
>+    result[1][2] = ddy_fine(x[1][2]);
>+    result[1][3] = ddy_fine(x[1][3]);
>+    return result;
>+}
>+half3x2 ddy_fine(half3x2 x) {
>+    half3x2 result;
>+    result[0][0] = ddy_fine(x[0][0]);
>+    result[0][1] = ddy_fine(x[0][1]);
>+    result[1][0] = ddy_fine(x[1][0]);
>+    result[1][1] = ddy_fine(x[1][1]);
>+    result[2][0] = ddy_fine(x[2][0]);
>+    result[2][1] = ddy_fine(x[2][1]);
>+    return result;
>+}
>+half3x3 ddy_fine(half3x3 x) {
>+    half3x3 result;
>+    result[0][0] = ddy_fine(x[0][0]);
>+    result[0][1] = ddy_fine(x[0][1]);
>+    result[0][2] = ddy_fine(x[0][2]);
>+    result[1][0] = ddy_fine(x[1][0]);
>+    result[1][1] = ddy_fine(x[1][1]);
>+    result[1][2] = ddy_fine(x[1][2]);
>+    result[2][0] = ddy_fine(x[2][0]);
>+    result[2][1] = ddy_fine(x[2][1]);
>+    result[2][2] = ddy_fine(x[2][2]);
>+    return result;
>+}
>+half3x4 ddy_fine(half3x4 x) {
>+    half3x4 result;
>+    result[0][0] = ddy_fine(x[0][0]);
>+    result[0][1] = ddy_fine(x[0][1]);
>+    result[0][2] = ddy_fine(x[0][2]);
>+    result[0][3] = ddy_fine(x[0][3]);
>+    result[1][0] = ddy_fine(x[1][0]);
>+    result[1][1] = ddy_fine(x[1][1]);
>+    result[1][2] = ddy_fine(x[1][2]);
>+    result[1][3] = ddy_fine(x[1][3]);
>+    result[2][0] = ddy_fine(x[2][0]);
>+    result[2][1] = ddy_fine(x[2][1]);
>+    result[2][2] = ddy_fine(x[2][2]);
>+    result[2][3] = ddy_fine(x[2][3]);
>+    return result;
>+}
>+half4x2 ddy_fine(half4x2 x) {
>+    half4x2 result;
>+    result[0][0] = ddy_fine(x[0][0]);
>+    result[0][1] = ddy_fine(x[0][1]);
>+    result[1][0] = ddy_fine(x[1][0]);
>+    result[1][1] = ddy_fine(x[1][1]);
>+    result[2][0] = ddy_fine(x[2][0]);
>+    result[2][1] = ddy_fine(x[2][1]);
>+    result[3][0] = ddy_fine(x[3][0]);
>+    result[3][1] = ddy_fine(x[3][1]);
>+    return result;
>+}
>+half4x3 ddy_fine(half4x3 x) {
>+    half4x3 result;
>+    result[0][0] = ddy_fine(x[0][0]);
>+    result[0][1] = ddy_fine(x[0][1]);
>+    result[0][2] = ddy_fine(x[0][2]);
>+    result[1][0] = ddy_fine(x[1][0]);
>+    result[1][1] = ddy_fine(x[1][1]);
>+    result[1][2] = ddy_fine(x[1][2]);
>+    result[2][0] = ddy_fine(x[2][0]);
>+    result[2][1] = ddy_fine(x[2][1]);
>+    result[2][2] = ddy_fine(x[2][2]);
>+    result[3][0] = ddy_fine(x[3][0]);
>+    result[3][1] = ddy_fine(x[3][1]);
>+    result[3][2] = ddy_fine(x[3][2]);
>+    return result;
>+}
>+half4x4 ddy_fine(half4x4 x) {
>+    half4x4 result;
>+    result[0][0] = ddy_fine(x[0][0]);
>+    result[0][1] = ddy_fine(x[0][1]);
>+    result[0][2] = ddy_fine(x[0][2]);
>+    result[0][3] = ddy_fine(x[0][3]);
>+    result[1][0] = ddy_fine(x[1][0]);
>+    result[1][1] = ddy_fine(x[1][1]);
>+    result[1][2] = ddy_fine(x[1][2]);
>+    result[1][3] = ddy_fine(x[1][3]);
>+    result[2][0] = ddy_fine(x[2][0]);
>+    result[2][1] = ddy_fine(x[2][1]);
>+    result[2][2] = ddy_fine(x[2][2]);
>+    result[2][3] = ddy_fine(x[2][3]);
>+    result[3][0] = ddy_fine(x[3][0]);
>+    result[3][1] = ddy_fine(x[3][1]);
>+    result[3][2] = ddy_fine(x[3][2]);
>+    result[3][3] = ddy_fine(x[3][3]);
>+    return result;
>+}
>+float ddy_fine(float x) {
>+    return ddy(x);
>+}
>+float2 ddy_fine(float2 x) {
>+    float2 result;
>+    result[0] = ddy_fine(x[0]);
>+    result[1] = ddy_fine(x[1]);
>+    return result;
>+}
>+float3 ddy_fine(float3 x) {
>+    float3 result;
>+    result[0] = ddy_fine(x[0]);
>+    result[1] = ddy_fine(x[1]);
>+    result[2] = ddy_fine(x[2]);
>+    return result;
>+}
>+float4 ddy_fine(float4 x) {
>+    float4 result;
>+    result[0] = ddy_fine(x[0]);
>+    result[1] = ddy_fine(x[1]);
>+    result[2] = ddy_fine(x[2]);
>+    result[3] = ddy_fine(x[3]);
>+    return result;
>+}
>+float2x2 ddy_fine(float2x2 x) {
>+    float2x2 result;
>+    result[0][0] = ddy_fine(x[0][0]);
>+    result[0][1] = ddy_fine(x[0][1]);
>+    result[1][0] = ddy_fine(x[1][0]);
>+    result[1][1] = ddy_fine(x[1][1]);
>+    return result;
>+}
>+float2x3 ddy_fine(float2x3 x) {
>+    float2x3 result;
>+    result[0][0] = ddy_fine(x[0][0]);
>+    result[0][1] = ddy_fine(x[0][1]);
>+    result[0][2] = ddy_fine(x[0][2]);
>+    result[1][0] = ddy_fine(x[1][0]);
>+    result[1][1] = ddy_fine(x[1][1]);
>+    result[1][2] = ddy_fine(x[1][2]);
>+    return result;
>+}
>+float2x4 ddy_fine(float2x4 x) {
>+    float2x4 result;
>+    result[0][0] = ddy_fine(x[0][0]);
>+    result[0][1] = ddy_fine(x[0][1]);
>+    result[0][2] = ddy_fine(x[0][2]);
>+    result[0][3] = ddy_fine(x[0][3]);
>+    result[1][0] = ddy_fine(x[1][0]);
>+    result[1][1] = ddy_fine(x[1][1]);
>+    result[1][2] = ddy_fine(x[1][2]);
>+    result[1][3] = ddy_fine(x[1][3]);
>+    return result;
>+}
>+float3x2 ddy_fine(float3x2 x) {
>+    float3x2 result;
>+    result[0][0] = ddy_fine(x[0][0]);
>+    result[0][1] = ddy_fine(x[0][1]);
>+    result[1][0] = ddy_fine(x[1][0]);
>+    result[1][1] = ddy_fine(x[1][1]);
>+    result[2][0] = ddy_fine(x[2][0]);
>+    result[2][1] = ddy_fine(x[2][1]);
>+    return result;
>+}
>+float3x3 ddy_fine(float3x3 x) {
>+    float3x3 result;
>+    result[0][0] = ddy_fine(x[0][0]);
>+    result[0][1] = ddy_fine(x[0][1]);
>+    result[0][2] = ddy_fine(x[0][2]);
>+    result[1][0] = ddy_fine(x[1][0]);
>+    result[1][1] = ddy_fine(x[1][1]);
>+    result[1][2] = ddy_fine(x[1][2]);
>+    result[2][0] = ddy_fine(x[2][0]);
>+    result[2][1] = ddy_fine(x[2][1]);
>+    result[2][2] = ddy_fine(x[2][2]);
>+    return result;
>+}
>+float3x4 ddy_fine(float3x4 x) {
>+    float3x4 result;
>+    result[0][0] = ddy_fine(x[0][0]);
>+    result[0][1] = ddy_fine(x[0][1]);
>+    result[0][2] = ddy_fine(x[0][2]);
>+    result[0][3] = ddy_fine(x[0][3]);
>+    result[1][0] = ddy_fine(x[1][0]);
>+    result[1][1] = ddy_fine(x[1][1]);
>+    result[1][2] = ddy_fine(x[1][2]);
>+    result[1][3] = ddy_fine(x[1][3]);
>+    result[2][0] = ddy_fine(x[2][0]);
>+    result[2][1] = ddy_fine(x[2][1]);
>+    result[2][2] = ddy_fine(x[2][2]);
>+    result[2][3] = ddy_fine(x[2][3]);
>+    return result;
>+}
>+float4x2 ddy_fine(float4x2 x) {
>+    float4x2 result;
>+    result[0][0] = ddy_fine(x[0][0]);
>+    result[0][1] = ddy_fine(x[0][1]);
>+    result[1][0] = ddy_fine(x[1][0]);
>+    result[1][1] = ddy_fine(x[1][1]);
>+    result[2][0] = ddy_fine(x[2][0]);
>+    result[2][1] = ddy_fine(x[2][1]);
>+    result[3][0] = ddy_fine(x[3][0]);
>+    result[3][1] = ddy_fine(x[3][1]);
>+    return result;
>+}
>+float4x3 ddy_fine(float4x3 x) {
>+    float4x3 result;
>+    result[0][0] = ddy_fine(x[0][0]);
>+    result[0][1] = ddy_fine(x[0][1]);
>+    result[0][2] = ddy_fine(x[0][2]);
>+    result[1][0] = ddy_fine(x[1][0]);
>+    result[1][1] = ddy_fine(x[1][1]);
>+    result[1][2] = ddy_fine(x[1][2]);
>+    result[2][0] = ddy_fine(x[2][0]);
>+    result[2][1] = ddy_fine(x[2][1]);
>+    result[2][2] = ddy_fine(x[2][2]);
>+    result[3][0] = ddy_fine(x[3][0]);
>+    result[3][1] = ddy_fine(x[3][1]);
>+    result[3][2] = ddy_fine(x[3][2]);
>+    return result;
>+}
>+float4x4 ddy_fine(float4x4 x) {
>+    float4x4 result;
>+    result[0][0] = ddy_fine(x[0][0]);
>+    result[0][1] = ddy_fine(x[0][1]);
>+    result[0][2] = ddy_fine(x[0][2]);
>+    result[0][3] = ddy_fine(x[0][3]);
>+    result[1][0] = ddy_fine(x[1][0]);
>+    result[1][1] = ddy_fine(x[1][1]);
>+    result[1][2] = ddy_fine(x[1][2]);
>+    result[1][3] = ddy_fine(x[1][3]);
>+    result[2][0] = ddy_fine(x[2][0]);
>+    result[2][1] = ddy_fine(x[2][1]);
>+    result[2][2] = ddy_fine(x[2][2]);
>+    result[2][3] = ddy_fine(x[2][3]);
>+    result[3][0] = ddy_fine(x[3][0]);
>+    result[3][1] = ddy_fine(x[3][1]);
>+    result[3][2] = ddy_fine(x[3][2]);
>+    result[3][3] = ddy_fine(x[3][3]);
>+    return result;
>+}
>+
>+/* Functions named operator.xyzx */
>+bool4 operator.xyzx(bool3 v) {
>+    bool4 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.z;
>+    result.w = v.x;
>+    return result;
>+}
>+bool4 operator.xyzx(bool4 v) {
>+    bool4 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.z;
>+    result.w = v.x;
>+    return result;
>+}
>+uchar4 operator.xyzx(uchar3 v) {
>+    uchar4 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.z;
>+    result.w = v.x;
>+    return result;
>+}
>+uchar4 operator.xyzx(uchar4 v) {
>+    uchar4 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.z;
>+    result.w = v.x;
>+    return result;
>+}
>+ushort4 operator.xyzx(ushort3 v) {
>+    ushort4 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.z;
>+    result.w = v.x;
>+    return result;
>+}
>+ushort4 operator.xyzx(ushort4 v) {
>+    ushort4 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.z;
>+    result.w = v.x;
>+    return result;
>+}
>+uint4 operator.xyzx(uint3 v) {
>+    uint4 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.z;
>+    result.w = v.x;
>+    return result;
>+}
>+uint4 operator.xyzx(uint4 v) {
>+    uint4 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.z;
>+    result.w = v.x;
>+    return result;
>+}
>+char4 operator.xyzx(char3 v) {
>+    char4 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.z;
>+    result.w = v.x;
>+    return result;
>+}
>+char4 operator.xyzx(char4 v) {
>+    char4 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.z;
>+    result.w = v.x;
>+    return result;
>+}
>+short4 operator.xyzx(short3 v) {
>+    short4 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.z;
>+    result.w = v.x;
>+    return result;
>+}
>+short4 operator.xyzx(short4 v) {
>+    short4 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.z;
>+    result.w = v.x;
>+    return result;
>+}
>+int4 operator.xyzx(int3 v) {
>+    int4 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.z;
>+    result.w = v.x;
>+    return result;
>+}
>+int4 operator.xyzx(int4 v) {
>+    int4 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.z;
>+    result.w = v.x;
>+    return result;
>+}
>+half4 operator.xyzx(half3 v) {
>+    half4 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.z;
>+    result.w = v.x;
>+    return result;
>+}
>+half4 operator.xyzx(half4 v) {
>+    half4 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.z;
>+    result.w = v.x;
>+    return result;
>+}
>+float4 operator.xyzx(float3 v) {
>+    float4 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.z;
>+    result.w = v.x;
>+    return result;
>+}
>+float4 operator.xyzx(float4 v) {
>+    float4 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.z;
>+    result.w = v.x;
>+    return result;
>+}
>+
>+/* Functions named operator.wyx= */
>+bool4 operator.wyx=(bool4 v, bool3 c) {
>+    bool4 result = v;
>+    result.w = c.x;
>+    result.y = c.y;
>+    result.x = c.z;
>+    return result;
>+}
>+uchar4 operator.wyx=(uchar4 v, uchar3 c) {
>+    uchar4 result = v;
>+    result.w = c.x;
>+    result.y = c.y;
>+    result.x = c.z;
>+    return result;
>+}
>+ushort4 operator.wyx=(ushort4 v, ushort3 c) {
>+    ushort4 result = v;
>+    result.w = c.x;
>+    result.y = c.y;
>+    result.x = c.z;
>+    return result;
>+}
>+uint4 operator.wyx=(uint4 v, uint3 c) {
>+    uint4 result = v;
>+    result.w = c.x;
>+    result.y = c.y;
>+    result.x = c.z;
>+    return result;
>+}
>+char4 operator.wyx=(char4 v, char3 c) {
>+    char4 result = v;
>+    result.w = c.x;
>+    result.y = c.y;
>+    result.x = c.z;
>+    return result;
>+}
>+short4 operator.wyx=(short4 v, short3 c) {
>+    short4 result = v;
>+    result.w = c.x;
>+    result.y = c.y;
>+    result.x = c.z;
>+    return result;
>+}
>+int4 operator.wyx=(int4 v, int3 c) {
>+    int4 result = v;
>+    result.w = c.x;
>+    result.y = c.y;
>+    result.x = c.z;
>+    return result;
>+}
>+half4 operator.wyx=(half4 v, half3 c) {
>+    half4 result = v;
>+    result.w = c.x;
>+    result.y = c.y;
>+    result.x = c.z;
>+    return result;
>+}
>+float4 operator.wyx=(float4 v, float3 c) {
>+    float4 result = v;
>+    result.w = c.x;
>+    result.y = c.y;
>+    result.x = c.z;
>+    return result;
>+}
>+
>+/* Functions named operator.wzyy */
>+bool4 operator.wzyy(bool4 v) {
>+    bool4 result;
>+    result.x = v.w;
>+    result.y = v.z;
>+    result.z = v.y;
>+    result.w = v.y;
>+    return result;
>+}
>+uchar4 operator.wzyy(uchar4 v) {
>+    uchar4 result;
>+    result.x = v.w;
>+    result.y = v.z;
>+    result.z = v.y;
>+    result.w = v.y;
>+    return result;
>+}
>+ushort4 operator.wzyy(ushort4 v) {
>+    ushort4 result;
>+    result.x = v.w;
>+    result.y = v.z;
>+    result.z = v.y;
>+    result.w = v.y;
>+    return result;
>+}
>+uint4 operator.wzyy(uint4 v) {
>+    uint4 result;
>+    result.x = v.w;
>+    result.y = v.z;
>+    result.z = v.y;
>+    result.w = v.y;
>+    return result;
>+}
>+char4 operator.wzyy(char4 v) {
>+    char4 result;
>+    result.x = v.w;
>+    result.y = v.z;
>+    result.z = v.y;
>+    result.w = v.y;
>+    return result;
>+}
>+short4 operator.wzyy(short4 v) {
>+    short4 result;
>+    result.x = v.w;
>+    result.y = v.z;
>+    result.z = v.y;
>+    result.w = v.y;
>+    return result;
>+}
>+int4 operator.wzyy(int4 v) {
>+    int4 result;
>+    result.x = v.w;
>+    result.y = v.z;
>+    result.z = v.y;
>+    result.w = v.y;
>+    return result;
>+}
>+half4 operator.wzyy(half4 v) {
>+    half4 result;
>+    result.x = v.w;
>+    result.y = v.z;
>+    result.z = v.y;
>+    result.w = v.y;
>+    return result;
>+}
>+float4 operator.wzyy(float4 v) {
>+    float4 result;
>+    result.x = v.w;
>+    result.y = v.z;
>+    result.z = v.y;
>+    result.w = v.y;
>+    return result;
>+}
>+
>+/* Functions named operator.ywz */
>+bool3 operator.ywz(bool4 v) {
>+    bool3 result;
>+    result.x = v.y;
>+    result.y = v.w;
>+    result.z = v.z;
>+    return result;
>+}
>+uchar3 operator.ywz(uchar4 v) {
>+    uchar3 result;
>+    result.x = v.y;
>+    result.y = v.w;
>+    result.z = v.z;
>+    return result;
>+}
>+ushort3 operator.ywz(ushort4 v) {
>+    ushort3 result;
>+    result.x = v.y;
>+    result.y = v.w;
>+    result.z = v.z;
>+    return result;
>+}
>+uint3 operator.ywz(uint4 v) {
>+    uint3 result;
>+    result.x = v.y;
>+    result.y = v.w;
>+    result.z = v.z;
>+    return result;
>+}
>+char3 operator.ywz(char4 v) {
>+    char3 result;
>+    result.x = v.y;
>+    result.y = v.w;
>+    result.z = v.z;
>+    return result;
>+}
>+short3 operator.ywz(short4 v) {
>+    short3 result;
>+    result.x = v.y;
>+    result.y = v.w;
>+    result.z = v.z;
>+    return result;
>+}
>+int3 operator.ywz(int4 v) {
>+    int3 result;
>+    result.x = v.y;
>+    result.y = v.w;
>+    result.z = v.z;
>+    return result;
>+}
>+half3 operator.ywz(half4 v) {
>+    half3 result;
>+    result.x = v.y;
>+    result.y = v.w;
>+    result.z = v.z;
>+    return result;
>+}
>+float3 operator.ywz(float4 v) {
>+    float3 result;
>+    result.x = v.y;
>+    result.y = v.w;
>+    result.z = v.z;
>+    return result;
>+}
>+
>+/* Functions named any */
>+bool any(bool x) {
>+    return x;
>+}
>+bool any(bool2 x) {
>+    bool result = false;
>+    result = result || (x[0]);
>+    result = result || (x[1]);
>+    return result;
>+}
>+bool any(bool3 x) {
>+    bool result = false;
>+    result = result || (x[0]);
>+    result = result || (x[1]);
>+    result = result || (x[2]);
>+    return result;
>+}
>+bool any(bool4 x) {
>+    bool result = false;
>+    result = result || (x[0]);
>+    result = result || (x[1]);
>+    result = result || (x[2]);
>+    result = result || (x[3]);
>+    return result;
>+}
>+bool any(uchar x) {
>+    return x != 0;
>+}
>+bool any(uchar2 x) {
>+    bool result = false;
>+    result = result || (x[0] != 0);
>+    result = result || (x[1] != 0);
>+    return result;
>+}
>+bool any(uchar3 x) {
>+    bool result = false;
>+    result = result || (x[0] != 0);
>+    result = result || (x[1] != 0);
>+    result = result || (x[2] != 0);
>+    return result;
>+}
>+bool any(uchar4 x) {
>+    bool result = false;
>+    result = result || (x[0] != 0);
>+    result = result || (x[1] != 0);
>+    result = result || (x[2] != 0);
>+    result = result || (x[3] != 0);
>+    return result;
>+}
>+bool any(ushort x) {
>+    return x != 0;
>+}
>+bool any(ushort2 x) {
>+    bool result = false;
>+    result = result || (x[0] != 0);
>+    result = result || (x[1] != 0);
>+    return result;
>+}
>+bool any(ushort3 x) {
>+    bool result = false;
>+    result = result || (x[0] != 0);
>+    result = result || (x[1] != 0);
>+    result = result || (x[2] != 0);
>+    return result;
>+}
>+bool any(ushort4 x) {
>+    bool result = false;
>+    result = result || (x[0] != 0);
>+    result = result || (x[1] != 0);
>+    result = result || (x[2] != 0);
>+    result = result || (x[3] != 0);
>+    return result;
>+}
>+bool any(uint x) {
>+    return x != 0;
>+}
>+bool any(uint2 x) {
>+    bool result = false;
>+    result = result || (x[0] != 0);
>+    result = result || (x[1] != 0);
>+    return result;
>+}
>+bool any(uint3 x) {
>+    bool result = false;
>+    result = result || (x[0] != 0);
>+    result = result || (x[1] != 0);
>+    result = result || (x[2] != 0);
>+    return result;
>+}
>+bool any(uint4 x) {
>+    bool result = false;
>+    result = result || (x[0] != 0);
>+    result = result || (x[1] != 0);
>+    result = result || (x[2] != 0);
>+    result = result || (x[3] != 0);
>+    return result;
>+}
>+bool any(char x) {
>+    return x != 0;
>+}
>+bool any(char2 x) {
>+    bool result = false;
>+    result = result || (x[0] != 0);
>+    result = result || (x[1] != 0);
>+    return result;
>+}
>+bool any(char3 x) {
>+    bool result = false;
>+    result = result || (x[0] != 0);
>+    result = result || (x[1] != 0);
>+    result = result || (x[2] != 0);
>+    return result;
>+}
>+bool any(char4 x) {
>+    bool result = false;
>+    result = result || (x[0] != 0);
>+    result = result || (x[1] != 0);
>+    result = result || (x[2] != 0);
>+    result = result || (x[3] != 0);
>+    return result;
>+}
>+bool any(short x) {
>+    return x != 0;
>+}
>+bool any(short2 x) {
>+    bool result = false;
>+    result = result || (x[0] != 0);
>+    result = result || (x[1] != 0);
>+    return result;
>+}
>+bool any(short3 x) {
>+    bool result = false;
>+    result = result || (x[0] != 0);
>+    result = result || (x[1] != 0);
>+    result = result || (x[2] != 0);
>+    return result;
>+}
>+bool any(short4 x) {
>+    bool result = false;
>+    result = result || (x[0] != 0);
>+    result = result || (x[1] != 0);
>+    result = result || (x[2] != 0);
>+    result = result || (x[3] != 0);
>+    return result;
>+}
>+bool any(int x) {
>+    return x != 0;
>+}
>+bool any(int2 x) {
>+    bool result = false;
>+    result = result || (x[0] != 0);
>+    result = result || (x[1] != 0);
>+    return result;
>+}
>+bool any(int3 x) {
>+    bool result = false;
>+    result = result || (x[0] != 0);
>+    result = result || (x[1] != 0);
>+    result = result || (x[2] != 0);
>+    return result;
>+}
>+bool any(int4 x) {
>+    bool result = false;
>+    result = result || (x[0] != 0);
>+    result = result || (x[1] != 0);
>+    result = result || (x[2] != 0);
>+    result = result || (x[3] != 0);
>+    return result;
>+}
>+bool any(half x) {
>+    return x != 0;
>+}
>+bool any(half2 x) {
>+    bool result = false;
>+    result = result || (x[0] != 0);
>+    result = result || (x[1] != 0);
>+    return result;
>+}
>+bool any(half3 x) {
>+    bool result = false;
>+    result = result || (x[0] != 0);
>+    result = result || (x[1] != 0);
>+    result = result || (x[2] != 0);
>+    return result;
>+}
>+bool any(half4 x) {
>+    bool result = false;
>+    result = result || (x[0] != 0);
>+    result = result || (x[1] != 0);
>+    result = result || (x[2] != 0);
>+    result = result || (x[3] != 0);
>+    return result;
>+}
>+bool any(half2x2 x) {
>+    bool result = false;
>+    result = result || (x[0][0] != 0);
>+    result = result || (x[0][1] != 0);
>+    result = result || (x[1][0] != 0);
>+    result = result || (x[1][1] != 0);
>+    return result;
>+}
>+bool any(half2x3 x) {
>+    bool result = false;
>+    result = result || (x[0][0] != 0);
>+    result = result || (x[0][1] != 0);
>+    result = result || (x[0][2] != 0);
>+    result = result || (x[1][0] != 0);
>+    result = result || (x[1][1] != 0);
>+    result = result || (x[1][2] != 0);
>+    return result;
>+}
>+bool any(half2x4 x) {
>+    bool result = false;
>+    result = result || (x[0][0] != 0);
>+    result = result || (x[0][1] != 0);
>+    result = result || (x[0][2] != 0);
>+    result = result || (x[0][3] != 0);
>+    result = result || (x[1][0] != 0);
>+    result = result || (x[1][1] != 0);
>+    result = result || (x[1][2] != 0);
>+    result = result || (x[1][3] != 0);
>+    return result;
>+}
>+bool any(half3x2 x) {
>+    bool result = false;
>+    result = result || (x[0][0] != 0);
>+    result = result || (x[0][1] != 0);
>+    result = result || (x[1][0] != 0);
>+    result = result || (x[1][1] != 0);
>+    result = result || (x[2][0] != 0);
>+    result = result || (x[2][1] != 0);
>+    return result;
>+}
>+bool any(half3x3 x) {
>+    bool result = false;
>+    result = result || (x[0][0] != 0);
>+    result = result || (x[0][1] != 0);
>+    result = result || (x[0][2] != 0);
>+    result = result || (x[1][0] != 0);
>+    result = result || (x[1][1] != 0);
>+    result = result || (x[1][2] != 0);
>+    result = result || (x[2][0] != 0);
>+    result = result || (x[2][1] != 0);
>+    result = result || (x[2][2] != 0);
>+    return result;
>+}
>+bool any(half3x4 x) {
>+    bool result = false;
>+    result = result || (x[0][0] != 0);
>+    result = result || (x[0][1] != 0);
>+    result = result || (x[0][2] != 0);
>+    result = result || (x[0][3] != 0);
>+    result = result || (x[1][0] != 0);
>+    result = result || (x[1][1] != 0);
>+    result = result || (x[1][2] != 0);
>+    result = result || (x[1][3] != 0);
>+    result = result || (x[2][0] != 0);
>+    result = result || (x[2][1] != 0);
>+    result = result || (x[2][2] != 0);
>+    result = result || (x[2][3] != 0);
>+    return result;
>+}
>+bool any(half4x2 x) {
>+    bool result = false;
>+    result = result || (x[0][0] != 0);
>+    result = result || (x[0][1] != 0);
>+    result = result || (x[1][0] != 0);
>+    result = result || (x[1][1] != 0);
>+    result = result || (x[2][0] != 0);
>+    result = result || (x[2][1] != 0);
>+    result = result || (x[3][0] != 0);
>+    result = result || (x[3][1] != 0);
>+    return result;
>+}
>+bool any(half4x3 x) {
>+    bool result = false;
>+    result = result || (x[0][0] != 0);
>+    result = result || (x[0][1] != 0);
>+    result = result || (x[0][2] != 0);
>+    result = result || (x[1][0] != 0);
>+    result = result || (x[1][1] != 0);
>+    result = result || (x[1][2] != 0);
>+    result = result || (x[2][0] != 0);
>+    result = result || (x[2][1] != 0);
>+    result = result || (x[2][2] != 0);
>+    result = result || (x[3][0] != 0);
>+    result = result || (x[3][1] != 0);
>+    result = result || (x[3][2] != 0);
>+    return result;
>+}
>+bool any(half4x4 x) {
>+    bool result = false;
>+    result = result || (x[0][0] != 0);
>+    result = result || (x[0][1] != 0);
>+    result = result || (x[0][2] != 0);
>+    result = result || (x[0][3] != 0);
>+    result = result || (x[1][0] != 0);
>+    result = result || (x[1][1] != 0);
>+    result = result || (x[1][2] != 0);
>+    result = result || (x[1][3] != 0);
>+    result = result || (x[2][0] != 0);
>+    result = result || (x[2][1] != 0);
>+    result = result || (x[2][2] != 0);
>+    result = result || (x[2][3] != 0);
>+    result = result || (x[3][0] != 0);
>+    result = result || (x[3][1] != 0);
>+    result = result || (x[3][2] != 0);
>+    result = result || (x[3][3] != 0);
>+    return result;
>+}
>+bool any(float x) {
>+    return x != 0;
>+}
>+bool any(float2 x) {
>+    bool result = false;
>+    result = result || (x[0] != 0);
>+    result = result || (x[1] != 0);
>+    return result;
>+}
>+bool any(float3 x) {
>+    bool result = false;
>+    result = result || (x[0] != 0);
>+    result = result || (x[1] != 0);
>+    result = result || (x[2] != 0);
>+    return result;
>+}
>+bool any(float4 x) {
>+    bool result = false;
>+    result = result || (x[0] != 0);
>+    result = result || (x[1] != 0);
>+    result = result || (x[2] != 0);
>+    result = result || (x[3] != 0);
>+    return result;
>+}
>+bool any(float2x2 x) {
>+    bool result = false;
>+    result = result || (x[0][0] != 0);
>+    result = result || (x[0][1] != 0);
>+    result = result || (x[1][0] != 0);
>+    result = result || (x[1][1] != 0);
>+    return result;
>+}
>+bool any(float2x3 x) {
>+    bool result = false;
>+    result = result || (x[0][0] != 0);
>+    result = result || (x[0][1] != 0);
>+    result = result || (x[0][2] != 0);
>+    result = result || (x[1][0] != 0);
>+    result = result || (x[1][1] != 0);
>+    result = result || (x[1][2] != 0);
>+    return result;
>+}
>+bool any(float2x4 x) {
>+    bool result = false;
>+    result = result || (x[0][0] != 0);
>+    result = result || (x[0][1] != 0);
>+    result = result || (x[0][2] != 0);
>+    result = result || (x[0][3] != 0);
>+    result = result || (x[1][0] != 0);
>+    result = result || (x[1][1] != 0);
>+    result = result || (x[1][2] != 0);
>+    result = result || (x[1][3] != 0);
>+    return result;
>+}
>+bool any(float3x2 x) {
>+    bool result = false;
>+    result = result || (x[0][0] != 0);
>+    result = result || (x[0][1] != 0);
>+    result = result || (x[1][0] != 0);
>+    result = result || (x[1][1] != 0);
>+    result = result || (x[2][0] != 0);
>+    result = result || (x[2][1] != 0);
>+    return result;
>+}
>+bool any(float3x3 x) {
>+    bool result = false;
>+    result = result || (x[0][0] != 0);
>+    result = result || (x[0][1] != 0);
>+    result = result || (x[0][2] != 0);
>+    result = result || (x[1][0] != 0);
>+    result = result || (x[1][1] != 0);
>+    result = result || (x[1][2] != 0);
>+    result = result || (x[2][0] != 0);
>+    result = result || (x[2][1] != 0);
>+    result = result || (x[2][2] != 0);
>+    return result;
>+}
>+bool any(float3x4 x) {
>+    bool result = false;
>+    result = result || (x[0][0] != 0);
>+    result = result || (x[0][1] != 0);
>+    result = result || (x[0][2] != 0);
>+    result = result || (x[0][3] != 0);
>+    result = result || (x[1][0] != 0);
>+    result = result || (x[1][1] != 0);
>+    result = result || (x[1][2] != 0);
>+    result = result || (x[1][3] != 0);
>+    result = result || (x[2][0] != 0);
>+    result = result || (x[2][1] != 0);
>+    result = result || (x[2][2] != 0);
>+    result = result || (x[2][3] != 0);
>+    return result;
>+}
>+bool any(float4x2 x) {
>+    bool result = false;
>+    result = result || (x[0][0] != 0);
>+    result = result || (x[0][1] != 0);
>+    result = result || (x[1][0] != 0);
>+    result = result || (x[1][1] != 0);
>+    result = result || (x[2][0] != 0);
>+    result = result || (x[2][1] != 0);
>+    result = result || (x[3][0] != 0);
>+    result = result || (x[3][1] != 0);
>+    return result;
>+}
>+bool any(float4x3 x) {
>+    bool result = false;
>+    result = result || (x[0][0] != 0);
>+    result = result || (x[0][1] != 0);
>+    result = result || (x[0][2] != 0);
>+    result = result || (x[1][0] != 0);
>+    result = result || (x[1][1] != 0);
>+    result = result || (x[1][2] != 0);
>+    result = result || (x[2][0] != 0);
>+    result = result || (x[2][1] != 0);
>+    result = result || (x[2][2] != 0);
>+    result = result || (x[3][0] != 0);
>+    result = result || (x[3][1] != 0);
>+    result = result || (x[3][2] != 0);
>+    return result;
>+}
>+bool any(float4x4 x) {
>+    bool result = false;
>+    result = result || (x[0][0] != 0);
>+    result = result || (x[0][1] != 0);
>+    result = result || (x[0][2] != 0);
>+    result = result || (x[0][3] != 0);
>+    result = result || (x[1][0] != 0);
>+    result = result || (x[1][1] != 0);
>+    result = result || (x[1][2] != 0);
>+    result = result || (x[1][3] != 0);
>+    result = result || (x[2][0] != 0);
>+    result = result || (x[2][1] != 0);
>+    result = result || (x[2][2] != 0);
>+    result = result || (x[2][3] != 0);
>+    result = result || (x[3][0] != 0);
>+    result = result || (x[3][1] != 0);
>+    result = result || (x[3][2] != 0);
>+    result = result || (x[3][3] != 0);
>+    return result;
>+}
>+
>+
>+/* Functions named operator.yxww */
>+bool4 operator.yxww(bool4 v) {
>+    bool4 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.w;
>+    result.w = v.w;
>+    return result;
>+}
>+uchar4 operator.yxww(uchar4 v) {
>+    uchar4 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.w;
>+    result.w = v.w;
>+    return result;
>+}
>+ushort4 operator.yxww(ushort4 v) {
>+    ushort4 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.w;
>+    result.w = v.w;
>+    return result;
>+}
>+uint4 operator.yxww(uint4 v) {
>+    uint4 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.w;
>+    result.w = v.w;
>+    return result;
>+}
>+char4 operator.yxww(char4 v) {
>+    char4 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.w;
>+    result.w = v.w;
>+    return result;
>+}
>+short4 operator.yxww(short4 v) {
>+    short4 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.w;
>+    result.w = v.w;
>+    return result;
>+}
>+int4 operator.yxww(int4 v) {
>+    int4 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.w;
>+    result.w = v.w;
>+    return result;
>+}
>+half4 operator.yxww(half4 v) {
>+    half4 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.w;
>+    result.w = v.w;
>+    return result;
>+}
>+float4 operator.yxww(float4 v) {
>+    float4 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.w;
>+    result.w = v.w;
>+    return result;
>+}
>+
>+/* Functions named operator.zy= */
>+bool3 operator.zy=(bool3 v, bool2 c) {
>+    bool3 result = v;
>+    result.z = c.x;
>+    result.y = c.y;
>+    return result;
>+}
>+bool4 operator.zy=(bool4 v, bool2 c) {
>+    bool4 result = v;
>+    result.z = c.x;
>+    result.y = c.y;
>+    return result;
>+}
>+uchar3 operator.zy=(uchar3 v, uchar2 c) {
>+    uchar3 result = v;
>+    result.z = c.x;
>+    result.y = c.y;
>+    return result;
>+}
>+uchar4 operator.zy=(uchar4 v, uchar2 c) {
>+    uchar4 result = v;
>+    result.z = c.x;
>+    result.y = c.y;
>+    return result;
>+}
>+ushort3 operator.zy=(ushort3 v, ushort2 c) {
>+    ushort3 result = v;
>+    result.z = c.x;
>+    result.y = c.y;
>+    return result;
>+}
>+ushort4 operator.zy=(ushort4 v, ushort2 c) {
>+    ushort4 result = v;
>+    result.z = c.x;
>+    result.y = c.y;
>+    return result;
>+}
>+uint3 operator.zy=(uint3 v, uint2 c) {
>+    uint3 result = v;
>+    result.z = c.x;
>+    result.y = c.y;
>+    return result;
>+}
>+uint4 operator.zy=(uint4 v, uint2 c) {
>+    uint4 result = v;
>+    result.z = c.x;
>+    result.y = c.y;
>+    return result;
>+}
>+char3 operator.zy=(char3 v, char2 c) {
>+    char3 result = v;
>+    result.z = c.x;
>+    result.y = c.y;
>+    return result;
>+}
>+char4 operator.zy=(char4 v, char2 c) {
>+    char4 result = v;
>+    result.z = c.x;
>+    result.y = c.y;
>+    return result;
>+}
>+short3 operator.zy=(short3 v, short2 c) {
>+    short3 result = v;
>+    result.z = c.x;
>+    result.y = c.y;
>+    return result;
>+}
>+short4 operator.zy=(short4 v, short2 c) {
>+    short4 result = v;
>+    result.z = c.x;
>+    result.y = c.y;
>+    return result;
>+}
>+int3 operator.zy=(int3 v, int2 c) {
>+    int3 result = v;
>+    result.z = c.x;
>+    result.y = c.y;
>+    return result;
>+}
>+int4 operator.zy=(int4 v, int2 c) {
>+    int4 result = v;
>+    result.z = c.x;
>+    result.y = c.y;
>+    return result;
>+}
>+half3 operator.zy=(half3 v, half2 c) {
>+    half3 result = v;
>+    result.z = c.x;
>+    result.y = c.y;
>+    return result;
>+}
>+half4 operator.zy=(half4 v, half2 c) {
>+    half4 result = v;
>+    result.z = c.x;
>+    result.y = c.y;
>+    return result;
>+}
>+float3 operator.zy=(float3 v, float2 c) {
>+    float3 result = v;
>+    result.z = c.x;
>+    result.y = c.y;
>+    return result;
>+}
>+float4 operator.zy=(float4 v, float2 c) {
>+    float4 result = v;
>+    result.z = c.x;
>+    result.y = c.y;
>+    return result;
>+}
>+
>+/* Functions named operator.wyz */
>+bool3 operator.wyz(bool4 v) {
>+    bool3 result;
>+    result.x = v.w;
>+    result.y = v.y;
>+    result.z = v.z;
>+    return result;
>+}
>+uchar3 operator.wyz(uchar4 v) {
>+    uchar3 result;
>+    result.x = v.w;
>+    result.y = v.y;
>+    result.z = v.z;
>+    return result;
>+}
>+ushort3 operator.wyz(ushort4 v) {
>+    ushort3 result;
>+    result.x = v.w;
>+    result.y = v.y;
>+    result.z = v.z;
>+    return result;
>+}
>+uint3 operator.wyz(uint4 v) {
>+    uint3 result;
>+    result.x = v.w;
>+    result.y = v.y;
>+    result.z = v.z;
>+    return result;
>+}
>+char3 operator.wyz(char4 v) {
>+    char3 result;
>+    result.x = v.w;
>+    result.y = v.y;
>+    result.z = v.z;
>+    return result;
>+}
>+short3 operator.wyz(short4 v) {
>+    short3 result;
>+    result.x = v.w;
>+    result.y = v.y;
>+    result.z = v.z;
>+    return result;
>+}
>+int3 operator.wyz(int4 v) {
>+    int3 result;
>+    result.x = v.w;
>+    result.y = v.y;
>+    result.z = v.z;
>+    return result;
>+}
>+half3 operator.wyz(half4 v) {
>+    half3 result;
>+    result.x = v.w;
>+    result.y = v.y;
>+    result.z = v.z;
>+    return result;
>+}
>+float3 operator.wyz(float4 v) {
>+    float3 result;
>+    result.x = v.w;
>+    result.y = v.y;
>+    result.z = v.z;
>+    return result;
>+}
>+
>+/* Functions named operator.yxw= */
>+bool4 operator.yxw=(bool4 v, bool3 c) {
>+    bool4 result = v;
>+    result.y = c.x;
>+    result.x = c.y;
>+    result.w = c.z;
>+    return result;
>+}
>+uchar4 operator.yxw=(uchar4 v, uchar3 c) {
>+    uchar4 result = v;
>+    result.y = c.x;
>+    result.x = c.y;
>+    result.w = c.z;
>+    return result;
>+}
>+ushort4 operator.yxw=(ushort4 v, ushort3 c) {
>+    ushort4 result = v;
>+    result.y = c.x;
>+    result.x = c.y;
>+    result.w = c.z;
>+    return result;
>+}
>+uint4 operator.yxw=(uint4 v, uint3 c) {
>+    uint4 result = v;
>+    result.y = c.x;
>+    result.x = c.y;
>+    result.w = c.z;
>+    return result;
>+}
>+char4 operator.yxw=(char4 v, char3 c) {
>+    char4 result = v;
>+    result.y = c.x;
>+    result.x = c.y;
>+    result.w = c.z;
>+    return result;
>+}
>+short4 operator.yxw=(short4 v, short3 c) {
>+    short4 result = v;
>+    result.y = c.x;
>+    result.x = c.y;
>+    result.w = c.z;
>+    return result;
>+}
>+int4 operator.yxw=(int4 v, int3 c) {
>+    int4 result = v;
>+    result.y = c.x;
>+    result.x = c.y;
>+    result.w = c.z;
>+    return result;
>+}
>+half4 operator.yxw=(half4 v, half3 c) {
>+    half4 result = v;
>+    result.y = c.x;
>+    result.x = c.y;
>+    result.w = c.z;
>+    return result;
>+}
>+float4 operator.yxw=(float4 v, float3 c) {
>+    float4 result = v;
>+    result.y = c.x;
>+    result.x = c.y;
>+    result.w = c.z;
>+    return result;
>+}
>+
>+/* Functions named operator.wyxz */
>+bool4 operator.wyxz(bool4 v) {
>+    bool4 result;
>+    result.x = v.w;
>+    result.y = v.y;
>+    result.z = v.x;
>+    result.w = v.z;
>+    return result;
>+}
>+uchar4 operator.wyxz(uchar4 v) {
>+    uchar4 result;
>+    result.x = v.w;
>+    result.y = v.y;
>+    result.z = v.x;
>+    result.w = v.z;
>+    return result;
>+}
>+ushort4 operator.wyxz(ushort4 v) {
>+    ushort4 result;
>+    result.x = v.w;
>+    result.y = v.y;
>+    result.z = v.x;
>+    result.w = v.z;
>+    return result;
>+}
>+uint4 operator.wyxz(uint4 v) {
>+    uint4 result;
>+    result.x = v.w;
>+    result.y = v.y;
>+    result.z = v.x;
>+    result.w = v.z;
>+    return result;
>+}
>+char4 operator.wyxz(char4 v) {
>+    char4 result;
>+    result.x = v.w;
>+    result.y = v.y;
>+    result.z = v.x;
>+    result.w = v.z;
>+    return result;
>+}
>+short4 operator.wyxz(short4 v) {
>+    short4 result;
>+    result.x = v.w;
>+    result.y = v.y;
>+    result.z = v.x;
>+    result.w = v.z;
>+    return result;
>+}
>+int4 operator.wyxz(int4 v) {
>+    int4 result;
>+    result.x = v.w;
>+    result.y = v.y;
>+    result.z = v.x;
>+    result.w = v.z;
>+    return result;
>+}
>+half4 operator.wyxz(half4 v) {
>+    half4 result;
>+    result.x = v.w;
>+    result.y = v.y;
>+    result.z = v.x;
>+    result.w = v.z;
>+    return result;
>+}
>+float4 operator.wyxz(float4 v) {
>+    float4 result;
>+    result.x = v.w;
>+    result.y = v.y;
>+    result.z = v.x;
>+    result.w = v.z;
>+    return result;
>+}
>+
>+/* Functions named ddy_coarse */
>+half ddy_coarse(half x) {
>+    return ddy(x);
>+}
>+half2 ddy_coarse(half2 x) {
>+    half2 result;
>+    result[0] = ddy_coarse(x[0]);
>+    result[1] = ddy_coarse(x[1]);
>+    return result;
>+}
>+half3 ddy_coarse(half3 x) {
>+    half3 result;
>+    result[0] = ddy_coarse(x[0]);
>+    result[1] = ddy_coarse(x[1]);
>+    result[2] = ddy_coarse(x[2]);
>+    return result;
>+}
>+half4 ddy_coarse(half4 x) {
>+    half4 result;
>+    result[0] = ddy_coarse(x[0]);
>+    result[1] = ddy_coarse(x[1]);
>+    result[2] = ddy_coarse(x[2]);
>+    result[3] = ddy_coarse(x[3]);
>+    return result;
>+}
>+half2x2 ddy_coarse(half2x2 x) {
>+    half2x2 result;
>+    result[0][0] = ddy_coarse(x[0][0]);
>+    result[0][1] = ddy_coarse(x[0][1]);
>+    result[1][0] = ddy_coarse(x[1][0]);
>+    result[1][1] = ddy_coarse(x[1][1]);
>+    return result;
>+}
>+half2x3 ddy_coarse(half2x3 x) {
>+    half2x3 result;
>+    result[0][0] = ddy_coarse(x[0][0]);
>+    result[0][1] = ddy_coarse(x[0][1]);
>+    result[0][2] = ddy_coarse(x[0][2]);
>+    result[1][0] = ddy_coarse(x[1][0]);
>+    result[1][1] = ddy_coarse(x[1][1]);
>+    result[1][2] = ddy_coarse(x[1][2]);
>+    return result;
>+}
>+half2x4 ddy_coarse(half2x4 x) {
>+    half2x4 result;
>+    result[0][0] = ddy_coarse(x[0][0]);
>+    result[0][1] = ddy_coarse(x[0][1]);
>+    result[0][2] = ddy_coarse(x[0][2]);
>+    result[0][3] = ddy_coarse(x[0][3]);
>+    result[1][0] = ddy_coarse(x[1][0]);
>+    result[1][1] = ddy_coarse(x[1][1]);
>+    result[1][2] = ddy_coarse(x[1][2]);
>+    result[1][3] = ddy_coarse(x[1][3]);
>+    return result;
>+}
>+half3x2 ddy_coarse(half3x2 x) {
>+    half3x2 result;
>+    result[0][0] = ddy_coarse(x[0][0]);
>+    result[0][1] = ddy_coarse(x[0][1]);
>+    result[1][0] = ddy_coarse(x[1][0]);
>+    result[1][1] = ddy_coarse(x[1][1]);
>+    result[2][0] = ddy_coarse(x[2][0]);
>+    result[2][1] = ddy_coarse(x[2][1]);
>+    return result;
>+}
>+half3x3 ddy_coarse(half3x3 x) {
>+    half3x3 result;
>+    result[0][0] = ddy_coarse(x[0][0]);
>+    result[0][1] = ddy_coarse(x[0][1]);
>+    result[0][2] = ddy_coarse(x[0][2]);
>+    result[1][0] = ddy_coarse(x[1][0]);
>+    result[1][1] = ddy_coarse(x[1][1]);
>+    result[1][2] = ddy_coarse(x[1][2]);
>+    result[2][0] = ddy_coarse(x[2][0]);
>+    result[2][1] = ddy_coarse(x[2][1]);
>+    result[2][2] = ddy_coarse(x[2][2]);
>+    return result;
>+}
>+half3x4 ddy_coarse(half3x4 x) {
>+    half3x4 result;
>+    result[0][0] = ddy_coarse(x[0][0]);
>+    result[0][1] = ddy_coarse(x[0][1]);
>+    result[0][2] = ddy_coarse(x[0][2]);
>+    result[0][3] = ddy_coarse(x[0][3]);
>+    result[1][0] = ddy_coarse(x[1][0]);
>+    result[1][1] = ddy_coarse(x[1][1]);
>+    result[1][2] = ddy_coarse(x[1][2]);
>+    result[1][3] = ddy_coarse(x[1][3]);
>+    result[2][0] = ddy_coarse(x[2][0]);
>+    result[2][1] = ddy_coarse(x[2][1]);
>+    result[2][2] = ddy_coarse(x[2][2]);
>+    result[2][3] = ddy_coarse(x[2][3]);
>+    return result;
>+}
>+half4x2 ddy_coarse(half4x2 x) {
>+    half4x2 result;
>+    result[0][0] = ddy_coarse(x[0][0]);
>+    result[0][1] = ddy_coarse(x[0][1]);
>+    result[1][0] = ddy_coarse(x[1][0]);
>+    result[1][1] = ddy_coarse(x[1][1]);
>+    result[2][0] = ddy_coarse(x[2][0]);
>+    result[2][1] = ddy_coarse(x[2][1]);
>+    result[3][0] = ddy_coarse(x[3][0]);
>+    result[3][1] = ddy_coarse(x[3][1]);
>+    return result;
>+}
>+half4x3 ddy_coarse(half4x3 x) {
>+    half4x3 result;
>+    result[0][0] = ddy_coarse(x[0][0]);
>+    result[0][1] = ddy_coarse(x[0][1]);
>+    result[0][2] = ddy_coarse(x[0][2]);
>+    result[1][0] = ddy_coarse(x[1][0]);
>+    result[1][1] = ddy_coarse(x[1][1]);
>+    result[1][2] = ddy_coarse(x[1][2]);
>+    result[2][0] = ddy_coarse(x[2][0]);
>+    result[2][1] = ddy_coarse(x[2][1]);
>+    result[2][2] = ddy_coarse(x[2][2]);
>+    result[3][0] = ddy_coarse(x[3][0]);
>+    result[3][1] = ddy_coarse(x[3][1]);
>+    result[3][2] = ddy_coarse(x[3][2]);
>+    return result;
>+}
>+half4x4 ddy_coarse(half4x4 x) {
>+    half4x4 result;
>+    result[0][0] = ddy_coarse(x[0][0]);
>+    result[0][1] = ddy_coarse(x[0][1]);
>+    result[0][2] = ddy_coarse(x[0][2]);
>+    result[0][3] = ddy_coarse(x[0][3]);
>+    result[1][0] = ddy_coarse(x[1][0]);
>+    result[1][1] = ddy_coarse(x[1][1]);
>+    result[1][2] = ddy_coarse(x[1][2]);
>+    result[1][3] = ddy_coarse(x[1][3]);
>+    result[2][0] = ddy_coarse(x[2][0]);
>+    result[2][1] = ddy_coarse(x[2][1]);
>+    result[2][2] = ddy_coarse(x[2][2]);
>+    result[2][3] = ddy_coarse(x[2][3]);
>+    result[3][0] = ddy_coarse(x[3][0]);
>+    result[3][1] = ddy_coarse(x[3][1]);
>+    result[3][2] = ddy_coarse(x[3][2]);
>+    result[3][3] = ddy_coarse(x[3][3]);
>+    return result;
>+}
>+float ddy_coarse(float x) {
>+    return ddy(x);
>+}
>+float2 ddy_coarse(float2 x) {
>+    float2 result;
>+    result[0] = ddy_coarse(x[0]);
>+    result[1] = ddy_coarse(x[1]);
>+    return result;
>+}
>+float3 ddy_coarse(float3 x) {
>+    float3 result;
>+    result[0] = ddy_coarse(x[0]);
>+    result[1] = ddy_coarse(x[1]);
>+    result[2] = ddy_coarse(x[2]);
>+    return result;
>+}
>+float4 ddy_coarse(float4 x) {
>+    float4 result;
>+    result[0] = ddy_coarse(x[0]);
>+    result[1] = ddy_coarse(x[1]);
>+    result[2] = ddy_coarse(x[2]);
>+    result[3] = ddy_coarse(x[3]);
>+    return result;
>+}
>+float2x2 ddy_coarse(float2x2 x) {
>+    float2x2 result;
>+    result[0][0] = ddy_coarse(x[0][0]);
>+    result[0][1] = ddy_coarse(x[0][1]);
>+    result[1][0] = ddy_coarse(x[1][0]);
>+    result[1][1] = ddy_coarse(x[1][1]);
>+    return result;
>+}
>+float2x3 ddy_coarse(float2x3 x) {
>+    float2x3 result;
>+    result[0][0] = ddy_coarse(x[0][0]);
>+    result[0][1] = ddy_coarse(x[0][1]);
>+    result[0][2] = ddy_coarse(x[0][2]);
>+    result[1][0] = ddy_coarse(x[1][0]);
>+    result[1][1] = ddy_coarse(x[1][1]);
>+    result[1][2] = ddy_coarse(x[1][2]);
>+    return result;
>+}
>+float2x4 ddy_coarse(float2x4 x) {
>+    float2x4 result;
>+    result[0][0] = ddy_coarse(x[0][0]);
>+    result[0][1] = ddy_coarse(x[0][1]);
>+    result[0][2] = ddy_coarse(x[0][2]);
>+    result[0][3] = ddy_coarse(x[0][3]);
>+    result[1][0] = ddy_coarse(x[1][0]);
>+    result[1][1] = ddy_coarse(x[1][1]);
>+    result[1][2] = ddy_coarse(x[1][2]);
>+    result[1][3] = ddy_coarse(x[1][3]);
>+    return result;
>+}
>+float3x2 ddy_coarse(float3x2 x) {
>+    float3x2 result;
>+    result[0][0] = ddy_coarse(x[0][0]);
>+    result[0][1] = ddy_coarse(x[0][1]);
>+    result[1][0] = ddy_coarse(x[1][0]);
>+    result[1][1] = ddy_coarse(x[1][1]);
>+    result[2][0] = ddy_coarse(x[2][0]);
>+    result[2][1] = ddy_coarse(x[2][1]);
>+    return result;
>+}
>+float3x3 ddy_coarse(float3x3 x) {
>+    float3x3 result;
>+    result[0][0] = ddy_coarse(x[0][0]);
>+    result[0][1] = ddy_coarse(x[0][1]);
>+    result[0][2] = ddy_coarse(x[0][2]);
>+    result[1][0] = ddy_coarse(x[1][0]);
>+    result[1][1] = ddy_coarse(x[1][1]);
>+    result[1][2] = ddy_coarse(x[1][2]);
>+    result[2][0] = ddy_coarse(x[2][0]);
>+    result[2][1] = ddy_coarse(x[2][1]);
>+    result[2][2] = ddy_coarse(x[2][2]);
>+    return result;
>+}
>+float3x4 ddy_coarse(float3x4 x) {
>+    float3x4 result;
>+    result[0][0] = ddy_coarse(x[0][0]);
>+    result[0][1] = ddy_coarse(x[0][1]);
>+    result[0][2] = ddy_coarse(x[0][2]);
>+    result[0][3] = ddy_coarse(x[0][3]);
>+    result[1][0] = ddy_coarse(x[1][0]);
>+    result[1][1] = ddy_coarse(x[1][1]);
>+    result[1][2] = ddy_coarse(x[1][2]);
>+    result[1][3] = ddy_coarse(x[1][3]);
>+    result[2][0] = ddy_coarse(x[2][0]);
>+    result[2][1] = ddy_coarse(x[2][1]);
>+    result[2][2] = ddy_coarse(x[2][2]);
>+    result[2][3] = ddy_coarse(x[2][3]);
>+    return result;
>+}
>+float4x2 ddy_coarse(float4x2 x) {
>+    float4x2 result;
>+    result[0][0] = ddy_coarse(x[0][0]);
>+    result[0][1] = ddy_coarse(x[0][1]);
>+    result[1][0] = ddy_coarse(x[1][0]);
>+    result[1][1] = ddy_coarse(x[1][1]);
>+    result[2][0] = ddy_coarse(x[2][0]);
>+    result[2][1] = ddy_coarse(x[2][1]);
>+    result[3][0] = ddy_coarse(x[3][0]);
>+    result[3][1] = ddy_coarse(x[3][1]);
>+    return result;
>+}
>+float4x3 ddy_coarse(float4x3 x) {
>+    float4x3 result;
>+    result[0][0] = ddy_coarse(x[0][0]);
>+    result[0][1] = ddy_coarse(x[0][1]);
>+    result[0][2] = ddy_coarse(x[0][2]);
>+    result[1][0] = ddy_coarse(x[1][0]);
>+    result[1][1] = ddy_coarse(x[1][1]);
>+    result[1][2] = ddy_coarse(x[1][2]);
>+    result[2][0] = ddy_coarse(x[2][0]);
>+    result[2][1] = ddy_coarse(x[2][1]);
>+    result[2][2] = ddy_coarse(x[2][2]);
>+    result[3][0] = ddy_coarse(x[3][0]);
>+    result[3][1] = ddy_coarse(x[3][1]);
>+    result[3][2] = ddy_coarse(x[3][2]);
>+    return result;
>+}
>+float4x4 ddy_coarse(float4x4 x) {
>+    float4x4 result;
>+    result[0][0] = ddy_coarse(x[0][0]);
>+    result[0][1] = ddy_coarse(x[0][1]);
>+    result[0][2] = ddy_coarse(x[0][2]);
>+    result[0][3] = ddy_coarse(x[0][3]);
>+    result[1][0] = ddy_coarse(x[1][0]);
>+    result[1][1] = ddy_coarse(x[1][1]);
>+    result[1][2] = ddy_coarse(x[1][2]);
>+    result[1][3] = ddy_coarse(x[1][3]);
>+    result[2][0] = ddy_coarse(x[2][0]);
>+    result[2][1] = ddy_coarse(x[2][1]);
>+    result[2][2] = ddy_coarse(x[2][2]);
>+    result[2][3] = ddy_coarse(x[2][3]);
>+    result[3][0] = ddy_coarse(x[3][0]);
>+    result[3][1] = ddy_coarse(x[3][1]);
>+    result[3][2] = ddy_coarse(x[3][2]);
>+    result[3][3] = ddy_coarse(x[3][3]);
>+    return result;
>+}
>+
>+/* Functions named operator.xyzz */
>+bool4 operator.xyzz(bool3 v) {
>+    bool4 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.z;
>+    result.w = v.z;
>+    return result;
>+}
>+bool4 operator.xyzz(bool4 v) {
>+    bool4 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.z;
>+    result.w = v.z;
>+    return result;
>+}
>+uchar4 operator.xyzz(uchar3 v) {
>+    uchar4 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.z;
>+    result.w = v.z;
>+    return result;
>+}
>+uchar4 operator.xyzz(uchar4 v) {
>+    uchar4 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.z;
>+    result.w = v.z;
>+    return result;
>+}
>+ushort4 operator.xyzz(ushort3 v) {
>+    ushort4 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.z;
>+    result.w = v.z;
>+    return result;
>+}
>+ushort4 operator.xyzz(ushort4 v) {
>+    ushort4 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.z;
>+    result.w = v.z;
>+    return result;
>+}
>+uint4 operator.xyzz(uint3 v) {
>+    uint4 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.z;
>+    result.w = v.z;
>+    return result;
>+}
>+uint4 operator.xyzz(uint4 v) {
>+    uint4 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.z;
>+    result.w = v.z;
>+    return result;
>+}
>+char4 operator.xyzz(char3 v) {
>+    char4 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.z;
>+    result.w = v.z;
>+    return result;
>+}
>+char4 operator.xyzz(char4 v) {
>+    char4 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.z;
>+    result.w = v.z;
>+    return result;
>+}
>+short4 operator.xyzz(short3 v) {
>+    short4 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.z;
>+    result.w = v.z;
>+    return result;
>+}
>+short4 operator.xyzz(short4 v) {
>+    short4 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.z;
>+    result.w = v.z;
>+    return result;
>+}
>+int4 operator.xyzz(int3 v) {
>+    int4 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.z;
>+    result.w = v.z;
>+    return result;
>+}
>+int4 operator.xyzz(int4 v) {
>+    int4 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.z;
>+    result.w = v.z;
>+    return result;
>+}
>+half4 operator.xyzz(half3 v) {
>+    half4 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.z;
>+    result.w = v.z;
>+    return result;
>+}
>+half4 operator.xyzz(half4 v) {
>+    half4 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.z;
>+    result.w = v.z;
>+    return result;
>+}
>+float4 operator.xyzz(float3 v) {
>+    float4 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.z;
>+    result.w = v.z;
>+    return result;
>+}
>+float4 operator.xyzz(float4 v) {
>+    float4 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.z;
>+    result.w = v.z;
>+    return result;
>+}
>+
>+/* Functions named operator++ */
>+uchar operator++(uchar value) {
>+    return value + 1;
>+}
>+ushort operator++(ushort value) {
>+    return value + 1;
>+}
>+uint operator++(uint value) {
>+    return value + 1;
>+}
>+char operator++(char value) {
>+    return value + 1;
>+}
>+short operator++(short value) {
>+    return value + 1;
>+}
>+int operator++(int value) {
>+    return value + 1;
>+}
>+half operator++(half value) {
>+    return value + 1;
>+}
>+float operator++(float value) {
>+    return value + 1;
>+}
>+
>+/* Functions named InterlockedAnd */
>+native void InterlockedAnd(device atomic_uint*, uint, thread uint*);
>+native void InterlockedAnd(device atomic_int*, int, thread int*);
>+native void InterlockedAnd(device atomic_uint*, uint, device uint*);
>+native void InterlockedAnd(device atomic_int*, int, device int*);
>+native void InterlockedAnd(device atomic_uint*, uint, threadgroup uint*);
>+native void InterlockedAnd(device atomic_int*, int, threadgroup int*);
>+native void InterlockedAnd(threadgroup atomic_uint*, uint, thread uint*);
>+native void InterlockedAnd(threadgroup atomic_int*, int, thread int*);
>+native void InterlockedAnd(threadgroup atomic_uint*, uint, device uint*);
>+native void InterlockedAnd(threadgroup atomic_int*, int, device int*);
>+native void InterlockedAnd(threadgroup atomic_uint*, uint, threadgroup uint*);
>+native void InterlockedAnd(threadgroup atomic_int*, int, threadgroup int*);
>+
>+/* Functions named operator.wyzx= */
>+bool4 operator.wyzx=(bool4 v, bool4 c) {
>+    bool4 result = v;
>+    result.w = c.x;
>+    result.y = c.y;
>+    result.z = c.z;
>+    result.x = c.w;
>+    return result;
>+}
>+uchar4 operator.wyzx=(uchar4 v, uchar4 c) {
>+    uchar4 result = v;
>+    result.w = c.x;
>+    result.y = c.y;
>+    result.z = c.z;
>+    result.x = c.w;
>+    return result;
>+}
>+ushort4 operator.wyzx=(ushort4 v, ushort4 c) {
>+    ushort4 result = v;
>+    result.w = c.x;
>+    result.y = c.y;
>+    result.z = c.z;
>+    result.x = c.w;
>+    return result;
>+}
>+uint4 operator.wyzx=(uint4 v, uint4 c) {
>+    uint4 result = v;
>+    result.w = c.x;
>+    result.y = c.y;
>+    result.z = c.z;
>+    result.x = c.w;
>+    return result;
>+}
>+char4 operator.wyzx=(char4 v, char4 c) {
>+    char4 result = v;
>+    result.w = c.x;
>+    result.y = c.y;
>+    result.z = c.z;
>+    result.x = c.w;
>+    return result;
>+}
>+short4 operator.wyzx=(short4 v, short4 c) {
>+    short4 result = v;
>+    result.w = c.x;
>+    result.y = c.y;
>+    result.z = c.z;
>+    result.x = c.w;
>+    return result;
>+}
>+int4 operator.wyzx=(int4 v, int4 c) {
>+    int4 result = v;
>+    result.w = c.x;
>+    result.y = c.y;
>+    result.z = c.z;
>+    result.x = c.w;
>+    return result;
>+}
>+half4 operator.wyzx=(half4 v, half4 c) {
>+    half4 result = v;
>+    result.w = c.x;
>+    result.y = c.y;
>+    result.z = c.z;
>+    result.x = c.w;
>+    return result;
>+}
>+float4 operator.wyzx=(float4 v, float4 c) {
>+    float4 result = v;
>+    result.w = c.x;
>+    result.y = c.y;
>+    result.z = c.z;
>+    result.x = c.w;
>+    return result;
>+}
>+
>+/* Functions named operator.xxwx */
>+bool4 operator.xxwx(bool4 v) {
>+    bool4 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.w;
>+    result.w = v.x;
>+    return result;
>+}
>+uchar4 operator.xxwx(uchar4 v) {
>+    uchar4 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.w;
>+    result.w = v.x;
>+    return result;
>+}
>+ushort4 operator.xxwx(ushort4 v) {
>+    ushort4 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.w;
>+    result.w = v.x;
>+    return result;
>+}
>+uint4 operator.xxwx(uint4 v) {
>+    uint4 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.w;
>+    result.w = v.x;
>+    return result;
>+}
>+char4 operator.xxwx(char4 v) {
>+    char4 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.w;
>+    result.w = v.x;
>+    return result;
>+}
>+short4 operator.xxwx(short4 v) {
>+    short4 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.w;
>+    result.w = v.x;
>+    return result;
>+}
>+int4 operator.xxwx(int4 v) {
>+    int4 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.w;
>+    result.w = v.x;
>+    return result;
>+}
>+half4 operator.xxwx(half4 v) {
>+    half4 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.w;
>+    result.w = v.x;
>+    return result;
>+}
>+float4 operator.xxwx(float4 v) {
>+    float4 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.w;
>+    result.w = v.x;
>+    return result;
>+}
>+
>+/* Functions named operator.xwwx */
>+bool4 operator.xwwx(bool4 v) {
>+    bool4 result;
>+    result.x = v.x;
>+    result.y = v.w;
>+    result.z = v.w;
>+    result.w = v.x;
>+    return result;
>+}
>+uchar4 operator.xwwx(uchar4 v) {
>+    uchar4 result;
>+    result.x = v.x;
>+    result.y = v.w;
>+    result.z = v.w;
>+    result.w = v.x;
>+    return result;
>+}
>+ushort4 operator.xwwx(ushort4 v) {
>+    ushort4 result;
>+    result.x = v.x;
>+    result.y = v.w;
>+    result.z = v.w;
>+    result.w = v.x;
>+    return result;
>+}
>+uint4 operator.xwwx(uint4 v) {
>+    uint4 result;
>+    result.x = v.x;
>+    result.y = v.w;
>+    result.z = v.w;
>+    result.w = v.x;
>+    return result;
>+}
>+char4 operator.xwwx(char4 v) {
>+    char4 result;
>+    result.x = v.x;
>+    result.y = v.w;
>+    result.z = v.w;
>+    result.w = v.x;
>+    return result;
>+}
>+short4 operator.xwwx(short4 v) {
>+    short4 result;
>+    result.x = v.x;
>+    result.y = v.w;
>+    result.z = v.w;
>+    result.w = v.x;
>+    return result;
>+}
>+int4 operator.xwwx(int4 v) {
>+    int4 result;
>+    result.x = v.x;
>+    result.y = v.w;
>+    result.z = v.w;
>+    result.w = v.x;
>+    return result;
>+}
>+half4 operator.xwwx(half4 v) {
>+    half4 result;
>+    result.x = v.x;
>+    result.y = v.w;
>+    result.z = v.w;
>+    result.w = v.x;
>+    return result;
>+}
>+float4 operator.xwwx(float4 v) {
>+    float4 result;
>+    result.x = v.x;
>+    result.y = v.w;
>+    result.z = v.w;
>+    result.w = v.x;
>+    return result;
>+}
>+
>+/* Functions named operator.zy */
>+bool2 operator.zy(bool3 v) {
>+    bool2 result;
>+    result.x = v.z;
>+    result.y = v.y;
>+    return result;
>+}
>+bool2 operator.zy(bool4 v) {
>+    bool2 result;
>+    result.x = v.z;
>+    result.y = v.y;
>+    return result;
>+}
>+uchar2 operator.zy(uchar3 v) {
>+    uchar2 result;
>+    result.x = v.z;
>+    result.y = v.y;
>+    return result;
>+}
>+uchar2 operator.zy(uchar4 v) {
>+    uchar2 result;
>+    result.x = v.z;
>+    result.y = v.y;
>+    return result;
>+}
>+ushort2 operator.zy(ushort3 v) {
>+    ushort2 result;
>+    result.x = v.z;
>+    result.y = v.y;
>+    return result;
>+}
>+ushort2 operator.zy(ushort4 v) {
>+    ushort2 result;
>+    result.x = v.z;
>+    result.y = v.y;
>+    return result;
>+}
>+uint2 operator.zy(uint3 v) {
>+    uint2 result;
>+    result.x = v.z;
>+    result.y = v.y;
>+    return result;
>+}
>+uint2 operator.zy(uint4 v) {
>+    uint2 result;
>+    result.x = v.z;
>+    result.y = v.y;
>+    return result;
>+}
>+char2 operator.zy(char3 v) {
>+    char2 result;
>+    result.x = v.z;
>+    result.y = v.y;
>+    return result;
>+}
>+char2 operator.zy(char4 v) {
>+    char2 result;
>+    result.x = v.z;
>+    result.y = v.y;
>+    return result;
>+}
>+short2 operator.zy(short3 v) {
>+    short2 result;
>+    result.x = v.z;
>+    result.y = v.y;
>+    return result;
>+}
>+short2 operator.zy(short4 v) {
>+    short2 result;
>+    result.x = v.z;
>+    result.y = v.y;
>+    return result;
>+}
>+int2 operator.zy(int3 v) {
>+    int2 result;
>+    result.x = v.z;
>+    result.y = v.y;
>+    return result;
>+}
>+int2 operator.zy(int4 v) {
>+    int2 result;
>+    result.x = v.z;
>+    result.y = v.y;
>+    return result;
>+}
>+half2 operator.zy(half3 v) {
>+    half2 result;
>+    result.x = v.z;
>+    result.y = v.y;
>+    return result;
>+}
>+half2 operator.zy(half4 v) {
>+    half2 result;
>+    result.x = v.z;
>+    result.y = v.y;
>+    return result;
>+}
>+float2 operator.zy(float3 v) {
>+    float2 result;
>+    result.x = v.z;
>+    result.y = v.y;
>+    return result;
>+}
>+float2 operator.zy(float4 v) {
>+    float2 result;
>+    result.x = v.z;
>+    result.y = v.y;
>+    return result;
>+}
>+
>+/* Functions named operator.zyyw */
>+bool4 operator.zyyw(bool4 v) {
>+    bool4 result;
>+    result.x = v.z;
>+    result.y = v.y;
>+    result.z = v.y;
>+    result.w = v.w;
>+    return result;
>+}
>+uchar4 operator.zyyw(uchar4 v) {
>+    uchar4 result;
>+    result.x = v.z;
>+    result.y = v.y;
>+    result.z = v.y;
>+    result.w = v.w;
>+    return result;
>+}
>+ushort4 operator.zyyw(ushort4 v) {
>+    ushort4 result;
>+    result.x = v.z;
>+    result.y = v.y;
>+    result.z = v.y;
>+    result.w = v.w;
>+    return result;
>+}
>+uint4 operator.zyyw(uint4 v) {
>+    uint4 result;
>+    result.x = v.z;
>+    result.y = v.y;
>+    result.z = v.y;
>+    result.w = v.w;
>+    return result;
>+}
>+char4 operator.zyyw(char4 v) {
>+    char4 result;
>+    result.x = v.z;
>+    result.y = v.y;
>+    result.z = v.y;
>+    result.w = v.w;
>+    return result;
>+}
>+short4 operator.zyyw(short4 v) {
>+    short4 result;
>+    result.x = v.z;
>+    result.y = v.y;
>+    result.z = v.y;
>+    result.w = v.w;
>+    return result;
>+}
>+int4 operator.zyyw(int4 v) {
>+    int4 result;
>+    result.x = v.z;
>+    result.y = v.y;
>+    result.z = v.y;
>+    result.w = v.w;
>+    return result;
>+}
>+half4 operator.zyyw(half4 v) {
>+    half4 result;
>+    result.x = v.z;
>+    result.y = v.y;
>+    result.z = v.y;
>+    result.w = v.w;
>+    return result;
>+}
>+float4 operator.zyyw(float4 v) {
>+    float4 result;
>+    result.x = v.z;
>+    result.y = v.y;
>+    result.z = v.y;
>+    result.w = v.w;
>+    return result;
>+}
>+
>+/* Functions named operator.xwzy= */
>+bool4 operator.xwzy=(bool4 v, bool4 c) {
>+    bool4 result = v;
>+    result.x = c.x;
>+    result.w = c.y;
>+    result.z = c.z;
>+    result.y = c.w;
>+    return result;
>+}
>+uchar4 operator.xwzy=(uchar4 v, uchar4 c) {
>+    uchar4 result = v;
>+    result.x = c.x;
>+    result.w = c.y;
>+    result.z = c.z;
>+    result.y = c.w;
>+    return result;
>+}
>+ushort4 operator.xwzy=(ushort4 v, ushort4 c) {
>+    ushort4 result = v;
>+    result.x = c.x;
>+    result.w = c.y;
>+    result.z = c.z;
>+    result.y = c.w;
>+    return result;
>+}
>+uint4 operator.xwzy=(uint4 v, uint4 c) {
>+    uint4 result = v;
>+    result.x = c.x;
>+    result.w = c.y;
>+    result.z = c.z;
>+    result.y = c.w;
>+    return result;
>+}
>+char4 operator.xwzy=(char4 v, char4 c) {
>+    char4 result = v;
>+    result.x = c.x;
>+    result.w = c.y;
>+    result.z = c.z;
>+    result.y = c.w;
>+    return result;
>+}
>+short4 operator.xwzy=(short4 v, short4 c) {
>+    short4 result = v;
>+    result.x = c.x;
>+    result.w = c.y;
>+    result.z = c.z;
>+    result.y = c.w;
>+    return result;
>+}
>+int4 operator.xwzy=(int4 v, int4 c) {
>+    int4 result = v;
>+    result.x = c.x;
>+    result.w = c.y;
>+    result.z = c.z;
>+    result.y = c.w;
>+    return result;
>+}
>+half4 operator.xwzy=(half4 v, half4 c) {
>+    half4 result = v;
>+    result.x = c.x;
>+    result.w = c.y;
>+    result.z = c.z;
>+    result.y = c.w;
>+    return result;
>+}
>+float4 operator.xwzy=(float4 v, float4 c) {
>+    float4 result = v;
>+    result.x = c.x;
>+    result.w = c.y;
>+    result.z = c.z;
>+    result.y = c.w;
>+    return result;
>+}
>+
>+/* Functions named operator~ */
>+bool operator~(bool value) {
>+    return !value;
>+}
>+native int operator~(int);
>+native uint operator~(uint);
>+uchar operator~(uchar a) {
>+    return uchar(~uint(a));
>+}
>+ushort operator~(ushort a) {
>+    return ushort(~uint(a));
>+}
>+char operator~(char a) {
>+    return char(~int(a));
>+}
>+short operator~(short a) {
>+    return short(~int(a));
>+}
>+
>+/* Functions named ddx */
>+native float ddx(float);
>+half ddx(half x) {
>+    return half(ddx(float(x)));
>+}
>+half2 ddx(half2 x) {
>+    half2 result;
>+    result[0] = ddx(x[0]);
>+    result[1] = ddx(x[1]);
>+    return result;
>+}
>+half3 ddx(half3 x) {
>+    half3 result;
>+    result[0] = ddx(x[0]);
>+    result[1] = ddx(x[1]);
>+    result[2] = ddx(x[2]);
>+    return result;
>+}
>+half4 ddx(half4 x) {
>+    half4 result;
>+    result[0] = ddx(x[0]);
>+    result[1] = ddx(x[1]);
>+    result[2] = ddx(x[2]);
>+    result[3] = ddx(x[3]);
>+    return result;
>+}
>+half2x2 ddx(half2x2 x) {
>+    half2x2 result;
>+    result[0][0] = ddx(x[0][0]);
>+    result[0][1] = ddx(x[0][1]);
>+    result[1][0] = ddx(x[1][0]);
>+    result[1][1] = ddx(x[1][1]);
>+    return result;
>+}
>+half2x3 ddx(half2x3 x) {
>+    half2x3 result;
>+    result[0][0] = ddx(x[0][0]);
>+    result[0][1] = ddx(x[0][1]);
>+    result[0][2] = ddx(x[0][2]);
>+    result[1][0] = ddx(x[1][0]);
>+    result[1][1] = ddx(x[1][1]);
>+    result[1][2] = ddx(x[1][2]);
>+    return result;
>+}
>+half2x4 ddx(half2x4 x) {
>+    half2x4 result;
>+    result[0][0] = ddx(x[0][0]);
>+    result[0][1] = ddx(x[0][1]);
>+    result[0][2] = ddx(x[0][2]);
>+    result[0][3] = ddx(x[0][3]);
>+    result[1][0] = ddx(x[1][0]);
>+    result[1][1] = ddx(x[1][1]);
>+    result[1][2] = ddx(x[1][2]);
>+    result[1][3] = ddx(x[1][3]);
>+    return result;
>+}
>+half3x2 ddx(half3x2 x) {
>+    half3x2 result;
>+    result[0][0] = ddx(x[0][0]);
>+    result[0][1] = ddx(x[0][1]);
>+    result[1][0] = ddx(x[1][0]);
>+    result[1][1] = ddx(x[1][1]);
>+    result[2][0] = ddx(x[2][0]);
>+    result[2][1] = ddx(x[2][1]);
>+    return result;
>+}
>+half3x3 ddx(half3x3 x) {
>+    half3x3 result;
>+    result[0][0] = ddx(x[0][0]);
>+    result[0][1] = ddx(x[0][1]);
>+    result[0][2] = ddx(x[0][2]);
>+    result[1][0] = ddx(x[1][0]);
>+    result[1][1] = ddx(x[1][1]);
>+    result[1][2] = ddx(x[1][2]);
>+    result[2][0] = ddx(x[2][0]);
>+    result[2][1] = ddx(x[2][1]);
>+    result[2][2] = ddx(x[2][2]);
>+    return result;
>+}
>+half3x4 ddx(half3x4 x) {
>+    half3x4 result;
>+    result[0][0] = ddx(x[0][0]);
>+    result[0][1] = ddx(x[0][1]);
>+    result[0][2] = ddx(x[0][2]);
>+    result[0][3] = ddx(x[0][3]);
>+    result[1][0] = ddx(x[1][0]);
>+    result[1][1] = ddx(x[1][1]);
>+    result[1][2] = ddx(x[1][2]);
>+    result[1][3] = ddx(x[1][3]);
>+    result[2][0] = ddx(x[2][0]);
>+    result[2][1] = ddx(x[2][1]);
>+    result[2][2] = ddx(x[2][2]);
>+    result[2][3] = ddx(x[2][3]);
>+    return result;
>+}
>+half4x2 ddx(half4x2 x) {
>+    half4x2 result;
>+    result[0][0] = ddx(x[0][0]);
>+    result[0][1] = ddx(x[0][1]);
>+    result[1][0] = ddx(x[1][0]);
>+    result[1][1] = ddx(x[1][1]);
>+    result[2][0] = ddx(x[2][0]);
>+    result[2][1] = ddx(x[2][1]);
>+    result[3][0] = ddx(x[3][0]);
>+    result[3][1] = ddx(x[3][1]);
>+    return result;
>+}
>+half4x3 ddx(half4x3 x) {
>+    half4x3 result;
>+    result[0][0] = ddx(x[0][0]);
>+    result[0][1] = ddx(x[0][1]);
>+    result[0][2] = ddx(x[0][2]);
>+    result[1][0] = ddx(x[1][0]);
>+    result[1][1] = ddx(x[1][1]);
>+    result[1][2] = ddx(x[1][2]);
>+    result[2][0] = ddx(x[2][0]);
>+    result[2][1] = ddx(x[2][1]);
>+    result[2][2] = ddx(x[2][2]);
>+    result[3][0] = ddx(x[3][0]);
>+    result[3][1] = ddx(x[3][1]);
>+    result[3][2] = ddx(x[3][2]);
>+    return result;
>+}
>+half4x4 ddx(half4x4 x) {
>+    half4x4 result;
>+    result[0][0] = ddx(x[0][0]);
>+    result[0][1] = ddx(x[0][1]);
>+    result[0][2] = ddx(x[0][2]);
>+    result[0][3] = ddx(x[0][3]);
>+    result[1][0] = ddx(x[1][0]);
>+    result[1][1] = ddx(x[1][1]);
>+    result[1][2] = ddx(x[1][2]);
>+    result[1][3] = ddx(x[1][3]);
>+    result[2][0] = ddx(x[2][0]);
>+    result[2][1] = ddx(x[2][1]);
>+    result[2][2] = ddx(x[2][2]);
>+    result[2][3] = ddx(x[2][3]);
>+    result[3][0] = ddx(x[3][0]);
>+    result[3][1] = ddx(x[3][1]);
>+    result[3][2] = ddx(x[3][2]);
>+    result[3][3] = ddx(x[3][3]);
>+    return result;
>+}
>+float2 ddx(float2 x) {
>+    float2 result;
>+    result[0] = ddx(x[0]);
>+    result[1] = ddx(x[1]);
>+    return result;
>+}
>+float3 ddx(float3 x) {
>+    float3 result;
>+    result[0] = ddx(x[0]);
>+    result[1] = ddx(x[1]);
>+    result[2] = ddx(x[2]);
>+    return result;
>+}
>+float4 ddx(float4 x) {
>+    float4 result;
>+    result[0] = ddx(x[0]);
>+    result[1] = ddx(x[1]);
>+    result[2] = ddx(x[2]);
>+    result[3] = ddx(x[3]);
>+    return result;
>+}
>+float2x2 ddx(float2x2 x) {
>+    float2x2 result;
>+    result[0][0] = ddx(x[0][0]);
>+    result[0][1] = ddx(x[0][1]);
>+    result[1][0] = ddx(x[1][0]);
>+    result[1][1] = ddx(x[1][1]);
>+    return result;
>+}
>+float2x3 ddx(float2x3 x) {
>+    float2x3 result;
>+    result[0][0] = ddx(x[0][0]);
>+    result[0][1] = ddx(x[0][1]);
>+    result[0][2] = ddx(x[0][2]);
>+    result[1][0] = ddx(x[1][0]);
>+    result[1][1] = ddx(x[1][1]);
>+    result[1][2] = ddx(x[1][2]);
>+    return result;
>+}
>+float2x4 ddx(float2x4 x) {
>+    float2x4 result;
>+    result[0][0] = ddx(x[0][0]);
>+    result[0][1] = ddx(x[0][1]);
>+    result[0][2] = ddx(x[0][2]);
>+    result[0][3] = ddx(x[0][3]);
>+    result[1][0] = ddx(x[1][0]);
>+    result[1][1] = ddx(x[1][1]);
>+    result[1][2] = ddx(x[1][2]);
>+    result[1][3] = ddx(x[1][3]);
>+    return result;
>+}
>+float3x2 ddx(float3x2 x) {
>+    float3x2 result;
>+    result[0][0] = ddx(x[0][0]);
>+    result[0][1] = ddx(x[0][1]);
>+    result[1][0] = ddx(x[1][0]);
>+    result[1][1] = ddx(x[1][1]);
>+    result[2][0] = ddx(x[2][0]);
>+    result[2][1] = ddx(x[2][1]);
>+    return result;
>+}
>+float3x3 ddx(float3x3 x) {
>+    float3x3 result;
>+    result[0][0] = ddx(x[0][0]);
>+    result[0][1] = ddx(x[0][1]);
>+    result[0][2] = ddx(x[0][2]);
>+    result[1][0] = ddx(x[1][0]);
>+    result[1][1] = ddx(x[1][1]);
>+    result[1][2] = ddx(x[1][2]);
>+    result[2][0] = ddx(x[2][0]);
>+    result[2][1] = ddx(x[2][1]);
>+    result[2][2] = ddx(x[2][2]);
>+    return result;
>+}
>+float3x4 ddx(float3x4 x) {
>+    float3x4 result;
>+    result[0][0] = ddx(x[0][0]);
>+    result[0][1] = ddx(x[0][1]);
>+    result[0][2] = ddx(x[0][2]);
>+    result[0][3] = ddx(x[0][3]);
>+    result[1][0] = ddx(x[1][0]);
>+    result[1][1] = ddx(x[1][1]);
>+    result[1][2] = ddx(x[1][2]);
>+    result[1][3] = ddx(x[1][3]);
>+    result[2][0] = ddx(x[2][0]);
>+    result[2][1] = ddx(x[2][1]);
>+    result[2][2] = ddx(x[2][2]);
>+    result[2][3] = ddx(x[2][3]);
>+    return result;
>+}
>+float4x2 ddx(float4x2 x) {
>+    float4x2 result;
>+    result[0][0] = ddx(x[0][0]);
>+    result[0][1] = ddx(x[0][1]);
>+    result[1][0] = ddx(x[1][0]);
>+    result[1][1] = ddx(x[1][1]);
>+    result[2][0] = ddx(x[2][0]);
>+    result[2][1] = ddx(x[2][1]);
>+    result[3][0] = ddx(x[3][0]);
>+    result[3][1] = ddx(x[3][1]);
>+    return result;
>+}
>+float4x3 ddx(float4x3 x) {
>+    float4x3 result;
>+    result[0][0] = ddx(x[0][0]);
>+    result[0][1] = ddx(x[0][1]);
>+    result[0][2] = ddx(x[0][2]);
>+    result[1][0] = ddx(x[1][0]);
>+    result[1][1] = ddx(x[1][1]);
>+    result[1][2] = ddx(x[1][2]);
>+    result[2][0] = ddx(x[2][0]);
>+    result[2][1] = ddx(x[2][1]);
>+    result[2][2] = ddx(x[2][2]);
>+    result[3][0] = ddx(x[3][0]);
>+    result[3][1] = ddx(x[3][1]);
>+    result[3][2] = ddx(x[3][2]);
>+    return result;
>+}
>+float4x4 ddx(float4x4 x) {
>+    float4x4 result;
>+    result[0][0] = ddx(x[0][0]);
>+    result[0][1] = ddx(x[0][1]);
>+    result[0][2] = ddx(x[0][2]);
>+    result[0][3] = ddx(x[0][3]);
>+    result[1][0] = ddx(x[1][0]);
>+    result[1][1] = ddx(x[1][1]);
>+    result[1][2] = ddx(x[1][2]);
>+    result[1][3] = ddx(x[1][3]);
>+    result[2][0] = ddx(x[2][0]);
>+    result[2][1] = ddx(x[2][1]);
>+    result[2][2] = ddx(x[2][2]);
>+    result[2][3] = ddx(x[2][3]);
>+    result[3][0] = ddx(x[3][0]);
>+    result[3][1] = ddx(x[3][1]);
>+    result[3][2] = ddx(x[3][2]);
>+    result[3][3] = ddx(x[3][3]);
>+    return result;
>+}
>+
>+/* Functions named operator.zzyx */
>+bool4 operator.zzyx(bool3 v) {
>+    bool4 result;
>+    result.x = v.z;
>+    result.y = v.z;
>+    result.z = v.y;
>+    result.w = v.x;
>+    return result;
>+}
>+bool4 operator.zzyx(bool4 v) {
>+    bool4 result;
>+    result.x = v.z;
>+    result.y = v.z;
>+    result.z = v.y;
>+    result.w = v.x;
>+    return result;
>+}
>+uchar4 operator.zzyx(uchar3 v) {
>+    uchar4 result;
>+    result.x = v.z;
>+    result.y = v.z;
>+    result.z = v.y;
>+    result.w = v.x;
>+    return result;
>+}
>+uchar4 operator.zzyx(uchar4 v) {
>+    uchar4 result;
>+    result.x = v.z;
>+    result.y = v.z;
>+    result.z = v.y;
>+    result.w = v.x;
>+    return result;
>+}
>+ushort4 operator.zzyx(ushort3 v) {
>+    ushort4 result;
>+    result.x = v.z;
>+    result.y = v.z;
>+    result.z = v.y;
>+    result.w = v.x;
>+    return result;
>+}
>+ushort4 operator.zzyx(ushort4 v) {
>+    ushort4 result;
>+    result.x = v.z;
>+    result.y = v.z;
>+    result.z = v.y;
>+    result.w = v.x;
>+    return result;
>+}
>+uint4 operator.zzyx(uint3 v) {
>+    uint4 result;
>+    result.x = v.z;
>+    result.y = v.z;
>+    result.z = v.y;
>+    result.w = v.x;
>+    return result;
>+}
>+uint4 operator.zzyx(uint4 v) {
>+    uint4 result;
>+    result.x = v.z;
>+    result.y = v.z;
>+    result.z = v.y;
>+    result.w = v.x;
>+    return result;
>+}
>+char4 operator.zzyx(char3 v) {
>+    char4 result;
>+    result.x = v.z;
>+    result.y = v.z;
>+    result.z = v.y;
>+    result.w = v.x;
>+    return result;
>+}
>+char4 operator.zzyx(char4 v) {
>+    char4 result;
>+    result.x = v.z;
>+    result.y = v.z;
>+    result.z = v.y;
>+    result.w = v.x;
>+    return result;
>+}
>+short4 operator.zzyx(short3 v) {
>+    short4 result;
>+    result.x = v.z;
>+    result.y = v.z;
>+    result.z = v.y;
>+    result.w = v.x;
>+    return result;
>+}
>+short4 operator.zzyx(short4 v) {
>+    short4 result;
>+    result.x = v.z;
>+    result.y = v.z;
>+    result.z = v.y;
>+    result.w = v.x;
>+    return result;
>+}
>+int4 operator.zzyx(int3 v) {
>+    int4 result;
>+    result.x = v.z;
>+    result.y = v.z;
>+    result.z = v.y;
>+    result.w = v.x;
>+    return result;
>+}
>+int4 operator.zzyx(int4 v) {
>+    int4 result;
>+    result.x = v.z;
>+    result.y = v.z;
>+    result.z = v.y;
>+    result.w = v.x;
>+    return result;
>+}
>+half4 operator.zzyx(half3 v) {
>+    half4 result;
>+    result.x = v.z;
>+    result.y = v.z;
>+    result.z = v.y;
>+    result.w = v.x;
>+    return result;
>+}
>+half4 operator.zzyx(half4 v) {
>+    half4 result;
>+    result.x = v.z;
>+    result.y = v.z;
>+    result.z = v.y;
>+    result.w = v.x;
>+    return result;
>+}
>+float4 operator.zzyx(float3 v) {
>+    float4 result;
>+    result.x = v.z;
>+    result.y = v.z;
>+    result.z = v.y;
>+    result.w = v.x;
>+    return result;
>+}
>+float4 operator.zzyx(float4 v) {
>+    float4 result;
>+    result.x = v.z;
>+    result.y = v.z;
>+    result.z = v.y;
>+    result.w = v.x;
>+    return result;
>+}
>+
>+/* Functions named operator.xwzz */
>+bool4 operator.xwzz(bool4 v) {
>+    bool4 result;
>+    result.x = v.x;
>+    result.y = v.w;
>+    result.z = v.z;
>+    result.w = v.z;
>+    return result;
>+}
>+uchar4 operator.xwzz(uchar4 v) {
>+    uchar4 result;
>+    result.x = v.x;
>+    result.y = v.w;
>+    result.z = v.z;
>+    result.w = v.z;
>+    return result;
>+}
>+ushort4 operator.xwzz(ushort4 v) {
>+    ushort4 result;
>+    result.x = v.x;
>+    result.y = v.w;
>+    result.z = v.z;
>+    result.w = v.z;
>+    return result;
>+}
>+uint4 operator.xwzz(uint4 v) {
>+    uint4 result;
>+    result.x = v.x;
>+    result.y = v.w;
>+    result.z = v.z;
>+    result.w = v.z;
>+    return result;
>+}
>+char4 operator.xwzz(char4 v) {
>+    char4 result;
>+    result.x = v.x;
>+    result.y = v.w;
>+    result.z = v.z;
>+    result.w = v.z;
>+    return result;
>+}
>+short4 operator.xwzz(short4 v) {
>+    short4 result;
>+    result.x = v.x;
>+    result.y = v.w;
>+    result.z = v.z;
>+    result.w = v.z;
>+    return result;
>+}
>+int4 operator.xwzz(int4 v) {
>+    int4 result;
>+    result.x = v.x;
>+    result.y = v.w;
>+    result.z = v.z;
>+    result.w = v.z;
>+    return result;
>+}
>+half4 operator.xwzz(half4 v) {
>+    half4 result;
>+    result.x = v.x;
>+    result.y = v.w;
>+    result.z = v.z;
>+    result.w = v.z;
>+    return result;
>+}
>+float4 operator.xwzz(float4 v) {
>+    float4 result;
>+    result.x = v.x;
>+    result.y = v.w;
>+    result.z = v.z;
>+    result.w = v.z;
>+    return result;
>+}
>+
>+/* Functions named operator.wywx */
>+bool4 operator.wywx(bool4 v) {
>+    bool4 result;
>+    result.x = v.w;
>+    result.y = v.y;
>+    result.z = v.w;
>+    result.w = v.x;
>+    return result;
>+}
>+uchar4 operator.wywx(uchar4 v) {
>+    uchar4 result;
>+    result.x = v.w;
>+    result.y = v.y;
>+    result.z = v.w;
>+    result.w = v.x;
>+    return result;
>+}
>+ushort4 operator.wywx(ushort4 v) {
>+    ushort4 result;
>+    result.x = v.w;
>+    result.y = v.y;
>+    result.z = v.w;
>+    result.w = v.x;
>+    return result;
>+}
>+uint4 operator.wywx(uint4 v) {
>+    uint4 result;
>+    result.x = v.w;
>+    result.y = v.y;
>+    result.z = v.w;
>+    result.w = v.x;
>+    return result;
>+}
>+char4 operator.wywx(char4 v) {
>+    char4 result;
>+    result.x = v.w;
>+    result.y = v.y;
>+    result.z = v.w;
>+    result.w = v.x;
>+    return result;
>+}
>+short4 operator.wywx(short4 v) {
>+    short4 result;
>+    result.x = v.w;
>+    result.y = v.y;
>+    result.z = v.w;
>+    result.w = v.x;
>+    return result;
>+}
>+int4 operator.wywx(int4 v) {
>+    int4 result;
>+    result.x = v.w;
>+    result.y = v.y;
>+    result.z = v.w;
>+    result.w = v.x;
>+    return result;
>+}
>+half4 operator.wywx(half4 v) {
>+    half4 result;
>+    result.x = v.w;
>+    result.y = v.y;
>+    result.z = v.w;
>+    result.w = v.x;
>+    return result;
>+}
>+float4 operator.wywx(float4 v) {
>+    float4 result;
>+    result.x = v.w;
>+    result.y = v.y;
>+    result.z = v.w;
>+    result.w = v.x;
>+    return result;
>+}
>+
>+/* Functions named InterlockedMax */
>+native void InterlockedMax(device atomic_uint*, uint, thread uint*);
>+native void InterlockedMax(device atomic_int*, int, thread int*);
>+native void InterlockedMax(device atomic_uint*, uint, device uint*);
>+native void InterlockedMax(device atomic_int*, int, device int*);
>+native void InterlockedMax(device atomic_uint*, uint, threadgroup uint*);
>+native void InterlockedMax(device atomic_int*, int, threadgroup int*);
>+native void InterlockedMax(threadgroup atomic_uint*, uint, thread uint*);
>+native void InterlockedMax(threadgroup atomic_int*, int, thread int*);
>+native void InterlockedMax(threadgroup atomic_uint*, uint, device uint*);
>+native void InterlockedMax(threadgroup atomic_int*, int, device int*);
>+native void InterlockedMax(threadgroup atomic_uint*, uint, threadgroup uint*);
>+native void InterlockedMax(threadgroup atomic_int*, int, threadgroup int*);
>+
>+/* Functions named cosh */
>+native float cosh(float);
>+half cosh(half x) {
>+    return half(cosh(float(x)));
>+}
>+half2 cosh(half2 x) {
>+    half2 result;
>+    result[0] = cosh(x[0]);
>+    result[1] = cosh(x[1]);
>+    return result;
>+}
>+half3 cosh(half3 x) {
>+    half3 result;
>+    result[0] = cosh(x[0]);
>+    result[1] = cosh(x[1]);
>+    result[2] = cosh(x[2]);
>+    return result;
>+}
>+half4 cosh(half4 x) {
>+    half4 result;
>+    result[0] = cosh(x[0]);
>+    result[1] = cosh(x[1]);
>+    result[2] = cosh(x[2]);
>+    result[3] = cosh(x[3]);
>+    return result;
>+}
>+half2x2 cosh(half2x2 x) {
>+    half2x2 result;
>+    result[0][0] = cosh(x[0][0]);
>+    result[0][1] = cosh(x[0][1]);
>+    result[1][0] = cosh(x[1][0]);
>+    result[1][1] = cosh(x[1][1]);
>+    return result;
>+}
>+half2x3 cosh(half2x3 x) {
>+    half2x3 result;
>+    result[0][0] = cosh(x[0][0]);
>+    result[0][1] = cosh(x[0][1]);
>+    result[0][2] = cosh(x[0][2]);
>+    result[1][0] = cosh(x[1][0]);
>+    result[1][1] = cosh(x[1][1]);
>+    result[1][2] = cosh(x[1][2]);
>+    return result;
>+}
>+half2x4 cosh(half2x4 x) {
>+    half2x4 result;
>+    result[0][0] = cosh(x[0][0]);
>+    result[0][1] = cosh(x[0][1]);
>+    result[0][2] = cosh(x[0][2]);
>+    result[0][3] = cosh(x[0][3]);
>+    result[1][0] = cosh(x[1][0]);
>+    result[1][1] = cosh(x[1][1]);
>+    result[1][2] = cosh(x[1][2]);
>+    result[1][3] = cosh(x[1][3]);
>+    return result;
>+}
>+half3x2 cosh(half3x2 x) {
>+    half3x2 result;
>+    result[0][0] = cosh(x[0][0]);
>+    result[0][1] = cosh(x[0][1]);
>+    result[1][0] = cosh(x[1][0]);
>+    result[1][1] = cosh(x[1][1]);
>+    result[2][0] = cosh(x[2][0]);
>+    result[2][1] = cosh(x[2][1]);
>+    return result;
>+}
>+half3x3 cosh(half3x3 x) {
>+    half3x3 result;
>+    result[0][0] = cosh(x[0][0]);
>+    result[0][1] = cosh(x[0][1]);
>+    result[0][2] = cosh(x[0][2]);
>+    result[1][0] = cosh(x[1][0]);
>+    result[1][1] = cosh(x[1][1]);
>+    result[1][2] = cosh(x[1][2]);
>+    result[2][0] = cosh(x[2][0]);
>+    result[2][1] = cosh(x[2][1]);
>+    result[2][2] = cosh(x[2][2]);
>+    return result;
>+}
>+half3x4 cosh(half3x4 x) {
>+    half3x4 result;
>+    result[0][0] = cosh(x[0][0]);
>+    result[0][1] = cosh(x[0][1]);
>+    result[0][2] = cosh(x[0][2]);
>+    result[0][3] = cosh(x[0][3]);
>+    result[1][0] = cosh(x[1][0]);
>+    result[1][1] = cosh(x[1][1]);
>+    result[1][2] = cosh(x[1][2]);
>+    result[1][3] = cosh(x[1][3]);
>+    result[2][0] = cosh(x[2][0]);
>+    result[2][1] = cosh(x[2][1]);
>+    result[2][2] = cosh(x[2][2]);
>+    result[2][3] = cosh(x[2][3]);
>+    return result;
>+}
>+half4x2 cosh(half4x2 x) {
>+    half4x2 result;
>+    result[0][0] = cosh(x[0][0]);
>+    result[0][1] = cosh(x[0][1]);
>+    result[1][0] = cosh(x[1][0]);
>+    result[1][1] = cosh(x[1][1]);
>+    result[2][0] = cosh(x[2][0]);
>+    result[2][1] = cosh(x[2][1]);
>+    result[3][0] = cosh(x[3][0]);
>+    result[3][1] = cosh(x[3][1]);
>+    return result;
>+}
>+half4x3 cosh(half4x3 x) {
>+    half4x3 result;
>+    result[0][0] = cosh(x[0][0]);
>+    result[0][1] = cosh(x[0][1]);
>+    result[0][2] = cosh(x[0][2]);
>+    result[1][0] = cosh(x[1][0]);
>+    result[1][1] = cosh(x[1][1]);
>+    result[1][2] = cosh(x[1][2]);
>+    result[2][0] = cosh(x[2][0]);
>+    result[2][1] = cosh(x[2][1]);
>+    result[2][2] = cosh(x[2][2]);
>+    result[3][0] = cosh(x[3][0]);
>+    result[3][1] = cosh(x[3][1]);
>+    result[3][2] = cosh(x[3][2]);
>+    return result;
>+}
>+half4x4 cosh(half4x4 x) {
>+    half4x4 result;
>+    result[0][0] = cosh(x[0][0]);
>+    result[0][1] = cosh(x[0][1]);
>+    result[0][2] = cosh(x[0][2]);
>+    result[0][3] = cosh(x[0][3]);
>+    result[1][0] = cosh(x[1][0]);
>+    result[1][1] = cosh(x[1][1]);
>+    result[1][2] = cosh(x[1][2]);
>+    result[1][3] = cosh(x[1][3]);
>+    result[2][0] = cosh(x[2][0]);
>+    result[2][1] = cosh(x[2][1]);
>+    result[2][2] = cosh(x[2][2]);
>+    result[2][3] = cosh(x[2][3]);
>+    result[3][0] = cosh(x[3][0]);
>+    result[3][1] = cosh(x[3][1]);
>+    result[3][2] = cosh(x[3][2]);
>+    result[3][3] = cosh(x[3][3]);
>+    return result;
>+}
>+float2 cosh(float2 x) {
>+    float2 result;
>+    result[0] = cosh(x[0]);
>+    result[1] = cosh(x[1]);
>+    return result;
>+}
>+float3 cosh(float3 x) {
>+    float3 result;
>+    result[0] = cosh(x[0]);
>+    result[1] = cosh(x[1]);
>+    result[2] = cosh(x[2]);
>+    return result;
>+}
>+float4 cosh(float4 x) {
>+    float4 result;
>+    result[0] = cosh(x[0]);
>+    result[1] = cosh(x[1]);
>+    result[2] = cosh(x[2]);
>+    result[3] = cosh(x[3]);
>+    return result;
>+}
>+float2x2 cosh(float2x2 x) {
>+    float2x2 result;
>+    result[0][0] = cosh(x[0][0]);
>+    result[0][1] = cosh(x[0][1]);
>+    result[1][0] = cosh(x[1][0]);
>+    result[1][1] = cosh(x[1][1]);
>+    return result;
>+}
>+float2x3 cosh(float2x3 x) {
>+    float2x3 result;
>+    result[0][0] = cosh(x[0][0]);
>+    result[0][1] = cosh(x[0][1]);
>+    result[0][2] = cosh(x[0][2]);
>+    result[1][0] = cosh(x[1][0]);
>+    result[1][1] = cosh(x[1][1]);
>+    result[1][2] = cosh(x[1][2]);
>+    return result;
>+}
>+float2x4 cosh(float2x4 x) {
>+    float2x4 result;
>+    result[0][0] = cosh(x[0][0]);
>+    result[0][1] = cosh(x[0][1]);
>+    result[0][2] = cosh(x[0][2]);
>+    result[0][3] = cosh(x[0][3]);
>+    result[1][0] = cosh(x[1][0]);
>+    result[1][1] = cosh(x[1][1]);
>+    result[1][2] = cosh(x[1][2]);
>+    result[1][3] = cosh(x[1][3]);
>+    return result;
>+}
>+float3x2 cosh(float3x2 x) {
>+    float3x2 result;
>+    result[0][0] = cosh(x[0][0]);
>+    result[0][1] = cosh(x[0][1]);
>+    result[1][0] = cosh(x[1][0]);
>+    result[1][1] = cosh(x[1][1]);
>+    result[2][0] = cosh(x[2][0]);
>+    result[2][1] = cosh(x[2][1]);
>+    return result;
>+}
>+float3x3 cosh(float3x3 x) {
>+    float3x3 result;
>+    result[0][0] = cosh(x[0][0]);
>+    result[0][1] = cosh(x[0][1]);
>+    result[0][2] = cosh(x[0][2]);
>+    result[1][0] = cosh(x[1][0]);
>+    result[1][1] = cosh(x[1][1]);
>+    result[1][2] = cosh(x[1][2]);
>+    result[2][0] = cosh(x[2][0]);
>+    result[2][1] = cosh(x[2][1]);
>+    result[2][2] = cosh(x[2][2]);
>+    return result;
>+}
>+float3x4 cosh(float3x4 x) {
>+    float3x4 result;
>+    result[0][0] = cosh(x[0][0]);
>+    result[0][1] = cosh(x[0][1]);
>+    result[0][2] = cosh(x[0][2]);
>+    result[0][3] = cosh(x[0][3]);
>+    result[1][0] = cosh(x[1][0]);
>+    result[1][1] = cosh(x[1][1]);
>+    result[1][2] = cosh(x[1][2]);
>+    result[1][3] = cosh(x[1][3]);
>+    result[2][0] = cosh(x[2][0]);
>+    result[2][1] = cosh(x[2][1]);
>+    result[2][2] = cosh(x[2][2]);
>+    result[2][3] = cosh(x[2][3]);
>+    return result;
>+}
>+float4x2 cosh(float4x2 x) {
>+    float4x2 result;
>+    result[0][0] = cosh(x[0][0]);
>+    result[0][1] = cosh(x[0][1]);
>+    result[1][0] = cosh(x[1][0]);
>+    result[1][1] = cosh(x[1][1]);
>+    result[2][0] = cosh(x[2][0]);
>+    result[2][1] = cosh(x[2][1]);
>+    result[3][0] = cosh(x[3][0]);
>+    result[3][1] = cosh(x[3][1]);
>+    return result;
>+}
>+float4x3 cosh(float4x3 x) {
>+    float4x3 result;
>+    result[0][0] = cosh(x[0][0]);
>+    result[0][1] = cosh(x[0][1]);
>+    result[0][2] = cosh(x[0][2]);
>+    result[1][0] = cosh(x[1][0]);
>+    result[1][1] = cosh(x[1][1]);
>+    result[1][2] = cosh(x[1][2]);
>+    result[2][0] = cosh(x[2][0]);
>+    result[2][1] = cosh(x[2][1]);
>+    result[2][2] = cosh(x[2][2]);
>+    result[3][0] = cosh(x[3][0]);
>+    result[3][1] = cosh(x[3][1]);
>+    result[3][2] = cosh(x[3][2]);
>+    return result;
>+}
>+float4x4 cosh(float4x4 x) {
>+    float4x4 result;
>+    result[0][0] = cosh(x[0][0]);
>+    result[0][1] = cosh(x[0][1]);
>+    result[0][2] = cosh(x[0][2]);
>+    result[0][3] = cosh(x[0][3]);
>+    result[1][0] = cosh(x[1][0]);
>+    result[1][1] = cosh(x[1][1]);
>+    result[1][2] = cosh(x[1][2]);
>+    result[1][3] = cosh(x[1][3]);
>+    result[2][0] = cosh(x[2][0]);
>+    result[2][1] = cosh(x[2][1]);
>+    result[2][2] = cosh(x[2][2]);
>+    result[2][3] = cosh(x[2][3]);
>+    result[3][0] = cosh(x[3][0]);
>+    result[3][1] = cosh(x[3][1]);
>+    result[3][2] = cosh(x[3][2]);
>+    result[3][3] = cosh(x[3][3]);
>+    return result;
>+}
>+
>+/* Functions named ddx_coarse */
>+half ddx_coarse(half x) {
>+    return ddx(x);
>+}
>+half2 ddx_coarse(half2 x) {
>+    half2 result;
>+    result[0] = ddx_coarse(x[0]);
>+    result[1] = ddx_coarse(x[1]);
>+    return result;
>+}
>+half3 ddx_coarse(half3 x) {
>+    half3 result;
>+    result[0] = ddx_coarse(x[0]);
>+    result[1] = ddx_coarse(x[1]);
>+    result[2] = ddx_coarse(x[2]);
>+    return result;
>+}
>+half4 ddx_coarse(half4 x) {
>+    half4 result;
>+    result[0] = ddx_coarse(x[0]);
>+    result[1] = ddx_coarse(x[1]);
>+    result[2] = ddx_coarse(x[2]);
>+    result[3] = ddx_coarse(x[3]);
>+    return result;
>+}
>+half2x2 ddx_coarse(half2x2 x) {
>+    half2x2 result;
>+    result[0][0] = ddx_coarse(x[0][0]);
>+    result[0][1] = ddx_coarse(x[0][1]);
>+    result[1][0] = ddx_coarse(x[1][0]);
>+    result[1][1] = ddx_coarse(x[1][1]);
>+    return result;
>+}
>+half2x3 ddx_coarse(half2x3 x) {
>+    half2x3 result;
>+    result[0][0] = ddx_coarse(x[0][0]);
>+    result[0][1] = ddx_coarse(x[0][1]);
>+    result[0][2] = ddx_coarse(x[0][2]);
>+    result[1][0] = ddx_coarse(x[1][0]);
>+    result[1][1] = ddx_coarse(x[1][1]);
>+    result[1][2] = ddx_coarse(x[1][2]);
>+    return result;
>+}
>+half2x4 ddx_coarse(half2x4 x) {
>+    half2x4 result;
>+    result[0][0] = ddx_coarse(x[0][0]);
>+    result[0][1] = ddx_coarse(x[0][1]);
>+    result[0][2] = ddx_coarse(x[0][2]);
>+    result[0][3] = ddx_coarse(x[0][3]);
>+    result[1][0] = ddx_coarse(x[1][0]);
>+    result[1][1] = ddx_coarse(x[1][1]);
>+    result[1][2] = ddx_coarse(x[1][2]);
>+    result[1][3] = ddx_coarse(x[1][3]);
>+    return result;
>+}
>+half3x2 ddx_coarse(half3x2 x) {
>+    half3x2 result;
>+    result[0][0] = ddx_coarse(x[0][0]);
>+    result[0][1] = ddx_coarse(x[0][1]);
>+    result[1][0] = ddx_coarse(x[1][0]);
>+    result[1][1] = ddx_coarse(x[1][1]);
>+    result[2][0] = ddx_coarse(x[2][0]);
>+    result[2][1] = ddx_coarse(x[2][1]);
>+    return result;
>+}
>+half3x3 ddx_coarse(half3x3 x) {
>+    half3x3 result;
>+    result[0][0] = ddx_coarse(x[0][0]);
>+    result[0][1] = ddx_coarse(x[0][1]);
>+    result[0][2] = ddx_coarse(x[0][2]);
>+    result[1][0] = ddx_coarse(x[1][0]);
>+    result[1][1] = ddx_coarse(x[1][1]);
>+    result[1][2] = ddx_coarse(x[1][2]);
>+    result[2][0] = ddx_coarse(x[2][0]);
>+    result[2][1] = ddx_coarse(x[2][1]);
>+    result[2][2] = ddx_coarse(x[2][2]);
>+    return result;
>+}
>+half3x4 ddx_coarse(half3x4 x) {
>+    half3x4 result;
>+    result[0][0] = ddx_coarse(x[0][0]);
>+    result[0][1] = ddx_coarse(x[0][1]);
>+    result[0][2] = ddx_coarse(x[0][2]);
>+    result[0][3] = ddx_coarse(x[0][3]);
>+    result[1][0] = ddx_coarse(x[1][0]);
>+    result[1][1] = ddx_coarse(x[1][1]);
>+    result[1][2] = ddx_coarse(x[1][2]);
>+    result[1][3] = ddx_coarse(x[1][3]);
>+    result[2][0] = ddx_coarse(x[2][0]);
>+    result[2][1] = ddx_coarse(x[2][1]);
>+    result[2][2] = ddx_coarse(x[2][2]);
>+    result[2][3] = ddx_coarse(x[2][3]);
>+    return result;
>+}
>+half4x2 ddx_coarse(half4x2 x) {
>+    half4x2 result;
>+    result[0][0] = ddx_coarse(x[0][0]);
>+    result[0][1] = ddx_coarse(x[0][1]);
>+    result[1][0] = ddx_coarse(x[1][0]);
>+    result[1][1] = ddx_coarse(x[1][1]);
>+    result[2][0] = ddx_coarse(x[2][0]);
>+    result[2][1] = ddx_coarse(x[2][1]);
>+    result[3][0] = ddx_coarse(x[3][0]);
>+    result[3][1] = ddx_coarse(x[3][1]);
>+    return result;
>+}
>+half4x3 ddx_coarse(half4x3 x) {
>+    half4x3 result;
>+    result[0][0] = ddx_coarse(x[0][0]);
>+    result[0][1] = ddx_coarse(x[0][1]);
>+    result[0][2] = ddx_coarse(x[0][2]);
>+    result[1][0] = ddx_coarse(x[1][0]);
>+    result[1][1] = ddx_coarse(x[1][1]);
>+    result[1][2] = ddx_coarse(x[1][2]);
>+    result[2][0] = ddx_coarse(x[2][0]);
>+    result[2][1] = ddx_coarse(x[2][1]);
>+    result[2][2] = ddx_coarse(x[2][2]);
>+    result[3][0] = ddx_coarse(x[3][0]);
>+    result[3][1] = ddx_coarse(x[3][1]);
>+    result[3][2] = ddx_coarse(x[3][2]);
>+    return result;
>+}
>+half4x4 ddx_coarse(half4x4 x) {
>+    half4x4 result;
>+    result[0][0] = ddx_coarse(x[0][0]);
>+    result[0][1] = ddx_coarse(x[0][1]);
>+    result[0][2] = ddx_coarse(x[0][2]);
>+    result[0][3] = ddx_coarse(x[0][3]);
>+    result[1][0] = ddx_coarse(x[1][0]);
>+    result[1][1] = ddx_coarse(x[1][1]);
>+    result[1][2] = ddx_coarse(x[1][2]);
>+    result[1][3] = ddx_coarse(x[1][3]);
>+    result[2][0] = ddx_coarse(x[2][0]);
>+    result[2][1] = ddx_coarse(x[2][1]);
>+    result[2][2] = ddx_coarse(x[2][2]);
>+    result[2][3] = ddx_coarse(x[2][3]);
>+    result[3][0] = ddx_coarse(x[3][0]);
>+    result[3][1] = ddx_coarse(x[3][1]);
>+    result[3][2] = ddx_coarse(x[3][2]);
>+    result[3][3] = ddx_coarse(x[3][3]);
>+    return result;
>+}
>+float ddx_coarse(float x) {
>+    return ddx(x);
>+}
>+float2 ddx_coarse(float2 x) {
>+    float2 result;
>+    result[0] = ddx_coarse(x[0]);
>+    result[1] = ddx_coarse(x[1]);
>+    return result;
>+}
>+float3 ddx_coarse(float3 x) {
>+    float3 result;
>+    result[0] = ddx_coarse(x[0]);
>+    result[1] = ddx_coarse(x[1]);
>+    result[2] = ddx_coarse(x[2]);
>+    return result;
>+}
>+float4 ddx_coarse(float4 x) {
>+    float4 result;
>+    result[0] = ddx_coarse(x[0]);
>+    result[1] = ddx_coarse(x[1]);
>+    result[2] = ddx_coarse(x[2]);
>+    result[3] = ddx_coarse(x[3]);
>+    return result;
>+}
>+float2x2 ddx_coarse(float2x2 x) {
>+    float2x2 result;
>+    result[0][0] = ddx_coarse(x[0][0]);
>+    result[0][1] = ddx_coarse(x[0][1]);
>+    result[1][0] = ddx_coarse(x[1][0]);
>+    result[1][1] = ddx_coarse(x[1][1]);
>+    return result;
>+}
>+float2x3 ddx_coarse(float2x3 x) {
>+    float2x3 result;
>+    result[0][0] = ddx_coarse(x[0][0]);
>+    result[0][1] = ddx_coarse(x[0][1]);
>+    result[0][2] = ddx_coarse(x[0][2]);
>+    result[1][0] = ddx_coarse(x[1][0]);
>+    result[1][1] = ddx_coarse(x[1][1]);
>+    result[1][2] = ddx_coarse(x[1][2]);
>+    return result;
>+}
>+float2x4 ddx_coarse(float2x4 x) {
>+    float2x4 result;
>+    result[0][0] = ddx_coarse(x[0][0]);
>+    result[0][1] = ddx_coarse(x[0][1]);
>+    result[0][2] = ddx_coarse(x[0][2]);
>+    result[0][3] = ddx_coarse(x[0][3]);
>+    result[1][0] = ddx_coarse(x[1][0]);
>+    result[1][1] = ddx_coarse(x[1][1]);
>+    result[1][2] = ddx_coarse(x[1][2]);
>+    result[1][3] = ddx_coarse(x[1][3]);
>+    return result;
>+}
>+float3x2 ddx_coarse(float3x2 x) {
>+    float3x2 result;
>+    result[0][0] = ddx_coarse(x[0][0]);
>+    result[0][1] = ddx_coarse(x[0][1]);
>+    result[1][0] = ddx_coarse(x[1][0]);
>+    result[1][1] = ddx_coarse(x[1][1]);
>+    result[2][0] = ddx_coarse(x[2][0]);
>+    result[2][1] = ddx_coarse(x[2][1]);
>+    return result;
>+}
>+float3x3 ddx_coarse(float3x3 x) {
>+    float3x3 result;
>+    result[0][0] = ddx_coarse(x[0][0]);
>+    result[0][1] = ddx_coarse(x[0][1]);
>+    result[0][2] = ddx_coarse(x[0][2]);
>+    result[1][0] = ddx_coarse(x[1][0]);
>+    result[1][1] = ddx_coarse(x[1][1]);
>+    result[1][2] = ddx_coarse(x[1][2]);
>+    result[2][0] = ddx_coarse(x[2][0]);
>+    result[2][1] = ddx_coarse(x[2][1]);
>+    result[2][2] = ddx_coarse(x[2][2]);
>+    return result;
>+}
>+float3x4 ddx_coarse(float3x4 x) {
>+    float3x4 result;
>+    result[0][0] = ddx_coarse(x[0][0]);
>+    result[0][1] = ddx_coarse(x[0][1]);
>+    result[0][2] = ddx_coarse(x[0][2]);
>+    result[0][3] = ddx_coarse(x[0][3]);
>+    result[1][0] = ddx_coarse(x[1][0]);
>+    result[1][1] = ddx_coarse(x[1][1]);
>+    result[1][2] = ddx_coarse(x[1][2]);
>+    result[1][3] = ddx_coarse(x[1][3]);
>+    result[2][0] = ddx_coarse(x[2][0]);
>+    result[2][1] = ddx_coarse(x[2][1]);
>+    result[2][2] = ddx_coarse(x[2][2]);
>+    result[2][3] = ddx_coarse(x[2][3]);
>+    return result;
>+}
>+float4x2 ddx_coarse(float4x2 x) {
>+    float4x2 result;
>+    result[0][0] = ddx_coarse(x[0][0]);
>+    result[0][1] = ddx_coarse(x[0][1]);
>+    result[1][0] = ddx_coarse(x[1][0]);
>+    result[1][1] = ddx_coarse(x[1][1]);
>+    result[2][0] = ddx_coarse(x[2][0]);
>+    result[2][1] = ddx_coarse(x[2][1]);
>+    result[3][0] = ddx_coarse(x[3][0]);
>+    result[3][1] = ddx_coarse(x[3][1]);
>+    return result;
>+}
>+float4x3 ddx_coarse(float4x3 x) {
>+    float4x3 result;
>+    result[0][0] = ddx_coarse(x[0][0]);
>+    result[0][1] = ddx_coarse(x[0][1]);
>+    result[0][2] = ddx_coarse(x[0][2]);
>+    result[1][0] = ddx_coarse(x[1][0]);
>+    result[1][1] = ddx_coarse(x[1][1]);
>+    result[1][2] = ddx_coarse(x[1][2]);
>+    result[2][0] = ddx_coarse(x[2][0]);
>+    result[2][1] = ddx_coarse(x[2][1]);
>+    result[2][2] = ddx_coarse(x[2][2]);
>+    result[3][0] = ddx_coarse(x[3][0]);
>+    result[3][1] = ddx_coarse(x[3][1]);
>+    result[3][2] = ddx_coarse(x[3][2]);
>+    return result;
>+}
>+float4x4 ddx_coarse(float4x4 x) {
>+    float4x4 result;
>+    result[0][0] = ddx_coarse(x[0][0]);
>+    result[0][1] = ddx_coarse(x[0][1]);
>+    result[0][2] = ddx_coarse(x[0][2]);
>+    result[0][3] = ddx_coarse(x[0][3]);
>+    result[1][0] = ddx_coarse(x[1][0]);
>+    result[1][1] = ddx_coarse(x[1][1]);
>+    result[1][2] = ddx_coarse(x[1][2]);
>+    result[1][3] = ddx_coarse(x[1][3]);
>+    result[2][0] = ddx_coarse(x[2][0]);
>+    result[2][1] = ddx_coarse(x[2][1]);
>+    result[2][2] = ddx_coarse(x[2][2]);
>+    result[2][3] = ddx_coarse(x[2][3]);
>+    result[3][0] = ddx_coarse(x[3][0]);
>+    result[3][1] = ddx_coarse(x[3][1]);
>+    result[3][2] = ddx_coarse(x[3][2]);
>+    result[3][3] = ddx_coarse(x[3][3]);
>+    return result;
>+}
>+
>+/* Functions named operator.wxz= */
>+bool4 operator.wxz=(bool4 v, bool3 c) {
>+    bool4 result = v;
>+    result.w = c.x;
>+    result.x = c.y;
>+    result.z = c.z;
>+    return result;
>+}
>+uchar4 operator.wxz=(uchar4 v, uchar3 c) {
>+    uchar4 result = v;
>+    result.w = c.x;
>+    result.x = c.y;
>+    result.z = c.z;
>+    return result;
>+}
>+ushort4 operator.wxz=(ushort4 v, ushort3 c) {
>+    ushort4 result = v;
>+    result.w = c.x;
>+    result.x = c.y;
>+    result.z = c.z;
>+    return result;
>+}
>+uint4 operator.wxz=(uint4 v, uint3 c) {
>+    uint4 result = v;
>+    result.w = c.x;
>+    result.x = c.y;
>+    result.z = c.z;
>+    return result;
>+}
>+char4 operator.wxz=(char4 v, char3 c) {
>+    char4 result = v;
>+    result.w = c.x;
>+    result.x = c.y;
>+    result.z = c.z;
>+    return result;
>+}
>+short4 operator.wxz=(short4 v, short3 c) {
>+    short4 result = v;
>+    result.w = c.x;
>+    result.x = c.y;
>+    result.z = c.z;
>+    return result;
>+}
>+int4 operator.wxz=(int4 v, int3 c) {
>+    int4 result = v;
>+    result.w = c.x;
>+    result.x = c.y;
>+    result.z = c.z;
>+    return result;
>+}
>+half4 operator.wxz=(half4 v, half3 c) {
>+    half4 result = v;
>+    result.w = c.x;
>+    result.x = c.y;
>+    result.z = c.z;
>+    return result;
>+}
>+float4 operator.wxz=(float4 v, float3 c) {
>+    float4 result = v;
>+    result.w = c.x;
>+    result.x = c.y;
>+    result.z = c.z;
>+    return result;
>+}
>+
>+/* Functions named firstbithigh */
>+uint firstbithigh(uchar x) {
>+    if ((x & uchar(1 << 7)) != 0)
>+        return 0;
>+    if ((x & uchar(1 << 6)) != 0)
>+        return 1;
>+    if ((x & uchar(1 << 5)) != 0)
>+        return 2;
>+    if ((x & uchar(1 << 4)) != 0)
>+        return 3;
>+    if ((x & uchar(1 << 3)) != 0)
>+        return 4;
>+    if ((x & uchar(1 << 2)) != 0)
>+        return 5;
>+    if ((x & uchar(1 << 1)) != 0)
>+        return 6;
>+    if ((x & uchar(1 << 0)) != 0)
>+        return 7;
>+    return 8;
>+}
>+uint firstbithigh(ushort x) {
>+    if ((x & ushort(1 << 15)) != 0)
>+        return 0;
>+    if ((x & ushort(1 << 14)) != 0)
>+        return 1;
>+    if ((x & ushort(1 << 13)) != 0)
>+        return 2;
>+    if ((x & ushort(1 << 12)) != 0)
>+        return 3;
>+    if ((x & ushort(1 << 11)) != 0)
>+        return 4;
>+    if ((x & ushort(1 << 10)) != 0)
>+        return 5;
>+    if ((x & ushort(1 << 9)) != 0)
>+        return 6;
>+    if ((x & ushort(1 << 8)) != 0)
>+        return 7;
>+    if ((x & ushort(1 << 7)) != 0)
>+        return 8;
>+    if ((x & ushort(1 << 6)) != 0)
>+        return 9;
>+    if ((x & ushort(1 << 5)) != 0)
>+        return 10;
>+    if ((x & ushort(1 << 4)) != 0)
>+        return 11;
>+    if ((x & ushort(1 << 3)) != 0)
>+        return 12;
>+    if ((x & ushort(1 << 2)) != 0)
>+        return 13;
>+    if ((x & ushort(1 << 1)) != 0)
>+        return 14;
>+    if ((x & ushort(1 << 0)) != 0)
>+        return 15;
>+    return 16;
>+}
>+uint firstbithigh(uint x) {
>+    if ((x & uint(1 << 31)) != 0)
>+        return 0;
>+    if ((x & uint(1 << 30)) != 0)
>+        return 1;
>+    if ((x & uint(1 << 29)) != 0)
>+        return 2;
>+    if ((x & uint(1 << 28)) != 0)
>+        return 3;
>+    if ((x & uint(1 << 27)) != 0)
>+        return 4;
>+    if ((x & uint(1 << 26)) != 0)
>+        return 5;
>+    if ((x & uint(1 << 25)) != 0)
>+        return 6;
>+    if ((x & uint(1 << 24)) != 0)
>+        return 7;
>+    if ((x & uint(1 << 23)) != 0)
>+        return 8;
>+    if ((x & uint(1 << 22)) != 0)
>+        return 9;
>+    if ((x & uint(1 << 21)) != 0)
>+        return 10;
>+    if ((x & uint(1 << 20)) != 0)
>+        return 11;
>+    if ((x & uint(1 << 19)) != 0)
>+        return 12;
>+    if ((x & uint(1 << 18)) != 0)
>+        return 13;
>+    if ((x & uint(1 << 17)) != 0)
>+        return 14;
>+    if ((x & uint(1 << 16)) != 0)
>+        return 15;
>+    if ((x & uint(1 << 15)) != 0)
>+        return 16;
>+    if ((x & uint(1 << 14)) != 0)
>+        return 17;
>+    if ((x & uint(1 << 13)) != 0)
>+        return 18;
>+    if ((x & uint(1 << 12)) != 0)
>+        return 19;
>+    if ((x & uint(1 << 11)) != 0)
>+        return 20;
>+    if ((x & uint(1 << 10)) != 0)
>+        return 21;
>+    if ((x & uint(1 << 9)) != 0)
>+        return 22;
>+    if ((x & uint(1 << 8)) != 0)
>+        return 23;
>+    if ((x & uint(1 << 7)) != 0)
>+        return 24;
>+    if ((x & uint(1 << 6)) != 0)
>+        return 25;
>+    if ((x & uint(1 << 5)) != 0)
>+        return 26;
>+    if ((x & uint(1 << 4)) != 0)
>+        return 27;
>+    if ((x & uint(1 << 3)) != 0)
>+        return 28;
>+    if ((x & uint(1 << 2)) != 0)
>+        return 29;
>+    if ((x & uint(1 << 1)) != 0)
>+        return 30;
>+    if ((x & uint(1 << 0)) != 0)
>+        return 31;
>+    return 32;
>+}
>+uint firstbithigh(char x) {
>+    return firstbithigh(uchar(x));
>+}
>+uint firstbithigh(short x) {
>+    return firstbithigh(ushort(x));
>+}
>+uint firstbithigh(int x) {
>+    return firstbithigh(uint(x));
>+}
>+uint2 firstbithigh(uchar2 x) {
>+    uint2 result;
>+    result[0] = firstbithigh(x[0]);
>+    result[1] = firstbithigh(x[1]);
>+    return result;
>+}
>+uint3 firstbithigh(uchar3 x) {
>+    uint3 result;
>+    result[0] = firstbithigh(x[0]);
>+    result[1] = firstbithigh(x[1]);
>+    result[2] = firstbithigh(x[2]);
>+    return result;
>+}
>+uint4 firstbithigh(uchar4 x) {
>+    uint4 result;
>+    result[0] = firstbithigh(x[0]);
>+    result[1] = firstbithigh(x[1]);
>+    result[2] = firstbithigh(x[2]);
>+    result[3] = firstbithigh(x[3]);
>+    return result;
>+}
>+uint2 firstbithigh(ushort2 x) {
>+    uint2 result;
>+    result[0] = firstbithigh(x[0]);
>+    result[1] = firstbithigh(x[1]);
>+    return result;
>+}
>+uint3 firstbithigh(ushort3 x) {
>+    uint3 result;
>+    result[0] = firstbithigh(x[0]);
>+    result[1] = firstbithigh(x[1]);
>+    result[2] = firstbithigh(x[2]);
>+    return result;
>+}
>+uint4 firstbithigh(ushort4 x) {
>+    uint4 result;
>+    result[0] = firstbithigh(x[0]);
>+    result[1] = firstbithigh(x[1]);
>+    result[2] = firstbithigh(x[2]);
>+    result[3] = firstbithigh(x[3]);
>+    return result;
>+}
>+uint2 firstbithigh(uint2 x) {
>+    uint2 result;
>+    result[0] = firstbithigh(x[0]);
>+    result[1] = firstbithigh(x[1]);
>+    return result;
>+}
>+uint3 firstbithigh(uint3 x) {
>+    uint3 result;
>+    result[0] = firstbithigh(x[0]);
>+    result[1] = firstbithigh(x[1]);
>+    result[2] = firstbithigh(x[2]);
>+    return result;
>+}
>+uint4 firstbithigh(uint4 x) {
>+    uint4 result;
>+    result[0] = firstbithigh(x[0]);
>+    result[1] = firstbithigh(x[1]);
>+    result[2] = firstbithigh(x[2]);
>+    result[3] = firstbithigh(x[3]);
>+    return result;
>+}
>+uint2 firstbithigh(char2 x) {
>+    uint2 result;
>+    result[0] = firstbithigh(x[0]);
>+    result[1] = firstbithigh(x[1]);
>+    return result;
>+}
>+uint3 firstbithigh(char3 x) {
>+    uint3 result;
>+    result[0] = firstbithigh(x[0]);
>+    result[1] = firstbithigh(x[1]);
>+    result[2] = firstbithigh(x[2]);
>+    return result;
>+}
>+uint4 firstbithigh(char4 x) {
>+    uint4 result;
>+    result[0] = firstbithigh(x[0]);
>+    result[1] = firstbithigh(x[1]);
>+    result[2] = firstbithigh(x[2]);
>+    result[3] = firstbithigh(x[3]);
>+    return result;
>+}
>+uint2 firstbithigh(short2 x) {
>+    uint2 result;
>+    result[0] = firstbithigh(x[0]);
>+    result[1] = firstbithigh(x[1]);
>+    return result;
>+}
>+uint3 firstbithigh(short3 x) {
>+    uint3 result;
>+    result[0] = firstbithigh(x[0]);
>+    result[1] = firstbithigh(x[1]);
>+    result[2] = firstbithigh(x[2]);
>+    return result;
>+}
>+uint4 firstbithigh(short4 x) {
>+    uint4 result;
>+    result[0] = firstbithigh(x[0]);
>+    result[1] = firstbithigh(x[1]);
>+    result[2] = firstbithigh(x[2]);
>+    result[3] = firstbithigh(x[3]);
>+    return result;
>+}
>+uint2 firstbithigh(int2 x) {
>+    uint2 result;
>+    result[0] = firstbithigh(x[0]);
>+    result[1] = firstbithigh(x[1]);
>+    return result;
>+}
>+uint3 firstbithigh(int3 x) {
>+    uint3 result;
>+    result[0] = firstbithigh(x[0]);
>+    result[1] = firstbithigh(x[1]);
>+    result[2] = firstbithigh(x[2]);
>+    return result;
>+}
>+uint4 firstbithigh(int4 x) {
>+    uint4 result;
>+    result[0] = firstbithigh(x[0]);
>+    result[1] = firstbithigh(x[1]);
>+    result[2] = firstbithigh(x[2]);
>+    result[3] = firstbithigh(x[3]);
>+    return result;
>+}
>+
>+/* Functions named operator.xzzy */
>+bool4 operator.xzzy(bool3 v) {
>+    bool4 result;
>+    result.x = v.x;
>+    result.y = v.z;
>+    result.z = v.z;
>+    result.w = v.y;
>+    return result;
>+}
>+bool4 operator.xzzy(bool4 v) {
>+    bool4 result;
>+    result.x = v.x;
>+    result.y = v.z;
>+    result.z = v.z;
>+    result.w = v.y;
>+    return result;
>+}
>+uchar4 operator.xzzy(uchar3 v) {
>+    uchar4 result;
>+    result.x = v.x;
>+    result.y = v.z;
>+    result.z = v.z;
>+    result.w = v.y;
>+    return result;
>+}
>+uchar4 operator.xzzy(uchar4 v) {
>+    uchar4 result;
>+    result.x = v.x;
>+    result.y = v.z;
>+    result.z = v.z;
>+    result.w = v.y;
>+    return result;
>+}
>+ushort4 operator.xzzy(ushort3 v) {
>+    ushort4 result;
>+    result.x = v.x;
>+    result.y = v.z;
>+    result.z = v.z;
>+    result.w = v.y;
>+    return result;
>+}
>+ushort4 operator.xzzy(ushort4 v) {
>+    ushort4 result;
>+    result.x = v.x;
>+    result.y = v.z;
>+    result.z = v.z;
>+    result.w = v.y;
>+    return result;
>+}
>+uint4 operator.xzzy(uint3 v) {
>+    uint4 result;
>+    result.x = v.x;
>+    result.y = v.z;
>+    result.z = v.z;
>+    result.w = v.y;
>+    return result;
>+}
>+uint4 operator.xzzy(uint4 v) {
>+    uint4 result;
>+    result.x = v.x;
>+    result.y = v.z;
>+    result.z = v.z;
>+    result.w = v.y;
>+    return result;
>+}
>+char4 operator.xzzy(char3 v) {
>+    char4 result;
>+    result.x = v.x;
>+    result.y = v.z;
>+    result.z = v.z;
>+    result.w = v.y;
>+    return result;
>+}
>+char4 operator.xzzy(char4 v) {
>+    char4 result;
>+    result.x = v.x;
>+    result.y = v.z;
>+    result.z = v.z;
>+    result.w = v.y;
>+    return result;
>+}
>+short4 operator.xzzy(short3 v) {
>+    short4 result;
>+    result.x = v.x;
>+    result.y = v.z;
>+    result.z = v.z;
>+    result.w = v.y;
>+    return result;
>+}
>+short4 operator.xzzy(short4 v) {
>+    short4 result;
>+    result.x = v.x;
>+    result.y = v.z;
>+    result.z = v.z;
>+    result.w = v.y;
>+    return result;
>+}
>+int4 operator.xzzy(int3 v) {
>+    int4 result;
>+    result.x = v.x;
>+    result.y = v.z;
>+    result.z = v.z;
>+    result.w = v.y;
>+    return result;
>+}
>+int4 operator.xzzy(int4 v) {
>+    int4 result;
>+    result.x = v.x;
>+    result.y = v.z;
>+    result.z = v.z;
>+    result.w = v.y;
>+    return result;
>+}
>+half4 operator.xzzy(half3 v) {
>+    half4 result;
>+    result.x = v.x;
>+    result.y = v.z;
>+    result.z = v.z;
>+    result.w = v.y;
>+    return result;
>+}
>+half4 operator.xzzy(half4 v) {
>+    half4 result;
>+    result.x = v.x;
>+    result.y = v.z;
>+    result.z = v.z;
>+    result.w = v.y;
>+    return result;
>+}
>+float4 operator.xzzy(float3 v) {
>+    float4 result;
>+    result.x = v.x;
>+    result.y = v.z;
>+    result.z = v.z;
>+    result.w = v.y;
>+    return result;
>+}
>+float4 operator.xzzy(float4 v) {
>+    float4 result;
>+    result.x = v.x;
>+    result.y = v.z;
>+    result.z = v.z;
>+    result.w = v.y;
>+    return result;
>+}
>+
>+/* Functions named operator.zwzx */
>+bool4 operator.zwzx(bool4 v) {
>+    bool4 result;
>+    result.x = v.z;
>+    result.y = v.w;
>+    result.z = v.z;
>+    result.w = v.x;
>+    return result;
>+}
>+uchar4 operator.zwzx(uchar4 v) {
>+    uchar4 result;
>+    result.x = v.z;
>+    result.y = v.w;
>+    result.z = v.z;
>+    result.w = v.x;
>+    return result;
>+}
>+ushort4 operator.zwzx(ushort4 v) {
>+    ushort4 result;
>+    result.x = v.z;
>+    result.y = v.w;
>+    result.z = v.z;
>+    result.w = v.x;
>+    return result;
>+}
>+uint4 operator.zwzx(uint4 v) {
>+    uint4 result;
>+    result.x = v.z;
>+    result.y = v.w;
>+    result.z = v.z;
>+    result.w = v.x;
>+    return result;
>+}
>+char4 operator.zwzx(char4 v) {
>+    char4 result;
>+    result.x = v.z;
>+    result.y = v.w;
>+    result.z = v.z;
>+    result.w = v.x;
>+    return result;
>+}
>+short4 operator.zwzx(short4 v) {
>+    short4 result;
>+    result.x = v.z;
>+    result.y = v.w;
>+    result.z = v.z;
>+    result.w = v.x;
>+    return result;
>+}
>+int4 operator.zwzx(int4 v) {
>+    int4 result;
>+    result.x = v.z;
>+    result.y = v.w;
>+    result.z = v.z;
>+    result.w = v.x;
>+    return result;
>+}
>+half4 operator.zwzx(half4 v) {
>+    half4 result;
>+    result.x = v.z;
>+    result.y = v.w;
>+    result.z = v.z;
>+    result.w = v.x;
>+    return result;
>+}
>+float4 operator.zwzx(float4 v) {
>+    float4 result;
>+    result.x = v.z;
>+    result.y = v.w;
>+    result.z = v.z;
>+    result.w = v.x;
>+    return result;
>+}
>+
>+/* Functions named operator.yyzw */
>+bool4 operator.yyzw(bool4 v) {
>+    bool4 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.z;
>+    result.w = v.w;
>+    return result;
>+}
>+uchar4 operator.yyzw(uchar4 v) {
>+    uchar4 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.z;
>+    result.w = v.w;
>+    return result;
>+}
>+ushort4 operator.yyzw(ushort4 v) {
>+    ushort4 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.z;
>+    result.w = v.w;
>+    return result;
>+}
>+uint4 operator.yyzw(uint4 v) {
>+    uint4 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.z;
>+    result.w = v.w;
>+    return result;
>+}
>+char4 operator.yyzw(char4 v) {
>+    char4 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.z;
>+    result.w = v.w;
>+    return result;
>+}
>+short4 operator.yyzw(short4 v) {
>+    short4 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.z;
>+    result.w = v.w;
>+    return result;
>+}
>+int4 operator.yyzw(int4 v) {
>+    int4 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.z;
>+    result.w = v.w;
>+    return result;
>+}
>+half4 operator.yyzw(half4 v) {
>+    half4 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.z;
>+    result.w = v.w;
>+    return result;
>+}
>+float4 operator.yyzw(float4 v) {
>+    float4 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.z;
>+    result.w = v.w;
>+    return result;
>+}
>+
>+/* Functions named operator.xwxw */
>+bool4 operator.xwxw(bool4 v) {
>+    bool4 result;
>+    result.x = v.x;
>+    result.y = v.w;
>+    result.z = v.x;
>+    result.w = v.w;
>+    return result;
>+}
>+uchar4 operator.xwxw(uchar4 v) {
>+    uchar4 result;
>+    result.x = v.x;
>+    result.y = v.w;
>+    result.z = v.x;
>+    result.w = v.w;
>+    return result;
>+}
>+ushort4 operator.xwxw(ushort4 v) {
>+    ushort4 result;
>+    result.x = v.x;
>+    result.y = v.w;
>+    result.z = v.x;
>+    result.w = v.w;
>+    return result;
>+}
>+uint4 operator.xwxw(uint4 v) {
>+    uint4 result;
>+    result.x = v.x;
>+    result.y = v.w;
>+    result.z = v.x;
>+    result.w = v.w;
>+    return result;
>+}
>+char4 operator.xwxw(char4 v) {
>+    char4 result;
>+    result.x = v.x;
>+    result.y = v.w;
>+    result.z = v.x;
>+    result.w = v.w;
>+    return result;
>+}
>+short4 operator.xwxw(short4 v) {
>+    short4 result;
>+    result.x = v.x;
>+    result.y = v.w;
>+    result.z = v.x;
>+    result.w = v.w;
>+    return result;
>+}
>+int4 operator.xwxw(int4 v) {
>+    int4 result;
>+    result.x = v.x;
>+    result.y = v.w;
>+    result.z = v.x;
>+    result.w = v.w;
>+    return result;
>+}
>+half4 operator.xwxw(half4 v) {
>+    half4 result;
>+    result.x = v.x;
>+    result.y = v.w;
>+    result.z = v.x;
>+    result.w = v.w;
>+    return result;
>+}
>+float4 operator.xwxw(float4 v) {
>+    float4 result;
>+    result.x = v.x;
>+    result.y = v.w;
>+    result.z = v.x;
>+    result.w = v.w;
>+    return result;
>+}
>+
>+/* Functions named rcp */
>+half rcp(half x) {
>+    return 1 / x;
>+}
>+half2 rcp(half2 x) {
>+    half2 result;
>+    result[0] = rcp(x[0]);
>+    result[1] = rcp(x[1]);
>+    return result;
>+}
>+half3 rcp(half3 x) {
>+    half3 result;
>+    result[0] = rcp(x[0]);
>+    result[1] = rcp(x[1]);
>+    result[2] = rcp(x[2]);
>+    return result;
>+}
>+half4 rcp(half4 x) {
>+    half4 result;
>+    result[0] = rcp(x[0]);
>+    result[1] = rcp(x[1]);
>+    result[2] = rcp(x[2]);
>+    result[3] = rcp(x[3]);
>+    return result;
>+}
>+half2x2 rcp(half2x2 x) {
>+    half2x2 result;
>+    result[0][0] = rcp(x[0][0]);
>+    result[0][1] = rcp(x[0][1]);
>+    result[1][0] = rcp(x[1][0]);
>+    result[1][1] = rcp(x[1][1]);
>+    return result;
>+}
>+half2x3 rcp(half2x3 x) {
>+    half2x3 result;
>+    result[0][0] = rcp(x[0][0]);
>+    result[0][1] = rcp(x[0][1]);
>+    result[0][2] = rcp(x[0][2]);
>+    result[1][0] = rcp(x[1][0]);
>+    result[1][1] = rcp(x[1][1]);
>+    result[1][2] = rcp(x[1][2]);
>+    return result;
>+}
>+half2x4 rcp(half2x4 x) {
>+    half2x4 result;
>+    result[0][0] = rcp(x[0][0]);
>+    result[0][1] = rcp(x[0][1]);
>+    result[0][2] = rcp(x[0][2]);
>+    result[0][3] = rcp(x[0][3]);
>+    result[1][0] = rcp(x[1][0]);
>+    result[1][1] = rcp(x[1][1]);
>+    result[1][2] = rcp(x[1][2]);
>+    result[1][3] = rcp(x[1][3]);
>+    return result;
>+}
>+half3x2 rcp(half3x2 x) {
>+    half3x2 result;
>+    result[0][0] = rcp(x[0][0]);
>+    result[0][1] = rcp(x[0][1]);
>+    result[1][0] = rcp(x[1][0]);
>+    result[1][1] = rcp(x[1][1]);
>+    result[2][0] = rcp(x[2][0]);
>+    result[2][1] = rcp(x[2][1]);
>+    return result;
>+}
>+half3x3 rcp(half3x3 x) {
>+    half3x3 result;
>+    result[0][0] = rcp(x[0][0]);
>+    result[0][1] = rcp(x[0][1]);
>+    result[0][2] = rcp(x[0][2]);
>+    result[1][0] = rcp(x[1][0]);
>+    result[1][1] = rcp(x[1][1]);
>+    result[1][2] = rcp(x[1][2]);
>+    result[2][0] = rcp(x[2][0]);
>+    result[2][1] = rcp(x[2][1]);
>+    result[2][2] = rcp(x[2][2]);
>+    return result;
>+}
>+half3x4 rcp(half3x4 x) {
>+    half3x4 result;
>+    result[0][0] = rcp(x[0][0]);
>+    result[0][1] = rcp(x[0][1]);
>+    result[0][2] = rcp(x[0][2]);
>+    result[0][3] = rcp(x[0][3]);
>+    result[1][0] = rcp(x[1][0]);
>+    result[1][1] = rcp(x[1][1]);
>+    result[1][2] = rcp(x[1][2]);
>+    result[1][3] = rcp(x[1][3]);
>+    result[2][0] = rcp(x[2][0]);
>+    result[2][1] = rcp(x[2][1]);
>+    result[2][2] = rcp(x[2][2]);
>+    result[2][3] = rcp(x[2][3]);
>+    return result;
>+}
>+half4x2 rcp(half4x2 x) {
>+    half4x2 result;
>+    result[0][0] = rcp(x[0][0]);
>+    result[0][1] = rcp(x[0][1]);
>+    result[1][0] = rcp(x[1][0]);
>+    result[1][1] = rcp(x[1][1]);
>+    result[2][0] = rcp(x[2][0]);
>+    result[2][1] = rcp(x[2][1]);
>+    result[3][0] = rcp(x[3][0]);
>+    result[3][1] = rcp(x[3][1]);
>+    return result;
>+}
>+half4x3 rcp(half4x3 x) {
>+    half4x3 result;
>+    result[0][0] = rcp(x[0][0]);
>+    result[0][1] = rcp(x[0][1]);
>+    result[0][2] = rcp(x[0][2]);
>+    result[1][0] = rcp(x[1][0]);
>+    result[1][1] = rcp(x[1][1]);
>+    result[1][2] = rcp(x[1][2]);
>+    result[2][0] = rcp(x[2][0]);
>+    result[2][1] = rcp(x[2][1]);
>+    result[2][2] = rcp(x[2][2]);
>+    result[3][0] = rcp(x[3][0]);
>+    result[3][1] = rcp(x[3][1]);
>+    result[3][2] = rcp(x[3][2]);
>+    return result;
>+}
>+half4x4 rcp(half4x4 x) {
>+    half4x4 result;
>+    result[0][0] = rcp(x[0][0]);
>+    result[0][1] = rcp(x[0][1]);
>+    result[0][2] = rcp(x[0][2]);
>+    result[0][3] = rcp(x[0][3]);
>+    result[1][0] = rcp(x[1][0]);
>+    result[1][1] = rcp(x[1][1]);
>+    result[1][2] = rcp(x[1][2]);
>+    result[1][3] = rcp(x[1][3]);
>+    result[2][0] = rcp(x[2][0]);
>+    result[2][1] = rcp(x[2][1]);
>+    result[2][2] = rcp(x[2][2]);
>+    result[2][3] = rcp(x[2][3]);
>+    result[3][0] = rcp(x[3][0]);
>+    result[3][1] = rcp(x[3][1]);
>+    result[3][2] = rcp(x[3][2]);
>+    result[3][3] = rcp(x[3][3]);
>+    return result;
>+}
>+float rcp(float x) {
>+    return 1 / x;
>+}
>+float2 rcp(float2 x) {
>+    float2 result;
>+    result[0] = rcp(x[0]);
>+    result[1] = rcp(x[1]);
>+    return result;
>+}
>+float3 rcp(float3 x) {
>+    float3 result;
>+    result[0] = rcp(x[0]);
>+    result[1] = rcp(x[1]);
>+    result[2] = rcp(x[2]);
>+    return result;
>+}
>+float4 rcp(float4 x) {
>+    float4 result;
>+    result[0] = rcp(x[0]);
>+    result[1] = rcp(x[1]);
>+    result[2] = rcp(x[2]);
>+    result[3] = rcp(x[3]);
>+    return result;
>+}
>+float2x2 rcp(float2x2 x) {
>+    float2x2 result;
>+    result[0][0] = rcp(x[0][0]);
>+    result[0][1] = rcp(x[0][1]);
>+    result[1][0] = rcp(x[1][0]);
>+    result[1][1] = rcp(x[1][1]);
>+    return result;
>+}
>+float2x3 rcp(float2x3 x) {
>+    float2x3 result;
>+    result[0][0] = rcp(x[0][0]);
>+    result[0][1] = rcp(x[0][1]);
>+    result[0][2] = rcp(x[0][2]);
>+    result[1][0] = rcp(x[1][0]);
>+    result[1][1] = rcp(x[1][1]);
>+    result[1][2] = rcp(x[1][2]);
>+    return result;
>+}
>+float2x4 rcp(float2x4 x) {
>+    float2x4 result;
>+    result[0][0] = rcp(x[0][0]);
>+    result[0][1] = rcp(x[0][1]);
>+    result[0][2] = rcp(x[0][2]);
>+    result[0][3] = rcp(x[0][3]);
>+    result[1][0] = rcp(x[1][0]);
>+    result[1][1] = rcp(x[1][1]);
>+    result[1][2] = rcp(x[1][2]);
>+    result[1][3] = rcp(x[1][3]);
>+    return result;
>+}
>+float3x2 rcp(float3x2 x) {
>+    float3x2 result;
>+    result[0][0] = rcp(x[0][0]);
>+    result[0][1] = rcp(x[0][1]);
>+    result[1][0] = rcp(x[1][0]);
>+    result[1][1] = rcp(x[1][1]);
>+    result[2][0] = rcp(x[2][0]);
>+    result[2][1] = rcp(x[2][1]);
>+    return result;
>+}
>+float3x3 rcp(float3x3 x) {
>+    float3x3 result;
>+    result[0][0] = rcp(x[0][0]);
>+    result[0][1] = rcp(x[0][1]);
>+    result[0][2] = rcp(x[0][2]);
>+    result[1][0] = rcp(x[1][0]);
>+    result[1][1] = rcp(x[1][1]);
>+    result[1][2] = rcp(x[1][2]);
>+    result[2][0] = rcp(x[2][0]);
>+    result[2][1] = rcp(x[2][1]);
>+    result[2][2] = rcp(x[2][2]);
>+    return result;
>+}
>+float3x4 rcp(float3x4 x) {
>+    float3x4 result;
>+    result[0][0] = rcp(x[0][0]);
>+    result[0][1] = rcp(x[0][1]);
>+    result[0][2] = rcp(x[0][2]);
>+    result[0][3] = rcp(x[0][3]);
>+    result[1][0] = rcp(x[1][0]);
>+    result[1][1] = rcp(x[1][1]);
>+    result[1][2] = rcp(x[1][2]);
>+    result[1][3] = rcp(x[1][3]);
>+    result[2][0] = rcp(x[2][0]);
>+    result[2][1] = rcp(x[2][1]);
>+    result[2][2] = rcp(x[2][2]);
>+    result[2][3] = rcp(x[2][3]);
>+    return result;
>+}
>+float4x2 rcp(float4x2 x) {
>+    float4x2 result;
>+    result[0][0] = rcp(x[0][0]);
>+    result[0][1] = rcp(x[0][1]);
>+    result[1][0] = rcp(x[1][0]);
>+    result[1][1] = rcp(x[1][1]);
>+    result[2][0] = rcp(x[2][0]);
>+    result[2][1] = rcp(x[2][1]);
>+    result[3][0] = rcp(x[3][0]);
>+    result[3][1] = rcp(x[3][1]);
>+    return result;
>+}
>+float4x3 rcp(float4x3 x) {
>+    float4x3 result;
>+    result[0][0] = rcp(x[0][0]);
>+    result[0][1] = rcp(x[0][1]);
>+    result[0][2] = rcp(x[0][2]);
>+    result[1][0] = rcp(x[1][0]);
>+    result[1][1] = rcp(x[1][1]);
>+    result[1][2] = rcp(x[1][2]);
>+    result[2][0] = rcp(x[2][0]);
>+    result[2][1] = rcp(x[2][1]);
>+    result[2][2] = rcp(x[2][2]);
>+    result[3][0] = rcp(x[3][0]);
>+    result[3][1] = rcp(x[3][1]);
>+    result[3][2] = rcp(x[3][2]);
>+    return result;
>+}
>+float4x4 rcp(float4x4 x) {
>+    float4x4 result;
>+    result[0][0] = rcp(x[0][0]);
>+    result[0][1] = rcp(x[0][1]);
>+    result[0][2] = rcp(x[0][2]);
>+    result[0][3] = rcp(x[0][3]);
>+    result[1][0] = rcp(x[1][0]);
>+    result[1][1] = rcp(x[1][1]);
>+    result[1][2] = rcp(x[1][2]);
>+    result[1][3] = rcp(x[1][3]);
>+    result[2][0] = rcp(x[2][0]);
>+    result[2][1] = rcp(x[2][1]);
>+    result[2][2] = rcp(x[2][2]);
>+    result[2][3] = rcp(x[2][3]);
>+    result[3][0] = rcp(x[3][0]);
>+    result[3][1] = rcp(x[3][1]);
>+    result[3][2] = rcp(x[3][2]);
>+    result[3][3] = rcp(x[3][3]);
>+    return result;
>+}
>+
>+/* Functions named operator.wxzx */
>+bool4 operator.wxzx(bool4 v) {
>+    bool4 result;
>+    result.x = v.w;
>+    result.y = v.x;
>+    result.z = v.z;
>+    result.w = v.x;
>+    return result;
>+}
>+uchar4 operator.wxzx(uchar4 v) {
>+    uchar4 result;
>+    result.x = v.w;
>+    result.y = v.x;
>+    result.z = v.z;
>+    result.w = v.x;
>+    return result;
>+}
>+ushort4 operator.wxzx(ushort4 v) {
>+    ushort4 result;
>+    result.x = v.w;
>+    result.y = v.x;
>+    result.z = v.z;
>+    result.w = v.x;
>+    return result;
>+}
>+uint4 operator.wxzx(uint4 v) {
>+    uint4 result;
>+    result.x = v.w;
>+    result.y = v.x;
>+    result.z = v.z;
>+    result.w = v.x;
>+    return result;
>+}
>+char4 operator.wxzx(char4 v) {
>+    char4 result;
>+    result.x = v.w;
>+    result.y = v.x;
>+    result.z = v.z;
>+    result.w = v.x;
>+    return result;
>+}
>+short4 operator.wxzx(short4 v) {
>+    short4 result;
>+    result.x = v.w;
>+    result.y = v.x;
>+    result.z = v.z;
>+    result.w = v.x;
>+    return result;
>+}
>+int4 operator.wxzx(int4 v) {
>+    int4 result;
>+    result.x = v.w;
>+    result.y = v.x;
>+    result.z = v.z;
>+    result.w = v.x;
>+    return result;
>+}
>+half4 operator.wxzx(half4 v) {
>+    half4 result;
>+    result.x = v.w;
>+    result.y = v.x;
>+    result.z = v.z;
>+    result.w = v.x;
>+    return result;
>+}
>+float4 operator.wxzx(float4 v) {
>+    float4 result;
>+    result.x = v.w;
>+    result.y = v.x;
>+    result.z = v.z;
>+    result.w = v.x;
>+    return result;
>+}
>+
>+/* Functions named operator.wzy */
>+bool3 operator.wzy(bool4 v) {
>+    bool3 result;
>+    result.x = v.w;
>+    result.y = v.z;
>+    result.z = v.y;
>+    return result;
>+}
>+uchar3 operator.wzy(uchar4 v) {
>+    uchar3 result;
>+    result.x = v.w;
>+    result.y = v.z;
>+    result.z = v.y;
>+    return result;
>+}
>+ushort3 operator.wzy(ushort4 v) {
>+    ushort3 result;
>+    result.x = v.w;
>+    result.y = v.z;
>+    result.z = v.y;
>+    return result;
>+}
>+uint3 operator.wzy(uint4 v) {
>+    uint3 result;
>+    result.x = v.w;
>+    result.y = v.z;
>+    result.z = v.y;
>+    return result;
>+}
>+char3 operator.wzy(char4 v) {
>+    char3 result;
>+    result.x = v.w;
>+    result.y = v.z;
>+    result.z = v.y;
>+    return result;
>+}
>+short3 operator.wzy(short4 v) {
>+    short3 result;
>+    result.x = v.w;
>+    result.y = v.z;
>+    result.z = v.y;
>+    return result;
>+}
>+int3 operator.wzy(int4 v) {
>+    int3 result;
>+    result.x = v.w;
>+    result.y = v.z;
>+    result.z = v.y;
>+    return result;
>+}
>+half3 operator.wzy(half4 v) {
>+    half3 result;
>+    result.x = v.w;
>+    result.y = v.z;
>+    result.z = v.y;
>+    return result;
>+}
>+float3 operator.wzy(float4 v) {
>+    float3 result;
>+    result.x = v.w;
>+    result.y = v.z;
>+    result.z = v.y;
>+    return result;
>+}
>+
>+/* Functions named operator.zxw */
>+bool3 operator.zxw(bool4 v) {
>+    bool3 result;
>+    result.x = v.z;
>+    result.y = v.x;
>+    result.z = v.w;
>+    return result;
>+}
>+uchar3 operator.zxw(uchar4 v) {
>+    uchar3 result;
>+    result.x = v.z;
>+    result.y = v.x;
>+    result.z = v.w;
>+    return result;
>+}
>+ushort3 operator.zxw(ushort4 v) {
>+    ushort3 result;
>+    result.x = v.z;
>+    result.y = v.x;
>+    result.z = v.w;
>+    return result;
>+}
>+uint3 operator.zxw(uint4 v) {
>+    uint3 result;
>+    result.x = v.z;
>+    result.y = v.x;
>+    result.z = v.w;
>+    return result;
>+}
>+char3 operator.zxw(char4 v) {
>+    char3 result;
>+    result.x = v.z;
>+    result.y = v.x;
>+    result.z = v.w;
>+    return result;
>+}
>+short3 operator.zxw(short4 v) {
>+    short3 result;
>+    result.x = v.z;
>+    result.y = v.x;
>+    result.z = v.w;
>+    return result;
>+}
>+int3 operator.zxw(int4 v) {
>+    int3 result;
>+    result.x = v.z;
>+    result.y = v.x;
>+    result.z = v.w;
>+    return result;
>+}
>+half3 operator.zxw(half4 v) {
>+    half3 result;
>+    result.x = v.z;
>+    result.y = v.x;
>+    result.z = v.w;
>+    return result;
>+}
>+float3 operator.zxw(float4 v) {
>+    float3 result;
>+    result.x = v.z;
>+    result.y = v.x;
>+    result.z = v.w;
>+    return result;
>+}
>+
>+/* Functions named operator.zxyy */
>+bool4 operator.zxyy(bool3 v) {
>+    bool4 result;
>+    result.x = v.z;
>+    result.y = v.x;
>+    result.z = v.y;
>+    result.w = v.y;
>+    return result;
>+}
>+bool4 operator.zxyy(bool4 v) {
>+    bool4 result;
>+    result.x = v.z;
>+    result.y = v.x;
>+    result.z = v.y;
>+    result.w = v.y;
>+    return result;
>+}
>+uchar4 operator.zxyy(uchar3 v) {
>+    uchar4 result;
>+    result.x = v.z;
>+    result.y = v.x;
>+    result.z = v.y;
>+    result.w = v.y;
>+    return result;
>+}
>+uchar4 operator.zxyy(uchar4 v) {
>+    uchar4 result;
>+    result.x = v.z;
>+    result.y = v.x;
>+    result.z = v.y;
>+    result.w = v.y;
>+    return result;
>+}
>+ushort4 operator.zxyy(ushort3 v) {
>+    ushort4 result;
>+    result.x = v.z;
>+    result.y = v.x;
>+    result.z = v.y;
>+    result.w = v.y;
>+    return result;
>+}
>+ushort4 operator.zxyy(ushort4 v) {
>+    ushort4 result;
>+    result.x = v.z;
>+    result.y = v.x;
>+    result.z = v.y;
>+    result.w = v.y;
>+    return result;
>+}
>+uint4 operator.zxyy(uint3 v) {
>+    uint4 result;
>+    result.x = v.z;
>+    result.y = v.x;
>+    result.z = v.y;
>+    result.w = v.y;
>+    return result;
>+}
>+uint4 operator.zxyy(uint4 v) {
>+    uint4 result;
>+    result.x = v.z;
>+    result.y = v.x;
>+    result.z = v.y;
>+    result.w = v.y;
>+    return result;
>+}
>+char4 operator.zxyy(char3 v) {
>+    char4 result;
>+    result.x = v.z;
>+    result.y = v.x;
>+    result.z = v.y;
>+    result.w = v.y;
>+    return result;
>+}
>+char4 operator.zxyy(char4 v) {
>+    char4 result;
>+    result.x = v.z;
>+    result.y = v.x;
>+    result.z = v.y;
>+    result.w = v.y;
>+    return result;
>+}
>+short4 operator.zxyy(short3 v) {
>+    short4 result;
>+    result.x = v.z;
>+    result.y = v.x;
>+    result.z = v.y;
>+    result.w = v.y;
>+    return result;
>+}
>+short4 operator.zxyy(short4 v) {
>+    short4 result;
>+    result.x = v.z;
>+    result.y = v.x;
>+    result.z = v.y;
>+    result.w = v.y;
>+    return result;
>+}
>+int4 operator.zxyy(int3 v) {
>+    int4 result;
>+    result.x = v.z;
>+    result.y = v.x;
>+    result.z = v.y;
>+    result.w = v.y;
>+    return result;
>+}
>+int4 operator.zxyy(int4 v) {
>+    int4 result;
>+    result.x = v.z;
>+    result.y = v.x;
>+    result.z = v.y;
>+    result.w = v.y;
>+    return result;
>+}
>+half4 operator.zxyy(half3 v) {
>+    half4 result;
>+    result.x = v.z;
>+    result.y = v.x;
>+    result.z = v.y;
>+    result.w = v.y;
>+    return result;
>+}
>+half4 operator.zxyy(half4 v) {
>+    half4 result;
>+    result.x = v.z;
>+    result.y = v.x;
>+    result.z = v.y;
>+    result.w = v.y;
>+    return result;
>+}
>+float4 operator.zxyy(float3 v) {
>+    float4 result;
>+    result.x = v.z;
>+    result.y = v.x;
>+    result.z = v.y;
>+    result.w = v.y;
>+    return result;
>+}
>+float4 operator.zxyy(float4 v) {
>+    float4 result;
>+    result.x = v.z;
>+    result.y = v.x;
>+    result.z = v.y;
>+    result.w = v.y;
>+    return result;
>+}
>+
>+/* Functions named operator.yyyy */
>+bool4 operator.yyyy(bool2 v) {
>+    bool4 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.y;
>+    result.w = v.y;
>+    return result;
>+}
>+bool4 operator.yyyy(bool3 v) {
>+    bool4 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.y;
>+    result.w = v.y;
>+    return result;
>+}
>+bool4 operator.yyyy(bool4 v) {
>+    bool4 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.y;
>+    result.w = v.y;
>+    return result;
>+}
>+uchar4 operator.yyyy(uchar2 v) {
>+    uchar4 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.y;
>+    result.w = v.y;
>+    return result;
>+}
>+uchar4 operator.yyyy(uchar3 v) {
>+    uchar4 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.y;
>+    result.w = v.y;
>+    return result;
>+}
>+uchar4 operator.yyyy(uchar4 v) {
>+    uchar4 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.y;
>+    result.w = v.y;
>+    return result;
>+}
>+ushort4 operator.yyyy(ushort2 v) {
>+    ushort4 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.y;
>+    result.w = v.y;
>+    return result;
>+}
>+ushort4 operator.yyyy(ushort3 v) {
>+    ushort4 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.y;
>+    result.w = v.y;
>+    return result;
>+}
>+ushort4 operator.yyyy(ushort4 v) {
>+    ushort4 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.y;
>+    result.w = v.y;
>+    return result;
>+}
>+uint4 operator.yyyy(uint2 v) {
>+    uint4 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.y;
>+    result.w = v.y;
>+    return result;
>+}
>+uint4 operator.yyyy(uint3 v) {
>+    uint4 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.y;
>+    result.w = v.y;
>+    return result;
>+}
>+uint4 operator.yyyy(uint4 v) {
>+    uint4 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.y;
>+    result.w = v.y;
>+    return result;
>+}
>+char4 operator.yyyy(char2 v) {
>+    char4 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.y;
>+    result.w = v.y;
>+    return result;
>+}
>+char4 operator.yyyy(char3 v) {
>+    char4 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.y;
>+    result.w = v.y;
>+    return result;
>+}
>+char4 operator.yyyy(char4 v) {
>+    char4 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.y;
>+    result.w = v.y;
>+    return result;
>+}
>+short4 operator.yyyy(short2 v) {
>+    short4 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.y;
>+    result.w = v.y;
>+    return result;
>+}
>+short4 operator.yyyy(short3 v) {
>+    short4 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.y;
>+    result.w = v.y;
>+    return result;
>+}
>+short4 operator.yyyy(short4 v) {
>+    short4 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.y;
>+    result.w = v.y;
>+    return result;
>+}
>+int4 operator.yyyy(int2 v) {
>+    int4 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.y;
>+    result.w = v.y;
>+    return result;
>+}
>+int4 operator.yyyy(int3 v) {
>+    int4 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.y;
>+    result.w = v.y;
>+    return result;
>+}
>+int4 operator.yyyy(int4 v) {
>+    int4 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.y;
>+    result.w = v.y;
>+    return result;
>+}
>+half4 operator.yyyy(half2 v) {
>+    half4 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.y;
>+    result.w = v.y;
>+    return result;
>+}
>+half4 operator.yyyy(half3 v) {
>+    half4 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.y;
>+    result.w = v.y;
>+    return result;
>+}
>+half4 operator.yyyy(half4 v) {
>+    half4 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.y;
>+    result.w = v.y;
>+    return result;
>+}
>+float4 operator.yyyy(float2 v) {
>+    float4 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.y;
>+    result.w = v.y;
>+    return result;
>+}
>+float4 operator.yyyy(float3 v) {
>+    float4 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.y;
>+    result.w = v.y;
>+    return result;
>+}
>+float4 operator.yyyy(float4 v) {
>+    float4 result;
>+    result.x = v.y;
>+    result.y = v.y;
>+    result.z = v.y;
>+    result.w = v.y;
>+    return result;
>+}
>+
>+/* Functions named operator.yzwx= */
>+bool4 operator.yzwx=(bool4 v, bool4 c) {
>+    bool4 result = v;
>+    result.y = c.x;
>+    result.z = c.y;
>+    result.w = c.z;
>+    result.x = c.w;
>+    return result;
>+}
>+uchar4 operator.yzwx=(uchar4 v, uchar4 c) {
>+    uchar4 result = v;
>+    result.y = c.x;
>+    result.z = c.y;
>+    result.w = c.z;
>+    result.x = c.w;
>+    return result;
>+}
>+ushort4 operator.yzwx=(ushort4 v, ushort4 c) {
>+    ushort4 result = v;
>+    result.y = c.x;
>+    result.z = c.y;
>+    result.w = c.z;
>+    result.x = c.w;
>+    return result;
>+}
>+uint4 operator.yzwx=(uint4 v, uint4 c) {
>+    uint4 result = v;
>+    result.y = c.x;
>+    result.z = c.y;
>+    result.w = c.z;
>+    result.x = c.w;
>+    return result;
>+}
>+char4 operator.yzwx=(char4 v, char4 c) {
>+    char4 result = v;
>+    result.y = c.x;
>+    result.z = c.y;
>+    result.w = c.z;
>+    result.x = c.w;
>+    return result;
>+}
>+short4 operator.yzwx=(short4 v, short4 c) {
>+    short4 result = v;
>+    result.y = c.x;
>+    result.z = c.y;
>+    result.w = c.z;
>+    result.x = c.w;
>+    return result;
>+}
>+int4 operator.yzwx=(int4 v, int4 c) {
>+    int4 result = v;
>+    result.y = c.x;
>+    result.z = c.y;
>+    result.w = c.z;
>+    result.x = c.w;
>+    return result;
>+}
>+half4 operator.yzwx=(half4 v, half4 c) {
>+    half4 result = v;
>+    result.y = c.x;
>+    result.z = c.y;
>+    result.w = c.z;
>+    result.x = c.w;
>+    return result;
>+}
>+float4 operator.yzwx=(float4 v, float4 c) {
>+    float4 result = v;
>+    result.y = c.x;
>+    result.z = c.y;
>+    result.w = c.z;
>+    result.x = c.w;
>+    return result;
>+}
>+
>+/* Functions named operator.zzxy */
>+bool4 operator.zzxy(bool3 v) {
>+    bool4 result;
>+    result.x = v.z;
>+    result.y = v.z;
>+    result.z = v.x;
>+    result.w = v.y;
>+    return result;
>+}
>+bool4 operator.zzxy(bool4 v) {
>+    bool4 result;
>+    result.x = v.z;
>+    result.y = v.z;
>+    result.z = v.x;
>+    result.w = v.y;
>+    return result;
>+}
>+uchar4 operator.zzxy(uchar3 v) {
>+    uchar4 result;
>+    result.x = v.z;
>+    result.y = v.z;
>+    result.z = v.x;
>+    result.w = v.y;
>+    return result;
>+}
>+uchar4 operator.zzxy(uchar4 v) {
>+    uchar4 result;
>+    result.x = v.z;
>+    result.y = v.z;
>+    result.z = v.x;
>+    result.w = v.y;
>+    return result;
>+}
>+ushort4 operator.zzxy(ushort3 v) {
>+    ushort4 result;
>+    result.x = v.z;
>+    result.y = v.z;
>+    result.z = v.x;
>+    result.w = v.y;
>+    return result;
>+}
>+ushort4 operator.zzxy(ushort4 v) {
>+    ushort4 result;
>+    result.x = v.z;
>+    result.y = v.z;
>+    result.z = v.x;
>+    result.w = v.y;
>+    return result;
>+}
>+uint4 operator.zzxy(uint3 v) {
>+    uint4 result;
>+    result.x = v.z;
>+    result.y = v.z;
>+    result.z = v.x;
>+    result.w = v.y;
>+    return result;
>+}
>+uint4 operator.zzxy(uint4 v) {
>+    uint4 result;
>+    result.x = v.z;
>+    result.y = v.z;
>+    result.z = v.x;
>+    result.w = v.y;
>+    return result;
>+}
>+char4 operator.zzxy(char3 v) {
>+    char4 result;
>+    result.x = v.z;
>+    result.y = v.z;
>+    result.z = v.x;
>+    result.w = v.y;
>+    return result;
>+}
>+char4 operator.zzxy(char4 v) {
>+    char4 result;
>+    result.x = v.z;
>+    result.y = v.z;
>+    result.z = v.x;
>+    result.w = v.y;
>+    return result;
>+}
>+short4 operator.zzxy(short3 v) {
>+    short4 result;
>+    result.x = v.z;
>+    result.y = v.z;
>+    result.z = v.x;
>+    result.w = v.y;
>+    return result;
>+}
>+short4 operator.zzxy(short4 v) {
>+    short4 result;
>+    result.x = v.z;
>+    result.y = v.z;
>+    result.z = v.x;
>+    result.w = v.y;
>+    return result;
>+}
>+int4 operator.zzxy(int3 v) {
>+    int4 result;
>+    result.x = v.z;
>+    result.y = v.z;
>+    result.z = v.x;
>+    result.w = v.y;
>+    return result;
>+}
>+int4 operator.zzxy(int4 v) {
>+    int4 result;
>+    result.x = v.z;
>+    result.y = v.z;
>+    result.z = v.x;
>+    result.w = v.y;
>+    return result;
>+}
>+half4 operator.zzxy(half3 v) {
>+    half4 result;
>+    result.x = v.z;
>+    result.y = v.z;
>+    result.z = v.x;
>+    result.w = v.y;
>+    return result;
>+}
>+half4 operator.zzxy(half4 v) {
>+    half4 result;
>+    result.x = v.z;
>+    result.y = v.z;
>+    result.z = v.x;
>+    result.w = v.y;
>+    return result;
>+}
>+float4 operator.zzxy(float3 v) {
>+    float4 result;
>+    result.x = v.z;
>+    result.y = v.z;
>+    result.z = v.x;
>+    result.w = v.y;
>+    return result;
>+}
>+float4 operator.zzxy(float4 v) {
>+    float4 result;
>+    result.x = v.z;
>+    result.y = v.z;
>+    result.z = v.x;
>+    result.w = v.y;
>+    return result;
>+}
>+
>+/* Functions named fwidth */
>+half fwidth(half x) {
>+    return abs(ddx(x)) + abs(ddy(x));
>+}
>+half2 fwidth(half2 x) {
>+    half2 result;
>+    result[0] = fwidth(x[0]);
>+    result[1] = fwidth(x[1]);
>+    return result;
>+}
>+half3 fwidth(half3 x) {
>+    half3 result;
>+    result[0] = fwidth(x[0]);
>+    result[1] = fwidth(x[1]);
>+    result[2] = fwidth(x[2]);
>+    return result;
>+}
>+half4 fwidth(half4 x) {
>+    half4 result;
>+    result[0] = fwidth(x[0]);
>+    result[1] = fwidth(x[1]);
>+    result[2] = fwidth(x[2]);
>+    result[3] = fwidth(x[3]);
>+    return result;
>+}
>+half2x2 fwidth(half2x2 x) {
>+    half2x2 result;
>+    result[0][0] = fwidth(x[0][0]);
>+    result[0][1] = fwidth(x[0][1]);
>+    result[1][0] = fwidth(x[1][0]);
>+    result[1][1] = fwidth(x[1][1]);
>+    return result;
>+}
>+half2x3 fwidth(half2x3 x) {
>+    half2x3 result;
>+    result[0][0] = fwidth(x[0][0]);
>+    result[0][1] = fwidth(x[0][1]);
>+    result[0][2] = fwidth(x[0][2]);
>+    result[1][0] = fwidth(x[1][0]);
>+    result[1][1] = fwidth(x[1][1]);
>+    result[1][2] = fwidth(x[1][2]);
>+    return result;
>+}
>+half2x4 fwidth(half2x4 x) {
>+    half2x4 result;
>+    result[0][0] = fwidth(x[0][0]);
>+    result[0][1] = fwidth(x[0][1]);
>+    result[0][2] = fwidth(x[0][2]);
>+    result[0][3] = fwidth(x[0][3]);
>+    result[1][0] = fwidth(x[1][0]);
>+    result[1][1] = fwidth(x[1][1]);
>+    result[1][2] = fwidth(x[1][2]);
>+    result[1][3] = fwidth(x[1][3]);
>+    return result;
>+}
>+half3x2 fwidth(half3x2 x) {
>+    half3x2 result;
>+    result[0][0] = fwidth(x[0][0]);
>+    result[0][1] = fwidth(x[0][1]);
>+    result[1][0] = fwidth(x[1][0]);
>+    result[1][1] = fwidth(x[1][1]);
>+    result[2][0] = fwidth(x[2][0]);
>+    result[2][1] = fwidth(x[2][1]);
>+    return result;
>+}
>+half3x3 fwidth(half3x3 x) {
>+    half3x3 result;
>+    result[0][0] = fwidth(x[0][0]);
>+    result[0][1] = fwidth(x[0][1]);
>+    result[0][2] = fwidth(x[0][2]);
>+    result[1][0] = fwidth(x[1][0]);
>+    result[1][1] = fwidth(x[1][1]);
>+    result[1][2] = fwidth(x[1][2]);
>+    result[2][0] = fwidth(x[2][0]);
>+    result[2][1] = fwidth(x[2][1]);
>+    result[2][2] = fwidth(x[2][2]);
>+    return result;
>+}
>+half3x4 fwidth(half3x4 x) {
>+    half3x4 result;
>+    result[0][0] = fwidth(x[0][0]);
>+    result[0][1] = fwidth(x[0][1]);
>+    result[0][2] = fwidth(x[0][2]);
>+    result[0][3] = fwidth(x[0][3]);
>+    result[1][0] = fwidth(x[1][0]);
>+    result[1][1] = fwidth(x[1][1]);
>+    result[1][2] = fwidth(x[1][2]);
>+    result[1][3] = fwidth(x[1][3]);
>+    result[2][0] = fwidth(x[2][0]);
>+    result[2][1] = fwidth(x[2][1]);
>+    result[2][2] = fwidth(x[2][2]);
>+    result[2][3] = fwidth(x[2][3]);
>+    return result;
>+}
>+half4x2 fwidth(half4x2 x) {
>+    half4x2 result;
>+    result[0][0] = fwidth(x[0][0]);
>+    result[0][1] = fwidth(x[0][1]);
>+    result[1][0] = fwidth(x[1][0]);
>+    result[1][1] = fwidth(x[1][1]);
>+    result[2][0] = fwidth(x[2][0]);
>+    result[2][1] = fwidth(x[2][1]);
>+    result[3][0] = fwidth(x[3][0]);
>+    result[3][1] = fwidth(x[3][1]);
>+    return result;
>+}
>+half4x3 fwidth(half4x3 x) {
>+    half4x3 result;
>+    result[0][0] = fwidth(x[0][0]);
>+    result[0][1] = fwidth(x[0][1]);
>+    result[0][2] = fwidth(x[0][2]);
>+    result[1][0] = fwidth(x[1][0]);
>+    result[1][1] = fwidth(x[1][1]);
>+    result[1][2] = fwidth(x[1][2]);
>+    result[2][0] = fwidth(x[2][0]);
>+    result[2][1] = fwidth(x[2][1]);
>+    result[2][2] = fwidth(x[2][2]);
>+    result[3][0] = fwidth(x[3][0]);
>+    result[3][1] = fwidth(x[3][1]);
>+    result[3][2] = fwidth(x[3][2]);
>+    return result;
>+}
>+half4x4 fwidth(half4x4 x) {
>+    half4x4 result;
>+    result[0][0] = fwidth(x[0][0]);
>+    result[0][1] = fwidth(x[0][1]);
>+    result[0][2] = fwidth(x[0][2]);
>+    result[0][3] = fwidth(x[0][3]);
>+    result[1][0] = fwidth(x[1][0]);
>+    result[1][1] = fwidth(x[1][1]);
>+    result[1][2] = fwidth(x[1][2]);
>+    result[1][3] = fwidth(x[1][3]);
>+    result[2][0] = fwidth(x[2][0]);
>+    result[2][1] = fwidth(x[2][1]);
>+    result[2][2] = fwidth(x[2][2]);
>+    result[2][3] = fwidth(x[2][3]);
>+    result[3][0] = fwidth(x[3][0]);
>+    result[3][1] = fwidth(x[3][1]);
>+    result[3][2] = fwidth(x[3][2]);
>+    result[3][3] = fwidth(x[3][3]);
>+    return result;
>+}
>+
>+float fwidth(float x) {
>+    return abs(ddx(x)) + abs(ddy(x));
>+}
>+float2 fwidth(float2 x) {
>+    float2 result;
>+    result[0] = fwidth(x[0]);
>+    result[1] = fwidth(x[1]);
>+    return result;
>+}
>+float3 fwidth(float3 x) {
>+    float3 result;
>+    result[0] = fwidth(x[0]);
>+    result[1] = fwidth(x[1]);
>+    result[2] = fwidth(x[2]);
>+    return result;
>+}
>+float4 fwidth(float4 x) {
>+    float4 result;
>+    result[0] = fwidth(x[0]);
>+    result[1] = fwidth(x[1]);
>+    result[2] = fwidth(x[2]);
>+    result[3] = fwidth(x[3]);
>+    return result;
>+}
>+float2x2 fwidth(float2x2 x) {
>+    float2x2 result;
>+    result[0][0] = fwidth(x[0][0]);
>+    result[0][1] = fwidth(x[0][1]);
>+    result[1][0] = fwidth(x[1][0]);
>+    result[1][1] = fwidth(x[1][1]);
>+    return result;
>+}
>+float2x3 fwidth(float2x3 x) {
>+    float2x3 result;
>+    result[0][0] = fwidth(x[0][0]);
>+    result[0][1] = fwidth(x[0][1]);
>+    result[0][2] = fwidth(x[0][2]);
>+    result[1][0] = fwidth(x[1][0]);
>+    result[1][1] = fwidth(x[1][1]);
>+    result[1][2] = fwidth(x[1][2]);
>+    return result;
>+}
>+float2x4 fwidth(float2x4 x) {
>+    float2x4 result;
>+    result[0][0] = fwidth(x[0][0]);
>+    result[0][1] = fwidth(x[0][1]);
>+    result[0][2] = fwidth(x[0][2]);
>+    result[0][3] = fwidth(x[0][3]);
>+    result[1][0] = fwidth(x[1][0]);
>+    result[1][1] = fwidth(x[1][1]);
>+    result[1][2] = fwidth(x[1][2]);
>+    result[1][3] = fwidth(x[1][3]);
>+    return result;
>+}
>+float3x2 fwidth(float3x2 x) {
>+    float3x2 result;
>+    result[0][0] = fwidth(x[0][0]);
>+    result[0][1] = fwidth(x[0][1]);
>+    result[1][0] = fwidth(x[1][0]);
>+    result[1][1] = fwidth(x[1][1]);
>+    result[2][0] = fwidth(x[2][0]);
>+    result[2][1] = fwidth(x[2][1]);
>+    return result;
>+}
>+float3x3 fwidth(float3x3 x) {
>+    float3x3 result;
>+    result[0][0] = fwidth(x[0][0]);
>+    result[0][1] = fwidth(x[0][1]);
>+    result[0][2] = fwidth(x[0][2]);
>+    result[1][0] = fwidth(x[1][0]);
>+    result[1][1] = fwidth(x[1][1]);
>+    result[1][2] = fwidth(x[1][2]);
>+    result[2][0] = fwidth(x[2][0]);
>+    result[2][1] = fwidth(x[2][1]);
>+    result[2][2] = fwidth(x[2][2]);
>+    return result;
>+}
>+float3x4 fwidth(float3x4 x) {
>+    float3x4 result;
>+    result[0][0] = fwidth(x[0][0]);
>+    result[0][1] = fwidth(x[0][1]);
>+    result[0][2] = fwidth(x[0][2]);
>+    result[0][3] = fwidth(x[0][3]);
>+    result[1][0] = fwidth(x[1][0]);
>+    result[1][1] = fwidth(x[1][1]);
>+    result[1][2] = fwidth(x[1][2]);
>+    result[1][3] = fwidth(x[1][3]);
>+    result[2][0] = fwidth(x[2][0]);
>+    result[2][1] = fwidth(x[2][1]);
>+    result[2][2] = fwidth(x[2][2]);
>+    result[2][3] = fwidth(x[2][3]);
>+    return result;
>+}
>+float4x2 fwidth(float4x2 x) {
>+    float4x2 result;
>+    result[0][0] = fwidth(x[0][0]);
>+    result[0][1] = fwidth(x[0][1]);
>+    result[1][0] = fwidth(x[1][0]);
>+    result[1][1] = fwidth(x[1][1]);
>+    result[2][0] = fwidth(x[2][0]);
>+    result[2][1] = fwidth(x[2][1]);
>+    result[3][0] = fwidth(x[3][0]);
>+    result[3][1] = fwidth(x[3][1]);
>+    return result;
>+}
>+float4x3 fwidth(float4x3 x) {
>+    float4x3 result;
>+    result[0][0] = fwidth(x[0][0]);
>+    result[0][1] = fwidth(x[0][1]);
>+    result[0][2] = fwidth(x[0][2]);
>+    result[1][0] = fwidth(x[1][0]);
>+    result[1][1] = fwidth(x[1][1]);
>+    result[1][2] = fwidth(x[1][2]);
>+    result[2][0] = fwidth(x[2][0]);
>+    result[2][1] = fwidth(x[2][1]);
>+    result[2][2] = fwidth(x[2][2]);
>+    result[3][0] = fwidth(x[3][0]);
>+    result[3][1] = fwidth(x[3][1]);
>+    result[3][2] = fwidth(x[3][2]);
>+    return result;
>+}
>+float4x4 fwidth(float4x4 x) {
>+    float4x4 result;
>+    result[0][0] = fwidth(x[0][0]);
>+    result[0][1] = fwidth(x[0][1]);
>+    result[0][2] = fwidth(x[0][2]);
>+    result[0][3] = fwidth(x[0][3]);
>+    result[1][0] = fwidth(x[1][0]);
>+    result[1][1] = fwidth(x[1][1]);
>+    result[1][2] = fwidth(x[1][2]);
>+    result[1][3] = fwidth(x[1][3]);
>+    result[2][0] = fwidth(x[2][0]);
>+    result[2][1] = fwidth(x[2][1]);
>+    result[2][2] = fwidth(x[2][2]);
>+    result[2][3] = fwidth(x[2][3]);
>+    result[3][0] = fwidth(x[3][0]);
>+    result[3][1] = fwidth(x[3][1]);
>+    result[3][2] = fwidth(x[3][2]);
>+    result[3][3] = fwidth(x[3][3]);
>+    return result;
>+}
>+
>+
>+/* Functions named operator.z= */
>+native bool3 operator.z=(bool3, bool);
>+native bool4 operator.z=(bool4, bool);
>+native uchar3 operator.z=(uchar3, uchar);
>+native uchar4 operator.z=(uchar4, uchar);
>+native ushort3 operator.z=(ushort3, ushort);
>+native ushort4 operator.z=(ushort4, ushort);
>+native uint3 operator.z=(uint3, uint);
>+native uint4 operator.z=(uint4, uint);
>+native char3 operator.z=(char3, char);
>+native char4 operator.z=(char4, char);
>+native short3 operator.z=(short3, short);
>+native short4 operator.z=(short4, short);
>+native int3 operator.z=(int3, int);
>+native int4 operator.z=(int4, int);
>+native half3 operator.z=(half3, half);
>+native half4 operator.z=(half4, half);
>+native float3 operator.z=(float3, float);
>+native float4 operator.z=(float4, float);
>+
>+/* Functions named operator.x= */
>+native bool2 operator.x=(bool2, bool);
>+native bool3 operator.x=(bool3, bool);
>+native bool4 operator.x=(bool4, bool);
>+native uchar2 operator.x=(uchar2, uchar);
>+native uchar3 operator.x=(uchar3, uchar);
>+native uchar4 operator.x=(uchar4, uchar);
>+native ushort2 operator.x=(ushort2, ushort);
>+native ushort3 operator.x=(ushort3, ushort);
>+native ushort4 operator.x=(ushort4, ushort);
>+native uint2 operator.x=(uint2, uint);
>+native uint3 operator.x=(uint3, uint);
>+native uint4 operator.x=(uint4, uint);
>+native char2 operator.x=(char2, char);
>+native char3 operator.x=(char3, char);
>+native char4 operator.x=(char4, char);
>+native short2 operator.x=(short2, short);
>+native short3 operator.x=(short3, short);
>+native short4 operator.x=(short4, short);
>+native int2 operator.x=(int2, int);
>+native int3 operator.x=(int3, int);
>+native int4 operator.x=(int4, int);
>+native half2 operator.x=(half2, half);
>+native half3 operator.x=(half3, half);
>+native half4 operator.x=(half4, half);
>+native float2 operator.x=(float2, float);
>+native float3 operator.x=(float3, float);
>+native float4 operator.x=(float4, float);
>+
>+/* Functions named operator.xy= */
>+bool2 operator.xy=(bool2 v, bool2 c) {
>+    bool2 result = v;
>+    result.x = c.x;
>+    result.y = c.y;
>+    return result;
>+}
>+bool3 operator.xy=(bool3 v, bool2 c) {
>+    bool3 result = v;
>+    result.x = c.x;
>+    result.y = c.y;
>+    return result;
>+}
>+bool4 operator.xy=(bool4 v, bool2 c) {
>+    bool4 result = v;
>+    result.x = c.x;
>+    result.y = c.y;
>+    return result;
>+}
>+uchar2 operator.xy=(uchar2 v, uchar2 c) {
>+    uchar2 result = v;
>+    result.x = c.x;
>+    result.y = c.y;
>+    return result;
>+}
>+uchar3 operator.xy=(uchar3 v, uchar2 c) {
>+    uchar3 result = v;
>+    result.x = c.x;
>+    result.y = c.y;
>+    return result;
>+}
>+uchar4 operator.xy=(uchar4 v, uchar2 c) {
>+    uchar4 result = v;
>+    result.x = c.x;
>+    result.y = c.y;
>+    return result;
>+}
>+ushort2 operator.xy=(ushort2 v, ushort2 c) {
>+    ushort2 result = v;
>+    result.x = c.x;
>+    result.y = c.y;
>+    return result;
>+}
>+ushort3 operator.xy=(ushort3 v, ushort2 c) {
>+    ushort3 result = v;
>+    result.x = c.x;
>+    result.y = c.y;
>+    return result;
>+}
>+ushort4 operator.xy=(ushort4 v, ushort2 c) {
>+    ushort4 result = v;
>+    result.x = c.x;
>+    result.y = c.y;
>+    return result;
>+}
>+uint2 operator.xy=(uint2 v, uint2 c) {
>+    uint2 result = v;
>+    result.x = c.x;
>+    result.y = c.y;
>+    return result;
>+}
>+uint3 operator.xy=(uint3 v, uint2 c) {
>+    uint3 result = v;
>+    result.x = c.x;
>+    result.y = c.y;
>+    return result;
>+}
>+uint4 operator.xy=(uint4 v, uint2 c) {
>+    uint4 result = v;
>+    result.x = c.x;
>+    result.y = c.y;
>+    return result;
>+}
>+char2 operator.xy=(char2 v, char2 c) {
>+    char2 result = v;
>+    result.x = c.x;
>+    result.y = c.y;
>+    return result;
>+}
>+char3 operator.xy=(char3 v, char2 c) {
>+    char3 result = v;
>+    result.x = c.x;
>+    result.y = c.y;
>+    return result;
>+}
>+char4 operator.xy=(char4 v, char2 c) {
>+    char4 result = v;
>+    result.x = c.x;
>+    result.y = c.y;
>+    return result;
>+}
>+short2 operator.xy=(short2 v, short2 c) {
>+    short2 result = v;
>+    result.x = c.x;
>+    result.y = c.y;
>+    return result;
>+}
>+short3 operator.xy=(short3 v, short2 c) {
>+    short3 result = v;
>+    result.x = c.x;
>+    result.y = c.y;
>+    return result;
>+}
>+short4 operator.xy=(short4 v, short2 c) {
>+    short4 result = v;
>+    result.x = c.x;
>+    result.y = c.y;
>+    return result;
>+}
>+int2 operator.xy=(int2 v, int2 c) {
>+    int2 result = v;
>+    result.x = c.x;
>+    result.y = c.y;
>+    return result;
>+}
>+int3 operator.xy=(int3 v, int2 c) {
>+    int3 result = v;
>+    result.x = c.x;
>+    result.y = c.y;
>+    return result;
>+}
>+int4 operator.xy=(int4 v, int2 c) {
>+    int4 result = v;
>+    result.x = c.x;
>+    result.y = c.y;
>+    return result;
>+}
>+half2 operator.xy=(half2 v, half2 c) {
>+    half2 result = v;
>+    result.x = c.x;
>+    result.y = c.y;
>+    return result;
>+}
>+half3 operator.xy=(half3 v, half2 c) {
>+    half3 result = v;
>+    result.x = c.x;
>+    result.y = c.y;
>+    return result;
>+}
>+half4 operator.xy=(half4 v, half2 c) {
>+    half4 result = v;
>+    result.x = c.x;
>+    result.y = c.y;
>+    return result;
>+}
>+float2 operator.xy=(float2 v, float2 c) {
>+    float2 result = v;
>+    result.x = c.x;
>+    result.y = c.y;
>+    return result;
>+}
>+float3 operator.xy=(float3 v, float2 c) {
>+    float3 result = v;
>+    result.x = c.x;
>+    result.y = c.y;
>+    return result;
>+}
>+float4 operator.xy=(float4 v, float2 c) {
>+    float4 result = v;
>+    result.x = c.x;
>+    result.y = c.y;
>+    return result;
>+}
>+
>+/* Functions named operator.yxw */
>+bool3 operator.yxw(bool4 v) {
>+    bool3 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.w;
>+    return result;
>+}
>+uchar3 operator.yxw(uchar4 v) {
>+    uchar3 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.w;
>+    return result;
>+}
>+ushort3 operator.yxw(ushort4 v) {
>+    ushort3 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.w;
>+    return result;
>+}
>+uint3 operator.yxw(uint4 v) {
>+    uint3 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.w;
>+    return result;
>+}
>+char3 operator.yxw(char4 v) {
>+    char3 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.w;
>+    return result;
>+}
>+short3 operator.yxw(short4 v) {
>+    short3 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.w;
>+    return result;
>+}
>+int3 operator.yxw(int4 v) {
>+    int3 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.w;
>+    return result;
>+}
>+half3 operator.yxw(half4 v) {
>+    half3 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.w;
>+    return result;
>+}
>+float3 operator.yxw(float4 v) {
>+    float3 result;
>+    result.x = v.y;
>+    result.y = v.x;
>+    result.z = v.w;
>+    return result;
>+}
>+
>+/* Functions named operator.xxwy */
>+bool4 operator.xxwy(bool4 v) {
>+    bool4 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.w;
>+    result.w = v.y;
>+    return result;
>+}
>+uchar4 operator.xxwy(uchar4 v) {
>+    uchar4 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.w;
>+    result.w = v.y;
>+    return result;
>+}
>+ushort4 operator.xxwy(ushort4 v) {
>+    ushort4 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.w;
>+    result.w = v.y;
>+    return result;
>+}
>+uint4 operator.xxwy(uint4 v) {
>+    uint4 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.w;
>+    result.w = v.y;
>+    return result;
>+}
>+char4 operator.xxwy(char4 v) {
>+    char4 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.w;
>+    result.w = v.y;
>+    return result;
>+}
>+short4 operator.xxwy(short4 v) {
>+    short4 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.w;
>+    result.w = v.y;
>+    return result;
>+}
>+int4 operator.xxwy(int4 v) {
>+    int4 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.w;
>+    result.w = v.y;
>+    return result;
>+}
>+half4 operator.xxwy(half4 v) {
>+    half4 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.w;
>+    result.w = v.y;
>+    return result;
>+}
>+float4 operator.xxwy(float4 v) {
>+    float4 result;
>+    result.x = v.x;
>+    result.y = v.x;
>+    result.z = v.w;
>+    result.w = v.y;
>+    return result;
>+}
>+
>+/* Functions named operator.yw */
>+bool2 operator.yw(bool4 v) {
>+    bool2 result;
>+    result.x = v.y;
>+    result.y = v.w;
>+    return result;
>+}
>+uchar2 operator.yw(uchar4 v) {
>+    uchar2 result;
>+    result.x = v.y;
>+    result.y = v.w;
>+    return result;
>+}
>+ushort2 operator.yw(ushort4 v) {
>+    ushort2 result;
>+    result.x = v.y;
>+    result.y = v.w;
>+    return result;
>+}
>+uint2 operator.yw(uint4 v) {
>+    uint2 result;
>+    result.x = v.y;
>+    result.y = v.w;
>+    return result;
>+}
>+char2 operator.yw(char4 v) {
>+    char2 result;
>+    result.x = v.y;
>+    result.y = v.w;
>+    return result;
>+}
>+short2 operator.yw(short4 v) {
>+    short2 result;
>+    result.x = v.y;
>+    result.y = v.w;
>+    return result;
>+}
>+int2 operator.yw(int4 v) {
>+    int2 result;
>+    result.x = v.y;
>+    result.y = v.w;
>+    return result;
>+}
>+half2 operator.yw(half4 v) {
>+    half2 result;
>+    result.x = v.y;
>+    result.y = v.w;
>+    return result;
>+}
>+float2 operator.yw(float4 v) {
>+    float2 result;
>+    result.x = v.y;
>+    result.y = v.w;
>+    return result;
>+}
>+
>+/* Functions named operator.zxwx */
>+bool4 operator.zxwx(bool4 v) {
>+    bool4 result;
>+    result.x = v.z;
>+    result.y = v.x;
>+    result.z = v.w;
>+    result.w = v.x;
>+    return result;
>+}
>+uchar4 operator.zxwx(uchar4 v) {
>+    uchar4 result;
>+    result.x = v.z;
>+    result.y = v.x;
>+    result.z = v.w;
>+    result.w = v.x;
>+    return result;
>+}
>+ushort4 operator.zxwx(ushort4 v) {
>+    ushort4 result;
>+    result.x = v.z;
>+    result.y = v.x;
>+    result.z = v.w;
>+    result.w = v.x;
>+    return result;
>+}
>+uint4 operator.zxwx(uint4 v) {
>+    uint4 result;
>+    result.x = v.z;
>+    result.y = v.x;
>+    result.z = v.w;
>+    result.w = v.x;
>+    return result;
>+}
>+char4 operator.zxwx(char4 v) {
>+    char4 result;
>+    result.x = v.z;
>+    result.y = v.x;
>+    result.z = v.w;
>+    result.w = v.x;
>+    return result;
>+}
>+short4 operator.zxwx(short4 v) {
>+    short4 result;
>+    result.x = v.z;
>+    result.y = v.x;
>+    result.z = v.w;
>+    result.w = v.x;
>+    return result;
>+}
>+int4 operator.zxwx(int4 v) {
>+    int4 result;
>+    result.x = v.z;
>+    result.y = v.x;
>+    result.z = v.w;
>+    result.w = v.x;
>+    return result;
>+}
>+half4 operator.zxwx(half4 v) {
>+    half4 result;
>+    result.x = v.z;
>+    result.y = v.x;
>+    result.z = v.w;
>+    result.w = v.x;
>+    return result;
>+}
>+float4 operator.zxwx(float4 v) {
>+    float4 result;
>+    result.x = v.z;
>+    result.y = v.x;
>+    result.z = v.w;
>+    result.w = v.x;
>+    return result;
>+}
>+
>+/* Functions named operator.yzyy */
>+bool4 operator.yzyy(bool3 v) {
>+    bool4 result;
>+    result.x = v.y;
>+    result.y = v.z;
>+    result.z = v.y;
>+    result.w = v.y;
>+    return result;
>+}
>+bool4 operator.yzyy(bool4 v) {
>+    bool4 result;
>+    result.x = v.y;
>+    result.y = v.z;
>+    result.z = v.y;
>+    result.w = v.y;
>+    return result;
>+}
>+uchar4 operator.yzyy(uchar3 v) {
>+    uchar4 result;
>+    result.x = v.y;
>+    result.y = v.z;
>+    result.z = v.y;
>+    result.w = v.y;
>+    return result;
>+}
>+uchar4 operator.yzyy(uchar4 v) {
>+    uchar4 result;
>+    result.x = v.y;
>+    result.y = v.z;
>+    result.z = v.y;
>+    result.w = v.y;
>+    return result;
>+}
>+ushort4 operator.yzyy(ushort3 v) {
>+    ushort4 result;
>+    result.x = v.y;
>+    result.y = v.z;
>+    result.z = v.y;
>+    result.w = v.y;
>+    return result;
>+}
>+ushort4 operator.yzyy(ushort4 v) {
>+    ushort4 result;
>+    result.x = v.y;
>+    result.y = v.z;
>+    result.z = v.y;
>+    result.w = v.y;
>+    return result;
>+}
>+uint4 operator.yzyy(uint3 v) {
>+    uint4 result;
>+    result.x = v.y;
>+    result.y = v.z;
>+    result.z = v.y;
>+    result.w = v.y;
>+    return result;
>+}
>+uint4 operator.yzyy(uint4 v) {
>+    uint4 result;
>+    result.x = v.y;
>+    result.y = v.z;
>+    result.z = v.y;
>+    result.w = v.y;
>+    return result;
>+}
>+char4 operator.yzyy(char3 v) {
>+    char4 result;
>+    result.x = v.y;
>+    result.y = v.z;
>+    result.z = v.y;
>+    result.w = v.y;
>+    return result;
>+}
>+char4 operator.yzyy(char4 v) {
>+    char4 result;
>+    result.x = v.y;
>+    result.y = v.z;
>+    result.z = v.y;
>+    result.w = v.y;
>+    return result;
>+}
>+short4 operator.yzyy(short3 v) {
>+    short4 result;
>+    result.x = v.y;
>+    result.y = v.z;
>+    result.z = v.y;
>+    result.w = v.y;
>+    return result;
>+}
>+short4 operator.yzyy(short4 v) {
>+    short4 result;
>+    result.x = v.y;
>+    result.y = v.z;
>+    result.z = v.y;
>+    result.w = v.y;
>+    return result;
>+}
>+int4 operator.yzyy(int3 v) {
>+    int4 result;
>+    result.x = v.y;
>+    result.y = v.z;
>+    result.z = v.y;
>+    result.w = v.y;
>+    return result;
>+}
>+int4 operator.yzyy(int4 v) {
>+    int4 result;
>+    result.x = v.y;
>+    result.y = v.z;
>+    result.z = v.y;
>+    result.w = v.y;
>+    return result;
>+}
>+half4 operator.yzyy(half3 v) {
>+    half4 result;
>+    result.x = v.y;
>+    result.y = v.z;
>+    result.z = v.y;
>+    result.w = v.y;
>+    return result;
>+}
>+half4 operator.yzyy(half4 v) {
>+    half4 result;
>+    result.x = v.y;
>+    result.y = v.z;
>+    result.z = v.y;
>+    result.w = v.y;
>+    return result;
>+}
>+float4 operator.yzyy(float3 v) {
>+    float4 result;
>+    result.x = v.y;
>+    result.y = v.z;
>+    result.z = v.y;
>+    result.w = v.y;
>+    return result;
>+}
>+float4 operator.yzyy(float4 v) {
>+    float4 result;
>+    result.x = v.y;
>+    result.y = v.z;
>+    result.z = v.y;
>+    result.w = v.y;
>+    return result;
>+}
>+
>+/* Functions named operator.wwx */
>+bool3 operator.wwx(bool4 v) {
>+    bool3 result;
>+    result.x = v.w;
>+    result.y = v.w;
>+    result.z = v.x;
>+    return result;
>+}
>+uchar3 operator.wwx(uchar4 v) {
>+    uchar3 result;
>+    result.x = v.w;
>+    result.y = v.w;
>+    result.z = v.x;
>+    return result;
>+}
>+ushort3 operator.wwx(ushort4 v) {
>+    ushort3 result;
>+    result.x = v.w;
>+    result.y = v.w;
>+    result.z = v.x;
>+    return result;
>+}
>+uint3 operator.wwx(uint4 v) {
>+    uint3 result;
>+    result.x = v.w;
>+    result.y = v.w;
>+    result.z = v.x;
>+    return result;
>+}
>+char3 operator.wwx(char4 v) {
>+    char3 result;
>+    result.x = v.w;
>+    result.y = v.w;
>+    result.z = v.x;
>+    return result;
>+}
>+short3 operator.wwx(short4 v) {
>+    short3 result;
>+    result.x = v.w;
>+    result.y = v.w;
>+    result.z = v.x;
>+    return result;
>+}
>+int3 operator.wwx(int4 v) {
>+    int3 result;
>+    result.x = v.w;
>+    result.y = v.w;
>+    result.z = v.x;
>+    return result;
>+}
>+half3 operator.wwx(half4 v) {
>+    half3 result;
>+    result.x = v.w;
>+    result.y = v.w;
>+    result.z = v.x;
>+    return result;
>+}
>+float3 operator.wwx(float4 v) {
>+    float3 result;
>+    result.x = v.w;
>+    result.y = v.w;
>+    result.z = v.x;
>+    return result;
>+}
>+
>+/* Functions named operator.xwyx */
>+bool4 operator.xwyx(bool4 v) {
>+    bool4 result;
>+    result.x = v.x;
>+    result.y = v.w;
>+    result.z = v.y;
>+    result.w = v.x;
>+    return result;
>+}
>+uchar4 operator.xwyx(uchar4 v) {
>+    uchar4 result;
>+    result.x = v.x;
>+    result.y = v.w;
>+    result.z = v.y;
>+    result.w = v.x;
>+    return result;
>+}
>+ushort4 operator.xwyx(ushort4 v) {
>+    ushort4 result;
>+    result.x = v.x;
>+    result.y = v.w;
>+    result.z = v.y;
>+    result.w = v.x;
>+    return result;
>+}
>+uint4 operator.xwyx(uint4 v) {
>+    uint4 result;
>+    result.x = v.x;
>+    result.y = v.w;
>+    result.z = v.y;
>+    result.w = v.x;
>+    return result;
>+}
>+char4 operator.xwyx(char4 v) {
>+    char4 result;
>+    result.x = v.x;
>+    result.y = v.w;
>+    result.z = v.y;
>+    result.w = v.x;
>+    return result;
>+}
>+short4 operator.xwyx(short4 v) {
>+    short4 result;
>+    result.x = v.x;
>+    result.y = v.w;
>+    result.z = v.y;
>+    result.w = v.x;
>+    return result;
>+}
>+int4 operator.xwyx(int4 v) {
>+    int4 result;
>+    result.x = v.x;
>+    result.y = v.w;
>+    result.z = v.y;
>+    result.w = v.x;
>+    return result;
>+}
>+half4 operator.xwyx(half4 v) {
>+    half4 result;
>+    result.x = v.x;
>+    result.y = v.w;
>+    result.z = v.y;
>+    result.w = v.x;
>+    return result;
>+}
>+float4 operator.xwyx(float4 v) {
>+    float4 result;
>+    result.x = v.x;
>+    result.y = v.w;
>+    result.z = v.y;
>+    result.w = v.x;
>+    return result;
>+}
>+
>+/* Functions named operator.wxx */
>+bool3 operator.wxx(bool4 v) {
>+    bool3 result;
>+    result.x = v.w;
>+    result.y = v.x;
>+    result.z = v.x;
>+    return result;
>+}
>+uchar3 operator.wxx(uchar4 v) {
>+    uchar3 result;
>+    result.x = v.w;
>+    result.y = v.x;
>+    result.z = v.x;
>+    return result;
>+}
>+ushort3 operator.wxx(ushort4 v) {
>+    ushort3 result;
>+    result.x = v.w;
>+    result.y = v.x;
>+    result.z = v.x;
>+    return result;
>+}
>+uint3 operator.wxx(uint4 v) {
>+    uint3 result;
>+    result.x = v.w;
>+    result.y = v.x;
>+    result.z = v.x;
>+    return result;
>+}
>+char3 operator.wxx(char4 v) {
>+    char3 result;
>+    result.x = v.w;
>+    result.y = v.x;
>+    result.z = v.x;
>+    return result;
>+}
>+short3 operator.wxx(short4 v) {
>+    short3 result;
>+    result.x = v.w;
>+    result.y = v.x;
>+    result.z = v.x;
>+    return result;
>+}
>+int3 operator.wxx(int4 v) {
>+    int3 result;
>+    result.x = v.w;
>+    result.y = v.x;
>+    result.z = v.x;
>+    return result;
>+}
>+half3 operator.wxx(half4 v) {
>+    half3 result;
>+    result.x = v.w;
>+    result.y = v.x;
>+    result.z = v.x;
>+    return result;
>+}
>+float3 operator.wxx(float4 v) {
>+    float3 result;
>+    result.x = v.w;
>+    result.y = v.x;
>+    result.z = v.x;
>+    return result;
>+}
>+
>+/* Functions named operator.xyyx */
>+bool4 operator.xyyx(bool2 v) {
>+    bool4 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.y;
>+    result.w = v.x;
>+    return result;
>+}
>+bool4 operator.xyyx(bool3 v) {
>+    bool4 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.y;
>+    result.w = v.x;
>+    return result;
>+}
>+bool4 operator.xyyx(bool4 v) {
>+    bool4 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.y;
>+    result.w = v.x;
>+    return result;
>+}
>+uchar4 operator.xyyx(uchar2 v) {
>+    uchar4 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.y;
>+    result.w = v.x;
>+    return result;
>+}
>+uchar4 operator.xyyx(uchar3 v) {
>+    uchar4 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.y;
>+    result.w = v.x;
>+    return result;
>+}
>+uchar4 operator.xyyx(uchar4 v) {
>+    uchar4 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.y;
>+    result.w = v.x;
>+    return result;
>+}
>+ushort4 operator.xyyx(ushort2 v) {
>+    ushort4 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.y;
>+    result.w = v.x;
>+    return result;
>+}
>+ushort4 operator.xyyx(ushort3 v) {
>+    ushort4 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.y;
>+    result.w = v.x;
>+    return result;
>+}
>+ushort4 operator.xyyx(ushort4 v) {
>+    ushort4 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.y;
>+    result.w = v.x;
>+    return result;
>+}
>+uint4 operator.xyyx(uint2 v) {
>+    uint4 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.y;
>+    result.w = v.x;
>+    return result;
>+}
>+uint4 operator.xyyx(uint3 v) {
>+    uint4 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.y;
>+    result.w = v.x;
>+    return result;
>+}
>+uint4 operator.xyyx(uint4 v) {
>+    uint4 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.y;
>+    result.w = v.x;
>+    return result;
>+}
>+char4 operator.xyyx(char2 v) {
>+    char4 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.y;
>+    result.w = v.x;
>+    return result;
>+}
>+char4 operator.xyyx(char3 v) {
>+    char4 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.y;
>+    result.w = v.x;
>+    return result;
>+}
>+char4 operator.xyyx(char4 v) {
>+    char4 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.y;
>+    result.w = v.x;
>+    return result;
>+}
>+short4 operator.xyyx(short2 v) {
>+    short4 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.y;
>+    result.w = v.x;
>+    return result;
>+}
>+short4 operator.xyyx(short3 v) {
>+    short4 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.y;
>+    result.w = v.x;
>+    return result;
>+}
>+short4 operator.xyyx(short4 v) {
>+    short4 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.y;
>+    result.w = v.x;
>+    return result;
>+}
>+int4 operator.xyyx(int2 v) {
>+    int4 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.y;
>+    result.w = v.x;
>+    return result;
>+}
>+int4 operator.xyyx(int3 v) {
>+    int4 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.y;
>+    result.w = v.x;
>+    return result;
>+}
>+int4 operator.xyyx(int4 v) {
>+    int4 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.y;
>+    result.w = v.x;
>+    return result;
>+}
>+half4 operator.xyyx(half2 v) {
>+    half4 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.y;
>+    result.w = v.x;
>+    return result;
>+}
>+half4 operator.xyyx(half3 v) {
>+    half4 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.y;
>+    result.w = v.x;
>+    return result;
>+}
>+half4 operator.xyyx(half4 v) {
>+    half4 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.y;
>+    result.w = v.x;
>+    return result;
>+}
>+float4 operator.xyyx(float2 v) {
>+    float4 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.y;
>+    result.w = v.x;
>+    return result;
>+}
>+float4 operator.xyyx(float3 v) {
>+    float4 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.y;
>+    result.w = v.x;
>+    return result;
>+}
>+float4 operator.xyyx(float4 v) {
>+    float4 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.y;
>+    result.w = v.x;
>+    return result;
>+}
>+
>+/* Functions named operator.ywxx */
>+bool4 operator.ywxx(bool4 v) {
>+    bool4 result;
>+    result.x = v.y;
>+    result.y = v.w;
>+    result.z = v.x;
>+    result.w = v.x;
>+    return result;
>+}
>+uchar4 operator.ywxx(uchar4 v) {
>+    uchar4 result;
>+    result.x = v.y;
>+    result.y = v.w;
>+    result.z = v.x;
>+    result.w = v.x;
>+    return result;
>+}
>+ushort4 operator.ywxx(ushort4 v) {
>+    ushort4 result;
>+    result.x = v.y;
>+    result.y = v.w;
>+    result.z = v.x;
>+    result.w = v.x;
>+    return result;
>+}
>+uint4 operator.ywxx(uint4 v) {
>+    uint4 result;
>+    result.x = v.y;
>+    result.y = v.w;
>+    result.z = v.x;
>+    result.w = v.x;
>+    return result;
>+}
>+char4 operator.ywxx(char4 v) {
>+    char4 result;
>+    result.x = v.y;
>+    result.y = v.w;
>+    result.z = v.x;
>+    result.w = v.x;
>+    return result;
>+}
>+short4 operator.ywxx(short4 v) {
>+    short4 result;
>+    result.x = v.y;
>+    result.y = v.w;
>+    result.z = v.x;
>+    result.w = v.x;
>+    return result;
>+}
>+int4 operator.ywxx(int4 v) {
>+    int4 result;
>+    result.x = v.y;
>+    result.y = v.w;
>+    result.z = v.x;
>+    result.w = v.x;
>+    return result;
>+}
>+half4 operator.ywxx(half4 v) {
>+    half4 result;
>+    result.x = v.y;
>+    result.y = v.w;
>+    result.z = v.x;
>+    result.w = v.x;
>+    return result;
>+}
>+float4 operator.ywxx(float4 v) {
>+    float4 result;
>+    result.x = v.y;
>+    result.y = v.w;
>+    result.z = v.x;
>+    result.w = v.x;
>+    return result;
>+}
>+
>+/* Functions named operator.wwyw */
>+bool4 operator.wwyw(bool4 v) {
>+    bool4 result;
>+    result.x = v.w;
>+    result.y = v.w;
>+    result.z = v.y;
>+    result.w = v.w;
>+    return result;
>+}
>+uchar4 operator.wwyw(uchar4 v) {
>+    uchar4 result;
>+    result.x = v.w;
>+    result.y = v.w;
>+    result.z = v.y;
>+    result.w = v.w;
>+    return result;
>+}
>+ushort4 operator.wwyw(ushort4 v) {
>+    ushort4 result;
>+    result.x = v.w;
>+    result.y = v.w;
>+    result.z = v.y;
>+    result.w = v.w;
>+    return result;
>+}
>+uint4 operator.wwyw(uint4 v) {
>+    uint4 result;
>+    result.x = v.w;
>+    result.y = v.w;
>+    result.z = v.y;
>+    result.w = v.w;
>+    return result;
>+}
>+char4 operator.wwyw(char4 v) {
>+    char4 result;
>+    result.x = v.w;
>+    result.y = v.w;
>+    result.z = v.y;
>+    result.w = v.w;
>+    return result;
>+}
>+short4 operator.wwyw(short4 v) {
>+    short4 result;
>+    result.x = v.w;
>+    result.y = v.w;
>+    result.z = v.y;
>+    result.w = v.w;
>+    return result;
>+}
>+int4 operator.wwyw(int4 v) {
>+    int4 result;
>+    result.x = v.w;
>+    result.y = v.w;
>+    result.z = v.y;
>+    result.w = v.w;
>+    return result;
>+}
>+half4 operator.wwyw(half4 v) {
>+    half4 result;
>+    result.x = v.w;
>+    result.y = v.w;
>+    result.z = v.y;
>+    result.w = v.w;
>+    return result;
>+}
>+float4 operator.wwyw(float4 v) {
>+    float4 result;
>+    result.x = v.w;
>+    result.y = v.w;
>+    result.z = v.y;
>+    result.w = v.w;
>+    return result;
>+}
>+
>+/* Functions named operator.zwyx= */
>+bool4 operator.zwyx=(bool4 v, bool4 c) {
>+    bool4 result = v;
>+    result.z = c.x;
>+    result.w = c.y;
>+    result.y = c.z;
>+    result.x = c.w;
>+    return result;
>+}
>+uchar4 operator.zwyx=(uchar4 v, uchar4 c) {
>+    uchar4 result = v;
>+    result.z = c.x;
>+    result.w = c.y;
>+    result.y = c.z;
>+    result.x = c.w;
>+    return result;
>+}
>+ushort4 operator.zwyx=(ushort4 v, ushort4 c) {
>+    ushort4 result = v;
>+    result.z = c.x;
>+    result.w = c.y;
>+    result.y = c.z;
>+    result.x = c.w;
>+    return result;
>+}
>+uint4 operator.zwyx=(uint4 v, uint4 c) {
>+    uint4 result = v;
>+    result.z = c.x;
>+    result.w = c.y;
>+    result.y = c.z;
>+    result.x = c.w;
>+    return result;
>+}
>+char4 operator.zwyx=(char4 v, char4 c) {
>+    char4 result = v;
>+    result.z = c.x;
>+    result.w = c.y;
>+    result.y = c.z;
>+    result.x = c.w;
>+    return result;
>+}
>+short4 operator.zwyx=(short4 v, short4 c) {
>+    short4 result = v;
>+    result.z = c.x;
>+    result.w = c.y;
>+    result.y = c.z;
>+    result.x = c.w;
>+    return result;
>+}
>+int4 operator.zwyx=(int4 v, int4 c) {
>+    int4 result = v;
>+    result.z = c.x;
>+    result.w = c.y;
>+    result.y = c.z;
>+    result.x = c.w;
>+    return result;
>+}
>+half4 operator.zwyx=(half4 v, half4 c) {
>+    half4 result = v;
>+    result.z = c.x;
>+    result.w = c.y;
>+    result.y = c.z;
>+    result.x = c.w;
>+    return result;
>+}
>+float4 operator.zwyx=(float4 v, float4 c) {
>+    float4 result = v;
>+    result.z = c.x;
>+    result.w = c.y;
>+    result.y = c.z;
>+    result.x = c.w;
>+    return result;
>+}
>+
>+/* Functions named operator.xzy= */
>+bool3 operator.xzy=(bool3 v, bool3 c) {
>+    bool3 result = v;
>+    result.x = c.x;
>+    result.z = c.y;
>+    result.y = c.z;
>+    return result;
>+}
>+bool4 operator.xzy=(bool4 v, bool3 c) {
>+    bool4 result = v;
>+    result.x = c.x;
>+    result.z = c.y;
>+    result.y = c.z;
>+    return result;
>+}
>+uchar3 operator.xzy=(uchar3 v, uchar3 c) {
>+    uchar3 result = v;
>+    result.x = c.x;
>+    result.z = c.y;
>+    result.y = c.z;
>+    return result;
>+}
>+uchar4 operator.xzy=(uchar4 v, uchar3 c) {
>+    uchar4 result = v;
>+    result.x = c.x;
>+    result.z = c.y;
>+    result.y = c.z;
>+    return result;
>+}
>+ushort3 operator.xzy=(ushort3 v, ushort3 c) {
>+    ushort3 result = v;
>+    result.x = c.x;
>+    result.z = c.y;
>+    result.y = c.z;
>+    return result;
>+}
>+ushort4 operator.xzy=(ushort4 v, ushort3 c) {
>+    ushort4 result = v;
>+    result.x = c.x;
>+    result.z = c.y;
>+    result.y = c.z;
>+    return result;
>+}
>+uint3 operator.xzy=(uint3 v, uint3 c) {
>+    uint3 result = v;
>+    result.x = c.x;
>+    result.z = c.y;
>+    result.y = c.z;
>+    return result;
>+}
>+uint4 operator.xzy=(uint4 v, uint3 c) {
>+    uint4 result = v;
>+    result.x = c.x;
>+    result.z = c.y;
>+    result.y = c.z;
>+    return result;
>+}
>+char3 operator.xzy=(char3 v, char3 c) {
>+    char3 result = v;
>+    result.x = c.x;
>+    result.z = c.y;
>+    result.y = c.z;
>+    return result;
>+}
>+char4 operator.xzy=(char4 v, char3 c) {
>+    char4 result = v;
>+    result.x = c.x;
>+    result.z = c.y;
>+    result.y = c.z;
>+    return result;
>+}
>+short3 operator.xzy=(short3 v, short3 c) {
>+    short3 result = v;
>+    result.x = c.x;
>+    result.z = c.y;
>+    result.y = c.z;
>+    return result;
>+}
>+short4 operator.xzy=(short4 v, short3 c) {
>+    short4 result = v;
>+    result.x = c.x;
>+    result.z = c.y;
>+    result.y = c.z;
>+    return result;
>+}
>+int3 operator.xzy=(int3 v, int3 c) {
>+    int3 result = v;
>+    result.x = c.x;
>+    result.z = c.y;
>+    result.y = c.z;
>+    return result;
>+}
>+int4 operator.xzy=(int4 v, int3 c) {
>+    int4 result = v;
>+    result.x = c.x;
>+    result.z = c.y;
>+    result.y = c.z;
>+    return result;
>+}
>+half3 operator.xzy=(half3 v, half3 c) {
>+    half3 result = v;
>+    result.x = c.x;
>+    result.z = c.y;
>+    result.y = c.z;
>+    return result;
>+}
>+half4 operator.xzy=(half4 v, half3 c) {
>+    half4 result = v;
>+    result.x = c.x;
>+    result.z = c.y;
>+    result.y = c.z;
>+    return result;
>+}
>+float3 operator.xzy=(float3 v, float3 c) {
>+    float3 result = v;
>+    result.x = c.x;
>+    result.z = c.y;
>+    result.y = c.z;
>+    return result;
>+}
>+float4 operator.xzy=(float4 v, float3 c) {
>+    float4 result = v;
>+    result.x = c.x;
>+    result.z = c.y;
>+    result.y = c.z;
>+    return result;
>+}
>+
>+/* Functions named operator.xyyw */
>+bool4 operator.xyyw(bool4 v) {
>+    bool4 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.y;
>+    result.w = v.w;
>+    return result;
>+}
>+uchar4 operator.xyyw(uchar4 v) {
>+    uchar4 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.y;
>+    result.w = v.w;
>+    return result;
>+}
>+ushort4 operator.xyyw(ushort4 v) {
>+    ushort4 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.y;
>+    result.w = v.w;
>+    return result;
>+}
>+uint4 operator.xyyw(uint4 v) {
>+    uint4 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.y;
>+    result.w = v.w;
>+    return result;
>+}
>+char4 operator.xyyw(char4 v) {
>+    char4 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.y;
>+    result.w = v.w;
>+    return result;
>+}
>+short4 operator.xyyw(short4 v) {
>+    short4 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.y;
>+    result.w = v.w;
>+    return result;
>+}
>+int4 operator.xyyw(int4 v) {
>+    int4 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.y;
>+    result.w = v.w;
>+    return result;
>+}
>+half4 operator.xyyw(half4 v) {
>+    half4 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.y;
>+    result.w = v.w;
>+    return result;
>+}
>+float4 operator.xyyw(float4 v) {
>+    float4 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    result.z = v.y;
>+    result.w = v.w;
>+    return result;
>+}
>+
>+/* Functions named lerp */
>+half lerp(half x, half y, half s) {
>+    return x * (1 - s) + y * s;
>+}
>+half2 lerp(half2 x, half2 y, half2 z) {
>+    half2 result;
>+    result[0] = lerp(x[0], y[0], z[0]);
>+    result[1] = lerp(x[1], y[1], z[1]);
>+    return result;
>+}
>+half3 lerp(half3 x, half3 y, half3 z) {
>+    half3 result;
>+    result[0] = lerp(x[0], y[0], z[0]);
>+    result[1] = lerp(x[1], y[1], z[1]);
>+    result[2] = lerp(x[2], y[2], z[2]);
>+    return result;
>+}
>+half4 lerp(half4 x, half4 y, half4 z) {
>+    half4 result;
>+    result[0] = lerp(x[0], y[0], z[0]);
>+    result[1] = lerp(x[1], y[1], z[1]);
>+    result[2] = lerp(x[2], y[2], z[2]);
>+    result[3] = lerp(x[3], y[3], z[3]);
>+    return result;
>+}
>+half2x2 lerp(half2x2 x, half2x2 y, half2x2 z) {
>+    half2x2 result;
>+    result[0][0] = lerp(x[0][0], y[0][0], z[0][0]);
>+    result[0][1] = lerp(x[0][1], y[0][1], z[0][1]);
>+    result[1][0] = lerp(x[1][0], y[1][0], z[1][0]);
>+    result[1][1] = lerp(x[1][1], y[1][1], z[1][1]);
>+    return result;
>+}
>+half2x3 lerp(half2x3 x, half2x3 y, half2x3 z) {
>+    half2x3 result;
>+    result[0][0] = lerp(x[0][0], y[0][0], z[0][0]);
>+    result[0][1] = lerp(x[0][1], y[0][1], z[0][1]);
>+    result[0][2] = lerp(x[0][2], y[0][2], z[0][2]);
>+    result[1][0] = lerp(x[1][0], y[1][0], z[1][0]);
>+    result[1][1] = lerp(x[1][1], y[1][1], z[1][1]);
>+    result[1][2] = lerp(x[1][2], y[1][2], z[1][2]);
>+    return result;
>+}
>+half2x4 lerp(half2x4 x, half2x4 y, half2x4 z) {
>+    half2x4 result;
>+    result[0][0] = lerp(x[0][0], y[0][0], z[0][0]);
>+    result[0][1] = lerp(x[0][1], y[0][1], z[0][1]);
>+    result[0][2] = lerp(x[0][2], y[0][2], z[0][2]);
>+    result[0][3] = lerp(x[0][3], y[0][3], z[0][3]);
>+    result[1][0] = lerp(x[1][0], y[1][0], z[1][0]);
>+    result[1][1] = lerp(x[1][1], y[1][1], z[1][1]);
>+    result[1][2] = lerp(x[1][2], y[1][2], z[1][2]);
>+    result[1][3] = lerp(x[1][3], y[1][3], z[1][3]);
>+    return result;
>+}
>+half3x2 lerp(half3x2 x, half3x2 y, half3x2 z) {
>+    half3x2 result;
>+    result[0][0] = lerp(x[0][0], y[0][0], z[0][0]);
>+    result[0][1] = lerp(x[0][1], y[0][1], z[0][1]);
>+    result[1][0] = lerp(x[1][0], y[1][0], z[1][0]);
>+    result[1][1] = lerp(x[1][1], y[1][1], z[1][1]);
>+    result[2][0] = lerp(x[2][0], y[2][0], z[2][0]);
>+    result[2][1] = lerp(x[2][1], y[2][1], z[2][1]);
>+    return result;
>+}
>+half3x3 lerp(half3x3 x, half3x3 y, half3x3 z) {
>+    half3x3 result;
>+    result[0][0] = lerp(x[0][0], y[0][0], z[0][0]);
>+    result[0][1] = lerp(x[0][1], y[0][1], z[0][1]);
>+    result[0][2] = lerp(x[0][2], y[0][2], z[0][2]);
>+    result[1][0] = lerp(x[1][0], y[1][0], z[1][0]);
>+    result[1][1] = lerp(x[1][1], y[1][1], z[1][1]);
>+    result[1][2] = lerp(x[1][2], y[1][2], z[1][2]);
>+    result[2][0] = lerp(x[2][0], y[2][0], z[2][0]);
>+    result[2][1] = lerp(x[2][1], y[2][1], z[2][1]);
>+    result[2][2] = lerp(x[2][2], y[2][2], z[2][2]);
>+    return result;
>+}
>+half3x4 lerp(half3x4 x, half3x4 y, half3x4 z) {
>+    half3x4 result;
>+    result[0][0] = lerp(x[0][0], y[0][0], z[0][0]);
>+    result[0][1] = lerp(x[0][1], y[0][1], z[0][1]);
>+    result[0][2] = lerp(x[0][2], y[0][2], z[0][2]);
>+    result[0][3] = lerp(x[0][3], y[0][3], z[0][3]);
>+    result[1][0] = lerp(x[1][0], y[1][0], z[1][0]);
>+    result[1][1] = lerp(x[1][1], y[1][1], z[1][1]);
>+    result[1][2] = lerp(x[1][2], y[1][2], z[1][2]);
>+    result[1][3] = lerp(x[1][3], y[1][3], z[1][3]);
>+    result[2][0] = lerp(x[2][0], y[2][0], z[2][0]);
>+    result[2][1] = lerp(x[2][1], y[2][1], z[2][1]);
>+    result[2][2] = lerp(x[2][2], y[2][2], z[2][2]);
>+    result[2][3] = lerp(x[2][3], y[2][3], z[2][3]);
>+    return result;
>+}
>+half4x2 lerp(half4x2 x, half4x2 y, half4x2 z) {
>+    half4x2 result;
>+    result[0][0] = lerp(x[0][0], y[0][0], z[0][0]);
>+    result[0][1] = lerp(x[0][1], y[0][1], z[0][1]);
>+    result[1][0] = lerp(x[1][0], y[1][0], z[1][0]);
>+    result[1][1] = lerp(x[1][1], y[1][1], z[1][1]);
>+    result[2][0] = lerp(x[2][0], y[2][0], z[2][0]);
>+    result[2][1] = lerp(x[2][1], y[2][1], z[2][1]);
>+    result[3][0] = lerp(x[3][0], y[3][0], z[3][0]);
>+    result[3][1] = lerp(x[3][1], y[3][1], z[3][1]);
>+    return result;
>+}
>+half4x3 lerp(half4x3 x, half4x3 y, half4x3 z) {
>+    half4x3 result;
>+    result[0][0] = lerp(x[0][0], y[0][0], z[0][0]);
>+    result[0][1] = lerp(x[0][1], y[0][1], z[0][1]);
>+    result[0][2] = lerp(x[0][2], y[0][2], z[0][2]);
>+    result[1][0] = lerp(x[1][0], y[1][0], z[1][0]);
>+    result[1][1] = lerp(x[1][1], y[1][1], z[1][1]);
>+    result[1][2] = lerp(x[1][2], y[1][2], z[1][2]);
>+    result[2][0] = lerp(x[2][0], y[2][0], z[2][0]);
>+    result[2][1] = lerp(x[2][1], y[2][1], z[2][1]);
>+    result[2][2] = lerp(x[2][2], y[2][2], z[2][2]);
>+    result[3][0] = lerp(x[3][0], y[3][0], z[3][0]);
>+    result[3][1] = lerp(x[3][1], y[3][1], z[3][1]);
>+    result[3][2] = lerp(x[3][2], y[3][2], z[3][2]);
>+    return result;
>+}
>+half4x4 lerp(half4x4 x, half4x4 y, half4x4 z) {
>+    half4x4 result;
>+    result[0][0] = lerp(x[0][0], y[0][0], z[0][0]);
>+    result[0][1] = lerp(x[0][1], y[0][1], z[0][1]);
>+    result[0][2] = lerp(x[0][2], y[0][2], z[0][2]);
>+    result[0][3] = lerp(x[0][3], y[0][3], z[0][3]);
>+    result[1][0] = lerp(x[1][0], y[1][0], z[1][0]);
>+    result[1][1] = lerp(x[1][1], y[1][1], z[1][1]);
>+    result[1][2] = lerp(x[1][2], y[1][2], z[1][2]);
>+    result[1][3] = lerp(x[1][3], y[1][3], z[1][3]);
>+    result[2][0] = lerp(x[2][0], y[2][0], z[2][0]);
>+    result[2][1] = lerp(x[2][1], y[2][1], z[2][1]);
>+    result[2][2] = lerp(x[2][2], y[2][2], z[2][2]);
>+    result[2][3] = lerp(x[2][3], y[2][3], z[2][3]);
>+    result[3][0] = lerp(x[3][0], y[3][0], z[3][0]);
>+    result[3][1] = lerp(x[3][1], y[3][1], z[3][1]);
>+    result[3][2] = lerp(x[3][2], y[3][2], z[3][2]);
>+    result[3][3] = lerp(x[3][3], y[3][3], z[3][3]);
>+    return result;
>+}
>+float lerp(float x, float y, float s) {
>+    return x * (1 - s) + y * s;
>+}
>+float2 lerp(float2 x, float2 y, float2 z) {
>+    float2 result;
>+    result[0] = lerp(x[0], y[0], z[0]);
>+    result[1] = lerp(x[1], y[1], z[1]);
>+    return result;
>+}
>+float3 lerp(float3 x, float3 y, float3 z) {
>+    float3 result;
>+    result[0] = lerp(x[0], y[0], z[0]);
>+    result[1] = lerp(x[1], y[1], z[1]);
>+    result[2] = lerp(x[2], y[2], z[2]);
>+    return result;
>+}
>+float4 lerp(float4 x, float4 y, float4 z) {
>+    float4 result;
>+    result[0] = lerp(x[0], y[0], z[0]);
>+    result[1] = lerp(x[1], y[1], z[1]);
>+    result[2] = lerp(x[2], y[2], z[2]);
>+    result[3] = lerp(x[3], y[3], z[3]);
>+    return result;
>+}
>+float2x2 lerp(float2x2 x, float2x2 y, float2x2 z) {
>+    float2x2 result;
>+    result[0][0] = lerp(x[0][0], y[0][0], z[0][0]);
>+    result[0][1] = lerp(x[0][1], y[0][1], z[0][1]);
>+    result[1][0] = lerp(x[1][0], y[1][0], z[1][0]);
>+    result[1][1] = lerp(x[1][1], y[1][1], z[1][1]);
>+    return result;
>+}
>+float2x3 lerp(float2x3 x, float2x3 y, float2x3 z) {
>+    float2x3 result;
>+    result[0][0] = lerp(x[0][0], y[0][0], z[0][0]);
>+    result[0][1] = lerp(x[0][1], y[0][1], z[0][1]);
>+    result[0][2] = lerp(x[0][2], y[0][2], z[0][2]);
>+    result[1][0] = lerp(x[1][0], y[1][0], z[1][0]);
>+    result[1][1] = lerp(x[1][1], y[1][1], z[1][1]);
>+    result[1][2] = lerp(x[1][2], y[1][2], z[1][2]);
>+    return result;
>+}
>+float2x4 lerp(float2x4 x, float2x4 y, float2x4 z) {
>+    float2x4 result;
>+    result[0][0] = lerp(x[0][0], y[0][0], z[0][0]);
>+    result[0][1] = lerp(x[0][1], y[0][1], z[0][1]);
>+    result[0][2] = lerp(x[0][2], y[0][2], z[0][2]);
>+    result[0][3] = lerp(x[0][3], y[0][3], z[0][3]);
>+    result[1][0] = lerp(x[1][0], y[1][0], z[1][0]);
>+    result[1][1] = lerp(x[1][1], y[1][1], z[1][1]);
>+    result[1][2] = lerp(x[1][2], y[1][2], z[1][2]);
>+    result[1][3] = lerp(x[1][3], y[1][3], z[1][3]);
>+    return result;
>+}
>+float3x2 lerp(float3x2 x, float3x2 y, float3x2 z) {
>+    float3x2 result;
>+    result[0][0] = lerp(x[0][0], y[0][0], z[0][0]);
>+    result[0][1] = lerp(x[0][1], y[0][1], z[0][1]);
>+    result[1][0] = lerp(x[1][0], y[1][0], z[1][0]);
>+    result[1][1] = lerp(x[1][1], y[1][1], z[1][1]);
>+    result[2][0] = lerp(x[2][0], y[2][0], z[2][0]);
>+    result[2][1] = lerp(x[2][1], y[2][1], z[2][1]);
>+    return result;
>+}
>+float3x3 lerp(float3x3 x, float3x3 y, float3x3 z) {
>+    float3x3 result;
>+    result[0][0] = lerp(x[0][0], y[0][0], z[0][0]);
>+    result[0][1] = lerp(x[0][1], y[0][1], z[0][1]);
>+    result[0][2] = lerp(x[0][2], y[0][2], z[0][2]);
>+    result[1][0] = lerp(x[1][0], y[1][0], z[1][0]);
>+    result[1][1] = lerp(x[1][1], y[1][1], z[1][1]);
>+    result[1][2] = lerp(x[1][2], y[1][2], z[1][2]);
>+    result[2][0] = lerp(x[2][0], y[2][0], z[2][0]);
>+    result[2][1] = lerp(x[2][1], y[2][1], z[2][1]);
>+    result[2][2] = lerp(x[2][2], y[2][2], z[2][2]);
>+    return result;
>+}
>+float3x4 lerp(float3x4 x, float3x4 y, float3x4 z) {
>+    float3x4 result;
>+    result[0][0] = lerp(x[0][0], y[0][0], z[0][0]);
>+    result[0][1] = lerp(x[0][1], y[0][1], z[0][1]);
>+    result[0][2] = lerp(x[0][2], y[0][2], z[0][2]);
>+    result[0][3] = lerp(x[0][3], y[0][3], z[0][3]);
>+    result[1][0] = lerp(x[1][0], y[1][0], z[1][0]);
>+    result[1][1] = lerp(x[1][1], y[1][1], z[1][1]);
>+    result[1][2] = lerp(x[1][2], y[1][2], z[1][2]);
>+    result[1][3] = lerp(x[1][3], y[1][3], z[1][3]);
>+    result[2][0] = lerp(x[2][0], y[2][0], z[2][0]);
>+    result[2][1] = lerp(x[2][1], y[2][1], z[2][1]);
>+    result[2][2] = lerp(x[2][2], y[2][2], z[2][2]);
>+    result[2][3] = lerp(x[2][3], y[2][3], z[2][3]);
>+    return result;
>+}
>+float4x2 lerp(float4x2 x, float4x2 y, float4x2 z) {
>+    float4x2 result;
>+    result[0][0] = lerp(x[0][0], y[0][0], z[0][0]);
>+    result[0][1] = lerp(x[0][1], y[0][1], z[0][1]);
>+    result[1][0] = lerp(x[1][0], y[1][0], z[1][0]);
>+    result[1][1] = lerp(x[1][1], y[1][1], z[1][1]);
>+    result[2][0] = lerp(x[2][0], y[2][0], z[2][0]);
>+    result[2][1] = lerp(x[2][1], y[2][1], z[2][1]);
>+    result[3][0] = lerp(x[3][0], y[3][0], z[3][0]);
>+    result[3][1] = lerp(x[3][1], y[3][1], z[3][1]);
>+    return result;
>+}
>+float4x3 lerp(float4x3 x, float4x3 y, float4x3 z) {
>+    float4x3 result;
>+    result[0][0] = lerp(x[0][0], y[0][0], z[0][0]);
>+    result[0][1] = lerp(x[0][1], y[0][1], z[0][1]);
>+    result[0][2] = lerp(x[0][2], y[0][2], z[0][2]);
>+    result[1][0] = lerp(x[1][0], y[1][0], z[1][0]);
>+    result[1][1] = lerp(x[1][1], y[1][1], z[1][1]);
>+    result[1][2] = lerp(x[1][2], y[1][2], z[1][2]);
>+    result[2][0] = lerp(x[2][0], y[2][0], z[2][0]);
>+    result[2][1] = lerp(x[2][1], y[2][1], z[2][1]);
>+    result[2][2] = lerp(x[2][2], y[2][2], z[2][2]);
>+    result[3][0] = lerp(x[3][0], y[3][0], z[3][0]);
>+    result[3][1] = lerp(x[3][1], y[3][1], z[3][1]);
>+    result[3][2] = lerp(x[3][2], y[3][2], z[3][2]);
>+    return result;
>+}
>+float4x4 lerp(float4x4 x, float4x4 y, float4x4 z) {
>+    float4x4 result;
>+    result[0][0] = lerp(x[0][0], y[0][0], z[0][0]);
>+    result[0][1] = lerp(x[0][1], y[0][1], z[0][1]);
>+    result[0][2] = lerp(x[0][2], y[0][2], z[0][2]);
>+    result[0][3] = lerp(x[0][3], y[0][3], z[0][3]);
>+    result[1][0] = lerp(x[1][0], y[1][0], z[1][0]);
>+    result[1][1] = lerp(x[1][1], y[1][1], z[1][1]);
>+    result[1][2] = lerp(x[1][2], y[1][2], z[1][2]);
>+    result[1][3] = lerp(x[1][3], y[1][3], z[1][3]);
>+    result[2][0] = lerp(x[2][0], y[2][0], z[2][0]);
>+    result[2][1] = lerp(x[2][1], y[2][1], z[2][1]);
>+    result[2][2] = lerp(x[2][2], y[2][2], z[2][2]);
>+    result[2][3] = lerp(x[2][3], y[2][3], z[2][3]);
>+    result[3][0] = lerp(x[3][0], y[3][0], z[3][0]);
>+    result[3][1] = lerp(x[3][1], y[3][1], z[3][1]);
>+    result[3][2] = lerp(x[3][2], y[3][2], z[3][2]);
>+    result[3][3] = lerp(x[3][3], y[3][3], z[3][3]);
>+    return result;
>+}
>+
>+/* Functions named distance */
>+half distance(half x, half y) {
>+    return length(x - y);
>+}
>+half distance(half2 x, half2 y) {
>+    return length(x - y);
>+}
>+half distance(half3 x, half3 y) {
>+    return length(x - y);
>+}
>+half distance(half4 x, half4 y) {
>+    return length(x - y);
>+}
>+float distance(float x, float y) {
>+    return length(x - y);
>+}
>+float distance(float2 x, float2 y) {
>+    return length(x - y);
>+}
>+float distance(float3 x, float3 y) {
>+    return length(x - y);
>+}
>+float distance(float4 x, float4 y) {
>+    return length(x - y);
>+}
>+
>+
>+/* Functions named operator.zyzz */
>+bool4 operator.zyzz(bool3 v) {
>+    bool4 result;
>+    result.x = v.z;
>+    result.y = v.y;
>+    result.z = v.z;
>+    result.w = v.z;
>+    return result;
>+}
>+bool4 operator.zyzz(bool4 v) {
>+    bool4 result;
>+    result.x = v.z;
>+    result.y = v.y;
>+    result.z = v.z;
>+    result.w = v.z;
>+    return result;
>+}
>+uchar4 operator.zyzz(uchar3 v) {
>+    uchar4 result;
>+    result.x = v.z;
>+    result.y = v.y;
>+    result.z = v.z;
>+    result.w = v.z;
>+    return result;
>+}
>+uchar4 operator.zyzz(uchar4 v) {
>+    uchar4 result;
>+    result.x = v.z;
>+    result.y = v.y;
>+    result.z = v.z;
>+    result.w = v.z;
>+    return result;
>+}
>+ushort4 operator.zyzz(ushort3 v) {
>+    ushort4 result;
>+    result.x = v.z;
>+    result.y = v.y;
>+    result.z = v.z;
>+    result.w = v.z;
>+    return result;
>+}
>+ushort4 operator.zyzz(ushort4 v) {
>+    ushort4 result;
>+    result.x = v.z;
>+    result.y = v.y;
>+    result.z = v.z;
>+    result.w = v.z;
>+    return result;
>+}
>+uint4 operator.zyzz(uint3 v) {
>+    uint4 result;
>+    result.x = v.z;
>+    result.y = v.y;
>+    result.z = v.z;
>+    result.w = v.z;
>+    return result;
>+}
>+uint4 operator.zyzz(uint4 v) {
>+    uint4 result;
>+    result.x = v.z;
>+    result.y = v.y;
>+    result.z = v.z;
>+    result.w = v.z;
>+    return result;
>+}
>+char4 operator.zyzz(char3 v) {
>+    char4 result;
>+    result.x = v.z;
>+    result.y = v.y;
>+    result.z = v.z;
>+    result.w = v.z;
>+    return result;
>+}
>+char4 operator.zyzz(char4 v) {
>+    char4 result;
>+    result.x = v.z;
>+    result.y = v.y;
>+    result.z = v.z;
>+    result.w = v.z;
>+    return result;
>+}
>+short4 operator.zyzz(short3 v) {
>+    short4 result;
>+    result.x = v.z;
>+    result.y = v.y;
>+    result.z = v.z;
>+    result.w = v.z;
>+    return result;
>+}
>+short4 operator.zyzz(short4 v) {
>+    short4 result;
>+    result.x = v.z;
>+    result.y = v.y;
>+    result.z = v.z;
>+    result.w = v.z;
>+    return result;
>+}
>+int4 operator.zyzz(int3 v) {
>+    int4 result;
>+    result.x = v.z;
>+    result.y = v.y;
>+    result.z = v.z;
>+    result.w = v.z;
>+    return result;
>+}
>+int4 operator.zyzz(int4 v) {
>+    int4 result;
>+    result.x = v.z;
>+    result.y = v.y;
>+    result.z = v.z;
>+    result.w = v.z;
>+    return result;
>+}
>+half4 operator.zyzz(half3 v) {
>+    half4 result;
>+    result.x = v.z;
>+    result.y = v.y;
>+    result.z = v.z;
>+    result.w = v.z;
>+    return result;
>+}
>+half4 operator.zyzz(half4 v) {
>+    half4 result;
>+    result.x = v.z;
>+    result.y = v.y;
>+    result.z = v.z;
>+    result.w = v.z;
>+    return result;
>+}
>+float4 operator.zyzz(float3 v) {
>+    float4 result;
>+    result.x = v.z;
>+    result.y = v.y;
>+    result.z = v.z;
>+    result.w = v.z;
>+    return result;
>+}
>+float4 operator.zyzz(float4 v) {
>+    float4 result;
>+    result.x = v.z;
>+    result.y = v.y;
>+    result.z = v.z;
>+    result.w = v.z;
>+    return result;
>+}
>+
>+/* Functions named operator.w */
>+native bool operator.w(bool4);
>+native uchar operator.w(uchar4);
>+native ushort operator.w(ushort4);
>+native uint operator.w(uint4);
>+native char operator.w(char4);
>+native short operator.w(short4);
>+native int operator.w(int4);
>+native half operator.w(half4);
>+native float operator.w(float4);
> 
>-native void GetDimensions(Texture2D<float4>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* NumberOfLevels);
>-native void GetDimensions(Texture2D<float4>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* NumberOfLevels);
>-native void GetDimensions(Texture2D<float4>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels);
>-native void GetDimensions(Texture2D<float4>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* NumberOfLevels);
>-native void GetDimensions(Texture2D<float4>, uint MipLevel, thread uint* Width, device uint* Height, device uint* NumberOfLevels);
>-native void GetDimensions(Texture2D<float4>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* NumberOfLevels);
>-native void GetDimensions(Texture2D<float4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels);
>-native void GetDimensions(Texture2D<float4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* NumberOfLevels);
>-native void GetDimensions(Texture2D<float4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels);
>-native void GetDimensions(Texture2D<float4>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* NumberOfLevels);
>-native void GetDimensions(Texture2D<float4>, uint MipLevel, device uint* Width, thread uint* Height, device uint* NumberOfLevels);
>-native void GetDimensions(Texture2D<float4>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels);
>-native void GetDimensions(Texture2D<float4>, uint MipLevel, device uint* Width, device uint* Height, thread uint* NumberOfLevels);
>-native void GetDimensions(Texture2D<float4>, uint MipLevel, device uint* Width, device uint* Height, device uint* NumberOfLevels);
>-native void GetDimensions(Texture2D<float4>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* NumberOfLevels);
>-native void GetDimensions(Texture2D<float4>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels);
>-native void GetDimensions(Texture2D<float4>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* NumberOfLevels);
>-native void GetDimensions(Texture2D<float4>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels);
>-native void GetDimensions(Texture2D<float4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* NumberOfLevels);
>-native void GetDimensions(Texture2D<float4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* NumberOfLevels);
>-native void GetDimensions(Texture2D<float4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels);
>-native void GetDimensions(Texture2D<float4>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* NumberOfLevels);
>-native void GetDimensions(Texture2D<float4>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* NumberOfLevels);
>-native void GetDimensions(Texture2D<float4>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* NumberOfLevels);
>-native void GetDimensions(Texture2D<float4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels);
>-native void GetDimensions(Texture2D<float4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* NumberOfLevels);
>-native void GetDimensions(Texture2D<float4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels);
>+/* Functions named operator.wwxz */
>+bool4 operator.wwxz(bool4 v) {
>+    bool4 result;
>+    result.x = v.w;
>+    result.y = v.w;
>+    result.z = v.x;
>+    result.w = v.z;
>+    return result;
>+}
>+uchar4 operator.wwxz(uchar4 v) {
>+    uchar4 result;
>+    result.x = v.w;
>+    result.y = v.w;
>+    result.z = v.x;
>+    result.w = v.z;
>+    return result;
>+}
>+ushort4 operator.wwxz(ushort4 v) {
>+    ushort4 result;
>+    result.x = v.w;
>+    result.y = v.w;
>+    result.z = v.x;
>+    result.w = v.z;
>+    return result;
>+}
>+uint4 operator.wwxz(uint4 v) {
>+    uint4 result;
>+    result.x = v.w;
>+    result.y = v.w;
>+    result.z = v.x;
>+    result.w = v.z;
>+    return result;
>+}
>+char4 operator.wwxz(char4 v) {
>+    char4 result;
>+    result.x = v.w;
>+    result.y = v.w;
>+    result.z = v.x;
>+    result.w = v.z;
>+    return result;
>+}
>+short4 operator.wwxz(short4 v) {
>+    short4 result;
>+    result.x = v.w;
>+    result.y = v.w;
>+    result.z = v.x;
>+    result.w = v.z;
>+    return result;
>+}
>+int4 operator.wwxz(int4 v) {
>+    int4 result;
>+    result.x = v.w;
>+    result.y = v.w;
>+    result.z = v.x;
>+    result.w = v.z;
>+    return result;
>+}
>+half4 operator.wwxz(half4 v) {
>+    half4 result;
>+    result.x = v.w;
>+    result.y = v.w;
>+    result.z = v.x;
>+    result.w = v.z;
>+    return result;
>+}
>+float4 operator.wwxz(float4 v) {
>+    float4 result;
>+    result.x = v.w;
>+    result.y = v.w;
>+    result.z = v.x;
>+    result.w = v.z;
>+    return result;
>+}
>+
>+/* Functions named operator.xy */
>+bool2 operator.xy(bool2 v) {
>+    bool2 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    return result;
>+}
>+bool2 operator.xy(bool3 v) {
>+    bool2 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    return result;
>+}
>+bool2 operator.xy(bool4 v) {
>+    bool2 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    return result;
>+}
>+uchar2 operator.xy(uchar2 v) {
>+    uchar2 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    return result;
>+}
>+uchar2 operator.xy(uchar3 v) {
>+    uchar2 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    return result;
>+}
>+uchar2 operator.xy(uchar4 v) {
>+    uchar2 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    return result;
>+}
>+ushort2 operator.xy(ushort2 v) {
>+    ushort2 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    return result;
>+}
>+ushort2 operator.xy(ushort3 v) {
>+    ushort2 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    return result;
>+}
>+ushort2 operator.xy(ushort4 v) {
>+    ushort2 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    return result;
>+}
>+uint2 operator.xy(uint2 v) {
>+    uint2 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    return result;
>+}
>+uint2 operator.xy(uint3 v) {
>+    uint2 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    return result;
>+}
>+uint2 operator.xy(uint4 v) {
>+    uint2 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    return result;
>+}
>+char2 operator.xy(char2 v) {
>+    char2 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    return result;
>+}
>+char2 operator.xy(char3 v) {
>+    char2 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    return result;
>+}
>+char2 operator.xy(char4 v) {
>+    char2 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    return result;
>+}
>+short2 operator.xy(short2 v) {
>+    short2 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    return result;
>+}
>+short2 operator.xy(short3 v) {
>+    short2 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    return result;
>+}
>+short2 operator.xy(short4 v) {
>+    short2 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    return result;
>+}
>+int2 operator.xy(int2 v) {
>+    int2 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    return result;
>+}
>+int2 operator.xy(int3 v) {
>+    int2 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    return result;
>+}
>+int2 operator.xy(int4 v) {
>+    int2 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    return result;
>+}
>+half2 operator.xy(half2 v) {
>+    half2 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    return result;
>+}
>+half2 operator.xy(half3 v) {
>+    half2 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    return result;
>+}
>+half2 operator.xy(half4 v) {
>+    half2 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    return result;
>+}
>+float2 operator.xy(float2 v) {
>+    float2 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    return result;
>+}
>+float2 operator.xy(float3 v) {
>+    float2 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    return result;
>+}
>+float2 operator.xy(float4 v) {
>+    float2 result;
>+    result.x = v.x;
>+    result.y = v.y;
>+    return result;
>+}
> 
>-// FIXME: https://bugs.webkit.org/show_bug.cgi?id=192890 Insert the rest of the standard library once the parser is fast enough
>diff --git a/Source/WebCore/Modules/webgpu/WHLSL/WHLSLStandardLibraryFunctionMap.h b/Source/WebCore/Modules/webgpu/WHLSL/WHLSLStandardLibraryFunctionMap.h
>new file mode 100644
>index 0000000000000000000000000000000000000000..adad35064cd27c8872a0c32c94a4aae1b9fcf369
>--- /dev/null
>+++ b/Source/WebCore/Modules/webgpu/WHLSL/WHLSLStandardLibraryFunctionMap.h
>@@ -0,0 +1,48 @@
>+/*
>+ * Copyright (C) 2019 Apple Inc. All rights reserved.
>+ *
>+ * Redistribution and use in source and binary forms, with or without
>+ * modification, are permitted provided that the following conditions
>+ * are met:
>+ * 1. Redistributions of source code must retain the above copyright
>+ *    notice, this list of conditions and the following disclaimer.
>+ * 2. Redistributions in binary form must reproduce the above copyright
>+ *    notice, this list of conditions and the following disclaimer in the
>+ *    documentation and/or other materials provided with the distribution.
>+ *
>+ * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''
>+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
>+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
>+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
>+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
>+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
>+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
>+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
>+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
>+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
>+ * THE POSSIBILITY OF SUCH DAMAGE.
>+ */
>+
>+#pragma once
>+
>+#if ENABLE(WEBGPU)
>+
>+#include <wtf/HashMap.h>
>+#include <wtf/text/WTFString.h>
>+
>+namespace WebCore {
>+
>+namespace WHLSL {
>+
>+struct SubstringLocation {
>+    unsigned start;
>+    unsigned end;
>+};
>+
>+HashMap<String, SubstringLocation> computeStandardLibraryFunctionMap();
>+
>+} // namespace WHLSL
>+
>+} // namespace WebCore
>+
>+#endif // ENABLE(WEBGPU)
>diff --git a/Source/WebCore/Modules/webgpu/WHLSL/WHLSLStandardLibraryUtilities.h b/Source/WebCore/Modules/webgpu/WHLSL/WHLSLStandardLibraryUtilities.h
>new file mode 100644
>index 0000000000000000000000000000000000000000..63f16c5481dc1f72681f2f0dc427bcd0952e3f0f
>--- /dev/null
>+++ b/Source/WebCore/Modules/webgpu/WHLSL/WHLSLStandardLibraryUtilities.h
>@@ -0,0 +1,45 @@
>+/*
>+ * Copyright (C) 2019 Apple Inc. All rights reserved.
>+ *
>+ * Redistribution and use in source and binary forms, with or without
>+ * modification, are permitted provided that the following conditions
>+ * are met:
>+ * 1. Redistributions of source code must retain the above copyright
>+ *    notice, this list of conditions and the following disclaimer.
>+ * 2. Redistributions in binary form must reproduce the above copyright
>+ *    notice, this list of conditions and the following disclaimer in the
>+ *    documentation and/or other materials provided with the distribution.
>+ *
>+ * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''
>+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
>+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
>+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
>+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
>+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
>+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
>+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
>+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
>+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
>+ * THE POSSIBILITY OF SUCH DAMAGE.
>+ */
>+
>+#pragma once
>+
>+#if ENABLE(WEBGPU)
>+
>+#include <wtf/text/WTFString.h>
>+
>+namespace WebCore {
>+
>+namespace WHLSL {
>+
>+class Parser;
>+class Program;
>+
>+void includeStandardLibrary(Program&, Parser&);
>+
>+}
>+
>+}
>+
>+#endif
>diff --git a/Source/WebCore/Sources.txt b/Source/WebCore/Sources.txt
>index 155c66139b59f5fef0fe7ac1771f272bba54ba7f..859f38d70adff553fdda63c61294c0006d325a5b 100644
>--- a/Source/WebCore/Sources.txt
>+++ b/Source/WebCore/Sources.txt
>@@ -2502,6 +2502,7 @@ WebCoreJSBuiltinInternals.cpp
> WebCoreJSBuiltins.cpp
> JSSVGElementWrapperFactory.cpp
> JSHTMLElementWrapperFactory.cpp
>+WHLSLStandardLibraryFunctionMap.cpp
> 
> // IDL bindings
> // FIXME: We should probably move these into ${DerivedSources}/bindings/js/ so they get bundled with the custom bindings.
>diff --git a/Source/WebCore/SourcesCocoa.txt b/Source/WebCore/SourcesCocoa.txt
>index 7b1e575eab12d8155d46fee14b151381e3959014..13fbd10d7236f246f2682cf17e0f9d380330aaea 100644
>--- a/Source/WebCore/SourcesCocoa.txt
>+++ b/Source/WebCore/SourcesCocoa.txt
>@@ -27,6 +27,8 @@ Modules/plugins/QuickTimePluginReplacement.mm
> Modules/plugins/YouTubePluginReplacement.cpp
> Modules/webdatabase/cocoa/DatabaseManagerCocoa.mm
> 
>+Modules/webgpu/WHLSL/Cocoa/WHLSLStandardLibraryUtilities.cpp
>+
> accessibility/ios/AccessibilityObjectIOS.mm
> accessibility/ios/AXObjectCacheIOS.mm
> accessibility/ios/WebAccessibilityObjectWrapperIOS.mm
>diff --git a/Source/WebCore/WebCore.xcodeproj/project.pbxproj b/Source/WebCore/WebCore.xcodeproj/project.pbxproj
>index ae4802efa5bb9f523edcfc529ca9296d15f42eb9..c997ebbf731a582b43fa756d5cfe072c4ba0623d 100644
>--- a/Source/WebCore/WebCore.xcodeproj/project.pbxproj
>+++ b/Source/WebCore/WebCore.xcodeproj/project.pbxproj
>@@ -630,6 +630,7 @@
> 		1C73A71521857587004CCEA5 /* TextDecorationThickness.h in Headers */ = {isa = PBXBuildFile; fileRef = 1CB6B4F8217B83930093B9CD /* TextDecorationThickness.h */; settings = {ATTRIBUTES = (Private, ); }; };
> 		1C81B95A0E97330800266E07 /* InspectorController.h in Headers */ = {isa = PBXBuildFile; fileRef = 1C81B9560E97330800266E07 /* InspectorController.h */; settings = {ATTRIBUTES = (Private, ); }; };
> 		1C81B95C0E97330800266E07 /* InspectorClient.h in Headers */ = {isa = PBXBuildFile; fileRef = 1C81B9580E97330800266E07 /* InspectorClient.h */; settings = {ATTRIBUTES = (Private, ); }; };
>+		1C8D26D122C09E8300D125F3 /* libcompression.tbd in Frameworks */ = {isa = PBXBuildFile; fileRef = 1C8D26D022C09CDE00D125F3 /* libcompression.tbd */; };
> 		1CA19E160DC255CA0065A994 /* EventLoop.h in Headers */ = {isa = PBXBuildFile; fileRef = 1CA19E150DC255CA0065A994 /* EventLoop.h */; };
> 		1CAF34810A6C405200ABE06E /* WebScriptObject.h in Headers */ = {isa = PBXBuildFile; fileRef = 1CAF347E0A6C405200ABE06E /* WebScriptObject.h */; settings = {ATTRIBUTES = (Private, ); }; };
> 		1CAF34820A6C405200ABE06E /* WebScriptObject.mm in Sources */ = {isa = PBXBuildFile; fileRef = 1CAF347F0A6C405200ABE06E /* WebScriptObject.mm */; };
>@@ -6401,9 +6402,11 @@
> 		1C3969CF1B74211E002BCFA7 /* FontCacheCoreText.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = FontCacheCoreText.cpp; sourceTree = "<group>"; };
> 		1C43DE6822AB4B8A001527D9 /* LocalCurrentTraitCollection.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = LocalCurrentTraitCollection.h; sourceTree = "<group>"; };
> 		1C43DE6A22AB4B8A001527D9 /* LocalCurrentTraitCollection.mm */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.objcpp; path = LocalCurrentTraitCollection.mm; sourceTree = "<group>"; };
>+		1C50C49522C84F2400A6E4BE /* WHLSLStandardLibraryFunctionMap.cpp */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.cpp; path = WHLSLStandardLibraryFunctionMap.cpp; sourceTree = "<group>"; };
> 		1C59B0182238687900853805 /* WHLSLScopedSetAdder.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = WHLSLScopedSetAdder.h; sourceTree = "<group>"; };
> 		1C66260E1C6E7CA600AB527C /* FontFace.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = FontFace.cpp; sourceTree = "<group>"; };
> 		1C66260F1C6E7CA600AB527C /* FontFace.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = FontFace.h; sourceTree = "<group>"; };
>+		1C6B95DD22C858A400E6F14F /* WHLSLBuildStandardLibraryFunctionMap.py */ = {isa = PBXFileReference; lastKnownFileType = text.script.python; path = WHLSLBuildStandardLibraryFunctionMap.py; sourceTree = "<group>"; };
> 		1C81B9560E97330800266E07 /* InspectorController.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = InspectorController.h; sourceTree = "<group>"; };
> 		1C81B9570E97330800266E07 /* InspectorController.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = InspectorController.cpp; sourceTree = "<group>"; };
> 		1C81B9580E97330800266E07 /* InspectorClient.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = InspectorClient.h; sourceTree = "<group>"; };
>@@ -6417,6 +6420,9 @@
> 		1C86CA4C22AA19FF001BF961 /* WHLSLComputeDimensions.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = WHLSLComputeDimensions.h; sourceTree = "<group>"; };
> 		1C86CA4E22AA23C9001BF961 /* GPUPipelineMetalConvertLayout.cpp */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.cpp; path = GPUPipelineMetalConvertLayout.cpp; sourceTree = "<group>"; };
> 		1C86CA4F22AA23C9001BF961 /* GPUPipelineMetalConvertLayout.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = GPUPipelineMetalConvertLayout.h; sourceTree = "<group>"; };
>+		1C8D26C922C0945300D125F3 /* WHLSLStandardLibraryUtilities.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = WHLSLStandardLibraryUtilities.h; sourceTree = "<group>"; };
>+		1C8D26CE22C0951300D125F3 /* WHLSLStandardLibraryUtilities.cpp */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.cpp; path = WHLSLStandardLibraryUtilities.cpp; sourceTree = "<group>"; };
>+		1C8D26D022C09CDE00D125F3 /* libcompression.tbd */ = {isa = PBXFileReference; lastKnownFileType = "sourcecode.text-based-dylib-definition"; name = libcompression.tbd; path = usr/lib/libcompression.tbd; sourceTree = SDKROOT; };
> 		1C904DF90BA9D2C80081E9D0 /* Version.xcconfig */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.xcconfig; path = Version.xcconfig; sourceTree = "<group>"; };
> 		1C9AE5CA21ED9DF50069D5F2 /* WHLSLHighZombieFinder.cpp */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.cpp; path = WHLSLHighZombieFinder.cpp; sourceTree = "<group>"; };
> 		1C9AE5CB21ED9DF50069D5F2 /* WHLSLHighZombieFinder.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = WHLSLHighZombieFinder.h; sourceTree = "<group>"; };
>@@ -6446,6 +6452,7 @@
> 		1CB6B4FB217B83940093B9CD /* TextUnderlineOffset.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = TextUnderlineOffset.h; sourceTree = "<group>"; };
> 		1CCDF5BB1990332400BCEBAD /* SVGToOTFFontConversion.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = SVGToOTFFontConversion.cpp; sourceTree = "<group>"; };
> 		1CCDF5BC1990332400BCEBAD /* SVGToOTFFontConversion.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = SVGToOTFFontConversion.h; sourceTree = "<group>"; };
>+		1CDABD6B22C8479A00BD0A3A /* WHLSLStandardLibraryFunctionMap.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = WHLSLStandardLibraryFunctionMap.h; sourceTree = "<group>"; };
> 		1CDD45E40BA9C84600F90147 /* DebugRelease.xcconfig */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.xcconfig; path = DebugRelease.xcconfig; sourceTree = "<group>"; };
> 		1CDD45E50BA9C84600F90147 /* WebCore.xcconfig */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.xcconfig; path = WebCore.xcconfig; sourceTree = "<group>"; };
> 		1CDD45E60BA9C84600F90147 /* Base.xcconfig */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.xcconfig; path = Base.xcconfig; sourceTree = "<group>"; };
>@@ -15599,6 +15606,7 @@
> 				FD2DBF1312B048A300ED98C6 /* AudioToolbox.framework in Frameworks */,
> 				1AB33DA512551E320024457A /* IOKit.framework in Frameworks */,
> 				93F19B1608245E59001E9ABC /* JavaScriptCore.framework in Frameworks */,
>+				1C8D26D122C09E8300D125F3 /* libcompression.tbd in Frameworks */,
> 				93F19B1708245E59001E9ABC /* libicucore.dylib in Frameworks */,
> 				1CFAE3230A6D6A3F0032593D /* libobjc.dylib in Frameworks */,
> 				1C09D0591E31C6A900725F18 /* libPAL.a in Frameworks */,
>@@ -16192,6 +16200,7 @@
> 				A15E6BF01E212A6A0080AF34 /* Foundation.framework */,
> 				1AB33DA412551E320024457A /* IOKit.framework */,
> 				F8216299029F4FB501000131 /* JavaScriptCore.framework */,
>+				1C8D26D022C09CDE00D125F3 /* libcompression.tbd */,
> 				93F1D31A0558CC5C00821BC0 /* libicucore.dylib */,
> 				1CFAE3220A6D6A3F0032593D /* libobjc.dylib */,
> 				DD763BB10992C2C900740B8E /* libxml2.dylib */,
>@@ -17080,6 +17089,14 @@
> 			tabWidth = 8;
> 			usesTabs = 0;
> 		};
>+		1C8D26CD22C0948F00D125F3 /* Cocoa */ = {
>+			isa = PBXGroup;
>+			children = (
>+				1C8D26CE22C0951300D125F3 /* WHLSLStandardLibraryUtilities.cpp */,
>+			);
>+			path = Cocoa;
>+			sourceTree = "<group>";
>+		};
> 		1CA0C2F621EEDAD200A11860 /* AST */ = {
> 			isa = PBXGroup;
> 			children = (
>@@ -19890,6 +19907,7 @@
> 				1A1414B313A0F0500019996C /* WebKitFontFamilyNames.cpp */,
> 				1A1414B413A0F0500019996C /* WebKitFontFamilyNames.h */,
> 				C21BF74221CD963B00227979 /* WHLSLStandardLibrary.h */,
>+				1C50C49522C84F2400A6E4BE /* WHLSLStandardLibraryFunctionMap.cpp */,
> 				51748FA21CC6EEEB00728D84 /* WorkerGlobalScopeConstructors.idl */,
> 				9908B0F91BCAD07D00ED0F75 /* WritableStreamBuiltins.cpp */,
> 				9B03D8061BB3110D00B764E8 /* WritableStreamBuiltins.h */,
>@@ -25492,11 +25510,13 @@
> 			isa = PBXGroup;
> 			children = (
> 				1CA0C2F621EEDAD200A11860 /* AST */,
>+				1C8D26CD22C0948F00D125F3 /* Cocoa */,
> 				1CECB3AD21F2B96400F44542 /* Metal */,
> 				C20F88AA22966B0E00D610FA /* WHLSLASTDumper.cpp */,
> 				C20F88AC22966B0F00D610FA /* WHLSLASTDumper.h */,
> 				52B3434B22A0752300E49389 /* WHLSLAutoInitializeVariables.cpp */,
> 				52B3434922A0752200E49389 /* WHLSLAutoInitializeVariables.h */,
>+				1C6B95DD22C858A400E6F14F /* WHLSLBuildStandardLibraryFunctionMap.py */,
> 				C234A9B221E92C1F003C984D /* WHLSLCheckDuplicateFunctions.cpp */,
> 				C234A9AE21E92C1A003C984D /* WHLSLCheckDuplicateFunctions.h */,
> 				1C840B9B21EC400900D0500D /* WHLSLChecker.cpp */,
>@@ -25544,6 +25564,8 @@
> 				C24A57B221FB8DDA004C6DD1 /* WHLSLSemanticMatcher.cpp */,
> 				C24A57B321FB8DDA004C6DD1 /* WHLSLSemanticMatcher.h */,
> 				C21BF74521CD969800227979 /* WHLSLStandardLibrary.txt */,
>+				1CDABD6B22C8479A00BD0A3A /* WHLSLStandardLibraryFunctionMap.h */,
>+				1C8D26C922C0945300D125F3 /* WHLSLStandardLibraryUtilities.h */,
> 				1CECB3A921F2B67300F44542 /* WHLSLStatementBehaviorChecker.cpp */,
> 				1CECB3A821F2B67300F44542 /* WHLSLStatementBehaviorChecker.h */,
> 				C234A9A921E92C17003C984D /* WHLSLSynthesizeArrayOperatorLength.cpp */,
>diff --git a/LayoutTests/webgpu/whlsl-matrix.html b/LayoutTests/webgpu/whlsl-matrix.html
>index f47b06ce8f3936f95406623c83c7de5cd23fd5e6..dc3b65c286b3d511907c8f977c6b7728de2151d7 100644
>--- a/LayoutTests/webgpu/whlsl-matrix.html
>+++ b/LayoutTests/webgpu/whlsl-matrix.html
>@@ -24,19 +24,19 @@ compute void computeShader(device float[] buffer : register(u0), float3 threadID
>     if (!allEqual(foo, 0))
>         return;
> 
>-    foo = foo + 1.0;
>+    foo = foo + float2x3(float3(1.0, 1.0, 1.0), float3(1.0, 1.0, 1.0));
>     if (!allEqual(foo, 1))
>         return;
> 
>-    foo = foo * 8.5;
>+    foo = foo * float2x3(float3(8.5, 8.5, 8.5), float3(8.5, 8.5, 8.5));
>     if (!allEqual(foo, 8.5))
>         return;
> 
>-    foo = foo - 7.5;
>+    foo = foo - float2x3(float3(7.5, 7.5, 7.5), float3(7.5, 7.5, 7.5));
>     if (!allEqual(foo, 1))
>         return;
> 
>-    foo = foo + 1.0;
>+    foo = foo + float2x3(float3(1.0, 1.0, 1.0), float3(1.0, 1.0, 1.0));
>     if (!allEqual(foo, 2))
>         return;
>

Actions: View | Formatted Diff | Diff

Attachments on bug 198186: 372733 | 372942 | 372998 | 373090 | 373143 | 373164 | 373181 | 373187 | 373188 | 373189 | 373212 | 373343 | 373392