Attachment 347063 Details for Bug 188542 – Patch

[patch] Patch

bug-188542-20180813201655.patch (text/plain), 2.06 MB, created by Thomas Denney on 2018-08-13 20:16:56 PDT

(hide)

Description:

Filename:

MIME Type:

Creator: Thomas Denney

Created: 2018-08-13 20:16:56 PDT

Size: 2.06 MB

patch

obsolete

>Subversion Revision: 234815
>diff --git a/Tools/WebGPUShadingLanguageRI/All.js b/Tools/WebGPUShadingLanguageRI/All.js
>index 15dd7ccab94692a32acd27b9dac96c8a8f55d658..adea6df90f4742dbfe29f4992a4009008de8e35e 100644
>--- a/Tools/WebGPUShadingLanguageRI/All.js
>+++ b/Tools/WebGPUShadingLanguageRI/All.js
>@@ -34,6 +34,7 @@ load("Visitor.js");
> load("CreateLiteral.js");
> load("CreateLiteralType.js");
> load("PropertyAccessExpression.js");
>+load("SwizzleOp.js");
> 
> load("AddressSpace.js");
> load("AnonymousVariable.js");
>@@ -44,40 +45,45 @@ load("AutoWrapper.js");
> load("Block.js");
> load("BoolLiteral.js");
> load("Break.js");
>+load("BuiltinVectorCasts.js");
>+load("BuiltinVectorEqualityOperator.js");
>+load("BuiltinVectorGetter.js");
>+load("BuiltinVectorIndexGetter.js");
>+load("BuiltinVectorIndexSetter.js");
>+load("BuiltinVectorSetter.js");
> load("CallExpression.js");
>+load("CallExpressionTypeArgumentResolver.js");
> load("CallFunction.js");
> load("Check.js");
>+load("Checker.js");
> load("CheckLiteralTypes.js");
> load("CheckLoops.js");
>-load("CheckRecursiveTypes.js");
> load("CheckRecursion.js");
>+load("CheckRecursiveTypes.js");
> load("CheckReturns.js");
> load("CheckUnreachableCode.js");
> load("CheckWrapped.js");
>-load("Checker.js");
> load("CloneProgram.js");
> load("CommaExpression.js");
> load("ConstexprFolder.js");
>-load("ConstexprTypeParameter.js");
> load("Continue.js");
> load("ConvertPtrToArrayRefExpression.js");
> load("DereferenceExpression.js");
>-load("DoWhileLoop.js");
> load("DotExpression.js");
>+load("DoWhileLoop.js");
> load("EArrayRef.js");
> load("EBuffer.js");
> load("EBufferBuilder.js");
>-load("EPtr.js");
> load("EnumLiteral.js");
> load("EnumMember.js");
> load("EnumType.js");
>+load("EPtr.js");
> load("EvaluationCommon.js");
> load("Evaluator.js");
> load("ExpressionFinder.js");
> load("ExternalOrigin.js");
> load("Field.js");
> load("FindHighZombies.js");
>-load("FlattenProtocolExtends.js");
> load("FlattenedStructOffsetGatherer.js");
> load("FloatLiteral.js");
> load("FloatLiteralType.js");
>@@ -95,7 +101,6 @@ load("IndexExpression.js");
> load("InferTypesForCall.js");
> load("Inline.js");
> load("Inliner.js");
>-load("InstantiateImmediates.js");
> load("IntLiteral.js");
> load("IntLiteralType.js");
> load("Intrinsics.js");
>@@ -112,12 +117,14 @@ load("NameContext.js");
> load("NameFinder.js");
> load("NameResolver.js");
> load("NativeFunc.js");
>-load("NativeFuncInstance.js");
> load("NativeType.js");
>-load("NativeTypeInstance.js");
>+load("NativeParameterizedType.js"); // Depends on NativeType.js
> load("NormalUsePropertyResolver.js");
> load("NullLiteral.js");
> load("NullType.js");
>+load("OperatorAnderIndex.js");
>+load("OperatorArrayRefLength.js");
>+load("OperatorBool.js");
> load("OriginKind.js");
> load("OverloadResolutionFailure.js");
> load("Parse.js");
>@@ -125,14 +132,11 @@ load("Prepare.js");
> load("Program.js");
> load("ProgramWithUnnecessaryThingsRemoved.js");
> load("PropertyResolver.js");
>-load("Protocol.js");
>-load("ProtocolDecl.js");
>-load("ProtocolFuncDecl.js");
>-load("ProtocolRef.js");
> load("PtrType.js");
> load("ReadModifyWriteExpression.js");
> load("RecursionChecker.js");
> load("RecursiveTypeChecker.js");
>+load("ResolveCallExpressionsWithTypeArguments.js");
> load("ResolveNames.js");
> load("ResolveOverloadImpl.js");
> load("ResolveProperties.js");
>@@ -144,30 +148,32 @@ load("StandardLibrary.js");
> load("StatementCloner.js");
> load("StructLayoutBuilder.js");
> load("StructType.js");
>-load("Substitution.js");
> load("SwitchCase.js");
> load("SwitchStatement.js");
>+load("SynthesizeArrayOperatorLength.js");
>+load("SynthesizeCopyConstructorOperator.js");
>+load("SynthesizeDefaultConstructorOperator.js");
> load("SynthesizeEnumFunctions.js");
>+load("SynthesizeOperatorBool.js");
> load("SynthesizeStructAccessors.js");
>+load("TernaryExpression.js");
> load("TrapStatement.js");
> load("TypeDef.js");
> load("TypeDefResolver.js");
>-load("TypeOrVariableRef.js");
>-load("TypeParameterRewriter.js");
>-load("TypeRef.js");
>-load("TypeVariable.js");
>-load("TypeVariableTracker.js");
> load("TypedValue.js");
>+load("TypeRef.js");
> load("UintLiteral.js");
> load("UintLiteralType.js");
> load("UnificationContext.js");
> load("UnreachableCodeChecker.js");
> load("VariableDecl.js");
> load("VariableRef.js");
>+load("VectorType.js");
> load("VisitingSet.js");
>+load("WhileLoop.js");
>+load("WrapChecker.js");
> load("WSyntaxError.js");
> load("WTrapError.js");
> load("WTypeError.js");
>-load("WhileLoop.js");
>-load("WrapChecker.js");
>+
> 
>diff --git a/Tools/WebGPUShadingLanguageRI/AutoWrapper.js b/Tools/WebGPUShadingLanguageRI/AutoWrapper.js
>index 80ae7d92a4fa62666db2a2ff5220d149a7f38e9c..216a7e2e33de991b06ab636db5cfcab405d8ee29 100644
>--- a/Tools/WebGPUShadingLanguageRI/AutoWrapper.js
>+++ b/Tools/WebGPUShadingLanguageRI/AutoWrapper.js
>@@ -35,11 +35,6 @@ class AutoWrapper extends Rewriter {
>         return node;
>     }
>     
>-    visitConstexprTypeParameter(node)
>-    {
>-        return VariableRef.wrap(node);
>-    }
>-    
>     visitFuncParameter(node)
>     {
>         return VariableRef.wrap(node);
>@@ -60,11 +55,6 @@ class AutoWrapper extends Rewriter {
>         return TypeRef.wrap(node);
>     }
>     
>-    visitTypeVariable(node)
>-    {
>-        return TypeRef.wrap(node);
>-    }
>-    
>     visitGenericLiteralType(node)
>     {
>         return node;
>diff --git a/Tools/WebGPUShadingLanguageRI/BuiltinVectorCasts.js b/Tools/WebGPUShadingLanguageRI/BuiltinVectorCasts.js
>new file mode 100644
>index 0000000000000000000000000000000000000000..aec1195b6cb1b03cf301e8666835b36c812547aa
>--- /dev/null
>+++ b/Tools/WebGPUShadingLanguageRI/BuiltinVectorCasts.js
>@@ -0,0 +1,87 @@
>+/*
>+ * Copyright (C) 2017 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. ``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
>+ * 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. 
>+ */
>+"use strict";
>+
>+class BuiltinVectorCasts {
>+    constructor(baseTypeName, parameterSizes)
>+    {
>+        this._baseTypeName = baseTypeName;
>+        this._parameterSizes = parameterSizes;
>+    }
>+
>+    get baseTypeName() { return this._baseTypeName; }
>+    get parameterSizes() { return this._parameterSizes; }
>+    get outputSize()
>+    {
>+        let sum = 0;
>+        for (let paramSize of this.parameterSizes)
>+            sum += paramSize;
>+        return sum;
>+    }
>+
>+    toString()
>+    {
>+        return `native operator ${this.baseTypeName}${this.outputSize}(${this.parameterSizes.map(x => x == 1 ? this.baseTypeName : this.baseTypeName + x).join(",")})`;
>+    }
>+
>+    static functions()
>+    {
>+        if (!this._functions) {
>+            this._functions = [];
>+        
>+            for (let typeName of VectorElementTypes) {
>+                for (let size of VectorElementSizes) {
>+                    for (let paramSizes of this._vectorParameterSizesForMaximumSize(size))
>+                        this._functions.push(new BuiltinVectorCasts(typeName, paramSizes));
>+                }
>+            }
>+        }
>+        return this._functions;
>+    }
>+
>+    static _vectorParameterSizesForMaximumSize(maxSize)
>+    {
>+        let variants = [ [ maxSize ] ];
>+        for (let splitPoint = 1; splitPoint < maxSize; splitPoint++) {
>+            for (let v of BuiltinVectorCasts._vectorParameterSizesForMaximumSize(maxSize - splitPoint))
>+                variants.push([ splitPoint ].concat(v));
>+        }
>+        return variants;
>+    }
>+
>+    instantiateImplementation(func)
>+    {
>+        func.implementation = (args) => {
>+            const result = new EPtr(new EBuffer(this.outputSize), 0);
>+            let offset = 0;
>+            for (let i = 0; i < args.length; i++) {
>+                for (let j = 0; j < this.parameterSizes[i]; j++)
>+                    result.set(offset++, args[i].get(j));
>+            }
>+            return result;
>+        };
>+        func.implementationData = this;
>+    }
>+}
>\ No newline at end of file
>diff --git a/Tools/WebGPUShadingLanguageRI/BuiltinVectorEqualityOperator.js b/Tools/WebGPUShadingLanguageRI/BuiltinVectorEqualityOperator.js
>new file mode 100644
>index 0000000000000000000000000000000000000000..9123bbdad6f077b34c6191bc3e25cac71cf042be
>--- /dev/null
>+++ b/Tools/WebGPUShadingLanguageRI/BuiltinVectorEqualityOperator.js
>@@ -0,0 +1,66 @@
>+/*
>+ * Copyright (C) 2017 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. ``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
>+ * 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. 
>+ */
>+"use strict";
>+
>+class BuiltinVectorEqualityOperator {
>+    constructor(baseTypeName, size)
>+    {
>+        this._baseTypeName = baseTypeName;
>+        this._size = size;
>+    }
>+
>+    get baseTypeName() { return this._baseTypeName; }
>+    get size() { return this._size; }
>+
>+    toString()
>+    {
>+        return `native bool operator==(${this.baseTypeName}${this.size},${this.baseTypeName}${this.size})`;
>+    }
>+
>+    static functions()
>+    {
>+        if (!this._functions) {
>+            this._functions = [];
>+
>+            for (let typeName of VectorElementTypes) {
>+                for (let size of VectorElementSizes)
>+                    this._functions.push(new BuiltinVectorEqualityOperator(typeName, size));
>+            }
>+        }
>+        return this._functions;
>+    }
>+
>+    instantiateImplementation(func)
>+    {
>+        func.implementation = ([ref1, ref2], node) => {
>+            for (let i = 0; i < this.size; i++) {
>+                if (ref1.get(i) != ref2.get(i))
>+                    return EPtr.box(false);
>+            }
>+            return EPtr.box(true);
>+        };
>+        func.implementationData = this;
>+    }
>+}
>\ No newline at end of file
>diff --git a/Tools/WebGPUShadingLanguageRI/BuiltinVectorGetter.js b/Tools/WebGPUShadingLanguageRI/BuiltinVectorGetter.js
>new file mode 100644
>index 0000000000000000000000000000000000000000..88a9157a4edce476c934a5a05c771c3564c35609
>--- /dev/null
>+++ b/Tools/WebGPUShadingLanguageRI/BuiltinVectorGetter.js
>@@ -0,0 +1,70 @@
>+/*
>+ * Copyright (C) 2017 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. ``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
>+ * 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. 
>+ */
>+"use strict";
>+
>+class BuiltinVectorGetter {
>+    constructor(baseTypeName, size, elementName, index)
>+    {
>+        this._baseTypeName = baseTypeName;
>+        this._size = size;
>+        this._elementName = elementName;
>+        this._index = index;
>+    }
>+
>+    get baseTypeName() { return this._baseTypeName; }
>+    get size() { return this._size; }
>+    get elementName() { return this._elementName; }
>+    get index() { return this._index; }
>+
>+    toString()
>+    {
>+        return `native ${this.baseTypeName} operator.${this.elementName}(${this.baseTypeName}${this.size})`;
>+    }
>+
>+    static functions()
>+    {
>+        if (!this._functions) {
>+            this._functions = [];
>+        
>+            const elements = [ "x", "y", "z", "w" ];
>+
>+            for (let typeName of VectorElementTypes) {
>+                for (let size of VectorElementSizes) {
>+                    for (let i = 0; i < size; i++)
>+                        this._functions.push(new BuiltinVectorGetter(typeName, size, elements[i], i));
>+                }
>+            }
>+        }
>+        return this._functions;
>+    }
>+
>+    instantiateImplementation(func)
>+    {
>+        func.implementation = ([vec], node) => {
>+            return EPtr.box(vec.get(this.index));
>+        };
>+        func.implementationData = this;
>+    }
>+}
>\ No newline at end of file
>diff --git a/Tools/WebGPUShadingLanguageRI/BuiltinVectorIndexGetter.js b/Tools/WebGPUShadingLanguageRI/BuiltinVectorIndexGetter.js
>new file mode 100644
>index 0000000000000000000000000000000000000000..8ba53a1fbc379763d9b07a623fbe080560f94a02
>--- /dev/null
>+++ b/Tools/WebGPUShadingLanguageRI/BuiltinVectorIndexGetter.js
>@@ -0,0 +1,66 @@
>+/*
>+ * Copyright (C) 2017 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. ``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
>+ * 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. 
>+ */
>+"use strict";
>+
>+class BuiltinVectorIndexGetter {
>+    constructor(baseTypeName, size)
>+    {
>+        this._baseTypeName = baseTypeName;
>+        this._size = size;
>+    }
>+
>+    get baseTypeName() { return this._baseTypeName; }
>+    get size() { return this._size; }
>+
>+    toString()
>+    {
>+        return `native ${this.baseTypeName} operator[](${this.baseTypeName}${this.size},uint)`;
>+    }
>+
>+    static functions()
>+    {
>+        if (!this._allIndexGetters) {
>+            this._allIndexGetters = [];
>+
>+            for (let typeName of VectorElementTypes) {
>+                for (let size of VectorElementSizes)
>+                    this._allIndexGetters.push(new BuiltinVectorIndexGetter(typeName, size));
>+            }
>+        }
>+        return this._allIndexGetters;
>+    }
>+
>+    instantiateImplementation(func)
>+    {
>+        func.implementation = ([vec, index], node) => {
>+            const indexValue = index.loadValue();
>+            if (indexValue >= 0 && indexValue < this.size)
>+                return EPtr.box(vec.get(index.loadValue()));
>+            else
>+                throw new Error(`${indexValue} out of bounds for vector of size ${this.size}`);
>+        };
>+        func.implementationData = this;
>+    }
>+}
>\ No newline at end of file
>diff --git a/Tools/WebGPUShadingLanguageRI/BuiltinVectorIndexSetter.js b/Tools/WebGPUShadingLanguageRI/BuiltinVectorIndexSetter.js
>new file mode 100644
>index 0000000000000000000000000000000000000000..6e79d2534808aed7b39580d65f7e0298a085ff30
>--- /dev/null
>+++ b/Tools/WebGPUShadingLanguageRI/BuiltinVectorIndexSetter.js
>@@ -0,0 +1,71 @@
>+/*
>+ * Copyright (C) 2017 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. ``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
>+ * 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. 
>+ */
>+"use strict";
>+
>+class BuiltinVectorIndexSetter {
>+    constructor(baseTypeName, size)
>+    {
>+        this._baseTypeName = baseTypeName;
>+        this._size = size;
>+    }
>+
>+    get baseTypeName() { return this._baseTypeName; }
>+    get size() { return this._size; }
>+    get elementName() { return this._elementName; }
>+    get index() { return this._index; }
>+
>+    toString()
>+    {
>+        return `native ${this.baseTypeName}${this.size} operator[]=(${this.baseTypeName}${this.size},uint32,${this.baseTypeName})`;
>+    }
>+
>+    static functions()
>+    {
>+        if (!this._functions) {
>+            this._functions = [];
>+
>+            for (let typeName of VectorElementTypes) {
>+                for (let size of VectorElementSizes)
>+                    this._functions.push(new BuiltinVectorIndexSetter(typeName, size));
>+            }
>+        }
>+        return this._functions;
>+    }
>+
>+    instantiateImplementation(func)
>+    {
>+        func.implementation = ([base, index, value], node) => {
>+            const indexValue = index.loadValue();
>+            if (indexValue >= 0 && indexValue < this.size) {
>+                let result = new EPtr(new EBuffer(this.size), 0);
>+                result.copyFrom(base, this.size);
>+                result.plus(indexValue).copyFrom(value, 1);
>+                return result;
>+            } else
>+                throw new Error(`${indexValue} out of bounds for vector of size ${this.size}`);
>+        };
>+        func.implementationData = this;
>+    }
>+}
>\ No newline at end of file
>diff --git a/Tools/WebGPUShadingLanguageRI/BuiltinVectorSetter.js b/Tools/WebGPUShadingLanguageRI/BuiltinVectorSetter.js
>new file mode 100644
>index 0000000000000000000000000000000000000000..fd290c35476e957aad718058b620c3f3fa17fa52
>--- /dev/null
>+++ b/Tools/WebGPUShadingLanguageRI/BuiltinVectorSetter.js
>@@ -0,0 +1,73 @@
>+/*
>+ * Copyright (C) 2017 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. ``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
>+ * 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. 
>+ */
>+"use strict";
>+
>+class BuiltinVectorSetter {
>+    constructor(baseTypeName, size, elementName, index)
>+    {
>+        this._baseTypeName = baseTypeName;
>+        this._size = size;
>+        this._elementName = elementName;
>+        this._index = index;
>+    }
>+
>+    get baseTypeName() { return this._baseTypeName; }
>+    get size() { return this._size; }
>+    get elementName() { return this._elementName; }
>+    get index() { return this._index; }
>+
>+    toString()
>+    {
>+        return `native ${this.baseTypeName}${this.size} operator.${this.elementName}=(${this.baseTypeName}${this.size},${this.baseTypeName})`;
>+    }
>+
>+    static functions()
>+    {
>+        if (!this._functions) {
>+            this._functions = [];
>+        
>+            const elements = [ "x", "y", "z", "w" ];
>+
>+            for (let typeName of VectorElementTypes) {
>+                for (let size of VectorElementSizes) {
>+                    for (let i = 0; i < size; i++)
>+                        this._functions.push(new BuiltinVectorSetter(typeName, size, elements[i], i));
>+                }
>+            }
>+        }
>+        return this._functions;
>+    }
>+
>+    instantiateImplementation(func)
>+    {
>+        func.implementation = ([base, value], node) => {
>+            let result = new EPtr(new EBuffer(this.size), 0);
>+            result.copyFrom(base, this.size);
>+            result.plus(this.index).copyFrom(value, 1);
>+            return result;
>+        };
>+        func.implementationData = this;
>+    }
>+}
>\ No newline at end of file
>diff --git a/Tools/WebGPUShadingLanguageRI/CallExpression.js b/Tools/WebGPUShadingLanguageRI/CallExpression.js
>index b5ae0fe49fcedc8fa76a66793cfe0cb1f08b4571..9c7fcdc0195d3ec8b11c781c291703f2571b808a 100644
>--- a/Tools/WebGPUShadingLanguageRI/CallExpression.js
>+++ b/Tools/WebGPUShadingLanguageRI/CallExpression.js
>@@ -25,11 +25,10 @@
> "use strict";
> 
> class CallExpression extends Expression {
>-    constructor(origin, name, typeArguments, argumentList)
>+    constructor(origin, name, argumentList)
>     {
>         super(origin);
>         this._name = name;
>-        this._typeArguments = typeArguments;
>         this._argumentList = argumentList;
>         this.func = null;
>         this._isCast = false;
>@@ -37,85 +36,125 @@ class CallExpression extends Expression {
>     }
>     
>     get name() { return this._name; }
>-    get typeArguments() { return this._typeArguments; }
>     get argumentList() { return this._argumentList; }
>     get isCast() { return this._isCast; }
>     get returnType() { return this._returnType; }
>     
>-    static resolve(origin, possibleOverloads, typeParametersInScope, name, typeArguments, argumentList, argumentTypes, returnType)
>+    static resolve(origin, possibleOverloads, name, argumentList, argumentTypes, returnType, program)
>     {
>-        let call = new CallExpression(origin, name, typeArguments, argumentList);
>+        let call = new CallExpression(origin, name, [], argumentList);
>         call.argumentTypes = argumentTypes.map(argument => argument.visit(new AutoWrapper()));
>         call.possibleOverloads = possibleOverloads;
>         if (returnType)
>             call.setCastData(returnType);
>-        return {call, resultType: call.resolve(possibleOverloads, typeParametersInScope, typeArguments)};
>+        return {call, resultType: call.resolve(possibleOverloads, program)};
>     }
>-    
>-    resolve(possibleOverloads, typeParametersInScope, typeArguments)
>+
>+    resolve(possibleOverloads, program)
>     {
>         if (!possibleOverloads)
>             throw new WTypeError(this.origin.originString, "Did not find any functions named " + this.name);
>-        
>-        let overload = null;
>+
>         let failures = [];
>-        for (let typeParameter of typeParametersInScope) {
>-            if (!(typeParameter instanceof TypeVariable))
>-                continue;
>-            if (!typeParameter.protocol)
>-                continue;
>-            let signatures =
>-                typeParameter.protocol.protocolDecl.signaturesByNameWithTypeVariable(this.name, typeParameter);
>-            if (!signatures)
>-                continue;
>-            overload = resolveOverloadImpl(signatures, this.typeArguments, this.argumentTypes, this.returnType);
>-            if (overload.func)
>-                break;
>-            failures.push(...overload.failures);
>-            overload = null;
>-        }
>-        if (!overload) {
>-            overload = resolveOverloadImpl(
>-                possibleOverloads, this.typeArguments, this.argumentTypes, this.returnType);
>-            if (!overload.func) {
>-                failures.push(...overload.failures);
>-                let message = "Did not find function named " + this.name + " for call with ";
>-                if (this.typeArguments.length)
>-                    message += "type arguments <" + this.typeArguments + "> and ";
>-                message += "argument types (" + this.argumentTypes + ")";
>-                if (this.returnType)
>-                    message +=" and return type " + this.returnType;
>-                if (failures.length)
>-                    message += ", but considered:\n" + failures.join("\n")
>-                throw new WTypeError(this.origin.originString, message);
>-            }
>+        let overload = resolveOverloadImpl(possibleOverloads, this.argumentTypes, this.returnType);
>+
>+        if (!overload.func) {
>+            const func = this._resolveByInstantiation(program);
>+            if (func)
>+                overload.func = func;
>         }
>-        for (let i = 0; i < typeArguments.length; ++i) {
>-            let typeArgumentType = typeArguments[i];
>-            let typeParameter = overload.func.typeParameters[i];
>-            if (!(typeParameter instanceof ConstexprTypeParameter))
>-                continue;
>-            if (!typeParameter.type.equalsWithCommit(typeArgumentType))
>-                throw new Error("At " + this.origin.originString + " constexpr type argument and parameter types not equal: argument = " + typeArgumentType + ", parameter = " + typeParameter.type);
>+
>+
>+        if (!overload.func) {
>+            failures.push(...overload.failures);
>+            let message = "Did not find function named " + this.name + " for call with ";
>+            message += "argument types (" + this.argumentTypes + ")";
>+            if (this.returnType)
>+                message +=" and return type " + this.returnType;
>+            if (failures.length)
>+                message += ", but considered:\n" + failures.join("\n")
>+            throw new WTypeError(this.origin.originString, message);
>         }
>+
>         for (let i = 0; i < this.argumentTypes.length; ++i) {
>             let argumentType = this.argumentTypes[i];
>-            let parameterType = overload.func.parameters[i].type.substituteToUnification(
>-                overload.func.typeParameters, overload.unificationContext);
>+            let parameterType = overload.func.parameters[i].type;
>             let result = argumentType.equalsWithCommit(parameterType);
>             if (!result)
>                 throw new Error("At " + this.origin.originString + " argument and parameter types not equal after type argument substitution: argument = " + argumentType + ", parameter = " + parameterType);
>         }
>         return this.resolveToOverload(overload);
>     }
>+
>+    _resolveByInstantiation(program)
>+    {
>+        let func;
>+        if (this.name == "operator&[]")
>+            func = this._resolveToOperatorAnderIndexer(program);
>+        else if (this.name == "operator.length")
>+            func = this._resolveToOperatorLength(program);
>+        else
>+            return null;
>+
>+        program.add(func);
>+        return func;
>+    }
>+
>+    _resolveToOperatorAnderIndexer(program)
>+    {
>+        let arrayRefType = this.argumentTypes[0];
>+        if (!arrayRefType.isArrayRef)
>+            throw new WTypeError(this.origin.originString, `Expected ${arrayRefType} to be an array ref type for operator&[]`);
>+
>+        let indexType = this.argumentTypes[1];
>+        const addressSpace = arrayRefType.addressSpace;
>+
>+        // The later checkLiteralTypes stage will verify that the literal can be represented as a uint.
>+        const uintType = TypeRef.wrap(program.types.get("uint32"));
>+        indexType.type = uintType;
>+
>+        const elementType = this.argumentTypes[0].elementType;
>+        this.resultType = this._returnType = TypeRef.wrap(new PtrType(this.origin, addressSpace, TypeRef.wrap(elementType)))
>+
>+        let arrayRefAccessor = new OperatorAnderIndexer(this.returnType.toString(), addressSpace);
>+        const func = new NativeFunc(this.origin, "operator&[]", this.resultType, [
>+            new FuncParameter(this.origin, null, arrayRefType),
>+            new FuncParameter(this.origin, null, uintType)
>+        ], false, null);
>+
>+        arrayRefAccessor.instantiateImplementation(func);
>+
>+        return func;
>+    }
>+
>+    _resolveToOperatorLength(program)
>+    {
>+        this.resultType = this._returnType = TypeRef.wrap(program.types.get("uint32"));
>+
>+        if (this.argumentTypes[0].isArray) {
>+            const arrayType = this.argumentTypes[0];
>+            const func = new NativeFunc(this.origin, "operator.length", this.resultType, [
>+                new FuncParameter(this.origin, null, arrayType)
>+            ], false, null);
>+            func.implementation = (args, node) => EPtr.box(arrayType.numElementsValue);
>+            return func;
>+        } else if (this.argumentTypes[0].isArrayRef) {
>+            const arrayRefType = this.argumentTypes[0];
>+            const addressSpace = arrayRefType.addressSpace;
>+            const operatorLength = new OperatorArrayRefLength(arrayRefType.toString(), addressSpace);
>+            const func = new NativeFunc(this.origin, "operator.length", this.resultType, [
>+                new FuncParameter(this.origin, null, arrayRefType)
>+            ], false, null);
>+            operatorLength.instantiateImplementation(func);
>+            return func;
>+        } else
>+            throw new WTypeError(this.origin.originString, `Expected ${this.argumentTypes[0]} to be array/array ref type for operator.length`);
>+    }
>     
>     resolveToOverload(overload)
>     {
>         this.func = overload.func;
>-        this.actualTypeArguments = overload.typeArguments.map(typeArgument => typeArgument instanceof Type ? typeArgument.visit(new AutoWrapper()) : typeArgument);
>-        this.instantiatedActualTypeArguments = this.actualTypeArguments;
>-        let result = overload.func.returnType.substituteToUnification(
>-            overload.func.typeParameters, overload.unificationContext);
>+        let result = overload.func.returnType;
>         if (!result)
>             throw new Error("Null return type");
>         result = result.visit(new AutoWrapper());
>@@ -125,11 +164,10 @@ class CallExpression extends Expression {
>     
>     becomeCast(returnType)
>     {
>-        this._returnType = new TypeRef(this.origin, this.name, this._typeArguments);
>+        this._returnType = new TypeRef(this.origin, this.name, []);
>         this._returnType.type = returnType;
>         this._name = "operator cast";
>         this._isCast = true;
>-        this._typeArguments = [];
>     }
>     
>     setCastData(returnType)
>@@ -141,8 +179,6 @@ class CallExpression extends Expression {
>     toString()
>     {
>         return (this.isCast ? "operator " + this.returnType : this.name) +
>-            "<" + this.typeArguments + ">" +
>-            (this.actualTypeArguments ? "<<" + this.actualTypeArguments + ">>" : "") +
>             "(" + this.argumentList + ")";
>     }
> }
>diff --git a/Tools/WebGPUShadingLanguageRI/CallExpressionTypeArgumentResolver.js b/Tools/WebGPUShadingLanguageRI/CallExpressionTypeArgumentResolver.js
>new file mode 100644
>index 0000000000000000000000000000000000000000..b9a2e9688cb74e60bde473d03ef206b6272d14cd
>--- /dev/null
>+++ b/Tools/WebGPUShadingLanguageRI/CallExpressionTypeArgumentResolver.js
>@@ -0,0 +1,47 @@
>+/*
>+ * Copyright (C) 2018 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. ``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
>+ * 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.
>+ */
>+"use strict";
>+
>+class CallExpressionTypeArgumentResolver extends Visitor {
>+
>+    constructor(program)
>+    {
>+        super();
>+        this._nameResolver = new NameResolver(program.globalNameContext);
>+    }
>+
>+    visitCallExpression(node)
>+    {
>+        // Call expressions with type arguments are only ever operator casts.
>+        // At the point that this stage is executed the call expressions are of the form vector<int, 2>.
>+        // This replaces them with vector<T, N> operator cast(...).
>+        if (node.typeArguments.length) {
>+            node._returnType = new TypeRef(node.origin, node.name, node.typeArguments);
>+            node._name = "operator cast";
>+            node._typeArguments = [];
>+        }
>+    }
>+
>+}
>\ No newline at end of file
>diff --git a/Tools/WebGPUShadingLanguageRI/CallFunction.js b/Tools/WebGPUShadingLanguageRI/CallFunction.js
>index f0f039f5462d0781d82b3464c87478714c0a1737..7495760f2c5d81d839456cde4c459770bcc330fc 100644
>--- a/Tools/WebGPUShadingLanguageRI/CallFunction.js
>+++ b/Tools/WebGPUShadingLanguageRI/CallFunction.js
>@@ -25,17 +25,17 @@
> "use strict";
> 
> // This allows you to pass structs and arrays in-place, but it's a more annoying API.
>-function callFunction(program, name, typeArguments, argumentList)
>+function callFunction(program, name, argumentList)
> {
>     let argumentTypes = argumentList.map(argument => argument.type);
>-    let funcOrFailures = resolveInlinedFunction(program, name, typeArguments, argumentTypes, true);
>+    let funcOrFailures = resolveInlinedFunction(program, name, argumentTypes, true);
>     if (!(funcOrFailures instanceof Func)) {
>         let failures = funcOrFailures;
>-        throw new WTypeError("<callFunction>", "Cannot resolve function call " + name + "<" + typeArguments + ">(" + argumentList + ")" + (failures.length ? "; tried:\n" + failures.join("\n") : ""));
>+        throw new WTypeError("<callFunction>", "Cannot resolve function call " + name + "(" + argumentList + ")" + (failures.length ? "; tried:\n" + failures.join("\n") : ""));
>     }
>     let func = funcOrFailures;
>     for (let i = 0; i < func.parameters.length; ++i) {
>-        let type = argumentTypes[i].instantiatedType;
>+        let type = argumentTypes[i];
>         type.visit(new StructLayoutBuilder());
>         func.parameters[i].ePtr.copyFrom(argumentList[i].ePtr, type.size);
>     }
>diff --git a/Tools/WebGPUShadingLanguageRI/Checker.js b/Tools/WebGPUShadingLanguageRI/Checker.js
>index 8d55c50d836c15486fd2580c58e9606cad596ecb..1195fd17433d27ecbf2f18857a9bf39021a7d8bf 100644
>--- a/Tools/WebGPUShadingLanguageRI/Checker.js
>+++ b/Tools/WebGPUShadingLanguageRI/Checker.js
>@@ -43,8 +43,6 @@ class Checker extends Visitor {
>         
>         for (let type of node.types.values())
>             doStatement(type);
>-        for (let protocol of node.protocols.values())
>-            doStatement(protocol);
>         for (let funcs of node.functions.values()) {
>             for (let func of funcs) {
>                 this.visitFunc(func);
>@@ -59,8 +57,6 @@ class Checker extends Visitor {
>     _checkShaderType(node)
>     {
>         // FIXME: Relax these checks once we have implemented support for textures and samplers.
>-        if (node.typeParameters.length != 0)
>-            throw new WTypeError(node.origin.originString, "Entry point " + node.name + " must not have type arguments.");
>         let shaderFunc = node;
>         switch (node.shaderType) {
>         case "vertex":
>@@ -84,15 +80,6 @@ class Checker extends Visitor {
>         if (!func.name.startsWith("operator"))
>             throw new Error("Bad operator overload name: " + func.name);
>         
>-        let typeVariableTracker = new TypeVariableTracker();
>-        for (let parameterType of func.parameterTypes)
>-            parameterType.visit(typeVariableTracker);
>-        Node.visit(func.returnTypeForOverloadResolution, typeVariableTracker);
>-        for (let typeParameter of func.typeParameters) {
>-            if (!typeVariableTracker.set.has(typeParameter))
>-                throw new WTypeError(typeParameter.origin.originString, "Type parameter " + typeParameter + " to operator " + func.toDeclString() + " is not inferrable from value parameters");
>-        }
>-        
>         let checkGetter = (kind) => {
>             let numExpectedParameters = kind == "index" ? 2 : 1;
>             if (func.parameters.length != numExpectedParameters)
>@@ -115,11 +102,10 @@ class Checker extends Visitor {
>             if (!getterFuncs)
>                 throw new WTypeError(func.origin.originString, "Every setter must have a matching getter, but did not find any function named " + getterName + " to match " + func.name);
>             let argumentTypes = func.parameterTypes.slice(0, numExpectedParameters - 1);
>-            let overload = resolveOverloadImpl(getterFuncs, [], argumentTypes, null);
>+            let overload = resolveOverloadImpl(getterFuncs, argumentTypes, null);
>             if (!overload.func)
>                 throw new WTypeError(func.origin.originString, "Did not find function named " + func.name + " with arguments " + argumentTypes + (overload.failures.length ? "; tried:\n" + overload.failures.join("\n") : ""));
>-            let resultType = overload.func.returnType.substituteToUnification(
>-                overload.func.typeParameters, overload.unificationContext);
>+            let resultType = overload.func.returnType;
>             if (!resultType.equals(valueType))
>                 throw new WTypeError(func.origin.originString, "Setter and getter must agree on value type (getter at " + overload.func.origin.originString + " says " + resultType + " while this setter says " + valueType + ")");
>         };
>@@ -211,23 +197,6 @@ class Checker extends Visitor {
>     {
>     }
>     
>-    visitProtocolDecl(node)
>-    {
>-        for (let signature of node.signatures) {
>-            let typeVariableTracker = new TypeVariableTracker();
>-            for (let parameterType of signature.parameterTypes)
>-                parameterType.visit(typeVariableTracker);
>-            Node.visit(signature.returnTypeForOverloadResolution, typeVariableTracker);
>-            for (let typeParameter of signature.typeParameters) {
>-                if (!typeVariableTracker.set.has(typeParameter))
>-                    throw WTypeError(typeParameter.origin.originString, "Type parameter to protocol signature not inferrable from value parameters");
>-            }
>-            if (!typeVariableTracker.set.has(node.typeVariable))
>-                throw new WTypeError(signature.origin.originString, "Protocol's type variable (" + node.name + ") not mentioned in signature: " + signature);
>-            this._checkOperatorOverload(signature, name => node.signaturesByName(name));
>-        }
>-    }
>-    
>     visitEnumType(node)
>     {
>         node.baseType.visit(this);
>@@ -278,29 +247,41 @@ class Checker extends Visitor {
>             throw new WTypeError(node.origin.originString, "Enum does not have a member with the value zero");
>     }
>     
>-    _checkTypeArguments(origin, typeParameters, typeArguments)
>-    {
>-        for (let i = 0; i < typeParameters.length; ++i) {
>-            let argumentIsType = typeArguments[i] instanceof Type;
>-            let result = typeArguments[i].visit(this);
>-            if (argumentIsType) {
>-                let result = typeArguments[i].inherits(typeParameters[i].protocol);
>-                if (!result.result)
>-                    throw new WTypeError(origin.originString, "Type argument does not inherit protocol: " + result.reason);
>-            } else {
>-                if (!result.equalsWithCommit(typeParameters[i].type))
>-                    throw new WTypeError(origin.originString, "Wrong type for constexpr");
>-            }
>-        }
>-    }
>-    
>     visitTypeRef(node)
>     {
>         if (!node.type)
>             throw new Error("Type reference without a type in checker: " + node + " at " + node.origin);
>         if (!(node.type instanceof StructType))
>             node.type.visit(this);
>-        this._checkTypeArguments(node.origin, node.type.typeParameters, node.typeArguments);
>+    }
>+
>+    visitNativeParameterizedType(node)
>+    {
>+        for (let i = 0; i < node.typeArguments.length; ++i) {
>+            let result = node.typeArguments[i].visit(this);
>+            if (!node.typeArguments[i] instanceof Type) {
>+                if (!result.equalsWithCommit(node.typeArguments[i].type))
>+                    throw new WTypeError(origin.originString, "Wrong type for constexpr");
>+            }
>+        }
>+    }
>+
>+    visitVectorType(node)
>+    {
>+        node.elementType.visit(this);
>+
>+        if (!(node.elementType.equals(this._program.intrinsics.int32)
>+                || node.elementType.equals(this._program.intrinsics.uint32)
>+                || node.elementType.equals(this._program.intrinsics.float)))
>+            throw new WTypeError(node.origin.originString, `Vector element type ${node.elementType} not permitted`);
>+
>+        if (!node.numElements.isConstexpr)
>+            throw new WTypeError(node.origin.originString, "Vector size must be constexpr");
>+
>+        let numElementsType = node.numElements.visit(this);
>+
>+        if (!numElementsType.equalsWithCommit(this._program.intrinsics.uint32))
>+            throw new WTypeError(node.origin.originString, "Vector size must be a uint32");
>     }
>     
>     visitArrayType(node)
>@@ -426,8 +407,8 @@ class Checker extends Visitor {
>         
>         try {
>             let result = CallExpression.resolve(
>-                node.origin, node.possibleGetOverloads, this._currentStatement.typeParameters,
>-                node.getFuncName, [], [node.base, ...extraArgs], [baseType, ...extraArgTypes], null);
>+                node.origin, node.possibleGetOverloads,
>+                node.getFuncName, [node.base, ...extraArgs], [baseType, ...extraArgTypes], null, this._program);
>             node.callForGet = result.call;
>             node.resultTypeForGet = result.resultType;
>         } catch (e) {
>@@ -440,9 +421,9 @@ class Checker extends Visitor {
>             let baseForAnd = baseType.argumentForAndOverload(node.origin, node.base);
>             
>             let result = CallExpression.resolve(
>-                node.origin, node.possibleAndOverloads, this._currentStatement.typeParameters,
>-                node.andFuncName, [], [baseForAnd, ...extraArgs], [typeForAnd, ...extraArgTypes],
>-                null);
>+                node.origin, node.possibleAndOverloads,
>+                node.andFuncName, [baseForAnd, ...extraArgs], [typeForAnd, ...extraArgTypes],
>+                null, this._program);
>             node.callForAnd = result.call;
>             node.resultTypeForAnd = result.resultType.unifyNode.returnTypeFromAndOverload(node.origin);
>         } catch (e) {
>@@ -466,8 +447,8 @@ class Checker extends Visitor {
>         
>         try {
>             let result = CallExpression.resolve(
>-                node.origin, node.possibleSetOverloads, this._currentStatement.typeParameters,
>-                node.setFuncName, [], [node.base, ...extraArgs, null], [baseType, ...extraArgTypes, node.resultType], null);
>+                node.origin, node.possibleSetOverloads,
>+                node.setFuncName, [node.base, ...extraArgs, null], [baseType, ...extraArgTypes, node.resultType], null, this._program);
>             node.callForSet = result.call;
>             if (!result.resultType.equals(baseType))
>                 throw new WTypeError(node.origin.originString, "Result type of setter " + result.call.func + " is not the base type " + baseType);
>@@ -672,10 +653,24 @@ class Checker extends Visitor {
>             result = expression.visit(this);
>         return result;
>     }
>+
>+    visitTernaryExpression(node)
>+    {
>+        this._requireBool(node.predicate);
>+        let bodyType = node.bodyExpression.visit(this);
>+        let elseType = node.elseExpression.visit(this);
>+        if (!bodyType)
>+            throw new Error("Ternary expression body has no type: " + node.bodyExpression);
>+        if (!elseType)
>+            throw new Error("Ternary expression else has no type: " + node.elseExpression);
>+        if (!bodyType.equalsWithCommit(elseType))
>+            throw new WTypeError("Body and else clause of ternary statement don't have the same type: " + node);
>+        node.isLValue = node.bodyExpression.isLValue && node.elseExpression.isLValue;
>+        return bodyType;
>+    }
>     
>     visitCallExpression(node)
>     {
>-        let typeArguments = node.typeArguments.map(typeArgument => typeArgument.visit(this));
>         let argumentTypes = node.argumentList.map(argument => {
>             let newArgument = argument.visit(this);
>             if (!newArgument)
>@@ -687,7 +682,7 @@ class Checker extends Visitor {
>         if (node.returnType)
>             node.returnType.visit(this);
> 
>-        let result = node.resolve(node.possibleOverloads, this._currentStatement.typeParameters, typeArguments);
>+        let result = node.resolve(node.possibleOverloads, this._program);
>         return result;
>     }
> }
>diff --git a/Tools/WebGPUShadingLanguageRI/ConstexprFolder.js b/Tools/WebGPUShadingLanguageRI/ConstexprFolder.js
>index 1e5ad6615b39243c06a0c45aef7634f637653750..d7c8f3ff8c6e32186a4d1da72ccd54147a5afc2d 100644
>--- a/Tools/WebGPUShadingLanguageRI/ConstexprFolder.js
>+++ b/Tools/WebGPUShadingLanguageRI/ConstexprFolder.js
>@@ -34,17 +34,12 @@ class ConstexprFolder extends Visitor {
>         super.visitCallExpression(node);
>         
>         if (node.name == "operator-"
>-            && !node.typeArguments.length
>             && node.argumentList.length == 1
>-            && node.argumentList[0].unifyNode.isConstexpr
>-            && node.argumentList[0].unifyNode.negConstexpr) {
>+            && node.argumentList[0].isConstexpr
>+            && node.argumentList[0].negConstexpr) {
>             node.become(node.argumentList[0].unifyNode.negConstexpr(node.origin));
>             return;
>         }
>     }
>-    
>-    visitTypeOrVariableRef(node)
>-    {
>-    }
> }
> 
>diff --git a/Tools/WebGPUShadingLanguageRI/ConstexprTypeParameter.js b/Tools/WebGPUShadingLanguageRI/ConstexprTypeParameter.js
>deleted file mode 100644
>index e3c1826ed55f3fe56f7e0ed2a03dfda028da5b39..0000000000000000000000000000000000000000
>--- a/Tools/WebGPUShadingLanguageRI/ConstexprTypeParameter.js
>+++ /dev/null
>@@ -1,74 +0,0 @@
>-/*
>- * Copyright (C) 2017 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. ``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
>- * 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. 
>- */
>-"use strict";
>-
>-class ConstexprTypeParameter extends Value {
>-    constructor(origin, name, type)
>-    {
>-        super();
>-        this._origin = origin;
>-        this._name = name;
>-        this._type = type;
>-    }
>-    
>-    get origin() { return this._origin; }
>-    get name() { return this._name; }
>-    get type() { return this._type; }
>-    get isConstexpr() { return true; }
>-    get isUnifiable() { return true; }
>-    get varIsLValue() { return false; }
>-    
>-    typeVariableUnify(unificationContext, other)
>-    {
>-        if (!(other instanceof Value))
>-            return false;
>-
>-        if (!this.type.unify(unificationContext, other.type))
>-            return false;
>-        
>-        return this._typeVariableUnifyImpl(unificationContext, other);
>-    }
>-    
>-    unifyImpl(unificationContext, other)
>-    {
>-        return this.typeVariableUnify(unificationContext, other);
>-    }
>-    
>-    verifyAsArgument(unificationContext)
>-    {
>-        return {result: true};
>-    }
>-    
>-    verifyAsParameter(unificationContext)
>-    {
>-        return {result: true};
>-    }
>-    
>-    toString()
>-    {
>-        return this.type + " " + this.name;
>-    }
>-}
>-
>diff --git a/Tools/WebGPUShadingLanguageRI/CreateLiteralType.js b/Tools/WebGPUShadingLanguageRI/CreateLiteralType.js
>index 12914da3137fd6b90feda7258627effffbd4e541..dbe2168f44178e1b6a1c9191a3f5f262ac4503b8 100644
>--- a/Tools/WebGPUShadingLanguageRI/CreateLiteralType.js
>+++ b/Tools/WebGPUShadingLanguageRI/CreateLiteralType.js
>@@ -32,7 +32,7 @@ function createLiteralType(config)
>             super();
>             this._origin = origin;
>             this._value = value;
>-            this.preferredType = new TypeRef(origin, config.preferredTypeName, []);
>+            this.preferredType = new TypeRef(origin, config.preferredTypeName);
>         }
>         
>         get origin() { return this._origin; }
>@@ -52,13 +52,15 @@ function createLiteralType(config)
>         
>         unifyImpl(unificationContext, other)
>         {
>+            if (!other.isNumber)
>+                return false;
>             return this.typeVariableUnify(unificationContext, other);
>         }
>         
>         prepareToVerify(unificationContext)
>         {
>             let realThis = unificationContext.find(this);
>-            if (realThis instanceof TypeVariable || realThis.isLiteral) {
>+            if (realThis.isLiteral) {
>                 return () => {
>                     if (realThis.unify(unificationContext, this.preferredType))
>                         return {result: true};
>@@ -76,7 +78,7 @@ function createLiteralType(config)
>         {
>             throw new Error("GenericLiteralType should never be used as a type parameter");
>         }
>-        
>+
>         conversionCost(unificationContext)
>         {
>             let realThis = unificationContext.find(this);
>diff --git a/Tools/WebGPUShadingLanguageRI/Evaluator.js b/Tools/WebGPUShadingLanguageRI/Evaluator.js
>index 58ced89b7e47770023c7d8e1e81928751262eb38..d0899736fa69ba5e44677b7b896ccaff5e73551b 100644
>--- a/Tools/WebGPUShadingLanguageRI/Evaluator.js
>+++ b/Tools/WebGPUShadingLanguageRI/Evaluator.js
>@@ -142,6 +142,14 @@ class Evaluator extends Visitor {
>         // This should almost snapshot, except that tail-returning a pointer is totally OK.
>         return result;
>     }
>+
>+    visitTernaryExpression(node)
>+    {
>+        if (node.predicate.visit(this).loadValue())
>+            return node.bodyExpression.visit(this);
>+        return node.elseExpression.visit(this);
>+        
>+    }
>     
>     visitVariableRef(node)
>     {
>diff --git a/Tools/WebGPUShadingLanguageRI/ExpressionFinder.js b/Tools/WebGPUShadingLanguageRI/ExpressionFinder.js
>index 30e6b031a6dd66597407f3f6b7fe713ed8fdcc4a..0294782c0e793aa379573f5288c6ee9e8f90069c 100644
>--- a/Tools/WebGPUShadingLanguageRI/ExpressionFinder.js
>+++ b/Tools/WebGPUShadingLanguageRI/ExpressionFinder.js
>@@ -35,8 +35,6 @@ class ExpressionFinder extends Visitor {
>     visitFunc(node)
>     {
>         this._callback(node.returnType);
>-        for (let typeParameter of node.typeParameters)
>-            typeParameter.visit(this);
>         for (let parameter of node.parameters)
>             parameter.visit(this);
>     }
>@@ -46,11 +44,6 @@ class ExpressionFinder extends Visitor {
>         this._callback(node.type);
>     }
>     
>-    visitConstexprTypeParameter(node)
>-    {
>-        this._callback(node.type);
>-    }
>-    
>     visitAssignment(node)
>     {
>         this._callback(node);
>diff --git a/Tools/WebGPUShadingLanguageRI/FlattenProtocolExtends.js b/Tools/WebGPUShadingLanguageRI/FlattenProtocolExtends.js
>deleted file mode 100644
>index 76172d98d1e2c008edb5d8183f5eefd678dc8ee9..0000000000000000000000000000000000000000
>--- a/Tools/WebGPUShadingLanguageRI/FlattenProtocolExtends.js
>+++ /dev/null
>@@ -1,53 +0,0 @@
>-/*
>- * Copyright (C) 2017 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. ``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
>- * 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. 
>- */
>-"use strict";
>-
>-function flattenProtocolExtends(program)
>-{
>-    let visiting = new VisitingSet();
>-    
>-    function flatten(protocol)
>-    {
>-        if (!protocol.extends.length)
>-            return;
>-        
>-        visiting.doVisit(protocol, () => {
>-            for (let parent of protocol.extends) {
>-                parent = parent.protocolDecl;
>-                flatten(parent);
>-                for (let signature of parent.signatures) {
>-                    let newSignature = signature.visit(
>-                        new Substitution([parent.typeVariable], [protocol.typeVariable]));
>-                    protocol.add(newSignature);
>-                }
>-            }
>-            protocol.extends = [];
>-        });
>-    }
>-    
>-    for (let protocol of program.protocols.values())
>-        flatten(protocol);
>-}
>-
>diff --git a/Tools/WebGPUShadingLanguageRI/FlattenedStructOffsetGatherer.js b/Tools/WebGPUShadingLanguageRI/FlattenedStructOffsetGatherer.js
>index 01015ce85804270125dd4789547d30731159101d..2f7a43d1fd1ced7a3bfdb3a29205a0bcf0f5aad3 100644
>--- a/Tools/WebGPUShadingLanguageRI/FlattenedStructOffsetGatherer.js
>+++ b/Tools/WebGPUShadingLanguageRI/FlattenedStructOffsetGatherer.js
>@@ -62,5 +62,17 @@ class FlattenedStructOffsetGatherer extends Visitor {
>         super.visitTypeRef(node);
>         Node.visit(node.type, this);
>     }
>+
>+    visitVectorType(node)
>+    {
>+        const fieldNames = [ "x", "y", "z", "w" ];
>+        for (let i = 0; i < node.numElementsValue; i++) {
>+            this._result.push({
>+                name: this._name.join(".") + "." + fieldNames[i],
>+                offset: this._offset + i,
>+                type: node.elementType.name
>+            });
>+        }
>+    }
> }
> 
>diff --git a/Tools/WebGPUShadingLanguageRI/FloatLiteral.js b/Tools/WebGPUShadingLanguageRI/FloatLiteral.js
>index e6c5737de16a4a648d85adca1693454b6140727e..d5d1b15230f09c10a0bc125f03cf5ad4ce3dd2f7 100644
>--- a/Tools/WebGPUShadingLanguageRI/FloatLiteral.js
>+++ b/Tools/WebGPUShadingLanguageRI/FloatLiteral.js
>@@ -30,7 +30,7 @@ let FloatLiteral = createLiteral({
>     
>     negConstexpr(origin)
>     {
>-        return new IntLiteral(origin, -this.value);
>+        return new FloatLiteral(origin, -this.value);
>     },
>     
>     createType(origin, value)
>diff --git a/Tools/WebGPUShadingLanguageRI/Func.js b/Tools/WebGPUShadingLanguageRI/Func.js
>index 6fa7c9d1b6f4b958335981c2728be865a56e73ae..c15330b9235d560d2d64ab54c950c8515c3011ff 100644
>--- a/Tools/WebGPUShadingLanguageRI/Func.js
>+++ b/Tools/WebGPUShadingLanguageRI/Func.js
>@@ -25,7 +25,7 @@
> "use strict";
> 
> class Func extends Node {
>-    constructor(origin, name, returnType, typeParameters, parameters, isCast, shaderType)
>+    constructor(origin, name, returnType, parameters, isCast, shaderType)
>     {
>         if (!(origin instanceof LexerToken))
>             throw new Error("Bad origin: " + origin);
>@@ -39,7 +39,6 @@ class Func extends Node {
>         this._origin = origin;
>         this._name = name;
>         this._returnType = returnType;
>-        this._typeParameters = typeParameters;
>         this._parameters = parameters;
>         this._isCast = isCast;
>         this._shaderType = shaderType;
>@@ -48,8 +47,6 @@ class Func extends Node {
>     get origin() { return this._origin; }
>     get name() { return this._name; }
>     get returnType() { return this._returnType; }
>-    get typeParameters() { return this._typeParameters; }
>-    get typeParametersForCallResolution() { return this.typeParameters; }
>     get parameters() { return this._parameters; }
>     get parameterTypes() { return this.parameters.map(parameter => parameter.type); }
>     get isCast() { return this._isCast; }
>@@ -65,9 +62,9 @@ class Func extends Node {
>         if (this.shaderType)
>             result += this.shaderType + " ";
>         if (this.isCast)
>-            result += "operator<" + this.typeParameters + "> " + this.returnType;
>+            result += `operator ${this.returnType}`;
>         else
>-            result += this.returnType + " " + this.name + "<" + this.typeParameters + ">";
>+            result += `${this.returnType} ${this.name}`;
>         return result + "(" + this.parameters + ")";
>     }
>     
>diff --git a/Tools/WebGPUShadingLanguageRI/FuncDef.js b/Tools/WebGPUShadingLanguageRI/FuncDef.js
>index 11fa092e3b2278e215a0a67e951e17daba136a83..ca0597fcd294dfab6044214e0754f7ef944b878e 100644
>--- a/Tools/WebGPUShadingLanguageRI/FuncDef.js
>+++ b/Tools/WebGPUShadingLanguageRI/FuncDef.js
>@@ -25,9 +25,9 @@
> "use strict";
> 
> class FuncDef extends Func {
>-    constructor(origin, name, returnType, typeParameters, parameters, body, isCast, shaderType)
>+    constructor(origin, name, returnType, parameters, body, isCast, shaderType)
>     {
>-        super(origin, name, returnType, typeParameters, parameters, isCast, shaderType);
>+        super(origin, name, returnType, parameters, isCast, shaderType);
>         this._body = body;
>         this.isRestricted = false;
>     }
>@@ -36,8 +36,6 @@ class FuncDef extends Func {
>     
>     rewrite(rewriter)
>     {
>-        if (this._typeParameters.length)
>-            throw new Error("Cannot rewrite an uninstantiated function");
>         this._returnType = this._returnType.visit(rewriter);
>         this._parameters = this._parameters.map(parameter => parameter.visit(rewriter));
>         this._body = this.body.visit(rewriter);
>diff --git a/Tools/WebGPUShadingLanguageRI/FuncInstantiator.js b/Tools/WebGPUShadingLanguageRI/FuncInstantiator.js
>index 892862a6dd8565ee37e420631d7af70d5227e586..9844d90c197921cee7b62b5919f46d7e65c74b96 100644
>--- a/Tools/WebGPUShadingLanguageRI/FuncInstantiator.js
>+++ b/Tools/WebGPUShadingLanguageRI/FuncInstantiator.js
>@@ -20,7 +20,7 @@
>  * 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. 
>+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
>  */
> "use strict";
> 
>@@ -30,73 +30,36 @@ class FuncInstantiator {
>         this._program = program;
>         this._instances = new Map();
>     }
>-    
>+
>     get instances() { return this._instances; }
>-    
>+
>     // Returns a Func object that uniquely identifies a particular system of type arguments. You must
>     // intantiate things with concrete types, because this code casually assumes this. Note that this
>     // will return a different func from `func` no matter what. This ensures that we can use the
>     // returned func for rewrites that instantiate types without destroying our ability to do overload
>     // resolutions on the original Program.
>-    getUnique(func, typeArguments)
>+    getUnique(func)
>     {
>-        class FindTypeVariable extends Visitor {
>-            visitTypeRef(node)
>-            {
>-                for (let typeArgument of node.typeArguments)
>-                    typeArgument.visit(this);
>-            }
>-            
>-            visitTypeVariable(node) {
>-                throw new Error("Unexpected type variable: " + node + " when instantiating " + func + " with arguments " + typeArguments);
>-            }
>-        }
>-        for (let typeArgument of typeArguments)
>-            typeArgument.visit(new FindTypeVariable());
>-        
>         let instances = this._instances.get(func);
>         if (!instances)
>             this._instances.set(func, instances = []);
>-        
>-        for (let instance of instances) {
>-            let ok = true;
>-            for (let i = instance.typeArguments.length; i--;) {
>-                if (!instance.typeArguments[i].equals(typeArguments[i])) {
>-                    ok = false;
>-                    break;
>-                }
>-            }
>-            if (!ok)
>-                continue;
>-            return instance.func;
>-        }
>-        
>+
>         let thisInstantiator = this;
>-        
>-        class InstantiationSubstitution extends Substitution {
>+
>+        class InstantiationSubstitution extends Rewriter {
>             visitCallExpression(node)
>             {
>                 let result = super.visitCallExpression(node);
>-                
>-                // We may have to re-resolve the function call, if it was a call to a protocol
>-                // signature.
>-                if (result.func instanceof ProtocolFuncDecl) {
>-                    let overload = resolveOverloadImpl(result.possibleOverloads, result.typeArguments, result.argumentTypes, result.returnType);
>-                    if (!overload.func)
>-                        throw new Error("Could not resolve protocol signature function call during instantiation: " + result.func + (overload.failures.length ? "; tried:\n" + overload.failures.join("\n") : ""));
>-                    result.resolveToOverload(overload);
>-                }
>-                
>                 if (result.func.isNative)
>-                    result.nativeFuncInstance = thisInstantiator.getUnique(result.func, result.actualTypeArguments);
>-                
>+                    result.nativeFuncInstance = thisInstantiator.getUnique(result.func);
>+
>                 return result;
>             }
>         }
>-        
>-        let substitution = new InstantiationSubstitution(func.typeParameters, typeArguments);
> 
>-        class InstantiationInstantiateImmediates extends InstantiateImmediates {
>+        let substitution = new InstantiationSubstitution();
>+
>+        class InstantiationInstantiateImmediates extends Rewriter {
>             visitCallExpression(node)
>             {
>                 // We need to preserve certain things that would have instantiated, but that we cannot
>@@ -107,18 +70,17 @@ class FuncInstantiator {
>                     node.origin, node.name, node.typeArguments,
>                     node.argumentList.map(argument => Node.visit(argument, this)));
>                 result = this.processDerivedCallData(node, result);
>-                
>+
>                 result.argumentTypes = Array.from(node.argumentTypes);
>                 if (node.isCast)
>                     result.setCastData(node.returnType);
>-                result.actualTypeArguments = Array.from(node.actualTypeArguments);
>-                
>+
>                 return result;
>             }
>         }
> 
>         let instantiateImmediates = new InstantiationInstantiateImmediates();
>-        
>+
>         class Instantiate {
>             visitFuncDef(func)
>             {
>@@ -128,11 +90,9 @@ class FuncInstantiator {
>                 parameters = parameters.map(parameter => parameter.visit(instantiateImmediates));
>                 let body = func.body.visit(substitution);
>                 body = body.visit(instantiateImmediates);
>-                return new FuncDef(
>-                    func.origin, func.name, returnType, [], parameters, body, func.isCast,
>-                    func.shaderType);
>+                return new FuncDef(func.origin, func.name, returnType, parameters, body, func.isCast, func.shaderType);
>             }
>-            
>+
>             visitNativeFunc(func)
>             {
>                 return new NativeFuncInstance(
>@@ -146,7 +106,7 @@ class FuncInstantiator {
>         }
>         let resultingFunc = func.visit(new Instantiate());
>         resultingFunc.uninstantiatedReturnType = func.returnType.visit(substitution);
>-        let instance = {func: resultingFunc, typeArguments};
>+        let instance = {func: resultingFunc};
>         instances.push(instance);
>         return resultingFunc;
>     }
>diff --git a/Tools/WebGPUShadingLanguageRI/InferTypesForCall.js b/Tools/WebGPUShadingLanguageRI/InferTypesForCall.js
>index 446b351da5715c68a35d7697969d698ec73e74f8..2dd9da5088eecb4f0eb13e56d6ae3594d80570aa 100644
>--- a/Tools/WebGPUShadingLanguageRI/InferTypesForCall.js
>+++ b/Tools/WebGPUShadingLanguageRI/InferTypesForCall.js
>@@ -20,44 +20,30 @@
>  * 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. 
>+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
>  */
> "use strict";
> 
>-function inferTypesForCall(func, typeArguments, argumentTypes, returnType)
>+function inferTypesForCall(func, argumentTypes, returnType)
> {
>-    if (typeArguments.length && typeArguments.length != func.typeParameters.length)
>-        return {failure: new OverloadResolutionFailure(func, "Wrong number of type arguments (passed " + typeArguments.length + ", require " + func.typeParameters.length + ")")};
>     if (argumentTypes.length != func.parameters.length)
>         return {failure: new OverloadResolutionFailure(func, "Wrong number of arguments (passed " + argumentTypes.length + ", require " + func.parameters.length + ")")};
>-    let unificationContext = new UnificationContext(func.typeParametersForCallResolution);
>-    for (let i = 0; i < typeArguments.length; ++i) {
>-        let argument = typeArguments[i];
>-        let parameter = func.typeParameters[i];
>-        if (!argument.unify(unificationContext, parameter))
>-            return {failure: new OverloadResolutionFailure(func, "Type argument #" + (i + 1) + " for parameter " + parameter.name + " does not match (passed " + argument + ", require " + parameter + ")")};
>-    }
>+    let unificationContext = new UnificationContext();
>     for (let i = 0; i < argumentTypes.length; ++i) {
>         if (!argumentTypes[i])
>             throw new Error("Null argument type at i = " + i);
>         if (!argumentTypes[i].unify(unificationContext, func.parameters[i].type))
>             return {failure: new OverloadResolutionFailure(func, "Argument #" + (i + 1) + " " + (func.parameters[i].name ? "for parameter " + func.parameters[i].name + " " : "") + "does not match (passed " + argumentTypes[i] + ", require " + func.parameters[i].type + ")")};
>     }
>-    if (returnType && !returnType.unify(unificationContext, func.returnType))
>+    if (returnType && !returnType.unify(unificationContext, func.returnType)) {
>+        if (func.returnType.toString() == "vector") {
>+            returnType.unify(unificationContext, func.returnType)
>+        }
>         return {failure: new OverloadResolutionFailure(func, "Return type " + func.returnType + " does not match " + returnType)};
>+    }
>     let verificationResult = unificationContext.verify();
>     if (!verificationResult.result)
>         return {failure: new OverloadResolutionFailure(func, verificationResult.reason)};
>-    let shouldBuildTypeArguments = !typeArguments.length;
>-    if (shouldBuildTypeArguments)
>-        typeArguments = [];
>-    for (let typeParameter of func.typeParameters) {
>-        let typeArgument = unificationContext.find(typeParameter);
>-        if (typeArgument == typeParameter)
>-            return {failure: new OverloadResolutionFailure(func, "Type parameter " + typeParameter + " did not get assigned a type")};
>-        if (shouldBuildTypeArguments)
>-            typeArguments.push(typeArgument);
>-    }
>-    return {func, unificationContext, typeArguments};
>+    return {func, unificationContext};
> }
> 
>diff --git a/Tools/WebGPUShadingLanguageRI/Inline.js b/Tools/WebGPUShadingLanguageRI/Inline.js
>index f02873bd273d910b3df04fd2a51a3c7c0a467cef..33352235be6c879f93e1a4826e7e074fda06ebc7 100644
>--- a/Tools/WebGPUShadingLanguageRI/Inline.js
>+++ b/Tools/WebGPUShadingLanguageRI/Inline.js
>@@ -28,18 +28,14 @@ function inline(program)
> {
>     for (let funcList of program.functions.values()) {
>         for (let func of funcList) {
>-            if (!func.typeParameters.length) {
>-                func = program.funcInstantiator.getUnique(func, [])
>-                _inlineFunction(program, func, new VisitingSet(func));
>-            }
>+            func = program.funcInstantiator.getUnique(func);
>+            _inlineFunction(program, func, new VisitingSet(func));
>         }
>     }
> }
> 
> function _inlineFunction(program, func, visiting)
> {
>-    if (func.typeParameters.length)
>-        throw new Error("Cannot inline function that has type parameters");
>     if (func.inlined || func.isNative)
>         return;
>     
>@@ -55,14 +51,13 @@ function _inlineFunction(program, func, visiting)
>     func.inlined = true;
> }
> 
>-function resolveInlinedFunction(program, name, typeArguments, argumentTypes, allowEntryPoint = false)
>+function resolveInlinedFunction(program, name, argumentTypes, allowEntryPoint = false)
> {
>-    let overload = program.globalNameContext.resolveFuncOverload(name, typeArguments, argumentTypes, undefined, allowEntryPoint);
>+    let overload = program.globalNameContext.resolveFuncOverload(name, [], argumentTypes, undefined, allowEntryPoint);
>     if (!overload.func)
>         return overload.failures;
>-    if (!overload.func.typeParameters)
>-        return overload.func;
>-    let func = program.funcInstantiator.getUnique(overload.func, overload.typeArguments);
>+ 
>+    let func = program.funcInstantiator.getUnique(overload.func);
>     _inlineFunction(program, func, new VisitingSet(overload.func));
>     return func;
> }
>diff --git a/Tools/WebGPUShadingLanguageRI/Inliner.js b/Tools/WebGPUShadingLanguageRI/Inliner.js
>index 491ef3e221fc06318ee0367a381699e5723bfe5a..287cb83b296409b386c1c32baa155685093a1b2e 100644
>--- a/Tools/WebGPUShadingLanguageRI/Inliner.js
>+++ b/Tools/WebGPUShadingLanguageRI/Inliner.js
>@@ -35,10 +35,10 @@ class Inliner extends Rewriter {
>     visitCallExpression(node)
>     {
>         let result = super.visitCallExpression(node);
>-        if (result.nativeFuncInstance)
>+        if (result.func.isNative)
>             return result;
>         return this._visiting.doVisit(node.func, () => {
>-            let func = this._program.funcInstantiator.getUnique(result.func, result.actualTypeArguments);
>+            let func = this._program.funcInstantiator.getUnique(result.func);
>             if (func.isNative)
>                 throw new Error("Unexpected native func: " + func);
>             _inlineFunction(this._program, func, this._visiting);
>diff --git a/Tools/WebGPUShadingLanguageRI/InstantiateImmediates.js b/Tools/WebGPUShadingLanguageRI/InstantiateImmediates.js
>deleted file mode 100644
>index 2b39ed6638141348abc127696b6ee31e0b0c58b6..0000000000000000000000000000000000000000
>--- a/Tools/WebGPUShadingLanguageRI/InstantiateImmediates.js
>+++ /dev/null
>@@ -1,44 +0,0 @@
>-/*
>- * Copyright (C) 2017 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. ``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
>- * 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. 
>- */
>-"use strict";
>-
>-class InstantiateImmediates extends Rewriter {
>-    visitTypeRef(node)
>-    {
>-        node = super.visitTypeRef(node);
>-        if (!node.type.instantiate) {
>-            if (node.typeArguments.length)
>-                throw new Error("type does not support instantiation: " + type + " (" + type.constructor.name + ")");
>-            return node;
>-        }
>-        return node.type.instantiate(node.typeArguments).visit(new AutoWrapper());
>-    }
>-    
>-    visitReferenceType(node)
>-    {
>-        return node;
>-    }
>-}
>-
>diff --git a/Tools/WebGPUShadingLanguageRI/Intrinsics.js b/Tools/WebGPUShadingLanguageRI/Intrinsics.js
>index 933dfe011302b0fbc8344994a1a5c1f77c052a6f..9ef2ccbb1db47d5d83878412609b9b2a3163fe77 100644
>--- a/Tools/WebGPUShadingLanguageRI/Intrinsics.js
>+++ b/Tools/WebGPUShadingLanguageRI/Intrinsics.js
>@@ -35,7 +35,7 @@ class Intrinsics {
>         // use "int" here, since we don't yet know that they are the same type.
>         
>         this._map.set(
>-            "native typedef void<>",
>+            "native typedef void",
>             type => {
>                 this.void = type;
>                 type.size = 0;
>@@ -55,9 +55,16 @@ class Intrinsics {
>             }
>             return true;
>         }
>+        
>+        function cast(typedArrayConstructor, number)
>+        {
>+            var array = new typedArrayConstructor(1);
>+            array[0] = number;
>+            return array[0];
>+        }
> 
>         this._map.set(
>-            "native typedef int32<>",
>+            "native typedef int32",
>             type => {
>                 this.int32 = type;
>                 type.isPrimitive = true;
>@@ -82,7 +89,7 @@ class Intrinsics {
>             });
> 
>         this._map.set(
>-            "native typedef uint32<>",
>+            "native typedef uint32",
>             type => {
>                 this.uint32 = type;
>                 type.isPrimitive = true;
>@@ -105,7 +112,7 @@ class Intrinsics {
>             });
> 
>         this._map.set(
>-            "native typedef uint8<>",
>+            "native typedef uint8",
>             type => {
>                 this.uint8 = type;
>                 type.isInt = true;
>@@ -125,9 +132,56 @@ class Intrinsics {
>                         yield {value: i, name: i};
>                 };
>             });
>+        function bitwiseCast(typedArrayConstructor1, typedArrayConstructor2, value)
>+        {
>+            let typedArray1 = new typedArrayConstructor1(1);
>+            let typedArray2 = new typedArrayConstructor2(typedArray1.buffer);
>+            typedArray1[0] = value;
>+            return typedArray2[0];
>+        }
>+
>+        function castToHalf(number)
>+        {
>+            // FIXME: Make this math obey IEEE 754.
>+            if (Number.isNaN(number))
>+                return number
>+            if (number > 65504)
>+                return Number.POSITIVE_INFINITY;
>+            if (number < -65504)
>+                return Number.NEGATIVE_INFINITY;
>+            if (number > 0 && number < Math.pow(2, -24))
>+                return 0;
>+            if (number < 0 && number > -Math.pow(2, -24))
>+                return -0;
>+            let doubleArray = new Float64Array(1);
>+            let uintArray = new Uint8Array(doubleArray.buffer);
>+            doubleArray[0] = number;
>+            let sign = uintArray[7] & 0x80;
>+            let exponent = ((uintArray[7] & 0x7f) << 4) | ((uintArray[6] & 0xf0) >>> 4);
>+            let significand = ((uintArray[6] & 0x0f) << 6) | ((uintArray[5] & 0xfc) >>> 2);
>+
>+            if ((exponent - 1023) < -14) {
>+                exponent = 0;
>+                significand = (Math.abs(number) * Math.pow(2, 24)) >>> 0;
>+                let value = Math.pow(2, -14) * significand / 1024;
>+                if (sign != 0)
>+                    value *= -1;
>+                return value;
>+            }
>+
>+            doubleArray[0] = 0;
> 
>+            uintArray[7] |= sign;
>+            uintArray[7] |= (exponent >>> 4);
>+            uintArray[6] |= ((exponent << 4) & 0xf0);
>+            uintArray[6] |= (significand >>> 6);
>+            uintArray[5] |= ((significand << 2) & 0xfc);
>+            
>+            return doubleArray[0];
>+        }
>+        
>         this._map.set(
>-            "native typedef float32<>",
>+            "native typedef float",
>             type => {
>                 this.float = type;
>                 type.isPrimitive = true;
>@@ -140,409 +194,836 @@ class Intrinsics {
>                 type.formatValueFromUintLiteral = value => value;
>                 type.formatValueFromFloatLiteral = value => Math.fround(value);
>             });
>-
>+        
>         this._map.set(
>-            "native typedef bool<>",
>+            "native typedef bool",
>             type => {
>                 this.bool = type;
>                 type.isPrimitive = true;
>                 type.size = 1;
>                 type.populateDefaultValue = (buffer, offset) => buffer.set(offset, false);
>             });
>+
>+        for (let vectorType of VectorElementTypes) {
>+            for (let size of VectorElementSizes) {
>+                this._map.set(
>+                    `native typedef vector<${vectorType}, ${size}>`,
>+                    type  => {}
>+                )
>+            }
>+        }
>         
>         this._map.set(
>-            "native operator<> int32(uint32)",
>+            "native operator int32(uint32)",
>             func => {
>                 func.implementation = ([value]) => EPtr.box(value.loadValue() | 0);
>             });
>         
>+        // FIXME: Weird merge issue
>+        // this._map.set(
>+        //     "native operator int32(uint8)",
>+        this._map.set(
>+             "native typedef uchar",
>+             type => {
>+                 this.uchar = type;
>+                 type.isPrimitive = true;
>+                 type.isInt = true;
>+                 type.isNumber = true;
>+                 type.isSigned = false;
>+                 type.canRepresent = value => isBitwiseEquivalent(value & 0xff, value);
>+                 type.size = 1;
>+                 type.defaultValue = 0;
>+                 type.createLiteral = (origin, value) => IntLiteral.withType(origin, value & 0xff, type);
>+                 type.successorValue = value => (value + 1) & 0xff;
>+                 type.valuesEqual = (a, b) => a === b;
>+                 type.populateDefaultValue = (buffer, offset) => buffer.set(offset, 0);
>+                 type.formatValueFromIntLiteral = value => value & 0xff;
>+                 type.formatValueFromUintLiteral = value => value & 0xff;
>+                 type.allValues = function*() {
>+                     for (let i = 0; i <= 0xff; ++i)
>+                         yield {value: i, name: i};
>+                 };
>+             });
>+
>+        this._map.set(
>+             "native typedef ushort",
>+             type => {
>+                 this.ushort = type;
>+                 type.isPrimitive = true;
>+                 type.isInt = true;
>+                 type.isNumber = true;
>+                 type.isSigned = false;
>+                 type.canRepresent = value => isBitwiseEquivalent(value & 0xffff, value);
>+                 type.size = 1;
>+                 type.defaultValue = 0;
>+                 type.createLiteral = (origin, value) => IntLiteral.withType(origin, value & 0xffff, type);
>+                 type.successorValue = value => (value + 1) & 0xffff;
>+                 type.valuesEqual = (a, b) => a === b;
>+                 type.populateDefaultValue = (buffer, offset) => buffer.set(offset, 0);
>+                 type.formatValueFromIntLiteral = value => value & 0xffff;
>+                 type.formatValueFromUintLiteral = value => value & 0xffff;
>+                 type.allValues = function*() {
>+                     for (let i = 0; i <= 0xffff; ++i)
>+                         yield {value: i, name: i};
>+                 };
>+             });
>+
>+        this._map.set(
>+             "native typedef uint",
>+             type => {
>+                 this.uint = type;
>+                 type.isPrimitive = true;
>+                 type.isInt = true;
>+                 type.isNumber = true;
>+                 type.isSigned = false;
>+                 type.canRepresent = value => isBitwiseEquivalent(value >>> 0, value);
>+                 type.size = 1;
>+                 type.defaultValue = 0;
>+                 type.createLiteral = (origin, value) => IntLiteral.withType(origin, value >>> 0, type);
>+                 type.successorValue = value => (value + 1) >>> 0;
>+                 type.valuesEqual = (a, b) => a === b;
>+                 type.populateDefaultValue = (buffer, offset) => buffer.set(offset, 0);
>+                 type.formatValueFromIntLiteral = value => value >>> 0;
>+                 type.formatValueFromUintLiteral = value => value >>> 0;
>+                 type.allValues = function*() {
>+                     for (let i = 0; i <= 0xffffffff; ++i)
>+                         yield {value: i, name: i};
>+                 };
>+             });
>+
>+        this._map.set(
>+             "native typedef char",
>+             type => {
>+                 this.char = type;
>+                 type.isPrimitive = true;
>+                 type.isInt = true;
>+                 type.isNumber = true;
>+                 type.isSigned = true;
>+                 type.canRepresent = value => isBitwiseEquivalent(cast(Int8Array, value), value);
>+                 type.size = 1;
>+                 type.defaultValue = 0;
>+                 type.createLiteral = (origin, value) => IntLiteral.withType(origin, cast(Int8Array, value), type);
>+                 type.successorValue = value => cast(Int8Array, value + 1);
>+                 type.valuesEqual = (a, b) => a === b;
>+                 type.populateDefaultValue = (buffer, offset) => buffer.set(offset, 0);
>+                 type.formatValueFromIntLiteral = value => cast(Int8Array, value);
>+                 type.formatValueFromUintLiteral = value => cast(Int8Array, value);
>+                 type.allValues = function*() {
>+                     for (let i = 0; i <= 0xff; ++i) {
>+                         let value = cast(Int8Array, i);
>+                         yield {value: value, name: value};
>+                     }
>+                 };
>+             });
>+
>+        this._map.set(
>+             "native typedef short",
>+             type => {
>+                 this.short = type;
>+                 type.isPrimitive = true;
>+                 type.isInt = true;
>+                 type.isNumber = true;
>+                 type.isSigned = true;
>+                 type.canRepresent = value => isBitwiseEquivalent(cast(Int16Array, value), value);
>+                 type.size = 1;
>+                 type.defaultValue = 0;
>+                 type.createLiteral = (origin, value) => IntLiteral.withType(origin, cast(Int16Array, value), type);
>+                 type.successorValue = value => cast(Int16Array, value + 1);
>+                 type.valuesEqual = (a, b) => a === b;
>+                 type.populateDefaultValue = (buffer, offset) => buffer.set(offset, 0);
>+                 type.formatValueFromIntLiteral = value => cast(Int16Array, value);
>+                 type.formatValueFromUintLiteral = value => cast(Int16Array, value);
>+                 type.allValues = function*() {
>+                     for (let i = 0; i <= 0xffff; ++i) {
>+                         let value = cast(Int16Array, i);
>+                         yield {value: value, name: value};
>+                     }
>+                 };
>+             });
>+
>+        this._map.set(
>+             "native typedef int",
>+             type => {
>+                 this.int = type;
>+                 type.isPrimitive = true;
>+                 type.isInt = true;
>+                 type.isNumber = true;
>+                 type.isSigned = true;
>+                 type.canRepresent = value => isBitwiseEquivalent(value | 0, value);
>+                 type.size = 1;
>+                 type.defaultValue = 0;
>+                 type.createLiteral = (origin, value) => IntLiteral.withType(origin, value | 0, type);
>+                 type.successorValue = value => (value + 1) | 0;
>+                 type.valuesEqual = (a, b) => a === b;
>+                 type.populateDefaultValue = (buffer, offset) => buffer.set(offset, 0);
>+                 type.formatValueFromIntLiteral = value => value | 0;
>+                 type.formatValueFromUintLiteral = value => value | 0;
>+                 type.allValues = function*() {
>+                     for (let i = 0; i <= 0xffffffff; ++i) {
>+                         let value = i | 0;
>+                         yield {value: value, name: value};
>+                     }
>+                 };
>+             });
>+
>+         this._map.set(
>+             "native typedef half",
>+             type => {
>+                 this.half = type;
>+                 type.isPrimitive = true;
>+                 type.size = 1;
>+                 type.isFloating = true;
>+                 type.isNumber = true;
>+                 type.canRepresent = value => isBitwiseEquivalent(castToHalf(value), value);
>+                 type.populateDefaultValue = (buffer, offset) => buffer.set(offset, 0);
>+                 type.formatValueFromIntLiteral = value => value;
>+                 type.formatValueFromUintLiteral = value => value;
>+                 type.formatValueFromFloatLiteral = value => castToHalf(value);
>+             });
>+
>+
>+
>+        this._map.set(
>+             "native typedef atomic_int",
>+             type => {
>+                 this.atomic_int = type;
>+                 // FIXME: Figure out what to put here.
>+             });
>+
>+        this._map.set(
>+             "native typedef atomic_uint",
>+             type => {
>+                 this.atomic_uint = type;
>+                 // FIXME: Figure out what to put here.
>+             });
>+
>+        for (let primitiveType of ["bool", "uchar", "ushort", "uint", "char", "short", "int", "half", "float"]) {
>+            for (let i = 2; i <= 4; ++i) {
>+                this._map.set(
>+                    `native typedef ${primitiveType}${i}`,
>+                    type => {
>+                        this[`${primitiveType}${i}`] = type;
>+                        // FIXME: Figure out what to put here.
>+                    });
>+            }
>+        }
>+
>+        for (let primitiveType of ["half", "float"]) {
>+            for (let i = 2; i <= 4; ++i) {
>+                for (let j = 2; j <= 4; ++j) {
>+                    this._map.set(
>+                        `native typedef ${primitiveType}${i}x${j}`,
>+                        type => {
>+                            this[`${primitiveType}${i}x${j}`] = type;
>+                            // FIXME: Figure out what to put here.
>+                        });
>+                }
>+            }
>+        }
>+
>         this._map.set(
>-            "native operator<> int32(uint8)",
>+             "native typedef sampler",
>+             type => {
>+                 this.sampler = type;
>+                 // FIXME: Figure out what to put here.
>+             });
>+
>+        // FIXME: Probably want to do this the typed way
>+
>+        for (let textureType of ["Texture1D", "RWTexture1D", "Texture1DArray", "RWTexture1DArray", "Texture2D", "RWTexture2D", "Texture2DArray", "RWTexture2DArray", "Texture3D", "RWTexture3D", "TextureCube"]) {
>+            for (let typeArgument of ["bool", "uchar", "ushort", "uint", "char", "short", "int", "half", "float"]) {
>+                this._map.set(
>+                    `native typedef ${textureType}<${typeArgument}>`,
>+                    type => {
>+                        this[`${textureType}<${typeArgument}>`] = type;
>+                        // FIXME: Figure out what to put here.
>+                    });
>+                for (let i = 2; i <= 4; ++i) {
>+                    this._map.set(
>+                        `native typedef ${textureType}<${typeArgument}${i}>`,
>+                        type => {
>+                            this[`${textureType}<${typeArgument}${i}>`] = type;
>+                            // FIXME: Figure out what to put here.
>+                        });
>+                }
>+            }
>+        }
>+
>+        for (let textureType of ["TextureDepth2D", "RWTextureDepth2D", "TextureDepth2DArray", "RWTextureDepth2DArray", "TextureDepthCube"]) {
>+            for (let typeArgument of ["float", "half"]) {
>+                this._map.set(
>+                    `native typedef ${textureType}<${typeArgument}>`,
>+                    type => {
>+                        this[`${textureType}<${typeArgument}>`] = type;
>+                        // FIXME: Figure out what to put here.
>+                    });
>+            }
>+        }
>+
>+        for (let primitiveType of ["ushort", "uint", "char", "short", "int", "half", "float"]) {
>+            this._map.set(
>+                `native operator uchar(${primitiveType})`,
>+                func => {
>+                    func.implementation = ([value]) => EPtr.box(value.loadValue() & 0xff);
>+                });
>+        }
>+
>+        for (let primitiveType of ["uchar", "uint", "char", "short", "int", "half", "float"]) {
>+            this._map.set(
>+                `native operator ushort(${primitiveType})`,
>+                func => {
>+                    func.implementation = ([value]) => EPtr.box(value.loadValue() & 0xffff);
>+                });
>+        }
>+
>+        for (let primitiveType of ["uchar", "ushort", "char", "short", "int", "half", "float"]) {
>+            this._map.set(
>+                `native operator uint(${primitiveType})`,
>+                func => {
>+                    func.implementation = ([value]) => EPtr.box(value.loadValue() >>> 0);
>+                });
>+        }
>+
>+        for (let primitiveType of ["uchar", "ushort", "uint", "short", "int", "half", "float"]) {
>+            this._map.set(
>+                `native operator char(${primitiveType})`,
>+                func => {
>+                    func.implementation = ([value]) => EPtr.box(cast(Int8Array, value.loadValue()));
>+                });
>+        }
>+
>+        for (let primitiveType of ["uchar", "ushort", "uint", "char", "int", "half", "float"]) {
>+            this._map.set(
>+                `native operator short(${primitiveType})`,
>+                func => {
>+                    func.implementation = ([value]) => EPtr.box(cast(Int16Array, value.loadValue()));
>+                });
>+        }
>+
>+        for (let primitiveType of ["uchar", "ushort", "uint", "char", "short", "half", "float"]) {
>+            this._map.set(
>+                `native operator int(${primitiveType})`,
>+                func => {
>+                    func.implementation = ([value]) => EPtr.box(cast(Int32Array, value.loadValue()));
>+                });
>+        }
>+
>+        for (let primitiveType of ["uchar", "ushort", "uint", "char", "short", "int", "float"]) {
>+            this._map.set(
>+                `native operator half(${primitiveType})`,
>+                func => {
>+                    func.implementation = ([value]) => EPtr.box(castToHalf(value.loadValue()));
>+                });
>+        }
>+
>+        for (let primitiveType of ["uchar", "ushort", "uint", "char", "short", "int", "half"]) {
>+            this._map.set(
>+                `native operator float(${primitiveType})`,
>+                func => {
>+                    func.implementation = ([value]) => EPtr.box(Math.fround(value.loadValue()));
>+                });
>+        }
>+
>+        this._map.set(
>+            `native operator int(atomic_int)`,
>             func => {
>-                func.implementation = ([value]) => EPtr.box(value.loadValue() | 0);
>+                func.implementation = ([value]) => EPtr.box(value.loadValue());
>             });
>-        
>+
>         this._map.set(
>-            "native operator<> int32(float)",
>+            `native operator uint(atomic_uint)`,
>             func => {
>-                func.implementation = ([value]) => EPtr.box(value.loadValue() | 0);
>+                func.implementation = ([value]) => EPtr.box(value.loadValue());
>             });
>-        
>+
>         this._map.set(
>-            "native operator<> uint32(int32)",
>+            "native bool operator==(bool,bool)",
>             func => {
>-                func.implementation = ([value]) => EPtr.box(value.loadValue() >>> 0);
>+                func.implementation = ([left, right]) =>
>+                    EPtr.box(left.loadValue() == right.loadValue());
>             });
>-        
>+
>+
>+        for (let primitiveType of ["uint", "int", "float"]) {
>+            this._map.set(
>+                `native bool operator==(${primitiveType},${primitiveType})`,
>+                func => {
>+                    func.implementation = ([left, right]) =>
>+                        EPtr.box(left.loadValue() == right.loadValue());
>+                });
>+
>+            this._map.set(
>+                `native bool operator<(${primitiveType},${primitiveType})`,
>+                func => {
>+                    func.implementation = ([left, right]) =>
>+                        EPtr.box(left.loadValue() < right.loadValue());
>+                });
>+
>+            this._map.set(
>+                `native bool operator<=(${primitiveType},${primitiveType})`,
>+                func => {
>+                    func.implementation = ([left, right]) =>
>+                        EPtr.box(left.loadValue() <= right.loadValue());
>+                });
>+
>+            this._map.set(
>+                `native bool operator>(${primitiveType},${primitiveType})`,
>+                func => {
>+                    func.implementation = ([left, right]) =>
>+                        EPtr.box(left.loadValue() > right.loadValue());
>+                });
>+
>+            this._map.set(
>+                `native bool operator>=(${primitiveType},${primitiveType})`,
>+                func => {
>+                    func.implementation = ([left, right]) =>
>+                        EPtr.box(left.loadValue() >= right.loadValue());
>+                });
>+        }
>+
>         this._map.set(
>-            "native operator<> uint32(uint8)",
>+            "native int operator-(int)",
>             func => {
>-                func.implementation = ([value]) => EPtr.box(value.loadValue() >>> 0);
>+                func.implementation = ([value]) =>
>+                    EPtr.box((-value.loadValue()) | 0);
>             });
>-        
>+
>         this._map.set(
>-            "native operator<> uint32(float)",
>+            "native float operator-(float)",
>             func => {
>-                func.implementation = ([value]) => EPtr.box(value.loadValue() >>> 0);
>+                func.implementation = ([value]) =>
>+                    EPtr.box(Math.fround(-value.loadValue()));
>             });
>-        
>+
>         this._map.set(
>-            "native operator<> uint8(int32)",
>+            "native int operator+(int,int)",
>             func => {
>-                func.implementation = ([value]) => EPtr.box(value.loadValue() & 0xff);
>+                func.implementation = ([left, right]) =>
>+                    EPtr.box((left.loadValue() + right.loadValue()) | 0);
>             });
>-        
>+
>         this._map.set(
>-            "native operator<> uint8(uint32)",
>+            "native int operator-(int,int)",
>             func => {
>-                func.implementation = ([value]) => EPtr.box(value.loadValue() & 0xff);
>+                func.implementation = ([left, right]) =>
>+                    EPtr.box((left.loadValue() - right.loadValue()) | 0);
>             });
>-        
>+
>         this._map.set(
>-            "native operator<> uint8(float)",
>+            "native int operator*(int,int)",
>             func => {
>-                func.implementation = ([value]) => EPtr.box(value.loadValue() & 0xff);
>+                func.implementation = ([left, right]) =>
>+                    EPtr.box((left.loadValue() * right.loadValue()) | 0);
>             });
>-        
>+
>         this._map.set(
>-            "native operator<> float(int32)",
>+            "native int operator/(int,int)",
>             func => {
>-                func.implementation = ([value]) => EPtr.box(Math.fround(value.loadValue()));
>+                func.implementation = ([left, right]) =>
>+                    EPtr.box((left.loadValue() / right.loadValue()) | 0);
>             });
>-        
>+
>         this._map.set(
>-            "native operator<> float(uint32)",
>+            "native uint operator+(uint,uint)",
>             func => {
>-                func.implementation = ([value]) => EPtr.box(Math.fround(value.loadValue()));
>+                func.implementation = ([left, right]) =>
>+                    EPtr.box((left.loadValue() + right.loadValue()) >>> 0);
>             });
>-        
>+
>         this._map.set(
>-            "native operator<> float(uint8)",
>+            "native uint operator-(uint,uint)",
>             func => {
>-                func.implementation = ([value]) => EPtr.box(Math.fround(value.loadValue()));
>+                func.implementation = ([left, right]) =>
>+                    EPtr.box((left.loadValue() - right.loadValue()) >>> 0);
>             });
>-        
>+
>         this._map.set(
>-            "native int operator+<>(int,int)",
>+            "native uint operator*(uint,uint)",
>             func => {
>                 func.implementation = ([left, right]) =>
>-                    EPtr.box((left.loadValue() + right.loadValue()) | 0);
>+                    EPtr.box((left.loadValue() * right.loadValue()) >>> 0);
>             });
>-        
>+
>         this._map.set(
>-            "native uint operator+<>(uint,uint)",
>+            "native uint operator/(uint,uint)",
>             func => {
>                 func.implementation = ([left, right]) =>
>-                    EPtr.box((left.loadValue() + right.loadValue()) >>> 0);
>+                    EPtr.box((left.loadValue() / right.loadValue()) >>> 0);
>             });
>-        
>+
>         this._map.set(
>-            "native float operator+<>(float,float)",
>+            "native float operator+(float,float)",
>             func => {
>                 func.implementation = ([left, right]) =>
>                     EPtr.box(Math.fround(left.loadValue() + right.loadValue()));
>             });
>-        
>+
>         this._map.set(
>-            "native int operator-<>(int,int)",
>+            "native float operator-(float,float)",
>             func => {
>                 func.implementation = ([left, right]) =>
>-                    EPtr.box((left.loadValue() - right.loadValue()) | 0);
>+                    EPtr.box(Math.fround(left.loadValue() - right.loadValue()));
>             });
>-        
>+
>         this._map.set(
>-            "native uint operator-<>(uint,uint)",
>+            "native float operator*(float,float)",
>             func => {
>                 func.implementation = ([left, right]) =>
>-                    EPtr.box((left.loadValue() - right.loadValue()) >>> 0);
>+                    EPtr.box(Math.fround(left.loadValue() * right.loadValue()));
>             });
>-        
>+
>         this._map.set(
>-            "native float operator-<>(float,float)",
>+            "native float operator/(float,float)",
>             func => {
>                 func.implementation = ([left, right]) =>
>-                    EPtr.box(Math.fround(left.loadValue() - right.loadValue()));
>+                    EPtr.box(Math.fround(left.loadValue() / right.loadValue()));
>             });
>-        
>+
>         this._map.set(
>-            "native int operator*<>(int,int)",
>+            "native int operator&(int,int)",
>             func => {
>                 func.implementation = ([left, right]) =>
>-                    EPtr.box((left.loadValue() * right.loadValue()) | 0);
>+                    EPtr.box((left.loadValue() & right.loadValue()) | 0);
>             });
>-        
>+
>         this._map.set(
>-            "native uint operator*<>(uint,uint)",
>+            "native int operator|(int,int)",
>             func => {
>                 func.implementation = ([left, right]) =>
>-                    EPtr.box((left.loadValue() * right.loadValue()) >>> 0);
>+                    EPtr.box((left.loadValue() | right.loadValue()) | 0);
>             });
>-        
>+
>         this._map.set(
>-            "native float operator*<>(float,float)",
>+            "native int operator^(int,int)",
>             func => {
>                 func.implementation = ([left, right]) =>
>-                    EPtr.box(Math.fround(left.loadValue() * right.loadValue()));
>+                    EPtr.box((left.loadValue() ^ right.loadValue()) | 0);
>             });
>-        
>+
>         this._map.set(
>-            "native int operator/<>(int,int)",
>+            "native int operator~(int)",
>             func => {
>-                func.implementation = ([left, right]) =>
>-                    EPtr.box((left.loadValue() / right.loadValue()) | 0);
>+                func.implementation = ([value]) => EPtr.box((~value.loadValue()) | 0);
>             });
>-        
>+
>         this._map.set(
>-            "native uint operator/<>(uint,uint)",
>+            "native int operator<<(int,uint)",
>             func => {
>                 func.implementation = ([left, right]) =>
>-                    EPtr.box((left.loadValue() / right.loadValue()) >>> 0);
>+                    EPtr.box((left.loadValue() << right.loadValue()) | 0);
>             });
>-        
>+
>         this._map.set(
>-            "native int operator&<>(int,int)",
>+            "native int operator>>(int,uint)",
>             func => {
>                 func.implementation = ([left, right]) =>
>-                    EPtr.box(left.loadValue() & right.loadValue());
>+                    EPtr.box((left.loadValue() >> right.loadValue()) | 0);
>             });
>-        
>+
>         this._map.set(
>-            "native uint operator&<>(uint,uint)",
>+            "native uint operator&(uint,uint)",
>             func => {
>                 func.implementation = ([left, right]) =>
>                     EPtr.box((left.loadValue() & right.loadValue()) >>> 0);
>             });
>-        
>+
>         this._map.set(
>-            "native int operator|<>(int,int)",
>+            "native uint operator|(uint,uint)",
>             func => {
>                 func.implementation = ([left, right]) =>
>-                    EPtr.box(left.loadValue() | right.loadValue());
>+                    EPtr.box((left.loadValue() | right.loadValue()) >>> 0);
>             });
>-        
>+
>         this._map.set(
>-            "native uint operator|<>(uint,uint)",
>+            "native uint operator^(uint,uint)",
>             func => {
>                 func.implementation = ([left, right]) =>
>-                    EPtr.box((left.loadValue() | right.loadValue()) >>> 0);
>+                    EPtr.box((left.loadValue() ^ right.loadValue()) >>> 0);
>             });
>-        
>+
>         this._map.set(
>-            "native int operator^<>(int,int)",
>+            "native uint operator~(uint)",
>             func => {
>-                func.implementation = ([left, right]) =>
>-                    EPtr.box(left.loadValue() ^ right.loadValue());
>+                func.implementation = ([value]) => EPtr.box((~value.loadValue()) >>> 0);
>             });
>-        
>+
>         this._map.set(
>-            "native uint operator^<>(uint,uint)",
>+            "native uint operator<<(uint,uint)",
>             func => {
>                 func.implementation = ([left, right]) =>
>-                    EPtr.box((left.loadValue() ^ right.loadValue()) >>> 0);
>+                    EPtr.box((left.loadValue() << right.loadValue()) >>> 0);
>             });
>-        
>+
>         this._map.set(
>-            "native int operator<<<>(int,uint)",
>+            "native uint operator>>(uint,uint)",
>             func => {
>                 func.implementation = ([left, right]) =>
>-                    EPtr.box(left.loadValue() << right.loadValue());
>+                    EPtr.box((left.loadValue() >> right.loadValue()) >>> 0);
>             });
>-        
>+
>         this._map.set(
>-            "native uint operator<<<>(uint,uint)",
>+            "native float cos(float)",
>             func => {
>-                func.implementation = ([left, right]) =>
>-                    EPtr.box((left.loadValue() << right.loadValue()) >>> 0);
>+                func.implementation = ([value]) =>
>+                    EPtr.box(Math.fround(Math.cos(value.loadValue())));
>             });
>-        
>+
>         this._map.set(
>-            "native int operator>><>(int,uint)",
>+            "native float sin(float)",
>             func => {
>-                func.implementation = ([left, right]) =>
>-                    EPtr.box(left.loadValue() >> right.loadValue());
>+                func.implementation = ([value]) =>
>+                    EPtr.box(Math.fround(Math.sin(value.loadValue())));
>             });
>-        
>+
>         this._map.set(
>-            "native uint operator>><>(uint,uint)",
>+            "native float tan(float)",
>             func => {
>-                func.implementation = ([left, right]) =>
>-                    EPtr.box(left.loadValue() >>> right.loadValue());
>+                func.implementation = ([value]) =>
>+                    EPtr.box(Math.fround(Math.tan(value.loadValue())));
>             });
>-        
>+
>         this._map.set(
>-            "native int operator~<>(int)",
>+            "native float acos(float)",
>             func => {
>-                func.implementation = ([value]) => EPtr.box(~value.loadValue());
>+                func.implementation = ([value]) =>
>+                    EPtr.box(Math.fround(Math.acos(value.loadValue())));
>             });
>-        
>+
>         this._map.set(
>-            "native uint operator~<>(uint)",
>+            "native float asin(float)",
>             func => {
>-                func.implementation = ([value]) => EPtr.box((~value.loadValue()) >>> 0);
>+                func.implementation = ([value]) =>
>+                    EPtr.box(Math.fround(Math.asin(value.loadValue())));
>             });
>-        
>+
>         this._map.set(
>-            "native float operator/<>(float,float)",
>+            "native float atan(float)",
>             func => {
>-                func.implementation = ([left, right]) =>
>-                    EPtr.box(Math.fround(left.loadValue() / right.loadValue()));
>+                func.implementation = ([value]) =>
>+                    EPtr.box(Math.fround(Math.atan(value.loadValue())));
>             });
>-        
>+
>         this._map.set(
>-            "native bool operator==<>(int,int)",
>+            "native float cosh(float)",
>             func => {
>-                func.implementation = ([left, right]) =>
>-                    EPtr.box(left.loadValue() == right.loadValue());
>+                func.implementation = ([value]) =>
>+                    EPtr.box(Math.fround(Math.cosh(value.loadValue())));
>             });
>-        
>+
>         this._map.set(
>-            "native bool operator==<>(uint,uint)",
>+            "native float sinh(float)",
>             func => {
>-                func.implementation = ([left, right]) =>
>-                    EPtr.box(left.loadValue() == right.loadValue());
>+                func.implementation = ([value]) =>
>+                    EPtr.box(Math.fround(Math.sinh(value.loadValue())));
>             });
>-        
>+
>         this._map.set(
>-            "native bool operator==<>(bool,bool)",
>+            "native float tanh(float)",
>             func => {
>-                func.implementation = ([left, right]) =>
>-                    EPtr.box(left.loadValue() == right.loadValue());
>+                func.implementation = ([value]) =>
>+                    EPtr.box(Math.fround(Math.tanh(value.loadValue())));
>             });
>-        
>+
>         this._map.set(
>-            "native bool operator==<>(float,float)",
>+            "native float ceil(float)",
>             func => {
>-                func.implementation = ([left, right]) =>
>-                    EPtr.box(left.loadValue() == right.loadValue());
>+                func.implementation = ([value]) =>
>+                    EPtr.box(Math.fround(Math.ceil(value.loadValue())));
>             });
>-        
>+
>         this._map.set(
>-            "native bool operator<<>(int,int)",
>+            "native float exp(float)",
>             func => {
>-                func.implementation = ([left, right]) =>
>-                    EPtr.box(left.loadValue() < right.loadValue());
>+                func.implementation = ([value]) =>
>+                    EPtr.box(Math.fround(Math.exp(value.loadValue())));
>             });
>-        
>+
>         this._map.set(
>-            "native bool operator<<>(uint,uint)",
>+            "native float floor(float)",
>             func => {
>-                func.implementation = ([left, right]) =>
>-                    EPtr.box(left.loadValue() < right.loadValue());
>+                func.implementation = ([value]) =>
>+                    EPtr.box(Math.fround(Math.floor(value.loadValue())));
>             });
>-        
>+
>         this._map.set(
>-            "native bool operator<<>(float,float)",
>+            "native float log(float)",
>             func => {
>-                func.implementation = ([left, right]) =>
>-                    EPtr.box(left.loadValue() < right.loadValue());
>+                func.implementation = ([value]) =>
>+                    EPtr.box(Math.fround(Math.log(value.loadValue())));
>             });
>-        
>+
>         this._map.set(
>-            "native bool operator<=<>(int,int)",
>+            "native float round(float)",
>             func => {
>-                func.implementation = ([left, right]) =>
>-                    EPtr.box(left.loadValue() <= right.loadValue());
>+                func.implementation = ([value]) =>
>+                    EPtr.box(Math.fround(Math.round(value.loadValue())));
>             });
>-        
>+
>         this._map.set(
>-            "native bool operator<=<>(uint,uint)",
>+            "native float sqrt(float)",
>             func => {
>-                func.implementation = ([left, right]) =>
>-                    EPtr.box(left.loadValue() <= right.loadValue());
>+                func.implementation = ([value]) =>
>+                    EPtr.box(Math.fround(Math.sqrt(value.loadValue())));
>             });
>-        
>+
>         this._map.set(
>-            "native bool operator<=<>(float,float)",
>+            "native float trunc(float)",
>             func => {
>-                func.implementation = ([left, right]) =>
>-                    EPtr.box(left.loadValue() <= right.loadValue());
>+                func.implementation = ([value]) =>
>+                    EPtr.box(Math.fround(Math.trunc(value.loadValue())));
>             });
>-        
>+
>         this._map.set(
>-            "native bool operator><>(int,int)",
>+            "native float ddx(float)",
>             func => {
>-                func.implementation = ([left, right]) =>
>-                    EPtr.box(left.loadValue() > right.loadValue());
>+                func.implementation = ([value]) => EPtr.box(0);
>             });
>-        
>+
>         this._map.set(
>-            "native bool operator><>(uint,uint)",
>+            "native float ddy(float)",
>             func => {
>-                func.implementation = ([left, right]) =>
>-                    EPtr.box(left.loadValue() > right.loadValue());
>+                func.implementation = ([value]) => EPtr.box(0);
>             });
>-        
>+
>         this._map.set(
>-            "native bool operator><>(float,float)",
>+            "native float pow(float,float)",
>             func => {
>                 func.implementation = ([left, right]) =>
>-                    EPtr.box(left.loadValue() > right.loadValue());
>+                    EPtr.box(Math.fround(Math.pow(left.loadValue(), right.loadValue())));
>             });
>-        
>+
>         this._map.set(
>-            "native bool operator>=<>(int,int)",
>+            "native bool isfinite(float)",
>             func => {
>-                func.implementation = ([left, right]) =>
>-                    EPtr.box(left.loadValue() >= right.loadValue());
>+                func.implementation = ([value]) =>
>+                    EPtr.box(Number.isFinite(value.loadValue()));
>             });
>-        
>+
>         this._map.set(
>-            "native bool operator>=<>(uint,uint)",
>+            "native bool isinf(float)",
>             func => {
>-                func.implementation = ([left, right]) =>
>-                    EPtr.box(left.loadValue() >= right.loadValue());
>+                func.implementation = ([value]) =>
>+                    EPtr.box((value.loadValue() == Number.POSITIVE_INFINITY) || (value.loadValue() == Number.NEGATIVE_INFINITY));
>             });
>-        
>+
>         this._map.set(
>-            "native bool operator>=<>(float,float)",
>+            "native bool isnan(float)",
>+            func => {
>+                func.implementation = ([value]) =>
>+                    EPtr.box(Number.isNaN(value.loadValue()));
>+            });
>+
>+        // FIXME: Implement this.
>+        this._map.set(
>+            "native bool isnormal(half)",
>+            func => {
>+                func.implementation = ([value]) =>
>+                    EPtr.box(isNaN(value.loadValue()));
>+            });
>+
>+        // FIXME: Implement this.
>+        this._map.set(
>+            "native bool isnormal(float)",
>+            func => {
>+                func.implementation = ([value]) =>
>+                    EPtr.box(isNaN(value.loadValue()));
>+            });
>+
>+        this._map.set(
>+            "native float atan2(float,float)",
>             func => {
>                 func.implementation = ([left, right]) =>
>-                    EPtr.box(left.loadValue() >= right.loadValue());
>+                    EPtr.box(Math.fround(Math.atan2(left.loadValue(), right.loadValue())));
>             });
>-        
>-        for (let addressSpace of addressSpaces) {
>-            this._map.set(
>-                `native T* ${addressSpace} operator&[]<T>(T[] ${addressSpace},uint)`,
>-                func => {
>-                    func.implementation = ([ref, index], node) => {
>-                        ref = ref.loadValue();
>-                        if (!ref)
>-                            throw new WTrapError(node.origin.originString, "Null dereference");
>-                        index = index.loadValue();
>-                        if (index > ref.length)
>-                            throw new WTrapError(node.origin.originString, "Array index " + index + " is out of bounds of " + ref);
>-                        return EPtr.box(ref.ptr.plus(index * node.instantiatedActualTypeArguments[0].size));
>-                    };
>-                });
> 
>-            this._map.set(
>-                `native uint operator.length<T>(T[] ${addressSpace})`,
>-                func => {
>-                    func.implementation = ([ref], node) => {
>-                        ref = ref.loadValue();
>-                        if (!ref)
>-                            return EPtr.box(0);
>-                        return EPtr.box(ref.length);
>-                    };
>-                });
>-        }
>+        for (let swizzle of SwizzleOp.functions())
>+            this._map.set(swizzle.toString(), func => swizzle.instantiateImplementation(func));
> 
>-        for (let swizzle of SwizzleOp.allSwizzleOperators()) {
>-            this._map.set(swizzle.toString(), 
>-            func => {
>-                func.implementation = ([vec], node) => {
>-                    const outputBuffer = new EBuffer(swizzle.outSize);
>-                    const readIndices = { 'x': 0, 'y': 1, 'z': 2, 'w': 3 };
>-                    for (let i = 0; i < swizzle.outSize; i++)
>-                        outputBuffer.set(i, vec.get(readIndices[swizzle.components[i]]));
>-                    
>-                    
>-                    return new EPtr(outputBuffer, 0);
>-                },
>-                func.implementationData = swizzle;
>-            });
>-            console.log(swizzle.toString());
>-        }
>+        for (let boolOp of OperatorBool.functions())
>+            this._map.set(boolOp.toString(), func => boolOp.instantiateImplementation(func));
>+
>+        for (let anderIndex of OperatorAnderIndexer.functions())
>+            this._map.set(anderIndex.toString(), func => anderIndex.instantiateImplementation(func));
>+
>+        for (let cast of BuiltinVectorCasts.functions())
>+            this._map.set(cast.toString(), func => cast.instantiateImplementation(func));
>+
>+        for (let getter of BuiltinVectorIndexGetter.functions())
>+            this._map.set(getter.toString(), func => getter.instantiateImplementation(func));
>+
>+        for (let setter of BuiltinVectorIndexSetter.functions())
>+            this._map.set(setter.toString(), func => setter.instantiateImplementation(func));
>+
>+        for (let equalityOperator of BuiltinVectorEqualityOperator.functions())
>+            this._map.set(equalityOperator.toString(), func => equalityOperator.instantiateImplementation(func));
>+
>+        for (let getter of BuiltinVectorGetter.functions())
>+            this._map.set(getter.toString(), func => getter.instantiateImplementation(func));
>+
>+        for (let setter of BuiltinVectorSetter.functions())
>+            this._map.set(setter.toString(), func => setter.instantiateImplementation(func));
>+            
>+        this._map.set(
>+            "native int asint(float)",
>+            func => {
>+                func.implementation = ([value]) =>
>+                    EPtr.box(bitwiseCast(Float32Array, Int32Array, value.loadValue()));
>+            });
>+
>+        this._map.set(
>+            "native uint asuint(float)",
>+            func => {
>+                func.implementation = ([value]) =>
>+                    EPtr.box(bitwiseCast(Float32Array, Uint32Array, value.loadValue()));
>+            });
>+
>+        this._map.set(
>+            "native float asfloat(int)",
>+            func => {
>+                func.implementation = ([value]) =>
>+                    EPtr.box(bitwiseCast(Int32Array, Float32Array, value.loadValue()));
>+            });
>+
>+        this._map.set(
>+            "native float asfloat(uint)",
>+            func => {
>+                func.implementation = ([value]) =>
>+                    EPtr.box(bitwiseCast(Uint32Array, Float32Array, value.loadValue()));
>+            });
>+
>+        // FIXME: Implement this.
>+        this._map.set(
>+            "native float f16tof32(uint)",
>+            func => {
>+                func.implementation = ([value]) =>
>+                    EPtr.box(0);
>+            });
>+
>+        // FIXME: Implement this.
>+        this._map.set(
>+            "native uint f32tof16(float)",
>+            func => {
>+                func.implementation = ([value]) =>
>+                    EPtr.box(0);
>+            });
>+
>+        this._map.set(
>+            "native void AllMemoryBarrierWithGroupSync()",
>+            func => {
>+                func.implementation = function() {};
>+            });
>+
>+        this._map.set(
>+            "native void DeviceMemoryBarrierWithGroupSync()",
>+            func => {
>+                func.implementation = function() {};
>+            });
>+
>+        this._map.set(
>+            "native void GroupMemoryBarrierWithGroupSync()",
>+            func => {
>+                func.implementation = function() {};
>+            });
>     }
>     
>     add(thing)
>diff --git a/Tools/WebGPUShadingLanguageRI/Lexer.js b/Tools/WebGPUShadingLanguageRI/Lexer.js
>index be2165db79e83ecc28f5d346b5c5d21e3244bd0c..af1a09b7eff62a1880346d91764476def75d4d03 100644
>--- a/Tools/WebGPUShadingLanguageRI/Lexer.js
>+++ b/Tools/WebGPUShadingLanguageRI/Lexer.js
>@@ -122,7 +122,7 @@ class Lexer {
>         
>         // FIXME: Make this do Unicode.
>         if (Lexer._textIsIdentifierImpl(relevantText)) {
>-            if (/^(struct|protocol|typedef|if|else|enum|continue|break|switch|case|default|for|while|do|return|constant|device|threadgroup|thread|operator|null|true|false)$/.test(RegExp.lastMatch))
>+            if (/^(struct|typedef|if|else|enum|continue|break|switch|case|default|for|while|do|return|constant|device|threadgroup|thread|operator|null|true|false)$/.test(RegExp.lastMatch))
>                 return result("keyword");
>             
>             if (this._originKind == "native" && /^(native|restricted)$/.test(RegExp.lastMatch))
>diff --git a/Tools/WebGPUShadingLanguageRI/LiteralTypeChecker.js b/Tools/WebGPUShadingLanguageRI/LiteralTypeChecker.js
>index 849d034d53573da3bf938f905cd60b7637dcaa53..55ae01b09018c0cda1dbc884eb5955cf87368f6c 100644
>--- a/Tools/WebGPUShadingLanguageRI/LiteralTypeChecker.js
>+++ b/Tools/WebGPUShadingLanguageRI/LiteralTypeChecker.js
>@@ -43,6 +43,8 @@ class LiteralTypeChecker extends Visitor {
>     {
>         if (!node.type)
>             throw new Error(node + " at " + node.origin.originString + " does not have type");
>+        if (!node.type.type.canRepresent(node.value))
>+            throw new Error(`${node.value} at ${node.origin.originString} cannot be represented by ${node.type}`);
>     }
> }
> 
>diff --git a/Tools/WebGPUShadingLanguageRI/Myles.html b/Tools/WebGPUShadingLanguageRI/Myles.html
>new file mode 100644
>index 0000000000000000000000000000000000000000..7bedc8e67c324ea456a4ba2f11e9c51208c7c28c
>--- /dev/null
>+++ b/Tools/WebGPUShadingLanguageRI/Myles.html
>@@ -0,0 +1,152 @@
>+<html>
>+<head>
>+<title>Myles</title>
>+<script src="Node.js"></script>
>+<script src="Type.js"></script>
>+<script src="ReferenceType.js"></script>
>+<script src="Value.js"></script>
>+<script src="Expression.js"></script>
>+<script src="Rewriter.js"></script>
>+<script src="Visitor.js"></script>
>+<script src="CreateLiteral.js"></script>
>+<script src="CreateLiteralType.js"></script>
>+<script src="PropertyAccessExpression.js"></script>
>+<script src="SwizzleOp.js"></script>
>+
>+<script src="AddressSpace.js"></script>
>+<script src="AnonymousVariable.js"></script>
>+<script src="ArrayRefType.js"></script>
>+<script src="ArrayType.js"></script>
>+<script src="Assignment.js"></script>
>+<script src="AutoWrapper.js"></script>
>+<script src="Block.js"></script>
>+<script src="BoolLiteral.js"></script>
>+<script src="Break.js"></script>
>+<script src="CallExpression.js"></script>
>+<script src="CallFunction.js"></script>
>+<script src="Check.js"></script>
>+<script src="CheckLiteralTypes.js"></script>
>+<script src="CheckLoops.js"></script>
>+<script src="CheckRecursion.js"></script>
>+<script src="CheckRecursiveTypes.js"></script>
>+<script src="CheckReturns.js"></script>
>+<script src="CheckUnreachableCode.js"></script>
>+<script src="CheckWrapped.js"></script>
>+<script src="Checker.js"></script>
>+<script src="CloneProgram.js"></script>
>+<script src="CommaExpression.js"></script>
>+<script src="ConstexprFolder.js"></script>
>+<script src="Continue.js"></script>
>+<script src="ConvertPtrToArrayRefExpression.js"></script>
>+<script src="DoWhileLoop.js"></script>
>+<script src="DotExpression.js"></script>
>+<script src="DereferenceExpression.js"></script>
>+<script src="EArrayRef.js"></script>
>+<script src="EBuffer.js"></script>
>+<script src="EBufferBuilder.js"></script>
>+<script src="EPtr.js"></script>
>+<script src="EnumLiteral.js"></script>
>+<script src="EnumMember.js"></script>
>+<script src="EnumType.js"></script>
>+<script src="EvaluationCommon.js"></script>
>+<script src="Evaluator.js"></script>
>+<script src="ExpressionFinder.js"></script>
>+<script src="ExternalOrigin.js"></script>
>+<script src="Field.js"></script>
>+<script src="FindHighZombies.js"></script>
>+<script src="FlattenedStructOffsetGatherer.js"></script>
>+<script src="FloatLiteral.js"></script>
>+<script src="FloatLiteralType.js"></script>
>+<script src="FoldConstexprs.js"></script>
>+<script src="ForLoop.js"></script>
>+<script src="Func.js"></script>
>+<script src="FuncDef.js"></script>
>+<script src="FuncParameter.js"></script>
>+<script src="FunctionLikeBlock.js"></script>
>+<script src="HighZombieFinder.js"></script>
>+<script src="IdentityExpression.js"></script>
>+<script src="IfStatement.js"></script>
>+<script src="IndexExpression.js"></script>
>+<script src="InferTypesForCall.js"></script>
>+<script src="Inline.js"></script>
>+<script src="Inliner.js"></script>
>+<script src="IntLiteral.js"></script>
>+<script src="IntLiteralType.js"></script>
>+<script src="Intrinsics.js"></script>
>+<script src="LateChecker.js"></script>
>+<script src="Lexer.js"></script>
>+<script src="LexerToken.js"></script>
>+<script src="LiteralTypeChecker.js"></script>
>+<script src="LogicalExpression.js"></script>
>+<script src="LogicalNot.js"></script>
>+<script src="LoopChecker.js"></script>
>+<script src="MakeArrayRefExpression.js"></script>
>+<script src="MakePtrExpression.js"></script>
>+<script src="NameContext.js"></script>
>+<script src="NameFinder.js"></script>
>+<script src="NameResolver.js"></script>
>+<script src="NativeFunc.js"></script>
>+<script src="NativeType.js"></script>
>+<script src="NormalUsePropertyResolver.js"></script>
>+<script src="NullLiteral.js"></script>
>+<script src="NullType.js"></script>
>+<script src="OriginKind.js"></script>
>+<script src="OverloadResolutionFailure.js"></script>
>+<script src="Parse.js"></script>
>+<script src="Prepare.js"></script>
>+<script src="PropertyResolver.js"></script>
>+<script src="Program.js"></script>
>+<script src="ProgramWithUnnecessaryThingsRemoved.js"></script>
>+<script src="PtrType.js"></script>
>+<script src="ReadModifyWriteExpression.js"></script>
>+<script src="RecursionChecker.js"></script>
>+<script src="RecursiveTypeChecker.js"></script>
>+<script src="ResolveNames.js"></script>
>+<script src="ResolveOverloadImpl.js"></script>
>+<script src="ResolveProperties.js"></script>
>+<script src="ResolveTypeDefs.js"></script>
>+<script src="Return.js"></script>
>+<script src="ReturnChecker.js"></script>
>+<script src="ReturnException.js"></script>
>+<script src="StandardLibrary.js"></script>
>+<script src="StatementCloner.js"></script>
>+<script src="StructLayoutBuilder.js"></script>
>+<script src="StructType.js"></script>
>+<script src="Substitution.js"></script>
>+<script src="SwitchCase.js"></script>
>+<script src="SwitchStatement.js"></script>
>+<script src="SynthesizeEnumFunctions.js"></script>
>+<script src="SynthesizeStructAccessors.js"></script>
>+<script src="TernaryExpression.js"></script>
>+<script src="TrapStatement.js"></script>
>+<script src="TypeDef.js"></script>
>+<script src="TypeDefResolver.js"></script>
>+<script src="TypeOrVariableRef.js"></script>
>+<script src="TypeRef.js"></script>
>+<script src="TypedValue.js"></script>
>+<script src="UintLiteral.js"></script>
>+<script src="UintLiteralType.js"></script>
>+<script src="UnificationContext.js"></script>
>+<script src="UnreachableCodeChecker.js"></script>
>+<script src="VariableDecl.js"></script>
>+<script src="VariableRef.js"></script>
>+<script src="VisitingSet.js"></script>
>+<script src="WSyntaxError.js"></script>
>+<script src="WTrapError.js"></script>
>+<script src="WTypeError.js"></script>
>+<script src="WhileLoop.js"></script>
>+<script src="WrapChecker.js"></script>
>+
>+<script src="Test.js"></script>
>+
>+<script>
>+window.addEventListener("load", function() {
>+    prepare();
>+});
>+</script>
>+
>+</head>
>+<body>
>+<div id="messages"></div>
>+</body>
>+</html>
>diff --git a/Tools/WebGPUShadingLanguageRI/Myles.js b/Tools/WebGPUShadingLanguageRI/Myles.js
>new file mode 100644
>index 0000000000000000000000000000000000000000..4ca3c3bef726a704631731c3292ee409d81deaeb
>--- /dev/null
>+++ b/Tools/WebGPUShadingLanguageRI/Myles.js
>@@ -0,0 +1,38 @@
>+/*
>+ * Copyright (C) 2017 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. ``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
>+ * 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. 
>+ */
>+"use strict";
>+
>+if (this.window) {
>+    this.print = (text) => {
>+        var span = document.createElement("span");
>+        document.getElementById("messages").appendChild(span);
>+        span.innerHTML = text.replace(/ /g, "&nbsp;").replace(/\n/g, "<br>") + "<br>";
>+        window.scrollTo(0,document.body.scrollHeight);
>+    };
>+    this.preciseTime = () => performance.now() / 1000;
>+} else
>+    load("All.js");
>+
>+prepare("/internal/test", 0, "");
>diff --git a/Tools/WebGPUShadingLanguageRI/NameContext.js b/Tools/WebGPUShadingLanguageRI/NameContext.js
>index c31bc428294430bd4527796f4d7a9960539f6188..70cc890ffbe55312f4fd7f630a90dd3cb7e25ac5 100644
>--- a/Tools/WebGPUShadingLanguageRI/NameContext.js
>+++ b/Tools/WebGPUShadingLanguageRI/NameContext.js
>@@ -48,7 +48,7 @@ class NameContext {
>             return;
>         if (!thing.origin)
>             throw new Error("Thing does not have origin: " + thing);
>-        
>+
>         if (thing.isNative && !thing.implementation) {
>             if (!this._intrinsics)
>                 throw new Error("Native function in a scope that does not recognize intrinsics");
>@@ -67,9 +67,23 @@ class NameContext {
>                 throw new WTypeError(thing.origin.originString, "Cannot reuse type name for function: " + thing.name);
>             array.push(thing);
>             return;
>+        } else if (thing.kind == NativeParameterizedType) {
>+            this._set.add(thing);
>+            let array = this._map.get(thing.name);
>+            if (!array) {
>+                array = [];
>+                array.kind = NativeParameterizedType;
>+                this._map.set(thing.name, array);
>+            }
>+            if (array.kind != NativeParameterizedType)
>+                throw new WTypeError(thing.origin.originString, "Cannot reuse name for " + thing.name);
>+            array.push(thing);
>+            return;
>         }
>+
>         if (this._map.has(thing.name))
>             throw new WTypeError(thing.origin.originString, "Duplicate name: " + thing.name);
>+
>         this._set.add(thing);
>         this._map.set(thing.name, thing);
>     }
>@@ -100,17 +114,23 @@ class NameContext {
>             for (let func of thing)
>                 yield func;
>             return;
>+        } else if (thing.kind === NativeParameterizedType) {
>+            if (!(thing instanceof Array))
>+                throw new Error("NativeParameterized thing is not an array " + thing);
>+            for (let nativeParameterizedType of thing)
>+                yield nativeParameterizedType;
>+            return;
>         }
>         yield thing;
>     }
>     
>-    resolveFuncOverload(name, typeArguments, argumentTypes, returnType, allowEntryPoint = false)
>+    resolveFuncOverload(name, argumentTypes, returnType, allowEntryPoint = false)
>     {
>         let functions = this.get(Func, name);
>         if (!functions)
>             return {failures: []};
>         
>-        return resolveOverloadImpl(functions, typeArguments, argumentTypes, returnType, allowEntryPoint);
>+        return resolveOverloadImpl(functions, argumentTypes, returnType, allowEntryPoint);
>     }
>     
>     get currentStatement()
>diff --git a/Tools/WebGPUShadingLanguageRI/NameFinder.js b/Tools/WebGPUShadingLanguageRI/NameFinder.js
>index fc2fdbd032527ccc54cad71ba576b99221ee9c7d..69de328e1582d97d891396cd87d1d7f1f683643e 100644
>--- a/Tools/WebGPUShadingLanguageRI/NameFinder.js
>+++ b/Tools/WebGPUShadingLanguageRI/NameFinder.js
>@@ -43,12 +43,6 @@ class NameFinder extends Visitor {
>         this._worklist.push(name);
>     }
>     
>-    visitProtocolRef(node)
>-    {
>-        this.add(node.name);
>-        super.visitProtocolRef(node);
>-    }
>-    
>     visitTypeRef(node)
>     {
>         this.add(node.name);
>@@ -60,11 +54,6 @@ class NameFinder extends Visitor {
>         this.add(node.name);
>         super.visitVariableRef(node);
>     }
>-    
>-    visitTypeOrVariableRef(node)
>-    {
>-        this.add(node.name);
>-    }
> 
>     _handlePropertyAccess(node)
>     {
>diff --git a/Tools/WebGPUShadingLanguageRI/NameResolver.js b/Tools/WebGPUShadingLanguageRI/NameResolver.js
>index 731964fc78221ae73118981252232503bcfabc30..6ab35ce1c7786e62091588f735bb8cbc4a244ae9 100644
>--- a/Tools/WebGPUShadingLanguageRI/NameResolver.js
>+++ b/Tools/WebGPUShadingLanguageRI/NameResolver.js
>@@ -41,19 +41,14 @@ class NameResolver extends Visitor {
>         this._nameContext.doStatement(statement, () => statement.visit(this));
>     }
>     
>-    _visitTypeParametersAndBuildNameContext(node)
>+    _buildNameContext()
>     {
>-        let nameContext = new NameContext(this._nameContext);
>-        for (let typeParameter of node.typeParameters) {
>-            nameContext.add(typeParameter);
>-            typeParameter.visit(this);
>-        }
>-        return nameContext;
>+        return new NameContext(this._nameContext);
>     }
>     
>     visitFunc(node)
>     {
>-        let checker = new NameResolver(this._visitTypeParametersAndBuildNameContext(node));
>+        let checker = new NameResolver(this._buildNameContext(node));
>         node.returnType.visit(checker);
>         for (let parameter of node.parameters)
>             parameter.visit(checker);
>@@ -61,16 +56,14 @@ class NameResolver extends Visitor {
>     
>     visitFuncDef(node)
>     {
>-        let contextWithTypeParameters = this._visitTypeParametersAndBuildNameContext(node);
>-        let checkerWithTypeParameters = new NameResolver(contextWithTypeParameters);
>-        node.returnType.visit(checkerWithTypeParameters);
>-        let contextWithParameters = new NameContext(contextWithTypeParameters);
>+        let innerContext = this._buildNameContext();
>+        let innerChecker = new NameResolver(innerContext);
>+        node.returnType.visit(innerChecker);
>         for (let parameter of node.parameters) {
>-            parameter.visit(checkerWithTypeParameters);
>-            contextWithParameters.add(parameter);
>+            parameter.visit(innerChecker);
>+            innerContext.add(parameter);
>         }
>-        let checkerWithParameters = new NameResolver(contextWithParameters);
>-        node.body.visit(checkerWithParameters);
>+        node.body.visit(innerChecker);
>     }
>     
>     visitBlock(node)
>@@ -115,41 +108,9 @@ class NameResolver extends Visitor {
>         node.body.visit(newResolver);
>     }
>     
>-    visitProtocolDecl(node)
>-    {
>-        for (let parent of node.extends)
>-            parent.visit(this);
>-        let nameContext = new NameContext(this._nameContext);
>-        nameContext.add(node.typeVariable);
>-        let checker = new NameResolver(nameContext);
>-        for (let signature of node.signatures)
>-            signature.visit(checker);
>-    }
>-    
>-    visitProtocolRef(node)
>-    {
>-        let result = this._nameContext.get(Protocol, node.name);
>-        if (!result)
>-            throw new WTypeError(node.origin.originString, "Could not find protocol named " + node.name);
>-        node.protocolDecl = result;
>-    }
>-    
>-    visitProtocolFuncDecl(node)
>-    {
>-        this.visitFunc(node);
>-        let funcs = this._nameContext.get(Func, node.name);
>-        if (!funcs)
>-            throw new WTypeError(node.origin.originString, "Cannot find any functions named " + node.name);
>-        node.possibleOverloads = funcs;
>-    }
>-    
>     visitTypeDef(node)
>     {
>         let nameContext = new NameContext(this._nameContext);
>-        for (let typeParameter of node.typeParameters) {
>-            typeParameter.visit(this);
>-            nameContext.add(typeParameter);
>-        }
>         let checker = new NameResolver(nameContext);
>         node.type.visit(checker);
>     }
>@@ -157,15 +118,51 @@ class NameResolver extends Visitor {
>     visitStructType(node)
>     {
>         let nameContext = new NameContext(this._nameContext);
>-        for (let typeParameter of node.typeParameters) {
>-            typeParameter.visit(this);
>-            nameContext.add(typeParameter);
>-        }
>         let checker = new NameResolver(nameContext);
>         for (let field of node.fields)
>             field.visit(checker);
>     }
>     
>+    visitTypeRef(node)
>+    {
>+        for (let arg of node.typeArguments)
>+            arg.visit(this);
>+        
>+        let type = node.type;
>+        if (!type) {
>+            type = this._nameContext.get(Type, node.name);
>+            if (type)
>+                node.type = type;
>+            else { 
>+                let possibleTypes = this._nameContext.get(NativeParameterizedType, node.name);
>+                for (let possibleType of possibleTypes) {
>+                    // At this point the possible type arguments might be unresolved TypeRef, we ensure they are concrete types.
>+                    possibleType.visit(this);
>+                    if (possibleType.typeArguments.length == node.typeArguments.length) {
>+                        let argumentsMatch = true;
>+                        for (let i = 0; argumentsMatch && i < possibleType.typeArguments.length; i++) {
>+                            if (!node.typeArguments[i].equals(possibleType.typeArguments[i]))
>+                                argumentsMatch = false;
>+                        }
>+
>+                        if (argumentsMatch) {
>+                            type = possibleType;
>+                            break;
>+                        }
>+                    }
>+                }
>+
>+                if (!type)
>+                    throw new WTypeError(node.origin.originString, `Could not find type named ${node.name} with arguments ${node.typeArguments.join(", ")}`);
>+            }
>+
>+            if (!type)
>+                throw new WTypeError(node.origin.originString, "Could not find type named " + node.name);
>+
>+            node.type = type;
>+        }
>+    }
>+
>     _resolveTypeArguments(typeArguments)
>     {
>         for (let i = 0; i < typeArguments.length; ++i) {
>@@ -181,36 +178,16 @@ class NameResolver extends Visitor {
>                 else
>                     throw new WTypeError(typeArgument.origin.originString, "Type argument resolved to wrong kind of thing: " + thing.kind);
>             }
>-            
>-            if (typeArgument[i] instanceof Value
>-                && !typeArgument[i].isConstexpr)
>+            if (typeArgument[i] instanceof Value && !typeArgument[i].isConstexpr)
>                 throw new WTypeError(typeArgument[i].origin.originString, "Expected constexpr");
>         }
>     }
>     
>-    visitTypeRef(node)
>+    visitNativeType(node)
>     {
>         this._resolveTypeArguments(node.typeArguments);
>-        
>-        let type = node.type;
>-        if (!type) {
>-            type = this._nameContext.get(Type, node.name);
>-            if (!type)
>-                throw new WTypeError(node.origin.originString, "Could not find type named " + node.name);
>-            node.type = type;
>-        }
>-        
>-        if (type.typeParameters.length != node.typeArguments.length)
>-            throw new WTypeError(node.origin.originString, "Wrong number of type arguments (passed " + node.typeArguments.length + ", expected " + type.typeParameters.length + ")");
>-        for (let i = 0; i < type.typeParameters.length; ++i) {
>-            let parameterIsType = type.typeParameters[i] instanceof TypeVariable;
>-            let argumentIsType = node.typeArguments[i] instanceof Type;
>-            node.typeArguments[i].visit(this);
>-            if (parameterIsType && !argumentIsType)
>-                throw new WTypeError(node.origin.originString, "Expected type, but got value at argument #" + i);
>-            if (!parameterIsType && argumentIsType)
>-                throw new WTypeError(node.origin.originString, "Expected value, but got type at argument #" + i);
>-        }
>+        for(let typeArgument of node.typeArguments)
>+            typeArgument.visit(this);
>     }
>     
>     visitReferenceType(node)
>@@ -279,8 +256,6 @@ class NameResolver extends Visitor {
>     
>     visitCallExpression(node)
>     {
>-        this._resolveTypeArguments(node.typeArguments);
>-        
>         let funcs = this._nameContext.get(Func, node.name);
>         if (funcs)
>             node.possibleOverloads = funcs;
>@@ -296,5 +271,11 @@ class NameResolver extends Visitor {
>         
>         super.visitCallExpression(node);
>     }
>-}
> 
>+    visitVectorType(node)
>+    {
>+        for (let arg of node.typeArguments)
>+            arg.visit(this);
>+    }
>+}
>+ 
>\ No newline at end of file
>diff --git a/Tools/WebGPUShadingLanguageRI/NativeFunc.js b/Tools/WebGPUShadingLanguageRI/NativeFunc.js
>index a553352d9aee60bca62ad6e123288b8905182487..dc0ff781b692e184627864850ef68dd35b9a8f05 100644
>--- a/Tools/WebGPUShadingLanguageRI/NativeFunc.js
>+++ b/Tools/WebGPUShadingLanguageRI/NativeFunc.js
>@@ -25,13 +25,12 @@
> "use strict";
> 
> class NativeFunc extends Func {
>-    constructor(origin, name, returnType, typeParameters, parameters, isCast, shaderType)
>+    constructor(origin, name, returnType, parameters, isCast, shaderType)
>     {
>-        super(origin, name, returnType, typeParameters, parameters, isCast, shaderType);
>+        super(origin, name, returnType, parameters, isCast, shaderType);
>         this.isRestricted = false;
>         this.implementation = null;
>         this._implementationData = null;
>-        this.instantiateImplementation = (substitution) => {};
>         this.visitImplementationData = (implementationData, visitor) => null;
>         this.didLayoutStructsInImplementationData = implementationData => null;
>     }
>diff --git a/Tools/WebGPUShadingLanguageRI/NativeFuncInstance.js b/Tools/WebGPUShadingLanguageRI/NativeFuncInstance.js
>index c99b78263535a70d9309626d585035900105d411..bb47c82a15add187ac236a079e531ca5c4f62d32 100644
>--- a/Tools/WebGPUShadingLanguageRI/NativeFuncInstance.js
>+++ b/Tools/WebGPUShadingLanguageRI/NativeFuncInstance.js
>@@ -27,7 +27,7 @@
> class NativeFuncInstance extends Func {
>     constructor(func, returnType, parameters, isCast, shaderType, implementationData)
>     {
>-        super(func.origin, func.name, returnType, [], parameters, isCast, shaderType);
>+        super(func.origin, func.name, returnType, parameters, isCast, shaderType);
>         this._func = func;
>         this._implementationData = implementationData;
>     }
>diff --git a/Tools/WebGPUShadingLanguageRI/NativeParameterizedType.js b/Tools/WebGPUShadingLanguageRI/NativeParameterizedType.js
>new file mode 100644
>index 0000000000000000000000000000000000000000..ac1d4a02f4c1202f50eafa85250a680d131430a1
>--- /dev/null
>+++ b/Tools/WebGPUShadingLanguageRI/NativeParameterizedType.js
>@@ -0,0 +1,79 @@
>+/*
>+ * Copyright (C) 2017 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. ``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
>+ * 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. 
>+ */
>+"use strict";
>+
>+class NativeParameterizedType extends NativeType {
>+    constructor(origin, name, typeArguments)
>+    {
>+        if (!(typeArguments instanceof Array))
>+            throw new Error("type arguments not array: " + typeArguments);
>+        super(origin, name);
>+
>+        this._typeArguments = typeArguments;
>+    }
>+
>+    get isPrimitive() { return true; }
>+
>+    static fromNameAndTypeArguments(origin, name, typeArguments)
>+    {
>+        switch (name) {
>+        case "vector":
>+            return new VectorType(origin, name, typeArguments);
>+        case "matrix":
>+            throw new Error("TODO: Implement NativeParameterizedType.fromNameAndTypeArguments case \"matrix\"");
>+        case "sampler":
>+        case "Texture1D":
>+        case "RWTexture1D":
>+        case "Texture1DArray":
>+        case "RWTexture1DArray":
>+        case "Texture2D":
>+        case "RWTexture2D":
>+        case "Texture2DArray":
>+        case "RWTexture2DArray":
>+        case "Texture3D":
>+        case "RWTexture3D":
>+        case "TextureCube":
>+        case "TextureDepth2D":
>+        case "RWTextureDepth2D":
>+        case "TextureDepth2DArray":
>+        case "RWTextureDepth2DArray":
>+        case "TextureDepthCube":
>+            // FIXME: Verify the type argument
>+            return new NativeParameterizedType(origin, name, typeArguments);
>+        default:
>+            throw new Error(`Unrecognized native type ${name}`);
>+        }
>+    }
>+
>+    get kind() { return NativeParameterizedType; }
>+    
>+    get typeArguments() { return this._typeArguments; }
>+    
>+    toString()
>+    {
>+        return `native typedef ${this.name}<${this.typeArguments.join(", ")}>`;
>+    }
>+}
>+
>diff --git a/Tools/WebGPUShadingLanguageRI/NativeType.js b/Tools/WebGPUShadingLanguageRI/NativeType.js
>index b8b1a47330b5fd51ff021af06586844c2acba8ea..0b94004243e7ca342aa59eaac074e57cdcaf1636 100644
>--- a/Tools/WebGPUShadingLanguageRI/NativeType.js
>+++ b/Tools/WebGPUShadingLanguageRI/NativeType.js
>@@ -25,14 +25,11 @@
> "use strict";
> 
> class NativeType extends Type {
>-    constructor(origin, name, typeParameters)
>+    constructor(origin, name)
>     {
>-        if (!(typeParameters instanceof Array))
>-            throw new Error("type parameters not array: " + typeParameters);
>         super();
>         this._origin = origin;
>         this._name = name;
>-        this._typeParameters = typeParameters;
>         this._isNumber = false;
>         this._isInt = false;
>         this._isFloating = false;
>@@ -40,8 +37,8 @@ class NativeType extends Type {
>     }
>     
>     get origin() { return this._origin; }
>+    get baseName() { return this._name; }
>     get name() { return this._name; }
>-    get typeParameters() { return this._typeParameters; }
>     get isNative() { return true; }
>     
>     // We let Intrinsics.js set these as it likes.
>@@ -54,18 +51,9 @@ class NativeType extends Type {
>     get isPrimitive() { return this._isPrimitive; }
>     set isPrimitive(value) { this._isPrimitive = value; }
>     
>-    instantiate(typeArguments)
>-    {
>-        if (typeArguments.length != this.typeParameters.length)
>-            throw new Error("Wrong number of type arguments to instantiation");
>-        if (!typeArguments.length)
>-            return this;
>-        return new NativeTypeInstance(this, typeArguments);
>-    }
>-    
>     toString()
>     {
>-        return "native typedef " + this.name + "<" + this.typeParameters + ">";
>+        return "native typedef " + this.name;
>     }
> }
> 
>diff --git a/Tools/WebGPUShadingLanguageRI/NativeTypeInstance.js b/Tools/WebGPUShadingLanguageRI/NativeTypeInstance.js
>deleted file mode 100644
>index ca39e777870049ed22d7041a52014cc8e69cbc4f..0000000000000000000000000000000000000000
>--- a/Tools/WebGPUShadingLanguageRI/NativeTypeInstance.js
>+++ /dev/null
>@@ -1,58 +0,0 @@
>-/*
>- * Copyright (C) 2017 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. ``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
>- * 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. 
>- */
>-"use strict";
>-
>-class NativeTypeInstance extends Type {
>-    constructor(type, typeArguments)
>-    {
>-        super();
>-        this._type = type;
>-        this._typeArguments = typeArguments;
>-    }
>-    
>-    get type() { return this._type; }
>-    get typeArguments() { return this._typeArguments; }
>-    get isPrimitive() { return this._type.isPrimitive; }
>-    get isNative() { return true; }
>-    
>-    unifyImpl(unificationContext, other)
>-    {
>-        if (this.type != other.type)
>-            return false;
>-        if (this.typeArguments.length != other.typeArguments.length)
>-            return false;
>-        for (let i = 0; i < this.typeArguments.length; ++i) {
>-            if (!this.typeArguments[i].unify(unificationContext, other.typeArguments[i]))
>-                return false;
>-        }
>-        return true;
>-    }
>-    
>-    toString()
>-    {
>-        return this.type + "<" + this.typeArguments + ">";
>-    }
>-}
>-
>diff --git a/Tools/WebGPUShadingLanguageRI/Node.js b/Tools/WebGPUShadingLanguageRI/Node.js
>index 881030130773e70ea88e0ab597974cf561f9d5e4..efe4a1a482b4721f2fb3fe58776dada6af77d9c2 100644
>--- a/Tools/WebGPUShadingLanguageRI/Node.js
>+++ b/Tools/WebGPUShadingLanguageRI/Node.js
>@@ -88,9 +88,9 @@ class Node {
>     get isLiteral() { return false; }
>     
>     get isNative() { return false; }
>-    
>+
>     conversionCost(unificationContext) { return 0; }
>-    
>+
>     equals(other)
>     {
>         let unificationContext = new UnificationContext();
>@@ -123,11 +123,4 @@ class Node {
>     {
>         return this.visit(new Substitution(parameters, argumentList));
>     }
>-    
>-    substituteToUnification(parameters, unificationContext)
>-    {
>-        return this.substitute(
>-            parameters,
>-            parameters.map(type => unificationContext.find(type)));
>-    }
> }
>diff --git a/Tools/WebGPUShadingLanguageRI/NormalUsePropertyResolver.js b/Tools/WebGPUShadingLanguageRI/NormalUsePropertyResolver.js
>index df45d7e4eb1149bef31582961515f7f96f4e0115..9af19ee0e7e2fa4c56a40d0bbb59cd7a8c8afea1 100644
>--- a/Tools/WebGPUShadingLanguageRI/NormalUsePropertyResolver.js
>+++ b/Tools/WebGPUShadingLanguageRI/NormalUsePropertyResolver.js
>@@ -34,5 +34,12 @@ class NormalUsePropertyResolver extends Rewriter {
>     {
>         return super.visitIndexExpression(node).rewriteAfterCloning();
>     }
>+
>+    visitTernaryExpression(node)
>+    {
>+        let result = super.visitTernaryExpression(node);
>+        result.isLValue = node.isLValue;
>+        return result;
>+    }
> }
> 
>diff --git a/Tools/WebGPUShadingLanguageRI/OperatorAnderIndex.js b/Tools/WebGPUShadingLanguageRI/OperatorAnderIndex.js
>new file mode 100644
>index 0000000000000000000000000000000000000000..af4dec079f72f4d1bd47f7339cbd4a1d3534b423
>--- /dev/null
>+++ b/Tools/WebGPUShadingLanguageRI/OperatorAnderIndex.js
>@@ -0,0 +1,71 @@
>+/*
>+ * Copyright (C) 2017 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. ``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
>+ * 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.
>+ */
>+"use strict";
>+
>+class OperatorAnderIndexer {
>+    constructor(baseTypeName, addressSpace)
>+    {
>+        this._baseTypeName = baseTypeName;
>+        this._addressSpace = addressSpace;
>+    }
>+
>+    get addressSpace() { return this._addressSpace; }
>+    get baseTypeName() { return this._baseTypeName; }
>+
>+    toString()
>+    {
>+        return `native ${this.baseTypeName}* ${this.addressSpace} operator&[](${this.baseTypeName}[] ${this.addressSpace},uint)`;
>+    }
>+
>+    static functions()
>+    {
>+        if (!this._functions) {
>+            this._functions = [];
>+
>+            const typeNames = [ "uint", "int", "float", "bool" ].concat(allVectorTypeNames());
>+            const addressSpaces = [ "thread", "threadgroup", "device", "constant" ];
>+
>+            for (let addressSpace of addressSpaces) {
>+                for (let typeName of typeNames)
>+                    this._functions.push(new OperatorAnderIndexer(typeName, addressSpace));
>+            }
>+        }
>+        return this._functions;
>+    }
>+
>+    instantiateImplementation(func)
>+    {
>+        func.implementation = ([ref, index], node) => {
>+            ref = ref.loadValue();
>+            if (!ref)
>+                throw new WTrapError(node.origin.originString, "Null dereference");
>+            index = index.loadValue();
>+            if (index > ref.length)
>+                throw new WTrapError(node.origin.originString, "Array index " + index + " is out of bounds of " + ref);
>+            return EPtr.box(ref.ptr.plus(index * node.argumentTypes[0].elementType.size));
>+        };
>+        func.implementationData = this;
>+    }
>+}
>\ No newline at end of file
>diff --git a/Tools/WebGPUShadingLanguageRI/OperatorArrayRefLength.js b/Tools/WebGPUShadingLanguageRI/OperatorArrayRefLength.js
>new file mode 100644
>index 0000000000000000000000000000000000000000..c350d10aac6b0c5ff00736b2ea18013481fbaa73
>--- /dev/null
>+++ b/Tools/WebGPUShadingLanguageRI/OperatorArrayRefLength.js
>@@ -0,0 +1,52 @@
>+/*
>+ * Copyright (C) 2017 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. ``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
>+ * 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.
>+ */
>+"use strict";
>+
>+class OperatorArrayRefLength {
>+    constructor(baseTypeName, addressSpace)
>+    {
>+        this._baseTypeName = baseTypeName;
>+        this._addressSpace = addressSpace;
>+    }
>+
>+    get addressSpace() { return this._addressSpace; }
>+    get baseTypeName() { return this._baseTypeName; }
>+
>+    toString()
>+    {
>+        return `native uint32 ${this.addressSpace} operator.length(${this.baseTypeName}[] ${this.addressSpace})`;
>+    }
>+
>+    instantiateImplementation(func)
>+    {
>+        func.implementation = ([ref], node) => {
>+            ref = ref.loadValue();
>+            if (!ref)
>+                return EPtr.box(0);
>+            return EPtr.box(ref.length);
>+        };
>+        func.implementationData = this;
>+    }
>+}
>\ No newline at end of file
>diff --git a/Tools/WebGPUShadingLanguageRI/OperatorBool.js b/Tools/WebGPUShadingLanguageRI/OperatorBool.js
>new file mode 100644
>index 0000000000000000000000000000000000000000..ad488351293493b3322a7944c08eb9777d86a540
>--- /dev/null
>+++ b/Tools/WebGPUShadingLanguageRI/OperatorBool.js
>@@ -0,0 +1,66 @@
>+/*
>+ * Copyright (C) 2017 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. ``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
>+ * 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.
>+ */
>+"use strict";
>+
>+class OperatorBool {
>+    constructor(baseTypeName)
>+    {
>+        this._baseTypeName = baseTypeName;
>+    }
>+
>+    get baseTypeName() { return this._baseTypeName; }
>+
>+    toString()
>+    {
>+        return `native operator bool(${this.baseTypeName})`;
>+    }
>+
>+    static functions()
>+    {
>+        if (!OperatorBool._functions) {
>+            OperatorBool._functions = [];
>+
>+            // bool is not included because this is generated by the copy constructor.
>+            const typeNames = [ "uint8", "uint", "int", "float" ].concat(allVectorTypeNames());
>+
>+            for (let typeName of typeNames)
>+                OperatorBool._functions.push(new OperatorBool(typeName));
>+        }
>+        return OperatorBool._functions;
>+    }
>+
>+    instantiateImplementation(func)
>+    {
>+        func.implementation = ([ref], node) => {
>+            const size = node.argumentTypes[0].size;
>+            for (let i = 0; i < size; ++i) {
>+                if (!!ref.get(i))
>+                    return EPtr.box(true);
>+            }
>+            return EPtr.box(false);
>+        }
>+        func.implementationData = this;
>+    }
>+}
>\ No newline at end of file
>diff --git a/Tools/WebGPUShadingLanguageRI/Parse.js b/Tools/WebGPUShadingLanguageRI/Parse.js
>index 6d2b431615601ab9dd3d0938fbfb385ee2a4daf1..3cdfa6bc3e5c66c7d0f581f5729f5e4112a5ef12 100644
>--- a/Tools/WebGPUShadingLanguageRI/Parse.js
>+++ b/Tools/WebGPUShadingLanguageRI/Parse.js
>@@ -24,6 +24,8 @@
>  */
> "use strict";
> 
>+var asdf = 0;
>+
> function parse(program, origin, originKind, lineNumberOffset, text)
> {
>     let lexer = new Lexer(origin, originKind, lineNumberOffset, text);
>@@ -121,12 +123,6 @@ function parse(program, origin, originKind, lineNumberOffset, text)
>         return result;
>     }
>     
>-    function parseProtocolRef()
>-    {
>-        let protocolToken = consumeKind("identifier");
>-        return new ProtocolRef(protocolToken, protocolToken.text);
>-    }
>-    
>     function consumeEndOfTypeArgs()
>     {
>         let rightShift = tryConsume(">>");
>@@ -136,34 +132,6 @@ function parse(program, origin, originKind, lineNumberOffset, text)
>             consume(">");
>     }
>     
>-    function parseTypeParameters()
>-    {
>-        if (!test("<"))
>-            return [];
>-        
>-        let result = [];
>-        consume("<");
>-        while (!test(">")) {
>-            let constexpr = lexer.backtrackingScope(() => {
>-                let type = parseType();
>-                let name = consumeKind("identifier");
>-                assertNext(",", ">", ">>");
>-                return new ConstexprTypeParameter(type.origin, name.text, type);
>-            });
>-            if (constexpr)
>-                result.push(constexpr);
>-            else {
>-                let name = consumeKind("identifier");
>-                let protocol = tryConsume(":") ? parseProtocolRef() : null;
>-                result.push(new TypeVariable(name, name.text, protocol));
>-            }
>-            if (!tryConsume(","))
>-                break;
>-        }
>-        consumeEndOfTypeArgs();
>-        return result;
>-    }
>-    
>     function parseTerm()
>     {
>         let token;
>@@ -222,7 +190,7 @@ function parse(program, origin, originKind, lineNumberOffset, text)
>     {
>         let token;
>         if (token = tryConsume("-"))
>-            return new CallExpression(token, "operator" + token.text, [], [parseTerm()]);
>+            return new CallExpression(token, "operator" + token.text, [parseTerm()]);
>         let left = parseTerm();
>         if (token = tryConsume("."))
>             left = new DotExpression(token, left, consumeKind("identifier").text);
>@@ -233,7 +201,7 @@ function parse(program, origin, originKind, lineNumberOffset, text)
>     {
>         if (!test("<"))
>             return [];
>-        
>+
>         let result = [];
>         consume("<");
>         while (!test(">")) {
>@@ -248,13 +216,13 @@ function parse(program, origin, originKind, lineNumberOffset, text)
>             // In the future we'll allow constexprs to do more things, and then we'll still have
>             // the problem that something of the form T[1][2][3]... can either be a type or a
>             // constexpr, and we can figure out in the checker which it is.
>-            let typeOrVariableRef = lexer.backtrackingScope(() => {
>+            let typeRef = lexer.backtrackingScope(() => {
>                 let result = consumeKind("identifier");
>                 assertNext(",", ">", ">>");
>-                return new TypeOrVariableRef(result, result.text);
>+                return new TypeRef(result, result.text, []);
>             });
>-            if (typeOrVariableRef)
>-                result.push(typeOrVariableRef);
>+            if (typeRef)
>+                result.push(typeRef);
>             else {
>                 let constexpr = lexer.backtrackingScope(() => {
>                     let result = parseConstexpr();
>@@ -273,7 +241,7 @@ function parse(program, origin, originKind, lineNumberOffset, text)
>         return result;
>     }
>     
>-    function parseType()
>+    function parseType(allowTypeArguments = true)
>     {
>         let token;
>         let addressSpace;
>@@ -282,7 +250,7 @@ function parse(program, origin, originKind, lineNumberOffset, text)
>             addressSpace = token.text;
>         
>         let name = consumeKind("identifier");
>-        let typeArguments = parseTypeArguments();
>+        let typeArguments = allowTypeArguments ? parseTypeArguments() : [];
>         let type = new TypeRef(name, name.text, typeArguments);
>         
>         function getAddressSpace()
>@@ -318,11 +286,10 @@ function parse(program, origin, originKind, lineNumberOffset, text)
>     {
>         let origin = consume("typedef");
>         let name = consumeKind("identifier").text;
>-        let typeParameters = parseTypeParameters();
>         consume("=");
>-        let type = parseType();
>+        let type = parseType(true);
>         consume(";");
>-        return new TypeDef(origin, name, typeParameters, type);
>+        return new TypeDef(origin, name, type);
>     }
>     
>     function genericParseLeft(texts, nextParser, constructor)
>@@ -339,13 +306,12 @@ function parse(program, origin, originKind, lineNumberOffset, text)
>         return genericParseLeft(
>             texts, nextParser,
>             (token, left, right) =>
>-                new CallExpression(token, "operator" + token.text, [], [left, right]));
>+                new CallExpression(token, "operator" + token.text, [left, right]));
>     }
>     
>     function parseCallExpression()
>     {
>         let name = consumeKind("identifier");
>-        let typeArguments = parseTypeArguments();
>         consume("(");
>         let argumentList = [];
>         while (!test(")")) {
>@@ -355,7 +321,7 @@ function parse(program, origin, originKind, lineNumberOffset, text)
>                 break;
>         }
>         consume(")");
>-        let result = new CallExpression(name, name.text, typeArguments, argumentList);
>+        let result = new CallExpression(name, name.text, argumentList);
>         return result;
>     }
>     
>@@ -363,7 +329,6 @@ function parse(program, origin, originKind, lineNumberOffset, text)
>     {
>         return lexer.testScope(() => {
>             consumeKind("identifier");
>-            parseTypeArguments();
>             consume("(");
>         });
>     }
>@@ -381,7 +346,7 @@ function parse(program, origin, originKind, lineNumberOffset, text)
>         if (name == "operator")
>             throw new Error("Invalid name: " + name);
>         
>-        return new CallExpression(token, name, [], args);
>+        return new CallExpression(token, name, args);
>     }
>     
>     function finishParsingPostIncrement(token, left)
>@@ -454,7 +419,7 @@ function parse(program, origin, originKind, lineNumberOffset, text)
>         if (test("++", "--"))
>             return parsePreIncrement();
>         if (token = tryConsume("+", "-", "~"))
>-            return new CallExpression(token, "operator" + token.text, [], [parsePossiblePrefix()]);
>+            return new CallExpression(token, "operator" + token.text, [parsePossiblePrefix()]);
>         if (token = tryConsume("*"))
>             return new DereferenceExpression(token, parsePossiblePrefix());
>         if (token = tryConsume("&"))
>@@ -463,7 +428,7 @@ function parse(program, origin, originKind, lineNumberOffset, text)
>             return new MakeArrayRefExpression(token, parsePossiblePrefix());
>         if (token = tryConsume("!")) {
>             let remainder = parsePossiblePrefix();
>-            return new LogicalNot(token, new CallExpression(remainder.origin, "bool", [], [remainder]));
>+            return new LogicalNot(token, new CallExpression(remainder.origin, "bool", [remainder]));
>         }
>         return parsePossibleSuffix();
>     }
>@@ -493,7 +458,7 @@ function parse(program, origin, originKind, lineNumberOffset, text)
>         return genericParseLeft(
>             ["==", "!="], parsePossibleRelationalInequality,
>             (token, left, right) => {
>-                let result = new CallExpression(token, "operator==", [], [left, right]);
>+                let result = new CallExpression(token, "operator==", [left, right]);
>                 if (token.text == "!=")
>                     result = new LogicalNot(token, result);
>                 return result;
>@@ -519,7 +484,7 @@ function parse(program, origin, originKind, lineNumberOffset, text)
>     {
>         return genericParseLeft(
>             texts, nextParser,
>-            (token, left, right) => new LogicalExpression(token, token.text, new CallExpression(left.origin, "bool", [], [left]), new CallExpression(right.origin, "bool", [], [right])));
>+            (token, left, right) => new LogicalExpression(token, token.text, new CallExpression(left.origin, "bool", [left]), new CallExpression(right.origin, "bool", [right])));
>     }
>     
>     function parsePossibleLogicalAnd()
>@@ -538,7 +503,10 @@ function parse(program, origin, originKind, lineNumberOffset, text)
>         let operator = tryConsume("?");
>         if (!operator)
>             return predicate;
>-        return new TernaryExpression(operator, predicate, parsePossibleAssignment(), parsePossibleAssignment());
>+        let bodyExpression = parsePossibleAssignment();
>+        consume(":");
>+        let elseExpression = parsePossibleAssignment();
>+        return new TernaryExpression(operator, predicate, bodyExpression, elseExpression);
>     }
>     
>     function parsePossibleAssignment(mode)
>@@ -547,7 +515,7 @@ function parse(program, origin, originKind, lineNumberOffset, text)
>         let operator = tryConsume("=", "+=", "-=", "*=", "/=", "%=", "^=", "|=", "&=");
>         if (!operator) {
>             if (mode == "required")
>-                lexer.fail("Expected assignment");
>+                lexer.fail("Expected assignment: " + lexer._text.substring(lexer._index));
>             return lhs;
>         }
>         if (operator.text == "=")
>@@ -656,7 +624,7 @@ function parse(program, origin, originKind, lineNumberOffset, text)
>         let elseBody;
>         if (tryConsume("else"))
>             elseBody = parseStatement();
>-        return new IfStatement(origin, new CallExpression(conditional.origin, "bool", [], [conditional]), body, elseBody);
>+        return new IfStatement(origin, new CallExpression(conditional.origin, "bool", [conditional]), body, elseBody);
>     }
> 
>     function parseWhile()
>@@ -666,7 +634,7 @@ function parse(program, origin, originKind, lineNumberOffset, text)
>         let conditional = parseExpression();
>         consume(")");
>         let body = parseStatement();
>-        return new WhileLoop(origin, new CallExpression(conditional.origin, "bool", [], [conditional]), body);
>+        return new WhileLoop(origin, new CallExpression(conditional.origin, "bool", [conditional]), body);
>     }
> 
>     function parseFor()
>@@ -687,7 +655,7 @@ function parse(program, origin, originKind, lineNumberOffset, text)
>         else {
>             condition = parseExpression();
>             consume(";");
>-            condition = new CallExpression(condition.origin, "bool", [], [condition]);
>+            condition = new CallExpression(condition.origin, "bool", [condition]);
>         }
>         let increment;
>         if (tryConsume(")"))
>@@ -708,7 +676,7 @@ function parse(program, origin, originKind, lineNumberOffset, text)
>         consume("(");
>         let conditional = parseExpression();
>         consume(")");
>-        return new DoWhileLoop(origin, body, new CallExpression(conditional.origin, "bool", [], [conditional]));
>+        return new DoWhileLoop(origin, body, new CallExpression(conditional.origin, "bool", [conditional]));
>     }
>     
>     function parseVariableDecls()
>@@ -858,13 +826,11 @@ function parse(program, origin, originKind, lineNumberOffset, text)
>         let origin;
>         let returnType;
>         let name;
>-        let typeParameters;
>         let isCast;
>         let shaderType;
>         let operatorToken = tryConsume("operator");
>         if (operatorToken) {
>             origin = operatorToken;
>-            typeParameters = parseTypeParameters();
>             returnType = parseType();
>             name = "operator cast";
>             isCast = true;
>@@ -877,44 +843,17 @@ function parse(program, origin, originKind, lineNumberOffset, text)
>             } else
>                 origin = returnType.origin;
>             name = parseFuncName();
>-            typeParameters = parseTypeParameters();
>             isCast = false;
>         }
>         let parameters = parseParameters();
>-        return new Func(origin, name, returnType, typeParameters, parameters, isCast, shaderType);
>+        return new Func(origin, name, returnType, parameters, isCast, shaderType);
>     }
> 
>-    function parseProtocolFuncDecl()
>-    {
>-        let func = parseFuncDecl();
>-        return new ProtocolFuncDecl(func.origin, func.name, func.returnType, func.typeParameters, func.parameters, func.isCast, func.shaderType);
>-    }
>-    
>     function parseFuncDef()
>     {
>         let func = parseFuncDecl();
>         let body = parseBlock();
>-        return new FuncDef(func.origin, func.name, func.returnType, func.typeParameters, func.parameters, body, func.isCast, func.shaderType);
>-    }
>-    
>-    function parseProtocolDecl()
>-    {
>-        let origin = consume("protocol");
>-        let name = consumeKind("identifier").text;
>-        let result = new ProtocolDecl(origin, name);
>-        if (tryConsume(":")) {
>-            while (!test("{")) {
>-                result.addExtends(parseProtocolRef());
>-                if (!tryConsume(","))
>-                    break;
>-            }
>-        }
>-        consume("{");
>-        while (!tryConsume("}")) {
>-            result.add(parseProtocolFuncDecl());
>-            consume(";");
>-        }
>-        return result;
>+        return new FuncDef(func.origin, func.name, func.returnType, func.parameters, body, func.isCast, func.shaderType);
>     }
>     
>     function parseField()
>@@ -929,8 +868,7 @@ function parse(program, origin, originKind, lineNumberOffset, text)
>     {
>         let origin = consume("struct");
>         let name = consumeKind("identifier").text;
>-        let typeParameters = parseTypeParameters();
>-        let result = new StructType(origin, name, typeParameters);
>+        let result = new StructType(origin, name);
>         consume("{");
>         while (!tryConsume("}"))
>             result.add(parseField());
>@@ -941,7 +879,7 @@ function parse(program, origin, originKind, lineNumberOffset, text)
>     {
>         let func = parseFuncDecl();
>         consume(";");
>-        return new NativeFunc(func.origin, func.name, func.returnType, func.typeParameters, func.parameters, func.isCast, func.shaderType);
>+        return new NativeFunc(func.origin, func.name, func.returnType, func.parameters, func.isCast, func.shaderType);
>     }
>     
>     function parseNative()
>@@ -949,9 +887,12 @@ function parse(program, origin, originKind, lineNumberOffset, text)
>         let origin = consume("native");
>         if (tryConsume("typedef")) {
>             let name = consumeKind("identifier");
>-            let parameters = parseTypeParameters();
>+            let args = parseTypeArguments();
>             consume(";");
>-            return new NativeType(origin, name.text, parameters);
>+            if (args.length)
>+                return NativeParameterizedType.fromNameAndTypeArguments(origin, name.text, args);
>+            else
>+                return new NativeType(origin, name.text);
>         }
>         return parseNativeFunc();
>     }
>@@ -985,7 +926,7 @@ function parse(program, origin, originKind, lineNumberOffset, text)
>         if (tryConsume(":"))
>             baseType = parseType();
>         else
>-            baseType = new TypeRef(name, "int", []);
>+            baseType = new TypeRef(name, "int");
>         consume("{");
>         let result = new EnumType(name, name.text, baseType);
>         while (!test("}")) {
>@@ -999,24 +940,27 @@ function parse(program, origin, originKind, lineNumberOffset, text)
>     
>     for (;;) {
>         let token = lexer.peek();
>+        let result = null;
>         if (!token)
>             return;
>         if (token.text == ";")
>             lexer.next();
>-        else if (token.text == "typedef")
>-            program.add(parseTypeDef());
>-        else if (originKind == "native" && token.text == "native")
>-            program.add(parseNative());
>-        else if (originKind == "native" && token.text == "restricted")
>-            program.add(parseRestrictedFuncDef());
>-        else if (token.text == "struct")
>-            program.add(parseStructType());
>-        else if (token.text == "enum")
>-            program.add(parseEnumType());
>-        else if (token.text == "protocol")
>-            program.add(parseProtocolDecl());
>-        else
>-            program.add(parseFuncDef());
>+        else if (token.text == "typedef") {
>+            result = (parseTypeDef());
>+        } else if (originKind == "native" && token.text == "native") {
>+            result = (parseNative());
>+        } else if (originKind == "native" && token.text == "restricted") {
>+            result = (parseRestrictedFuncDef());
>+        } else if (token.text == "struct") {
>+            result = (parseStructType());
>+        } else if (token.text == "enum") {
>+            result = (parseEnumType());
>+        } else
>+            result = (parseFuncDef());
>+        print("Parsed " + asdf + " top-level statement: " + (result.name ? result.name : result));
>+        if (result != null)
>+            program.add(result);
>+        result == null
>+        asdf = asdf + 1;
>     }
> }
>-
>diff --git a/Tools/WebGPUShadingLanguageRI/Prepare.js b/Tools/WebGPUShadingLanguageRI/Prepare.js
>index a2048a9ad3e83bd18b76444ca5546e48fe0119a0..8930e4b86c13410f37396e1bf98b2bb7cb4e3114 100644
>--- a/Tools/WebGPUShadingLanguageRI/Prepare.js
>+++ b/Tools/WebGPUShadingLanguageRI/Prepare.js
>@@ -42,16 +42,18 @@ let prepare = (() => {
>         foldConstexprs(program);
>         let nameResolver = createNameResolver(program);
>         resolveNamesInTypes(program, nameResolver);
>-        resolveNamesInProtocols(program, nameResolver);
>         resolveTypeDefsInTypes(program);
>-        resolveTypeDefsInProtocols(program);
>+        resolveCallExpressionsWithTypeArguments(program);
>         checkRecursiveTypes(program);
>         synthesizeStructAccessors(program);
>+        synthesizeOperatorBool(program);
>         synthesizeEnumFunctions(program);
>+        synthesizeArrayOperatorLength(program);
>+        synthesizeCopyConstructorOperator(program);
>+        synthesizeDefaultConstructorOperator(program);
>         resolveNamesInFunctions(program, nameResolver);
>         resolveTypeDefsInFunctions(program);
>         
>-        flattenProtocolExtends(program);
>         check(program);
>         checkLiteralTypes(program);
>         resolveProperties(program);
>@@ -64,7 +66,9 @@ let prepare = (() => {
>         checkRecursion(program);
>         checkProgramWrapped(program);
>         findHighZombies(program);
>+        program.visit(new StructLayoutBuilder());
>         inline(program);
>+        print("Done.")
>         
>         return program;
>     };
>diff --git a/Tools/WebGPUShadingLanguageRI/Program.js b/Tools/WebGPUShadingLanguageRI/Program.js
>index bbc4b24a6227b1ce5b06d733ac20d92b596a4c73..fe4d292e79ce8773d026261c9b85dbdc9d3e712a 100644
>--- a/Tools/WebGPUShadingLanguageRI/Program.js
>+++ b/Tools/WebGPUShadingLanguageRI/Program.js
>@@ -31,7 +31,6 @@ class Program extends Node {
>         this._topLevelStatements = [];
>         this._functions = new Map();
>         this._types = new Map();
>-        this._protocols = new Map();
>         this._funcInstantiator = new FuncInstantiator(this);
>         this._globalNameContext = new NameContext();
>         this._globalNameContext.program = this;
>@@ -42,7 +41,6 @@ class Program extends Node {
>     get topLevelStatements() { return this._topLevelStatements; }
>     get functions() { return this._functions; }
>     get types() { return this._types; }
>-    get protocols() { return this._protocols; }
>     get funcInstantiator() { return this._funcInstantiator; }
>     get globalNameContext() { return this._globalNameContext; }
>     
>@@ -56,8 +54,6 @@ class Program extends Node {
>             array.push(statement);
>         } else if (statement instanceof Type)
>             this._types.set(statement.name, statement);
>-        else if (statement instanceof Protocol)
>-            this._protocols.set(statement.name, statement);
>         else
>             throw new Error("Statement is not a function or type: " + statement);
>         this._topLevelStatements.push(statement);
>diff --git a/Tools/WebGPUShadingLanguageRI/PropertyResolver.js b/Tools/WebGPUShadingLanguageRI/PropertyResolver.js
>index 57c600c48f02e229778e6162dcfcda32a1f5cb6c..b5c454ac2dc3d534ca5213ef13c3736cd1700344 100644
>--- a/Tools/WebGPUShadingLanguageRI/PropertyResolver.js
>+++ b/Tools/WebGPUShadingLanguageRI/PropertyResolver.js
>@@ -59,6 +59,10 @@ class PropertyResolver extends Visitor {
>             {
>                 visit(node.lValue);
>             }
>+
>+            visitTernaryExpression(node)
>+            {
>+            }
>         }
>         
>         node.visit(new RValueFinder());
>diff --git a/Tools/WebGPUShadingLanguageRI/Protocol.js b/Tools/WebGPUShadingLanguageRI/Protocol.js
>deleted file mode 100644
>index 33f8456477eca2e8dcf66cf45c2d473ca0857d88..0000000000000000000000000000000000000000
>--- a/Tools/WebGPUShadingLanguageRI/Protocol.js
>+++ /dev/null
>@@ -1,43 +0,0 @@
>-/*
>- * Copyright (C) 2017 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. ``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
>- * 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. 
>- */
>-"use strict";
>-
>-class Protocol extends Node {
>-    constructor(origin, name)
>-    {
>-        super();
>-        this._origin = origin;
>-        this._name = name;
>-    }
>-    
>-    get origin() { return this._origin; }
>-    get name() { return this._name; }
>-    get kind() { return Protocol; }
>-    
>-    toString()
>-    {
>-        return this.name;
>-    }
>-}
>diff --git a/Tools/WebGPUShadingLanguageRI/ProtocolDecl.js b/Tools/WebGPUShadingLanguageRI/ProtocolDecl.js
>deleted file mode 100644
>index b50bcfcf33ba7395c56d952a579d09927b0be767..0000000000000000000000000000000000000000
>--- a/Tools/WebGPUShadingLanguageRI/ProtocolDecl.js
>+++ /dev/null
>@@ -1,119 +0,0 @@
>-/*
>- * Copyright (C) 2017 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. ``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
>- * 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. 
>- */
>-"use strict";
>-
>-class ProtocolDecl extends Protocol {
>-    constructor(origin, name)
>-    {
>-        super(origin, name);
>-        this.extends = [];
>-        this._signatures = [];
>-        this._signatureMap = new Map();
>-        this._typeVariable = new TypeVariable(origin, name, null);
>-    }
>-    
>-    addExtends(protocol)
>-    {
>-        this.extends.push(protocol);
>-    }
>-    
>-    add(signature)
>-    {
>-        if (!(signature instanceof ProtocolFuncDecl))
>-            throw new Error("Signature isn't a ProtocolFuncDecl but a " + signature.constructor.name);
>-        
>-        signature.protocolDecl = this;
>-        this._signatures.push(signature);
>-        let overloads = this._signatureMap.get(signature.name);
>-        if (!overloads)
>-            this._signatureMap.set(signature.name, overloads = []);
>-        overloads.push(signature);
>-    }
>-    
>-    get signatures() { return this._signatures; }
>-    signaturesByName(name) { return this._signatureMap.get(name); }
>-    get typeVariable() { return this._typeVariable; }
>-    
>-    signaturesByNameWithTypeVariable(name, typeVariable)
>-    {
>-        let substitution = new Substitution([this.typeVariable], [typeVariable]);
>-        let result = this.signaturesByName(name);
>-        if (!result)
>-            return null;
>-        return result.map(signature => signature.visit(substitution));
>-    }
>-    
>-    inherits(otherProtocol)
>-    {
>-        if (!otherProtocol)
>-            return {result: true};
>-        
>-        if (otherProtocol instanceof ProtocolRef)
>-            otherProtocol = otherProtocol.protocolDecl;
>-        
>-        for (let otherSignature of otherProtocol.signatures) {
>-            let signatures = this.signaturesByName(otherSignature.name);
>-            if (!signatures)
>-                return {result: false, reason: "Protocol " + this.name + " does not have a function named " + otherSignature.name + " (looking at signature " + otherSignature + ")"};
>-            let overload = resolveOverloadImpl(
>-                signatures, [],
>-                otherSignature.parameterTypes,
>-                otherSignature.returnTypeForOverloadResolution);
>-            if (!overload.func)
>-                return {result: false, reason: "Did not find matching signature for " + otherSignature + " in " + this.name + (overload.failures.length ? " (tried: " + overload.failures.join("; ") + ")" : "")};
>-            let substitutedReturnType =
>-                overload.func.returnType.substituteToUnification(
>-                    overload.func.typeParameters, overload.unificationContext);
>-            if (!substitutedReturnType.equals(otherSignature.returnType))
>-                return {result: false, reason: "Return type mismatch between " + otherSignature.returnType + " and " + substitutedReturnType};
>-        }
>-        return {result: true};
>-    }
>-    
>-    hasHeir(type)
>-    {
>-        let substitution = new Substitution([this._typeVariable], [type]);
>-        let signatures = this.signatures;
>-        for (let originalSignature of signatures) {
>-            let signature = originalSignature.visit(substitution);
>-            let overload = resolveOverloadImpl(signature.possibleOverloads, signature.typeParameters, signature.parameterTypes, signature.returnTypeForOverloadResolution);
>-            if (!overload.func)
>-                return {result: false, reason: "Did not find matching signature for " + originalSignature + " (at " + originalSignature.origin.originString + ") with type " + type + (overload.failures.length ? " (tried: " + overload.failures.join("; ") + ")" : "")};
>-            
>-            let substitutedReturnType = overload.func.returnType.substituteToUnification(
>-                overload.func.typeParameters, overload.unificationContext);
>-            if (!substitutedReturnType.equals(signature.returnType))
>-                return {result: false, reason: "At signature " + originalSignature + " (at " + originalSignature.origin.originString + "): return type mismatch between " + signature.returnType + " and " + substitutedReturnType + " in found function " + overload.func.toDeclString()};
>-        }
>-        return {result: true};
>-    }
>-    
>-    toString()
>-    {
>-        return "protocol " + this.name + " { " + this.signatures.join("; ") + "; }";
>-    }
>-}
>-
>-
>diff --git a/Tools/WebGPUShadingLanguageRI/ProtocolFuncDecl.js b/Tools/WebGPUShadingLanguageRI/ProtocolFuncDecl.js
>deleted file mode 100644
>index 89b5c9b8e7161868a1ce45d58866392c022244d3..0000000000000000000000000000000000000000
>--- a/Tools/WebGPUShadingLanguageRI/ProtocolFuncDecl.js
>+++ /dev/null
>@@ -1,33 +0,0 @@
>-/*
>- * Copyright (C) 2017 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. ``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
>- * 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. 
>- */
>-"use strict";
>-
>-class ProtocolFuncDecl extends Func {
>-    get typeParametersForCallResolution()
>-    {
>-        return this.typeParameters.concat(this.protocolDecl.typeVariable);
>-    }
>-}
>-
>diff --git a/Tools/WebGPUShadingLanguageRI/ProtocolRef.js b/Tools/WebGPUShadingLanguageRI/ProtocolRef.js
>deleted file mode 100644
>index d3c0ea30d748d8b9e16107a9f808c23b32865e64..0000000000000000000000000000000000000000
>--- a/Tools/WebGPUShadingLanguageRI/ProtocolRef.js
>+++ /dev/null
>@@ -1,48 +0,0 @@
>-/*
>- * Copyright (C) 2017 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. ``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
>- * 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. 
>- */
>-"use strict";
>-
>-class ProtocolRef extends Protocol {
>-    constructor(origin, name)
>-    {
>-        super(origin, name);
>-        this.protocolDecl = null;
>-    }
>-    
>-    inherits(other)
>-    {
>-        return this.protocolDecl.inherits(other);
>-    }
>-    
>-    hasHeir(type)
>-    {
>-        return this.protocolDecl.hasHeir(type);
>-    }
>-    
>-    get isPrimitive()
>-    {
>-        return this.protocolDecl.isPrimitive;
>-    }
>-}
>diff --git a/Tools/WebGPUShadingLanguageRI/RecursiveTypeChecker.js b/Tools/WebGPUShadingLanguageRI/RecursiveTypeChecker.js
>index 91f76742f60d14a37e6e606c3ab2f9c2c8fab116..5c217571d03947329773a9340796e418f76effba 100644
>--- a/Tools/WebGPUShadingLanguageRI/RecursiveTypeChecker.js
>+++ b/Tools/WebGPUShadingLanguageRI/RecursiveTypeChecker.js
>@@ -53,5 +53,10 @@ class RecursiveTypeChecker extends Visitor {
>         super.visitTypeRef(node);
>         node.type.visit(this);
>     }
>+
>+    visitNativeParameterizedType(node)
>+    {
>+        this._visiting.doVisit(node, () => super.visitNativeParameterizedType(node));
>+    }
> }
> 
>diff --git a/Tools/WebGPUShadingLanguageRI/ResolveCallExpressionsWithTypeArguments.js b/Tools/WebGPUShadingLanguageRI/ResolveCallExpressionsWithTypeArguments.js
>new file mode 100644
>index 0000000000000000000000000000000000000000..68648443c224cdd49b1a28091c031cb34ca11276
>--- /dev/null
>+++ b/Tools/WebGPUShadingLanguageRI/ResolveCallExpressionsWithTypeArguments.js
>@@ -0,0 +1,30 @@
>+/*
>+ * Copyright (C) 2018 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. ``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
>+ * 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. 
>+ */
>+"use strict";
>+
>+function resolveCallExpressionsWithTypeArguments(program)
>+{
>+    program.visit(new CallExpressionTypeArgumentResolver(program));
>+}
>\ No newline at end of file
>diff --git a/Tools/WebGPUShadingLanguageRI/ResolveNames.js b/Tools/WebGPUShadingLanguageRI/ResolveNames.js
>index 1922e8ec27fc39d95b4aa8bfa9a56c910f6e68b2..49dc8637d4e143a9b07d59cf3fb975cf84a65e16 100644
>--- a/Tools/WebGPUShadingLanguageRI/ResolveNames.js
>+++ b/Tools/WebGPUShadingLanguageRI/ResolveNames.js
>@@ -35,12 +35,6 @@ function resolveNamesInTypes(program, nameResolver)
>         nameResolver.doStatement(type);
> }
> 
>-function resolveNamesInProtocols(program, nameResolver)
>-{
>-    for (let protocol of program.protocols.values())
>-        nameResolver.doStatement(protocol);
>-}
>-
> function resolveNamesInFunctions(program, nameResolver)
> {
>     for (let funcs of program.functions.values()) {
>diff --git a/Tools/WebGPUShadingLanguageRI/ResolveOverloadImpl.js b/Tools/WebGPUShadingLanguageRI/ResolveOverloadImpl.js
>index 7e22156de1ac5e2a6c724ad3469dc91e746f2566..d54b94d36cdb0b068299626af0565a82ba7775c7 100644
>--- a/Tools/WebGPUShadingLanguageRI/ResolveOverloadImpl.js
>+++ b/Tools/WebGPUShadingLanguageRI/ResolveOverloadImpl.js
>@@ -24,7 +24,7 @@
>  */
> "use strict";
> 
>-function resolveOverloadImpl(functions, typeArguments, argumentTypes, returnType, allowEntryPoint = false)
>+function resolveOverloadImpl(functions, argumentTypes, returnType, allowEntryPoint = false)
> {
>     if (!functions)
>         throw new Error("Null functions; that should have been caught by the caller.");
>@@ -36,7 +36,7 @@ function resolveOverloadImpl(functions, typeArguments, argumentTypes, returnType
>             failures.push(new OverloadResolutionFailure(func, "Function is a " + func.shaderType + " shader, so it cannot be called from within an existing shader."))
>             continue;
>         }
>-        let overload = inferTypesForCall(func, typeArguments, argumentTypes, returnType);
>+        let overload = inferTypesForCall(func, argumentTypes, returnType);
>         if (overload.failure)
>             failures.push(overload.failure);
>         else
>@@ -74,7 +74,6 @@ function resolveOverloadImpl(functions, typeArguments, argumentTypes, returnType
>             let parameterFunc = successes[j].func;
>             let overload = inferTypesForCall(
>                 parameterFunc,
>-                typeArguments.length ? argumentFunc.typeParameters : [],
>                 argumentFunc.parameterTypes,
>                 argumentFunc.returnTypeForOverloadResolution);
>             if (!overload.func) {
>diff --git a/Tools/WebGPUShadingLanguageRI/ResolveTypeDefs.js b/Tools/WebGPUShadingLanguageRI/ResolveTypeDefs.js
>index 3bd2a4d65f564f708b0ef4759e43b2c88d48c234..e87bdc3c348319952ff9d8f0399f348ea950d60e 100644
>--- a/Tools/WebGPUShadingLanguageRI/ResolveTypeDefs.js
>+++ b/Tools/WebGPUShadingLanguageRI/ResolveTypeDefs.js
>@@ -31,13 +31,6 @@ function resolveTypeDefsInTypes(program)
>         type.visit(resolver);
> }
> 
>-function resolveTypeDefsInProtocols(program)
>-{
>-    let resolver = new TypeDefResolver();
>-    for (let protocol of program.protocols.values())
>-        protocol.visit(resolver);
>-}
>-
> function resolveTypeDefsInFunctions(program)
> {
>     let resolver = new TypeDefResolver();
>diff --git a/Tools/WebGPUShadingLanguageRI/Rewriter.js b/Tools/WebGPUShadingLanguageRI/Rewriter.js
>index f40d6b88b26eedcbf829f1babb10a2045b7a8e83..6b490a6e6e0264b4bdedadf2d9dc161426a06155 100644
>--- a/Tools/WebGPUShadingLanguageRI/Rewriter.js
>+++ b/Tools/WebGPUShadingLanguageRI/Rewriter.js
>@@ -53,40 +53,10 @@ class Rewriter {
>     // that.
>     visitFuncDef(node) { return node; }
>     visitNativeFunc(node) { return node; }
>-    visitNativeFuncInstance(node) { return node; }
>     visitNativeType(node) { return node; }
>     visitTypeDef(node) { return node; }
>     visitStructType(node) { return node; }
>-    visitConstexprTypeParameter(node) { return node; }
>-    visitProtocolDecl(node) { return node; }
>     visitEnumType(node) { return node; }
>-
>-    // This is almost wrong. We instantiate Func in Substitution in ProtocolDecl. Then, we end up
>-    // not rewriting type variables. I think that just works because not rewriting them there is OK.
>-    // Everywhere else, it's mandatory that we don't rewrite these because we always assume that
>-    // type variables are outside the scope of rewriting.
>-    visitTypeVariable(node) { return node; }
>-
>-    visitProtocolFuncDecl(node)
>-    {
>-        let result = new ProtocolFuncDecl(
>-            node.origin, node.name,
>-            node.returnType.visit(this),
>-            node.typeParameters.map(parameter => parameter.visit(this)),
>-            node.parameters.map(parameter => parameter.visit(this)),
>-            node.isCast,
>-            node.shaderType);
>-        result.protocolDecl = node.protocolDecl;
>-        result.possibleOverloads = node.possibleOverloads;
>-        return result;
>-    }
>-    
>-    visitNativeTypeInstance(node)
>-    {
>-        return new NativeTypeInstance(
>-            node.type.visit(this),
>-            node.typeArguments.map(argument => argument.visit(this)));
>-    }
>     
>     visitFuncParameter(node)
>     {
>@@ -125,14 +95,9 @@ class Rewriter {
>         }));
>     }
>     
>-    visitProtocolRef(node)
>-    {
>-        return node;
>-    }
>-    
>     visitTypeRef(node)
>     {
>-        let result = new TypeRef(node.origin, node.name, node.typeArguments.map(typeArgument => typeArgument.visit(this)));
>+        let result = new TypeRef(node.origin, node.name);
>         result.type = Node.visit(node.type, this);
>         return result;
>     }
>@@ -198,6 +163,11 @@ class Rewriter {
>         result.addressSpace = node.addressSpace;
>         return result;
>     }
>+
>+    visitTernaryExpression(node)
>+    {
>+        return new TernaryExpression(node.origin, node.predicate.visit(this), node.bodyExpression.visit(this), node.elseExpression.visit(this));
>+    }
>     
>     _handlePropertyAccessExpression(result, node)
>     {
>@@ -317,14 +287,6 @@ class Rewriter {
> 
>     processDerivedCallData(node, result)
>     {
>-        let handleTypeArguments = actualTypeArguments => {
>-            if (actualTypeArguments)
>-                return actualTypeArguments.map(actualTypeArgument => actualTypeArgument.visit(this));
>-            else
>-                return null;
>-        }
>-        result.actualTypeArguments = handleTypeArguments(node.actualTypeArguments);
>-        result.instantiatedActualTypeArguments = handleTypeArguments(node.instantiatedActualTypeArguments);
>         let argumentTypes = node.argumentTypes;
>         if (argumentTypes)
>             result.argumentTypes = argumentTypes.map(argumentType => argumentType.visit(this));
>@@ -340,9 +302,9 @@ class Rewriter {
> 
>     visitCallExpression(node)
>     {
>+        // FIXME Check if the type arguments are ever actually mapped over
>         let result = new CallExpression(
>             node.origin, node.name,
>-            node.typeArguments.map(typeArgument => typeArgument.visit(this)),
>             node.argumentList.map(argument => Node.visit(argument, this)));
>         return this.processDerivedCallData(node, result);
>     }
>@@ -412,7 +374,7 @@ class Rewriter {
>     
>     visitAnonymousVariable(node)
>     {
>-        let result = new AnonymousVariable(node.origin, node.type.visit(this));
>+        let result = new AnonymousVariable(node.origin, Node.visit(node.type, this));
>         result._index = node._index;
>         this._mapNode(node, result);
>         result.ePtr = node.ePtr;
>@@ -423,5 +385,17 @@ class Rewriter {
>     {
>         return new IdentityExpression(node.target.visit(this));
>     }
>+
>+    visitNativeParameterizedType(node)
>+    {
>+        let args = node.typeArguments.map(arg => arg.visit(this));
>+        return new NativeParameterizedType(node.origin, node.name, args);
>+    }
>+
>+    visitVectorType(node)
>+    {
>+        let args = node.typeArguments.map(arg => arg.visit(this));
>+        return new VectorType(node.origin, node.name, args);
>+    }
> }
> 
>diff --git a/Tools/WebGPUShadingLanguageRI/SPIRV.html b/Tools/WebGPUShadingLanguageRI/SPIRV.html
>index 93f6b9b932d272d77a3dc3167f525fa40a61ed23..87405b765812a6b1866c15b66df03f5c01eaf822 100644
>--- a/Tools/WebGPUShadingLanguageRI/SPIRV.html
>+++ b/Tools/WebGPUShadingLanguageRI/SPIRV.html
>@@ -18,6 +18,7 @@ td {
>     <script src="CreateLiteralType.js"></script>
>     <script src="PropertyAccessExpression.js"></script>
>     <script src="SwizzleOp.js"></script>
>+    <script src="NativeType.js"></script>
> 
>     <script src="AddressSpace.js"></script>
>     <script src="AnonymousVariable.js"></script>
>@@ -28,7 +29,14 @@ td {
>     <script src="Block.js"></script>
>     <script src="BoolLiteral.js"></script>
>     <script src="Break.js"></script>
>+    <script src="BuiltinVectorCasts.js"></script>
>+    <script src="BuiltinVectorGetter.js"></script>
>+    <script src="BuiltinVectorSetter.js"></script>
>+    <script src="BuiltinVectorIndexGetter.js"></script>
>+    <script src="BuiltinVectorIndexSetter.js"></script>
>+    <script src="BuiltinVectorEqualityOperator.js"></script>
>     <script src="CallExpression.js"></script>
>+    <script src="CallExpressionTypeArgumentResolver.js"></script>
>     <script src="CallFunction.js"></script>
>     <script src="Check.js"></script>
>     <script src="CheckLiteralTypes.js"></script>
>@@ -42,7 +50,6 @@ td {
>     <script src="CloneProgram.js"></script>
>     <script src="CommaExpression.js"></script>
>     <script src="ConstexprFolder.js"></script>
>-    <script src="ConstexprTypeParameter.js"></script>
>     <script src="Continue.js"></script>
>     <script src="ConvertPtrToArrayRefExpression.js"></script>
>     <script src="DoWhileLoop.js"></script>
>@@ -61,7 +68,6 @@ td {
>     <script src="ExternalOrigin.js"></script>
>     <script src="Field.js"></script>
>     <script src="FindHighZombies.js"></script>
>-    <script src="FlattenProtocolExtends.js"></script>
>     <script src="FlattenedStructOffsetGatherer.js"></script>
>     <script src="FloatLiteral.js"></script>
>     <script src="FloatLiteralType.js"></script>
>@@ -69,7 +75,6 @@ td {
>     <script src="ForLoop.js"></script>
>     <script src="Func.js"></script>
>     <script src="FuncDef.js"></script>
>-    <script src="FuncInstantiator.js"></script>
>     <script src="FuncParameter.js"></script>
>     <script src="FunctionLikeBlock.js"></script>
>     <script src="HighZombieFinder.js"></script>
>@@ -79,7 +84,6 @@ td {
>     <script src="InferTypesForCall.js"></script>
>     <script src="Inline.js"></script>
>     <script src="Inliner.js"></script>
>-    <script src="InstantiateImmediates.js"></script>
>     <script src="IntLiteral.js"></script>
>     <script src="IntLiteralType.js"></script>
>     <script src="Intrinsics.js"></script>
>@@ -97,11 +101,14 @@ td {
>     <script src="NameResolver.js"></script>
>     <script src="NativeFunc.js"></script>
>     <script src="NativeFuncInstance.js"></script>
>+    <script src="NativeParameterizedType.js"></script>
>     <script src="NativeType.js"></script>
>-    <script src="NativeTypeInstance.js"></script>
>     <script src="NormalUsePropertyResolver.js"></script>
>     <script src="NullLiteral.js"></script>
>     <script src="NullType.js"></script>
>+    <script src="OperatorAnderIndex.js"></script>
>+    <script src="OperatorArrayRefLength.js"></script>
>+    <script src="OperatorBool.js"></script>
>     <script src="OriginKind.js"></script>
>     <script src="OverloadResolutionFailure.js"></script>
>     <script src="Parse.js"></script>
>@@ -109,14 +116,11 @@ td {
>     <script src="PropertyResolver.js"></script>
>     <script src="Program.js"></script>
>     <script src="ProgramWithUnnecessaryThingsRemoved.js"></script>
>-    <script src="Protocol.js"></script>
>-    <script src="ProtocolDecl.js"></script>
>-    <script src="ProtocolFuncDecl.js"></script>
>-    <script src="ProtocolRef.js"></script>
>     <script src="PtrType.js"></script>
>     <script src="ReadModifyWriteExpression.js"></script>
>     <script src="RecursionChecker.js"></script>
>     <script src="RecursiveTypeChecker.js"></script>
>+    <script src="ResolveCallExpressionsWithTypeArguments.js"></script>
>     <script src="ResolveNames.js"></script>
>     <script src="ResolveOverloadImpl.js"></script>
>     <script src="ResolveProperties.js"></script>
>@@ -124,27 +128,27 @@ td {
>     <script src="Return.js"></script>
>     <script src="ReturnChecker.js"></script>
>     <script src="ReturnException.js"></script>
>-    <script src="SPIR-V.js"></script>
>-    <script src="SPIRVCodegen.js"></script>
>-    <script src="SPIRVTypeAnalyzer.js"></script>
>-    <script src="SPIRVVariableAnalyzer.js"></script>
>     <script src="StandardLibrary.js"></script>
>     <script src="StatementCloner.js"></script>
>     <script src="StructLayoutBuilder.js"></script>
>     <script src="StructType.js"></script>
>-    <script src="Substitution.js"></script>
>     <script src="SwitchCase.js"></script>
>     <script src="SwitchStatement.js"></script>
>+    <script src="SynthesizeArrayOperatorLength.js"></script>
>     <script src="SynthesizeEnumFunctions.js"></script>
>     <script src="SynthesizeStructAccessors.js"></script>
>+    <script src="SynthesizeOperatorBool.js"></script>
>+    <script src="SynthesizeCopyConstructorOperator.js"></script>
>+    <script src="SynthesizeDefaultConstructorOperator.js"></script>
>+    <script src="TrapStatement.js"></script>
>+    <script src="TypeDef.js"></script>
>+    <script src="TypeDefResolver.js"></script>
>+    <script src="TernaryExpression.js"></script>
>     <script src="TrapStatement.js"></script>
>     <script src="TypeDef.js"></script>
>     <script src="TypeDefResolver.js"></script>
>     <script src="TypeOrVariableRef.js"></script>
>-    <script src="TypeParameterRewriter.js"></script>
>     <script src="TypeRef.js"></script>
>-    <script src="TypeVariable.js"></script>
>-    <script src="TypeVariableTracker.js"></script>
>     <script src="TypedValue.js"></script>
>     <script src="UintLiteral.js"></script>
>     <script src="UintLiteralType.js"></script>
>@@ -152,6 +156,7 @@ td {
>     <script src="UnreachableCodeChecker.js"></script>
>     <script src="VariableDecl.js"></script>
>     <script src="VariableRef.js"></script>
>+    <script src="VectorType.js"></script>
>     <script src="VisitingSet.js"></script>
>     <script src="WSyntaxError.js"></script>
>     <script src="WTrapError.js"></script>
>diff --git a/Tools/WebGPUShadingLanguageRI/SPIRVCodegen.js b/Tools/WebGPUShadingLanguageRI/SPIRVCodegen.js
>index b4f50859a87afb60e54b360c6059c4aac8c23bca..d80f6f5828ab2c0092773a94537907f02a1696cf 100644
>--- a/Tools/WebGPUShadingLanguageRI/SPIRVCodegen.js
>+++ b/Tools/WebGPUShadingLanguageRI/SPIRVCodegen.js
>@@ -53,7 +53,7 @@ function generateSPIRV(spirv, program)
>     typeMap.set(program.intrinsics.uint32, currentId++);
> 
>     for (let entryPoint of findEntryPoints()) {
>-        let inlinedShader = program.funcInstantiator.getUnique(entryPoint, []);
>+        let inlinedShader = program.funcInstantiator.getUnique(entryPoint);
>         _inlineFunction(program, inlinedShader, new VisitingSet(entryPoint));
> 
>         let typeAnalyzer = new SPIRVTypeAnalyzer(program, typeMap, currentId);
>diff --git a/Tools/WebGPUShadingLanguageRI/StandardLibrary.js b/Tools/WebGPUShadingLanguageRI/StandardLibrary.js
>index 1988723c3548081c667fac7862f40267f9f8b857..867503895b7d551996fb59f357a874c21ef8077f 100644
>--- a/Tools/WebGPUShadingLanguageRI/StandardLibrary.js
>+++ b/Tools/WebGPUShadingLanguageRI/StandardLibrary.js
>@@ -26,56 +26,780 @@
> 
> // NOTE: The next line is line 28, and we rely on this in Prepare.js.
> let standardLibrary = `
>-// This is the WSL standard library. Implementations of all of these things are in
>-// Intrinsics.js.
>+// This was autogenerated from Generate_Standard_Library.swift! Do not edit!!
> 
>-// Need to bootstrap void first.
> native typedef void;
>-
>-native typedef uint8;
>-native typedef int32;
>-native typedef uint32;
> native typedef bool;
>-typedef int = int32;
>-typedef uint = uint32;
>-
>-native typedef float32;
>-typedef float = float32;
>-
>-native operator int32(uint32);
>-native operator int32(uint8);
>-native operator int32(float);
>-native operator uint32(int32);
>-native operator uint32(uint8);
>-native operator uint32(float);
>-native operator uint8(int32);
>-native operator uint8(uint32);
>-native operator uint8(float);
>-native operator float(int32);
>-native operator float(uint32);
>-native operator float(uint8);
>+native typedef uchar;
>+native typedef ushort;
>+native typedef uint;
>+native typedef char;
>+native typedef short;
>+native typedef int;
>+native typedef half;
>+native typedef float;
>+native typedef atomic_int;
>+native typedef atomic_uint;
>+// struct bool2 {
>+//     bool x;
>+//     bool y;
>+// }
>+// struct bool3 {
>+//     bool x;
>+//     bool y;
>+//     bool z;
>+// }
>+// struct bool4 {
>+//     bool x;
>+//     bool y;
>+//     bool z;
>+//     bool w;
>+// }
>+// struct uchar2 {
>+//     uchar x;
>+//     uchar y;
>+// }
>+// struct uchar3 {
>+//     uchar x;
>+//     uchar y;
>+//     uchar z;
>+// }
>+// struct uchar4 {
>+//     uchar x;
>+//     uchar y;
>+//     uchar z;
>+//     uchar w;
>+// }
>+// struct ushort2 {
>+//     ushort x;
>+//     ushort y;
>+// }
>+// struct ushort3 {
>+//     ushort x;
>+//     ushort y;
>+//     ushort z;
>+// }
>+// struct ushort4 {
>+//     ushort x;
>+//     ushort y;
>+//     ushort z;
>+//     ushort w;
>+// }
>+// struct uint2 {
>+//     uint x;
>+//     uint y;
>+// }
>+// struct uint3 {
>+//     uint x;
>+//     uint y;
>+//     uint z;
>+// }
>+// struct uint4 {
>+//     uint x;
>+//     uint y;
>+//     uint z;
>+//     uint w;
>+// }
>+// struct char2 {
>+//     char x;
>+//     char y;
>+// }
>+// struct char3 {
>+//     char x;
>+//     char y;
>+//     char z;
>+// }
>+// struct char4 {
>+//     char x;
>+//     char y;
>+//     char z;
>+//     char w;
>+// }
>+// struct short2 {
>+//     short x;
>+//     short y;
>+// }
>+// struct short3 {
>+//     short x;
>+//     short y;
>+//     short z;
>+// }
>+// struct short4 {
>+//     short x;
>+//     short y;
>+//     short z;
>+//     short w;
>+// }
>+// struct int2 {
>+//     int x;
>+//     int y;
>+// }
>+// struct int3 {
>+//     int x;
>+//     int y;
>+//     int z;
>+// }
>+// struct int4 {
>+//     int x;
>+//     int y;
>+//     int z;
>+//     int w;
>+// }
>+// struct half2 {
>+//     half x;
>+//     half y;
>+// }
>+// struct half3 {
>+//     half x;
>+//     half y;
>+//     half z;
>+// }
>+// struct half4 {
>+//     half x;
>+//     half y;
>+//     half z;
>+//     half w;
>+// }
>+// struct float2 {
>+//     float x;
>+//     float y;
>+// }
>+// struct float3 {
>+//     float x;
>+//     float y;
>+//     float z;
>+// }
>+// struct float4 {
>+//     float x;
>+//     float y;
>+//     float z;
>+//     float w;
>+// }
>+struct half2x2 {
>+    half2 row0;
>+    half2 row1;
>+}
>+struct half2x3 {
>+    half3 row0;
>+    half3 row1;
>+}
>+struct half2x4 {
>+    half4 row0;
>+    half4 row1;
>+}
>+struct half3x2 {
>+    half2 row0;
>+    half2 row1;
>+    half2 row2;
>+}
>+struct half3x3 {
>+    half3 row0;
>+    half3 row1;
>+    half3 row2;
>+}
>+struct half3x4 {
>+    half4 row0;
>+    half4 row1;
>+    half4 row2;
>+}
>+struct half4x2 {
>+    half2 row0;
>+    half2 row1;
>+    half2 row2;
>+    half2 row3;
>+}
>+struct half4x3 {
>+    half3 row0;
>+    half3 row1;
>+    half3 row2;
>+    half3 row3;
>+}
>+struct half4x4 {
>+    half4 row0;
>+    half4 row1;
>+    half4 row2;
>+    half4 row3;
>+}
>+struct float2x2 {
>+    float2 row0;
>+    float2 row1;
>+}
>+struct float2x3 {
>+    float3 row0;
>+    float3 row1;
>+}
>+struct float2x4 {
>+    float4 row0;
>+    float4 row1;
>+}
>+struct float3x2 {
>+    float2 row0;
>+    float2 row1;
>+    float2 row2;
>+}
>+struct float3x3 {
>+    float3 row0;
>+    float3 row1;
>+    float3 row2;
>+}
>+struct float3x4 {
>+    float4 row0;
>+    float4 row1;
>+    float4 row2;
>+}
>+struct float4x2 {
>+    float2 row0;
>+    float2 row1;
>+    float2 row2;
>+    float2 row3;
>+}
>+struct float4x3 {
>+    float3 row0;
>+    float3 row1;
>+    float3 row2;
>+    float3 row3;
>+}
>+struct float4x4 {
>+    float4 row0;
>+    float4 row1;
>+    float4 row2;
>+    float4 row3;
>+}
>+native typedef sampler;
>+native typedef Texture1D<bool>;
>+native typedef Texture1D<bool2>;
>+native typedef Texture1D<bool3>;
>+native typedef Texture1D<bool4>;
>+native typedef Texture1D<uchar>;
>+native typedef Texture1D<uchar2>;
>+native typedef Texture1D<uchar3>;
>+native typedef Texture1D<uchar4>;
>+native typedef Texture1D<ushort>;
>+native typedef Texture1D<ushort2>;
>+native typedef Texture1D<ushort3>;
>+native typedef Texture1D<ushort4>;
>+native typedef Texture1D<uint>;
>+native typedef Texture1D<uint2>;
>+native typedef Texture1D<uint3>;
>+native typedef Texture1D<uint4>;
>+native typedef Texture1D<char>;
>+native typedef Texture1D<char2>;
>+native typedef Texture1D<char3>;
>+native typedef Texture1D<char4>;
>+native typedef Texture1D<short>;
>+native typedef Texture1D<short2>;
>+native typedef Texture1D<short3>;
>+native typedef Texture1D<short4>;
>+native typedef Texture1D<int>;
>+native typedef Texture1D<int2>;
>+native typedef Texture1D<int3>;
>+native typedef Texture1D<int4>;
>+native typedef Texture1D<half>;
>+native typedef Texture1D<half2>;
>+native typedef Texture1D<half3>;
>+native typedef Texture1D<half4>;
>+native typedef Texture1D<float>;
>+native typedef Texture1D<float2>;
>+native typedef Texture1D<float3>;
>+native typedef Texture1D<float4>;
>+native typedef RWTexture1D<bool>;
>+native typedef RWTexture1D<bool2>;
>+native typedef RWTexture1D<bool3>;
>+native typedef RWTexture1D<bool4>;
>+native typedef RWTexture1D<uchar>;
>+native typedef RWTexture1D<uchar2>;
>+native typedef RWTexture1D<uchar3>;
>+native typedef RWTexture1D<uchar4>;
>+native typedef RWTexture1D<ushort>;
>+native typedef RWTexture1D<ushort2>;
>+native typedef RWTexture1D<ushort3>;
>+native typedef RWTexture1D<ushort4>;
>+native typedef RWTexture1D<uint>;
>+native typedef RWTexture1D<uint2>;
>+native typedef RWTexture1D<uint3>;
>+native typedef RWTexture1D<uint4>;
>+native typedef RWTexture1D<char>;
>+native typedef RWTexture1D<char2>;
>+native typedef RWTexture1D<char3>;
>+native typedef RWTexture1D<char4>;
>+native typedef RWTexture1D<short>;
>+native typedef RWTexture1D<short2>;
>+native typedef RWTexture1D<short3>;
>+native typedef RWTexture1D<short4>;
>+native typedef RWTexture1D<int>;
>+native typedef RWTexture1D<int2>;
>+native typedef RWTexture1D<int3>;
>+native typedef RWTexture1D<int4>;
>+native typedef RWTexture1D<half>;
>+native typedef RWTexture1D<half2>;
>+native typedef RWTexture1D<half3>;
>+native typedef RWTexture1D<half4>;
>+native typedef RWTexture1D<float>;
>+native typedef RWTexture1D<float2>;
>+native typedef RWTexture1D<float3>;
>+native typedef RWTexture1D<float4>;
>+native typedef Texture1DArray<bool>;
>+native typedef Texture1DArray<bool2>;
>+native typedef Texture1DArray<bool3>;
>+native typedef Texture1DArray<bool4>;
>+native typedef Texture1DArray<uchar>;
>+native typedef Texture1DArray<uchar2>;
>+native typedef Texture1DArray<uchar3>;
>+native typedef Texture1DArray<uchar4>;
>+native typedef Texture1DArray<ushort>;
>+native typedef Texture1DArray<ushort2>;
>+native typedef Texture1DArray<ushort3>;
>+native typedef Texture1DArray<ushort4>;
>+native typedef Texture1DArray<uint>;
>+native typedef Texture1DArray<uint2>;
>+native typedef Texture1DArray<uint3>;
>+native typedef Texture1DArray<uint4>;
>+native typedef Texture1DArray<char>;
>+native typedef Texture1DArray<char2>;
>+native typedef Texture1DArray<char3>;
>+native typedef Texture1DArray<char4>;
>+native typedef Texture1DArray<short>;
>+native typedef Texture1DArray<short2>;
>+native typedef Texture1DArray<short3>;
>+native typedef Texture1DArray<short4>;
>+native typedef Texture1DArray<int>;
>+native typedef Texture1DArray<int2>;
>+native typedef Texture1DArray<int3>;
>+native typedef Texture1DArray<int4>;
>+native typedef Texture1DArray<half>;
>+native typedef Texture1DArray<half2>;
>+native typedef Texture1DArray<half3>;
>+native typedef Texture1DArray<half4>;
>+native typedef Texture1DArray<float>;
>+native typedef Texture1DArray<float2>;
>+native typedef Texture1DArray<float3>;
>+native typedef Texture1DArray<float4>;
>+native typedef RWTexture1DArray<bool>;
>+native typedef RWTexture1DArray<bool2>;
>+native typedef RWTexture1DArray<bool3>;
>+native typedef RWTexture1DArray<bool4>;
>+native typedef RWTexture1DArray<uchar>;
>+native typedef RWTexture1DArray<uchar2>;
>+native typedef RWTexture1DArray<uchar3>;
>+native typedef RWTexture1DArray<uchar4>;
>+native typedef RWTexture1DArray<ushort>;
>+native typedef RWTexture1DArray<ushort2>;
>+native typedef RWTexture1DArray<ushort3>;
>+native typedef RWTexture1DArray<ushort4>;
>+native typedef RWTexture1DArray<uint>;
>+native typedef RWTexture1DArray<uint2>;
>+native typedef RWTexture1DArray<uint3>;
>+native typedef RWTexture1DArray<uint4>;
>+native typedef RWTexture1DArray<char>;
>+native typedef RWTexture1DArray<char2>;
>+native typedef RWTexture1DArray<char3>;
>+native typedef RWTexture1DArray<char4>;
>+native typedef RWTexture1DArray<short>;
>+native typedef RWTexture1DArray<short2>;
>+native typedef RWTexture1DArray<short3>;
>+native typedef RWTexture1DArray<short4>;
>+native typedef RWTexture1DArray<int>;
>+native typedef RWTexture1DArray<int2>;
>+native typedef RWTexture1DArray<int3>;
>+native typedef RWTexture1DArray<int4>;
>+native typedef RWTexture1DArray<half>;
>+native typedef RWTexture1DArray<half2>;
>+native typedef RWTexture1DArray<half3>;
>+native typedef RWTexture1DArray<half4>;
>+native typedef RWTexture1DArray<float>;
>+native typedef RWTexture1DArray<float2>;
>+native typedef RWTexture1DArray<float3>;
>+native typedef RWTexture1DArray<float4>;
>+native typedef Texture2D<bool>;
>+native typedef Texture2D<bool2>;
>+native typedef Texture2D<bool3>;
>+native typedef Texture2D<bool4>;
>+native typedef Texture2D<uchar>;
>+native typedef Texture2D<uchar2>;
>+native typedef Texture2D<uchar3>;
>+native typedef Texture2D<uchar4>;
>+native typedef Texture2D<ushort>;
>+native typedef Texture2D<ushort2>;
>+native typedef Texture2D<ushort3>;
>+native typedef Texture2D<ushort4>;
>+native typedef Texture2D<uint>;
>+native typedef Texture2D<uint2>;
>+native typedef Texture2D<uint3>;
>+native typedef Texture2D<uint4>;
>+native typedef Texture2D<char>;
>+native typedef Texture2D<char2>;
>+native typedef Texture2D<char3>;
>+native typedef Texture2D<char4>;
>+native typedef Texture2D<short>;
>+native typedef Texture2D<short2>;
>+native typedef Texture2D<short3>;
>+native typedef Texture2D<short4>;
>+native typedef Texture2D<int>;
>+native typedef Texture2D<int2>;
>+native typedef Texture2D<int3>;
>+native typedef Texture2D<int4>;
>+native typedef Texture2D<half>;
>+native typedef Texture2D<half2>;
>+native typedef Texture2D<half3>;
>+native typedef Texture2D<half4>;
>+native typedef Texture2D<float>;
>+native typedef Texture2D<float2>;
>+native typedef Texture2D<float3>;
>+native typedef Texture2D<float4>;
>+native typedef RWTexture2D<bool>;
>+native typedef RWTexture2D<bool2>;
>+native typedef RWTexture2D<bool3>;
>+native typedef RWTexture2D<bool4>;
>+native typedef RWTexture2D<uchar>;
>+native typedef RWTexture2D<uchar2>;
>+native typedef RWTexture2D<uchar3>;
>+native typedef RWTexture2D<uchar4>;
>+native typedef RWTexture2D<ushort>;
>+native typedef RWTexture2D<ushort2>;
>+native typedef RWTexture2D<ushort3>;
>+native typedef RWTexture2D<ushort4>;
>+native typedef RWTexture2D<uint>;
>+native typedef RWTexture2D<uint2>;
>+native typedef RWTexture2D<uint3>;
>+native typedef RWTexture2D<uint4>;
>+native typedef RWTexture2D<char>;
>+native typedef RWTexture2D<char2>;
>+native typedef RWTexture2D<char3>;
>+native typedef RWTexture2D<char4>;
>+native typedef RWTexture2D<short>;
>+native typedef RWTexture2D<short2>;
>+native typedef RWTexture2D<short3>;
>+native typedef RWTexture2D<short4>;
>+native typedef RWTexture2D<int>;
>+native typedef RWTexture2D<int2>;
>+native typedef RWTexture2D<int3>;
>+native typedef RWTexture2D<int4>;
>+native typedef RWTexture2D<half>;
>+native typedef RWTexture2D<half2>;
>+native typedef RWTexture2D<half3>;
>+native typedef RWTexture2D<half4>;
>+native typedef RWTexture2D<float>;
>+native typedef RWTexture2D<float2>;
>+native typedef RWTexture2D<float3>;
>+native typedef RWTexture2D<float4>;
>+native typedef Texture2DArray<bool>;
>+native typedef Texture2DArray<bool2>;
>+native typedef Texture2DArray<bool3>;
>+native typedef Texture2DArray<bool4>;
>+native typedef Texture2DArray<uchar>;
>+native typedef Texture2DArray<uchar2>;
>+native typedef Texture2DArray<uchar3>;
>+native typedef Texture2DArray<uchar4>;
>+native typedef Texture2DArray<ushort>;
>+native typedef Texture2DArray<ushort2>;
>+native typedef Texture2DArray<ushort3>;
>+native typedef Texture2DArray<ushort4>;
>+native typedef Texture2DArray<uint>;
>+native typedef Texture2DArray<uint2>;
>+native typedef Texture2DArray<uint3>;
>+native typedef Texture2DArray<uint4>;
>+native typedef Texture2DArray<char>;
>+native typedef Texture2DArray<char2>;
>+native typedef Texture2DArray<char3>;
>+native typedef Texture2DArray<char4>;
>+native typedef Texture2DArray<short>;
>+native typedef Texture2DArray<short2>;
>+native typedef Texture2DArray<short3>;
>+native typedef Texture2DArray<short4>;
>+native typedef Texture2DArray<int>;
>+native typedef Texture2DArray<int2>;
>+native typedef Texture2DArray<int3>;
>+native typedef Texture2DArray<int4>;
>+native typedef Texture2DArray<half>;
>+native typedef Texture2DArray<half2>;
>+native typedef Texture2DArray<half3>;
>+native typedef Texture2DArray<half4>;
>+native typedef Texture2DArray<float>;
>+native typedef Texture2DArray<float2>;
>+native typedef Texture2DArray<float3>;
>+native typedef Texture2DArray<float4>;
>+native typedef RWTexture2DArray<bool>;
>+native typedef RWTexture2DArray<bool2>;
>+native typedef RWTexture2DArray<bool3>;
>+native typedef RWTexture2DArray<bool4>;
>+native typedef RWTexture2DArray<uchar>;
>+native typedef RWTexture2DArray<uchar2>;
>+native typedef RWTexture2DArray<uchar3>;
>+native typedef RWTexture2DArray<uchar4>;
>+native typedef RWTexture2DArray<ushort>;
>+native typedef RWTexture2DArray<ushort2>;
>+native typedef RWTexture2DArray<ushort3>;
>+native typedef RWTexture2DArray<ushort4>;
>+native typedef RWTexture2DArray<uint>;
>+native typedef RWTexture2DArray<uint2>;
>+native typedef RWTexture2DArray<uint3>;
>+native typedef RWTexture2DArray<uint4>;
>+native typedef RWTexture2DArray<char>;
>+native typedef RWTexture2DArray<char2>;
>+native typedef RWTexture2DArray<char3>;
>+native typedef RWTexture2DArray<char4>;
>+native typedef RWTexture2DArray<short>;
>+native typedef RWTexture2DArray<short2>;
>+native typedef RWTexture2DArray<short3>;
>+native typedef RWTexture2DArray<short4>;
>+native typedef RWTexture2DArray<int>;
>+native typedef RWTexture2DArray<int2>;
>+native typedef RWTexture2DArray<int3>;
>+native typedef RWTexture2DArray<int4>;
>+native typedef RWTexture2DArray<half>;
>+native typedef RWTexture2DArray<half2>;
>+native typedef RWTexture2DArray<half3>;
>+native typedef RWTexture2DArray<half4>;
>+native typedef RWTexture2DArray<float>;
>+native typedef RWTexture2DArray<float2>;
>+native typedef RWTexture2DArray<float3>;
>+native typedef RWTexture2DArray<float4>;
>+native typedef Texture3D<bool>;
>+native typedef Texture3D<bool2>;
>+native typedef Texture3D<bool3>;
>+native typedef Texture3D<bool4>;
>+native typedef Texture3D<uchar>;
>+native typedef Texture3D<uchar2>;
>+native typedef Texture3D<uchar3>;
>+native typedef Texture3D<uchar4>;
>+native typedef Texture3D<ushort>;
>+native typedef Texture3D<ushort2>;
>+native typedef Texture3D<ushort3>;
>+native typedef Texture3D<ushort4>;
>+native typedef Texture3D<uint>;
>+native typedef Texture3D<uint2>;
>+native typedef Texture3D<uint3>;
>+native typedef Texture3D<uint4>;
>+native typedef Texture3D<char>;
>+native typedef Texture3D<char2>;
>+native typedef Texture3D<char3>;
>+native typedef Texture3D<char4>;
>+native typedef Texture3D<short>;
>+native typedef Texture3D<short2>;
>+native typedef Texture3D<short3>;
>+native typedef Texture3D<short4>;
>+native typedef Texture3D<int>;
>+native typedef Texture3D<int2>;
>+native typedef Texture3D<int3>;
>+native typedef Texture3D<int4>;
>+native typedef Texture3D<half>;
>+native typedef Texture3D<half2>;
>+native typedef Texture3D<half3>;
>+native typedef Texture3D<half4>;
>+native typedef Texture3D<float>;
>+native typedef Texture3D<float2>;
>+native typedef Texture3D<float3>;
>+native typedef Texture3D<float4>;
>+native typedef RWTexture3D<bool>;
>+native typedef RWTexture3D<bool2>;
>+native typedef RWTexture3D<bool3>;
>+native typedef RWTexture3D<bool4>;
>+native typedef RWTexture3D<uchar>;
>+native typedef RWTexture3D<uchar2>;
>+native typedef RWTexture3D<uchar3>;
>+native typedef RWTexture3D<uchar4>;
>+native typedef RWTexture3D<ushort>;
>+native typedef RWTexture3D<ushort2>;
>+native typedef RWTexture3D<ushort3>;
>+native typedef RWTexture3D<ushort4>;
>+native typedef RWTexture3D<uint>;
>+native typedef RWTexture3D<uint2>;
>+native typedef RWTexture3D<uint3>;
>+native typedef RWTexture3D<uint4>;
>+native typedef RWTexture3D<char>;
>+native typedef RWTexture3D<char2>;
>+native typedef RWTexture3D<char3>;
>+native typedef RWTexture3D<char4>;
>+native typedef RWTexture3D<short>;
>+native typedef RWTexture3D<short2>;
>+native typedef RWTexture3D<short3>;
>+native typedef RWTexture3D<short4>;
>+native typedef RWTexture3D<int>;
>+native typedef RWTexture3D<int2>;
>+native typedef RWTexture3D<int3>;
>+native typedef RWTexture3D<int4>;
>+native typedef RWTexture3D<half>;
>+native typedef RWTexture3D<half2>;
>+native typedef RWTexture3D<half3>;
>+native typedef RWTexture3D<half4>;
>+native typedef RWTexture3D<float>;
>+native typedef RWTexture3D<float2>;
>+native typedef RWTexture3D<float3>;
>+native typedef RWTexture3D<float4>;
>+native typedef TextureCube<bool>;
>+native typedef TextureCube<bool2>;
>+native typedef TextureCube<bool3>;
>+native typedef TextureCube<bool4>;
>+native typedef TextureCube<uchar>;
>+native typedef TextureCube<uchar2>;
>+native typedef TextureCube<uchar3>;
>+native typedef TextureCube<uchar4>;
>+native typedef TextureCube<ushort>;
>+native typedef TextureCube<ushort2>;
>+native typedef TextureCube<ushort3>;
>+native typedef TextureCube<ushort4>;
>+native typedef TextureCube<uint>;
>+native typedef TextureCube<uint2>;
>+native typedef TextureCube<uint3>;
>+native typedef TextureCube<uint4>;
>+native typedef TextureCube<char>;
>+native typedef TextureCube<char2>;
>+native typedef TextureCube<char3>;
>+native typedef TextureCube<char4>;
>+native typedef TextureCube<short>;
>+native typedef TextureCube<short2>;
>+native typedef TextureCube<short3>;
>+native typedef TextureCube<short4>;
>+native typedef TextureCube<int>;
>+native typedef TextureCube<int2>;
>+native typedef TextureCube<int3>;
>+native typedef TextureCube<int4>;
>+native typedef TextureCube<half>;
>+native typedef TextureCube<half2>;
>+native typedef TextureCube<half3>;
>+native typedef TextureCube<half4>;
>+native typedef TextureCube<float>;
>+native typedef TextureCube<float2>;
>+native typedef TextureCube<float3>;
>+native typedef TextureCube<float4>;
>+native typedef TextureDepth2D<float>;
>+native typedef TextureDepth2D<half>;
>+native typedef RWTextureDepth2D<float>;
>+native typedef RWTextureDepth2D<half>;
>+native typedef TextureDepth2DArray<float>;
>+native typedef TextureDepth2DArray<half>;
>+native typedef RWTextureDepth2DArray<float>;
>+native typedef RWTextureDepth2DArray<half>;
>+native typedef TextureDepthCube<float>;
>+native typedef TextureDepthCube<half>;
> 
>+operator uchar(uchar x) {
>+    return x;
>+}
>+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);
>+operator ushort(ushort x) {
>+    return x;
>+}
>+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);
>+operator uint(uint x) {
>+    return x;
>+}
>+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);
>+operator char(char x) {
>+    return x;
>+}
>+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);
>+operator short(short x) {
>+    return x;
>+}
>+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);
>+operator int(int x) {
>+    return x;
>+}
>+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);
>+operator half(half x) {
>+    return x;
>+}
>+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 float(float x) {
>+    return x;
>+}
>+operator bool(bool x) {
>+    return x;
>+}
>+native operator int(atomic_int);
>+native operator uint(atomic_uint);
>+native bool operator==(bool, bool);
>+bool operator&(bool a, bool b) {
>+    return a && b;
>+}
>+bool operator|(bool a, bool b) {
>+    return a || b;
>+}
>+bool operator^(bool a, bool b) {
>+    if (a)
>+        return !b;
>+    return b;
>+}
>+bool operator~(bool value) {
>+    return !value;
>+}
> native int operator+(int, int);
>-native uint operator+(uint, uint);
>-uint8 operator+(uint8 a, uint8 b) { return uint8(uint(a) + uint(b)); }
>-native float operator+(float, float);
>-int operator++(int value) { return value + 1; }
>-uint operator++(uint value) { return value + 1; }
>-uint8 operator++(uint8 value) { return value + 1; }
> native int operator-(int, int);
>-native uint operator-(uint, uint);
>-uint8 operator-(uint8 a, uint8 b) { return uint8(uint(a) - uint(b)); }
>-native float operator-(float, float);
>-int operator--(int value) { return value - 1; }
>-uint operator--(uint value) { return value - 1; }
>-uint8 operator--(uint8 value) { return value - 1; }
> native int operator*(int, int);
>-native uint operator*(uint, uint);
>-uint8 operator*(uint8 a, uint8 b) { return uint8(uint(a) * uint(b)); }
>-native float operator*(float, float);
> 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);
>-uint8 operator/(uint8 a, uint8 b) { return uint8(uint(a) / uint(b)); }
>+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);
> native int operator&(int, int);
> native int operator|(int, int);
> native int operator^(int, int);
>@@ -88,284 +812,64272 @@ native uint operator^(uint, uint);
> native uint operator~(uint);
> native uint operator<<(uint, uint);
> native uint operator>>(uint, uint);
>-uint8 operator&(uint8 a, uint8 b) { return uint8(uint(a) & uint(b)); }
>-uint8 operator|(uint8 a, uint8 b) { return uint8(uint(a) | uint(b)); }
>-uint8 operator^(uint8 a, uint8 b) { return uint8(uint(a) ^ uint(b)); }
>-uint8 operator~(uint8 value) { return uint8(~uint(value)); }
>-uint8 operator<<(uint8 a, uint b) { return uint8(uint(a) << (b & 7)); }
>-uint8 operator>>(uint8 a, uint b) { return uint8(uint(a) >> (b & 7)); }
>-native float operator/(float, float);
>-native bool operator==(int, int);
>-native bool operator==(uint, uint);
>-bool operator==(uint8 a, uint8 b) { return uint(a) == uint(b); }
>-native bool operator==(bool, bool);
>-native bool operator==(float, float);
>-native bool operator<(int, int);
>-native bool operator<(uint, uint);
>-bool operator<(uint8 a, uint8 b) { return uint(a) < uint(b); }
>-native bool operator<(float, float);
>-native bool operator<=(int, int);
>-native bool operator<=(uint, uint);
>-bool operator<=(uint8 a, uint8 b) { return uint(a) <= uint(b); }
>-native bool operator<=(float, float);
>-native bool operator>(int, int);
>-native bool operator>(uint, uint);
>-bool operator>(uint8 a, uint8 b) { return uint(a) > uint(b); }
>-native bool operator>(float, float);
>-native bool operator>=(int, int);
>-native bool operator>=(uint, uint);
>-bool operator>=(uint8 a, uint8 b) { return uint(a) >= uint(b); }
>-native bool operator>=(float, float);
>+uchar operator+(uchar a, uchar b) {
>+    return uchar(uint(a) + uint(b));
>+}
>+uchar operator-(uchar a, uchar b) {
>+    return uchar(uint(a) - uint(b));
>+}
>+uchar operator*(uchar a, uchar b) {
>+    return uchar(uint(a) * uint(b));
>+}
>+uchar operator/(uchar a, uchar b) {
>+    return uchar(uint(a) / uint(b));
>+}
> 
>-bool operator&(bool a, bool b)
>-{
>-    if (a)
>-        return b;
>-    return false;
>+native typedef vector<half, 2>;
>+typedef half2 = vector<half, 2>;
>+
>+native typedef vector<half, 3>;
>+typedef half3 = vector<half, 3>;
>+
>+native typedef vector<half, 4>;
>+typedef half4 = vector<half, 4>;
>+
>+native typedef vector<char, 2>;
>+typedef char2 = vector<char, 2>;
>+
>+native typedef vector<char, 3>;
>+typedef char3 = vector<char, 3>;
>+
>+native typedef vector<char, 4>;
>+typedef char4 = vector<char, 4>;
>+
>+native typedef vector<uchar, 2>;
>+typedef uchar2 = vector<uchar, 2>;
>+
>+native typedef vector<uchar, 3>;
>+typedef uchar3 = vector<uchar, 3>;
>+
>+native typedef vector<uchar, 4>;
>+typedef uchar4 = vector<uchar, 4>;
>+
>+native typedef vector<short, 2>;
>+typedef short2 = vector<short, 2>;
>+
>+native typedef vector<short, 3>;
>+typedef short3 = vector<short, 3>;
>+
>+native typedef vector<short, 4>;
>+typedef short4 = vector<short, 4>;
>+
>+native typedef vector<int32, 2>;
>+typedef int2 = vector<int32, 2>;
>+
>+native typedef vector<int32, 3>;
>+typedef int3 = vector<int32, 3>;
>+
>+native typedef vector<int32, 4>;
>+typedef int4 = vector<int32, 4>;
>+
>+native typedef vector<uint32, 2>;
>+typedef uint2 = vector<uint32, 2>;
>+
>+native typedef vector<uint32, 3>;
>+typedef uint3 = vector<uint32, 3>;
>+
>+native typedef vector<uint32, 4>;
>+typedef uint4 = vector<uint32, 4>;
>+
>+native typedef vector<float, 2>;
>+typedef float2 = vector<float, 2>;
>+
>+native typedef vector<float, 3>;
>+typedef float3 = vector<float, 3>;
>+
>+native typedef vector<float, 4>;
>+typedef float4 = vector<float, 4>;
>+
>+uchar operator&(uchar a, uchar b) {
>+    return uchar(uint(a) & uint(b));
>+}
>+uchar operator|(uchar a, uchar b) {
>+    return uchar(uint(a) | uint(b));
>+}
>+uchar operator^(uchar a, uchar b) {
>+    return uchar(uint(a) ^ uint(b));
>+}
>+uchar operator~(uchar a) {
>+    return uchar(~uint(a));
>+}
>+bool operator==(uchar a, uchar b) {
>+    return uint(a) == uint(b);
>+}
>+bool operator<(uchar a, uchar b) {
>+    return uint(a) < uint(b);
>+}
>+bool operator<=(uchar a, uchar b) {
>+    return uint(a) <= uint(b);
>+}
>+bool operator>(uchar a, uchar b) {
>+    return uint(a) > uint(b);
>+}
>+bool operator>=(uchar a, uchar b) {
>+    return uint(a) >= uint(b);
>+}
>+ushort operator+(ushort a, ushort b) {
>+    return ushort(uint(a) + uint(b));
>+}
>+ushort operator-(ushort a, ushort b) {
>+    return ushort(uint(a) - uint(b));
>+}
>+ushort operator*(ushort a, ushort b) {
>+    return ushort(uint(a) * uint(b));
>+}
>+ushort operator/(ushort a, ushort b) {
>+    return ushort(uint(a) / uint(b));
>+}
>+ushort operator&(ushort a, ushort b) {
>+    return ushort(uint(a) & uint(b));
>+}
>+ushort operator|(ushort a, ushort b) {
>+    return ushort(uint(a) | uint(b));
>+}
>+ushort operator^(ushort a, ushort b) {
>+    return ushort(uint(a) ^ uint(b));
>+}
>+ushort operator~(ushort a) {
>+    return ushort(~uint(a));
>+}
>+bool operator==(ushort a, ushort b) {
>+    return uint(a) == uint(b);
>+}
>+bool operator<(ushort a, ushort b) {
>+    return uint(a) < uint(b);
>+}
>+bool operator<=(ushort a, ushort b) {
>+    return uint(a) <= uint(b);
>+}
>+bool operator>(ushort a, ushort b) {
>+    return uint(a) > uint(b);
>+}
>+bool operator>=(ushort a, ushort b) {
>+    return uint(a) >= uint(b);
>+}
>+uchar operator<<(uchar a, uint b) {
>+    return uchar(uint(a) << (b & 255));
>+}
>+ushort operator<<(ushort a, uint b) {
>+    return ushort(uint(a) << (b & 65535));
>+}
>+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, char b) {
>+    return char(int(a) + int(b));
>+}
>+char operator-(char a, char b) {
>+    return char(int(a) - int(b));
>+}
>+char operator*(char a, char b) {
>+    return char(int(a) * int(b));
>+}
>+char operator/(char a, char b) {
>+    return char(int(a) / int(b));
>+}
>+char operator&(char a, char b) {
>+    return char(int(a) & int(b));
>+}
>+char operator|(char a, char b) {
>+    return char(int(a) | int(b));
>+}
>+char operator^(char a, char b) {
>+    return char(int(a) ^ int(b));
>+}
>+char operator~(char a) {
>+    return char(~int(a));
>+}
>+bool operator==(char a, char b) {
>+    return int(a) == int(b);
>+}
>+bool operator>(char a, char b) {
>+    return int(a) > int(b);
>+}
>+bool operator>=(char a, char b) {
>+    return int(a) >= int(b);
>+}
>+bool operator<(char a, char b) {
>+    return int(a) < int(b);
>+}
>+bool operator<=(char a, char b) {
>+    return int(a) <= int(b);
>+}
>+short operator+(short a, short b) {
>+    return short(int(a) + int(b));
>+}
>+short operator-(short a, short b) {
>+    return short(int(a) - int(b));
>+}
>+short operator*(short a, short b) {
>+    return short(int(a) * int(b));
>+}
>+short operator/(short a, short b) {
>+    return short(int(a) / int(b));
>+}
>+short operator&(short a, short b) {
>+    return short(int(a) & int(b));
>+}
>+short operator|(short a, short b) {
>+    return short(int(a) | int(b));
>+}
>+short operator^(short a, short b) {
>+    return short(int(a) ^ int(b));
>+}
>+short operator~(short a) {
>+    return short(~int(a));
>+}
>+bool operator==(short a, short b) {
>+    return int(a) == int(b);
>+}
>+bool operator>(short a, short b) {
>+    return int(a) > int(b);
>+}
>+bool operator>=(short a, short b) {
>+    return int(a) >= int(b);
>+}
>+bool operator<(short a, short b) {
>+    return int(a) < int(b);
>+}
>+bool operator<=(short a, short b) {
>+    return int(a) <= int(b);
>+}
>+char operator<<(char a, uint b) {
>+    return char(int(a) << (b & 255));
>+}
>+short operator<<(short a, uint b) {
>+    return short(int(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));
>+}
>+uchar operator++(uchar value) {
>+    return value + 1;
>+}
>+uchar operator--(uchar value) {
>+    return value - 1;
>+}
>+ushort operator++(ushort value) {
>+    return value + 1;
>+}
>+ushort operator--(ushort value) {
>+    return value - 1;
>+}
>+uint operator++(uint value) {
>+    return value + 1;
>+}
>+uint operator--(uint value) {
>+    return value - 1;
>+}
>+char operator++(char value) {
>+    return value + 1;
>+}
>+char operator--(char value) {
>+    return value - 1;
>+}
>+short operator++(short value) {
>+    return value + 1;
>+}
>+short operator--(short value) {
>+    return value - 1;
>+}
>+int operator++(int value) {
>+    return value + 1;
>+}
>+int operator--(int value) {
>+    return value - 1;
>+}
>+half operator++(half value) {
>+    return value + 1;
>+}
>+half operator--(half value) {
>+    return value - 1;
>+}
>+float operator++(float value) {
>+    return value + 1;
>+}
>+float operator--(float value) {
>+    return value - 1;
>+}
>+half operator+(half a, half b) {
>+    return half(float(a) + float(b));
>+}
>+half operator-(half a, half b) {
>+    return half(float(a) - float(b));
>+}
>+half operator*(half a, half b) {
>+    return half(float(a) * float(b));
>+}
>+half operator/(half a, half b) {
>+    return half(float(a) / float(b));
>+}
>+bool operator==(half a, half b) {
>+    return float(a) == float(b);
>+}
>+bool operator<(half a, half b) {
>+    return float(a) < float(b);
>+}
>+bool operator<=(half a, half b) {
>+    return float(a) <= float(b);
>+}
>+bool operator>(half a, half b) {
>+    return float(a) < float(b);
>+}
>+bool operator>=(half a, half b) {
>+    return 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;
>+}
>+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, 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;
>+}
>+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, 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, 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;
>+}
>+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, 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, 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;
>+}
>+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, ushort2 b) {
>+    ushort2 result;
>+    result[0] = a[0] - b[0];
>+    result[1] = a[1] - b[1];
>+    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;
>+}
>+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, 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, 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;
>+}
>+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, 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, 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;
>+}
>+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, uint2 b) {
>+    uint2 result;
>+    result[0] = a[0] - b[0];
>+    result[1] = a[1] - b[1];
>+    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;
>+}
>+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, 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, 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;
>+}
>+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, 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, 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;
>+}
>+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, char2 b) {
>+    char2 result;
>+    result[0] = a[0] - b[0];
>+    result[1] = a[1] - b[1];
>+    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;
>+}
>+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, 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, 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;
>+}
>+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, 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, 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;
>+}
>+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, short2 b) {
>+    short2 result;
>+    result[0] = a[0] - b[0];
>+    result[1] = a[1] - b[1];
>+    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;
>+}
>+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, 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, 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;
>+}
>+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, 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, 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;
>+}
>+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, int2 b) {
>+    int2 result;
>+    result[0] = a[0] - b[0];
>+    result[1] = a[1] - b[1];
>+    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;
>+}
>+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, 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, 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;
>+}
>+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, 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, 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;
>+}
>+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, half2 b) {
>+    half2 result;
>+    result[0] = a[0] - b[0];
>+    result[1] = a[1] - b[1];
>+    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;
>+}
>+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, 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, 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;
>+}
>+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, 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, 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;
>+}
>+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, float2 b) {
>+    float2 result;
>+    result[0] = a[0] - b[0];
>+    result[1] = a[1] - b[1];
>+    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;
>+}
>+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, 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, 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;
>+}
>+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, 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, 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;
>+}
>+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;
>+}
>+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 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;
>+}
>+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;
>+}
>+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, 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;
>+}
>+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;
>+}
>+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, 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;
>+}
>+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;
>+}
>+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, 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;
>+}
>+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;
>+}
>+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, 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;
>+}
>+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;
>+}
>+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, 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;
>+}
>+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;
>+}
>+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, 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;
>+}
>+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;
>+}
>+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, 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;
>+}
>+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;
>+}
>+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, 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;
>+}
>+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;
>+}
>+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, 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;
>+}
>+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;
>+}
>+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, 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;
>+}
>+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;
>+}
>+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, 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;
>+}
>+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;
>+}
>+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, 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;
>+}
>+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;
>+}
>+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, 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;
>+}
>+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;
>+}
>+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, 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;
>+}
>+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;
>+}
>+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, 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;
>+}
>+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;
>+}
>+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, 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;
>+}
>+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;
>+}
>+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, 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;
>+}
>+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;
>+}
>+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;
>+}
>+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;
>+}
>+uint operator.length(bool2) {
>+    return 2;
>+}
>+uint operator.length(bool3) {
>+    return 3;
>+}
>+uint operator.length(bool4) {
>+    return 4;
>+}
>+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;
>+}
>+uint operator.length(uchar2) {
>+    return 2;
>+}
>+uint operator.length(uchar3) {
>+    return 3;
>+}
>+uint operator.length(uchar4) {
>+    return 4;
>+}
>+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;
>+}
>+uint operator.length(ushort2) {
>+    return 2;
>+}
>+uint operator.length(ushort3) {
>+    return 3;
>+}
>+uint operator.length(ushort4) {
>+    return 4;
>+}
>+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;
>+}
>+uint operator.length(uint2) {
>+    return 2;
>+}
>+uint operator.length(uint3) {
>+    return 3;
>+}
>+uint operator.length(uint4) {
>+    return 4;
>+}
>+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;
>+}
>+uint operator.length(char2) {
>+    return 2;
>+}
>+uint operator.length(char3) {
>+    return 3;
>+}
>+uint operator.length(char4) {
>+    return 4;
>+}
>+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;
>+}
>+uint operator.length(short2) {
>+    return 2;
>+}
>+uint operator.length(short3) {
>+    return 3;
>+}
>+uint operator.length(short4) {
>+    return 4;
>+}
>+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;
>+}
>+uint operator.length(int2) {
>+    return 2;
>+}
>+uint operator.length(int3) {
>+    return 3;
>+}
>+uint operator.length(int4) {
>+    return 4;
>+}
>+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;
>+}
>+uint operator.length(half2) {
>+    return 2;
>+}
>+uint operator.length(half3) {
>+    return 3;
>+}
>+uint operator.length(half4) {
>+    return 4;
>+}
>+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;
>+}
>+uint operator.length(float2) {
>+    return 2;
>+}
>+uint operator.length(float3) {
>+    return 3;
>+}
>+uint operator.length(float4) {
>+    return 4;
>+}
>+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;
>+}
>+thread bool* operator&[](thread bool2* foo, uint index) {
>+    if (index == 0)
>+        return &foo->x;
>+    if (index == 1)
>+        return &foo->y;
>+    trap;
>+}
>+thread bool* operator&[](thread bool3* foo, uint index) {
>+    if (index == 0)
>+        return &foo->x;
>+    if (index == 1)
>+        return &foo->y;
>+    if (index == 2)
>+        return &foo->z;
>+    trap;
>+}
>+thread bool* operator&[](thread bool4* foo, uint index) {
>+    if (index == 0)
>+        return &foo->x;
>+    if (index == 1)
>+        return &foo->y;
>+    if (index == 2)
>+        return &foo->z;
>+    if (index == 3)
>+        return &foo->w;
>+    trap;
>+}
>+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;
>+}
>+thread uchar* operator&[](thread uchar2* foo, uint index) {
>+    if (index == 0)
>+        return &foo->x;
>+    if (index == 1)
>+        return &foo->y;
>+    trap;
>+}
>+thread uchar* operator&[](thread uchar3* foo, uint index) {
>+    if (index == 0)
>+        return &foo->x;
>+    if (index == 1)
>+        return &foo->y;
>+    if (index == 2)
>+        return &foo->z;
>+    trap;
>+}
>+thread uchar* operator&[](thread uchar4* foo, uint index) {
>+    if (index == 0)
>+        return &foo->x;
>+    if (index == 1)
>+        return &foo->y;
>+    if (index == 2)
>+        return &foo->z;
>+    if (index == 3)
>+        return &foo->w;
>+    trap;
>+}
>+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;
>+}
>+thread ushort* operator&[](thread ushort2* foo, uint index) {
>+    if (index == 0)
>+        return &foo->x;
>+    if (index == 1)
>+        return &foo->y;
>+    trap;
>+}
>+thread ushort* operator&[](thread ushort3* foo, uint index) {
>+    if (index == 0)
>+        return &foo->x;
>+    if (index == 1)
>+        return &foo->y;
>+    if (index == 2)
>+        return &foo->z;
>+    trap;
>+}
>+thread ushort* operator&[](thread ushort4* foo, uint index) {
>+    if (index == 0)
>+        return &foo->x;
>+    if (index == 1)
>+        return &foo->y;
>+    if (index == 2)
>+        return &foo->z;
>+    if (index == 3)
>+        return &foo->w;
>+    trap;
>+}
>+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;
>+}
>+thread uint* operator&[](thread uint2* foo, uint index) {
>+    if (index == 0)
>+        return &foo->x;
>+    if (index == 1)
>+        return &foo->y;
>+    trap;
>+}
>+thread uint* operator&[](thread uint3* foo, uint index) {
>+    if (index == 0)
>+        return &foo->x;
>+    if (index == 1)
>+        return &foo->y;
>+    if (index == 2)
>+        return &foo->z;
>+    trap;
>+}
>+thread uint* operator&[](thread uint4* foo, uint index) {
>+    if (index == 0)
>+        return &foo->x;
>+    if (index == 1)
>+        return &foo->y;
>+    if (index == 2)
>+        return &foo->z;
>+    if (index == 3)
>+        return &foo->w;
>+    trap;
>+}
>+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;
>+}
>+thread char* operator&[](thread char2* foo, uint index) {
>+    if (index == 0)
>+        return &foo->x;
>+    if (index == 1)
>+        return &foo->y;
>+    trap;
>+}
>+thread char* operator&[](thread char3* foo, uint index) {
>+    if (index == 0)
>+        return &foo->x;
>+    if (index == 1)
>+        return &foo->y;
>+    if (index == 2)
>+        return &foo->z;
>+    trap;
>+}
>+thread char* operator&[](thread char4* foo, uint index) {
>+    if (index == 0)
>+        return &foo->x;
>+    if (index == 1)
>+        return &foo->y;
>+    if (index == 2)
>+        return &foo->z;
>+    if (index == 3)
>+        return &foo->w;
>+    trap;
>+}
>+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;
>+}
>+thread short* operator&[](thread short2* foo, uint index) {
>+    if (index == 0)
>+        return &foo->x;
>+    if (index == 1)
>+        return &foo->y;
>+    trap;
>+}
>+thread short* operator&[](thread short3* foo, uint index) {
>+    if (index == 0)
>+        return &foo->x;
>+    if (index == 1)
>+        return &foo->y;
>+    if (index == 2)
>+        return &foo->z;
>+    trap;
>+}
>+thread short* operator&[](thread short4* foo, uint index) {
>+    if (index == 0)
>+        return &foo->x;
>+    if (index == 1)
>+        return &foo->y;
>+    if (index == 2)
>+        return &foo->z;
>+    if (index == 3)
>+        return &foo->w;
>+    trap;
>+}
>+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;
>+}
>+thread int* operator&[](thread int2* foo, uint index) {
>+    if (index == 0)
>+        return &foo->x;
>+    if (index == 1)
>+        return &foo->y;
>+    trap;
>+}
>+thread int* operator&[](thread int3* foo, uint index) {
>+    if (index == 0)
>+        return &foo->x;
>+    if (index == 1)
>+        return &foo->y;
>+    if (index == 2)
>+        return &foo->z;
>+    trap;
>+}
>+thread int* operator&[](thread int4* foo, uint index) {
>+    if (index == 0)
>+        return &foo->x;
>+    if (index == 1)
>+        return &foo->y;
>+    if (index == 2)
>+        return &foo->z;
>+    if (index == 3)
>+        return &foo->w;
>+    trap;
>+}
>+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;
>+}
>+thread half* operator&[](thread half2* foo, uint index) {
>+    if (index == 0)
>+        return &foo->x;
>+    if (index == 1)
>+        return &foo->y;
>+    trap;
>+}
>+thread half* operator&[](thread half3* foo, uint index) {
>+    if (index == 0)
>+        return &foo->x;
>+    if (index == 1)
>+        return &foo->y;
>+    if (index == 2)
>+        return &foo->z;
>+    trap;
>+}
>+thread half* operator&[](thread half4* foo, uint index) {
>+    if (index == 0)
>+        return &foo->x;
>+    if (index == 1)
>+        return &foo->y;
>+    if (index == 2)
>+        return &foo->z;
>+    if (index == 3)
>+        return &foo->w;
>+    trap;
>+}
>+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;
>+}
>+thread float* operator&[](thread float2* foo, uint index) {
>+    if (index == 0)
>+        return &foo->x;
>+    if (index == 1)
>+        return &foo->y;
>+    trap;
>+}
>+thread float* operator&[](thread float3* foo, uint index) {
>+    if (index == 0)
>+        return &foo->x;
>+    if (index == 1)
>+        return &foo->y;
>+    if (index == 2)
>+        return &foo->z;
>+    trap;
>+}
>+thread float* operator&[](thread float4* foo, uint index) {
>+    if (index == 0)
>+        return &foo->x;
>+    if (index == 1)
>+        return &foo->y;
>+    if (index == 2)
>+        return &foo->z;
>+    if (index == 3)
>+        return &foo->w;
>+    trap;
>+}
>+thread half2* operator&[](thread half2x2* foo, uint index) {
>+    if (index == 0)
>+        return &foo->row0;
>+    if (index == 1)
>+        return &foo->row1;
>+    trap;
>+}
>+thread half2* operator&[](thread half3x2* foo, uint index) {
>+    if (index == 0)
>+        return &foo->row0;
>+    if (index == 1)
>+        return &foo->row1;
>+    if (index == 2)
>+        return &foo->row2;
>+    trap;
>+}
>+thread half2* operator&[](thread half4x2* foo, uint index) {
>+    if (index == 0)
>+        return &foo->row0;
>+    if (index == 1)
>+        return &foo->row1;
>+    if (index == 2)
>+        return &foo->row2;
>+    if (index == 3)
>+        return &foo->row3;
>+    trap;
>+}
>+thread half3* operator&[](thread half2x3* foo, uint index) {
>+    if (index == 0)
>+        return &foo->row0;
>+    if (index == 1)
>+        return &foo->row1;
>+    trap;
>+}
>+thread half3* operator&[](thread half3x3* foo, uint index) {
>+    if (index == 0)
>+        return &foo->row0;
>+    if (index == 1)
>+        return &foo->row1;
>+    if (index == 2)
>+        return &foo->row2;
>+    trap;
>+}
>+thread half3* operator&[](thread half4x3* foo, uint index) {
>+    if (index == 0)
>+        return &foo->row0;
>+    if (index == 1)
>+        return &foo->row1;
>+    if (index == 2)
>+        return &foo->row2;
>+    if (index == 3)
>+        return &foo->row3;
>+    trap;
>+}
>+thread half4* operator&[](thread half2x4* foo, uint index) {
>+    if (index == 0)
>+        return &foo->row0;
>+    if (index == 1)
>+        return &foo->row1;
>+    trap;
>+}
>+thread half4* operator&[](thread half3x4* foo, uint index) {
>+    if (index == 0)
>+        return &foo->row0;
>+    if (index == 1)
>+        return &foo->row1;
>+    if (index == 2)
>+        return &foo->row2;
>+    trap;
>+}
>+thread half4* operator&[](thread half4x4* foo, uint index) {
>+    if (index == 0)
>+        return &foo->row0;
>+    if (index == 1)
>+        return &foo->row1;
>+    if (index == 2)
>+        return &foo->row2;
>+    if (index == 3)
>+        return &foo->row3;
>+    trap;
>+}
>+thread float2* operator&[](thread float2x2* foo, uint index) {
>+    if (index == 0)
>+        return &foo->row0;
>+    if (index == 1)
>+        return &foo->row1;
>+    trap;
>+}
>+thread float2* operator&[](thread float3x2* foo, uint index) {
>+    if (index == 0)
>+        return &foo->row0;
>+    if (index == 1)
>+        return &foo->row1;
>+    if (index == 2)
>+        return &foo->row2;
>+    trap;
>+}
>+thread float2* operator&[](thread float4x2* foo, uint index) {
>+    if (index == 0)
>+        return &foo->row0;
>+    if (index == 1)
>+        return &foo->row1;
>+    if (index == 2)
>+        return &foo->row2;
>+    if (index == 3)
>+        return &foo->row3;
>+    trap;
>+}
>+thread float3* operator&[](thread float2x3* foo, uint index) {
>+    if (index == 0)
>+        return &foo->row0;
>+    if (index == 1)
>+        return &foo->row1;
>+    trap;
>+}
>+thread float3* operator&[](thread float3x3* foo, uint index) {
>+    if (index == 0)
>+        return &foo->row0;
>+    if (index == 1)
>+        return &foo->row1;
>+    if (index == 2)
>+        return &foo->row2;
>+    trap;
>+}
>+thread float3* operator&[](thread float4x3* foo, uint index) {
>+    if (index == 0)
>+        return &foo->row0;
>+    if (index == 1)
>+        return &foo->row1;
>+    if (index == 2)
>+        return &foo->row2;
>+    if (index == 3)
>+        return &foo->row3;
>+    trap;
>+}
>+thread float4* operator&[](thread float2x4* foo, uint index) {
>+    if (index == 0)
>+        return &foo->row0;
>+    if (index == 1)
>+        return &foo->row1;
>+    trap;
>+}
>+thread float4* operator&[](thread float3x4* foo, uint index) {
>+    if (index == 0)
>+        return &foo->row0;
>+    if (index == 1)
>+        return &foo->row1;
>+    if (index == 2)
>+        return &foo->row2;
>+    trap;
>+}
>+thread float4* operator&[](thread float4x4* foo, uint index) {
>+    if (index == 0)
>+        return &foo->row0;
>+    if (index == 1)
>+        return &foo->row1;
>+    if (index == 2)
>+        return &foo->row2;
>+    if (index == 3)
>+        return &foo->row3;
>+    trap;
>+}
>+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;
>+}
>+// bool2 operator.xx(bool2 v) {
>+//     bool2 result;
>+//     result.x = v.x;
>+//     result.y = v.x;
>+//     return result;
>+// }
>+// bool2 operator.xy(bool2 v) {
>+//     bool2 result;
>+//     result.x = v.x;
>+//     result.y = v.y;
>+//     return result;
>+// }
>+// bool2 operator.xy=(bool2 v, bool2 c) {
>+//     bool2 result = v;
>+//     result.x = c.x;
>+//     result.y = c.y;
>+//     return result;
>+// }
>+// bool2 operator.yx(bool2 v) {
>+//     bool2 result;
>+//     result.x = v.y;
>+//     result.y = v.x;
>+//     return result;
>+// }
>+// bool2 operator.yx=(bool2 v, bool2 c) {
>+//     bool2 result = v;
>+//     result.y = c.x;
>+//     result.x = c.y;
>+//     return result;
>+// }
>+// bool2 operator.yy(bool2 v) {
>+//     bool2 result;
>+//     result.x = v.y;
>+//     result.y = v.y;
>+//     return result;
>+// }
>+// bool2 operator.xx(bool3 v) {
>+//     bool2 result;
>+//     result.x = v.x;
>+//     result.y = v.x;
>+//     return result;
>+// }
>+// bool2 operator.xy(bool3 v) {
>+//     bool2 result;
>+//     result.x = v.x;
>+//     result.y = v.y;
>+//     return result;
>+// }
>+// bool3 operator.xy=(bool3 v, bool2 c) {
>+//     bool3 result = v;
>+//     result.x = c.x;
>+//     result.y = c.y;
>+//     return result;
>+// }
>+// bool2 operator.xz(bool3 v) {
>+//     bool2 result;
>+//     result.x = v.x;
>+//     result.y = v.z;
>+//     return result;
>+// }
>+// bool3 operator.xz=(bool3 v, bool2 c) {
>+//     bool3 result = v;
>+//     result.x = c.x;
>+//     result.z = c.y;
>+//     return result;
>+// }
>+// bool2 operator.yx(bool3 v) {
>+//     bool2 result;
>+//     result.x = v.y;
>+//     result.y = v.x;
>+//     return result;
>+// }
>+// bool3 operator.yx=(bool3 v, bool2 c) {
>+//     bool3 result = v;
>+//     result.y = c.x;
>+//     result.x = c.y;
>+//     return result;
>+// }
>+// bool2 operator.yy(bool3 v) {
>+//     bool2 result;
>+//     result.x = v.y;
>+//     result.y = v.y;
>+//     return result;
>+// }
>+// bool2 operator.yz(bool3 v) {
>+//     bool2 result;
>+//     result.x = v.y;
>+//     result.y = v.z;
>+//     return result;
>+// }
>+// bool3 operator.yz=(bool3 v, bool2 c) {
>+//     bool3 result = v;
>+//     result.y = c.x;
>+//     result.z = c.y;
>+//     return result;
>+// }
>+// bool2 operator.zx(bool3 v) {
>+//     bool2 result;
>+//     result.x = v.z;
>+//     result.y = v.x;
>+//     return result;
>+// }
>+// bool3 operator.zx=(bool3 v, bool2 c) {
>+//     bool3 result = v;
>+//     result.z = c.x;
>+//     result.x = c.y;
>+//     return result;
>+// }
>+// bool2 operator.zy(bool3 v) {
>+//     bool2 result;
>+//     result.x = v.z;
>+//     result.y = v.y;
>+//     return result;
>+// }
>+// bool3 operator.zy=(bool3 v, bool2 c) {
>+//     bool3 result = v;
>+//     result.z = c.x;
>+//     result.y = c.y;
>+//     return result;
>+// }
>+// bool2 operator.zz(bool3 v) {
>+//     bool2 result;
>+//     result.x = v.z;
>+//     result.y = v.z;
>+//     return result;
>+// }
>+// bool2 operator.xx(bool4 v) {
>+//     bool2 result;
>+//     result.x = v.x;
>+//     result.y = v.x;
>+//     return result;
>+// }
>+// bool2 operator.xy(bool4 v) {
>+//     bool2 result;
>+//     result.x = v.x;
>+//     result.y = v.y;
>+//     return result;
>+// }
>+// bool4 operator.xy=(bool4 v, bool2 c) {
>+//     bool4 result = v;
>+//     result.x = c.x;
>+//     result.y = c.y;
>+//     return result;
>+// }
>+// bool2 operator.xz(bool4 v) {
>+//     bool2 result;
>+//     result.x = v.x;
>+//     result.y = v.z;
>+//     return result;
>+// }
>+// bool4 operator.xz=(bool4 v, bool2 c) {
>+//     bool4 result = v;
>+//     result.x = c.x;
>+//     result.z = c.y;
>+//     return result;
>+// }
>+// bool2 operator.xw(bool4 v) {
>+//     bool2 result;
>+//     result.x = v.x;
>+//     result.y = v.w;
>+//     return result;
>+// }
>+// bool4 operator.xw=(bool4 v, bool2 c) {
>+//     bool4 result = v;
>+//     result.x = c.x;
>+//     result.w = c.y;
>+//     return result;
>+// }
>+// bool2 operator.yx(bool4 v) {
>+//     bool2 result;
>+//     result.x = v.y;
>+//     result.y = v.x;
>+//     return result;
>+// }
>+// bool4 operator.yx=(bool4 v, bool2 c) {
>+//     bool4 result = v;
>+//     result.y = c.x;
>+//     result.x = c.y;
>+//     return result;
>+// }
>+// bool2 operator.yy(bool4 v) {
>+//     bool2 result;
>+//     result.x = v.y;
>+//     result.y = v.y;
>+//     return result;
>+// }
>+// bool2 operator.yz(bool4 v) {
>+//     bool2 result;
>+//     result.x = v.y;
>+//     result.y = v.z;
>+//     return result;
>+// }
>+// bool4 operator.yz=(bool4 v, bool2 c) {
>+//     bool4 result = v;
>+//     result.y = c.x;
>+//     result.z = c.y;
>+//     return result;
>+// }
>+// bool2 operator.yw(bool4 v) {
>+//     bool2 result;
>+//     result.x = v.y;
>+//     result.y = v.w;
>+//     return result;
>+// }
>+// bool4 operator.yw=(bool4 v, bool2 c) {
>+//     bool4 result = v;
>+//     result.y = c.x;
>+//     result.w = c.y;
>+//     return result;
>+// }
>+// bool2 operator.zx(bool4 v) {
>+//     bool2 result;
>+//     result.x = v.z;
>+//     result.y = v.x;
>+//     return result;
>+// }
>+// bool4 operator.zx=(bool4 v, bool2 c) {
>+//     bool4 result = v;
>+//     result.z = c.x;
>+//     result.x = c.y;
>+//     return result;
>+// }
>+// bool2 operator.zy(bool4 v) {
>+//     bool2 result;
>+//     result.x = v.z;
>+//     result.y = v.y;
>+//     return result;
>+// }
>+// bool4 operator.zy=(bool4 v, bool2 c) {
>+//     bool4 result = v;
>+//     result.z = c.x;
>+//     result.y = c.y;
>+//     return result;
>+// }
>+// bool2 operator.zz(bool4 v) {
>+//     bool2 result;
>+//     result.x = v.z;
>+//     result.y = v.z;
>+//     return result;
>+// }
>+// bool2 operator.zw(bool4 v) {
>+//     bool2 result;
>+//     result.x = v.z;
>+//     result.y = v.w;
>+//     return result;
>+// }
>+// bool4 operator.zw=(bool4 v, bool2 c) {
>+//     bool4 result = v;
>+//     result.z = c.x;
>+//     result.w = c.y;
>+//     return result;
>+// }
>+// bool2 operator.wx(bool4 v) {
>+//     bool2 result;
>+//     result.x = v.w;
>+//     result.y = v.x;
>+//     return result;
>+// }
>+// bool4 operator.wx=(bool4 v, bool2 c) {
>+//     bool4 result = v;
>+//     result.w = c.x;
>+//     result.x = c.y;
>+//     return result;
>+// }
>+// bool2 operator.wy(bool4 v) {
>+//     bool2 result;
>+//     result.x = v.w;
>+//     result.y = v.y;
>+//     return result;
>+// }
>+// bool4 operator.wy=(bool4 v, bool2 c) {
>+//     bool4 result = v;
>+//     result.w = c.x;
>+//     result.y = c.y;
>+//     return result;
>+// }
>+// bool2 operator.wz(bool4 v) {
>+//     bool2 result;
>+//     result.x = v.w;
>+//     result.y = v.z;
>+//     return result;
>+// }
>+// bool4 operator.wz=(bool4 v, bool2 c) {
>+//     bool4 result = v;
>+//     result.w = c.x;
>+//     result.z = c.y;
>+//     return result;
>+// }
>+// bool2 operator.ww(bool4 v) {
>+//     bool2 result;
>+//     result.x = v.w;
>+//     result.y = v.w;
>+//     return result;
>+// }
>+// bool3 operator.xxx(bool2 v) {
>+//     bool3 result;
>+//     result.x = v.x;
>+//     result.y = v.x;
>+//     result.z = v.x;
>+//     return result;
>+// }
>+// bool3 operator.xxy(bool2 v) {
>+//     bool3 result;
>+//     result.x = v.x;
>+//     result.y = v.x;
>+//     result.z = v.y;
>+//     return result;
>+// }
>+// bool3 operator.xyx(bool2 v) {
>+//     bool3 result;
>+//     result.x = v.x;
>+//     result.y = v.y;
>+//     result.z = v.x;
>+//     return result;
>+// }
>+// bool3 operator.xyy(bool2 v) {
>+//     bool3 result;
>+//     result.x = v.x;
>+//     result.y = v.y;
>+//     result.z = v.y;
>+//     return result;
>+// }
>+// bool3 operator.yxx(bool2 v) {
>+//     bool3 result;
>+//     result.x = v.y;
>+//     result.y = v.x;
>+//     result.z = v.x;
>+//     return result;
>+// }
>+// bool3 operator.yxy(bool2 v) {
>+//     bool3 result;
>+//     result.x = v.y;
>+//     result.y = v.x;
>+//     result.z = v.y;
>+//     return result;
>+// }
>+// bool3 operator.yyx(bool2 v) {
>+//     bool3 result;
>+//     result.x = v.y;
>+//     result.y = v.y;
>+//     result.z = v.x;
>+//     return result;
>+// }
>+// bool3 operator.yyy(bool2 v) {
>+//     bool3 result;
>+//     result.x = v.y;
>+//     result.y = v.y;
>+//     result.z = v.y;
>+//     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.xxy(bool3 v) {
>+//     bool3 result;
>+//     result.x = v.x;
>+//     result.y = v.x;
>+//     result.z = v.y;
>+//     return result;
>+// }
>+// bool3 operator.xxz(bool3 v) {
>+//     bool3 result;
>+//     result.x = v.x;
>+//     result.y = v.x;
>+//     result.z = v.z;
>+//     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.xyy(bool3 v) {
>+//     bool3 result;
>+//     result.x = v.x;
>+//     result.y = v.y;
>+//     result.z = v.y;
>+//     return result;
>+// }
>+// bool3 operator.xyz(bool3 v) {
>+//     bool3 result;
>+//     result.x = v.x;
>+//     result.y = v.y;
>+//     result.z = v.z;
>+//     return result;
>+// }
>+// bool3 operator.xyz=(bool3 v, bool3 c) {
>+//     bool3 result = v;
>+//     result.x = c.x;
>+//     result.y = c.y;
>+//     result.z = c.z;
>+//     return result;
>+// }
>+// bool3 operator.xzx(bool3 v) {
>+//     bool3 result;
>+//     result.x = v.x;
>+//     result.y = v.z;
>+//     result.z = v.x;
>+//     return result;
>+// }
>+// bool3 operator.xzy(bool3 v) {
>+//     bool3 result;
>+//     result.x = v.x;
>+//     result.y = v.z;
>+//     result.z = v.y;
>+//     return result;
>+// }
>+// bool3 operator.xzy=(bool3 v, bool3 c) {
>+//     bool3 result = v;
>+//     result.x = c.x;
>+//     result.z = c.y;
>+//     result.y = c.z;
>+//     return result;
>+// }
>+// bool3 operator.xzz(bool3 v) {
>+//     bool3 result;
>+//     result.x = v.x;
>+//     result.y = v.z;
>+//     result.z = v.z;
>+//     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.yxy(bool3 v) {
>+//     bool3 result;
>+//     result.x = v.y;
>+//     result.y = v.x;
>+//     result.z = v.y;
>+//     return result;
>+// }
>+// bool3 operator.yxz(bool3 v) {
>+//     bool3 result;
>+//     result.x = v.y;
>+//     result.y = v.x;
>+//     result.z = v.z;
>+//     return result;
>+// }
>+// bool3 operator.yxz=(bool3 v, bool3 c) {
>+//     bool3 result = v;
>+//     result.y = c.x;
>+//     result.x = c.y;
>+//     result.z = c.z;
>+//     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.yyy(bool3 v) {
>+//     bool3 result;
>+//     result.x = v.y;
>+//     result.y = v.y;
>+//     result.z = v.y;
>+//     return result;
>+// }
>+// bool3 operator.yyz(bool3 v) {
>+//     bool3 result;
>+//     result.x = v.y;
>+//     result.y = v.y;
>+//     result.z = v.z;
>+//     return result;
>+// }
>+// bool3 operator.yzx(bool3 v) {
>+//     bool3 result;
>+//     result.x = v.y;
>+//     result.y = v.z;
>+//     result.z = v.x;
>+//     return result;
>+// }
>+// bool3 operator.yzx=(bool3 v, bool3 c) {
>+//     bool3 result = v;
>+//     result.y = c.x;
>+//     result.z = c.y;
>+//     result.x = c.z;
>+//     return result;
>+// }
>+// bool3 operator.yzy(bool3 v) {
>+//     bool3 result;
>+//     result.x = v.y;
>+//     result.y = v.z;
>+//     result.z = v.y;
>+//     return result;
>+// }
>+// bool3 operator.yzz(bool3 v) {
>+//     bool3 result;
>+//     result.x = v.y;
>+//     result.y = v.z;
>+//     result.z = v.z;
>+//     return result;
>+// }
>+// bool3 operator.zxx(bool3 v) {
>+//     bool3 result;
>+//     result.x = v.z;
>+//     result.y = v.x;
>+//     result.z = v.x;
>+//     return result;
>+// }
>+// bool3 operator.zxy(bool3 v) {
>+//     bool3 result;
>+//     result.x = v.z;
>+//     result.y = v.x;
>+//     result.z = v.y;
>+//     return result;
>+// }
>+// bool3 operator.zxy=(bool3 v, bool3 c) {
>+//     bool3 result = v;
>+//     result.z = c.x;
>+//     result.x = c.y;
>+//     result.y = c.z;
>+//     return result;
>+// }
>+// bool3 operator.zxz(bool3 v) {
>+//     bool3 result;
>+//     result.x = v.z;
>+//     result.y = v.x;
>+//     result.z = v.z;
>+//     return result;
>+// }
>+// bool3 operator.zyx(bool3 v) {
>+//     bool3 result;
>+//     result.x = v.z;
>+//     result.y = v.y;
>+//     result.z = v.x;
>+//     return result;
>+// }
>+// bool3 operator.zyx=(bool3 v, bool3 c) {
>+//     bool3 result = v;
>+//     result.z = c.x;
>+//     result.y = c.y;
>+//     result.x = c.z;
>+//     return result;
>+// }
>+// bool3 operator.zyy(bool3 v) {
>+//     bool3 result;
>+//     result.x = v.z;
>+//     result.y = v.y;
>+//     result.z = v.y;
>+//     return result;
>+// }
>+// bool3 operator.zyz(bool3 v) {
>+//     bool3 result;
>+//     result.x = v.z;
>+//     result.y = v.y;
>+//     result.z = v.z;
>+//     return result;
>+// }
>+// bool3 operator.zzx(bool3 v) {
>+//     bool3 result;
>+//     result.x = v.z;
>+//     result.y = v.z;
>+//     result.z = v.x;
>+//     return result;
>+// }
>+// bool3 operator.zzy(bool3 v) {
>+//     bool3 result;
>+//     result.x = v.z;
>+//     result.y = v.z;
>+//     result.z = v.y;
>+//     return result;
>+// }
>+// bool3 operator.zzz(bool3 v) {
>+//     bool3 result;
>+//     result.x = v.z;
>+//     result.y = v.z;
>+//     result.z = v.z;
>+//     return result;
>+// }
>+// bool3 operator.xxx(bool4 v) {
>+//     bool3 result;
>+//     result.x = v.x;
>+//     result.y = v.x;
>+//     result.z = v.x;
>+//     return result;
>+// }
>+// bool3 operator.xxy(bool4 v) {
>+//     bool3 result;
>+//     result.x = v.x;
>+//     result.y = v.x;
>+//     result.z = v.y;
>+//     return result;
>+// }
>+// bool3 operator.xxz(bool4 v) {
>+//     bool3 result;
>+//     result.x = v.x;
>+//     result.y = v.x;
>+//     result.z = v.z;
>+//     return result;
>+// }
>+// bool3 operator.xxw(bool4 v) {
>+//     bool3 result;
>+//     result.x = v.x;
>+//     result.y = v.x;
>+//     result.z = v.w;
>+//     return result;
>+// }
>+// bool3 operator.xyx(bool4 v) {
>+//     bool3 result;
>+//     result.x = v.x;
>+//     result.y = v.y;
>+//     result.z = v.x;
>+//     return result;
>+// }
>+// bool3 operator.xyy(bool4 v) {
>+//     bool3 result;
>+//     result.x = v.x;
>+//     result.y = v.y;
>+//     result.z = v.y;
>+//     return result;
>+// }
>+// bool3 operator.xyz(bool4 v) {
>+//     bool3 result;
>+//     result.x = v.x;
>+//     result.y = v.y;
>+//     result.z = v.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;
>+// }
>+// bool3 operator.xyw(bool4 v) {
>+//     bool3 result;
>+//     result.x = v.x;
>+//     result.y = v.y;
>+//     result.z = v.w;
>+//     return result;
>+// }
>+// bool4 operator.xyw=(bool4 v, bool3 c) {
>+//     bool4 result = v;
>+//     result.x = c.x;
>+//     result.y = c.y;
>+//     result.w = c.z;
>+//     return result;
>+// }
>+// bool3 operator.xzx(bool4 v) {
>+//     bool3 result;
>+//     result.x = v.x;
>+//     result.y = v.z;
>+//     result.z = v.x;
>+//     return result;
>+// }
>+// bool3 operator.xzy(bool4 v) {
>+//     bool3 result;
>+//     result.x = v.x;
>+//     result.y = v.z;
>+//     result.z = v.y;
>+//     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;
>+// }
>+// bool3 operator.xzz(bool4 v) {
>+//     bool3 result;
>+//     result.x = v.x;
>+//     result.y = v.z;
>+//     result.z = v.z;
>+//     return result;
>+// }
>+// bool3 operator.xzw(bool4 v) {
>+//     bool3 result;
>+//     result.x = v.x;
>+//     result.y = v.z;
>+//     result.z = v.w;
>+//     return result;
>+// }
>+// bool4 operator.xzw=(bool4 v, bool3 c) {
>+//     bool4 result = v;
>+//     result.x = c.x;
>+//     result.z = c.y;
>+//     result.w = c.z;
>+//     return result;
>+// }
>+// bool3 operator.xwx(bool4 v) {
>+//     bool3 result;
>+//     result.x = v.x;
>+//     result.y = v.w;
>+//     result.z = v.x;
>+//     return result;
>+// }
>+// bool3 operator.xwy(bool4 v) {
>+//     bool3 result;
>+//     result.x = v.x;
>+//     result.y = v.w;
>+//     result.z = v.y;
>+//     return result;
>+// }
>+// bool4 operator.xwy=(bool4 v, bool3 c) {
>+//     bool4 result = v;
>+//     result.x = c.x;
>+//     result.w = c.y;
>+//     result.y = c.z;
>+//     return result;
>+// }
>+// bool3 operator.xwz(bool4 v) {
>+//     bool3 result;
>+//     result.x = v.x;
>+//     result.y = v.w;
>+//     result.z = v.z;
>+//     return result;
>+// }
>+// bool4 operator.xwz=(bool4 v, bool3 c) {
>+//     bool4 result = v;
>+//     result.x = c.x;
>+//     result.w = c.y;
>+//     result.z = c.z;
>+//     return result;
>+// }
>+// bool3 operator.xww(bool4 v) {
>+//     bool3 result;
>+//     result.x = v.x;
>+//     result.y = v.w;
>+//     result.z = v.w;
>+//     return result;
>+// }
>+// bool3 operator.yxx(bool4 v) {
>+//     bool3 result;
>+//     result.x = v.y;
>+//     result.y = v.x;
>+//     result.z = v.x;
>+//     return result;
>+// }
>+// bool3 operator.yxy(bool4 v) {
>+//     bool3 result;
>+//     result.x = v.y;
>+//     result.y = v.x;
>+//     result.z = v.y;
>+//     return result;
>+// }
>+// bool3 operator.yxz(bool4 v) {
>+//     bool3 result;
>+//     result.x = v.y;
>+//     result.y = v.x;
>+//     result.z = v.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;
>+// }
>+// bool3 operator.yxw(bool4 v) {
>+//     bool3 result;
>+//     result.x = v.y;
>+//     result.y = v.x;
>+//     result.z = v.w;
>+//     return result;
>+// }
>+// bool4 operator.yxw=(bool4 v, bool3 c) {
>+//     bool4 result = v;
>+//     result.y = c.x;
>+//     result.x = c.y;
>+//     result.w = c.z;
>+//     return result;
>+// }
>+// bool3 operator.yyx(bool4 v) {
>+//     bool3 result;
>+//     result.x = v.y;
>+//     result.y = v.y;
>+//     result.z = v.x;
>+//     return result;
>+// }
>+// bool3 operator.yyy(bool4 v) {
>+//     bool3 result;
>+//     result.x = v.y;
>+//     result.y = v.y;
>+//     result.z = v.y;
>+//     return result;
>+// }
>+// bool3 operator.yyz(bool4 v) {
>+//     bool3 result;
>+//     result.x = v.y;
>+//     result.y = v.y;
>+//     result.z = v.z;
>+//     return result;
>+// }
>+// bool3 operator.yyw(bool4 v) {
>+//     bool3 result;
>+//     result.x = v.y;
>+//     result.y = v.y;
>+//     result.z = v.w;
>+//     return result;
>+// }
>+// bool3 operator.yzx(bool4 v) {
>+//     bool3 result;
>+//     result.x = v.y;
>+//     result.y = v.z;
>+//     result.z = v.x;
>+//     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;
>+// }
>+// bool3 operator.yzy(bool4 v) {
>+//     bool3 result;
>+//     result.x = v.y;
>+//     result.y = v.z;
>+//     result.z = v.y;
>+//     return result;
>+// }
>+// bool3 operator.yzz(bool4 v) {
>+//     bool3 result;
>+//     result.x = v.y;
>+//     result.y = v.z;
>+//     result.z = v.z;
>+//     return result;
>+// }
>+// bool3 operator.yzw(bool4 v) {
>+//     bool3 result;
>+//     result.x = v.y;
>+//     result.y = v.z;
>+//     result.z = v.w;
>+//     return result;
>+// }
>+// bool4 operator.yzw=(bool4 v, bool3 c) {
>+//     bool4 result = v;
>+//     result.y = c.x;
>+//     result.z = c.y;
>+//     result.w = c.z;
>+//     return result;
>+// }
>+// bool3 operator.ywx(bool4 v) {
>+//     bool3 result;
>+//     result.x = v.y;
>+//     result.y = v.w;
>+//     result.z = v.x;
>+//     return result;
>+// }
>+// bool4 operator.ywx=(bool4 v, bool3 c) {
>+//     bool4 result = v;
>+//     result.y = c.x;
>+//     result.w = c.y;
>+//     result.x = c.z;
>+//     return result;
>+// }
>+// bool3 operator.ywy(bool4 v) {
>+//     bool3 result;
>+//     result.x = v.y;
>+//     result.y = v.w;
>+//     result.z = v.y;
>+//     return result;
>+// }
>+// bool3 operator.ywz(bool4 v) {
>+//     bool3 result;
>+//     result.x = v.y;
>+//     result.y = v.w;
>+//     result.z = v.z;
>+//     return result;
>+// }
>+// bool4 operator.ywz=(bool4 v, bool3 c) {
>+//     bool4 result = v;
>+//     result.y = c.x;
>+//     result.w = c.y;
>+//     result.z = c.z;
>+//     return result;
>+// }
>+// bool3 operator.yww(bool4 v) {
>+//     bool3 result;
>+//     result.x = v.y;
>+//     result.y = v.w;
>+//     result.z = v.w;
>+//     return result;
>+// }
>+// bool3 operator.zxx(bool4 v) {
>+//     bool3 result;
>+//     result.x = v.z;
>+//     result.y = v.x;
>+//     result.z = v.x;
>+//     return result;
>+// }
>+// bool3 operator.zxy(bool4 v) {
>+//     bool3 result;
>+//     result.x = v.z;
>+//     result.y = v.x;
>+//     result.z = v.y;
>+//     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;
>+// }
>+// bool3 operator.zxz(bool4 v) {
>+//     bool3 result;
>+//     result.x = v.z;
>+//     result.y = v.x;
>+//     result.z = v.z;
>+//     return result;
>+// }
>+// bool3 operator.zxw(bool4 v) {
>+//     bool3 result;
>+//     result.x = v.z;
>+//     result.y = v.x;
>+//     result.z = v.w;
>+//     return result;
>+// }
>+// bool4 operator.zxw=(bool4 v, bool3 c) {
>+//     bool4 result = v;
>+//     result.z = c.x;
>+//     result.x = c.y;
>+//     result.w = c.z;
>+//     return result;
>+// }
>+// bool3 operator.zyx(bool4 v) {
>+//     bool3 result;
>+//     result.x = v.z;
>+//     result.y = v.y;
>+//     result.z = v.x;
>+//     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;
>+// }
>+// bool3 operator.zyy(bool4 v) {
>+//     bool3 result;
>+//     result.x = v.z;
>+//     result.y = v.y;
>+//     result.z = v.y;
>+//     return result;
>+// }
>+// bool3 operator.zyz(bool4 v) {
>+//     bool3 result;
>+//     result.x = v.z;
>+//     result.y = v.y;
>+//     result.z = v.z;
>+//     return result;
>+// }
>+// bool3 operator.zyw(bool4 v) {
>+//     bool3 result;
>+//     result.x = v.z;
>+//     result.y = v.y;
>+//     result.z = v.w;
>+//     return result;
>+// }
>+// bool4 operator.zyw=(bool4 v, bool3 c) {
>+//     bool4 result = v;
>+//     result.z = c.x;
>+//     result.y = c.y;
>+//     result.w = c.z;
>+//     return result;
>+// }
>+// bool3 operator.zzx(bool4 v) {
>+//     bool3 result;
>+//     result.x = v.z;
>+//     result.y = v.z;
>+//     result.z = v.x;
>+//     return result;
>+// }
>+// bool3 operator.zzy(bool4 v) {
>+//     bool3 result;
>+//     result.x = v.z;
>+//     result.y = v.z;
>+//     result.z = v.y;
>+//     return result;
>+// }
>+// bool3 operator.zzz(bool4 v) {
>+//     bool3 result;
>+//     result.x = v.z;
>+//     result.y = v.z;
>+//     result.z = v.z;
>+//     return result;
>+// }
>+// bool3 operator.zzw(bool4 v) {
>+//     bool3 result;
>+//     result.x = v.z;
>+//     result.y = v.z;
>+//     result.z = v.w;
>+//     return result;
>+// }
>+// bool3 operator.zwx(bool4 v) {
>+//     bool3 result;
>+//     result.x = v.z;
>+//     result.y = v.w;
>+//     result.z = v.x;
>+//     return result;
>+// }
>+// bool4 operator.zwx=(bool4 v, bool3 c) {
>+//     bool4 result = v;
>+//     result.z = c.x;
>+//     result.w = c.y;
>+//     result.x = c.z;
>+//     return result;
>+// }
>+// bool3 operator.zwy(bool4 v) {
>+//     bool3 result;
>+//     result.x = v.z;
>+//     result.y = v.w;
>+//     result.z = v.y;
>+//     return result;
>+// }
>+// bool4 operator.zwy=(bool4 v, bool3 c) {
>+//     bool4 result = v;
>+//     result.z = c.x;
>+//     result.w = c.y;
>+//     result.y = c.z;
>+//     return result;
>+// }
>+// bool3 operator.zwz(bool4 v) {
>+//     bool3 result;
>+//     result.x = v.z;
>+//     result.y = v.w;
>+//     result.z = v.z;
>+//     return result;
>+// }
>+// bool3 operator.zww(bool4 v) {
>+//     bool3 result;
>+//     result.x = v.z;
>+//     result.y = v.w;
>+//     result.z = v.w;
>+//     return result;
>+// }
>+// bool3 operator.wxx(bool4 v) {
>+//     bool3 result;
>+//     result.x = v.w;
>+//     result.y = v.x;
>+//     result.z = v.x;
>+//     return result;
>+// }
>+// bool3 operator.wxy(bool4 v) {
>+//     bool3 result;
>+//     result.x = v.w;
>+//     result.y = v.x;
>+//     result.z = v.y;
>+//     return result;
>+// }
>+// bool4 operator.wxy=(bool4 v, bool3 c) {
>+//     bool4 result = v;
>+//     result.w = c.x;
>+//     result.x = c.y;
>+//     result.y = c.z;
>+//     return result;
>+// }
>+// bool3 operator.wxz(bool4 v) {
>+//     bool3 result;
>+//     result.x = v.w;
>+//     result.y = v.x;
>+//     result.z = v.z;
>+//     return result;
>+// }
>+// bool4 operator.wxz=(bool4 v, bool3 c) {
>+//     bool4 result = v;
>+//     result.w = c.x;
>+//     result.x = c.y;
>+//     result.z = c.z;
>+//     return result;
>+// }
>+// bool3 operator.wxw(bool4 v) {
>+//     bool3 result;
>+//     result.x = v.w;
>+//     result.y = v.x;
>+//     result.z = v.w;
>+//     return result;
>+// }
>+// bool3 operator.wyx(bool4 v) {
>+//     bool3 result;
>+//     result.x = v.w;
>+//     result.y = v.y;
>+//     result.z = v.x;
>+//     return result;
>+// }
>+// bool4 operator.wyx=(bool4 v, bool3 c) {
>+//     bool4 result = v;
>+//     result.w = c.x;
>+//     result.y = c.y;
>+//     result.x = c.z;
>+//     return result;
>+// }
>+// bool3 operator.wyy(bool4 v) {
>+//     bool3 result;
>+//     result.x = v.w;
>+//     result.y = v.y;
>+//     result.z = v.y;
>+//     return result;
>+// }
>+// bool3 operator.wyz(bool4 v) {
>+//     bool3 result;
>+//     result.x = v.w;
>+//     result.y = v.y;
>+//     result.z = v.z;
>+//     return result;
>+// }
>+// bool4 operator.wyz=(bool4 v, bool3 c) {
>+//     bool4 result = v;
>+//     result.w = c.x;
>+//     result.y = c.y;
>+//     result.z = c.z;
>+//     return result;
>+// }
>+// bool3 operator.wyw(bool4 v) {
>+//     bool3 result;
>+//     result.x = v.w;
>+//     result.y = v.y;
>+//     result.z = v.w;
>+//     return result;
>+// }
>+// bool3 operator.wzx(bool4 v) {
>+//     bool3 result;
>+//     result.x = v.w;
>+//     result.y = v.z;
>+//     result.z = v.x;
>+//     return result;
>+// }
>+// bool4 operator.wzx=(bool4 v, bool3 c) {
>+//     bool4 result = v;
>+//     result.w = c.x;
>+//     result.z = c.y;
>+//     result.x = c.z;
>+//     return result;
>+// }
>+// bool3 operator.wzy(bool4 v) {
>+//     bool3 result;
>+//     result.x = v.w;
>+//     result.y = v.z;
>+//     result.z = v.y;
>+//     return result;
>+// }
>+// bool4 operator.wzy=(bool4 v, bool3 c) {
>+//     bool4 result = v;
>+//     result.w = c.x;
>+//     result.z = c.y;
>+//     result.y = c.z;
>+//     return result;
>+// }
>+// bool3 operator.wzz(bool4 v) {
>+//     bool3 result;
>+//     result.x = v.w;
>+//     result.y = v.z;
>+//     result.z = v.z;
>+//     return result;
>+// }
>+// bool3 operator.wzw(bool4 v) {
>+//     bool3 result;
>+//     result.x = v.w;
>+//     result.y = v.z;
>+//     result.z = v.w;
>+//     return result;
>+// }
>+// bool3 operator.wwx(bool4 v) {
>+//     bool3 result;
>+//     result.x = v.w;
>+//     result.y = v.w;
>+//     result.z = v.x;
>+//     return result;
>+// }
>+// bool3 operator.wwy(bool4 v) {
>+//     bool3 result;
>+//     result.x = v.w;
>+//     result.y = v.w;
>+//     result.z = v.y;
>+//     return result;
>+// }
>+// bool3 operator.wwz(bool4 v) {
>+//     bool3 result;
>+//     result.x = v.w;
>+//     result.y = v.w;
>+//     result.z = v.z;
>+//     return result;
>+// }
>+// bool3 operator.www(bool4 v) {
>+//     bool3 result;
>+//     result.x = v.w;
>+//     result.y = v.w;
>+//     result.z = v.w;
>+//     return result;
>+// }
>+// 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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.zyxy(bool3 v) {
>+//     bool4 result;
>+//     result.x = v.z;
>+//     result.y = v.y;
>+//     result.z = v.x;
>+//     result.w = v.y;
>+//     return result;
>+// }
>+// 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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.xxxx(bool4 v) {
>+//     bool4 result;
>+//     result.x = v.x;
>+//     result.y = v.x;
>+//     result.z = v.x;
>+//     result.w = v.x;
>+//     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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// uchar2 operator.xx(uchar2 v) {
>+//     uchar2 result;
>+//     result.x = v.x;
>+//     result.y = v.x;
>+//     return result;
>+// }
>+// uchar2 operator.xy(uchar2 v) {
>+//     uchar2 result;
>+//     result.x = v.x;
>+//     result.y = v.y;
>+//     return result;
>+// }
>+// uchar2 operator.xy=(uchar2 v, uchar2 c) {
>+//     uchar2 result = v;
>+//     result.x = c.x;
>+//     result.y = c.y;
>+//     return result;
>+// }
>+// uchar2 operator.yx(uchar2 v) {
>+//     uchar2 result;
>+//     result.x = v.y;
>+//     result.y = v.x;
>+//     return result;
>+// }
>+// uchar2 operator.yx=(uchar2 v, uchar2 c) {
>+//     uchar2 result = v;
>+//     result.y = c.x;
>+//     result.x = c.y;
>+//     return result;
>+// }
>+// uchar2 operator.yy(uchar2 v) {
>+//     uchar2 result;
>+//     result.x = v.y;
>+//     result.y = v.y;
>+//     return result;
>+// }
>+// uchar2 operator.xx(uchar3 v) {
>+//     uchar2 result;
>+//     result.x = v.x;
>+//     result.y = v.x;
>+//     return result;
>+// }
>+// uchar2 operator.xy(uchar3 v) {
>+//     uchar2 result;
>+//     result.x = v.x;
>+//     result.y = v.y;
>+//     return result;
>+// }
>+// uchar3 operator.xy=(uchar3 v, uchar2 c) {
>+//     uchar3 result = v;
>+//     result.x = c.x;
>+//     result.y = c.y;
>+//     return result;
>+// }
>+// uchar2 operator.xz(uchar3 v) {
>+//     uchar2 result;
>+//     result.x = v.x;
>+//     result.y = v.z;
>+//     return result;
>+// }
>+// uchar3 operator.xz=(uchar3 v, uchar2 c) {
>+//     uchar3 result = v;
>+//     result.x = c.x;
>+//     result.z = c.y;
>+//     return result;
>+// }
>+// uchar2 operator.yx(uchar3 v) {
>+//     uchar2 result;
>+//     result.x = v.y;
>+//     result.y = v.x;
>+//     return result;
>+// }
>+// uchar3 operator.yx=(uchar3 v, uchar2 c) {
>+//     uchar3 result = v;
>+//     result.y = c.x;
>+//     result.x = c.y;
>+//     return result;
>+// }
>+// uchar2 operator.yy(uchar3 v) {
>+//     uchar2 result;
>+//     result.x = v.y;
>+//     result.y = v.y;
>+//     return result;
>+// }
>+// uchar2 operator.yz(uchar3 v) {
>+//     uchar2 result;
>+//     result.x = v.y;
>+//     result.y = v.z;
>+//     return result;
>+// }
>+// uchar3 operator.yz=(uchar3 v, uchar2 c) {
>+//     uchar3 result = v;
>+//     result.y = c.x;
>+//     result.z = c.y;
>+//     return result;
>+// }
>+// uchar2 operator.zx(uchar3 v) {
>+//     uchar2 result;
>+//     result.x = v.z;
>+//     result.y = v.x;
>+//     return result;
>+// }
>+// uchar3 operator.zx=(uchar3 v, uchar2 c) {
>+//     uchar3 result = v;
>+//     result.z = c.x;
>+//     result.x = c.y;
>+//     return result;
>+// }
>+// uchar2 operator.zy(uchar3 v) {
>+//     uchar2 result;
>+//     result.x = v.z;
>+//     result.y = v.y;
>+//     return result;
>+// }
>+// uchar3 operator.zy=(uchar3 v, uchar2 c) {
>+//     uchar3 result = v;
>+//     result.z = c.x;
>+//     result.y = c.y;
>+//     return result;
>+// }
>+// uchar2 operator.zz(uchar3 v) {
>+//     uchar2 result;
>+//     result.x = v.z;
>+//     result.y = v.z;
>+//     return result;
>+// }
>+// uchar2 operator.xx(uchar4 v) {
>+//     uchar2 result;
>+//     result.x = v.x;
>+//     result.y = v.x;
>+//     return result;
>+// }
>+// uchar2 operator.xy(uchar4 v) {
>+//     uchar2 result;
>+//     result.x = v.x;
>+//     result.y = v.y;
>+//     return result;
>+// }
>+// uchar4 operator.xy=(uchar4 v, uchar2 c) {
>+//     uchar4 result = v;
>+//     result.x = c.x;
>+//     result.y = c.y;
>+//     return result;
>+// }
>+// uchar2 operator.xz(uchar4 v) {
>+//     uchar2 result;
>+//     result.x = v.x;
>+//     result.y = v.z;
>+//     return result;
>+// }
>+// uchar4 operator.xz=(uchar4 v, uchar2 c) {
>+//     uchar4 result = v;
>+//     result.x = c.x;
>+//     result.z = c.y;
>+//     return result;
>+// }
>+// uchar2 operator.xw(uchar4 v) {
>+//     uchar2 result;
>+//     result.x = v.x;
>+//     result.y = v.w;
>+//     return result;
>+// }
>+// uchar4 operator.xw=(uchar4 v, uchar2 c) {
>+//     uchar4 result = v;
>+//     result.x = c.x;
>+//     result.w = c.y;
>+//     return result;
>+// }
>+// uchar2 operator.yx(uchar4 v) {
>+//     uchar2 result;
>+//     result.x = v.y;
>+//     result.y = v.x;
>+//     return result;
>+// }
>+// uchar4 operator.yx=(uchar4 v, uchar2 c) {
>+//     uchar4 result = v;
>+//     result.y = c.x;
>+//     result.x = c.y;
>+//     return result;
>+// }
>+// uchar2 operator.yy(uchar4 v) {
>+//     uchar2 result;
>+//     result.x = v.y;
>+//     result.y = v.y;
>+//     return result;
>+// }
>+// uchar2 operator.yz(uchar4 v) {
>+//     uchar2 result;
>+//     result.x = v.y;
>+//     result.y = v.z;
>+//     return result;
>+// }
>+// uchar4 operator.yz=(uchar4 v, uchar2 c) {
>+//     uchar4 result = v;
>+//     result.y = c.x;
>+//     result.z = c.y;
>+//     return result;
>+// }
>+// uchar2 operator.yw(uchar4 v) {
>+//     uchar2 result;
>+//     result.x = v.y;
>+//     result.y = v.w;
>+//     return result;
>+// }
>+// uchar4 operator.yw=(uchar4 v, uchar2 c) {
>+//     uchar4 result = v;
>+//     result.y = c.x;
>+//     result.w = c.y;
>+//     return result;
>+// }
>+// uchar2 operator.zx(uchar4 v) {
>+//     uchar2 result;
>+//     result.x = v.z;
>+//     result.y = v.x;
>+//     return result;
>+// }
>+// uchar4 operator.zx=(uchar4 v, uchar2 c) {
>+//     uchar4 result = v;
>+//     result.z = c.x;
>+//     result.x = c.y;
>+//     return result;
>+// }
>+// uchar2 operator.zy(uchar4 v) {
>+//     uchar2 result;
>+//     result.x = v.z;
>+//     result.y = v.y;
>+//     return result;
>+// }
>+// uchar4 operator.zy=(uchar4 v, uchar2 c) {
>+//     uchar4 result = v;
>+//     result.z = c.x;
>+//     result.y = c.y;
>+//     return result;
>+// }
>+// uchar2 operator.zz(uchar4 v) {
>+//     uchar2 result;
>+//     result.x = v.z;
>+//     result.y = v.z;
>+//     return result;
>+// }
>+// uchar2 operator.zw(uchar4 v) {
>+//     uchar2 result;
>+//     result.x = v.z;
>+//     result.y = v.w;
>+//     return result;
>+// }
>+// uchar4 operator.zw=(uchar4 v, uchar2 c) {
>+//     uchar4 result = v;
>+//     result.z = c.x;
>+//     result.w = c.y;
>+//     return result;
>+// }
>+// uchar2 operator.wx(uchar4 v) {
>+//     uchar2 result;
>+//     result.x = v.w;
>+//     result.y = v.x;
>+//     return result;
>+// }
>+// uchar4 operator.wx=(uchar4 v, uchar2 c) {
>+//     uchar4 result = v;
>+//     result.w = c.x;
>+//     result.x = c.y;
>+//     return result;
>+// }
>+// uchar2 operator.wy(uchar4 v) {
>+//     uchar2 result;
>+//     result.x = v.w;
>+//     result.y = v.y;
>+//     return result;
>+// }
>+// uchar4 operator.wy=(uchar4 v, uchar2 c) {
>+//     uchar4 result = v;
>+//     result.w = c.x;
>+//     result.y = c.y;
>+//     return result;
>+// }
>+// uchar2 operator.wz(uchar4 v) {
>+//     uchar2 result;
>+//     result.x = v.w;
>+//     result.y = v.z;
>+//     return result;
>+// }
>+// uchar4 operator.wz=(uchar4 v, uchar2 c) {
>+//     uchar4 result = v;
>+//     result.w = c.x;
>+//     result.z = c.y;
>+//     return result;
>+// }
>+// uchar2 operator.ww(uchar4 v) {
>+//     uchar2 result;
>+//     result.x = v.w;
>+//     result.y = v.w;
>+//     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.xxy(uchar2 v) {
>+//     uchar3 result;
>+//     result.x = v.x;
>+//     result.y = v.x;
>+//     result.z = v.y;
>+//     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.xyy(uchar2 v) {
>+//     uchar3 result;
>+//     result.x = v.x;
>+//     result.y = v.y;
>+//     result.z = v.y;
>+//     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.yxy(uchar2 v) {
>+//     uchar3 result;
>+//     result.x = v.y;
>+//     result.y = v.x;
>+//     result.z = v.y;
>+//     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.yyy(uchar2 v) {
>+//     uchar3 result;
>+//     result.x = v.y;
>+//     result.y = v.y;
>+//     result.z = v.y;
>+//     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.xxy(uchar3 v) {
>+//     uchar3 result;
>+//     result.x = v.x;
>+//     result.y = v.x;
>+//     result.z = v.y;
>+//     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.xyx(uchar3 v) {
>+//     uchar3 result;
>+//     result.x = v.x;
>+//     result.y = v.y;
>+//     result.z = v.x;
>+//     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.xyz(uchar3 v) {
>+//     uchar3 result;
>+//     result.x = v.x;
>+//     result.y = v.y;
>+//     result.z = v.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;
>+// }
>+// uchar3 operator.xzx(uchar3 v) {
>+//     uchar3 result;
>+//     result.x = v.x;
>+//     result.y = v.z;
>+//     result.z = v.x;
>+//     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=(uchar3 v, uchar3 c) {
>+//     uchar3 result = v;
>+//     result.x = c.x;
>+//     result.z = c.y;
>+//     result.y = c.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.yxx(uchar3 v) {
>+//     uchar3 result;
>+//     result.x = v.y;
>+//     result.y = v.x;
>+//     result.z = v.x;
>+//     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.yxz(uchar3 v) {
>+//     uchar3 result;
>+//     result.x = v.y;
>+//     result.y = v.x;
>+//     result.z = v.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;
>+// }
>+// uchar3 operator.yyx(uchar3 v) {
>+//     uchar3 result;
>+//     result.x = v.y;
>+//     result.y = v.y;
>+//     result.z = v.x;
>+//     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.yyz(uchar3 v) {
>+//     uchar3 result;
>+//     result.x = v.y;
>+//     result.y = v.y;
>+//     result.z = v.z;
>+//     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=(uchar3 v, uchar3 c) {
>+//     uchar3 result = v;
>+//     result.y = c.x;
>+//     result.z = c.y;
>+//     result.x = c.z;
>+//     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.yzz(uchar3 v) {
>+//     uchar3 result;
>+//     result.x = v.y;
>+//     result.y = v.z;
>+//     result.z = v.z;
>+//     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.zxy(uchar3 v) {
>+//     uchar3 result;
>+//     result.x = v.z;
>+//     result.y = v.x;
>+//     result.z = v.y;
>+//     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;
>+// }
>+// uchar3 operator.zxz(uchar3 v) {
>+//     uchar3 result;
>+//     result.x = v.z;
>+//     result.y = v.x;
>+//     result.z = v.z;
>+//     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=(uchar3 v, uchar3 c) {
>+//     uchar3 result = v;
>+//     result.z = c.x;
>+//     result.y = c.y;
>+//     result.x = c.z;
>+//     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.zyz(uchar3 v) {
>+//     uchar3 result;
>+//     result.x = v.z;
>+//     result.y = v.y;
>+//     result.z = v.z;
>+//     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.zzy(uchar3 v) {
>+//     uchar3 result;
>+//     result.x = v.z;
>+//     result.y = v.z;
>+//     result.z = v.y;
>+//     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.xxx(uchar4 v) {
>+//     uchar3 result;
>+//     result.x = v.x;
>+//     result.y = v.x;
>+//     result.z = v.x;
>+//     return result;
>+// }
>+// uchar3 operator.xxy(uchar4 v) {
>+//     uchar3 result;
>+//     result.x = v.x;
>+//     result.y = v.x;
>+//     result.z = v.y;
>+//     return result;
>+// }
>+// uchar3 operator.xxz(uchar4 v) {
>+//     uchar3 result;
>+//     result.x = v.x;
>+//     result.y = v.x;
>+//     result.z = v.z;
>+//     return result;
>+// }
>+// uchar3 operator.xxw(uchar4 v) {
>+//     uchar3 result;
>+//     result.x = v.x;
>+//     result.y = v.x;
>+//     result.z = v.w;
>+//     return result;
>+// }
>+// uchar3 operator.xyx(uchar4 v) {
>+//     uchar3 result;
>+//     result.x = v.x;
>+//     result.y = v.y;
>+//     result.z = v.x;
>+//     return result;
>+// }
>+// uchar3 operator.xyy(uchar4 v) {
>+//     uchar3 result;
>+//     result.x = v.x;
>+//     result.y = v.y;
>+//     result.z = v.y;
>+//     return result;
>+// }
>+// uchar3 operator.xyz(uchar4 v) {
>+//     uchar3 result;
>+//     result.x = v.x;
>+//     result.y = v.y;
>+//     result.z = v.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;
>+// }
>+// uchar3 operator.xyw(uchar4 v) {
>+//     uchar3 result;
>+//     result.x = v.x;
>+//     result.y = v.y;
>+//     result.z = v.w;
>+//     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;
>+// }
>+// uchar3 operator.xzx(uchar4 v) {
>+//     uchar3 result;
>+//     result.x = v.x;
>+//     result.y = v.z;
>+//     result.z = v.x;
>+//     return result;
>+// }
>+// uchar3 operator.xzy(uchar4 v) {
>+//     uchar3 result;
>+//     result.x = v.x;
>+//     result.y = v.z;
>+//     result.z = v.y;
>+//     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;
>+// }
>+// uchar3 operator.xzz(uchar4 v) {
>+//     uchar3 result;
>+//     result.x = v.x;
>+//     result.y = v.z;
>+//     result.z = v.z;
>+//     return result;
>+// }
>+// uchar3 operator.xzw(uchar4 v) {
>+//     uchar3 result;
>+//     result.x = v.x;
>+//     result.y = v.z;
>+//     result.z = v.w;
>+//     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;
>+// }
>+// uchar3 operator.xwx(uchar4 v) {
>+//     uchar3 result;
>+//     result.x = v.x;
>+//     result.y = v.w;
>+//     result.z = v.x;
>+//     return result;
>+// }
>+// uchar3 operator.xwy(uchar4 v) {
>+//     uchar3 result;
>+//     result.x = v.x;
>+//     result.y = v.w;
>+//     result.z = v.y;
>+//     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;
>+// }
>+// uchar3 operator.xwz(uchar4 v) {
>+//     uchar3 result;
>+//     result.x = v.x;
>+//     result.y = v.w;
>+//     result.z = v.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;
>+// }
>+// uchar3 operator.xww(uchar4 v) {
>+//     uchar3 result;
>+//     result.x = v.x;
>+//     result.y = v.w;
>+//     result.z = v.w;
>+//     return result;
>+// }
>+// uchar3 operator.yxx(uchar4 v) {
>+//     uchar3 result;
>+//     result.x = v.y;
>+//     result.y = v.x;
>+//     result.z = v.x;
>+//     return result;
>+// }
>+// uchar3 operator.yxy(uchar4 v) {
>+//     uchar3 result;
>+//     result.x = v.y;
>+//     result.y = v.x;
>+//     result.z = v.y;
>+//     return result;
>+// }
>+// uchar3 operator.yxz(uchar4 v) {
>+//     uchar3 result;
>+//     result.x = v.y;
>+//     result.y = v.x;
>+//     result.z = v.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;
>+// }
>+// uchar3 operator.yxw(uchar4 v) {
>+//     uchar3 result;
>+//     result.x = v.y;
>+//     result.y = v.x;
>+//     result.z = v.w;
>+//     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;
>+// }
>+// uchar3 operator.yyx(uchar4 v) {
>+//     uchar3 result;
>+//     result.x = v.y;
>+//     result.y = v.y;
>+//     result.z = v.x;
>+//     return result;
>+// }
>+// uchar3 operator.yyy(uchar4 v) {
>+//     uchar3 result;
>+//     result.x = v.y;
>+//     result.y = v.y;
>+//     result.z = v.y;
>+//     return result;
>+// }
>+// uchar3 operator.yyz(uchar4 v) {
>+//     uchar3 result;
>+//     result.x = v.y;
>+//     result.y = v.y;
>+//     result.z = v.z;
>+//     return result;
>+// }
>+// uchar3 operator.yyw(uchar4 v) {
>+//     uchar3 result;
>+//     result.x = v.y;
>+//     result.y = v.y;
>+//     result.z = v.w;
>+//     return result;
>+// }
>+// uchar3 operator.yzx(uchar4 v) {
>+//     uchar3 result;
>+//     result.x = v.y;
>+//     result.y = v.z;
>+//     result.z = v.x;
>+//     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;
>+// }
>+// uchar3 operator.yzy(uchar4 v) {
>+//     uchar3 result;
>+//     result.x = v.y;
>+//     result.y = v.z;
>+//     result.z = v.y;
>+//     return result;
>+// }
>+// uchar3 operator.yzz(uchar4 v) {
>+//     uchar3 result;
>+//     result.x = v.y;
>+//     result.y = v.z;
>+//     result.z = v.z;
>+//     return result;
>+// }
>+// uchar3 operator.yzw(uchar4 v) {
>+//     uchar3 result;
>+//     result.x = v.y;
>+//     result.y = v.z;
>+//     result.z = v.w;
>+//     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;
>+// }
>+// uchar3 operator.ywx(uchar4 v) {
>+//     uchar3 result;
>+//     result.x = v.y;
>+//     result.y = v.w;
>+//     result.z = v.x;
>+//     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;
>+// }
>+// uchar3 operator.ywy(uchar4 v) {
>+//     uchar3 result;
>+//     result.x = v.y;
>+//     result.y = v.w;
>+//     result.z = v.y;
>+//     return result;
>+// }
>+// uchar3 operator.ywz(uchar4 v) {
>+//     uchar3 result;
>+//     result.x = v.y;
>+//     result.y = v.w;
>+//     result.z = v.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;
>+// }
>+// uchar3 operator.yww(uchar4 v) {
>+//     uchar3 result;
>+//     result.x = v.y;
>+//     result.y = v.w;
>+//     result.z = v.w;
>+//     return result;
>+// }
>+// uchar3 operator.zxx(uchar4 v) {
>+//     uchar3 result;
>+//     result.x = v.z;
>+//     result.y = v.x;
>+//     result.z = v.x;
>+//     return result;
>+// }
>+// uchar3 operator.zxy(uchar4 v) {
>+//     uchar3 result;
>+//     result.x = v.z;
>+//     result.y = v.x;
>+//     result.z = v.y;
>+//     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;
>+// }
>+// uchar3 operator.zxz(uchar4 v) {
>+//     uchar3 result;
>+//     result.x = v.z;
>+//     result.y = v.x;
>+//     result.z = v.z;
>+//     return result;
>+// }
>+// uchar3 operator.zxw(uchar4 v) {
>+//     uchar3 result;
>+//     result.x = v.z;
>+//     result.y = v.x;
>+//     result.z = v.w;
>+//     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;
>+// }
>+// uchar3 operator.zyx(uchar4 v) {
>+//     uchar3 result;
>+//     result.x = v.z;
>+//     result.y = v.y;
>+//     result.z = v.x;
>+//     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;
>+// }
>+// uchar3 operator.zyy(uchar4 v) {
>+//     uchar3 result;
>+//     result.x = v.z;
>+//     result.y = v.y;
>+//     result.z = v.y;
>+//     return result;
>+// }
>+// uchar3 operator.zyz(uchar4 v) {
>+//     uchar3 result;
>+//     result.x = v.z;
>+//     result.y = v.y;
>+//     result.z = v.z;
>+//     return result;
>+// }
>+// uchar3 operator.zyw(uchar4 v) {
>+//     uchar3 result;
>+//     result.x = v.z;
>+//     result.y = v.y;
>+//     result.z = v.w;
>+//     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;
>+// }
>+// uchar3 operator.zzx(uchar4 v) {
>+//     uchar3 result;
>+//     result.x = v.z;
>+//     result.y = v.z;
>+//     result.z = v.x;
>+//     return result;
>+// }
>+// uchar3 operator.zzy(uchar4 v) {
>+//     uchar3 result;
>+//     result.x = v.z;
>+//     result.y = v.z;
>+//     result.z = v.y;
>+//     return result;
>+// }
>+// uchar3 operator.zzz(uchar4 v) {
>+//     uchar3 result;
>+//     result.x = v.z;
>+//     result.y = v.z;
>+//     result.z = v.z;
>+//     return result;
>+// }
>+// uchar3 operator.zzw(uchar4 v) {
>+//     uchar3 result;
>+//     result.x = v.z;
>+//     result.y = v.z;
>+//     result.z = v.w;
>+//     return result;
>+// }
>+// uchar3 operator.zwx(uchar4 v) {
>+//     uchar3 result;
>+//     result.x = v.z;
>+//     result.y = v.w;
>+//     result.z = v.x;
>+//     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;
>+// }
>+// uchar3 operator.zwy(uchar4 v) {
>+//     uchar3 result;
>+//     result.x = v.z;
>+//     result.y = v.w;
>+//     result.z = v.y;
>+//     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;
>+// }
>+// uchar3 operator.zwz(uchar4 v) {
>+//     uchar3 result;
>+//     result.x = v.z;
>+//     result.y = v.w;
>+//     result.z = v.z;
>+//     return result;
>+// }
>+// uchar3 operator.zww(uchar4 v) {
>+//     uchar3 result;
>+//     result.x = v.z;
>+//     result.y = v.w;
>+//     result.z = v.w;
>+//     return result;
>+// }
>+// uchar3 operator.wxx(uchar4 v) {
>+//     uchar3 result;
>+//     result.x = v.w;
>+//     result.y = v.x;
>+//     result.z = v.x;
>+//     return result;
>+// }
>+// uchar3 operator.wxy(uchar4 v) {
>+//     uchar3 result;
>+//     result.x = v.w;
>+//     result.y = v.x;
>+//     result.z = v.y;
>+//     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;
>+// }
>+// uchar3 operator.wxz(uchar4 v) {
>+//     uchar3 result;
>+//     result.x = v.w;
>+//     result.y = v.x;
>+//     result.z = v.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;
>+// }
>+// uchar3 operator.wxw(uchar4 v) {
>+//     uchar3 result;
>+//     result.x = v.w;
>+//     result.y = v.x;
>+//     result.z = v.w;
>+//     return result;
>+// }
>+// uchar3 operator.wyx(uchar4 v) {
>+//     uchar3 result;
>+//     result.x = v.w;
>+//     result.y = v.y;
>+//     result.z = v.x;
>+//     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;
>+// }
>+// uchar3 operator.wyy(uchar4 v) {
>+//     uchar3 result;
>+//     result.x = v.w;
>+//     result.y = v.y;
>+//     result.z = v.y;
>+//     return result;
>+// }
>+// uchar3 operator.wyz(uchar4 v) {
>+//     uchar3 result;
>+//     result.x = v.w;
>+//     result.y = v.y;
>+//     result.z = v.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;
>+// }
>+// uchar3 operator.wyw(uchar4 v) {
>+//     uchar3 result;
>+//     result.x = v.w;
>+//     result.y = v.y;
>+//     result.z = v.w;
>+//     return result;
>+// }
>+// uchar3 operator.wzx(uchar4 v) {
>+//     uchar3 result;
>+//     result.x = v.w;
>+//     result.y = v.z;
>+//     result.z = v.x;
>+//     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;
>+// }
>+// uchar3 operator.wzy(uchar4 v) {
>+//     uchar3 result;
>+//     result.x = v.w;
>+//     result.y = v.z;
>+//     result.z = v.y;
>+//     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;
>+// }
>+// uchar3 operator.wzz(uchar4 v) {
>+//     uchar3 result;
>+//     result.x = v.w;
>+//     result.y = v.z;
>+//     result.z = v.z;
>+//     return result;
>+// }
>+// uchar3 operator.wzw(uchar4 v) {
>+//     uchar3 result;
>+//     result.x = v.w;
>+//     result.y = v.z;
>+//     result.z = v.w;
>+//     return result;
>+// }
>+// uchar3 operator.wwx(uchar4 v) {
>+//     uchar3 result;
>+//     result.x = v.w;
>+//     result.y = v.w;
>+//     result.z = v.x;
>+//     return result;
>+// }
>+// uchar3 operator.wwy(uchar4 v) {
>+//     uchar3 result;
>+//     result.x = v.w;
>+//     result.y = v.w;
>+//     result.z = v.y;
>+//     return result;
>+// }
>+// uchar3 operator.wwz(uchar4 v) {
>+//     uchar3 result;
>+//     result.x = v.w;
>+//     result.y = v.w;
>+//     result.z = v.z;
>+//     return result;
>+// }
>+// uchar3 operator.www(uchar4 v) {
>+//     uchar3 result;
>+//     result.x = v.w;
>+//     result.y = v.w;
>+//     result.z = v.w;
>+//     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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.zyxy(uchar3 v) {
>+//     uchar4 result;
>+//     result.x = v.z;
>+//     result.y = v.y;
>+//     result.z = v.x;
>+//     result.w = v.y;
>+//     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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.xxxx(uchar4 v) {
>+//     uchar4 result;
>+//     result.x = v.x;
>+//     result.y = v.x;
>+//     result.z = v.x;
>+//     result.w = v.x;
>+//     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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// ushort2 operator.xx(ushort2 v) {
>+//     ushort2 result;
>+//     result.x = v.x;
>+//     result.y = v.x;
>+//     return result;
>+// }
>+// ushort2 operator.xy(ushort2 v) {
>+//     ushort2 result;
>+//     result.x = v.x;
>+//     result.y = v.y;
>+//     return result;
>+// }
>+// ushort2 operator.xy=(ushort2 v, ushort2 c) {
>+//     ushort2 result = v;
>+//     result.x = c.x;
>+//     result.y = c.y;
>+//     return result;
>+// }
>+// ushort2 operator.yx(ushort2 v) {
>+//     ushort2 result;
>+//     result.x = v.y;
>+//     result.y = v.x;
>+//     return result;
>+// }
>+// ushort2 operator.yx=(ushort2 v, ushort2 c) {
>+//     ushort2 result = v;
>+//     result.y = c.x;
>+//     result.x = c.y;
>+//     return result;
>+// }
>+// ushort2 operator.yy(ushort2 v) {
>+//     ushort2 result;
>+//     result.x = v.y;
>+//     result.y = v.y;
>+//     return result;
>+// }
>+// ushort2 operator.xx(ushort3 v) {
>+//     ushort2 result;
>+//     result.x = v.x;
>+//     result.y = v.x;
>+//     return result;
>+// }
>+// ushort2 operator.xy(ushort3 v) {
>+//     ushort2 result;
>+//     result.x = v.x;
>+//     result.y = v.y;
>+//     return result;
>+// }
>+// ushort3 operator.xy=(ushort3 v, ushort2 c) {
>+//     ushort3 result = v;
>+//     result.x = c.x;
>+//     result.y = c.y;
>+//     return result;
>+// }
>+// ushort2 operator.xz(ushort3 v) {
>+//     ushort2 result;
>+//     result.x = v.x;
>+//     result.y = v.z;
>+//     return result;
>+// }
>+// ushort3 operator.xz=(ushort3 v, ushort2 c) {
>+//     ushort3 result = v;
>+//     result.x = c.x;
>+//     result.z = c.y;
>+//     return result;
>+// }
>+// ushort2 operator.yx(ushort3 v) {
>+//     ushort2 result;
>+//     result.x = v.y;
>+//     result.y = v.x;
>+//     return result;
>+// }
>+// ushort3 operator.yx=(ushort3 v, ushort2 c) {
>+//     ushort3 result = v;
>+//     result.y = c.x;
>+//     result.x = c.y;
>+//     return result;
>+// }
>+// ushort2 operator.yy(ushort3 v) {
>+//     ushort2 result;
>+//     result.x = v.y;
>+//     result.y = v.y;
>+//     return result;
>+// }
>+// ushort2 operator.yz(ushort3 v) {
>+//     ushort2 result;
>+//     result.x = v.y;
>+//     result.y = v.z;
>+//     return result;
>+// }
>+// ushort3 operator.yz=(ushort3 v, ushort2 c) {
>+//     ushort3 result = v;
>+//     result.y = c.x;
>+//     result.z = c.y;
>+//     return result;
>+// }
>+// ushort2 operator.zx(ushort3 v) {
>+//     ushort2 result;
>+//     result.x = v.z;
>+//     result.y = v.x;
>+//     return result;
>+// }
>+// ushort3 operator.zx=(ushort3 v, ushort2 c) {
>+//     ushort3 result = v;
>+//     result.z = c.x;
>+//     result.x = c.y;
>+//     return result;
>+// }
>+// ushort2 operator.zy(ushort3 v) {
>+//     ushort2 result;
>+//     result.x = v.z;
>+//     result.y = v.y;
>+//     return result;
>+// }
>+// ushort3 operator.zy=(ushort3 v, ushort2 c) {
>+//     ushort3 result = v;
>+//     result.z = c.x;
>+//     result.y = c.y;
>+//     return result;
>+// }
>+// ushort2 operator.zz(ushort3 v) {
>+//     ushort2 result;
>+//     result.x = v.z;
>+//     result.y = v.z;
>+//     return result;
>+// }
>+// ushort2 operator.xx(ushort4 v) {
>+//     ushort2 result;
>+//     result.x = v.x;
>+//     result.y = v.x;
>+//     return result;
>+// }
>+// ushort2 operator.xy(ushort4 v) {
>+//     ushort2 result;
>+//     result.x = v.x;
>+//     result.y = v.y;
>+//     return result;
>+// }
>+// ushort4 operator.xy=(ushort4 v, ushort2 c) {
>+//     ushort4 result = v;
>+//     result.x = c.x;
>+//     result.y = c.y;
>+//     return result;
>+// }
>+// ushort2 operator.xz(ushort4 v) {
>+//     ushort2 result;
>+//     result.x = v.x;
>+//     result.y = v.z;
>+//     return result;
>+// }
>+// ushort4 operator.xz=(ushort4 v, ushort2 c) {
>+//     ushort4 result = v;
>+//     result.x = c.x;
>+//     result.z = c.y;
>+//     return result;
>+// }
>+// ushort2 operator.xw(ushort4 v) {
>+//     ushort2 result;
>+//     result.x = v.x;
>+//     result.y = v.w;
>+//     return result;
>+// }
>+// ushort4 operator.xw=(ushort4 v, ushort2 c) {
>+//     ushort4 result = v;
>+//     result.x = c.x;
>+//     result.w = c.y;
>+//     return result;
>+// }
>+// ushort2 operator.yx(ushort4 v) {
>+//     ushort2 result;
>+//     result.x = v.y;
>+//     result.y = v.x;
>+//     return result;
>+// }
>+// ushort4 operator.yx=(ushort4 v, ushort2 c) {
>+//     ushort4 result = v;
>+//     result.y = c.x;
>+//     result.x = c.y;
>+//     return result;
>+// }
>+// ushort2 operator.yy(ushort4 v) {
>+//     ushort2 result;
>+//     result.x = v.y;
>+//     result.y = v.y;
>+//     return result;
>+// }
>+// ushort2 operator.yz(ushort4 v) {
>+//     ushort2 result;
>+//     result.x = v.y;
>+//     result.y = v.z;
>+//     return result;
>+// }
>+// ushort4 operator.yz=(ushort4 v, ushort2 c) {
>+//     ushort4 result = v;
>+//     result.y = c.x;
>+//     result.z = c.y;
>+//     return result;
>+// }
>+// ushort2 operator.yw(ushort4 v) {
>+//     ushort2 result;
>+//     result.x = v.y;
>+//     result.y = v.w;
>+//     return result;
>+// }
>+// ushort4 operator.yw=(ushort4 v, ushort2 c) {
>+//     ushort4 result = v;
>+//     result.y = c.x;
>+//     result.w = c.y;
>+//     return result;
>+// }
>+// ushort2 operator.zx(ushort4 v) {
>+//     ushort2 result;
>+//     result.x = v.z;
>+//     result.y = v.x;
>+//     return result;
>+// }
>+// ushort4 operator.zx=(ushort4 v, ushort2 c) {
>+//     ushort4 result = v;
>+//     result.z = c.x;
>+//     result.x = c.y;
>+//     return result;
>+// }
>+// ushort2 operator.zy(ushort4 v) {
>+//     ushort2 result;
>+//     result.x = v.z;
>+//     result.y = v.y;
>+//     return result;
>+// }
>+// ushort4 operator.zy=(ushort4 v, ushort2 c) {
>+//     ushort4 result = v;
>+//     result.z = c.x;
>+//     result.y = c.y;
>+//     return result;
>+// }
>+// ushort2 operator.zz(ushort4 v) {
>+//     ushort2 result;
>+//     result.x = v.z;
>+//     result.y = v.z;
>+//     return result;
>+// }
>+// ushort2 operator.zw(ushort4 v) {
>+//     ushort2 result;
>+//     result.x = v.z;
>+//     result.y = v.w;
>+//     return result;
>+// }
>+// ushort4 operator.zw=(ushort4 v, ushort2 c) {
>+//     ushort4 result = v;
>+//     result.z = c.x;
>+//     result.w = c.y;
>+//     return result;
>+// }
>+// ushort2 operator.wx(ushort4 v) {
>+//     ushort2 result;
>+//     result.x = v.w;
>+//     result.y = v.x;
>+//     return result;
>+// }
>+// ushort4 operator.wx=(ushort4 v, ushort2 c) {
>+//     ushort4 result = v;
>+//     result.w = c.x;
>+//     result.x = c.y;
>+//     return result;
>+// }
>+// ushort2 operator.wy(ushort4 v) {
>+//     ushort2 result;
>+//     result.x = v.w;
>+//     result.y = v.y;
>+//     return result;
>+// }
>+// ushort4 operator.wy=(ushort4 v, ushort2 c) {
>+//     ushort4 result = v;
>+//     result.w = c.x;
>+//     result.y = c.y;
>+//     return result;
>+// }
>+// ushort2 operator.wz(ushort4 v) {
>+//     ushort2 result;
>+//     result.x = v.w;
>+//     result.y = v.z;
>+//     return result;
>+// }
>+// ushort4 operator.wz=(ushort4 v, ushort2 c) {
>+//     ushort4 result = v;
>+//     result.w = c.x;
>+//     result.z = c.y;
>+//     return result;
>+// }
>+// ushort2 operator.ww(ushort4 v) {
>+//     ushort2 result;
>+//     result.x = v.w;
>+//     result.y = v.w;
>+//     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.xxy(ushort2 v) {
>+//     ushort3 result;
>+//     result.x = v.x;
>+//     result.y = v.x;
>+//     result.z = v.y;
>+//     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.xyy(ushort2 v) {
>+//     ushort3 result;
>+//     result.x = v.x;
>+//     result.y = v.y;
>+//     result.z = v.y;
>+//     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.yxy(ushort2 v) {
>+//     ushort3 result;
>+//     result.x = v.y;
>+//     result.y = v.x;
>+//     result.z = v.y;
>+//     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.yyy(ushort2 v) {
>+//     ushort3 result;
>+//     result.x = v.y;
>+//     result.y = v.y;
>+//     result.z = v.y;
>+//     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.xxy(ushort3 v) {
>+//     ushort3 result;
>+//     result.x = v.x;
>+//     result.y = v.x;
>+//     result.z = v.y;
>+//     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.xyx(ushort3 v) {
>+//     ushort3 result;
>+//     result.x = v.x;
>+//     result.y = v.y;
>+//     result.z = v.x;
>+//     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.xyz(ushort3 v) {
>+//     ushort3 result;
>+//     result.x = v.x;
>+//     result.y = v.y;
>+//     result.z = v.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;
>+// }
>+// ushort3 operator.xzx(ushort3 v) {
>+//     ushort3 result;
>+//     result.x = v.x;
>+//     result.y = v.z;
>+//     result.z = v.x;
>+//     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=(ushort3 v, ushort3 c) {
>+//     ushort3 result = v;
>+//     result.x = c.x;
>+//     result.z = c.y;
>+//     result.y = c.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.yxx(ushort3 v) {
>+//     ushort3 result;
>+//     result.x = v.y;
>+//     result.y = v.x;
>+//     result.z = v.x;
>+//     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.yxz(ushort3 v) {
>+//     ushort3 result;
>+//     result.x = v.y;
>+//     result.y = v.x;
>+//     result.z = v.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;
>+// }
>+// ushort3 operator.yyx(ushort3 v) {
>+//     ushort3 result;
>+//     result.x = v.y;
>+//     result.y = v.y;
>+//     result.z = v.x;
>+//     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.yyz(ushort3 v) {
>+//     ushort3 result;
>+//     result.x = v.y;
>+//     result.y = v.y;
>+//     result.z = v.z;
>+//     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=(ushort3 v, ushort3 c) {
>+//     ushort3 result = v;
>+//     result.y = c.x;
>+//     result.z = c.y;
>+//     result.x = c.z;
>+//     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.yzz(ushort3 v) {
>+//     ushort3 result;
>+//     result.x = v.y;
>+//     result.y = v.z;
>+//     result.z = v.z;
>+//     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.zxy(ushort3 v) {
>+//     ushort3 result;
>+//     result.x = v.z;
>+//     result.y = v.x;
>+//     result.z = v.y;
>+//     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;
>+// }
>+// ushort3 operator.zxz(ushort3 v) {
>+//     ushort3 result;
>+//     result.x = v.z;
>+//     result.y = v.x;
>+//     result.z = v.z;
>+//     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=(ushort3 v, ushort3 c) {
>+//     ushort3 result = v;
>+//     result.z = c.x;
>+//     result.y = c.y;
>+//     result.x = c.z;
>+//     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.zyz(ushort3 v) {
>+//     ushort3 result;
>+//     result.x = v.z;
>+//     result.y = v.y;
>+//     result.z = v.z;
>+//     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.zzy(ushort3 v) {
>+//     ushort3 result;
>+//     result.x = v.z;
>+//     result.y = v.z;
>+//     result.z = v.y;
>+//     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.xxx(ushort4 v) {
>+//     ushort3 result;
>+//     result.x = v.x;
>+//     result.y = v.x;
>+//     result.z = v.x;
>+//     return result;
>+// }
>+// ushort3 operator.xxy(ushort4 v) {
>+//     ushort3 result;
>+//     result.x = v.x;
>+//     result.y = v.x;
>+//     result.z = v.y;
>+//     return result;
>+// }
>+// ushort3 operator.xxz(ushort4 v) {
>+//     ushort3 result;
>+//     result.x = v.x;
>+//     result.y = v.x;
>+//     result.z = v.z;
>+//     return result;
>+// }
>+// ushort3 operator.xxw(ushort4 v) {
>+//     ushort3 result;
>+//     result.x = v.x;
>+//     result.y = v.x;
>+//     result.z = v.w;
>+//     return result;
>+// }
>+// ushort3 operator.xyx(ushort4 v) {
>+//     ushort3 result;
>+//     result.x = v.x;
>+//     result.y = v.y;
>+//     result.z = v.x;
>+//     return result;
>+// }
>+// ushort3 operator.xyy(ushort4 v) {
>+//     ushort3 result;
>+//     result.x = v.x;
>+//     result.y = v.y;
>+//     result.z = v.y;
>+//     return result;
>+// }
>+// ushort3 operator.xyz(ushort4 v) {
>+//     ushort3 result;
>+//     result.x = v.x;
>+//     result.y = v.y;
>+//     result.z = v.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;
>+// }
>+// ushort3 operator.xyw(ushort4 v) {
>+//     ushort3 result;
>+//     result.x = v.x;
>+//     result.y = v.y;
>+//     result.z = v.w;
>+//     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;
>+// }
>+// ushort3 operator.xzx(ushort4 v) {
>+//     ushort3 result;
>+//     result.x = v.x;
>+//     result.y = v.z;
>+//     result.z = v.x;
>+//     return result;
>+// }
>+// ushort3 operator.xzy(ushort4 v) {
>+//     ushort3 result;
>+//     result.x = v.x;
>+//     result.y = v.z;
>+//     result.z = v.y;
>+//     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;
>+// }
>+// ushort3 operator.xzz(ushort4 v) {
>+//     ushort3 result;
>+//     result.x = v.x;
>+//     result.y = v.z;
>+//     result.z = v.z;
>+//     return result;
>+// }
>+// ushort3 operator.xzw(ushort4 v) {
>+//     ushort3 result;
>+//     result.x = v.x;
>+//     result.y = v.z;
>+//     result.z = v.w;
>+//     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;
>+// }
>+// ushort3 operator.xwx(ushort4 v) {
>+//     ushort3 result;
>+//     result.x = v.x;
>+//     result.y = v.w;
>+//     result.z = v.x;
>+//     return result;
>+// }
>+// ushort3 operator.xwy(ushort4 v) {
>+//     ushort3 result;
>+//     result.x = v.x;
>+//     result.y = v.w;
>+//     result.z = v.y;
>+//     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;
>+// }
>+// ushort3 operator.xwz(ushort4 v) {
>+//     ushort3 result;
>+//     result.x = v.x;
>+//     result.y = v.w;
>+//     result.z = v.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;
>+// }
>+// ushort3 operator.xww(ushort4 v) {
>+//     ushort3 result;
>+//     result.x = v.x;
>+//     result.y = v.w;
>+//     result.z = v.w;
>+//     return result;
>+// }
>+// ushort3 operator.yxx(ushort4 v) {
>+//     ushort3 result;
>+//     result.x = v.y;
>+//     result.y = v.x;
>+//     result.z = v.x;
>+//     return result;
>+// }
>+// ushort3 operator.yxy(ushort4 v) {
>+//     ushort3 result;
>+//     result.x = v.y;
>+//     result.y = v.x;
>+//     result.z = v.y;
>+//     return result;
>+// }
>+// ushort3 operator.yxz(ushort4 v) {
>+//     ushort3 result;
>+//     result.x = v.y;
>+//     result.y = v.x;
>+//     result.z = v.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;
>+// }
>+// ushort3 operator.yxw(ushort4 v) {
>+//     ushort3 result;
>+//     result.x = v.y;
>+//     result.y = v.x;
>+//     result.z = v.w;
>+//     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;
>+// }
>+// ushort3 operator.yyx(ushort4 v) {
>+//     ushort3 result;
>+//     result.x = v.y;
>+//     result.y = v.y;
>+//     result.z = v.x;
>+//     return result;
>+// }
>+// ushort3 operator.yyy(ushort4 v) {
>+//     ushort3 result;
>+//     result.x = v.y;
>+//     result.y = v.y;
>+//     result.z = v.y;
>+//     return result;
>+// }
>+// ushort3 operator.yyz(ushort4 v) {
>+//     ushort3 result;
>+//     result.x = v.y;
>+//     result.y = v.y;
>+//     result.z = v.z;
>+//     return result;
>+// }
>+// ushort3 operator.yyw(ushort4 v) {
>+//     ushort3 result;
>+//     result.x = v.y;
>+//     result.y = v.y;
>+//     result.z = v.w;
>+//     return result;
>+// }
>+// ushort3 operator.yzx(ushort4 v) {
>+//     ushort3 result;
>+//     result.x = v.y;
>+//     result.y = v.z;
>+//     result.z = v.x;
>+//     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;
>+// }
>+// ushort3 operator.yzy(ushort4 v) {
>+//     ushort3 result;
>+//     result.x = v.y;
>+//     result.y = v.z;
>+//     result.z = v.y;
>+//     return result;
>+// }
>+// ushort3 operator.yzz(ushort4 v) {
>+//     ushort3 result;
>+//     result.x = v.y;
>+//     result.y = v.z;
>+//     result.z = v.z;
>+//     return result;
>+// }
>+// ushort3 operator.yzw(ushort4 v) {
>+//     ushort3 result;
>+//     result.x = v.y;
>+//     result.y = v.z;
>+//     result.z = v.w;
>+//     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;
>+// }
>+// ushort3 operator.ywx(ushort4 v) {
>+//     ushort3 result;
>+//     result.x = v.y;
>+//     result.y = v.w;
>+//     result.z = v.x;
>+//     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;
>+// }
>+// ushort3 operator.ywy(ushort4 v) {
>+//     ushort3 result;
>+//     result.x = v.y;
>+//     result.y = v.w;
>+//     result.z = v.y;
>+//     return result;
>+// }
>+// ushort3 operator.ywz(ushort4 v) {
>+//     ushort3 result;
>+//     result.x = v.y;
>+//     result.y = v.w;
>+//     result.z = v.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;
>+// }
>+// ushort3 operator.yww(ushort4 v) {
>+//     ushort3 result;
>+//     result.x = v.y;
>+//     result.y = v.w;
>+//     result.z = v.w;
>+//     return result;
>+// }
>+// ushort3 operator.zxx(ushort4 v) {
>+//     ushort3 result;
>+//     result.x = v.z;
>+//     result.y = v.x;
>+//     result.z = v.x;
>+//     return result;
>+// }
>+// ushort3 operator.zxy(ushort4 v) {
>+//     ushort3 result;
>+//     result.x = v.z;
>+//     result.y = v.x;
>+//     result.z = v.y;
>+//     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;
>+// }
>+// ushort3 operator.zxz(ushort4 v) {
>+//     ushort3 result;
>+//     result.x = v.z;
>+//     result.y = v.x;
>+//     result.z = v.z;
>+//     return result;
>+// }
>+// ushort3 operator.zxw(ushort4 v) {
>+//     ushort3 result;
>+//     result.x = v.z;
>+//     result.y = v.x;
>+//     result.z = v.w;
>+//     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;
>+// }
>+// ushort3 operator.zyx(ushort4 v) {
>+//     ushort3 result;
>+//     result.x = v.z;
>+//     result.y = v.y;
>+//     result.z = v.x;
>+//     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;
>+// }
>+// ushort3 operator.zyy(ushort4 v) {
>+//     ushort3 result;
>+//     result.x = v.z;
>+//     result.y = v.y;
>+//     result.z = v.y;
>+//     return result;
>+// }
>+// ushort3 operator.zyz(ushort4 v) {
>+//     ushort3 result;
>+//     result.x = v.z;
>+//     result.y = v.y;
>+//     result.z = v.z;
>+//     return result;
>+// }
>+// ushort3 operator.zyw(ushort4 v) {
>+//     ushort3 result;
>+//     result.x = v.z;
>+//     result.y = v.y;
>+//     result.z = v.w;
>+//     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;
>+// }
>+// ushort3 operator.zzx(ushort4 v) {
>+//     ushort3 result;
>+//     result.x = v.z;
>+//     result.y = v.z;
>+//     result.z = v.x;
>+//     return result;
>+// }
>+// ushort3 operator.zzy(ushort4 v) {
>+//     ushort3 result;
>+//     result.x = v.z;
>+//     result.y = v.z;
>+//     result.z = v.y;
>+//     return result;
>+// }
>+// ushort3 operator.zzz(ushort4 v) {
>+//     ushort3 result;
>+//     result.x = v.z;
>+//     result.y = v.z;
>+//     result.z = v.z;
>+//     return result;
>+// }
>+// ushort3 operator.zzw(ushort4 v) {
>+//     ushort3 result;
>+//     result.x = v.z;
>+//     result.y = v.z;
>+//     result.z = v.w;
>+//     return result;
>+// }
>+// ushort3 operator.zwx(ushort4 v) {
>+//     ushort3 result;
>+//     result.x = v.z;
>+//     result.y = v.w;
>+//     result.z = v.x;
>+//     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;
>+// }
>+// ushort3 operator.zwy(ushort4 v) {
>+//     ushort3 result;
>+//     result.x = v.z;
>+//     result.y = v.w;
>+//     result.z = v.y;
>+//     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;
>+// }
>+// ushort3 operator.zwz(ushort4 v) {
>+//     ushort3 result;
>+//     result.x = v.z;
>+//     result.y = v.w;
>+//     result.z = v.z;
>+//     return result;
>+// }
>+// ushort3 operator.zww(ushort4 v) {
>+//     ushort3 result;
>+//     result.x = v.z;
>+//     result.y = v.w;
>+//     result.z = v.w;
>+//     return result;
>+// }
>+// ushort3 operator.wxx(ushort4 v) {
>+//     ushort3 result;
>+//     result.x = v.w;
>+//     result.y = v.x;
>+//     result.z = v.x;
>+//     return result;
>+// }
>+// ushort3 operator.wxy(ushort4 v) {
>+//     ushort3 result;
>+//     result.x = v.w;
>+//     result.y = v.x;
>+//     result.z = v.y;
>+//     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;
>+// }
>+// ushort3 operator.wxz(ushort4 v) {
>+//     ushort3 result;
>+//     result.x = v.w;
>+//     result.y = v.x;
>+//     result.z = v.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;
>+// }
>+// ushort3 operator.wxw(ushort4 v) {
>+//     ushort3 result;
>+//     result.x = v.w;
>+//     result.y = v.x;
>+//     result.z = v.w;
>+//     return result;
>+// }
>+// ushort3 operator.wyx(ushort4 v) {
>+//     ushort3 result;
>+//     result.x = v.w;
>+//     result.y = v.y;
>+//     result.z = v.x;
>+//     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;
>+// }
>+// ushort3 operator.wyy(ushort4 v) {
>+//     ushort3 result;
>+//     result.x = v.w;
>+//     result.y = v.y;
>+//     result.z = v.y;
>+//     return result;
>+// }
>+// ushort3 operator.wyz(ushort4 v) {
>+//     ushort3 result;
>+//     result.x = v.w;
>+//     result.y = v.y;
>+//     result.z = v.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;
>+// }
>+// ushort3 operator.wyw(ushort4 v) {
>+//     ushort3 result;
>+//     result.x = v.w;
>+//     result.y = v.y;
>+//     result.z = v.w;
>+//     return result;
>+// }
>+// ushort3 operator.wzx(ushort4 v) {
>+//     ushort3 result;
>+//     result.x = v.w;
>+//     result.y = v.z;
>+//     result.z = v.x;
>+//     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;
>+// }
>+// ushort3 operator.wzy(ushort4 v) {
>+//     ushort3 result;
>+//     result.x = v.w;
>+//     result.y = v.z;
>+//     result.z = v.y;
>+//     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;
>+// }
>+// ushort3 operator.wzz(ushort4 v) {
>+//     ushort3 result;
>+//     result.x = v.w;
>+//     result.y = v.z;
>+//     result.z = v.z;
>+//     return result;
>+// }
>+// ushort3 operator.wzw(ushort4 v) {
>+//     ushort3 result;
>+//     result.x = v.w;
>+//     result.y = v.z;
>+//     result.z = v.w;
>+//     return result;
>+// }
>+// ushort3 operator.wwx(ushort4 v) {
>+//     ushort3 result;
>+//     result.x = v.w;
>+//     result.y = v.w;
>+//     result.z = v.x;
>+//     return result;
>+// }
>+// ushort3 operator.wwy(ushort4 v) {
>+//     ushort3 result;
>+//     result.x = v.w;
>+//     result.y = v.w;
>+//     result.z = v.y;
>+//     return result;
>+// }
>+// ushort3 operator.wwz(ushort4 v) {
>+//     ushort3 result;
>+//     result.x = v.w;
>+//     result.y = v.w;
>+//     result.z = v.z;
>+//     return result;
>+// }
>+// ushort3 operator.www(ushort4 v) {
>+//     ushort3 result;
>+//     result.x = v.w;
>+//     result.y = v.w;
>+//     result.z = v.w;
>+//     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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.xxxx(ushort4 v) {
>+//     ushort4 result;
>+//     result.x = v.x;
>+//     result.y = v.x;
>+//     result.z = v.x;
>+//     result.w = v.x;
>+//     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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// uint2 operator.xx(uint2 v) {
>+//     uint2 result;
>+//     result.x = v.x;
>+//     result.y = v.x;
>+//     return result;
>+// }
>+// uint2 operator.xy(uint2 v) {
>+//     uint2 result;
>+//     result.x = v.x;
>+//     result.y = v.y;
>+//     return result;
>+// }
>+// uint2 operator.xy=(uint2 v, uint2 c) {
>+//     uint2 result = v;
>+//     result.x = c.x;
>+//     result.y = c.y;
>+//     return result;
>+// }
>+// uint2 operator.yx(uint2 v) {
>+//     uint2 result;
>+//     result.x = v.y;
>+//     result.y = v.x;
>+//     return result;
>+// }
>+// uint2 operator.yx=(uint2 v, uint2 c) {
>+//     uint2 result = v;
>+//     result.y = c.x;
>+//     result.x = c.y;
>+//     return result;
>+// }
>+// uint2 operator.yy(uint2 v) {
>+//     uint2 result;
>+//     result.x = v.y;
>+//     result.y = v.y;
>+//     return result;
>+// }
>+// uint2 operator.xx(uint3 v) {
>+//     uint2 result;
>+//     result.x = v.x;
>+//     result.y = v.x;
>+//     return result;
>+// }
>+// uint2 operator.xy(uint3 v) {
>+//     uint2 result;
>+//     result.x = v.x;
>+//     result.y = v.y;
>+//     return result;
>+// }
>+// uint3 operator.xy=(uint3 v, uint2 c) {
>+//     uint3 result = v;
>+//     result.x = c.x;
>+//     result.y = c.y;
>+//     return result;
>+// }
>+// uint2 operator.xz(uint3 v) {
>+//     uint2 result;
>+//     result.x = v.x;
>+//     result.y = v.z;
>+//     return result;
>+// }
>+// uint3 operator.xz=(uint3 v, uint2 c) {
>+//     uint3 result = v;
>+//     result.x = c.x;
>+//     result.z = c.y;
>+//     return result;
>+// }
>+// uint2 operator.yx(uint3 v) {
>+//     uint2 result;
>+//     result.x = v.y;
>+//     result.y = v.x;
>+//     return result;
>+// }
>+// uint3 operator.yx=(uint3 v, uint2 c) {
>+//     uint3 result = v;
>+//     result.y = c.x;
>+//     result.x = c.y;
>+//     return result;
>+// }
>+// uint2 operator.yy(uint3 v) {
>+//     uint2 result;
>+//     result.x = v.y;
>+//     result.y = v.y;
>+//     return result;
>+// }
>+// uint2 operator.yz(uint3 v) {
>+//     uint2 result;
>+//     result.x = v.y;
>+//     result.y = v.z;
>+//     return result;
>+// }
>+// uint3 operator.yz=(uint3 v, uint2 c) {
>+//     uint3 result = v;
>+//     result.y = c.x;
>+//     result.z = c.y;
>+//     return result;
>+// }
>+// uint2 operator.zx(uint3 v) {
>+//     uint2 result;
>+//     result.x = v.z;
>+//     result.y = v.x;
>+//     return result;
>+// }
>+// uint3 operator.zx=(uint3 v, uint2 c) {
>+//     uint3 result = v;
>+//     result.z = c.x;
>+//     result.x = c.y;
>+//     return result;
>+// }
>+// uint2 operator.zy(uint3 v) {
>+//     uint2 result;
>+//     result.x = v.z;
>+//     result.y = v.y;
>+//     return result;
>+// }
>+// uint3 operator.zy=(uint3 v, uint2 c) {
>+//     uint3 result = v;
>+//     result.z = c.x;
>+//     result.y = c.y;
>+//     return result;
>+// }
>+// uint2 operator.zz(uint3 v) {
>+//     uint2 result;
>+//     result.x = v.z;
>+//     result.y = v.z;
>+//     return result;
>+// }
>+// uint2 operator.xx(uint4 v) {
>+//     uint2 result;
>+//     result.x = v.x;
>+//     result.y = v.x;
>+//     return result;
>+// }
>+// uint2 operator.xy(uint4 v) {
>+//     uint2 result;
>+//     result.x = v.x;
>+//     result.y = v.y;
>+//     return result;
>+// }
>+// uint4 operator.xy=(uint4 v, uint2 c) {
>+//     uint4 result = v;
>+//     result.x = c.x;
>+//     result.y = c.y;
>+//     return result;
>+// }
>+// uint2 operator.xz(uint4 v) {
>+//     uint2 result;
>+//     result.x = v.x;
>+//     result.y = v.z;
>+//     return result;
>+// }
>+// uint4 operator.xz=(uint4 v, uint2 c) {
>+//     uint4 result = v;
>+//     result.x = c.x;
>+//     result.z = c.y;
>+//     return result;
>+// }
>+// uint2 operator.xw(uint4 v) {
>+//     uint2 result;
>+//     result.x = v.x;
>+//     result.y = v.w;
>+//     return result;
>+// }
>+// uint4 operator.xw=(uint4 v, uint2 c) {
>+//     uint4 result = v;
>+//     result.x = c.x;
>+//     result.w = c.y;
>+//     return result;
>+// }
>+// uint2 operator.yx(uint4 v) {
>+//     uint2 result;
>+//     result.x = v.y;
>+//     result.y = v.x;
>+//     return result;
>+// }
>+// uint4 operator.yx=(uint4 v, uint2 c) {
>+//     uint4 result = v;
>+//     result.y = c.x;
>+//     result.x = c.y;
>+//     return result;
>+// }
>+// uint2 operator.yy(uint4 v) {
>+//     uint2 result;
>+//     result.x = v.y;
>+//     result.y = v.y;
>+//     return result;
>+// }
>+// uint2 operator.yz(uint4 v) {
>+//     uint2 result;
>+//     result.x = v.y;
>+//     result.y = v.z;
>+//     return result;
>+// }
>+// uint4 operator.yz=(uint4 v, uint2 c) {
>+//     uint4 result = v;
>+//     result.y = c.x;
>+//     result.z = c.y;
>+//     return result;
>+// }
>+// uint2 operator.yw(uint4 v) {
>+//     uint2 result;
>+//     result.x = v.y;
>+//     result.y = v.w;
>+//     return result;
>+// }
>+// uint4 operator.yw=(uint4 v, uint2 c) {
>+//     uint4 result = v;
>+//     result.y = c.x;
>+//     result.w = c.y;
>+//     return result;
>+// }
>+// uint2 operator.zx(uint4 v) {
>+//     uint2 result;
>+//     result.x = v.z;
>+//     result.y = v.x;
>+//     return result;
>+// }
>+// uint4 operator.zx=(uint4 v, uint2 c) {
>+//     uint4 result = v;
>+//     result.z = c.x;
>+//     result.x = c.y;
>+//     return result;
>+// }
>+// uint2 operator.zy(uint4 v) {
>+//     uint2 result;
>+//     result.x = v.z;
>+//     result.y = v.y;
>+//     return result;
>+// }
>+// uint4 operator.zy=(uint4 v, uint2 c) {
>+//     uint4 result = v;
>+//     result.z = c.x;
>+//     result.y = c.y;
>+//     return result;
>+// }
>+// uint2 operator.zz(uint4 v) {
>+//     uint2 result;
>+//     result.x = v.z;
>+//     result.y = v.z;
>+//     return result;
>+// }
>+// uint2 operator.zw(uint4 v) {
>+//     uint2 result;
>+//     result.x = v.z;
>+//     result.y = v.w;
>+//     return result;
>+// }
>+// uint4 operator.zw=(uint4 v, uint2 c) {
>+//     uint4 result = v;
>+//     result.z = c.x;
>+//     result.w = c.y;
>+//     return result;
>+// }
>+// uint2 operator.wx(uint4 v) {
>+//     uint2 result;
>+//     result.x = v.w;
>+//     result.y = v.x;
>+//     return result;
>+// }
>+// uint4 operator.wx=(uint4 v, uint2 c) {
>+//     uint4 result = v;
>+//     result.w = c.x;
>+//     result.x = c.y;
>+//     return result;
>+// }
>+// uint2 operator.wy(uint4 v) {
>+//     uint2 result;
>+//     result.x = v.w;
>+//     result.y = v.y;
>+//     return result;
>+// }
>+// uint4 operator.wy=(uint4 v, uint2 c) {
>+//     uint4 result = v;
>+//     result.w = c.x;
>+//     result.y = c.y;
>+//     return result;
>+// }
>+// uint2 operator.wz(uint4 v) {
>+//     uint2 result;
>+//     result.x = v.w;
>+//     result.y = v.z;
>+//     return result;
>+// }
>+// uint4 operator.wz=(uint4 v, uint2 c) {
>+//     uint4 result = v;
>+//     result.w = c.x;
>+//     result.z = c.y;
>+//     return result;
>+// }
>+// uint2 operator.ww(uint4 v) {
>+//     uint2 result;
>+//     result.x = v.w;
>+//     result.y = v.w;
>+//     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.xxy(uint2 v) {
>+//     uint3 result;
>+//     result.x = v.x;
>+//     result.y = v.x;
>+//     result.z = v.y;
>+//     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.xyy(uint2 v) {
>+//     uint3 result;
>+//     result.x = v.x;
>+//     result.y = v.y;
>+//     result.z = v.y;
>+//     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.yxy(uint2 v) {
>+//     uint3 result;
>+//     result.x = v.y;
>+//     result.y = v.x;
>+//     result.z = v.y;
>+//     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.yyy(uint2 v) {
>+//     uint3 result;
>+//     result.x = v.y;
>+//     result.y = v.y;
>+//     result.z = v.y;
>+//     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.xxy(uint3 v) {
>+//     uint3 result;
>+//     result.x = v.x;
>+//     result.y = v.x;
>+//     result.z = v.y;
>+//     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.xyx(uint3 v) {
>+//     uint3 result;
>+//     result.x = v.x;
>+//     result.y = v.y;
>+//     result.z = v.x;
>+//     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.xyz(uint3 v) {
>+//     uint3 result;
>+//     result.x = v.x;
>+//     result.y = v.y;
>+//     result.z = v.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;
>+// }
>+// uint3 operator.xzx(uint3 v) {
>+//     uint3 result;
>+//     result.x = v.x;
>+//     result.y = v.z;
>+//     result.z = v.x;
>+//     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=(uint3 v, uint3 c) {
>+//     uint3 result = v;
>+//     result.x = c.x;
>+//     result.z = c.y;
>+//     result.y = c.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.yxx(uint3 v) {
>+//     uint3 result;
>+//     result.x = v.y;
>+//     result.y = v.x;
>+//     result.z = v.x;
>+//     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.yxz(uint3 v) {
>+//     uint3 result;
>+//     result.x = v.y;
>+//     result.y = v.x;
>+//     result.z = v.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;
>+// }
>+// uint3 operator.yyx(uint3 v) {
>+//     uint3 result;
>+//     result.x = v.y;
>+//     result.y = v.y;
>+//     result.z = v.x;
>+//     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.yyz(uint3 v) {
>+//     uint3 result;
>+//     result.x = v.y;
>+//     result.y = v.y;
>+//     result.z = v.z;
>+//     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=(uint3 v, uint3 c) {
>+//     uint3 result = v;
>+//     result.y = c.x;
>+//     result.z = c.y;
>+//     result.x = c.z;
>+//     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.yzz(uint3 v) {
>+//     uint3 result;
>+//     result.x = v.y;
>+//     result.y = v.z;
>+//     result.z = v.z;
>+//     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.zxy(uint3 v) {
>+//     uint3 result;
>+//     result.x = v.z;
>+//     result.y = v.x;
>+//     result.z = v.y;
>+//     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;
>+// }
>+// uint3 operator.zxz(uint3 v) {
>+//     uint3 result;
>+//     result.x = v.z;
>+//     result.y = v.x;
>+//     result.z = v.z;
>+//     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=(uint3 v, uint3 c) {
>+//     uint3 result = v;
>+//     result.z = c.x;
>+//     result.y = c.y;
>+//     result.x = c.z;
>+//     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.zyz(uint3 v) {
>+//     uint3 result;
>+//     result.x = v.z;
>+//     result.y = v.y;
>+//     result.z = v.z;
>+//     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.zzy(uint3 v) {
>+//     uint3 result;
>+//     result.x = v.z;
>+//     result.y = v.z;
>+//     result.z = v.y;
>+//     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.xxx(uint4 v) {
>+//     uint3 result;
>+//     result.x = v.x;
>+//     result.y = v.x;
>+//     result.z = v.x;
>+//     return result;
>+// }
>+// uint3 operator.xxy(uint4 v) {
>+//     uint3 result;
>+//     result.x = v.x;
>+//     result.y = v.x;
>+//     result.z = v.y;
>+//     return result;
>+// }
>+// uint3 operator.xxz(uint4 v) {
>+//     uint3 result;
>+//     result.x = v.x;
>+//     result.y = v.x;
>+//     result.z = v.z;
>+//     return result;
>+// }
>+// uint3 operator.xxw(uint4 v) {
>+//     uint3 result;
>+//     result.x = v.x;
>+//     result.y = v.x;
>+//     result.z = v.w;
>+//     return result;
>+// }
>+// uint3 operator.xyx(uint4 v) {
>+//     uint3 result;
>+//     result.x = v.x;
>+//     result.y = v.y;
>+//     result.z = v.x;
>+//     return result;
>+// }
>+// uint3 operator.xyy(uint4 v) {
>+//     uint3 result;
>+//     result.x = v.x;
>+//     result.y = v.y;
>+//     result.z = v.y;
>+//     return result;
>+// }
>+// uint3 operator.xyz(uint4 v) {
>+//     uint3 result;
>+//     result.x = v.x;
>+//     result.y = v.y;
>+//     result.z = v.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;
>+// }
>+// uint3 operator.xyw(uint4 v) {
>+//     uint3 result;
>+//     result.x = v.x;
>+//     result.y = v.y;
>+//     result.z = v.w;
>+//     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;
>+// }
>+// uint3 operator.xzx(uint4 v) {
>+//     uint3 result;
>+//     result.x = v.x;
>+//     result.y = v.z;
>+//     result.z = v.x;
>+//     return result;
>+// }
>+// uint3 operator.xzy(uint4 v) {
>+//     uint3 result;
>+//     result.x = v.x;
>+//     result.y = v.z;
>+//     result.z = v.y;
>+//     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;
>+// }
>+// uint3 operator.xzz(uint4 v) {
>+//     uint3 result;
>+//     result.x = v.x;
>+//     result.y = v.z;
>+//     result.z = v.z;
>+//     return result;
>+// }
>+// uint3 operator.xzw(uint4 v) {
>+//     uint3 result;
>+//     result.x = v.x;
>+//     result.y = v.z;
>+//     result.z = v.w;
>+//     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;
>+// }
>+// uint3 operator.xwx(uint4 v) {
>+//     uint3 result;
>+//     result.x = v.x;
>+//     result.y = v.w;
>+//     result.z = v.x;
>+//     return result;
>+// }
>+// uint3 operator.xwy(uint4 v) {
>+//     uint3 result;
>+//     result.x = v.x;
>+//     result.y = v.w;
>+//     result.z = v.y;
>+//     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;
>+// }
>+// uint3 operator.xwz(uint4 v) {
>+//     uint3 result;
>+//     result.x = v.x;
>+//     result.y = v.w;
>+//     result.z = v.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;
>+// }
>+// uint3 operator.xww(uint4 v) {
>+//     uint3 result;
>+//     result.x = v.x;
>+//     result.y = v.w;
>+//     result.z = v.w;
>+//     return result;
>+// }
>+// uint3 operator.yxx(uint4 v) {
>+//     uint3 result;
>+//     result.x = v.y;
>+//     result.y = v.x;
>+//     result.z = v.x;
>+//     return result;
>+// }
>+// uint3 operator.yxy(uint4 v) {
>+//     uint3 result;
>+//     result.x = v.y;
>+//     result.y = v.x;
>+//     result.z = v.y;
>+//     return result;
>+// }
>+// uint3 operator.yxz(uint4 v) {
>+//     uint3 result;
>+//     result.x = v.y;
>+//     result.y = v.x;
>+//     result.z = v.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;
>+// }
>+// uint3 operator.yxw(uint4 v) {
>+//     uint3 result;
>+//     result.x = v.y;
>+//     result.y = v.x;
>+//     result.z = v.w;
>+//     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;
>+// }
>+// uint3 operator.yyx(uint4 v) {
>+//     uint3 result;
>+//     result.x = v.y;
>+//     result.y = v.y;
>+//     result.z = v.x;
>+//     return result;
>+// }
>+// uint3 operator.yyy(uint4 v) {
>+//     uint3 result;
>+//     result.x = v.y;
>+//     result.y = v.y;
>+//     result.z = v.y;
>+//     return result;
>+// }
>+// uint3 operator.yyz(uint4 v) {
>+//     uint3 result;
>+//     result.x = v.y;
>+//     result.y = v.y;
>+//     result.z = v.z;
>+//     return result;
>+// }
>+// uint3 operator.yyw(uint4 v) {
>+//     uint3 result;
>+//     result.x = v.y;
>+//     result.y = v.y;
>+//     result.z = v.w;
>+//     return result;
>+// }
>+// uint3 operator.yzx(uint4 v) {
>+//     uint3 result;
>+//     result.x = v.y;
>+//     result.y = v.z;
>+//     result.z = v.x;
>+//     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;
>+// }
>+// uint3 operator.yzy(uint4 v) {
>+//     uint3 result;
>+//     result.x = v.y;
>+//     result.y = v.z;
>+//     result.z = v.y;
>+//     return result;
>+// }
>+// uint3 operator.yzz(uint4 v) {
>+//     uint3 result;
>+//     result.x = v.y;
>+//     result.y = v.z;
>+//     result.z = v.z;
>+//     return result;
>+// }
>+// uint3 operator.yzw(uint4 v) {
>+//     uint3 result;
>+//     result.x = v.y;
>+//     result.y = v.z;
>+//     result.z = v.w;
>+//     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;
>+// }
>+// uint3 operator.ywx(uint4 v) {
>+//     uint3 result;
>+//     result.x = v.y;
>+//     result.y = v.w;
>+//     result.z = v.x;
>+//     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;
>+// }
>+// uint3 operator.ywy(uint4 v) {
>+//     uint3 result;
>+//     result.x = v.y;
>+//     result.y = v.w;
>+//     result.z = v.y;
>+//     return result;
>+// }
>+// uint3 operator.ywz(uint4 v) {
>+//     uint3 result;
>+//     result.x = v.y;
>+//     result.y = v.w;
>+//     result.z = v.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;
>+// }
>+// uint3 operator.yww(uint4 v) {
>+//     uint3 result;
>+//     result.x = v.y;
>+//     result.y = v.w;
>+//     result.z = v.w;
>+//     return result;
>+// }
>+// uint3 operator.zxx(uint4 v) {
>+//     uint3 result;
>+//     result.x = v.z;
>+//     result.y = v.x;
>+//     result.z = v.x;
>+//     return result;
>+// }
>+// uint3 operator.zxy(uint4 v) {
>+//     uint3 result;
>+//     result.x = v.z;
>+//     result.y = v.x;
>+//     result.z = v.y;
>+//     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;
>+// }
>+// uint3 operator.zxz(uint4 v) {
>+//     uint3 result;
>+//     result.x = v.z;
>+//     result.y = v.x;
>+//     result.z = v.z;
>+//     return result;
>+// }
>+// uint3 operator.zxw(uint4 v) {
>+//     uint3 result;
>+//     result.x = v.z;
>+//     result.y = v.x;
>+//     result.z = v.w;
>+//     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;
>+// }
>+// uint3 operator.zyx(uint4 v) {
>+//     uint3 result;
>+//     result.x = v.z;
>+//     result.y = v.y;
>+//     result.z = v.x;
>+//     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;
>+// }
>+// uint3 operator.zyy(uint4 v) {
>+//     uint3 result;
>+//     result.x = v.z;
>+//     result.y = v.y;
>+//     result.z = v.y;
>+//     return result;
>+// }
>+// uint3 operator.zyz(uint4 v) {
>+//     uint3 result;
>+//     result.x = v.z;
>+//     result.y = v.y;
>+//     result.z = v.z;
>+//     return result;
>+// }
>+// uint3 operator.zyw(uint4 v) {
>+//     uint3 result;
>+//     result.x = v.z;
>+//     result.y = v.y;
>+//     result.z = v.w;
>+//     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;
>+// }
>+// uint3 operator.zzx(uint4 v) {
>+//     uint3 result;
>+//     result.x = v.z;
>+//     result.y = v.z;
>+//     result.z = v.x;
>+//     return result;
>+// }
>+// uint3 operator.zzy(uint4 v) {
>+//     uint3 result;
>+//     result.x = v.z;
>+//     result.y = v.z;
>+//     result.z = v.y;
>+//     return result;
>+// }
>+// uint3 operator.zzz(uint4 v) {
>+//     uint3 result;
>+//     result.x = v.z;
>+//     result.y = v.z;
>+//     result.z = v.z;
>+//     return result;
>+// }
>+// uint3 operator.zzw(uint4 v) {
>+//     uint3 result;
>+//     result.x = v.z;
>+//     result.y = v.z;
>+//     result.z = v.w;
>+//     return result;
>+// }
>+// uint3 operator.zwx(uint4 v) {
>+//     uint3 result;
>+//     result.x = v.z;
>+//     result.y = v.w;
>+//     result.z = v.x;
>+//     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;
>+// }
>+// uint3 operator.zwy(uint4 v) {
>+//     uint3 result;
>+//     result.x = v.z;
>+//     result.y = v.w;
>+//     result.z = v.y;
>+//     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;
>+// }
>+// uint3 operator.zwz(uint4 v) {
>+//     uint3 result;
>+//     result.x = v.z;
>+//     result.y = v.w;
>+//     result.z = v.z;
>+//     return result;
>+// }
>+// uint3 operator.zww(uint4 v) {
>+//     uint3 result;
>+//     result.x = v.z;
>+//     result.y = v.w;
>+//     result.z = v.w;
>+//     return result;
>+// }
>+// uint3 operator.wxx(uint4 v) {
>+//     uint3 result;
>+//     result.x = v.w;
>+//     result.y = v.x;
>+//     result.z = v.x;
>+//     return result;
>+// }
>+// uint3 operator.wxy(uint4 v) {
>+//     uint3 result;
>+//     result.x = v.w;
>+//     result.y = v.x;
>+//     result.z = v.y;
>+//     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;
>+// }
>+// uint3 operator.wxz(uint4 v) {
>+//     uint3 result;
>+//     result.x = v.w;
>+//     result.y = v.x;
>+//     result.z = v.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;
>+// }
>+// uint3 operator.wxw(uint4 v) {
>+//     uint3 result;
>+//     result.x = v.w;
>+//     result.y = v.x;
>+//     result.z = v.w;
>+//     return result;
>+// }
>+// uint3 operator.wyx(uint4 v) {
>+//     uint3 result;
>+//     result.x = v.w;
>+//     result.y = v.y;
>+//     result.z = v.x;
>+//     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;
>+// }
>+// uint3 operator.wyy(uint4 v) {
>+//     uint3 result;
>+//     result.x = v.w;
>+//     result.y = v.y;
>+//     result.z = v.y;
>+//     return result;
>+// }
>+// uint3 operator.wyz(uint4 v) {
>+//     uint3 result;
>+//     result.x = v.w;
>+//     result.y = v.y;
>+//     result.z = v.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;
>+// }
>+// uint3 operator.wyw(uint4 v) {
>+//     uint3 result;
>+//     result.x = v.w;
>+//     result.y = v.y;
>+//     result.z = v.w;
>+//     return result;
>+// }
>+// uint3 operator.wzx(uint4 v) {
>+//     uint3 result;
>+//     result.x = v.w;
>+//     result.y = v.z;
>+//     result.z = v.x;
>+//     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;
>+// }
>+// uint3 operator.wzy(uint4 v) {
>+//     uint3 result;
>+//     result.x = v.w;
>+//     result.y = v.z;
>+//     result.z = v.y;
>+//     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;
>+// }
>+// uint3 operator.wzz(uint4 v) {
>+//     uint3 result;
>+//     result.x = v.w;
>+//     result.y = v.z;
>+//     result.z = v.z;
>+//     return result;
>+// }
>+// uint3 operator.wzw(uint4 v) {
>+//     uint3 result;
>+//     result.x = v.w;
>+//     result.y = v.z;
>+//     result.z = v.w;
>+//     return result;
>+// }
>+// uint3 operator.wwx(uint4 v) {
>+//     uint3 result;
>+//     result.x = v.w;
>+//     result.y = v.w;
>+//     result.z = v.x;
>+//     return result;
>+// }
>+// uint3 operator.wwy(uint4 v) {
>+//     uint3 result;
>+//     result.x = v.w;
>+//     result.y = v.w;
>+//     result.z = v.y;
>+//     return result;
>+// }
>+// uint3 operator.wwz(uint4 v) {
>+//     uint3 result;
>+//     result.x = v.w;
>+//     result.y = v.w;
>+//     result.z = v.z;
>+//     return result;
>+// }
>+// uint3 operator.www(uint4 v) {
>+//     uint3 result;
>+//     result.x = v.w;
>+//     result.y = v.w;
>+//     result.z = v.w;
>+//     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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.xxxx(uint4 v) {
>+//     uint4 result;
>+//     result.x = v.x;
>+//     result.y = v.x;
>+//     result.z = v.x;
>+//     result.w = v.x;
>+//     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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// char2 operator.xx(char2 v) {
>+//     char2 result;
>+//     result.x = v.x;
>+//     result.y = v.x;
>+//     return result;
>+// }
>+// char2 operator.xy(char2 v) {
>+//     char2 result;
>+//     result.x = v.x;
>+//     result.y = v.y;
>+//     return result;
>+// }
>+// char2 operator.xy=(char2 v, char2 c) {
>+//     char2 result = v;
>+//     result.x = c.x;
>+//     result.y = c.y;
>+//     return result;
>+// }
>+// char2 operator.yx(char2 v) {
>+//     char2 result;
>+//     result.x = v.y;
>+//     result.y = v.x;
>+//     return result;
>+// }
>+// char2 operator.yx=(char2 v, char2 c) {
>+//     char2 result = v;
>+//     result.y = c.x;
>+//     result.x = c.y;
>+//     return result;
>+// }
>+// char2 operator.yy(char2 v) {
>+//     char2 result;
>+//     result.x = v.y;
>+//     result.y = v.y;
>+//     return result;
>+// }
>+// char2 operator.xx(char3 v) {
>+//     char2 result;
>+//     result.x = v.x;
>+//     result.y = v.x;
>+//     return result;
>+// }
>+// char2 operator.xy(char3 v) {
>+//     char2 result;
>+//     result.x = v.x;
>+//     result.y = v.y;
>+//     return result;
>+// }
>+// char3 operator.xy=(char3 v, char2 c) {
>+//     char3 result = v;
>+//     result.x = c.x;
>+//     result.y = c.y;
>+//     return result;
>+// }
>+// char2 operator.xz(char3 v) {
>+//     char2 result;
>+//     result.x = v.x;
>+//     result.y = v.z;
>+//     return result;
>+// }
>+// char3 operator.xz=(char3 v, char2 c) {
>+//     char3 result = v;
>+//     result.x = c.x;
>+//     result.z = c.y;
>+//     return result;
>+// }
>+// char2 operator.yx(char3 v) {
>+//     char2 result;
>+//     result.x = v.y;
>+//     result.y = v.x;
>+//     return result;
>+// }
>+// char3 operator.yx=(char3 v, char2 c) {
>+//     char3 result = v;
>+//     result.y = c.x;
>+//     result.x = c.y;
>+//     return result;
>+// }
>+// char2 operator.yy(char3 v) {
>+//     char2 result;
>+//     result.x = v.y;
>+//     result.y = v.y;
>+//     return result;
>+// }
>+// char2 operator.yz(char3 v) {
>+//     char2 result;
>+//     result.x = v.y;
>+//     result.y = v.z;
>+//     return result;
>+// }
>+// char3 operator.yz=(char3 v, char2 c) {
>+//     char3 result = v;
>+//     result.y = c.x;
>+//     result.z = c.y;
>+//     return result;
>+// }
>+// char2 operator.zx(char3 v) {
>+//     char2 result;
>+//     result.x = v.z;
>+//     result.y = v.x;
>+//     return result;
>+// }
>+// char3 operator.zx=(char3 v, char2 c) {
>+//     char3 result = v;
>+//     result.z = c.x;
>+//     result.x = c.y;
>+//     return result;
>+// }
>+// char2 operator.zy(char3 v) {
>+//     char2 result;
>+//     result.x = v.z;
>+//     result.y = v.y;
>+//     return result;
>+// }
>+// char3 operator.zy=(char3 v, char2 c) {
>+//     char3 result = v;
>+//     result.z = c.x;
>+//     result.y = c.y;
>+//     return result;
>+// }
>+// char2 operator.zz(char3 v) {
>+//     char2 result;
>+//     result.x = v.z;
>+//     result.y = v.z;
>+//     return result;
>+// }
>+// char2 operator.xx(char4 v) {
>+//     char2 result;
>+//     result.x = v.x;
>+//     result.y = v.x;
>+//     return result;
>+// }
>+// char2 operator.xy(char4 v) {
>+//     char2 result;
>+//     result.x = v.x;
>+//     result.y = v.y;
>+//     return result;
>+// }
>+// char4 operator.xy=(char4 v, char2 c) {
>+//     char4 result = v;
>+//     result.x = c.x;
>+//     result.y = c.y;
>+//     return result;
>+// }
>+// char2 operator.xz(char4 v) {
>+//     char2 result;
>+//     result.x = v.x;
>+//     result.y = v.z;
>+//     return result;
>+// }
>+// char4 operator.xz=(char4 v, char2 c) {
>+//     char4 result = v;
>+//     result.x = c.x;
>+//     result.z = c.y;
>+//     return result;
>+// }
>+// char2 operator.xw(char4 v) {
>+//     char2 result;
>+//     result.x = v.x;
>+//     result.y = v.w;
>+//     return result;
>+// }
>+// char4 operator.xw=(char4 v, char2 c) {
>+//     char4 result = v;
>+//     result.x = c.x;
>+//     result.w = c.y;
>+//     return result;
>+// }
>+// char2 operator.yx(char4 v) {
>+//     char2 result;
>+//     result.x = v.y;
>+//     result.y = v.x;
>+//     return result;
>+// }
>+// char4 operator.yx=(char4 v, char2 c) {
>+//     char4 result = v;
>+//     result.y = c.x;
>+//     result.x = c.y;
>+//     return result;
>+// }
>+// char2 operator.yy(char4 v) {
>+//     char2 result;
>+//     result.x = v.y;
>+//     result.y = v.y;
>+//     return result;
>+// }
>+// char2 operator.yz(char4 v) {
>+//     char2 result;
>+//     result.x = v.y;
>+//     result.y = v.z;
>+//     return result;
>+// }
>+// char4 operator.yz=(char4 v, char2 c) {
>+//     char4 result = v;
>+//     result.y = c.x;
>+//     result.z = c.y;
>+//     return result;
>+// }
>+// char2 operator.yw(char4 v) {
>+//     char2 result;
>+//     result.x = v.y;
>+//     result.y = v.w;
>+//     return result;
>+// }
>+// char4 operator.yw=(char4 v, char2 c) {
>+//     char4 result = v;
>+//     result.y = c.x;
>+//     result.w = c.y;
>+//     return result;
>+// }
>+// char2 operator.zx(char4 v) {
>+//     char2 result;
>+//     result.x = v.z;
>+//     result.y = v.x;
>+//     return result;
>+// }
>+// char4 operator.zx=(char4 v, char2 c) {
>+//     char4 result = v;
>+//     result.z = c.x;
>+//     result.x = c.y;
>+//     return result;
>+// }
>+// char2 operator.zy(char4 v) {
>+//     char2 result;
>+//     result.x = v.z;
>+//     result.y = v.y;
>+//     return result;
>+// }
>+// char4 operator.zy=(char4 v, char2 c) {
>+//     char4 result = v;
>+//     result.z = c.x;
>+//     result.y = c.y;
>+//     return result;
>+// }
>+// char2 operator.zz(char4 v) {
>+//     char2 result;
>+//     result.x = v.z;
>+//     result.y = v.z;
>+//     return result;
>+// }
>+// char2 operator.zw(char4 v) {
>+//     char2 result;
>+//     result.x = v.z;
>+//     result.y = v.w;
>+//     return result;
>+// }
>+// char4 operator.zw=(char4 v, char2 c) {
>+//     char4 result = v;
>+//     result.z = c.x;
>+//     result.w = c.y;
>+//     return result;
>+// }
>+// char2 operator.wx(char4 v) {
>+//     char2 result;
>+//     result.x = v.w;
>+//     result.y = v.x;
>+//     return result;
>+// }
>+// char4 operator.wx=(char4 v, char2 c) {
>+//     char4 result = v;
>+//     result.w = c.x;
>+//     result.x = c.y;
>+//     return result;
>+// }
>+// char2 operator.wy(char4 v) {
>+//     char2 result;
>+//     result.x = v.w;
>+//     result.y = v.y;
>+//     return result;
>+// }
>+// char4 operator.wy=(char4 v, char2 c) {
>+//     char4 result = v;
>+//     result.w = c.x;
>+//     result.y = c.y;
>+//     return result;
>+// }
>+// char2 operator.wz(char4 v) {
>+//     char2 result;
>+//     result.x = v.w;
>+//     result.y = v.z;
>+//     return result;
>+// }
>+// char4 operator.wz=(char4 v, char2 c) {
>+//     char4 result = v;
>+//     result.w = c.x;
>+//     result.z = c.y;
>+//     return result;
>+// }
>+// char2 operator.ww(char4 v) {
>+//     char2 result;
>+//     result.x = v.w;
>+//     result.y = v.w;
>+//     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.xxy(char2 v) {
>+//     char3 result;
>+//     result.x = v.x;
>+//     result.y = v.x;
>+//     result.z = v.y;
>+//     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.xyy(char2 v) {
>+//     char3 result;
>+//     result.x = v.x;
>+//     result.y = v.y;
>+//     result.z = v.y;
>+//     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.yxy(char2 v) {
>+//     char3 result;
>+//     result.x = v.y;
>+//     result.y = v.x;
>+//     result.z = v.y;
>+//     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.yyy(char2 v) {
>+//     char3 result;
>+//     result.x = v.y;
>+//     result.y = v.y;
>+//     result.z = v.y;
>+//     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.xxy(char3 v) {
>+//     char3 result;
>+//     result.x = v.x;
>+//     result.y = v.x;
>+//     result.z = v.y;
>+//     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.xyx(char3 v) {
>+//     char3 result;
>+//     result.x = v.x;
>+//     result.y = v.y;
>+//     result.z = v.x;
>+//     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.xyz(char3 v) {
>+//     char3 result;
>+//     result.x = v.x;
>+//     result.y = v.y;
>+//     result.z = v.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;
>+// }
>+// char3 operator.xzx(char3 v) {
>+//     char3 result;
>+//     result.x = v.x;
>+//     result.y = v.z;
>+//     result.z = v.x;
>+//     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=(char3 v, char3 c) {
>+//     char3 result = v;
>+//     result.x = c.x;
>+//     result.z = c.y;
>+//     result.y = c.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.yxx(char3 v) {
>+//     char3 result;
>+//     result.x = v.y;
>+//     result.y = v.x;
>+//     result.z = v.x;
>+//     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.yxz(char3 v) {
>+//     char3 result;
>+//     result.x = v.y;
>+//     result.y = v.x;
>+//     result.z = v.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;
>+// }
>+// char3 operator.yyx(char3 v) {
>+//     char3 result;
>+//     result.x = v.y;
>+//     result.y = v.y;
>+//     result.z = v.x;
>+//     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.yyz(char3 v) {
>+//     char3 result;
>+//     result.x = v.y;
>+//     result.y = v.y;
>+//     result.z = v.z;
>+//     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=(char3 v, char3 c) {
>+//     char3 result = v;
>+//     result.y = c.x;
>+//     result.z = c.y;
>+//     result.x = c.z;
>+//     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.yzz(char3 v) {
>+//     char3 result;
>+//     result.x = v.y;
>+//     result.y = v.z;
>+//     result.z = v.z;
>+//     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.zxy(char3 v) {
>+//     char3 result;
>+//     result.x = v.z;
>+//     result.y = v.x;
>+//     result.z = v.y;
>+//     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;
>+// }
>+// char3 operator.zxz(char3 v) {
>+//     char3 result;
>+//     result.x = v.z;
>+//     result.y = v.x;
>+//     result.z = v.z;
>+//     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=(char3 v, char3 c) {
>+//     char3 result = v;
>+//     result.z = c.x;
>+//     result.y = c.y;
>+//     result.x = c.z;
>+//     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.zyz(char3 v) {
>+//     char3 result;
>+//     result.x = v.z;
>+//     result.y = v.y;
>+//     result.z = v.z;
>+//     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.zzy(char3 v) {
>+//     char3 result;
>+//     result.x = v.z;
>+//     result.y = v.z;
>+//     result.z = v.y;
>+//     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.xxx(char4 v) {
>+//     char3 result;
>+//     result.x = v.x;
>+//     result.y = v.x;
>+//     result.z = v.x;
>+//     return result;
>+// }
>+// char3 operator.xxy(char4 v) {
>+//     char3 result;
>+//     result.x = v.x;
>+//     result.y = v.x;
>+//     result.z = v.y;
>+//     return result;
>+// }
>+// char3 operator.xxz(char4 v) {
>+//     char3 result;
>+//     result.x = v.x;
>+//     result.y = v.x;
>+//     result.z = v.z;
>+//     return result;
>+// }
>+// char3 operator.xxw(char4 v) {
>+//     char3 result;
>+//     result.x = v.x;
>+//     result.y = v.x;
>+//     result.z = v.w;
>+//     return result;
>+// }
>+// char3 operator.xyx(char4 v) {
>+//     char3 result;
>+//     result.x = v.x;
>+//     result.y = v.y;
>+//     result.z = v.x;
>+//     return result;
>+// }
>+// char3 operator.xyy(char4 v) {
>+//     char3 result;
>+//     result.x = v.x;
>+//     result.y = v.y;
>+//     result.z = v.y;
>+//     return result;
>+// }
>+// char3 operator.xyz(char4 v) {
>+//     char3 result;
>+//     result.x = v.x;
>+//     result.y = v.y;
>+//     result.z = v.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;
>+// }
>+// char3 operator.xyw(char4 v) {
>+//     char3 result;
>+//     result.x = v.x;
>+//     result.y = v.y;
>+//     result.z = v.w;
>+//     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;
>+// }
>+// char3 operator.xzx(char4 v) {
>+//     char3 result;
>+//     result.x = v.x;
>+//     result.y = v.z;
>+//     result.z = v.x;
>+//     return result;
>+// }
>+// char3 operator.xzy(char4 v) {
>+//     char3 result;
>+//     result.x = v.x;
>+//     result.y = v.z;
>+//     result.z = v.y;
>+//     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;
>+// }
>+// char3 operator.xzz(char4 v) {
>+//     char3 result;
>+//     result.x = v.x;
>+//     result.y = v.z;
>+//     result.z = v.z;
>+//     return result;
>+// }
>+// char3 operator.xzw(char4 v) {
>+//     char3 result;
>+//     result.x = v.x;
>+//     result.y = v.z;
>+//     result.z = v.w;
>+//     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;
>+// }
>+// char3 operator.xwx(char4 v) {
>+//     char3 result;
>+//     result.x = v.x;
>+//     result.y = v.w;
>+//     result.z = v.x;
>+//     return result;
>+// }
>+// char3 operator.xwy(char4 v) {
>+//     char3 result;
>+//     result.x = v.x;
>+//     result.y = v.w;
>+//     result.z = v.y;
>+//     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;
>+// }
>+// char3 operator.xwz(char4 v) {
>+//     char3 result;
>+//     result.x = v.x;
>+//     result.y = v.w;
>+//     result.z = v.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;
>+// }
>+// char3 operator.xww(char4 v) {
>+//     char3 result;
>+//     result.x = v.x;
>+//     result.y = v.w;
>+//     result.z = v.w;
>+//     return result;
>+// }
>+// char3 operator.yxx(char4 v) {
>+//     char3 result;
>+//     result.x = v.y;
>+//     result.y = v.x;
>+//     result.z = v.x;
>+//     return result;
>+// }
>+// char3 operator.yxy(char4 v) {
>+//     char3 result;
>+//     result.x = v.y;
>+//     result.y = v.x;
>+//     result.z = v.y;
>+//     return result;
>+// }
>+// char3 operator.yxz(char4 v) {
>+//     char3 result;
>+//     result.x = v.y;
>+//     result.y = v.x;
>+//     result.z = v.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;
>+// }
>+// char3 operator.yxw(char4 v) {
>+//     char3 result;
>+//     result.x = v.y;
>+//     result.y = v.x;
>+//     result.z = v.w;
>+//     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;
>+// }
>+// char3 operator.yyx(char4 v) {
>+//     char3 result;
>+//     result.x = v.y;
>+//     result.y = v.y;
>+//     result.z = v.x;
>+//     return result;
>+// }
>+// char3 operator.yyy(char4 v) {
>+//     char3 result;
>+//     result.x = v.y;
>+//     result.y = v.y;
>+//     result.z = v.y;
>+//     return result;
>+// }
>+// char3 operator.yyz(char4 v) {
>+//     char3 result;
>+//     result.x = v.y;
>+//     result.y = v.y;
>+//     result.z = v.z;
>+//     return result;
>+// }
>+// char3 operator.yyw(char4 v) {
>+//     char3 result;
>+//     result.x = v.y;
>+//     result.y = v.y;
>+//     result.z = v.w;
>+//     return result;
>+// }
>+// char3 operator.yzx(char4 v) {
>+//     char3 result;
>+//     result.x = v.y;
>+//     result.y = v.z;
>+//     result.z = v.x;
>+//     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;
>+// }
>+// char3 operator.yzy(char4 v) {
>+//     char3 result;
>+//     result.x = v.y;
>+//     result.y = v.z;
>+//     result.z = v.y;
>+//     return result;
>+// }
>+// char3 operator.yzz(char4 v) {
>+//     char3 result;
>+//     result.x = v.y;
>+//     result.y = v.z;
>+//     result.z = v.z;
>+//     return result;
>+// }
>+// char3 operator.yzw(char4 v) {
>+//     char3 result;
>+//     result.x = v.y;
>+//     result.y = v.z;
>+//     result.z = v.w;
>+//     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;
>+// }
>+// char3 operator.ywx(char4 v) {
>+//     char3 result;
>+//     result.x = v.y;
>+//     result.y = v.w;
>+//     result.z = v.x;
>+//     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;
>+// }
>+// char3 operator.ywy(char4 v) {
>+//     char3 result;
>+//     result.x = v.y;
>+//     result.y = v.w;
>+//     result.z = v.y;
>+//     return result;
>+// }
>+// char3 operator.ywz(char4 v) {
>+//     char3 result;
>+//     result.x = v.y;
>+//     result.y = v.w;
>+//     result.z = v.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;
>+// }
>+// char3 operator.yww(char4 v) {
>+//     char3 result;
>+//     result.x = v.y;
>+//     result.y = v.w;
>+//     result.z = v.w;
>+//     return result;
>+// }
>+// char3 operator.zxx(char4 v) {
>+//     char3 result;
>+//     result.x = v.z;
>+//     result.y = v.x;
>+//     result.z = v.x;
>+//     return result;
>+// }
>+// char3 operator.zxy(char4 v) {
>+//     char3 result;
>+//     result.x = v.z;
>+//     result.y = v.x;
>+//     result.z = v.y;
>+//     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;
>+// }
>+// char3 operator.zxz(char4 v) {
>+//     char3 result;
>+//     result.x = v.z;
>+//     result.y = v.x;
>+//     result.z = v.z;
>+//     return result;
>+// }
>+// char3 operator.zxw(char4 v) {
>+//     char3 result;
>+//     result.x = v.z;
>+//     result.y = v.x;
>+//     result.z = v.w;
>+//     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;
>+// }
>+// char3 operator.zyx(char4 v) {
>+//     char3 result;
>+//     result.x = v.z;
>+//     result.y = v.y;
>+//     result.z = v.x;
>+//     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;
>+// }
>+// char3 operator.zyy(char4 v) {
>+//     char3 result;
>+//     result.x = v.z;
>+//     result.y = v.y;
>+//     result.z = v.y;
>+//     return result;
>+// }
>+// char3 operator.zyz(char4 v) {
>+//     char3 result;
>+//     result.x = v.z;
>+//     result.y = v.y;
>+//     result.z = v.z;
>+//     return result;
>+// }
>+// char3 operator.zyw(char4 v) {
>+//     char3 result;
>+//     result.x = v.z;
>+//     result.y = v.y;
>+//     result.z = v.w;
>+//     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;
>+// }
>+// char3 operator.zzx(char4 v) {
>+//     char3 result;
>+//     result.x = v.z;
>+//     result.y = v.z;
>+//     result.z = v.x;
>+//     return result;
>+// }
>+// char3 operator.zzy(char4 v) {
>+//     char3 result;
>+//     result.x = v.z;
>+//     result.y = v.z;
>+//     result.z = v.y;
>+//     return result;
>+// }
>+// char3 operator.zzz(char4 v) {
>+//     char3 result;
>+//     result.x = v.z;
>+//     result.y = v.z;
>+//     result.z = v.z;
>+//     return result;
>+// }
>+// char3 operator.zzw(char4 v) {
>+//     char3 result;
>+//     result.x = v.z;
>+//     result.y = v.z;
>+//     result.z = v.w;
>+//     return result;
>+// }
>+// char3 operator.zwx(char4 v) {
>+//     char3 result;
>+//     result.x = v.z;
>+//     result.y = v.w;
>+//     result.z = v.x;
>+//     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;
>+// }
>+// char3 operator.zwy(char4 v) {
>+//     char3 result;
>+//     result.x = v.z;
>+//     result.y = v.w;
>+//     result.z = v.y;
>+//     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;
>+// }
>+// char3 operator.zwz(char4 v) {
>+//     char3 result;
>+//     result.x = v.z;
>+//     result.y = v.w;
>+//     result.z = v.z;
>+//     return result;
>+// }
>+// char3 operator.zww(char4 v) {
>+//     char3 result;
>+//     result.x = v.z;
>+//     result.y = v.w;
>+//     result.z = v.w;
>+//     return result;
>+// }
>+// char3 operator.wxx(char4 v) {
>+//     char3 result;
>+//     result.x = v.w;
>+//     result.y = v.x;
>+//     result.z = v.x;
>+//     return result;
>+// }
>+// char3 operator.wxy(char4 v) {
>+//     char3 result;
>+//     result.x = v.w;
>+//     result.y = v.x;
>+//     result.z = v.y;
>+//     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;
>+// }
>+// char3 operator.wxz(char4 v) {
>+//     char3 result;
>+//     result.x = v.w;
>+//     result.y = v.x;
>+//     result.z = v.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;
>+// }
>+// char3 operator.wxw(char4 v) {
>+//     char3 result;
>+//     result.x = v.w;
>+//     result.y = v.x;
>+//     result.z = v.w;
>+//     return result;
>+// }
>+// char3 operator.wyx(char4 v) {
>+//     char3 result;
>+//     result.x = v.w;
>+//     result.y = v.y;
>+//     result.z = v.x;
>+//     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;
>+// }
>+// char3 operator.wyy(char4 v) {
>+//     char3 result;
>+//     result.x = v.w;
>+//     result.y = v.y;
>+//     result.z = v.y;
>+//     return result;
>+// }
>+// char3 operator.wyz(char4 v) {
>+//     char3 result;
>+//     result.x = v.w;
>+//     result.y = v.y;
>+//     result.z = v.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;
>+// }
>+// char3 operator.wyw(char4 v) {
>+//     char3 result;
>+//     result.x = v.w;
>+//     result.y = v.y;
>+//     result.z = v.w;
>+//     return result;
>+// }
>+// char3 operator.wzx(char4 v) {
>+//     char3 result;
>+//     result.x = v.w;
>+//     result.y = v.z;
>+//     result.z = v.x;
>+//     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;
>+// }
>+// char3 operator.wzy(char4 v) {
>+//     char3 result;
>+//     result.x = v.w;
>+//     result.y = v.z;
>+//     result.z = v.y;
>+//     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;
>+// }
>+// char3 operator.wzz(char4 v) {
>+//     char3 result;
>+//     result.x = v.w;
>+//     result.y = v.z;
>+//     result.z = v.z;
>+//     return result;
>+// }
>+// char3 operator.wzw(char4 v) {
>+//     char3 result;
>+//     result.x = v.w;
>+//     result.y = v.z;
>+//     result.z = v.w;
>+//     return result;
>+// }
>+// char3 operator.wwx(char4 v) {
>+//     char3 result;
>+//     result.x = v.w;
>+//     result.y = v.w;
>+//     result.z = v.x;
>+//     return result;
>+// }
>+// char3 operator.wwy(char4 v) {
>+//     char3 result;
>+//     result.x = v.w;
>+//     result.y = v.w;
>+//     result.z = v.y;
>+//     return result;
>+// }
>+// char3 operator.wwz(char4 v) {
>+//     char3 result;
>+//     result.x = v.w;
>+//     result.y = v.w;
>+//     result.z = v.z;
>+//     return result;
>+// }
>+// char3 operator.www(char4 v) {
>+//     char3 result;
>+//     result.x = v.w;
>+//     result.y = v.w;
>+//     result.z = v.w;
>+//     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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.xxxx(char4 v) {
>+//     char4 result;
>+//     result.x = v.x;
>+//     result.y = v.x;
>+//     result.z = v.x;
>+//     result.w = v.x;
>+//     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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// short2 operator.xx(short2 v) {
>+//     short2 result;
>+//     result.x = v.x;
>+//     result.y = v.x;
>+//     return result;
>+// }
>+// short2 operator.xy(short2 v) {
>+//     short2 result;
>+//     result.x = v.x;
>+//     result.y = v.y;
>+//     return result;
>+// }
>+// short2 operator.xy=(short2 v, short2 c) {
>+//     short2 result = v;
>+//     result.x = c.x;
>+//     result.y = c.y;
>+//     return result;
>+// }
>+// short2 operator.yx(short2 v) {
>+//     short2 result;
>+//     result.x = v.y;
>+//     result.y = v.x;
>+//     return result;
>+// }
>+// short2 operator.yx=(short2 v, short2 c) {
>+//     short2 result = v;
>+//     result.y = c.x;
>+//     result.x = c.y;
>+//     return result;
>+// }
>+// short2 operator.yy(short2 v) {
>+//     short2 result;
>+//     result.x = v.y;
>+//     result.y = v.y;
>+//     return result;
>+// }
>+// short2 operator.xx(short3 v) {
>+//     short2 result;
>+//     result.x = v.x;
>+//     result.y = v.x;
>+//     return result;
>+// }
>+// short2 operator.xy(short3 v) {
>+//     short2 result;
>+//     result.x = v.x;
>+//     result.y = v.y;
>+//     return result;
>+// }
>+// short3 operator.xy=(short3 v, short2 c) {
>+//     short3 result = v;
>+//     result.x = c.x;
>+//     result.y = c.y;
>+//     return result;
>+// }
>+// short2 operator.xz(short3 v) {
>+//     short2 result;
>+//     result.x = v.x;
>+//     result.y = v.z;
>+//     return result;
>+// }
>+// short3 operator.xz=(short3 v, short2 c) {
>+//     short3 result = v;
>+//     result.x = c.x;
>+//     result.z = c.y;
>+//     return result;
>+// }
>+// short2 operator.yx(short3 v) {
>+//     short2 result;
>+//     result.x = v.y;
>+//     result.y = v.x;
>+//     return result;
>+// }
>+// short3 operator.yx=(short3 v, short2 c) {
>+//     short3 result = v;
>+//     result.y = c.x;
>+//     result.x = c.y;
>+//     return result;
>+// }
>+// short2 operator.yy(short3 v) {
>+//     short2 result;
>+//     result.x = v.y;
>+//     result.y = v.y;
>+//     return result;
>+// }
>+// short2 operator.yz(short3 v) {
>+//     short2 result;
>+//     result.x = v.y;
>+//     result.y = v.z;
>+//     return result;
>+// }
>+// short3 operator.yz=(short3 v, short2 c) {
>+//     short3 result = v;
>+//     result.y = c.x;
>+//     result.z = c.y;
>+//     return result;
>+// }
>+// short2 operator.zx(short3 v) {
>+//     short2 result;
>+//     result.x = v.z;
>+//     result.y = v.x;
>+//     return result;
>+// }
>+// short3 operator.zx=(short3 v, short2 c) {
>+//     short3 result = v;
>+//     result.z = c.x;
>+//     result.x = c.y;
>+//     return result;
>+// }
>+// short2 operator.zy(short3 v) {
>+//     short2 result;
>+//     result.x = v.z;
>+//     result.y = v.y;
>+//     return result;
>+// }
>+// short3 operator.zy=(short3 v, short2 c) {
>+//     short3 result = v;
>+//     result.z = c.x;
>+//     result.y = c.y;
>+//     return result;
>+// }
>+// short2 operator.zz(short3 v) {
>+//     short2 result;
>+//     result.x = v.z;
>+//     result.y = v.z;
>+//     return result;
>+// }
>+// short2 operator.xx(short4 v) {
>+//     short2 result;
>+//     result.x = v.x;
>+//     result.y = v.x;
>+//     return result;
>+// }
>+// short2 operator.xy(short4 v) {
>+//     short2 result;
>+//     result.x = v.x;
>+//     result.y = v.y;
>+//     return result;
>+// }
>+// short4 operator.xy=(short4 v, short2 c) {
>+//     short4 result = v;
>+//     result.x = c.x;
>+//     result.y = c.y;
>+//     return result;
>+// }
>+// short2 operator.xz(short4 v) {
>+//     short2 result;
>+//     result.x = v.x;
>+//     result.y = v.z;
>+//     return result;
>+// }
>+// short4 operator.xz=(short4 v, short2 c) {
>+//     short4 result = v;
>+//     result.x = c.x;
>+//     result.z = c.y;
>+//     return result;
>+// }
>+// short2 operator.xw(short4 v) {
>+//     short2 result;
>+//     result.x = v.x;
>+//     result.y = v.w;
>+//     return result;
>+// }
>+// short4 operator.xw=(short4 v, short2 c) {
>+//     short4 result = v;
>+//     result.x = c.x;
>+//     result.w = c.y;
>+//     return result;
>+// }
>+// short2 operator.yx(short4 v) {
>+//     short2 result;
>+//     result.x = v.y;
>+//     result.y = v.x;
>+//     return result;
>+// }
>+// short4 operator.yx=(short4 v, short2 c) {
>+//     short4 result = v;
>+//     result.y = c.x;
>+//     result.x = c.y;
>+//     return result;
>+// }
>+// short2 operator.yy(short4 v) {
>+//     short2 result;
>+//     result.x = v.y;
>+//     result.y = v.y;
>+//     return result;
>+// }
>+// short2 operator.yz(short4 v) {
>+//     short2 result;
>+//     result.x = v.y;
>+//     result.y = v.z;
>+//     return result;
>+// }
>+// short4 operator.yz=(short4 v, short2 c) {
>+//     short4 result = v;
>+//     result.y = c.x;
>+//     result.z = c.y;
>+//     return result;
>+// }
>+// short2 operator.yw(short4 v) {
>+//     short2 result;
>+//     result.x = v.y;
>+//     result.y = v.w;
>+//     return result;
>+// }
>+// short4 operator.yw=(short4 v, short2 c) {
>+//     short4 result = v;
>+//     result.y = c.x;
>+//     result.w = c.y;
>+//     return result;
>+// }
>+// short2 operator.zx(short4 v) {
>+//     short2 result;
>+//     result.x = v.z;
>+//     result.y = v.x;
>+//     return result;
>+// }
>+// short4 operator.zx=(short4 v, short2 c) {
>+//     short4 result = v;
>+//     result.z = c.x;
>+//     result.x = c.y;
>+//     return result;
>+// }
>+// short2 operator.zy(short4 v) {
>+//     short2 result;
>+//     result.x = v.z;
>+//     result.y = v.y;
>+//     return result;
>+// }
>+// short4 operator.zy=(short4 v, short2 c) {
>+//     short4 result = v;
>+//     result.z = c.x;
>+//     result.y = c.y;
>+//     return result;
>+// }
>+// short2 operator.zz(short4 v) {
>+//     short2 result;
>+//     result.x = v.z;
>+//     result.y = v.z;
>+//     return result;
>+// }
>+// short2 operator.zw(short4 v) {
>+//     short2 result;
>+//     result.x = v.z;
>+//     result.y = v.w;
>+//     return result;
>+// }
>+// short4 operator.zw=(short4 v, short2 c) {
>+//     short4 result = v;
>+//     result.z = c.x;
>+//     result.w = c.y;
>+//     return result;
>+// }
>+// short2 operator.wx(short4 v) {
>+//     short2 result;
>+//     result.x = v.w;
>+//     result.y = v.x;
>+//     return result;
>+// }
>+// short4 operator.wx=(short4 v, short2 c) {
>+//     short4 result = v;
>+//     result.w = c.x;
>+//     result.x = c.y;
>+//     return result;
>+// }
>+// short2 operator.wy(short4 v) {
>+//     short2 result;
>+//     result.x = v.w;
>+//     result.y = v.y;
>+//     return result;
>+// }
>+// short4 operator.wy=(short4 v, short2 c) {
>+//     short4 result = v;
>+//     result.w = c.x;
>+//     result.y = c.y;
>+//     return result;
>+// }
>+// short2 operator.wz(short4 v) {
>+//     short2 result;
>+//     result.x = v.w;
>+//     result.y = v.z;
>+//     return result;
>+// }
>+// short4 operator.wz=(short4 v, short2 c) {
>+//     short4 result = v;
>+//     result.w = c.x;
>+//     result.z = c.y;
>+//     return result;
>+// }
>+// short2 operator.ww(short4 v) {
>+//     short2 result;
>+//     result.x = v.w;
>+//     result.y = v.w;
>+//     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.xxy(short2 v) {
>+//     short3 result;
>+//     result.x = v.x;
>+//     result.y = v.x;
>+//     result.z = v.y;
>+//     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.xyy(short2 v) {
>+//     short3 result;
>+//     result.x = v.x;
>+//     result.y = v.y;
>+//     result.z = v.y;
>+//     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.yxy(short2 v) {
>+//     short3 result;
>+//     result.x = v.y;
>+//     result.y = v.x;
>+//     result.z = v.y;
>+//     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.yyy(short2 v) {
>+//     short3 result;
>+//     result.x = v.y;
>+//     result.y = v.y;
>+//     result.z = v.y;
>+//     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.xxy(short3 v) {
>+//     short3 result;
>+//     result.x = v.x;
>+//     result.y = v.x;
>+//     result.z = v.y;
>+//     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.xyx(short3 v) {
>+//     short3 result;
>+//     result.x = v.x;
>+//     result.y = v.y;
>+//     result.z = v.x;
>+//     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.xyz(short3 v) {
>+//     short3 result;
>+//     result.x = v.x;
>+//     result.y = v.y;
>+//     result.z = v.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;
>+// }
>+// short3 operator.xzx(short3 v) {
>+//     short3 result;
>+//     result.x = v.x;
>+//     result.y = v.z;
>+//     result.z = v.x;
>+//     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=(short3 v, short3 c) {
>+//     short3 result = v;
>+//     result.x = c.x;
>+//     result.z = c.y;
>+//     result.y = c.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.yxx(short3 v) {
>+//     short3 result;
>+//     result.x = v.y;
>+//     result.y = v.x;
>+//     result.z = v.x;
>+//     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.yxz(short3 v) {
>+//     short3 result;
>+//     result.x = v.y;
>+//     result.y = v.x;
>+//     result.z = v.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;
>+// }
>+// short3 operator.yyx(short3 v) {
>+//     short3 result;
>+//     result.x = v.y;
>+//     result.y = v.y;
>+//     result.z = v.x;
>+//     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.yyz(short3 v) {
>+//     short3 result;
>+//     result.x = v.y;
>+//     result.y = v.y;
>+//     result.z = v.z;
>+//     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=(short3 v, short3 c) {
>+//     short3 result = v;
>+//     result.y = c.x;
>+//     result.z = c.y;
>+//     result.x = c.z;
>+//     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.yzz(short3 v) {
>+//     short3 result;
>+//     result.x = v.y;
>+//     result.y = v.z;
>+//     result.z = v.z;
>+//     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.zxy(short3 v) {
>+//     short3 result;
>+//     result.x = v.z;
>+//     result.y = v.x;
>+//     result.z = v.y;
>+//     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;
>+// }
>+// short3 operator.zxz(short3 v) {
>+//     short3 result;
>+//     result.x = v.z;
>+//     result.y = v.x;
>+//     result.z = v.z;
>+//     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=(short3 v, short3 c) {
>+//     short3 result = v;
>+//     result.z = c.x;
>+//     result.y = c.y;
>+//     result.x = c.z;
>+//     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.zyz(short3 v) {
>+//     short3 result;
>+//     result.x = v.z;
>+//     result.y = v.y;
>+//     result.z = v.z;
>+//     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.zzy(short3 v) {
>+//     short3 result;
>+//     result.x = v.z;
>+//     result.y = v.z;
>+//     result.z = v.y;
>+//     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.xxx(short4 v) {
>+//     short3 result;
>+//     result.x = v.x;
>+//     result.y = v.x;
>+//     result.z = v.x;
>+//     return result;
>+// }
>+// short3 operator.xxy(short4 v) {
>+//     short3 result;
>+//     result.x = v.x;
>+//     result.y = v.x;
>+//     result.z = v.y;
>+//     return result;
>+// }
>+// short3 operator.xxz(short4 v) {
>+//     short3 result;
>+//     result.x = v.x;
>+//     result.y = v.x;
>+//     result.z = v.z;
>+//     return result;
>+// }
>+// short3 operator.xxw(short4 v) {
>+//     short3 result;
>+//     result.x = v.x;
>+//     result.y = v.x;
>+//     result.z = v.w;
>+//     return result;
>+// }
>+// short3 operator.xyx(short4 v) {
>+//     short3 result;
>+//     result.x = v.x;
>+//     result.y = v.y;
>+//     result.z = v.x;
>+//     return result;
>+// }
>+// short3 operator.xyy(short4 v) {
>+//     short3 result;
>+//     result.x = v.x;
>+//     result.y = v.y;
>+//     result.z = v.y;
>+//     return result;
>+// }
>+// short3 operator.xyz(short4 v) {
>+//     short3 result;
>+//     result.x = v.x;
>+//     result.y = v.y;
>+//     result.z = v.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;
>+// }
>+// short3 operator.xyw(short4 v) {
>+//     short3 result;
>+//     result.x = v.x;
>+//     result.y = v.y;
>+//     result.z = v.w;
>+//     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;
>+// }
>+// short3 operator.xzx(short4 v) {
>+//     short3 result;
>+//     result.x = v.x;
>+//     result.y = v.z;
>+//     result.z = v.x;
>+//     return result;
>+// }
>+// short3 operator.xzy(short4 v) {
>+//     short3 result;
>+//     result.x = v.x;
>+//     result.y = v.z;
>+//     result.z = v.y;
>+//     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;
>+// }
>+// short3 operator.xzz(short4 v) {
>+//     short3 result;
>+//     result.x = v.x;
>+//     result.y = v.z;
>+//     result.z = v.z;
>+//     return result;
>+// }
>+// short3 operator.xzw(short4 v) {
>+//     short3 result;
>+//     result.x = v.x;
>+//     result.y = v.z;
>+//     result.z = v.w;
>+//     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;
>+// }
>+// short3 operator.xwx(short4 v) {
>+//     short3 result;
>+//     result.x = v.x;
>+//     result.y = v.w;
>+//     result.z = v.x;
>+//     return result;
>+// }
>+// short3 operator.xwy(short4 v) {
>+//     short3 result;
>+//     result.x = v.x;
>+//     result.y = v.w;
>+//     result.z = v.y;
>+//     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;
>+// }
>+// short3 operator.xwz(short4 v) {
>+//     short3 result;
>+//     result.x = v.x;
>+//     result.y = v.w;
>+//     result.z = v.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;
>+// }
>+// short3 operator.xww(short4 v) {
>+//     short3 result;
>+//     result.x = v.x;
>+//     result.y = v.w;
>+//     result.z = v.w;
>+//     return result;
>+// }
>+// short3 operator.yxx(short4 v) {
>+//     short3 result;
>+//     result.x = v.y;
>+//     result.y = v.x;
>+//     result.z = v.x;
>+//     return result;
>+// }
>+// short3 operator.yxy(short4 v) {
>+//     short3 result;
>+//     result.x = v.y;
>+//     result.y = v.x;
>+//     result.z = v.y;
>+//     return result;
>+// }
>+// short3 operator.yxz(short4 v) {
>+//     short3 result;
>+//     result.x = v.y;
>+//     result.y = v.x;
>+//     result.z = v.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;
>+// }
>+// short3 operator.yxw(short4 v) {
>+//     short3 result;
>+//     result.x = v.y;
>+//     result.y = v.x;
>+//     result.z = v.w;
>+//     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;
>+// }
>+// short3 operator.yyx(short4 v) {
>+//     short3 result;
>+//     result.x = v.y;
>+//     result.y = v.y;
>+//     result.z = v.x;
>+//     return result;
>+// }
>+// short3 operator.yyy(short4 v) {
>+//     short3 result;
>+//     result.x = v.y;
>+//     result.y = v.y;
>+//     result.z = v.y;
>+//     return result;
>+// }
>+// short3 operator.yyz(short4 v) {
>+//     short3 result;
>+//     result.x = v.y;
>+//     result.y = v.y;
>+//     result.z = v.z;
>+//     return result;
>+// }
>+// short3 operator.yyw(short4 v) {
>+//     short3 result;
>+//     result.x = v.y;
>+//     result.y = v.y;
>+//     result.z = v.w;
>+//     return result;
>+// }
>+// short3 operator.yzx(short4 v) {
>+//     short3 result;
>+//     result.x = v.y;
>+//     result.y = v.z;
>+//     result.z = v.x;
>+//     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;
>+// }
>+// short3 operator.yzy(short4 v) {
>+//     short3 result;
>+//     result.x = v.y;
>+//     result.y = v.z;
>+//     result.z = v.y;
>+//     return result;
>+// }
>+// short3 operator.yzz(short4 v) {
>+//     short3 result;
>+//     result.x = v.y;
>+//     result.y = v.z;
>+//     result.z = v.z;
>+//     return result;
>+// }
>+// short3 operator.yzw(short4 v) {
>+//     short3 result;
>+//     result.x = v.y;
>+//     result.y = v.z;
>+//     result.z = v.w;
>+//     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;
>+// }
>+// short3 operator.ywx(short4 v) {
>+//     short3 result;
>+//     result.x = v.y;
>+//     result.y = v.w;
>+//     result.z = v.x;
>+//     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;
>+// }
>+// short3 operator.ywy(short4 v) {
>+//     short3 result;
>+//     result.x = v.y;
>+//     result.y = v.w;
>+//     result.z = v.y;
>+//     return result;
>+// }
>+// short3 operator.ywz(short4 v) {
>+//     short3 result;
>+//     result.x = v.y;
>+//     result.y = v.w;
>+//     result.z = v.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;
>+// }
>+// short3 operator.yww(short4 v) {
>+//     short3 result;
>+//     result.x = v.y;
>+//     result.y = v.w;
>+//     result.z = v.w;
>+//     return result;
>+// }
>+// short3 operator.zxx(short4 v) {
>+//     short3 result;
>+//     result.x = v.z;
>+//     result.y = v.x;
>+//     result.z = v.x;
>+//     return result;
>+// }
>+// short3 operator.zxy(short4 v) {
>+//     short3 result;
>+//     result.x = v.z;
>+//     result.y = v.x;
>+//     result.z = v.y;
>+//     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;
>+// }
>+// short3 operator.zxz(short4 v) {
>+//     short3 result;
>+//     result.x = v.z;
>+//     result.y = v.x;
>+//     result.z = v.z;
>+//     return result;
>+// }
>+// short3 operator.zxw(short4 v) {
>+//     short3 result;
>+//     result.x = v.z;
>+//     result.y = v.x;
>+//     result.z = v.w;
>+//     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;
>+// }
>+// short3 operator.zyx(short4 v) {
>+//     short3 result;
>+//     result.x = v.z;
>+//     result.y = v.y;
>+//     result.z = v.x;
>+//     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;
>+// }
>+// short3 operator.zyy(short4 v) {
>+//     short3 result;
>+//     result.x = v.z;
>+//     result.y = v.y;
>+//     result.z = v.y;
>+//     return result;
>+// }
>+// short3 operator.zyz(short4 v) {
>+//     short3 result;
>+//     result.x = v.z;
>+//     result.y = v.y;
>+//     result.z = v.z;
>+//     return result;
>+// }
>+// short3 operator.zyw(short4 v) {
>+//     short3 result;
>+//     result.x = v.z;
>+//     result.y = v.y;
>+//     result.z = v.w;
>+//     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;
>+// }
>+// short3 operator.zzx(short4 v) {
>+//     short3 result;
>+//     result.x = v.z;
>+//     result.y = v.z;
>+//     result.z = v.x;
>+//     return result;
>+// }
>+// short3 operator.zzy(short4 v) {
>+//     short3 result;
>+//     result.x = v.z;
>+//     result.y = v.z;
>+//     result.z = v.y;
>+//     return result;
>+// }
>+// short3 operator.zzz(short4 v) {
>+//     short3 result;
>+//     result.x = v.z;
>+//     result.y = v.z;
>+//     result.z = v.z;
>+//     return result;
>+// }
>+// short3 operator.zzw(short4 v) {
>+//     short3 result;
>+//     result.x = v.z;
>+//     result.y = v.z;
>+//     result.z = v.w;
>+//     return result;
>+// }
>+// short3 operator.zwx(short4 v) {
>+//     short3 result;
>+//     result.x = v.z;
>+//     result.y = v.w;
>+//     result.z = v.x;
>+//     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;
>+// }
>+// short3 operator.zwy(short4 v) {
>+//     short3 result;
>+//     result.x = v.z;
>+//     result.y = v.w;
>+//     result.z = v.y;
>+//     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;
>+// }
>+// short3 operator.zwz(short4 v) {
>+//     short3 result;
>+//     result.x = v.z;
>+//     result.y = v.w;
>+//     result.z = v.z;
>+//     return result;
>+// }
>+// short3 operator.zww(short4 v) {
>+//     short3 result;
>+//     result.x = v.z;
>+//     result.y = v.w;
>+//     result.z = v.w;
>+//     return result;
>+// }
>+// short3 operator.wxx(short4 v) {
>+//     short3 result;
>+//     result.x = v.w;
>+//     result.y = v.x;
>+//     result.z = v.x;
>+//     return result;
>+// }
>+// short3 operator.wxy(short4 v) {
>+//     short3 result;
>+//     result.x = v.w;
>+//     result.y = v.x;
>+//     result.z = v.y;
>+//     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;
>+// }
>+// short3 operator.wxz(short4 v) {
>+//     short3 result;
>+//     result.x = v.w;
>+//     result.y = v.x;
>+//     result.z = v.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;
>+// }
>+// short3 operator.wxw(short4 v) {
>+//     short3 result;
>+//     result.x = v.w;
>+//     result.y = v.x;
>+//     result.z = v.w;
>+//     return result;
>+// }
>+// short3 operator.wyx(short4 v) {
>+//     short3 result;
>+//     result.x = v.w;
>+//     result.y = v.y;
>+//     result.z = v.x;
>+//     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;
>+// }
>+// short3 operator.wyy(short4 v) {
>+//     short3 result;
>+//     result.x = v.w;
>+//     result.y = v.y;
>+//     result.z = v.y;
>+//     return result;
>+// }
>+// short3 operator.wyz(short4 v) {
>+//     short3 result;
>+//     result.x = v.w;
>+//     result.y = v.y;
>+//     result.z = v.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;
>+// }
>+// short3 operator.wyw(short4 v) {
>+//     short3 result;
>+//     result.x = v.w;
>+//     result.y = v.y;
>+//     result.z = v.w;
>+//     return result;
>+// }
>+// short3 operator.wzx(short4 v) {
>+//     short3 result;
>+//     result.x = v.w;
>+//     result.y = v.z;
>+//     result.z = v.x;
>+//     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;
>+// }
>+// short3 operator.wzy(short4 v) {
>+//     short3 result;
>+//     result.x = v.w;
>+//     result.y = v.z;
>+//     result.z = v.y;
>+//     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;
>+// }
>+// short3 operator.wzz(short4 v) {
>+//     short3 result;
>+//     result.x = v.w;
>+//     result.y = v.z;
>+//     result.z = v.z;
>+//     return result;
>+// }
>+// short3 operator.wzw(short4 v) {
>+//     short3 result;
>+//     result.x = v.w;
>+//     result.y = v.z;
>+//     result.z = v.w;
>+//     return result;
>+// }
>+// short3 operator.wwx(short4 v) {
>+//     short3 result;
>+//     result.x = v.w;
>+//     result.y = v.w;
>+//     result.z = v.x;
>+//     return result;
>+// }
>+// short3 operator.wwy(short4 v) {
>+//     short3 result;
>+//     result.x = v.w;
>+//     result.y = v.w;
>+//     result.z = v.y;
>+//     return result;
>+// }
>+// short3 operator.wwz(short4 v) {
>+//     short3 result;
>+//     result.x = v.w;
>+//     result.y = v.w;
>+//     result.z = v.z;
>+//     return result;
>+// }
>+// short3 operator.www(short4 v) {
>+//     short3 result;
>+//     result.x = v.w;
>+//     result.y = v.w;
>+//     result.z = v.w;
>+//     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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.xxxx(short4 v) {
>+//     short4 result;
>+//     result.x = v.x;
>+//     result.y = v.x;
>+//     result.z = v.x;
>+//     result.w = v.x;
>+//     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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// int2 operator.xx(int2 v) {
>+//     int2 result;
>+//     result.x = v.x;
>+//     result.y = v.x;
>+//     return result;
>+// }
>+// int2 operator.xy(int2 v) {
>+//     int2 result;
>+//     result.x = v.x;
>+//     result.y = v.y;
>+//     return result;
>+// }
>+// int2 operator.xy=(int2 v, int2 c) {
>+//     int2 result = v;
>+//     result.x = c.x;
>+//     result.y = c.y;
>+//     return result;
>+// }
>+// int2 operator.yx(int2 v) {
>+//     int2 result;
>+//     result.x = v.y;
>+//     result.y = v.x;
>+//     return result;
>+// }
>+// int2 operator.yx=(int2 v, int2 c) {
>+//     int2 result = v;
>+//     result.y = c.x;
>+//     result.x = c.y;
>+//     return result;
>+// }
>+// int2 operator.yy(int2 v) {
>+//     int2 result;
>+//     result.x = v.y;
>+//     result.y = v.y;
>+//     return result;
>+// }
>+// int2 operator.xx(int3 v) {
>+//     int2 result;
>+//     result.x = v.x;
>+//     result.y = v.x;
>+//     return result;
>+// }
>+// int2 operator.xy(int3 v) {
>+//     int2 result;
>+//     result.x = v.x;
>+//     result.y = v.y;
>+//     return result;
>+// }
>+// int3 operator.xy=(int3 v, int2 c) {
>+//     int3 result = v;
>+//     result.x = c.x;
>+//     result.y = c.y;
>+//     return result;
>+// }
>+// int2 operator.xz(int3 v) {
>+//     int2 result;
>+//     result.x = v.x;
>+//     result.y = v.z;
>+//     return result;
>+// }
>+// int3 operator.xz=(int3 v, int2 c) {
>+//     int3 result = v;
>+//     result.x = c.x;
>+//     result.z = c.y;
>+//     return result;
>+// }
>+// int2 operator.yx(int3 v) {
>+//     int2 result;
>+//     result.x = v.y;
>+//     result.y = v.x;
>+//     return result;
>+// }
>+// int3 operator.yx=(int3 v, int2 c) {
>+//     int3 result = v;
>+//     result.y = c.x;
>+//     result.x = c.y;
>+//     return result;
>+// }
>+// int2 operator.yy(int3 v) {
>+//     int2 result;
>+//     result.x = v.y;
>+//     result.y = v.y;
>+//     return result;
>+// }
>+// int2 operator.yz(int3 v) {
>+//     int2 result;
>+//     result.x = v.y;
>+//     result.y = v.z;
>+//     return result;
>+// }
>+// int3 operator.yz=(int3 v, int2 c) {
>+//     int3 result = v;
>+//     result.y = c.x;
>+//     result.z = c.y;
>+//     return result;
>+// }
>+// int2 operator.zx(int3 v) {
>+//     int2 result;
>+//     result.x = v.z;
>+//     result.y = v.x;
>+//     return result;
>+// }
>+// int3 operator.zx=(int3 v, int2 c) {
>+//     int3 result = v;
>+//     result.z = c.x;
>+//     result.x = c.y;
>+//     return result;
>+// }
>+// int2 operator.zy(int3 v) {
>+//     int2 result;
>+//     result.x = v.z;
>+//     result.y = v.y;
>+//     return result;
>+// }
>+// int3 operator.zy=(int3 v, int2 c) {
>+//     int3 result = v;
>+//     result.z = c.x;
>+//     result.y = c.y;
>+//     return result;
>+// }
>+// int2 operator.zz(int3 v) {
>+//     int2 result;
>+//     result.x = v.z;
>+//     result.y = v.z;
>+//     return result;
>+// }
>+// int2 operator.xx(int4 v) {
>+//     int2 result;
>+//     result.x = v.x;
>+//     result.y = v.x;
>+//     return result;
>+// }
>+// int2 operator.xy(int4 v) {
>+//     int2 result;
>+//     result.x = v.x;
>+//     result.y = v.y;
>+//     return result;
>+// }
>+// int4 operator.xy=(int4 v, int2 c) {
>+//     int4 result = v;
>+//     result.x = c.x;
>+//     result.y = c.y;
>+//     return result;
>+// }
>+// int2 operator.xz(int4 v) {
>+//     int2 result;
>+//     result.x = v.x;
>+//     result.y = v.z;
>+//     return result;
>+// }
>+// int4 operator.xz=(int4 v, int2 c) {
>+//     int4 result = v;
>+//     result.x = c.x;
>+//     result.z = c.y;
>+//     return result;
>+// }
>+// int2 operator.xw(int4 v) {
>+//     int2 result;
>+//     result.x = v.x;
>+//     result.y = v.w;
>+//     return result;
>+// }
>+// int4 operator.xw=(int4 v, int2 c) {
>+//     int4 result = v;
>+//     result.x = c.x;
>+//     result.w = c.y;
>+//     return result;
>+// }
>+// int2 operator.yx(int4 v) {
>+//     int2 result;
>+//     result.x = v.y;
>+//     result.y = v.x;
>+//     return result;
>+// }
>+// int4 operator.yx=(int4 v, int2 c) {
>+//     int4 result = v;
>+//     result.y = c.x;
>+//     result.x = c.y;
>+//     return result;
>+// }
>+// int2 operator.yy(int4 v) {
>+//     int2 result;
>+//     result.x = v.y;
>+//     result.y = v.y;
>+//     return result;
>+// }
>+// int2 operator.yz(int4 v) {
>+//     int2 result;
>+//     result.x = v.y;
>+//     result.y = v.z;
>+//     return result;
>+// }
>+// int4 operator.yz=(int4 v, int2 c) {
>+//     int4 result = v;
>+//     result.y = c.x;
>+//     result.z = c.y;
>+//     return result;
>+// }
>+// int2 operator.yw(int4 v) {
>+//     int2 result;
>+//     result.x = v.y;
>+//     result.y = v.w;
>+//     return result;
>+// }
>+// int4 operator.yw=(int4 v, int2 c) {
>+//     int4 result = v;
>+//     result.y = c.x;
>+//     result.w = c.y;
>+//     return result;
>+// }
>+// int2 operator.zx(int4 v) {
>+//     int2 result;
>+//     result.x = v.z;
>+//     result.y = v.x;
>+//     return result;
>+// }
>+// int4 operator.zx=(int4 v, int2 c) {
>+//     int4 result = v;
>+//     result.z = c.x;
>+//     result.x = c.y;
>+//     return result;
>+// }
>+// int2 operator.zy(int4 v) {
>+//     int2 result;
>+//     result.x = v.z;
>+//     result.y = v.y;
>+//     return result;
>+// }
>+// int4 operator.zy=(int4 v, int2 c) {
>+//     int4 result = v;
>+//     result.z = c.x;
>+//     result.y = c.y;
>+//     return result;
>+// }
>+// int2 operator.zz(int4 v) {
>+//     int2 result;
>+//     result.x = v.z;
>+//     result.y = v.z;
>+//     return result;
>+// }
>+// int2 operator.zw(int4 v) {
>+//     int2 result;
>+//     result.x = v.z;
>+//     result.y = v.w;
>+//     return result;
>+// }
>+// int4 operator.zw=(int4 v, int2 c) {
>+//     int4 result = v;
>+//     result.z = c.x;
>+//     result.w = c.y;
>+//     return result;
>+// }
>+// int2 operator.wx(int4 v) {
>+//     int2 result;
>+//     result.x = v.w;
>+//     result.y = v.x;
>+//     return result;
>+// }
>+// int4 operator.wx=(int4 v, int2 c) {
>+//     int4 result = v;
>+//     result.w = c.x;
>+//     result.x = c.y;
>+//     return result;
>+// }
>+// int2 operator.wy(int4 v) {
>+//     int2 result;
>+//     result.x = v.w;
>+//     result.y = v.y;
>+//     return result;
>+// }
>+// int4 operator.wy=(int4 v, int2 c) {
>+//     int4 result = v;
>+//     result.w = c.x;
>+//     result.y = c.y;
>+//     return result;
>+// }
>+// int2 operator.wz(int4 v) {
>+//     int2 result;
>+//     result.x = v.w;
>+//     result.y = v.z;
>+//     return result;
>+// }
>+// int4 operator.wz=(int4 v, int2 c) {
>+//     int4 result = v;
>+//     result.w = c.x;
>+//     result.z = c.y;
>+//     return result;
>+// }
>+// int2 operator.ww(int4 v) {
>+//     int2 result;
>+//     result.x = v.w;
>+//     result.y = v.w;
>+//     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.xxy(int2 v) {
>+//     int3 result;
>+//     result.x = v.x;
>+//     result.y = v.x;
>+//     result.z = v.y;
>+//     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.xyy(int2 v) {
>+//     int3 result;
>+//     result.x = v.x;
>+//     result.y = v.y;
>+//     result.z = v.y;
>+//     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.yxy(int2 v) {
>+//     int3 result;
>+//     result.x = v.y;
>+//     result.y = v.x;
>+//     result.z = v.y;
>+//     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.yyy(int2 v) {
>+//     int3 result;
>+//     result.x = v.y;
>+//     result.y = v.y;
>+//     result.z = v.y;
>+//     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.xxy(int3 v) {
>+//     int3 result;
>+//     result.x = v.x;
>+//     result.y = v.x;
>+//     result.z = v.y;
>+//     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.xyx(int3 v) {
>+//     int3 result;
>+//     result.x = v.x;
>+//     result.y = v.y;
>+//     result.z = v.x;
>+//     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.xyz(int3 v) {
>+//     int3 result;
>+//     result.x = v.x;
>+//     result.y = v.y;
>+//     result.z = v.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;
>+// }
>+// int3 operator.xzx(int3 v) {
>+//     int3 result;
>+//     result.x = v.x;
>+//     result.y = v.z;
>+//     result.z = v.x;
>+//     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=(int3 v, int3 c) {
>+//     int3 result = v;
>+//     result.x = c.x;
>+//     result.z = c.y;
>+//     result.y = c.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.yxx(int3 v) {
>+//     int3 result;
>+//     result.x = v.y;
>+//     result.y = v.x;
>+//     result.z = v.x;
>+//     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.yxz(int3 v) {
>+//     int3 result;
>+//     result.x = v.y;
>+//     result.y = v.x;
>+//     result.z = v.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;
>+// }
>+// int3 operator.yyx(int3 v) {
>+//     int3 result;
>+//     result.x = v.y;
>+//     result.y = v.y;
>+//     result.z = v.x;
>+//     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.yyz(int3 v) {
>+//     int3 result;
>+//     result.x = v.y;
>+//     result.y = v.y;
>+//     result.z = v.z;
>+//     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=(int3 v, int3 c) {
>+//     int3 result = v;
>+//     result.y = c.x;
>+//     result.z = c.y;
>+//     result.x = c.z;
>+//     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.yzz(int3 v) {
>+//     int3 result;
>+//     result.x = v.y;
>+//     result.y = v.z;
>+//     result.z = v.z;
>+//     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.zxy(int3 v) {
>+//     int3 result;
>+//     result.x = v.z;
>+//     result.y = v.x;
>+//     result.z = v.y;
>+//     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;
>+// }
>+// int3 operator.zxz(int3 v) {
>+//     int3 result;
>+//     result.x = v.z;
>+//     result.y = v.x;
>+//     result.z = v.z;
>+//     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=(int3 v, int3 c) {
>+//     int3 result = v;
>+//     result.z = c.x;
>+//     result.y = c.y;
>+//     result.x = c.z;
>+//     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.zyz(int3 v) {
>+//     int3 result;
>+//     result.x = v.z;
>+//     result.y = v.y;
>+//     result.z = v.z;
>+//     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.zzy(int3 v) {
>+//     int3 result;
>+//     result.x = v.z;
>+//     result.y = v.z;
>+//     result.z = v.y;
>+//     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.xxx(int4 v) {
>+//     int3 result;
>+//     result.x = v.x;
>+//     result.y = v.x;
>+//     result.z = v.x;
>+//     return result;
>+// }
>+// int3 operator.xxy(int4 v) {
>+//     int3 result;
>+//     result.x = v.x;
>+//     result.y = v.x;
>+//     result.z = v.y;
>+//     return result;
>+// }
>+// int3 operator.xxz(int4 v) {
>+//     int3 result;
>+//     result.x = v.x;
>+//     result.y = v.x;
>+//     result.z = v.z;
>+//     return result;
>+// }
>+// int3 operator.xxw(int4 v) {
>+//     int3 result;
>+//     result.x = v.x;
>+//     result.y = v.x;
>+//     result.z = v.w;
>+//     return result;
>+// }
>+// int3 operator.xyx(int4 v) {
>+//     int3 result;
>+//     result.x = v.x;
>+//     result.y = v.y;
>+//     result.z = v.x;
>+//     return result;
>+// }
>+// int3 operator.xyy(int4 v) {
>+//     int3 result;
>+//     result.x = v.x;
>+//     result.y = v.y;
>+//     result.z = v.y;
>+//     return result;
>+// }
>+// int3 operator.xyz(int4 v) {
>+//     int3 result;
>+//     result.x = v.x;
>+//     result.y = v.y;
>+//     result.z = v.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;
>+// }
>+// int3 operator.xyw(int4 v) {
>+//     int3 result;
>+//     result.x = v.x;
>+//     result.y = v.y;
>+//     result.z = v.w;
>+//     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;
>+// }
>+// int3 operator.xzx(int4 v) {
>+//     int3 result;
>+//     result.x = v.x;
>+//     result.y = v.z;
>+//     result.z = v.x;
>+//     return result;
>+// }
>+// int3 operator.xzy(int4 v) {
>+//     int3 result;
>+//     result.x = v.x;
>+//     result.y = v.z;
>+//     result.z = v.y;
>+//     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;
>+// }
>+// int3 operator.xzz(int4 v) {
>+//     int3 result;
>+//     result.x = v.x;
>+//     result.y = v.z;
>+//     result.z = v.z;
>+//     return result;
>+// }
>+// int3 operator.xzw(int4 v) {
>+//     int3 result;
>+//     result.x = v.x;
>+//     result.y = v.z;
>+//     result.z = v.w;
>+//     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;
>+// }
>+// int3 operator.xwx(int4 v) {
>+//     int3 result;
>+//     result.x = v.x;
>+//     result.y = v.w;
>+//     result.z = v.x;
>+//     return result;
>+// }
>+// int3 operator.xwy(int4 v) {
>+//     int3 result;
>+//     result.x = v.x;
>+//     result.y = v.w;
>+//     result.z = v.y;
>+//     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;
>+// }
>+// int3 operator.xwz(int4 v) {
>+//     int3 result;
>+//     result.x = v.x;
>+//     result.y = v.w;
>+//     result.z = v.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;
>+// }
>+// int3 operator.xww(int4 v) {
>+//     int3 result;
>+//     result.x = v.x;
>+//     result.y = v.w;
>+//     result.z = v.w;
>+//     return result;
>+// }
>+// int3 operator.yxx(int4 v) {
>+//     int3 result;
>+//     result.x = v.y;
>+//     result.y = v.x;
>+//     result.z = v.x;
>+//     return result;
>+// }
>+// int3 operator.yxy(int4 v) {
>+//     int3 result;
>+//     result.x = v.y;
>+//     result.y = v.x;
>+//     result.z = v.y;
>+//     return result;
>+// }
>+// int3 operator.yxz(int4 v) {
>+//     int3 result;
>+//     result.x = v.y;
>+//     result.y = v.x;
>+//     result.z = v.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;
>+// }
>+// int3 operator.yxw(int4 v) {
>+//     int3 result;
>+//     result.x = v.y;
>+//     result.y = v.x;
>+//     result.z = v.w;
>+//     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;
>+// }
>+// int3 operator.yyx(int4 v) {
>+//     int3 result;
>+//     result.x = v.y;
>+//     result.y = v.y;
>+//     result.z = v.x;
>+//     return result;
>+// }
>+// int3 operator.yyy(int4 v) {
>+//     int3 result;
>+//     result.x = v.y;
>+//     result.y = v.y;
>+//     result.z = v.y;
>+//     return result;
>+// }
>+// int3 operator.yyz(int4 v) {
>+//     int3 result;
>+//     result.x = v.y;
>+//     result.y = v.y;
>+//     result.z = v.z;
>+//     return result;
>+// }
>+// int3 operator.yyw(int4 v) {
>+//     int3 result;
>+//     result.x = v.y;
>+//     result.y = v.y;
>+//     result.z = v.w;
>+//     return result;
>+// }
>+// int3 operator.yzx(int4 v) {
>+//     int3 result;
>+//     result.x = v.y;
>+//     result.y = v.z;
>+//     result.z = v.x;
>+//     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;
>+// }
>+// int3 operator.yzy(int4 v) {
>+//     int3 result;
>+//     result.x = v.y;
>+//     result.y = v.z;
>+//     result.z = v.y;
>+//     return result;
>+// }
>+// int3 operator.yzz(int4 v) {
>+//     int3 result;
>+//     result.x = v.y;
>+//     result.y = v.z;
>+//     result.z = v.z;
>+//     return result;
>+// }
>+// int3 operator.yzw(int4 v) {
>+//     int3 result;
>+//     result.x = v.y;
>+//     result.y = v.z;
>+//     result.z = v.w;
>+//     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;
>+// }
>+// int3 operator.ywx(int4 v) {
>+//     int3 result;
>+//     result.x = v.y;
>+//     result.y = v.w;
>+//     result.z = v.x;
>+//     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;
>+// }
>+// int3 operator.ywy(int4 v) {
>+//     int3 result;
>+//     result.x = v.y;
>+//     result.y = v.w;
>+//     result.z = v.y;
>+//     return result;
>+// }
>+// int3 operator.ywz(int4 v) {
>+//     int3 result;
>+//     result.x = v.y;
>+//     result.y = v.w;
>+//     result.z = v.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;
>+// }
>+// int3 operator.yww(int4 v) {
>+//     int3 result;
>+//     result.x = v.y;
>+//     result.y = v.w;
>+//     result.z = v.w;
>+//     return result;
>+// }
>+// int3 operator.zxx(int4 v) {
>+//     int3 result;
>+//     result.x = v.z;
>+//     result.y = v.x;
>+//     result.z = v.x;
>+//     return result;
>+// }
>+// int3 operator.zxy(int4 v) {
>+//     int3 result;
>+//     result.x = v.z;
>+//     result.y = v.x;
>+//     result.z = v.y;
>+//     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;
>+// }
>+// int3 operator.zxz(int4 v) {
>+//     int3 result;
>+//     result.x = v.z;
>+//     result.y = v.x;
>+//     result.z = v.z;
>+//     return result;
>+// }
>+// int3 operator.zxw(int4 v) {
>+//     int3 result;
>+//     result.x = v.z;
>+//     result.y = v.x;
>+//     result.z = v.w;
>+//     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;
>+// }
>+// int3 operator.zyx(int4 v) {
>+//     int3 result;
>+//     result.x = v.z;
>+//     result.y = v.y;
>+//     result.z = v.x;
>+//     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;
>+// }
>+// int3 operator.zyy(int4 v) {
>+//     int3 result;
>+//     result.x = v.z;
>+//     result.y = v.y;
>+//     result.z = v.y;
>+//     return result;
>+// }
>+// int3 operator.zyz(int4 v) {
>+//     int3 result;
>+//     result.x = v.z;
>+//     result.y = v.y;
>+//     result.z = v.z;
>+//     return result;
>+// }
>+// int3 operator.zyw(int4 v) {
>+//     int3 result;
>+//     result.x = v.z;
>+//     result.y = v.y;
>+//     result.z = v.w;
>+//     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;
>+// }
>+// int3 operator.zzx(int4 v) {
>+//     int3 result;
>+//     result.x = v.z;
>+//     result.y = v.z;
>+//     result.z = v.x;
>+//     return result;
>+// }
>+// int3 operator.zzy(int4 v) {
>+//     int3 result;
>+//     result.x = v.z;
>+//     result.y = v.z;
>+//     result.z = v.y;
>+//     return result;
>+// }
>+// int3 operator.zzz(int4 v) {
>+//     int3 result;
>+//     result.x = v.z;
>+//     result.y = v.z;
>+//     result.z = v.z;
>+//     return result;
>+// }
>+// int3 operator.zzw(int4 v) {
>+//     int3 result;
>+//     result.x = v.z;
>+//     result.y = v.z;
>+//     result.z = v.w;
>+//     return result;
>+// }
>+// int3 operator.zwx(int4 v) {
>+//     int3 result;
>+//     result.x = v.z;
>+//     result.y = v.w;
>+//     result.z = v.x;
>+//     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;
>+// }
>+// int3 operator.zwy(int4 v) {
>+//     int3 result;
>+//     result.x = v.z;
>+//     result.y = v.w;
>+//     result.z = v.y;
>+//     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;
>+// }
>+// int3 operator.zwz(int4 v) {
>+//     int3 result;
>+//     result.x = v.z;
>+//     result.y = v.w;
>+//     result.z = v.z;
>+//     return result;
>+// }
>+// int3 operator.zww(int4 v) {
>+//     int3 result;
>+//     result.x = v.z;
>+//     result.y = v.w;
>+//     result.z = v.w;
>+//     return result;
>+// }
>+// int3 operator.wxx(int4 v) {
>+//     int3 result;
>+//     result.x = v.w;
>+//     result.y = v.x;
>+//     result.z = v.x;
>+//     return result;
>+// }
>+// int3 operator.wxy(int4 v) {
>+//     int3 result;
>+//     result.x = v.w;
>+//     result.y = v.x;
>+//     result.z = v.y;
>+//     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;
>+// }
>+// int3 operator.wxz(int4 v) {
>+//     int3 result;
>+//     result.x = v.w;
>+//     result.y = v.x;
>+//     result.z = v.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;
>+// }
>+// int3 operator.wxw(int4 v) {
>+//     int3 result;
>+//     result.x = v.w;
>+//     result.y = v.x;
>+//     result.z = v.w;
>+//     return result;
>+// }
>+// int3 operator.wyx(int4 v) {
>+//     int3 result;
>+//     result.x = v.w;
>+//     result.y = v.y;
>+//     result.z = v.x;
>+//     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;
>+// }
>+// int3 operator.wyy(int4 v) {
>+//     int3 result;
>+//     result.x = v.w;
>+//     result.y = v.y;
>+//     result.z = v.y;
>+//     return result;
>+// }
>+// int3 operator.wyz(int4 v) {
>+//     int3 result;
>+//     result.x = v.w;
>+//     result.y = v.y;
>+//     result.z = v.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;
>+// }
>+// int3 operator.wyw(int4 v) {
>+//     int3 result;
>+//     result.x = v.w;
>+//     result.y = v.y;
>+//     result.z = v.w;
>+//     return result;
>+// }
>+// int3 operator.wzx(int4 v) {
>+//     int3 result;
>+//     result.x = v.w;
>+//     result.y = v.z;
>+//     result.z = v.x;
>+//     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;
>+// }
>+// int3 operator.wzy(int4 v) {
>+//     int3 result;
>+//     result.x = v.w;
>+//     result.y = v.z;
>+//     result.z = v.y;
>+//     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;
>+// }
>+// int3 operator.wzz(int4 v) {
>+//     int3 result;
>+//     result.x = v.w;
>+//     result.y = v.z;
>+//     result.z = v.z;
>+//     return result;
>+// }
>+// int3 operator.wzw(int4 v) {
>+//     int3 result;
>+//     result.x = v.w;
>+//     result.y = v.z;
>+//     result.z = v.w;
>+//     return result;
>+// }
>+// int3 operator.wwx(int4 v) {
>+//     int3 result;
>+//     result.x = v.w;
>+//     result.y = v.w;
>+//     result.z = v.x;
>+//     return result;
>+// }
>+// int3 operator.wwy(int4 v) {
>+//     int3 result;
>+//     result.x = v.w;
>+//     result.y = v.w;
>+//     result.z = v.y;
>+//     return result;
>+// }
>+// int3 operator.wwz(int4 v) {
>+//     int3 result;
>+//     result.x = v.w;
>+//     result.y = v.w;
>+//     result.z = v.z;
>+//     return result;
>+// }
>+// int3 operator.www(int4 v) {
>+//     int3 result;
>+//     result.x = v.w;
>+//     result.y = v.w;
>+//     result.z = v.w;
>+//     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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.xxxx(int4 v) {
>+//     int4 result;
>+//     result.x = v.x;
>+//     result.y = v.x;
>+//     result.z = v.x;
>+//     result.w = v.x;
>+//     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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// half2 operator.xx(half2 v) {
>+//     half2 result;
>+//     result.x = v.x;
>+//     result.y = v.x;
>+//     return result;
>+// }
>+// half2 operator.xy(half2 v) {
>+//     half2 result;
>+//     result.x = v.x;
>+//     result.y = v.y;
>+//     return result;
>+// }
>+// half2 operator.xy=(half2 v, half2 c) {
>+//     half2 result = v;
>+//     result.x = c.x;
>+//     result.y = c.y;
>+//     return result;
>+// }
>+// half2 operator.yx(half2 v) {
>+//     half2 result;
>+//     result.x = v.y;
>+//     result.y = v.x;
>+//     return result;
>+// }
>+// half2 operator.yx=(half2 v, half2 c) {
>+//     half2 result = v;
>+//     result.y = c.x;
>+//     result.x = c.y;
>+//     return result;
>+// }
>+// half2 operator.yy(half2 v) {
>+//     half2 result;
>+//     result.x = v.y;
>+//     result.y = v.y;
>+//     return result;
>+// }
>+// half2 operator.xx(half3 v) {
>+//     half2 result;
>+//     result.x = v.x;
>+//     result.y = v.x;
>+//     return result;
>+// }
>+// half2 operator.xy(half3 v) {
>+//     half2 result;
>+//     result.x = v.x;
>+//     result.y = v.y;
>+//     return result;
>+// }
>+// half3 operator.xy=(half3 v, half2 c) {
>+//     half3 result = v;
>+//     result.x = c.x;
>+//     result.y = c.y;
>+//     return result;
>+// }
>+// half2 operator.xz(half3 v) {
>+//     half2 result;
>+//     result.x = v.x;
>+//     result.y = v.z;
>+//     return result;
>+// }
>+// half3 operator.xz=(half3 v, half2 c) {
>+//     half3 result = v;
>+//     result.x = c.x;
>+//     result.z = c.y;
>+//     return result;
>+// }
>+// half2 operator.yx(half3 v) {
>+//     half2 result;
>+//     result.x = v.y;
>+//     result.y = v.x;
>+//     return result;
>+// }
>+// half3 operator.yx=(half3 v, half2 c) {
>+//     half3 result = v;
>+//     result.y = c.x;
>+//     result.x = c.y;
>+//     return result;
>+// }
>+// half2 operator.yy(half3 v) {
>+//     half2 result;
>+//     result.x = v.y;
>+//     result.y = v.y;
>+//     return result;
>+// }
>+// half2 operator.yz(half3 v) {
>+//     half2 result;
>+//     result.x = v.y;
>+//     result.y = v.z;
>+//     return result;
>+// }
>+// half3 operator.yz=(half3 v, half2 c) {
>+//     half3 result = v;
>+//     result.y = c.x;
>+//     result.z = c.y;
>+//     return result;
>+// }
>+// half2 operator.zx(half3 v) {
>+//     half2 result;
>+//     result.x = v.z;
>+//     result.y = v.x;
>+//     return result;
>+// }
>+// half3 operator.zx=(half3 v, half2 c) {
>+//     half3 result = v;
>+//     result.z = c.x;
>+//     result.x = c.y;
>+//     return result;
>+// }
>+// half2 operator.zy(half3 v) {
>+//     half2 result;
>+//     result.x = v.z;
>+//     result.y = v.y;
>+//     return result;
>+// }
>+// half3 operator.zy=(half3 v, half2 c) {
>+//     half3 result = v;
>+//     result.z = c.x;
>+//     result.y = c.y;
>+//     return result;
>+// }
>+// half2 operator.zz(half3 v) {
>+//     half2 result;
>+//     result.x = v.z;
>+//     result.y = v.z;
>+//     return result;
>+// }
>+// half2 operator.xx(half4 v) {
>+//     half2 result;
>+//     result.x = v.x;
>+//     result.y = v.x;
>+//     return result;
>+// }
>+// half2 operator.xy(half4 v) {
>+//     half2 result;
>+//     result.x = v.x;
>+//     result.y = v.y;
>+//     return result;
>+// }
>+// half4 operator.xy=(half4 v, half2 c) {
>+//     half4 result = v;
>+//     result.x = c.x;
>+//     result.y = c.y;
>+//     return result;
>+// }
>+// half2 operator.xz(half4 v) {
>+//     half2 result;
>+//     result.x = v.x;
>+//     result.y = v.z;
>+//     return result;
>+// }
>+// half4 operator.xz=(half4 v, half2 c) {
>+//     half4 result = v;
>+//     result.x = c.x;
>+//     result.z = c.y;
>+//     return result;
>+// }
>+// half2 operator.xw(half4 v) {
>+//     half2 result;
>+//     result.x = v.x;
>+//     result.y = v.w;
>+//     return result;
>+// }
>+// half4 operator.xw=(half4 v, half2 c) {
>+//     half4 result = v;
>+//     result.x = c.x;
>+//     result.w = c.y;
>+//     return result;
>+// }
>+// half2 operator.yx(half4 v) {
>+//     half2 result;
>+//     result.x = v.y;
>+//     result.y = v.x;
>+//     return result;
>+// }
>+// half4 operator.yx=(half4 v, half2 c) {
>+//     half4 result = v;
>+//     result.y = c.x;
>+//     result.x = c.y;
>+//     return result;
>+// }
>+// half2 operator.yy(half4 v) {
>+//     half2 result;
>+//     result.x = v.y;
>+//     result.y = v.y;
>+//     return result;
>+// }
>+// half2 operator.yz(half4 v) {
>+//     half2 result;
>+//     result.x = v.y;
>+//     result.y = v.z;
>+//     return result;
>+// }
>+// half4 operator.yz=(half4 v, half2 c) {
>+//     half4 result = v;
>+//     result.y = c.x;
>+//     result.z = c.y;
>+//     return result;
>+// }
>+// half2 operator.yw(half4 v) {
>+//     half2 result;
>+//     result.x = v.y;
>+//     result.y = v.w;
>+//     return result;
>+// }
>+// half4 operator.yw=(half4 v, half2 c) {
>+//     half4 result = v;
>+//     result.y = c.x;
>+//     result.w = c.y;
>+//     return result;
>+// }
>+// half2 operator.zx(half4 v) {
>+//     half2 result;
>+//     result.x = v.z;
>+//     result.y = v.x;
>+//     return result;
>+// }
>+// half4 operator.zx=(half4 v, half2 c) {
>+//     half4 result = v;
>+//     result.z = c.x;
>+//     result.x = c.y;
>+//     return result;
>+// }
>+// half2 operator.zy(half4 v) {
>+//     half2 result;
>+//     result.x = v.z;
>+//     result.y = v.y;
>+//     return result;
>+// }
>+// half4 operator.zy=(half4 v, half2 c) {
>+//     half4 result = v;
>+//     result.z = c.x;
>+//     result.y = c.y;
>+//     return result;
>+// }
>+// half2 operator.zz(half4 v) {
>+//     half2 result;
>+//     result.x = v.z;
>+//     result.y = v.z;
>+//     return result;
>+// }
>+// half2 operator.zw(half4 v) {
>+//     half2 result;
>+//     result.x = v.z;
>+//     result.y = v.w;
>+//     return result;
>+// }
>+// half4 operator.zw=(half4 v, half2 c) {
>+//     half4 result = v;
>+//     result.z = c.x;
>+//     result.w = c.y;
>+//     return result;
>+// }
>+// half2 operator.wx(half4 v) {
>+//     half2 result;
>+//     result.x = v.w;
>+//     result.y = v.x;
>+//     return result;
>+// }
>+// half4 operator.wx=(half4 v, half2 c) {
>+//     half4 result = v;
>+//     result.w = c.x;
>+//     result.x = c.y;
>+//     return result;
>+// }
>+// half2 operator.wy(half4 v) {
>+//     half2 result;
>+//     result.x = v.w;
>+//     result.y = v.y;
>+//     return result;
>+// }
>+// half4 operator.wy=(half4 v, half2 c) {
>+//     half4 result = v;
>+//     result.w = c.x;
>+//     result.y = c.y;
>+//     return result;
>+// }
>+// half2 operator.wz(half4 v) {
>+//     half2 result;
>+//     result.x = v.w;
>+//     result.y = v.z;
>+//     return result;
>+// }
>+// half4 operator.wz=(half4 v, half2 c) {
>+//     half4 result = v;
>+//     result.w = c.x;
>+//     result.z = c.y;
>+//     return result;
>+// }
>+// half2 operator.ww(half4 v) {
>+//     half2 result;
>+//     result.x = v.w;
>+//     result.y = v.w;
>+//     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.xxy(half2 v) {
>+//     half3 result;
>+//     result.x = v.x;
>+//     result.y = v.x;
>+//     result.z = v.y;
>+//     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.xyy(half2 v) {
>+//     half3 result;
>+//     result.x = v.x;
>+//     result.y = v.y;
>+//     result.z = v.y;
>+//     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.yxy(half2 v) {
>+//     half3 result;
>+//     result.x = v.y;
>+//     result.y = v.x;
>+//     result.z = v.y;
>+//     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.yyy(half2 v) {
>+//     half3 result;
>+//     result.x = v.y;
>+//     result.y = v.y;
>+//     result.z = v.y;
>+//     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.xxy(half3 v) {
>+//     half3 result;
>+//     result.x = v.x;
>+//     result.y = v.x;
>+//     result.z = v.y;
>+//     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.xyx(half3 v) {
>+//     half3 result;
>+//     result.x = v.x;
>+//     result.y = v.y;
>+//     result.z = v.x;
>+//     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.xyz(half3 v) {
>+//     half3 result;
>+//     result.x = v.x;
>+//     result.y = v.y;
>+//     result.z = v.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;
>+// }
>+// half3 operator.xzx(half3 v) {
>+//     half3 result;
>+//     result.x = v.x;
>+//     result.y = v.z;
>+//     result.z = v.x;
>+//     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=(half3 v, half3 c) {
>+//     half3 result = v;
>+//     result.x = c.x;
>+//     result.z = c.y;
>+//     result.y = c.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.yxx(half3 v) {
>+//     half3 result;
>+//     result.x = v.y;
>+//     result.y = v.x;
>+//     result.z = v.x;
>+//     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.yxz(half3 v) {
>+//     half3 result;
>+//     result.x = v.y;
>+//     result.y = v.x;
>+//     result.z = v.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;
>+// }
>+// half3 operator.yyx(half3 v) {
>+//     half3 result;
>+//     result.x = v.y;
>+//     result.y = v.y;
>+//     result.z = v.x;
>+//     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.yyz(half3 v) {
>+//     half3 result;
>+//     result.x = v.y;
>+//     result.y = v.y;
>+//     result.z = v.z;
>+//     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=(half3 v, half3 c) {
>+//     half3 result = v;
>+//     result.y = c.x;
>+//     result.z = c.y;
>+//     result.x = c.z;
>+//     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.yzz(half3 v) {
>+//     half3 result;
>+//     result.x = v.y;
>+//     result.y = v.z;
>+//     result.z = v.z;
>+//     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.zxy(half3 v) {
>+//     half3 result;
>+//     result.x = v.z;
>+//     result.y = v.x;
>+//     result.z = v.y;
>+//     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;
>+// }
>+// half3 operator.zxz(half3 v) {
>+//     half3 result;
>+//     result.x = v.z;
>+//     result.y = v.x;
>+//     result.z = v.z;
>+//     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=(half3 v, half3 c) {
>+//     half3 result = v;
>+//     result.z = c.x;
>+//     result.y = c.y;
>+//     result.x = c.z;
>+//     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.zyz(half3 v) {
>+//     half3 result;
>+//     result.x = v.z;
>+//     result.y = v.y;
>+//     result.z = v.z;
>+//     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.zzy(half3 v) {
>+//     half3 result;
>+//     result.x = v.z;
>+//     result.y = v.z;
>+//     result.z = v.y;
>+//     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.xxx(half4 v) {
>+//     half3 result;
>+//     result.x = v.x;
>+//     result.y = v.x;
>+//     result.z = v.x;
>+//     return result;
>+// }
>+// half3 operator.xxy(half4 v) {
>+//     half3 result;
>+//     result.x = v.x;
>+//     result.y = v.x;
>+//     result.z = v.y;
>+//     return result;
>+// }
>+// half3 operator.xxz(half4 v) {
>+//     half3 result;
>+//     result.x = v.x;
>+//     result.y = v.x;
>+//     result.z = v.z;
>+//     return result;
>+// }
>+// half3 operator.xxw(half4 v) {
>+//     half3 result;
>+//     result.x = v.x;
>+//     result.y = v.x;
>+//     result.z = v.w;
>+//     return result;
>+// }
>+// half3 operator.xyx(half4 v) {
>+//     half3 result;
>+//     result.x = v.x;
>+//     result.y = v.y;
>+//     result.z = v.x;
>+//     return result;
>+// }
>+// half3 operator.xyy(half4 v) {
>+//     half3 result;
>+//     result.x = v.x;
>+//     result.y = v.y;
>+//     result.z = v.y;
>+//     return result;
>+// }
>+// half3 operator.xyz(half4 v) {
>+//     half3 result;
>+//     result.x = v.x;
>+//     result.y = v.y;
>+//     result.z = v.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;
>+// }
>+// half3 operator.xyw(half4 v) {
>+//     half3 result;
>+//     result.x = v.x;
>+//     result.y = v.y;
>+//     result.z = v.w;
>+//     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;
>+// }
>+// half3 operator.xzx(half4 v) {
>+//     half3 result;
>+//     result.x = v.x;
>+//     result.y = v.z;
>+//     result.z = v.x;
>+//     return result;
>+// }
>+// half3 operator.xzy(half4 v) {
>+//     half3 result;
>+//     result.x = v.x;
>+//     result.y = v.z;
>+//     result.z = v.y;
>+//     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;
>+// }
>+// half3 operator.xzz(half4 v) {
>+//     half3 result;
>+//     result.x = v.x;
>+//     result.y = v.z;
>+//     result.z = v.z;
>+//     return result;
>+// }
>+// half3 operator.xzw(half4 v) {
>+//     half3 result;
>+//     result.x = v.x;
>+//     result.y = v.z;
>+//     result.z = v.w;
>+//     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;
>+// }
>+// half3 operator.xwx(half4 v) {
>+//     half3 result;
>+//     result.x = v.x;
>+//     result.y = v.w;
>+//     result.z = v.x;
>+//     return result;
>+// }
>+// half3 operator.xwy(half4 v) {
>+//     half3 result;
>+//     result.x = v.x;
>+//     result.y = v.w;
>+//     result.z = v.y;
>+//     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;
>+// }
>+// half3 operator.xwz(half4 v) {
>+//     half3 result;
>+//     result.x = v.x;
>+//     result.y = v.w;
>+//     result.z = v.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;
>+// }
>+// half3 operator.xww(half4 v) {
>+//     half3 result;
>+//     result.x = v.x;
>+//     result.y = v.w;
>+//     result.z = v.w;
>+//     return result;
>+// }
>+// half3 operator.yxx(half4 v) {
>+//     half3 result;
>+//     result.x = v.y;
>+//     result.y = v.x;
>+//     result.z = v.x;
>+//     return result;
>+// }
>+// half3 operator.yxy(half4 v) {
>+//     half3 result;
>+//     result.x = v.y;
>+//     result.y = v.x;
>+//     result.z = v.y;
>+//     return result;
>+// }
>+// half3 operator.yxz(half4 v) {
>+//     half3 result;
>+//     result.x = v.y;
>+//     result.y = v.x;
>+//     result.z = v.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;
>+// }
>+// half3 operator.yxw(half4 v) {
>+//     half3 result;
>+//     result.x = v.y;
>+//     result.y = v.x;
>+//     result.z = v.w;
>+//     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;
>+// }
>+// half3 operator.yyx(half4 v) {
>+//     half3 result;
>+//     result.x = v.y;
>+//     result.y = v.y;
>+//     result.z = v.x;
>+//     return result;
>+// }
>+// half3 operator.yyy(half4 v) {
>+//     half3 result;
>+//     result.x = v.y;
>+//     result.y = v.y;
>+//     result.z = v.y;
>+//     return result;
>+// }
>+// half3 operator.yyz(half4 v) {
>+//     half3 result;
>+//     result.x = v.y;
>+//     result.y = v.y;
>+//     result.z = v.z;
>+//     return result;
>+// }
>+// half3 operator.yyw(half4 v) {
>+//     half3 result;
>+//     result.x = v.y;
>+//     result.y = v.y;
>+//     result.z = v.w;
>+//     return result;
>+// }
>+// half3 operator.yzx(half4 v) {
>+//     half3 result;
>+//     result.x = v.y;
>+//     result.y = v.z;
>+//     result.z = v.x;
>+//     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;
>+// }
>+// half3 operator.yzy(half4 v) {
>+//     half3 result;
>+//     result.x = v.y;
>+//     result.y = v.z;
>+//     result.z = v.y;
>+//     return result;
>+// }
>+// half3 operator.yzz(half4 v) {
>+//     half3 result;
>+//     result.x = v.y;
>+//     result.y = v.z;
>+//     result.z = v.z;
>+//     return result;
>+// }
>+// half3 operator.yzw(half4 v) {
>+//     half3 result;
>+//     result.x = v.y;
>+//     result.y = v.z;
>+//     result.z = v.w;
>+//     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;
>+// }
>+// half3 operator.ywx(half4 v) {
>+//     half3 result;
>+//     result.x = v.y;
>+//     result.y = v.w;
>+//     result.z = v.x;
>+//     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;
>+// }
>+// half3 operator.ywy(half4 v) {
>+//     half3 result;
>+//     result.x = v.y;
>+//     result.y = v.w;
>+//     result.z = v.y;
>+//     return result;
>+// }
>+// half3 operator.ywz(half4 v) {
>+//     half3 result;
>+//     result.x = v.y;
>+//     result.y = v.w;
>+//     result.z = v.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;
>+// }
>+// half3 operator.yww(half4 v) {
>+//     half3 result;
>+//     result.x = v.y;
>+//     result.y = v.w;
>+//     result.z = v.w;
>+//     return result;
>+// }
>+// half3 operator.zxx(half4 v) {
>+//     half3 result;
>+//     result.x = v.z;
>+//     result.y = v.x;
>+//     result.z = v.x;
>+//     return result;
>+// }
>+// half3 operator.zxy(half4 v) {
>+//     half3 result;
>+//     result.x = v.z;
>+//     result.y = v.x;
>+//     result.z = v.y;
>+//     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;
>+// }
>+// half3 operator.zxz(half4 v) {
>+//     half3 result;
>+//     result.x = v.z;
>+//     result.y = v.x;
>+//     result.z = v.z;
>+//     return result;
>+// }
>+// half3 operator.zxw(half4 v) {
>+//     half3 result;
>+//     result.x = v.z;
>+//     result.y = v.x;
>+//     result.z = v.w;
>+//     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;
>+// }
>+// half3 operator.zyx(half4 v) {
>+//     half3 result;
>+//     result.x = v.z;
>+//     result.y = v.y;
>+//     result.z = v.x;
>+//     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;
>+// }
>+// half3 operator.zyy(half4 v) {
>+//     half3 result;
>+//     result.x = v.z;
>+//     result.y = v.y;
>+//     result.z = v.y;
>+//     return result;
>+// }
>+// half3 operator.zyz(half4 v) {
>+//     half3 result;
>+//     result.x = v.z;
>+//     result.y = v.y;
>+//     result.z = v.z;
>+//     return result;
>+// }
>+// half3 operator.zyw(half4 v) {
>+//     half3 result;
>+//     result.x = v.z;
>+//     result.y = v.y;
>+//     result.z = v.w;
>+//     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;
>+// }
>+// half3 operator.zzx(half4 v) {
>+//     half3 result;
>+//     result.x = v.z;
>+//     result.y = v.z;
>+//     result.z = v.x;
>+//     return result;
>+// }
>+// half3 operator.zzy(half4 v) {
>+//     half3 result;
>+//     result.x = v.z;
>+//     result.y = v.z;
>+//     result.z = v.y;
>+//     return result;
>+// }
>+// half3 operator.zzz(half4 v) {
>+//     half3 result;
>+//     result.x = v.z;
>+//     result.y = v.z;
>+//     result.z = v.z;
>+//     return result;
>+// }
>+// half3 operator.zzw(half4 v) {
>+//     half3 result;
>+//     result.x = v.z;
>+//     result.y = v.z;
>+//     result.z = v.w;
>+//     return result;
>+// }
>+// half3 operator.zwx(half4 v) {
>+//     half3 result;
>+//     result.x = v.z;
>+//     result.y = v.w;
>+//     result.z = v.x;
>+//     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;
>+// }
>+// half3 operator.zwy(half4 v) {
>+//     half3 result;
>+//     result.x = v.z;
>+//     result.y = v.w;
>+//     result.z = v.y;
>+//     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;
>+// }
>+// half3 operator.zwz(half4 v) {
>+//     half3 result;
>+//     result.x = v.z;
>+//     result.y = v.w;
>+//     result.z = v.z;
>+//     return result;
>+// }
>+// half3 operator.zww(half4 v) {
>+//     half3 result;
>+//     result.x = v.z;
>+//     result.y = v.w;
>+//     result.z = v.w;
>+//     return result;
>+// }
>+// half3 operator.wxx(half4 v) {
>+//     half3 result;
>+//     result.x = v.w;
>+//     result.y = v.x;
>+//     result.z = v.x;
>+//     return result;
>+// }
>+// half3 operator.wxy(half4 v) {
>+//     half3 result;
>+//     result.x = v.w;
>+//     result.y = v.x;
>+//     result.z = v.y;
>+//     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;
>+// }
>+// half3 operator.wxz(half4 v) {
>+//     half3 result;
>+//     result.x = v.w;
>+//     result.y = v.x;
>+//     result.z = v.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;
>+// }
>+// half3 operator.wxw(half4 v) {
>+//     half3 result;
>+//     result.x = v.w;
>+//     result.y = v.x;
>+//     result.z = v.w;
>+//     return result;
>+// }
>+// half3 operator.wyx(half4 v) {
>+//     half3 result;
>+//     result.x = v.w;
>+//     result.y = v.y;
>+//     result.z = v.x;
>+//     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;
>+// }
>+// half3 operator.wyy(half4 v) {
>+//     half3 result;
>+//     result.x = v.w;
>+//     result.y = v.y;
>+//     result.z = v.y;
>+//     return result;
>+// }
>+// half3 operator.wyz(half4 v) {
>+//     half3 result;
>+//     result.x = v.w;
>+//     result.y = v.y;
>+//     result.z = v.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;
>+// }
>+// half3 operator.wyw(half4 v) {
>+//     half3 result;
>+//     result.x = v.w;
>+//     result.y = v.y;
>+//     result.z = v.w;
>+//     return result;
>+// }
>+// half3 operator.wzx(half4 v) {
>+//     half3 result;
>+//     result.x = v.w;
>+//     result.y = v.z;
>+//     result.z = v.x;
>+//     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;
>+// }
>+// half3 operator.wzy(half4 v) {
>+//     half3 result;
>+//     result.x = v.w;
>+//     result.y = v.z;
>+//     result.z = v.y;
>+//     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;
>+// }
>+// half3 operator.wzz(half4 v) {
>+//     half3 result;
>+//     result.x = v.w;
>+//     result.y = v.z;
>+//     result.z = v.z;
>+//     return result;
>+// }
>+// half3 operator.wzw(half4 v) {
>+//     half3 result;
>+//     result.x = v.w;
>+//     result.y = v.z;
>+//     result.z = v.w;
>+//     return result;
>+// }
>+// half3 operator.wwx(half4 v) {
>+//     half3 result;
>+//     result.x = v.w;
>+//     result.y = v.w;
>+//     result.z = v.x;
>+//     return result;
>+// }
>+// half3 operator.wwy(half4 v) {
>+//     half3 result;
>+//     result.x = v.w;
>+//     result.y = v.w;
>+//     result.z = v.y;
>+//     return result;
>+// }
>+// half3 operator.wwz(half4 v) {
>+//     half3 result;
>+//     result.x = v.w;
>+//     result.y = v.w;
>+//     result.z = v.z;
>+//     return result;
>+// }
>+// half3 operator.www(half4 v) {
>+//     half3 result;
>+//     result.x = v.w;
>+//     result.y = v.w;
>+//     result.z = v.w;
>+//     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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.xxxx(half4 v) {
>+//     half4 result;
>+//     result.x = v.x;
>+//     result.y = v.x;
>+//     result.z = v.x;
>+//     result.w = v.x;
>+//     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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// float2 operator.xx(float2 v) {
>+//     float2 result;
>+//     result.x = v.x;
>+//     result.y = v.x;
>+//     return result;
>+// }
>+// float2 operator.xy(float2 v) {
>+//     float2 result;
>+//     result.x = v.x;
>+//     result.y = v.y;
>+//     return result;
>+// }
>+// float2 operator.xy=(float2 v, float2 c) {
>+//     float2 result = v;
>+//     result.x = c.x;
>+//     result.y = c.y;
>+//     return result;
>+// }
>+// float2 operator.yx(float2 v) {
>+//     float2 result;
>+//     result.x = v.y;
>+//     result.y = v.x;
>+//     return result;
>+// }
>+// float2 operator.yx=(float2 v, float2 c) {
>+//     float2 result = v;
>+//     result.y = c.x;
>+//     result.x = c.y;
>+//     return result;
>+// }
>+// float2 operator.yy(float2 v) {
>+//     float2 result;
>+//     result.x = v.y;
>+//     result.y = v.y;
>+//     return result;
>+// }
>+// float2 operator.xx(float3 v) {
>+//     float2 result;
>+//     result.x = v.x;
>+//     result.y = v.x;
>+//     return result;
>+// }
>+// float2 operator.xy(float3 v) {
>+//     float2 result;
>+//     result.x = v.x;
>+//     result.y = v.y;
>+//     return result;
>+// }
>+// float3 operator.xy=(float3 v, float2 c) {
>+//     float3 result = v;
>+//     result.x = c.x;
>+//     result.y = c.y;
>+//     return result;
>+// }
>+// float2 operator.xz(float3 v) {
>+//     float2 result;
>+//     result.x = v.x;
>+//     result.y = v.z;
>+//     return result;
>+// }
>+// float3 operator.xz=(float3 v, float2 c) {
>+//     float3 result = v;
>+//     result.x = c.x;
>+//     result.z = c.y;
>+//     return result;
>+// }
>+// float2 operator.yx(float3 v) {
>+//     float2 result;
>+//     result.x = v.y;
>+//     result.y = v.x;
>+//     return result;
>+// }
>+// float3 operator.yx=(float3 v, float2 c) {
>+//     float3 result = v;
>+//     result.y = c.x;
>+//     result.x = c.y;
>+//     return result;
>+// }
>+// float2 operator.yy(float3 v) {
>+//     float2 result;
>+//     result.x = v.y;
>+//     result.y = v.y;
>+//     return result;
>+// }
>+// float2 operator.yz(float3 v) {
>+//     float2 result;
>+//     result.x = v.y;
>+//     result.y = v.z;
>+//     return result;
>+// }
>+// float3 operator.yz=(float3 v, float2 c) {
>+//     float3 result = v;
>+//     result.y = c.x;
>+//     result.z = c.y;
>+//     return result;
>+// }
>+// float2 operator.zx(float3 v) {
>+//     float2 result;
>+//     result.x = v.z;
>+//     result.y = v.x;
>+//     return result;
>+// }
>+// float3 operator.zx=(float3 v, float2 c) {
>+//     float3 result = v;
>+//     result.z = c.x;
>+//     result.x = c.y;
>+//     return result;
>+// }
>+// float2 operator.zy(float3 v) {
>+//     float2 result;
>+//     result.x = v.z;
>+//     result.y = v.y;
>+//     return result;
>+// }
>+// float3 operator.zy=(float3 v, float2 c) {
>+//     float3 result = v;
>+//     result.z = c.x;
>+//     result.y = c.y;
>+//     return result;
>+// }
>+// float2 operator.zz(float3 v) {
>+//     float2 result;
>+//     result.x = v.z;
>+//     result.y = v.z;
>+//     return result;
>+// }
>+// float2 operator.xx(float4 v) {
>+//     float2 result;
>+//     result.x = v.x;
>+//     result.y = v.x;
>+//     return result;
>+// }
>+// float2 operator.xy(float4 v) {
>+//     float2 result;
>+//     result.x = v.x;
>+//     result.y = v.y;
>+//     return result;
>+// }
>+// float4 operator.xy=(float4 v, float2 c) {
>+//     float4 result = v;
>+//     result.x = c.x;
>+//     result.y = c.y;
>+//     return result;
>+// }
>+// float2 operator.xz(float4 v) {
>+//     float2 result;
>+//     result.x = v.x;
>+//     result.y = v.z;
>+//     return result;
>+// }
>+// float4 operator.xz=(float4 v, float2 c) {
>+//     float4 result = v;
>+//     result.x = c.x;
>+//     result.z = c.y;
>+//     return result;
>+// }
>+// float2 operator.xw(float4 v) {
>+//     float2 result;
>+//     result.x = v.x;
>+//     result.y = v.w;
>+//     return result;
>+// }
>+// float4 operator.xw=(float4 v, float2 c) {
>+//     float4 result = v;
>+//     result.x = c.x;
>+//     result.w = c.y;
>+//     return result;
>+// }
>+// float2 operator.yx(float4 v) {
>+//     float2 result;
>+//     result.x = v.y;
>+//     result.y = v.x;
>+//     return result;
>+// }
>+// float4 operator.yx=(float4 v, float2 c) {
>+//     float4 result = v;
>+//     result.y = c.x;
>+//     result.x = c.y;
>+//     return result;
>+// }
>+// float2 operator.yy(float4 v) {
>+//     float2 result;
>+//     result.x = v.y;
>+//     result.y = v.y;
>+//     return result;
>+// }
>+// float2 operator.yz(float4 v) {
>+//     float2 result;
>+//     result.x = v.y;
>+//     result.y = v.z;
>+//     return result;
>+// }
>+// float4 operator.yz=(float4 v, float2 c) {
>+//     float4 result = v;
>+//     result.y = c.x;
>+//     result.z = c.y;
>+//     return result;
>+// }
>+// float2 operator.yw(float4 v) {
>+//     float2 result;
>+//     result.x = v.y;
>+//     result.y = v.w;
>+//     return result;
>+// }
>+// float4 operator.yw=(float4 v, float2 c) {
>+//     float4 result = v;
>+//     result.y = c.x;
>+//     result.w = c.y;
>+//     return result;
>+// }
>+// float2 operator.zx(float4 v) {
>+//     float2 result;
>+//     result.x = v.z;
>+//     result.y = v.x;
>+//     return result;
>+// }
>+// float4 operator.zx=(float4 v, float2 c) {
>+//     float4 result = v;
>+//     result.z = c.x;
>+//     result.x = c.y;
>+//     return result;
>+// }
>+// float2 operator.zy(float4 v) {
>+//     float2 result;
>+//     result.x = v.z;
>+//     result.y = v.y;
>+//     return result;
>+// }
>+// float4 operator.zy=(float4 v, float2 c) {
>+//     float4 result = v;
>+//     result.z = c.x;
>+//     result.y = c.y;
>+//     return result;
>+// }
>+// float2 operator.zz(float4 v) {
>+//     float2 result;
>+//     result.x = v.z;
>+//     result.y = v.z;
>+//     return result;
>+// }
>+// float2 operator.zw(float4 v) {
>+//     float2 result;
>+//     result.x = v.z;
>+//     result.y = v.w;
>+//     return result;
>+// }
>+// float4 operator.zw=(float4 v, float2 c) {
>+//     float4 result = v;
>+//     result.z = c.x;
>+//     result.w = c.y;
>+//     return result;
>+// }
>+// float2 operator.wx(float4 v) {
>+//     float2 result;
>+//     result.x = v.w;
>+//     result.y = v.x;
>+//     return result;
>+// }
>+// float4 operator.wx=(float4 v, float2 c) {
>+//     float4 result = v;
>+//     result.w = c.x;
>+//     result.x = c.y;
>+//     return result;
>+// }
>+// float2 operator.wy(float4 v) {
>+//     float2 result;
>+//     result.x = v.w;
>+//     result.y = v.y;
>+//     return result;
>+// }
>+// float4 operator.wy=(float4 v, float2 c) {
>+//     float4 result = v;
>+//     result.w = c.x;
>+//     result.y = c.y;
>+//     return result;
>+// }
>+// float2 operator.wz(float4 v) {
>+//     float2 result;
>+//     result.x = v.w;
>+//     result.y = v.z;
>+//     return result;
>+// }
>+// float4 operator.wz=(float4 v, float2 c) {
>+//     float4 result = v;
>+//     result.w = c.x;
>+//     result.z = c.y;
>+//     return result;
>+// }
>+// float2 operator.ww(float4 v) {
>+//     float2 result;
>+//     result.x = v.w;
>+//     result.y = v.w;
>+//     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.xxy(float2 v) {
>+//     float3 result;
>+//     result.x = v.x;
>+//     result.y = v.x;
>+//     result.z = v.y;
>+//     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.xyy(float2 v) {
>+//     float3 result;
>+//     result.x = v.x;
>+//     result.y = v.y;
>+//     result.z = v.y;
>+//     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.yxy(float2 v) {
>+//     float3 result;
>+//     result.x = v.y;
>+//     result.y = v.x;
>+//     result.z = v.y;
>+//     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.yyy(float2 v) {
>+//     float3 result;
>+//     result.x = v.y;
>+//     result.y = v.y;
>+//     result.z = v.y;
>+//     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.xxy(float3 v) {
>+//     float3 result;
>+//     result.x = v.x;
>+//     result.y = v.x;
>+//     result.z = v.y;
>+//     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.xyx(float3 v) {
>+//     float3 result;
>+//     result.x = v.x;
>+//     result.y = v.y;
>+//     result.z = v.x;
>+//     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.xyz(float3 v) {
>+//     float3 result;
>+//     result.x = v.x;
>+//     result.y = v.y;
>+//     result.z = v.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;
>+// }
>+// float3 operator.xzx(float3 v) {
>+//     float3 result;
>+//     result.x = v.x;
>+//     result.y = v.z;
>+//     result.z = v.x;
>+//     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=(float3 v, float3 c) {
>+//     float3 result = v;
>+//     result.x = c.x;
>+//     result.z = c.y;
>+//     result.y = c.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.yxx(float3 v) {
>+//     float3 result;
>+//     result.x = v.y;
>+//     result.y = v.x;
>+//     result.z = v.x;
>+//     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.yxz(float3 v) {
>+//     float3 result;
>+//     result.x = v.y;
>+//     result.y = v.x;
>+//     result.z = v.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;
>+// }
>+// float3 operator.yyx(float3 v) {
>+//     float3 result;
>+//     result.x = v.y;
>+//     result.y = v.y;
>+//     result.z = v.x;
>+//     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.yyz(float3 v) {
>+//     float3 result;
>+//     result.x = v.y;
>+//     result.y = v.y;
>+//     result.z = v.z;
>+//     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=(float3 v, float3 c) {
>+//     float3 result = v;
>+//     result.y = c.x;
>+//     result.z = c.y;
>+//     result.x = c.z;
>+//     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.yzz(float3 v) {
>+//     float3 result;
>+//     result.x = v.y;
>+//     result.y = v.z;
>+//     result.z = v.z;
>+//     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.zxy(float3 v) {
>+//     float3 result;
>+//     result.x = v.z;
>+//     result.y = v.x;
>+//     result.z = v.y;
>+//     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;
>+// }
>+// float3 operator.zxz(float3 v) {
>+//     float3 result;
>+//     result.x = v.z;
>+//     result.y = v.x;
>+//     result.z = v.z;
>+//     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=(float3 v, float3 c) {
>+//     float3 result = v;
>+//     result.z = c.x;
>+//     result.y = c.y;
>+//     result.x = c.z;
>+//     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.zyz(float3 v) {
>+//     float3 result;
>+//     result.x = v.z;
>+//     result.y = v.y;
>+//     result.z = v.z;
>+//     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.zzy(float3 v) {
>+//     float3 result;
>+//     result.x = v.z;
>+//     result.y = v.z;
>+//     result.z = v.y;
>+//     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.xxx(float4 v) {
>+//     float3 result;
>+//     result.x = v.x;
>+//     result.y = v.x;
>+//     result.z = v.x;
>+//     return result;
>+// }
>+// float3 operator.xxy(float4 v) {
>+//     float3 result;
>+//     result.x = v.x;
>+//     result.y = v.x;
>+//     result.z = v.y;
>+//     return result;
>+// }
>+// float3 operator.xxz(float4 v) {
>+//     float3 result;
>+//     result.x = v.x;
>+//     result.y = v.x;
>+//     result.z = v.z;
>+//     return result;
>+// }
>+// float3 operator.xxw(float4 v) {
>+//     float3 result;
>+//     result.x = v.x;
>+//     result.y = v.x;
>+//     result.z = v.w;
>+//     return result;
>+// }
>+// float3 operator.xyx(float4 v) {
>+//     float3 result;
>+//     result.x = v.x;
>+//     result.y = v.y;
>+//     result.z = v.x;
>+//     return result;
>+// }
>+// float3 operator.xyy(float4 v) {
>+//     float3 result;
>+//     result.x = v.x;
>+//     result.y = v.y;
>+//     result.z = v.y;
>+//     return result;
>+// }
>+// float3 operator.xyz(float4 v) {
>+//     float3 result;
>+//     result.x = v.x;
>+//     result.y = v.y;
>+//     result.z = v.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;
>+// }
>+// float3 operator.xyw(float4 v) {
>+//     float3 result;
>+//     result.x = v.x;
>+//     result.y = v.y;
>+//     result.z = v.w;
>+//     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;
>+// }
>+// float3 operator.xzx(float4 v) {
>+//     float3 result;
>+//     result.x = v.x;
>+//     result.y = v.z;
>+//     result.z = v.x;
>+//     return result;
>+// }
>+// float3 operator.xzy(float4 v) {
>+//     float3 result;
>+//     result.x = v.x;
>+//     result.y = v.z;
>+//     result.z = v.y;
>+//     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;
>+// }
>+// float3 operator.xzz(float4 v) {
>+//     float3 result;
>+//     result.x = v.x;
>+//     result.y = v.z;
>+//     result.z = v.z;
>+//     return result;
>+// }
>+// float3 operator.xzw(float4 v) {
>+//     float3 result;
>+//     result.x = v.x;
>+//     result.y = v.z;
>+//     result.z = v.w;
>+//     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;
>+// }
>+// float3 operator.xwx(float4 v) {
>+//     float3 result;
>+//     result.x = v.x;
>+//     result.y = v.w;
>+//     result.z = v.x;
>+//     return result;
>+// }
>+// float3 operator.xwy(float4 v) {
>+//     float3 result;
>+//     result.x = v.x;
>+//     result.y = v.w;
>+//     result.z = v.y;
>+//     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;
>+// }
>+// float3 operator.xwz(float4 v) {
>+//     float3 result;
>+//     result.x = v.x;
>+//     result.y = v.w;
>+//     result.z = v.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;
>+// }
>+// float3 operator.xww(float4 v) {
>+//     float3 result;
>+//     result.x = v.x;
>+//     result.y = v.w;
>+//     result.z = v.w;
>+//     return result;
>+// }
>+// float3 operator.yxx(float4 v) {
>+//     float3 result;
>+//     result.x = v.y;
>+//     result.y = v.x;
>+//     result.z = v.x;
>+//     return result;
>+// }
>+// float3 operator.yxy(float4 v) {
>+//     float3 result;
>+//     result.x = v.y;
>+//     result.y = v.x;
>+//     result.z = v.y;
>+//     return result;
>+// }
>+// float3 operator.yxz(float4 v) {
>+//     float3 result;
>+//     result.x = v.y;
>+//     result.y = v.x;
>+//     result.z = v.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;
>+// }
>+// float3 operator.yxw(float4 v) {
>+//     float3 result;
>+//     result.x = v.y;
>+//     result.y = v.x;
>+//     result.z = v.w;
>+//     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;
>+// }
>+// float3 operator.yyx(float4 v) {
>+//     float3 result;
>+//     result.x = v.y;
>+//     result.y = v.y;
>+//     result.z = v.x;
>+//     return result;
>+// }
>+// float3 operator.yyy(float4 v) {
>+//     float3 result;
>+//     result.x = v.y;
>+//     result.y = v.y;
>+//     result.z = v.y;
>+//     return result;
>+// }
>+// float3 operator.yyz(float4 v) {
>+//     float3 result;
>+//     result.x = v.y;
>+//     result.y = v.y;
>+//     result.z = v.z;
>+//     return result;
>+// }
>+// float3 operator.yyw(float4 v) {
>+//     float3 result;
>+//     result.x = v.y;
>+//     result.y = v.y;
>+//     result.z = v.w;
>+//     return result;
>+// }
>+// float3 operator.yzx(float4 v) {
>+//     float3 result;
>+//     result.x = v.y;
>+//     result.y = v.z;
>+//     result.z = v.x;
>+//     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;
>+// }
>+// float3 operator.yzy(float4 v) {
>+//     float3 result;
>+//     result.x = v.y;
>+//     result.y = v.z;
>+//     result.z = v.y;
>+//     return result;
>+// }
>+// float3 operator.yzz(float4 v) {
>+//     float3 result;
>+//     result.x = v.y;
>+//     result.y = v.z;
>+//     result.z = v.z;
>+//     return result;
>+// }
>+// float3 operator.yzw(float4 v) {
>+//     float3 result;
>+//     result.x = v.y;
>+//     result.y = v.z;
>+//     result.z = v.w;
>+//     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;
>+// }
>+// float3 operator.ywx(float4 v) {
>+//     float3 result;
>+//     result.x = v.y;
>+//     result.y = v.w;
>+//     result.z = v.x;
>+//     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;
>+// }
>+// float3 operator.ywy(float4 v) {
>+//     float3 result;
>+//     result.x = v.y;
>+//     result.y = v.w;
>+//     result.z = v.y;
>+//     return result;
>+// }
>+// float3 operator.ywz(float4 v) {
>+//     float3 result;
>+//     result.x = v.y;
>+//     result.y = v.w;
>+//     result.z = v.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;
>+// }
>+// float3 operator.yww(float4 v) {
>+//     float3 result;
>+//     result.x = v.y;
>+//     result.y = v.w;
>+//     result.z = v.w;
>+//     return result;
>+// }
>+// float3 operator.zxx(float4 v) {
>+//     float3 result;
>+//     result.x = v.z;
>+//     result.y = v.x;
>+//     result.z = v.x;
>+//     return result;
>+// }
>+// float3 operator.zxy(float4 v) {
>+//     float3 result;
>+//     result.x = v.z;
>+//     result.y = v.x;
>+//     result.z = v.y;
>+//     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;
>+// }
>+// float3 operator.zxz(float4 v) {
>+//     float3 result;
>+//     result.x = v.z;
>+//     result.y = v.x;
>+//     result.z = v.z;
>+//     return result;
>+// }
>+// float3 operator.zxw(float4 v) {
>+//     float3 result;
>+//     result.x = v.z;
>+//     result.y = v.x;
>+//     result.z = v.w;
>+//     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;
>+// }
>+// float3 operator.zyx(float4 v) {
>+//     float3 result;
>+//     result.x = v.z;
>+//     result.y = v.y;
>+//     result.z = v.x;
>+//     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;
>+// }
>+// float3 operator.zyy(float4 v) {
>+//     float3 result;
>+//     result.x = v.z;
>+//     result.y = v.y;
>+//     result.z = v.y;
>+//     return result;
>+// }
>+// float3 operator.zyz(float4 v) {
>+//     float3 result;
>+//     result.x = v.z;
>+//     result.y = v.y;
>+//     result.z = v.z;
>+//     return result;
>+// }
>+// float3 operator.zyw(float4 v) {
>+//     float3 result;
>+//     result.x = v.z;
>+//     result.y = v.y;
>+//     result.z = v.w;
>+//     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;
>+// }
>+// float3 operator.zzx(float4 v) {
>+//     float3 result;
>+//     result.x = v.z;
>+//     result.y = v.z;
>+//     result.z = v.x;
>+//     return result;
>+// }
>+// float3 operator.zzy(float4 v) {
>+//     float3 result;
>+//     result.x = v.z;
>+//     result.y = v.z;
>+//     result.z = v.y;
>+//     return result;
>+// }
>+// float3 operator.zzz(float4 v) {
>+//     float3 result;
>+//     result.x = v.z;
>+//     result.y = v.z;
>+//     result.z = v.z;
>+//     return result;
>+// }
>+// float3 operator.zzw(float4 v) {
>+//     float3 result;
>+//     result.x = v.z;
>+//     result.y = v.z;
>+//     result.z = v.w;
>+//     return result;
>+// }
>+// float3 operator.zwx(float4 v) {
>+//     float3 result;
>+//     result.x = v.z;
>+//     result.y = v.w;
>+//     result.z = v.x;
>+//     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;
>+// }
>+// float3 operator.zwy(float4 v) {
>+//     float3 result;
>+//     result.x = v.z;
>+//     result.y = v.w;
>+//     result.z = v.y;
>+//     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;
>+// }
>+// float3 operator.zwz(float4 v) {
>+//     float3 result;
>+//     result.x = v.z;
>+//     result.y = v.w;
>+//     result.z = v.z;
>+//     return result;
>+// }
>+// float3 operator.zww(float4 v) {
>+//     float3 result;
>+//     result.x = v.z;
>+//     result.y = v.w;
>+//     result.z = v.w;
>+//     return result;
>+// }
>+// float3 operator.wxx(float4 v) {
>+//     float3 result;
>+//     result.x = v.w;
>+//     result.y = v.x;
>+//     result.z = v.x;
>+//     return result;
>+// }
>+// float3 operator.wxy(float4 v) {
>+//     float3 result;
>+//     result.x = v.w;
>+//     result.y = v.x;
>+//     result.z = v.y;
>+//     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;
>+// }
>+// float3 operator.wxz(float4 v) {
>+//     float3 result;
>+//     result.x = v.w;
>+//     result.y = v.x;
>+//     result.z = v.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;
>+// }
>+// float3 operator.wxw(float4 v) {
>+//     float3 result;
>+//     result.x = v.w;
>+//     result.y = v.x;
>+//     result.z = v.w;
>+//     return result;
>+// }
>+// float3 operator.wyx(float4 v) {
>+//     float3 result;
>+//     result.x = v.w;
>+//     result.y = v.y;
>+//     result.z = v.x;
>+//     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;
>+// }
>+// float3 operator.wyy(float4 v) {
>+//     float3 result;
>+//     result.x = v.w;
>+//     result.y = v.y;
>+//     result.z = v.y;
>+//     return result;
>+// }
>+// float3 operator.wyz(float4 v) {
>+//     float3 result;
>+//     result.x = v.w;
>+//     result.y = v.y;
>+//     result.z = v.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;
>+// }
>+// float3 operator.wyw(float4 v) {
>+//     float3 result;
>+//     result.x = v.w;
>+//     result.y = v.y;
>+//     result.z = v.w;
>+//     return result;
>+// }
>+// float3 operator.wzx(float4 v) {
>+//     float3 result;
>+//     result.x = v.w;
>+//     result.y = v.z;
>+//     result.z = v.x;
>+//     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;
>+// }
>+// float3 operator.wzy(float4 v) {
>+//     float3 result;
>+//     result.x = v.w;
>+//     result.y = v.z;
>+//     result.z = v.y;
>+//     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;
>+// }
>+// float3 operator.wzz(float4 v) {
>+//     float3 result;
>+//     result.x = v.w;
>+//     result.y = v.z;
>+//     result.z = v.z;
>+//     return result;
>+// }
>+// float3 operator.wzw(float4 v) {
>+//     float3 result;
>+//     result.x = v.w;
>+//     result.y = v.z;
>+//     result.z = v.w;
>+//     return result;
>+// }
>+// float3 operator.wwx(float4 v) {
>+//     float3 result;
>+//     result.x = v.w;
>+//     result.y = v.w;
>+//     result.z = v.x;
>+//     return result;
>+// }
>+// float3 operator.wwy(float4 v) {
>+//     float3 result;
>+//     result.x = v.w;
>+//     result.y = v.w;
>+//     result.z = v.y;
>+//     return result;
>+// }
>+// float3 operator.wwz(float4 v) {
>+//     float3 result;
>+//     result.x = v.w;
>+//     result.y = v.w;
>+//     result.z = v.z;
>+//     return result;
>+// }
>+// float3 operator.www(float4 v) {
>+//     float3 result;
>+//     result.x = v.w;
>+//     result.y = v.w;
>+//     result.z = v.w;
>+//     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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.yzzy(float3 v) {
>+//     float4 result;
>+//     result.x = v.y;
>+//     result.y = v.z;
>+//     result.z = v.z;
>+//     result.w = v.y;
>+//     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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.xxxx(float4 v) {
>+//     float4 result;
>+//     result.x = v.x;
>+//     result.y = v.x;
>+//     result.z = v.x;
>+//     result.w = v.x;
>+//     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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+// 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;
>+// }
>+
>+native float cos(float);
>+half cos(half x) {
>+    return half(cos(float(x)));
>+}
>+native float sin(float);
>+half sin(half x) {
>+    return half(sin(float(x)));
>+}
>+native float tan(float);
>+half tan(half x) {
>+    return half(tan(float(x)));
>+}
>+native float acos(float);
>+half acos(half x) {
>+    return half(acos(float(x)));
>+}
>+native float asin(float);
>+half asin(half x) {
>+    return half(asin(float(x)));
>+}
>+native float atan(float);
>+half atan(half x) {
>+    return half(atan(float(x)));
>+}
>+native float cosh(float);
>+half cosh(half x) {
>+    return half(cosh(float(x)));
>+}
>+native float sinh(float);
>+half sinh(half x) {
>+    return half(sinh(float(x)));
>+}
>+native float tanh(float);
>+half tanh(half x) {
>+    return half(tanh(float(x)));
>+}
>+native float ceil(float);
>+half ceil(half x) {
>+    return half(ceil(float(x)));
>+}
>+native float exp(float);
>+half exp(half x) {
>+    return half(exp(float(x)));
>+}
>+native float floor(float);
>+half floor(half x) {
>+    return half(floor(float(x)));
>+}
>+native float log(float);
>+half log(half x) {
>+    return half(log(float(x)));
>+}
>+native float round(float);
>+half round(half x) {
>+    return half(round(float(x)));
>+}
>+native float trunc(float);
>+half trunc(half x) {
>+    return half(trunc(float(x)));
>+}
>+native float ddx(float);
>+half ddx(half x) {
>+    return half(ddx(float(x)));
>+}
>+native float ddy(float);
>+half ddy(half x) {
>+    return half(ddy(float(x)));
>+}
>+half sqrt(half x) {
>+    return pow(x, 0.5);
>+}
>+half log2(half x) {
>+    return log(x) / log(2);
>+}
>+half log10(half x) {
>+    return log(x) / log(10);
>+}
>+half frac(half x) {
>+    return x - floor(x);
>+}
>+half exp2(half x) {
>+    return exp(x * log(2));
>+}
>+half degrees(half x) {
>+    return x * 180 / 3.14159;
>+}
>+half radians(half x) {
>+    return x * 3.14159 / 180;
>+}
>+half rcp(half x) {
>+    return 1 / x;
>+}
>+half rsqrt(half x) {
>+    return 1 / sqrt(x);
>+}
>+half saturate(half x) {
>+    return clamp(x, 0, 1);
>+}
>+half ddx_coarse(half x) {
>+    return ddx(x);
>+}
>+half ddx_fine(half x) {
>+    return ddx(x);
>+}
>+half ddy_coarse(half x) {
>+    return ddy(x);
>+}
>+half ddy_fine(half x) {
>+    return ddy(x);
>+}
>+half fwidth(half x) {
>+    return abs(ddx(x)) + abs(ddy(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;
>+}
>+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;
>+}
>+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;
>+}
>+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;
>+}
>+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;
>+}
>+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;
>+}
>+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;
>+}
>+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;
>+}
>+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;
>+}
>+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;
>+}
>+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;
>+}
>+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;
>+}
>+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;
>+}
>+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;
>+}
>+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;
>+}
>+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;
>+}
>+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;
>+}
>+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;
>+}
>+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;
>+}
>+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;
>+}
>+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;
>+}
>+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;
>+}
>+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;
>+}
>+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;
>+}
>+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;
>+}
>+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;
>+}
>+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;
>+}
>+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;
>+}
>+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;
>+}
>+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;
>+}
>+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;
>+}
>+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 sqrt(float x) {
>+    return pow(x, 0.5);
>+}
>+float log2(float x) {
>+    return log(x) / log(2);
>+}
>+float log10(float x) {
>+    return log(x) / log(10);
>+}
>+float frac(float x) {
>+    return x - floor(x);
>+}
>+float exp2(float x) {
>+    return exp(x * log(2));
>+}
>+float degrees(float x) {
>+    return x * 180 / 3.14159;
>+}
>+float radians(float x) {
>+    return x * 3.14159 / 180;
>+}
>+float rcp(float x) {
>+    return 1 / x;
>+}
>+float rsqrt(float x) {
>+    return 1 / sqrt(x);
>+}
>+float saturate(float x) {
>+    return clamp(x, 0, 1);
>+}
>+float ddx_coarse(float x) {
>+    return ddx(x);
>+}
>+float ddx_fine(float x) {
>+    return ddx(x);
>+}
>+float ddy_coarse(float x) {
>+    return ddy(x);
>+}
>+float ddy_fine(float x) {
>+    return ddy(x);
>+}
>+float fwidth(float x) {
>+    return abs(ddx(x)) + abs(ddy(x));
>+}
>+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;
>+}
>+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;
>+}
>+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;
>+}
>+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;
>+}
>+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;
>+}
>+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;
>+}
>+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;
>+}
>+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;
>+}
>+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;
>+}
>+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;
>+}
>+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;
>+}
>+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;
>+}
>+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;
>+}
>+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;
>+}
>+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;
>+}
>+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;
>+}
>+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;
>+}
>+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;
>+}
>+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;
>+}
>+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;
>+}
>+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;
>+}
>+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;
>+}
>+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;
>+}
>+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;
>+}
>+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;
>+}
>+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;
>+}
>+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;
>+}
>+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;
>+}
>+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;
>+}
>+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;
>+}
>+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;
>+}
>+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;
>+}
>+
>+native float pow(float, float);
>+half pow(half x, half y) {
>+    return half(pow(float(x), float(y)));
>+}
>+half step(half y, half x) {
>+    return x >= y ? 1 : 0;
>+}
>+half ldexp(half x, half e) {
>+    return x * pow(2, e);
>+}
>+half fmod(half x, half y) {
>+    uint whole = uint(x / y);
>+    half multiple = half(whole) * y;
>+    return x - multiple;
>+}
>+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;
>+}
>+half2 step(half2 x, half2 y) {
>+    half2 result;
>+    result[0] = step(x[0], y[0]);
>+    result[1] = step(x[1], y[1]);
>+    return result;
>+}
>+half3 step(half3 x, half3 y) {
>+    half3 result;
>+    result[0] = step(x[0], y[0]);
>+    result[1] = step(x[1], y[1]);
>+    result[2] = step(x[2], y[2]);
>+    return result;
>+}
>+half4 step(half4 x, half4 y) {
>+    half4 result;
>+    result[0] = step(x[0], y[0]);
>+    result[1] = step(x[1], y[1]);
>+    result[2] = step(x[2], y[2]);
>+    result[3] = step(x[3], y[3]);
>+    return result;
>+}
>+half2x2 step(half2x2 x, half2x2 y) {
>+    half2x2 result;
>+    result[0][0] = step(x[0][0], y[0][0]);
>+    result[0][1] = step(x[0][1], y[0][1]);
>+    result[1][0] = step(x[1][0], y[1][0]);
>+    result[1][1] = step(x[1][1], y[1][1]);
>+    return result;
>+}
>+half2x3 step(half2x3 x, half2x3 y) {
>+    half2x3 result;
>+    result[0][0] = step(x[0][0], y[0][0]);
>+    result[0][1] = step(x[0][1], y[0][1]);
>+    result[0][2] = step(x[0][2], y[0][2]);
>+    result[1][0] = step(x[1][0], y[1][0]);
>+    result[1][1] = step(x[1][1], y[1][1]);
>+    result[1][2] = step(x[1][2], y[1][2]);
>+    return result;
>+}
>+half2x4 step(half2x4 x, half2x4 y) {
>+    half2x4 result;
>+    result[0][0] = step(x[0][0], y[0][0]);
>+    result[0][1] = step(x[0][1], y[0][1]);
>+    result[0][2] = step(x[0][2], y[0][2]);
>+    result[0][3] = step(x[0][3], y[0][3]);
>+    result[1][0] = step(x[1][0], y[1][0]);
>+    result[1][1] = step(x[1][1], y[1][1]);
>+    result[1][2] = step(x[1][2], y[1][2]);
>+    result[1][3] = step(x[1][3], y[1][3]);
>+    return result;
>+}
>+half3x2 step(half3x2 x, half3x2 y) {
>+    half3x2 result;
>+    result[0][0] = step(x[0][0], y[0][0]);
>+    result[0][1] = step(x[0][1], y[0][1]);
>+    result[1][0] = step(x[1][0], y[1][0]);
>+    result[1][1] = step(x[1][1], y[1][1]);
>+    result[2][0] = step(x[2][0], y[2][0]);
>+    result[2][1] = step(x[2][1], y[2][1]);
>+    return result;
>+}
>+half3x3 step(half3x3 x, half3x3 y) {
>+    half3x3 result;
>+    result[0][0] = step(x[0][0], y[0][0]);
>+    result[0][1] = step(x[0][1], y[0][1]);
>+    result[0][2] = step(x[0][2], y[0][2]);
>+    result[1][0] = step(x[1][0], y[1][0]);
>+    result[1][1] = step(x[1][1], y[1][1]);
>+    result[1][2] = step(x[1][2], y[1][2]);
>+    result[2][0] = step(x[2][0], y[2][0]);
>+    result[2][1] = step(x[2][1], y[2][1]);
>+    result[2][2] = step(x[2][2], y[2][2]);
>+    return result;
>+}
>+half3x4 step(half3x4 x, half3x4 y) {
>+    half3x4 result;
>+    result[0][0] = step(x[0][0], y[0][0]);
>+    result[0][1] = step(x[0][1], y[0][1]);
>+    result[0][2] = step(x[0][2], y[0][2]);
>+    result[0][3] = step(x[0][3], y[0][3]);
>+    result[1][0] = step(x[1][0], y[1][0]);
>+    result[1][1] = step(x[1][1], y[1][1]);
>+    result[1][2] = step(x[1][2], y[1][2]);
>+    result[1][3] = step(x[1][3], y[1][3]);
>+    result[2][0] = step(x[2][0], y[2][0]);
>+    result[2][1] = step(x[2][1], y[2][1]);
>+    result[2][2] = step(x[2][2], y[2][2]);
>+    result[2][3] = step(x[2][3], y[2][3]);
>+    return result;
>+}
>+half4x2 step(half4x2 x, half4x2 y) {
>+    half4x2 result;
>+    result[0][0] = step(x[0][0], y[0][0]);
>+    result[0][1] = step(x[0][1], y[0][1]);
>+    result[1][0] = step(x[1][0], y[1][0]);
>+    result[1][1] = step(x[1][1], y[1][1]);
>+    result[2][0] = step(x[2][0], y[2][0]);
>+    result[2][1] = step(x[2][1], y[2][1]);
>+    result[3][0] = step(x[3][0], y[3][0]);
>+    result[3][1] = step(x[3][1], y[3][1]);
>+    return result;
>+}
>+half4x3 step(half4x3 x, half4x3 y) {
>+    half4x3 result;
>+    result[0][0] = step(x[0][0], y[0][0]);
>+    result[0][1] = step(x[0][1], y[0][1]);
>+    result[0][2] = step(x[0][2], y[0][2]);
>+    result[1][0] = step(x[1][0], y[1][0]);
>+    result[1][1] = step(x[1][1], y[1][1]);
>+    result[1][2] = step(x[1][2], y[1][2]);
>+    result[2][0] = step(x[2][0], y[2][0]);
>+    result[2][1] = step(x[2][1], y[2][1]);
>+    result[2][2] = step(x[2][2], y[2][2]);
>+    result[3][0] = step(x[3][0], y[3][0]);
>+    result[3][1] = step(x[3][1], y[3][1]);
>+    result[3][2] = step(x[3][2], y[3][2]);
>+    return result;
>+}
>+half4x4 step(half4x4 x, half4x4 y) {
>+    half4x4 result;
>+    result[0][0] = step(x[0][0], y[0][0]);
>+    result[0][1] = step(x[0][1], y[0][1]);
>+    result[0][2] = step(x[0][2], y[0][2]);
>+    result[0][3] = step(x[0][3], y[0][3]);
>+    result[1][0] = step(x[1][0], y[1][0]);
>+    result[1][1] = step(x[1][1], y[1][1]);
>+    result[1][2] = step(x[1][2], y[1][2]);
>+    result[1][3] = step(x[1][3], y[1][3]);
>+    result[2][0] = step(x[2][0], y[2][0]);
>+    result[2][1] = step(x[2][1], y[2][1]);
>+    result[2][2] = step(x[2][2], y[2][2]);
>+    result[2][3] = step(x[2][3], y[2][3]);
>+    result[3][0] = step(x[3][0], y[3][0]);
>+    result[3][1] = step(x[3][1], y[3][1]);
>+    result[3][2] = step(x[3][2], y[3][2]);
>+    result[3][3] = step(x[3][3], y[3][3]);
>+    return result;
>+}
>+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;
>+}
>+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 step(float y, float x) {
>+    return x >= y ? 1 : 0;
>+}
>+float ldexp(float x, float e) {
>+    return x * pow(2, e);
>+}
>+float fmod(float x, float y) {
>+    uint whole = uint(x / y);
>+    float multiple = float(whole) * y;
>+    return x - multiple;
>+}
>+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;
>+}
>+float2 step(float2 x, float2 y) {
>+    float2 result;
>+    result[0] = step(x[0], y[0]);
>+    result[1] = step(x[1], y[1]);
>+    return result;
>+}
>+float3 step(float3 x, float3 y) {
>+    float3 result;
>+    result[0] = step(x[0], y[0]);
>+    result[1] = step(x[1], y[1]);
>+    result[2] = step(x[2], y[2]);
>+    return result;
>+}
>+float4 step(float4 x, float4 y) {
>+    float4 result;
>+    result[0] = step(x[0], y[0]);
>+    result[1] = step(x[1], y[1]);
>+    result[2] = step(x[2], y[2]);
>+    result[3] = step(x[3], y[3]);
>+    return result;
>+}
>+float2x2 step(float2x2 x, float2x2 y) {
>+    float2x2 result;
>+    result[0][0] = step(x[0][0], y[0][0]);
>+    result[0][1] = step(x[0][1], y[0][1]);
>+    result[1][0] = step(x[1][0], y[1][0]);
>+    result[1][1] = step(x[1][1], y[1][1]);
>+    return result;
>+}
>+float2x3 step(float2x3 x, float2x3 y) {
>+    float2x3 result;
>+    result[0][0] = step(x[0][0], y[0][0]);
>+    result[0][1] = step(x[0][1], y[0][1]);
>+    result[0][2] = step(x[0][2], y[0][2]);
>+    result[1][0] = step(x[1][0], y[1][0]);
>+    result[1][1] = step(x[1][1], y[1][1]);
>+    result[1][2] = step(x[1][2], y[1][2]);
>+    return result;
>+}
>+float2x4 step(float2x4 x, float2x4 y) {
>+    float2x4 result;
>+    result[0][0] = step(x[0][0], y[0][0]);
>+    result[0][1] = step(x[0][1], y[0][1]);
>+    result[0][2] = step(x[0][2], y[0][2]);
>+    result[0][3] = step(x[0][3], y[0][3]);
>+    result[1][0] = step(x[1][0], y[1][0]);
>+    result[1][1] = step(x[1][1], y[1][1]);
>+    result[1][2] = step(x[1][2], y[1][2]);
>+    result[1][3] = step(x[1][3], y[1][3]);
>+    return result;
>+}
>+float3x2 step(float3x2 x, float3x2 y) {
>+    float3x2 result;
>+    result[0][0] = step(x[0][0], y[0][0]);
>+    result[0][1] = step(x[0][1], y[0][1]);
>+    result[1][0] = step(x[1][0], y[1][0]);
>+    result[1][1] = step(x[1][1], y[1][1]);
>+    result[2][0] = step(x[2][0], y[2][0]);
>+    result[2][1] = step(x[2][1], y[2][1]);
>+    return result;
>+}
>+float3x3 step(float3x3 x, float3x3 y) {
>+    float3x3 result;
>+    result[0][0] = step(x[0][0], y[0][0]);
>+    result[0][1] = step(x[0][1], y[0][1]);
>+    result[0][2] = step(x[0][2], y[0][2]);
>+    result[1][0] = step(x[1][0], y[1][0]);
>+    result[1][1] = step(x[1][1], y[1][1]);
>+    result[1][2] = step(x[1][2], y[1][2]);
>+    result[2][0] = step(x[2][0], y[2][0]);
>+    result[2][1] = step(x[2][1], y[2][1]);
>+    result[2][2] = step(x[2][2], y[2][2]);
>+    return result;
>+}
>+float3x4 step(float3x4 x, float3x4 y) {
>+    float3x4 result;
>+    result[0][0] = step(x[0][0], y[0][0]);
>+    result[0][1] = step(x[0][1], y[0][1]);
>+    result[0][2] = step(x[0][2], y[0][2]);
>+    result[0][3] = step(x[0][3], y[0][3]);
>+    result[1][0] = step(x[1][0], y[1][0]);
>+    result[1][1] = step(x[1][1], y[1][1]);
>+    result[1][2] = step(x[1][2], y[1][2]);
>+    result[1][3] = step(x[1][3], y[1][3]);
>+    result[2][0] = step(x[2][0], y[2][0]);
>+    result[2][1] = step(x[2][1], y[2][1]);
>+    result[2][2] = step(x[2][2], y[2][2]);
>+    result[2][3] = step(x[2][3], y[2][3]);
>+    return result;
>+}
>+float4x2 step(float4x2 x, float4x2 y) {
>+    float4x2 result;
>+    result[0][0] = step(x[0][0], y[0][0]);
>+    result[0][1] = step(x[0][1], y[0][1]);
>+    result[1][0] = step(x[1][0], y[1][0]);
>+    result[1][1] = step(x[1][1], y[1][1]);
>+    result[2][0] = step(x[2][0], y[2][0]);
>+    result[2][1] = step(x[2][1], y[2][1]);
>+    result[3][0] = step(x[3][0], y[3][0]);
>+    result[3][1] = step(x[3][1], y[3][1]);
>+    return result;
>+}
>+float4x3 step(float4x3 x, float4x3 y) {
>+    float4x3 result;
>+    result[0][0] = step(x[0][0], y[0][0]);
>+    result[0][1] = step(x[0][1], y[0][1]);
>+    result[0][2] = step(x[0][2], y[0][2]);
>+    result[1][0] = step(x[1][0], y[1][0]);
>+    result[1][1] = step(x[1][1], y[1][1]);
>+    result[1][2] = step(x[1][2], y[1][2]);
>+    result[2][0] = step(x[2][0], y[2][0]);
>+    result[2][1] = step(x[2][1], y[2][1]);
>+    result[2][2] = step(x[2][2], y[2][2]);
>+    result[3][0] = step(x[3][0], y[3][0]);
>+    result[3][1] = step(x[3][1], y[3][1]);
>+    result[3][2] = step(x[3][2], y[3][2]);
>+    return result;
>+}
>+float4x4 step(float4x4 x, float4x4 y) {
>+    float4x4 result;
>+    result[0][0] = step(x[0][0], y[0][0]);
>+    result[0][1] = step(x[0][1], y[0][1]);
>+    result[0][2] = step(x[0][2], y[0][2]);
>+    result[0][3] = step(x[0][3], y[0][3]);
>+    result[1][0] = step(x[1][0], y[1][0]);
>+    result[1][1] = step(x[1][1], y[1][1]);
>+    result[1][2] = step(x[1][2], y[1][2]);
>+    result[1][3] = step(x[1][3], y[1][3]);
>+    result[2][0] = step(x[2][0], y[2][0]);
>+    result[2][1] = step(x[2][1], y[2][1]);
>+    result[2][2] = step(x[2][2], y[2][2]);
>+    result[2][3] = step(x[2][3], y[2][3]);
>+    result[3][0] = step(x[3][0], y[3][0]);
>+    result[3][1] = step(x[3][1], y[3][1]);
>+    result[3][2] = step(x[3][2], y[3][2]);
>+    result[3][3] = step(x[3][3], y[3][3]);
>+    return result;
>+}
>+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;
>+}
>+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;
>+}
>+
>+half smoothstep(half edge0, half edge1, half x) {
>+    half t = clamp((x - edge0) / (edge1 - edge0), 0, 1);
>+    return t * t * (3 - 2 * t);
>+}
>+half lerp(half x, half y, half s) {
>+    return x * (1 - s) + y * s;
>+}
>+half fma(half x, half y, half z) {
>+    return x * y + z;
>+}
>+half mad(half x, half y, half z) {
>+    return x * y + z;
>+}
>+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;
>+}
>+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;
>+}
>+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;
>+}
>+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 smoothstep(float edge0, float edge1, float x) {
>+    float t = clamp((x - edge0) / (edge1 - edge0), 0, 1);
>+    return t * t * (3 - 2 * t);
>+}
>+float lerp(float x, float y, float s) {
>+    return x * (1 - s) + y * s;
>+}
>+float fma(float x, float y, float z) {
>+    return x * y + z;
>+}
>+float mad(float x, float y, float z) {
>+    return x * y + z;
>+}
>+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;
>+}
>+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;
>+}
>+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;
>+}
>+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;
>+}
>+
>+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;
>+}
>+
>+native bool isfinite(float);
>+bool isfinite(half x) {
>+    return isfinite(float(x));
>+}
>+native bool isinf(float);
>+bool isinf(half x) {
>+    return isinf(float(x));
>+}
>+native bool isnan(float);
>+bool isnan(half x) {
>+    return isnan(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 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 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 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;
>+}
>+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;
>+}
>+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;
>+}
>+
>+bool isordered(half x, half y) {
>+    return (x == x) && (y == y);
>+}
>+bool isunordered(half x, half y) {
>+    return isnan(x) || isnan(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;
>+}
>+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 isordered(float x, float y) {
>+    return (x == x) && (y == y);
>+}
>+bool isunordered(float x, float y) {
>+    return isnan(x) || isnan(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;
>+}
>+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;
>+}
>+
>+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;
>+}
>+
>+void sincos(half x, thread half* y, thread half* z) {
>+    *y = sin(x);
>+    *z = cos(x);
>+}
>+void sincos(half2 x, thread half2* y, thread half2* z) {
>+    sincos(x[0], &((*y)[0]), &((*z)[0]));
>+    sincos(x[1], &((*y)[1]), &((*z)[1]));
>+}
>+void sincos(half3 x, thread half3* y, thread half3* z) {
>+    sincos(x[0], &((*y)[0]), &((*z)[0]));
>+    sincos(x[1], &((*y)[1]), &((*z)[1]));
>+    sincos(x[2], &((*y)[2]), &((*z)[2]));
>+}
>+void sincos(half4 x, thread half4* y, thread half4* z) {
>+    sincos(x[0], &((*y)[0]), &((*z)[0]));
>+    sincos(x[1], &((*y)[1]), &((*z)[1]));
>+    sincos(x[2], &((*y)[2]), &((*z)[2]));
>+    sincos(x[3], &((*y)[3]), &((*z)[3]));
>+}
>+void sincos(half2x2 x, thread half2x2* y, thread half2x2* z) {
>+    sincos(x[0][0], &((*y)[0][0]), &((*z)[0][0]));
>+    sincos(x[0][1], &((*y)[0][1]), &((*z)[0][1]));
>+    sincos(x[1][0], &((*y)[1][0]), &((*z)[1][0]));
>+    sincos(x[1][1], &((*y)[1][1]), &((*z)[1][1]));
>+}
>+void sincos(half2x3 x, thread half2x3* y, thread half2x3* z) {
>+    sincos(x[0][0], &((*y)[0][0]), &((*z)[0][0]));
>+    sincos(x[0][1], &((*y)[0][1]), &((*z)[0][1]));
>+    sincos(x[0][2], &((*y)[0][2]), &((*z)[0][2]));
>+    sincos(x[1][0], &((*y)[1][0]), &((*z)[1][0]));
>+    sincos(x[1][1], &((*y)[1][1]), &((*z)[1][1]));
>+    sincos(x[1][2], &((*y)[1][2]), &((*z)[1][2]));
>+}
>+void sincos(half2x4 x, thread half2x4* y, thread half2x4* z) {
>+    sincos(x[0][0], &((*y)[0][0]), &((*z)[0][0]));
>+    sincos(x[0][1], &((*y)[0][1]), &((*z)[0][1]));
>+    sincos(x[0][2], &((*y)[0][2]), &((*z)[0][2]));
>+    sincos(x[0][3], &((*y)[0][3]), &((*z)[0][3]));
>+    sincos(x[1][0], &((*y)[1][0]), &((*z)[1][0]));
>+    sincos(x[1][1], &((*y)[1][1]), &((*z)[1][1]));
>+    sincos(x[1][2], &((*y)[1][2]), &((*z)[1][2]));
>+    sincos(x[1][3], &((*y)[1][3]), &((*z)[1][3]));
>+}
>+void sincos(half3x2 x, thread half3x2* y, thread half3x2* z) {
>+    sincos(x[0][0], &((*y)[0][0]), &((*z)[0][0]));
>+    sincos(x[0][1], &((*y)[0][1]), &((*z)[0][1]));
>+    sincos(x[1][0], &((*y)[1][0]), &((*z)[1][0]));
>+    sincos(x[1][1], &((*y)[1][1]), &((*z)[1][1]));
>+    sincos(x[2][0], &((*y)[2][0]), &((*z)[2][0]));
>+    sincos(x[2][1], &((*y)[2][1]), &((*z)[2][1]));
>+}
>+void sincos(half3x3 x, thread half3x3* y, thread half3x3* z) {
>+    sincos(x[0][0], &((*y)[0][0]), &((*z)[0][0]));
>+    sincos(x[0][1], &((*y)[0][1]), &((*z)[0][1]));
>+    sincos(x[0][2], &((*y)[0][2]), &((*z)[0][2]));
>+    sincos(x[1][0], &((*y)[1][0]), &((*z)[1][0]));
>+    sincos(x[1][1], &((*y)[1][1]), &((*z)[1][1]));
>+    sincos(x[1][2], &((*y)[1][2]), &((*z)[1][2]));
>+    sincos(x[2][0], &((*y)[2][0]), &((*z)[2][0]));
>+    sincos(x[2][1], &((*y)[2][1]), &((*z)[2][1]));
>+    sincos(x[2][2], &((*y)[2][2]), &((*z)[2][2]));
>+}
>+void sincos(half3x4 x, thread half3x4* y, thread half3x4* z) {
>+    sincos(x[0][0], &((*y)[0][0]), &((*z)[0][0]));
>+    sincos(x[0][1], &((*y)[0][1]), &((*z)[0][1]));
>+    sincos(x[0][2], &((*y)[0][2]), &((*z)[0][2]));
>+    sincos(x[0][3], &((*y)[0][3]), &((*z)[0][3]));
>+    sincos(x[1][0], &((*y)[1][0]), &((*z)[1][0]));
>+    sincos(x[1][1], &((*y)[1][1]), &((*z)[1][1]));
>+    sincos(x[1][2], &((*y)[1][2]), &((*z)[1][2]));
>+    sincos(x[1][3], &((*y)[1][3]), &((*z)[1][3]));
>+    sincos(x[2][0], &((*y)[2][0]), &((*z)[2][0]));
>+    sincos(x[2][1], &((*y)[2][1]), &((*z)[2][1]));
>+    sincos(x[2][2], &((*y)[2][2]), &((*z)[2][2]));
>+    sincos(x[2][3], &((*y)[2][3]), &((*z)[2][3]));
>+}
>+void sincos(half4x2 x, thread half4x2* y, thread half4x2* z) {
>+    sincos(x[0][0], &((*y)[0][0]), &((*z)[0][0]));
>+    sincos(x[0][1], &((*y)[0][1]), &((*z)[0][1]));
>+    sincos(x[1][0], &((*y)[1][0]), &((*z)[1][0]));
>+    sincos(x[1][1], &((*y)[1][1]), &((*z)[1][1]));
>+    sincos(x[2][0], &((*y)[2][0]), &((*z)[2][0]));
>+    sincos(x[2][1], &((*y)[2][1]), &((*z)[2][1]));
>+    sincos(x[3][0], &((*y)[3][0]), &((*z)[3][0]));
>+    sincos(x[3][1], &((*y)[3][1]), &((*z)[3][1]));
>+}
>+void sincos(half4x3 x, thread half4x3* y, thread half4x3* z) {
>+    sincos(x[0][0], &((*y)[0][0]), &((*z)[0][0]));
>+    sincos(x[0][1], &((*y)[0][1]), &((*z)[0][1]));
>+    sincos(x[0][2], &((*y)[0][2]), &((*z)[0][2]));
>+    sincos(x[1][0], &((*y)[1][0]), &((*z)[1][0]));
>+    sincos(x[1][1], &((*y)[1][1]), &((*z)[1][1]));
>+    sincos(x[1][2], &((*y)[1][2]), &((*z)[1][2]));
>+    sincos(x[2][0], &((*y)[2][0]), &((*z)[2][0]));
>+    sincos(x[2][1], &((*y)[2][1]), &((*z)[2][1]));
>+    sincos(x[2][2], &((*y)[2][2]), &((*z)[2][2]));
>+    sincos(x[3][0], &((*y)[3][0]), &((*z)[3][0]));
>+    sincos(x[3][1], &((*y)[3][1]), &((*z)[3][1]));
>+    sincos(x[3][2], &((*y)[3][2]), &((*z)[3][2]));
>+}
>+void sincos(half4x4 x, thread half4x4* y, thread half4x4* z) {
>+    sincos(x[0][0], &((*y)[0][0]), &((*z)[0][0]));
>+    sincos(x[0][1], &((*y)[0][1]), &((*z)[0][1]));
>+    sincos(x[0][2], &((*y)[0][2]), &((*z)[0][2]));
>+    sincos(x[0][3], &((*y)[0][3]), &((*z)[0][3]));
>+    sincos(x[1][0], &((*y)[1][0]), &((*z)[1][0]));
>+    sincos(x[1][1], &((*y)[1][1]), &((*z)[1][1]));
>+    sincos(x[1][2], &((*y)[1][2]), &((*z)[1][2]));
>+    sincos(x[1][3], &((*y)[1][3]), &((*z)[1][3]));
>+    sincos(x[2][0], &((*y)[2][0]), &((*z)[2][0]));
>+    sincos(x[2][1], &((*y)[2][1]), &((*z)[2][1]));
>+    sincos(x[2][2], &((*y)[2][2]), &((*z)[2][2]));
>+    sincos(x[2][3], &((*y)[2][3]), &((*z)[2][3]));
>+    sincos(x[3][0], &((*y)[3][0]), &((*z)[3][0]));
>+    sincos(x[3][1], &((*y)[3][1]), &((*z)[3][1]));
>+    sincos(x[3][2], &((*y)[3][2]), &((*z)[3][2]));
>+    sincos(x[3][3], &((*y)[3][3]), &((*z)[3][3]));
>+}
>+void sincos(float x, thread float* y, thread float* z) {
>+    *y = sin(x);
>+    *z = cos(x);
>+}
>+void sincos(float2 x, thread float2* y, thread float2* z) {
>+    sincos(x[0], &((*y)[0]), &((*z)[0]));
>+    sincos(x[1], &((*y)[1]), &((*z)[1]));
>+}
>+void sincos(float3 x, thread float3* y, thread float3* z) {
>+    sincos(x[0], &((*y)[0]), &((*z)[0]));
>+    sincos(x[1], &((*y)[1]), &((*z)[1]));
>+    sincos(x[2], &((*y)[2]), &((*z)[2]));
>+}
>+void sincos(float4 x, thread float4* y, thread float4* z) {
>+    sincos(x[0], &((*y)[0]), &((*z)[0]));
>+    sincos(x[1], &((*y)[1]), &((*z)[1]));
>+    sincos(x[2], &((*y)[2]), &((*z)[2]));
>+    sincos(x[3], &((*y)[3]), &((*z)[3]));
>+}
>+void sincos(float2x2 x, thread float2x2* y, thread float2x2* z) {
>+    sincos(x[0][0], &((*y)[0][0]), &((*z)[0][0]));
>+    sincos(x[0][1], &((*y)[0][1]), &((*z)[0][1]));
>+    sincos(x[1][0], &((*y)[1][0]), &((*z)[1][0]));
>+    sincos(x[1][1], &((*y)[1][1]), &((*z)[1][1]));
>+}
>+void sincos(float2x3 x, thread float2x3* y, thread float2x3* z) {
>+    sincos(x[0][0], &((*y)[0][0]), &((*z)[0][0]));
>+    sincos(x[0][1], &((*y)[0][1]), &((*z)[0][1]));
>+    sincos(x[0][2], &((*y)[0][2]), &((*z)[0][2]));
>+    sincos(x[1][0], &((*y)[1][0]), &((*z)[1][0]));
>+    sincos(x[1][1], &((*y)[1][1]), &((*z)[1][1]));
>+    sincos(x[1][2], &((*y)[1][2]), &((*z)[1][2]));
>+}
>+void sincos(float2x4 x, thread float2x4* y, thread float2x4* z) {
>+    sincos(x[0][0], &((*y)[0][0]), &((*z)[0][0]));
>+    sincos(x[0][1], &((*y)[0][1]), &((*z)[0][1]));
>+    sincos(x[0][2], &((*y)[0][2]), &((*z)[0][2]));
>+    sincos(x[0][3], &((*y)[0][3]), &((*z)[0][3]));
>+    sincos(x[1][0], &((*y)[1][0]), &((*z)[1][0]));
>+    sincos(x[1][1], &((*y)[1][1]), &((*z)[1][1]));
>+    sincos(x[1][2], &((*y)[1][2]), &((*z)[1][2]));
>+    sincos(x[1][3], &((*y)[1][3]), &((*z)[1][3]));
>+}
>+void sincos(float3x2 x, thread float3x2* y, thread float3x2* z) {
>+    sincos(x[0][0], &((*y)[0][0]), &((*z)[0][0]));
>+    sincos(x[0][1], &((*y)[0][1]), &((*z)[0][1]));
>+    sincos(x[1][0], &((*y)[1][0]), &((*z)[1][0]));
>+    sincos(x[1][1], &((*y)[1][1]), &((*z)[1][1]));
>+    sincos(x[2][0], &((*y)[2][0]), &((*z)[2][0]));
>+    sincos(x[2][1], &((*y)[2][1]), &((*z)[2][1]));
>+}
>+void sincos(float3x3 x, thread float3x3* y, thread float3x3* z) {
>+    sincos(x[0][0], &((*y)[0][0]), &((*z)[0][0]));
>+    sincos(x[0][1], &((*y)[0][1]), &((*z)[0][1]));
>+    sincos(x[0][2], &((*y)[0][2]), &((*z)[0][2]));
>+    sincos(x[1][0], &((*y)[1][0]), &((*z)[1][0]));
>+    sincos(x[1][1], &((*y)[1][1]), &((*z)[1][1]));
>+    sincos(x[1][2], &((*y)[1][2]), &((*z)[1][2]));
>+    sincos(x[2][0], &((*y)[2][0]), &((*z)[2][0]));
>+    sincos(x[2][1], &((*y)[2][1]), &((*z)[2][1]));
>+    sincos(x[2][2], &((*y)[2][2]), &((*z)[2][2]));
>+}
>+void sincos(float3x4 x, thread float3x4* y, thread float3x4* z) {
>+    sincos(x[0][0], &((*y)[0][0]), &((*z)[0][0]));
>+    sincos(x[0][1], &((*y)[0][1]), &((*z)[0][1]));
>+    sincos(x[0][2], &((*y)[0][2]), &((*z)[0][2]));
>+    sincos(x[0][3], &((*y)[0][3]), &((*z)[0][3]));
>+    sincos(x[1][0], &((*y)[1][0]), &((*z)[1][0]));
>+    sincos(x[1][1], &((*y)[1][1]), &((*z)[1][1]));
>+    sincos(x[1][2], &((*y)[1][2]), &((*z)[1][2]));
>+    sincos(x[1][3], &((*y)[1][3]), &((*z)[1][3]));
>+    sincos(x[2][0], &((*y)[2][0]), &((*z)[2][0]));
>+    sincos(x[2][1], &((*y)[2][1]), &((*z)[2][1]));
>+    sincos(x[2][2], &((*y)[2][2]), &((*z)[2][2]));
>+    sincos(x[2][3], &((*y)[2][3]), &((*z)[2][3]));
>+}
>+void sincos(float4x2 x, thread float4x2* y, thread float4x2* z) {
>+    sincos(x[0][0], &((*y)[0][0]), &((*z)[0][0]));
>+    sincos(x[0][1], &((*y)[0][1]), &((*z)[0][1]));
>+    sincos(x[1][0], &((*y)[1][0]), &((*z)[1][0]));
>+    sincos(x[1][1], &((*y)[1][1]), &((*z)[1][1]));
>+    sincos(x[2][0], &((*y)[2][0]), &((*z)[2][0]));
>+    sincos(x[2][1], &((*y)[2][1]), &((*z)[2][1]));
>+    sincos(x[3][0], &((*y)[3][0]), &((*z)[3][0]));
>+    sincos(x[3][1], &((*y)[3][1]), &((*z)[3][1]));
>+}
>+void sincos(float4x3 x, thread float4x3* y, thread float4x3* z) {
>+    sincos(x[0][0], &((*y)[0][0]), &((*z)[0][0]));
>+    sincos(x[0][1], &((*y)[0][1]), &((*z)[0][1]));
>+    sincos(x[0][2], &((*y)[0][2]), &((*z)[0][2]));
>+    sincos(x[1][0], &((*y)[1][0]), &((*z)[1][0]));
>+    sincos(x[1][1], &((*y)[1][1]), &((*z)[1][1]));
>+    sincos(x[1][2], &((*y)[1][2]), &((*z)[1][2]));
>+    sincos(x[2][0], &((*y)[2][0]), &((*z)[2][0]));
>+    sincos(x[2][1], &((*y)[2][1]), &((*z)[2][1]));
>+    sincos(x[2][2], &((*y)[2][2]), &((*z)[2][2]));
>+    sincos(x[3][0], &((*y)[3][0]), &((*z)[3][0]));
>+    sincos(x[3][1], &((*y)[3][1]), &((*z)[3][1]));
>+    sincos(x[3][2], &((*y)[3][2]), &((*z)[3][2]));
>+}
>+void sincos(float4x4 x, thread float4x4* y, thread float4x4* z) {
>+    sincos(x[0][0], &((*y)[0][0]), &((*z)[0][0]));
>+    sincos(x[0][1], &((*y)[0][1]), &((*z)[0][1]));
>+    sincos(x[0][2], &((*y)[0][2]), &((*z)[0][2]));
>+    sincos(x[0][3], &((*y)[0][3]), &((*z)[0][3]));
>+    sincos(x[1][0], &((*y)[1][0]), &((*z)[1][0]));
>+    sincos(x[1][1], &((*y)[1][1]), &((*z)[1][1]));
>+    sincos(x[1][2], &((*y)[1][2]), &((*z)[1][2]));
>+    sincos(x[1][3], &((*y)[1][3]), &((*z)[1][3]));
>+    sincos(x[2][0], &((*y)[2][0]), &((*z)[2][0]));
>+    sincos(x[2][1], &((*y)[2][1]), &((*z)[2][1]));
>+    sincos(x[2][2], &((*y)[2][2]), &((*z)[2][2]));
>+    sincos(x[2][3], &((*y)[2][3]), &((*z)[2][3]));
>+    sincos(x[3][0], &((*y)[3][0]), &((*z)[3][0]));
>+    sincos(x[3][1], &((*y)[3][1]), &((*z)[3][1]));
>+    sincos(x[3][2], &((*y)[3][2]), &((*z)[3][2]));
>+    sincos(x[3][3], &((*y)[3][3]), &((*z)[3][3]));
>+}
>+
>+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;
>+}
>+
>+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;
>+}
>+
>+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;
>+}
>+
>+uchar sign(uchar x) {
>+    return x == 0 ? 0 : 1;
>+}
>+ushort sign(ushort x) {
>+    return x == 0 ? 0 : 1;
>+}
>+uint sign(uint x) {
>+    return x == 0 ? 0 : 1;
>+}
>+char sign(char x) {
>+    if (x < 0)
>+        return -1;
>+    if (x == 0)
>+        return 0;
>+    return 1;
>+}
>+short sign(short x) {
>+    if (x < 0)
>+        return -1;
>+    if (x == 0)
>+        return 0;
>+    return 1;
>+}
>+int sign(int x) {
>+    if (x < 0)
>+        return -1;
>+    if (x == 0)
>+        return 0;
>+    return 1;
>+}
>+half sign(half x) {
>+    if (x < 0)
>+        return -1;
>+    if (x == 0)
>+        return 0;
>+    return 1;
>+}
>+float sign(float x) {
>+    if (x < 0)
>+        return -1;
>+    if (x == 0)
>+        return 0;
>+    return 1;
>+}
>+uchar2 sign(uchar2 x) {
>+    uchar2 result;
>+    result[0] = sign(x[0]);
>+    result[1] = sign(x[1]);
>+    return result;
>+}
>+uchar3 sign(uchar3 x) {
>+    uchar3 result;
>+    result[0] = sign(x[0]);
>+    result[1] = sign(x[1]);
>+    result[2] = sign(x[2]);
>+    return result;
>+}
>+uchar4 sign(uchar4 x) {
>+    uchar4 result;
>+    result[0] = sign(x[0]);
>+    result[1] = sign(x[1]);
>+    result[2] = sign(x[2]);
>+    result[3] = sign(x[3]);
>+    return result;
>+}
>+ushort2 sign(ushort2 x) {
>+    ushort2 result;
>+    result[0] = sign(x[0]);
>+    result[1] = sign(x[1]);
>+    return result;
>+}
>+ushort3 sign(ushort3 x) {
>+    ushort3 result;
>+    result[0] = sign(x[0]);
>+    result[1] = sign(x[1]);
>+    result[2] = sign(x[2]);
>+    return result;
>+}
>+ushort4 sign(ushort4 x) {
>+    ushort4 result;
>+    result[0] = sign(x[0]);
>+    result[1] = sign(x[1]);
>+    result[2] = sign(x[2]);
>+    result[3] = sign(x[3]);
>+    return result;
>+}
>+uint2 sign(uint2 x) {
>+    uint2 result;
>+    result[0] = sign(x[0]);
>+    result[1] = sign(x[1]);
>+    return result;
>+}
>+uint3 sign(uint3 x) {
>+    uint3 result;
>+    result[0] = sign(x[0]);
>+    result[1] = sign(x[1]);
>+    result[2] = sign(x[2]);
>+    return result;
>+}
>+uint4 sign(uint4 x) {
>+    uint4 result;
>+    result[0] = sign(x[0]);
>+    result[1] = sign(x[1]);
>+    result[2] = sign(x[2]);
>+    result[3] = sign(x[3]);
>+    return result;
>+}
>+char2 sign(char2 x) {
>+    char2 result;
>+    result[0] = sign(x[0]);
>+    result[1] = sign(x[1]);
>+    return result;
>+}
>+char3 sign(char3 x) {
>+    char3 result;
>+    result[0] = sign(x[0]);
>+    result[1] = sign(x[1]);
>+    result[2] = sign(x[2]);
>+    return result;
>+}
>+char4 sign(char4 x) {
>+    char4 result;
>+    result[0] = sign(x[0]);
>+    result[1] = sign(x[1]);
>+    result[2] = sign(x[2]);
>+    result[3] = sign(x[3]);
>+    return result;
>+}
>+short2 sign(short2 x) {
>+    short2 result;
>+    result[0] = sign(x[0]);
>+    result[1] = sign(x[1]);
>+    return result;
>+}
>+short3 sign(short3 x) {
>+    short3 result;
>+    result[0] = sign(x[0]);
>+    result[1] = sign(x[1]);
>+    result[2] = sign(x[2]);
>+    return result;
>+}
>+short4 sign(short4 x) {
>+    short4 result;
>+    result[0] = sign(x[0]);
>+    result[1] = sign(x[1]);
>+    result[2] = sign(x[2]);
>+    result[3] = sign(x[3]);
>+    return result;
>+}
>+int2 sign(int2 x) {
>+    int2 result;
>+    result[0] = sign(x[0]);
>+    result[1] = sign(x[1]);
>+    return result;
>+}
>+int3 sign(int3 x) {
>+    int3 result;
>+    result[0] = sign(x[0]);
>+    result[1] = sign(x[1]);
>+    result[2] = sign(x[2]);
>+    return result;
>+}
>+int4 sign(int4 x) {
>+    int4 result;
>+    result[0] = sign(x[0]);
>+    result[1] = sign(x[1]);
>+    result[2] = sign(x[2]);
>+    result[3] = sign(x[3]);
>+    return result;
>+}
>+half2 sign(half2 x) {
>+    half2 result;
>+    result[0] = sign(x[0]);
>+    result[1] = sign(x[1]);
>+    return result;
>+}
>+half3 sign(half3 x) {
>+    half3 result;
>+    result[0] = sign(x[0]);
>+    result[1] = sign(x[1]);
>+    result[2] = sign(x[2]);
>+    return result;
>+}
>+half4 sign(half4 x) {
>+    half4 result;
>+    result[0] = sign(x[0]);
>+    result[1] = sign(x[1]);
>+    result[2] = sign(x[2]);
>+    result[3] = sign(x[3]);
>+    return result;
>+}
>+half2x2 sign(half2x2 x) {
>+    half2x2 result;
>+    result[0][0] = sign(x[0][0]);
>+    result[0][1] = sign(x[0][1]);
>+    result[1][0] = sign(x[1][0]);
>+    result[1][1] = sign(x[1][1]);
>+    return result;
>+}
>+half2x3 sign(half2x3 x) {
>+    half2x3 result;
>+    result[0][0] = sign(x[0][0]);
>+    result[0][1] = sign(x[0][1]);
>+    result[0][2] = sign(x[0][2]);
>+    result[1][0] = sign(x[1][0]);
>+    result[1][1] = sign(x[1][1]);
>+    result[1][2] = sign(x[1][2]);
>+    return result;
>+}
>+half2x4 sign(half2x4 x) {
>+    half2x4 result;
>+    result[0][0] = sign(x[0][0]);
>+    result[0][1] = sign(x[0][1]);
>+    result[0][2] = sign(x[0][2]);
>+    result[0][3] = sign(x[0][3]);
>+    result[1][0] = sign(x[1][0]);
>+    result[1][1] = sign(x[1][1]);
>+    result[1][2] = sign(x[1][2]);
>+    result[1][3] = sign(x[1][3]);
>+    return result;
>+}
>+half3x2 sign(half3x2 x) {
>+    half3x2 result;
>+    result[0][0] = sign(x[0][0]);
>+    result[0][1] = sign(x[0][1]);
>+    result[1][0] = sign(x[1][0]);
>+    result[1][1] = sign(x[1][1]);
>+    result[2][0] = sign(x[2][0]);
>+    result[2][1] = sign(x[2][1]);
>+    return result;
>+}
>+half3x3 sign(half3x3 x) {
>+    half3x3 result;
>+    result[0][0] = sign(x[0][0]);
>+    result[0][1] = sign(x[0][1]);
>+    result[0][2] = sign(x[0][2]);
>+    result[1][0] = sign(x[1][0]);
>+    result[1][1] = sign(x[1][1]);
>+    result[1][2] = sign(x[1][2]);
>+    result[2][0] = sign(x[2][0]);
>+    result[2][1] = sign(x[2][1]);
>+    result[2][2] = sign(x[2][2]);
>+    return result;
>+}
>+half3x4 sign(half3x4 x) {
>+    half3x4 result;
>+    result[0][0] = sign(x[0][0]);
>+    result[0][1] = sign(x[0][1]);
>+    result[0][2] = sign(x[0][2]);
>+    result[0][3] = sign(x[0][3]);
>+    result[1][0] = sign(x[1][0]);
>+    result[1][1] = sign(x[1][1]);
>+    result[1][2] = sign(x[1][2]);
>+    result[1][3] = sign(x[1][3]);
>+    result[2][0] = sign(x[2][0]);
>+    result[2][1] = sign(x[2][1]);
>+    result[2][2] = sign(x[2][2]);
>+    result[2][3] = sign(x[2][3]);
>+    return result;
>+}
>+half4x2 sign(half4x2 x) {
>+    half4x2 result;
>+    result[0][0] = sign(x[0][0]);
>+    result[0][1] = sign(x[0][1]);
>+    result[1][0] = sign(x[1][0]);
>+    result[1][1] = sign(x[1][1]);
>+    result[2][0] = sign(x[2][0]);
>+    result[2][1] = sign(x[2][1]);
>+    result[3][0] = sign(x[3][0]);
>+    result[3][1] = sign(x[3][1]);
>+    return result;
>+}
>+half4x3 sign(half4x3 x) {
>+    half4x3 result;
>+    result[0][0] = sign(x[0][0]);
>+    result[0][1] = sign(x[0][1]);
>+    result[0][2] = sign(x[0][2]);
>+    result[1][0] = sign(x[1][0]);
>+    result[1][1] = sign(x[1][1]);
>+    result[1][2] = sign(x[1][2]);
>+    result[2][0] = sign(x[2][0]);
>+    result[2][1] = sign(x[2][1]);
>+    result[2][2] = sign(x[2][2]);
>+    result[3][0] = sign(x[3][0]);
>+    result[3][1] = sign(x[3][1]);
>+    result[3][2] = sign(x[3][2]);
>+    return result;
>+}
>+half4x4 sign(half4x4 x) {
>+    half4x4 result;
>+    result[0][0] = sign(x[0][0]);
>+    result[0][1] = sign(x[0][1]);
>+    result[0][2] = sign(x[0][2]);
>+    result[0][3] = sign(x[0][3]);
>+    result[1][0] = sign(x[1][0]);
>+    result[1][1] = sign(x[1][1]);
>+    result[1][2] = sign(x[1][2]);
>+    result[1][3] = sign(x[1][3]);
>+    result[2][0] = sign(x[2][0]);
>+    result[2][1] = sign(x[2][1]);
>+    result[2][2] = sign(x[2][2]);
>+    result[2][3] = sign(x[2][3]);
>+    result[3][0] = sign(x[3][0]);
>+    result[3][1] = sign(x[3][1]);
>+    result[3][2] = sign(x[3][2]);
>+    result[3][3] = sign(x[3][3]);
>+    return result;
>+}
>+float2 sign(float2 x) {
>+    float2 result;
>+    result[0] = sign(x[0]);
>+    result[1] = sign(x[1]);
>+    return result;
>+}
>+float3 sign(float3 x) {
>+    float3 result;
>+    result[0] = sign(x[0]);
>+    result[1] = sign(x[1]);
>+    result[2] = sign(x[2]);
>+    return result;
>+}
>+float4 sign(float4 x) {
>+    float4 result;
>+    result[0] = sign(x[0]);
>+    result[1] = sign(x[1]);
>+    result[2] = sign(x[2]);
>+    result[3] = sign(x[3]);
>+    return result;
>+}
>+float2x2 sign(float2x2 x) {
>+    float2x2 result;
>+    result[0][0] = sign(x[0][0]);
>+    result[0][1] = sign(x[0][1]);
>+    result[1][0] = sign(x[1][0]);
>+    result[1][1] = sign(x[1][1]);
>+    return result;
>+}
>+float2x3 sign(float2x3 x) {
>+    float2x3 result;
>+    result[0][0] = sign(x[0][0]);
>+    result[0][1] = sign(x[0][1]);
>+    result[0][2] = sign(x[0][2]);
>+    result[1][0] = sign(x[1][0]);
>+    result[1][1] = sign(x[1][1]);
>+    result[1][2] = sign(x[1][2]);
>+    return result;
>+}
>+float2x4 sign(float2x4 x) {
>+    float2x4 result;
>+    result[0][0] = sign(x[0][0]);
>+    result[0][1] = sign(x[0][1]);
>+    result[0][2] = sign(x[0][2]);
>+    result[0][3] = sign(x[0][3]);
>+    result[1][0] = sign(x[1][0]);
>+    result[1][1] = sign(x[1][1]);
>+    result[1][2] = sign(x[1][2]);
>+    result[1][3] = sign(x[1][3]);
>+    return result;
>+}
>+float3x2 sign(float3x2 x) {
>+    float3x2 result;
>+    result[0][0] = sign(x[0][0]);
>+    result[0][1] = sign(x[0][1]);
>+    result[1][0] = sign(x[1][0]);
>+    result[1][1] = sign(x[1][1]);
>+    result[2][0] = sign(x[2][0]);
>+    result[2][1] = sign(x[2][1]);
>+    return result;
>+}
>+float3x3 sign(float3x3 x) {
>+    float3x3 result;
>+    result[0][0] = sign(x[0][0]);
>+    result[0][1] = sign(x[0][1]);
>+    result[0][2] = sign(x[0][2]);
>+    result[1][0] = sign(x[1][0]);
>+    result[1][1] = sign(x[1][1]);
>+    result[1][2] = sign(x[1][2]);
>+    result[2][0] = sign(x[2][0]);
>+    result[2][1] = sign(x[2][1]);
>+    result[2][2] = sign(x[2][2]);
>+    return result;
>+}
>+float3x4 sign(float3x4 x) {
>+    float3x4 result;
>+    result[0][0] = sign(x[0][0]);
>+    result[0][1] = sign(x[0][1]);
>+    result[0][2] = sign(x[0][2]);
>+    result[0][3] = sign(x[0][3]);
>+    result[1][0] = sign(x[1][0]);
>+    result[1][1] = sign(x[1][1]);
>+    result[1][2] = sign(x[1][2]);
>+    result[1][3] = sign(x[1][3]);
>+    result[2][0] = sign(x[2][0]);
>+    result[2][1] = sign(x[2][1]);
>+    result[2][2] = sign(x[2][2]);
>+    result[2][3] = sign(x[2][3]);
>+    return result;
>+}
>+float4x2 sign(float4x2 x) {
>+    float4x2 result;
>+    result[0][0] = sign(x[0][0]);
>+    result[0][1] = sign(x[0][1]);
>+    result[1][0] = sign(x[1][0]);
>+    result[1][1] = sign(x[1][1]);
>+    result[2][0] = sign(x[2][0]);
>+    result[2][1] = sign(x[2][1]);
>+    result[3][0] = sign(x[3][0]);
>+    result[3][1] = sign(x[3][1]);
>+    return result;
>+}
>+float4x3 sign(float4x3 x) {
>+    float4x3 result;
>+    result[0][0] = sign(x[0][0]);
>+    result[0][1] = sign(x[0][1]);
>+    result[0][2] = sign(x[0][2]);
>+    result[1][0] = sign(x[1][0]);
>+    result[1][1] = sign(x[1][1]);
>+    result[1][2] = sign(x[1][2]);
>+    result[2][0] = sign(x[2][0]);
>+    result[2][1] = sign(x[2][1]);
>+    result[2][2] = sign(x[2][2]);
>+    result[3][0] = sign(x[3][0]);
>+    result[3][1] = sign(x[3][1]);
>+    result[3][2] = sign(x[3][2]);
>+    return result;
>+}
>+float4x4 sign(float4x4 x) {
>+    float4x4 result;
>+    result[0][0] = sign(x[0][0]);
>+    result[0][1] = sign(x[0][1]);
>+    result[0][2] = sign(x[0][2]);
>+    result[0][3] = sign(x[0][3]);
>+    result[1][0] = sign(x[1][0]);
>+    result[1][1] = sign(x[1][1]);
>+    result[1][2] = sign(x[1][2]);
>+    result[1][3] = sign(x[1][3]);
>+    result[2][0] = sign(x[2][0]);
>+    result[2][1] = sign(x[2][1]);
>+    result[2][2] = sign(x[2][2]);
>+    result[2][3] = sign(x[2][3]);
>+    result[3][0] = sign(x[3][0]);
>+    result[3][1] = sign(x[3][1]);
>+    result[3][2] = sign(x[3][2]);
>+    result[3][3] = sign(x[3][3]);
>+    return result;
>+}
>+
>+uchar min(uchar x, uchar y) {
>+    return x > y ? y : x;
>+}
>+uchar max(uchar x, uchar y) {
>+    return x > y ? x : y;
>+}
>+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;
>+}
>+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 min(ushort x, ushort y) {
>+    return x > y ? y : x;
>+}
>+ushort max(ushort x, ushort y) {
>+    return x > y ? x : y;
>+}
>+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;
>+}
>+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 min(uint x, uint y) {
>+    return x > y ? y : x;
>+}
>+uint max(uint x, uint y) {
>+    return x > y ? x : y;
>+}
>+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;
>+}
>+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 min(char x, char y) {
>+    return x > y ? y : x;
>+}
>+char max(char x, char y) {
>+    return x > y ? x : y;
>+}
>+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;
>+}
>+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 min(short x, short y) {
>+    return x > y ? y : x;
>+}
>+short max(short x, short y) {
>+    return x > y ? x : y;
>+}
>+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;
>+}
>+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 min(int x, int y) {
>+    return x > y ? y : x;
>+}
>+int max(int x, int y) {
>+    return x > y ? x : y;
>+}
>+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;
>+}
>+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 min(half x, half y) {
>+    return x > y ? y : x;
>+}
>+half max(half x, half y) {
>+    return x > y ? x : y;
>+}
>+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;
>+}
>+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 min(float x, float y) {
>+    return x > y ? y : x;
>+}
>+float max(float x, float y) {
>+    return x > y ? x : y;
>+}
>+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;
>+}
>+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;
>+}
>+
>+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;
>+}
>+
>+half modf(half x, thread half* ip) {
>+    uint result = uint(x);
>+    *ip = x - half(result);
>+    return half(result);
>+}
>+half2 modf(half2 x, thread half2* y) {
>+    half2 result;
>+    result[0] = modf(x[0], &((*y)[0]));
>+    result[1] = modf(x[1], &((*y)[1]));
>+    return result;
>+}
>+half3 modf(half3 x, thread half3* y) {
>+    half3 result;
>+    result[0] = modf(x[0], &((*y)[0]));
>+    result[1] = modf(x[1], &((*y)[1]));
>+    result[2] = modf(x[2], &((*y)[2]));
>+    return result;
>+}
>+half4 modf(half4 x, thread half4* y) {
>+    half4 result;
>+    result[0] = modf(x[0], &((*y)[0]));
>+    result[1] = modf(x[1], &((*y)[1]));
>+    result[2] = modf(x[2], &((*y)[2]));
>+    result[3] = modf(x[3], &((*y)[3]));
>+    return result;
>+}
>+half2x2 modf(half2x2 x, thread half2x2* y) {
>+    half2x2 result;
>+    result[0][0] = modf(x[0][0], &((*y)[0][0]));
>+    result[0][1] = modf(x[0][1], &((*y)[0][1]));
>+    result[1][0] = modf(x[1][0], &((*y)[1][0]));
>+    result[1][1] = modf(x[1][1], &((*y)[1][1]));
>+    return result;
>+}
>+half2x3 modf(half2x3 x, thread half2x3* y) {
>+    half2x3 result;
>+    result[0][0] = modf(x[0][0], &((*y)[0][0]));
>+    result[0][1] = modf(x[0][1], &((*y)[0][1]));
>+    result[0][2] = modf(x[0][2], &((*y)[0][2]));
>+    result[1][0] = modf(x[1][0], &((*y)[1][0]));
>+    result[1][1] = modf(x[1][1], &((*y)[1][1]));
>+    result[1][2] = modf(x[1][2], &((*y)[1][2]));
>+    return result;
>+}
>+half2x4 modf(half2x4 x, thread half2x4* y) {
>+    half2x4 result;
>+    result[0][0] = modf(x[0][0], &((*y)[0][0]));
>+    result[0][1] = modf(x[0][1], &((*y)[0][1]));
>+    result[0][2] = modf(x[0][2], &((*y)[0][2]));
>+    result[0][3] = modf(x[0][3], &((*y)[0][3]));
>+    result[1][0] = modf(x[1][0], &((*y)[1][0]));
>+    result[1][1] = modf(x[1][1], &((*y)[1][1]));
>+    result[1][2] = modf(x[1][2], &((*y)[1][2]));
>+    result[1][3] = modf(x[1][3], &((*y)[1][3]));
>+    return result;
>+}
>+half3x2 modf(half3x2 x, thread half3x2* y) {
>+    half3x2 result;
>+    result[0][0] = modf(x[0][0], &((*y)[0][0]));
>+    result[0][1] = modf(x[0][1], &((*y)[0][1]));
>+    result[1][0] = modf(x[1][0], &((*y)[1][0]));
>+    result[1][1] = modf(x[1][1], &((*y)[1][1]));
>+    result[2][0] = modf(x[2][0], &((*y)[2][0]));
>+    result[2][1] = modf(x[2][1], &((*y)[2][1]));
>+    return result;
>+}
>+half3x3 modf(half3x3 x, thread half3x3* y) {
>+    half3x3 result;
>+    result[0][0] = modf(x[0][0], &((*y)[0][0]));
>+    result[0][1] = modf(x[0][1], &((*y)[0][1]));
>+    result[0][2] = modf(x[0][2], &((*y)[0][2]));
>+    result[1][0] = modf(x[1][0], &((*y)[1][0]));
>+    result[1][1] = modf(x[1][1], &((*y)[1][1]));
>+    result[1][2] = modf(x[1][2], &((*y)[1][2]));
>+    result[2][0] = modf(x[2][0], &((*y)[2][0]));
>+    result[2][1] = modf(x[2][1], &((*y)[2][1]));
>+    result[2][2] = modf(x[2][2], &((*y)[2][2]));
>+    return result;
>+}
>+half3x4 modf(half3x4 x, thread half3x4* y) {
>+    half3x4 result;
>+    result[0][0] = modf(x[0][0], &((*y)[0][0]));
>+    result[0][1] = modf(x[0][1], &((*y)[0][1]));
>+    result[0][2] = modf(x[0][2], &((*y)[0][2]));
>+    result[0][3] = modf(x[0][3], &((*y)[0][3]));
>+    result[1][0] = modf(x[1][0], &((*y)[1][0]));
>+    result[1][1] = modf(x[1][1], &((*y)[1][1]));
>+    result[1][2] = modf(x[1][2], &((*y)[1][2]));
>+    result[1][3] = modf(x[1][3], &((*y)[1][3]));
>+    result[2][0] = modf(x[2][0], &((*y)[2][0]));
>+    result[2][1] = modf(x[2][1], &((*y)[2][1]));
>+    result[2][2] = modf(x[2][2], &((*y)[2][2]));
>+    result[2][3] = modf(x[2][3], &((*y)[2][3]));
>+    return result;
>+}
>+half4x2 modf(half4x2 x, thread half4x2* y) {
>+    half4x2 result;
>+    result[0][0] = modf(x[0][0], &((*y)[0][0]));
>+    result[0][1] = modf(x[0][1], &((*y)[0][1]));
>+    result[1][0] = modf(x[1][0], &((*y)[1][0]));
>+    result[1][1] = modf(x[1][1], &((*y)[1][1]));
>+    result[2][0] = modf(x[2][0], &((*y)[2][0]));
>+    result[2][1] = modf(x[2][1], &((*y)[2][1]));
>+    result[3][0] = modf(x[3][0], &((*y)[3][0]));
>+    result[3][1] = modf(x[3][1], &((*y)[3][1]));
>+    return result;
>+}
>+half4x3 modf(half4x3 x, thread half4x3* y) {
>+    half4x3 result;
>+    result[0][0] = modf(x[0][0], &((*y)[0][0]));
>+    result[0][1] = modf(x[0][1], &((*y)[0][1]));
>+    result[0][2] = modf(x[0][2], &((*y)[0][2]));
>+    result[1][0] = modf(x[1][0], &((*y)[1][0]));
>+    result[1][1] = modf(x[1][1], &((*y)[1][1]));
>+    result[1][2] = modf(x[1][2], &((*y)[1][2]));
>+    result[2][0] = modf(x[2][0], &((*y)[2][0]));
>+    result[2][1] = modf(x[2][1], &((*y)[2][1]));
>+    result[2][2] = modf(x[2][2], &((*y)[2][2]));
>+    result[3][0] = modf(x[3][0], &((*y)[3][0]));
>+    result[3][1] = modf(x[3][1], &((*y)[3][1]));
>+    result[3][2] = modf(x[3][2], &((*y)[3][2]));
>+    return result;
>+}
>+half4x4 modf(half4x4 x, thread half4x4* y) {
>+    half4x4 result;
>+    result[0][0] = modf(x[0][0], &((*y)[0][0]));
>+    result[0][1] = modf(x[0][1], &((*y)[0][1]));
>+    result[0][2] = modf(x[0][2], &((*y)[0][2]));
>+    result[0][3] = modf(x[0][3], &((*y)[0][3]));
>+    result[1][0] = modf(x[1][0], &((*y)[1][0]));
>+    result[1][1] = modf(x[1][1], &((*y)[1][1]));
>+    result[1][2] = modf(x[1][2], &((*y)[1][2]));
>+    result[1][3] = modf(x[1][3], &((*y)[1][3]));
>+    result[2][0] = modf(x[2][0], &((*y)[2][0]));
>+    result[2][1] = modf(x[2][1], &((*y)[2][1]));
>+    result[2][2] = modf(x[2][2], &((*y)[2][2]));
>+    result[2][3] = modf(x[2][3], &((*y)[2][3]));
>+    result[3][0] = modf(x[3][0], &((*y)[3][0]));
>+    result[3][1] = modf(x[3][1], &((*y)[3][1]));
>+    result[3][2] = modf(x[3][2], &((*y)[3][2]));
>+    result[3][3] = modf(x[3][3], &((*y)[3][3]));
>+    return result;
>+}
>+
>+float modf(float x, thread float* ip) {
>+    uint result = uint(x);
>+    *ip = x - float(result);
>+    return float(result);
>+}
>+float2 modf(float2 x, thread float2* y) {
>+    float2 result;
>+    result[0] = modf(x[0], &((*y)[0]));
>+    result[1] = modf(x[1], &((*y)[1]));
>+    return result;
>+}
>+float3 modf(float3 x, thread float3* y) {
>+    float3 result;
>+    result[0] = modf(x[0], &((*y)[0]));
>+    result[1] = modf(x[1], &((*y)[1]));
>+    result[2] = modf(x[2], &((*y)[2]));
>+    return result;
>+}
>+float4 modf(float4 x, thread float4* y) {
>+    float4 result;
>+    result[0] = modf(x[0], &((*y)[0]));
>+    result[1] = modf(x[1], &((*y)[1]));
>+    result[2] = modf(x[2], &((*y)[2]));
>+    result[3] = modf(x[3], &((*y)[3]));
>+    return result;
>+}
>+float2x2 modf(float2x2 x, thread float2x2* y) {
>+    float2x2 result;
>+    result[0][0] = modf(x[0][0], &((*y)[0][0]));
>+    result[0][1] = modf(x[0][1], &((*y)[0][1]));
>+    result[1][0] = modf(x[1][0], &((*y)[1][0]));
>+    result[1][1] = modf(x[1][1], &((*y)[1][1]));
>+    return result;
>+}
>+float2x3 modf(float2x3 x, thread float2x3* y) {
>+    float2x3 result;
>+    result[0][0] = modf(x[0][0], &((*y)[0][0]));
>+    result[0][1] = modf(x[0][1], &((*y)[0][1]));
>+    result[0][2] = modf(x[0][2], &((*y)[0][2]));
>+    result[1][0] = modf(x[1][0], &((*y)[1][0]));
>+    result[1][1] = modf(x[1][1], &((*y)[1][1]));
>+    result[1][2] = modf(x[1][2], &((*y)[1][2]));
>+    return result;
>+}
>+float2x4 modf(float2x4 x, thread float2x4* y) {
>+    float2x4 result;
>+    result[0][0] = modf(x[0][0], &((*y)[0][0]));
>+    result[0][1] = modf(x[0][1], &((*y)[0][1]));
>+    result[0][2] = modf(x[0][2], &((*y)[0][2]));
>+    result[0][3] = modf(x[0][3], &((*y)[0][3]));
>+    result[1][0] = modf(x[1][0], &((*y)[1][0]));
>+    result[1][1] = modf(x[1][1], &((*y)[1][1]));
>+    result[1][2] = modf(x[1][2], &((*y)[1][2]));
>+    result[1][3] = modf(x[1][3], &((*y)[1][3]));
>+    return result;
>+}
>+float3x2 modf(float3x2 x, thread float3x2* y) {
>+    float3x2 result;
>+    result[0][0] = modf(x[0][0], &((*y)[0][0]));
>+    result[0][1] = modf(x[0][1], &((*y)[0][1]));
>+    result[1][0] = modf(x[1][0], &((*y)[1][0]));
>+    result[1][1] = modf(x[1][1], &((*y)[1][1]));
>+    result[2][0] = modf(x[2][0], &((*y)[2][0]));
>+    result[2][1] = modf(x[2][1], &((*y)[2][1]));
>+    return result;
>+}
>+float3x3 modf(float3x3 x, thread float3x3* y) {
>+    float3x3 result;
>+    result[0][0] = modf(x[0][0], &((*y)[0][0]));
>+    result[0][1] = modf(x[0][1], &((*y)[0][1]));
>+    result[0][2] = modf(x[0][2], &((*y)[0][2]));
>+    result[1][0] = modf(x[1][0], &((*y)[1][0]));
>+    result[1][1] = modf(x[1][1], &((*y)[1][1]));
>+    result[1][2] = modf(x[1][2], &((*y)[1][2]));
>+    result[2][0] = modf(x[2][0], &((*y)[2][0]));
>+    result[2][1] = modf(x[2][1], &((*y)[2][1]));
>+    result[2][2] = modf(x[2][2], &((*y)[2][2]));
>+    return result;
>+}
>+float3x4 modf(float3x4 x, thread float3x4* y) {
>+    float3x4 result;
>+    result[0][0] = modf(x[0][0], &((*y)[0][0]));
>+    result[0][1] = modf(x[0][1], &((*y)[0][1]));
>+    result[0][2] = modf(x[0][2], &((*y)[0][2]));
>+    result[0][3] = modf(x[0][3], &((*y)[0][3]));
>+    result[1][0] = modf(x[1][0], &((*y)[1][0]));
>+    result[1][1] = modf(x[1][1], &((*y)[1][1]));
>+    result[1][2] = modf(x[1][2], &((*y)[1][2]));
>+    result[1][3] = modf(x[1][3], &((*y)[1][3]));
>+    result[2][0] = modf(x[2][0], &((*y)[2][0]));
>+    result[2][1] = modf(x[2][1], &((*y)[2][1]));
>+    result[2][2] = modf(x[2][2], &((*y)[2][2]));
>+    result[2][3] = modf(x[2][3], &((*y)[2][3]));
>+    return result;
>+}
>+float4x2 modf(float4x2 x, thread float4x2* y) {
>+    float4x2 result;
>+    result[0][0] = modf(x[0][0], &((*y)[0][0]));
>+    result[0][1] = modf(x[0][1], &((*y)[0][1]));
>+    result[1][0] = modf(x[1][0], &((*y)[1][0]));
>+    result[1][1] = modf(x[1][1], &((*y)[1][1]));
>+    result[2][0] = modf(x[2][0], &((*y)[2][0]));
>+    result[2][1] = modf(x[2][1], &((*y)[2][1]));
>+    result[3][0] = modf(x[3][0], &((*y)[3][0]));
>+    result[3][1] = modf(x[3][1], &((*y)[3][1]));
>+    return result;
>+}
>+float4x3 modf(float4x3 x, thread float4x3* y) {
>+    float4x3 result;
>+    result[0][0] = modf(x[0][0], &((*y)[0][0]));
>+    result[0][1] = modf(x[0][1], &((*y)[0][1]));
>+    result[0][2] = modf(x[0][2], &((*y)[0][2]));
>+    result[1][0] = modf(x[1][0], &((*y)[1][0]));
>+    result[1][1] = modf(x[1][1], &((*y)[1][1]));
>+    result[1][2] = modf(x[1][2], &((*y)[1][2]));
>+    result[2][0] = modf(x[2][0], &((*y)[2][0]));
>+    result[2][1] = modf(x[2][1], &((*y)[2][1]));
>+    result[2][2] = modf(x[2][2], &((*y)[2][2]));
>+    result[3][0] = modf(x[3][0], &((*y)[3][0]));
>+    result[3][1] = modf(x[3][1], &((*y)[3][1]));
>+    result[3][2] = modf(x[3][2], &((*y)[3][2]));
>+    return result;
>+}
>+float4x4 modf(float4x4 x, thread float4x4* y) {
>+    float4x4 result;
>+    result[0][0] = modf(x[0][0], &((*y)[0][0]));
>+    result[0][1] = modf(x[0][1], &((*y)[0][1]));
>+    result[0][2] = modf(x[0][2], &((*y)[0][2]));
>+    result[0][3] = modf(x[0][3], &((*y)[0][3]));
>+    result[1][0] = modf(x[1][0], &((*y)[1][0]));
>+    result[1][1] = modf(x[1][1], &((*y)[1][1]));
>+    result[1][2] = modf(x[1][2], &((*y)[1][2]));
>+    result[1][3] = modf(x[1][3], &((*y)[1][3]));
>+    result[2][0] = modf(x[2][0], &((*y)[2][0]));
>+    result[2][1] = modf(x[2][1], &((*y)[2][1]));
>+    result[2][2] = modf(x[2][2], &((*y)[2][2]));
>+    result[2][3] = modf(x[2][3], &((*y)[2][3]));
>+    result[3][0] = modf(x[3][0], &((*y)[3][0]));
>+    result[3][1] = modf(x[3][1], &((*y)[3][1]));
>+    result[3][2] = modf(x[3][2], &((*y)[3][2]));
>+    result[3][3] = modf(x[3][3], &((*y)[3][3]));
>+    return result;
>+}
>+
>+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));
>+}
>+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 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;
>+}
>+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;
>+}
>+
>+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));
>+}
>+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 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;
>+}
>+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;
>+}
>+
>+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;
>+}
>+
>+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;
>+}
>+
>+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);
>+}
>+
>+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;
>+}
>+
>+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;
>+}
>+
>+half faceforward(half n, half i, half ng) {
>+    return -n * sign(dot(i, ng));
>+}
>+half2 faceforward(half2 n, half2 i, half2 ng) {
>+    return -n * sign(dot(i, ng));
>+}
>+half3 faceforward(half3 n, half3 i, half3 ng) {
>+    return -n * sign(dot(i, ng));
>+}
>+half4 faceforward(half4 n, half4 i, half4 ng) {
>+    return -n * sign(dot(i, ng));
>+}
>+float faceforward(float n, float i, float ng) {
>+    return -n * sign(dot(i, ng));
>+}
>+float2 faceforward(float2 n, float2 i, float2 ng) {
>+    return -n * sign(dot(i, ng));
>+}
>+float3 faceforward(float3 n, float3 i, float3 ng) {
>+    return -n * sign(dot(i, ng));
>+}
>+float4 faceforward(float4 n, float4 i, float4 ng) {
>+    return -n * sign(dot(i, ng));
>+}
>+
>+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));
>+}
>+
>+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;
>+}
>+
>+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);
>+}
>+
>+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);
>+}
>+
>+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;
>+}
>+
>+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;
>+}
>+
>+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;
>+}
>+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;
>+}
>+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;
>+}
>+
>+native float f16tof32(uint);
>+native uint f32tof16(float);
>+float2 f16tof32(uint2 x) {
>+    float2 result;
>+    result[0] = f16tof32(x[0]);
>+    result[1] = f16tof32(x[1]);
>+    return result;
>+}
>+uint2 f32tof16(float2 x) {
>+    uint2 result;
>+    result[0] = f32tof16(x[0]);
>+    result[1] = f32tof16(x[1]);
>+    return result;
>+}
>+float3 f16tof32(uint3 x) {
>+    float3 result;
>+    result[0] = f16tof32(x[0]);
>+    result[1] = f16tof32(x[1]);
>+    result[2] = f16tof32(x[2]);
>+    return result;
>+}
>+uint3 f32tof16(float3 x) {
>+    uint3 result;
>+    result[0] = f32tof16(x[0]);
>+    result[1] = f32tof16(x[1]);
>+    result[2] = f32tof16(x[2]);
>+    return result;
>+}
>+float4 f16tof32(uint4 x) {
>+    float4 result;
>+    result[0] = f16tof32(x[0]);
>+    result[1] = f16tof32(x[1]);
>+    result[2] = f16tof32(x[2]);
>+    result[3] = f16tof32(x[3]);
>+    return result;
>+}
>+uint4 f32tof16(float4 x) {
>+    uint4 result;
>+    result[0] = f32tof16(x[0]);
>+    result[1] = f32tof16(x[1]);
>+    result[2] = f32tof16(x[2]);
>+    result[3] = f32tof16(x[3]);
>+    return result;
>+}
>+
>+native void AllMemoryBarrierWithGroupSync();
>+native void DeviceMemoryBarrierWithGroupSync();
>+native void GroupMemoryBarrierWithGroupSync();
>+
>+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;
>+}
>+uchar2 mul(uchar2 x, uchar2 y) {
>+    return dot(x, y);
>+}
>+uchar3 mul(uchar3 x, uchar3 y) {
>+    return dot(x, y);
>+}
>+uchar4 mul(uchar4 x, uchar4 y) {
>+    return dot(x, y);
>+}
>+ushort2 mul(ushort2 x, ushort2 y) {
>+    return dot(x, y);
>+}
>+ushort3 mul(ushort3 x, ushort3 y) {
>+    return dot(x, y);
>+}
>+ushort4 mul(ushort4 x, ushort4 y) {
>+    return dot(x, y);
>+}
>+uint2 mul(uint2 x, uint2 y) {
>+    return dot(x, y);
>+}
>+uint3 mul(uint3 x, uint3 y) {
>+    return dot(x, y);
>+}
>+uint4 mul(uint4 x, uint4 y) {
>+    return dot(x, y);
>+}
>+char2 mul(char2 x, char2 y) {
>+    return dot(x, y);
>+}
>+char3 mul(char3 x, char3 y) {
>+    return dot(x, y);
>+}
>+char4 mul(char4 x, char4 y) {
>+    return dot(x, y);
>+}
>+short2 mul(short2 x, short2 y) {
>+    return dot(x, y);
>+}
>+short3 mul(short3 x, short3 y) {
>+    return dot(x, y);
>+}
>+short4 mul(short4 x, short4 y) {
>+    return dot(x, y);
>+}
>+int2 mul(int2 x, int2 y) {
>+    return dot(x, y);
>+}
>+int3 mul(int3 x, int3 y) {
>+    return dot(x, y);
>+}
>+int4 mul(int4 x, int4 y) {
>+    return dot(x, y);
>+}
>+half2 mul(half2 x, half2 y) {
>+    return dot(x, y);
>+}
>+half3 mul(half3 x, half3 y) {
>+    return dot(x, y);
>+}
>+half4 mul(half4 x, half4 y) {
>+    return dot(x, y);
>+}
>+float2 mul(float2 x, float2 y) {
>+    return dot(x, y);
>+}
>+float3 mul(float3 x, float3 y) {
>+    return dot(x, y);
>+}
>+float4 mul(float4 x, float4 y) {
>+    return dot(x, y);
> }
>-
>-bool operator|(bool a, bool b)
>-{
>-    if (a)
>-        return true;
>-    if (b)
>-        return true;
>-    return false;
>+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;
> }
>-
>-bool operator^(bool a, bool b)
>-{
>-    if (a)
>-        return !b;
>-    return b;
>+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;
> }
>-
>-bool operator~(bool value)
>-{
>-    return !value;
>+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;
> }
>-
>-protocol Addable {
>-    Addable operator+(Addable, Addable);
>+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;
> }
>-
>-protocol Equatable {
>-    bool operator==(Equatable, Equatable);
>+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;
> }
>-
>-restricted operator<T> T()
>-{
>-    T defaultValue;
>-    return defaultValue;
>+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;
> }
>-
>-restricted operator<T> T(T x)
>-{
>-    return x;
>+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;
> }
>-
>-operator<T:Equatable> bool(T x)
>-{
>-    return x != T();
>+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;
> }
>-
>-struct vec2<T> {
>-    T x;
>-    T y;
>+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;
> }
>-
>-typedef int2 = vec2<int>;
>-typedef uint2 = vec2<uint>;
>-typedef float2 = vec2<float>;
>-
>-operator<T> vec2<T>(T x, T y)
>-{
>-    vec2<T> result;
>-    result.x = x;
>-    result.y = y;
>+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;
> }
>-
>-bool operator==<T:Equatable>(vec2<T> a, vec2<T> b)
>-{
>-    return a.x == b.x && a.y == b.y;
>+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;
> }
>-
>-thread T* operator&[]<T>(thread vec2<T>* foo, uint index)
>-{
>-    if (index == 0)
>-        return &foo->x;
>-    if (index == 1)
>-        return &foo->y;
>-    trap;
>+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;
> }
>-
>-struct vec3<T> {
>-    T x;
>-    T y;
>-    T z;
>+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;
> }
>-
>-typedef int3 = vec3<int>;
>-typedef uint3 = vec3<uint>;
>-typedef float3 = vec3<float>;
>-
>-operator<T> vec3<T>(T x, T y, T z)
>-{
>-    vec3<T> result;
>-    result.x = x;
>-    result.y = y;
>-    result.z = z;
>+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;
> }
>-
>-operator<T> vec3<T>(vec2<T> v2, T z)
>-{
>-    vec3<T> result;
>-    result.x = v2.x;
>-    result.y = v2.y;
>-    result.z = z;
>+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;
> }
>-
>-operator<T> vec3<T>(T x, vec2<T> v2)
>-{
>-    vec3<T> result;
>-    result.x = x;
>-    result.y = v2.x;
>-    result.z = v2.y;
>+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;
> }
>-
>-bool operator==<T:Equatable>(vec3<T> a, vec3<T> b)
>-{
>-    return a.x == b.x && a.y == b.y && a.z == b.z;
>+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;
> }
>-
>-thread T* operator&[]<T>(thread vec3<T>* foo, uint index)
>-{
>-    if (index == 0)
>-        return &foo->x;
>-    if (index == 1)
>-        return &foo->y;
>-    if (index == 2)
>-        return &foo->z;
>-    trap;
>+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;
> }
>-
>-struct vec4<T> {
>-    T x;
>-    T y;
>-    T z;
>-    T w;
>+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;
> }
>-
>-typedef int4 = vec4<int>;
>-typedef uint4 = vec4<uint>;
>-typedef float4 = vec4<float>;
>-
>-operator<T> vec4<T>(T x, T y, T z, T w)
>-{
>-    vec4<T> result;
>-    result.x = x;
>-    result.y = y;
>-    result.z = z;
>-    result.w = w;
>+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;
> }
>-
>-operator<T> vec4<T>(vec2<T> v2, T z, T w)
>-{
>-    vec4<T> result;
>-    result.x = v2.x;
>-    result.y = v2.y;
>-    result.z = z;
>-    result.w = w;
>+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;
> }
>-
>-operator<T> vec4<T>(T x, vec2<T> v2, T w)
>-{
>-    vec4<T> result;
>-    result.x = x;
>-    result.y = v2.x;
>-    result.z = v2.y;
>-    result.w = w;
>+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;
> }
>-
>-operator<T> vec4<T>(T x, T y, vec2<T> v2)
>-{
>-    vec4<T> result;
>-    result.x = x;
>-    result.y = y;
>-    result.z = v2.x;
>-    result.w = v2.y;
>+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;
> }
>-
>-operator<T> vec4<T>(vec2<T> v2a, vec2<T> v2b)
>-{
>-    vec4<T> result;
>-    result.x = v2a.x;
>-    result.y = v2a.y;
>-    result.z = v2b.x;
>-    result.w = v2b.y;
>+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;
> }
>-
>-operator<T> vec4<T>(vec3<T> v3, T w)
>-{
>-    vec4<T> result;
>-    result.x = v3.x;
>-    result.y = v3.y;
>-    result.z = v3.z;
>-    result.w = w;
>+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;
> }
>-
>-operator<T> vec4<T>(T x, vec3<T> v3)
>-{
>-    vec4<T> result;
>-    result.x = x;
>-    result.y = v3.x;
>-    result.z = v3.y;
>-    result.w = v3.z;
>+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;
> }
>-
>-bool operator==<T:Equatable>(vec4<T> a, vec4<T> b)
>-{
>-    return a.x == b.x && a.y == b.y && a.z == b.z && a.w == b.w;
>+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;
> }
>-
>-thread T* operator&[]<T>(thread vec4<T>* foo, uint index)
>-{
>-    if (index == 0)
>-        return &foo->x;
>-    if (index == 1)
>-        return &foo->y;
>-    if (index == 2)
>-        return &foo->z;
>-    if (index == 3)
>-        return &foo->w;
>-    trap;
>+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;
> }
>-
>-native thread T* operator&[]<T>(thread T[], uint);
>-native threadgroup T* operator&[]<T>(threadgroup T[], uint);
>-native device T* operator&[]<T>(device T[], uint);
>-native constant T* operator&[]<T>(constant T[], uint);
>-
>-native uint operator.length<T>(thread T[]);
>-native uint operator.length<T>(threadgroup T[]);
>-native uint operator.length<T>(device T[]);
>-native uint operator.length<T>(constant T[]);
>-
>-uint operator.length<T, uint length>(T[length])
>-{
>-    return length;
>+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][2] = 0;
>+    result[0][2] += x[0][0] * y[0][0];
>+    result[0][2] += x[0][1] * y[1][0];
>+    result[0][2] = 0;
>+    result[0][2] += x[0][0] * y[0][1];
>+    result[0][2] += x[0][1] * y[1][1];
>+    result[1][2] = 0;
>+    result[1][2] += x[1][0] * y[0][0];
>+    result[1][2] += x[1][1] * y[1][0];
>+    result[1][2] = 0;
>+    result[1][2] += x[1][0] * y[0][1];
>+    result[1][2] += x[1][1] * y[1][1];
>+    return result;
>+}
>+half2x3 mul(half2x2 x, half2x3 y) {
>+    half2x3 result;
>+    result[0][3] = 0;
>+    result[0][3] += x[0][0] * y[0][0];
>+    result[0][3] += x[0][1] * y[1][0];
>+    result[0][3] = 0;
>+    result[0][3] += x[0][0] * y[0][1];
>+    result[0][3] += x[0][1] * y[1][1];
>+    result[0][3] = 0;
>+    result[0][3] += x[0][0] * y[0][2];
>+    result[0][3] += x[0][1] * y[1][2];
>+    result[1][3] = 0;
>+    result[1][3] += x[1][0] * y[0][0];
>+    result[1][3] += x[1][1] * y[1][0];
>+    result[1][3] = 0;
>+    result[1][3] += x[1][0] * y[0][1];
>+    result[1][3] += x[1][1] * y[1][1];
>+    result[1][3] = 0;
>+    result[1][3] += x[1][0] * y[0][2];
>+    result[1][3] += x[1][1] * y[1][2];
>+    return result;
>+}
>+half2x4 mul(half2x2 x, half2x4 y) {
>+    half2x4 result;
>+    result[0][4] = 0;
>+    result[0][4] += x[0][0] * y[0][0];
>+    result[0][4] += x[0][1] * y[1][0];
>+    result[0][4] = 0;
>+    result[0][4] += x[0][0] * y[0][1];
>+    result[0][4] += x[0][1] * y[1][1];
>+    result[0][4] = 0;
>+    result[0][4] += x[0][0] * y[0][2];
>+    result[0][4] += x[0][1] * y[1][2];
>+    result[0][4] = 0;
>+    result[0][4] += x[0][0] * y[0][3];
>+    result[0][4] += x[0][1] * y[1][3];
>+    result[1][4] = 0;
>+    result[1][4] += x[1][0] * y[0][0];
>+    result[1][4] += x[1][1] * y[1][0];
>+    result[1][4] = 0;
>+    result[1][4] += x[1][0] * y[0][1];
>+    result[1][4] += x[1][1] * y[1][1];
>+    result[1][4] = 0;
>+    result[1][4] += x[1][0] * y[0][2];
>+    result[1][4] += x[1][1] * y[1][2];
>+    result[1][4] = 0;
>+    result[1][4] += x[1][0] * y[0][3];
>+    result[1][4] += x[1][1] * y[1][3];
>+    return result;
>+}
>+half2x2 mul(half2x3 x, half3x2 y) {
>+    half2x2 result;
>+    result[0][2] = 0;
>+    result[0][2] += x[0][0] * y[0][0];
>+    result[0][2] += x[0][1] * y[1][0];
>+    result[0][2] += x[0][2] * y[2][0];
>+    result[0][2] = 0;
>+    result[0][2] += x[0][0] * y[0][1];
>+    result[0][2] += x[0][1] * y[1][1];
>+    result[0][2] += x[0][2] * y[2][1];
>+    result[1][2] = 0;
>+    result[1][2] += x[1][0] * y[0][0];
>+    result[1][2] += x[1][1] * y[1][0];
>+    result[1][2] += x[1][2] * y[2][0];
>+    result[1][2] = 0;
>+    result[1][2] += x[1][0] * y[0][1];
>+    result[1][2] += x[1][1] * y[1][1];
>+    result[1][2] += x[1][2] * y[2][1];
>+    return result;
>+}
>+half2x3 mul(half2x3 x, half3x3 y) {
>+    half2x3 result;
>+    result[0][3] = 0;
>+    result[0][3] += x[0][0] * y[0][0];
>+    result[0][3] += x[0][1] * y[1][0];
>+    result[0][3] += x[0][2] * y[2][0];
>+    result[0][3] = 0;
>+    result[0][3] += x[0][0] * y[0][1];
>+    result[0][3] += x[0][1] * y[1][1];
>+    result[0][3] += x[0][2] * y[2][1];
>+    result[0][3] = 0;
>+    result[0][3] += x[0][0] * y[0][2];
>+    result[0][3] += x[0][1] * y[1][2];
>+    result[0][3] += x[0][2] * y[2][2];
>+    result[1][3] = 0;
>+    result[1][3] += x[1][0] * y[0][0];
>+    result[1][3] += x[1][1] * y[1][0];
>+    result[1][3] += x[1][2] * y[2][0];
>+    result[1][3] = 0;
>+    result[1][3] += x[1][0] * y[0][1];
>+    result[1][3] += x[1][1] * y[1][1];
>+    result[1][3] += x[1][2] * y[2][1];
>+    result[1][3] = 0;
>+    result[1][3] += x[1][0] * y[0][2];
>+    result[1][3] += x[1][1] * y[1][2];
>+    result[1][3] += x[1][2] * y[2][2];
>+    return result;
>+}
>+half2x4 mul(half2x3 x, half3x4 y) {
>+    half2x4 result;
>+    result[0][4] = 0;
>+    result[0][4] += x[0][0] * y[0][0];
>+    result[0][4] += x[0][1] * y[1][0];
>+    result[0][4] += x[0][2] * y[2][0];
>+    result[0][4] = 0;
>+    result[0][4] += x[0][0] * y[0][1];
>+    result[0][4] += x[0][1] * y[1][1];
>+    result[0][4] += x[0][2] * y[2][1];
>+    result[0][4] = 0;
>+    result[0][4] += x[0][0] * y[0][2];
>+    result[0][4] += x[0][1] * y[1][2];
>+    result[0][4] += x[0][2] * y[2][2];
>+    result[0][4] = 0;
>+    result[0][4] += x[0][0] * y[0][3];
>+    result[0][4] += x[0][1] * y[1][3];
>+    result[0][4] += x[0][2] * y[2][3];
>+    result[1][4] = 0;
>+    result[1][4] += x[1][0] * y[0][0];
>+    result[1][4] += x[1][1] * y[1][0];
>+    result[1][4] += x[1][2] * y[2][0];
>+    result[1][4] = 0;
>+    result[1][4] += x[1][0] * y[0][1];
>+    result[1][4] += x[1][1] * y[1][1];
>+    result[1][4] += x[1][2] * y[2][1];
>+    result[1][4] = 0;
>+    result[1][4] += x[1][0] * y[0][2];
>+    result[1][4] += x[1][1] * y[1][2];
>+    result[1][4] += x[1][2] * y[2][2];
>+    result[1][4] = 0;
>+    result[1][4] += x[1][0] * y[0][3];
>+    result[1][4] += x[1][1] * y[1][3];
>+    result[1][4] += x[1][2] * y[2][3];
>+    return result;
>+}
>+half2x2 mul(half2x4 x, half4x2 y) {
>+    half2x2 result;
>+    result[0][2] = 0;
>+    result[0][2] += x[0][0] * y[0][0];
>+    result[0][2] += x[0][1] * y[1][0];
>+    result[0][2] += x[0][2] * y[2][0];
>+    result[0][2] += x[0][3] * y[3][0];
>+    result[0][2] = 0;
>+    result[0][2] += x[0][0] * y[0][1];
>+    result[0][2] += x[0][1] * y[1][1];
>+    result[0][2] += x[0][2] * y[2][1];
>+    result[0][2] += x[0][3] * y[3][1];
>+    result[1][2] = 0;
>+    result[1][2] += x[1][0] * y[0][0];
>+    result[1][2] += x[1][1] * y[1][0];
>+    result[1][2] += x[1][2] * y[2][0];
>+    result[1][2] += x[1][3] * y[3][0];
>+    result[1][2] = 0;
>+    result[1][2] += x[1][0] * y[0][1];
>+    result[1][2] += x[1][1] * y[1][1];
>+    result[1][2] += x[1][2] * y[2][1];
>+    result[1][2] += x[1][3] * y[3][1];
>+    return result;
>+}
>+half2x3 mul(half2x4 x, half4x3 y) {
>+    half2x3 result;
>+    result[0][3] = 0;
>+    result[0][3] += x[0][0] * y[0][0];
>+    result[0][3] += x[0][1] * y[1][0];
>+    result[0][3] += x[0][2] * y[2][0];
>+    result[0][3] += x[0][3] * y[3][0];
>+    result[0][3] = 0;
>+    result[0][3] += x[0][0] * y[0][1];
>+    result[0][3] += x[0][1] * y[1][1];
>+    result[0][3] += x[0][2] * y[2][1];
>+    result[0][3] += x[0][3] * y[3][1];
>+    result[0][3] = 0;
>+    result[0][3] += x[0][0] * y[0][2];
>+    result[0][3] += x[0][1] * y[1][2];
>+    result[0][3] += x[0][2] * y[2][2];
>+    result[0][3] += x[0][3] * y[3][2];
>+    result[1][3] = 0;
>+    result[1][3] += x[1][0] * y[0][0];
>+    result[1][3] += x[1][1] * y[1][0];
>+    result[1][3] += x[1][2] * y[2][0];
>+    result[1][3] += x[1][3] * y[3][0];
>+    result[1][3] = 0;
>+    result[1][3] += x[1][0] * y[0][1];
>+    result[1][3] += x[1][1] * y[1][1];
>+    result[1][3] += x[1][2] * y[2][1];
>+    result[1][3] += x[1][3] * y[3][1];
>+    result[1][3] = 0;
>+    result[1][3] += x[1][0] * y[0][2];
>+    result[1][3] += x[1][1] * y[1][2];
>+    result[1][3] += x[1][2] * y[2][2];
>+    result[1][3] += x[1][3] * y[3][2];
>+    return result;
>+}
>+half2x4 mul(half2x4 x, half4x4 y) {
>+    half2x4 result;
>+    result[0][4] = 0;
>+    result[0][4] += x[0][0] * y[0][0];
>+    result[0][4] += x[0][1] * y[1][0];
>+    result[0][4] += x[0][2] * y[2][0];
>+    result[0][4] += x[0][3] * y[3][0];
>+    result[0][4] = 0;
>+    result[0][4] += x[0][0] * y[0][1];
>+    result[0][4] += x[0][1] * y[1][1];
>+    result[0][4] += x[0][2] * y[2][1];
>+    result[0][4] += x[0][3] * y[3][1];
>+    result[0][4] = 0;
>+    result[0][4] += x[0][0] * y[0][2];
>+    result[0][4] += x[0][1] * y[1][2];
>+    result[0][4] += x[0][2] * y[2][2];
>+    result[0][4] += x[0][3] * y[3][2];
>+    result[0][4] = 0;
>+    result[0][4] += x[0][0] * y[0][3];
>+    result[0][4] += x[0][1] * y[1][3];
>+    result[0][4] += x[0][2] * y[2][3];
>+    result[0][4] += x[0][3] * y[3][3];
>+    result[1][4] = 0;
>+    result[1][4] += x[1][0] * y[0][0];
>+    result[1][4] += x[1][1] * y[1][0];
>+    result[1][4] += x[1][2] * y[2][0];
>+    result[1][4] += x[1][3] * y[3][0];
>+    result[1][4] = 0;
>+    result[1][4] += x[1][0] * y[0][1];
>+    result[1][4] += x[1][1] * y[1][1];
>+    result[1][4] += x[1][2] * y[2][1];
>+    result[1][4] += x[1][3] * y[3][1];
>+    result[1][4] = 0;
>+    result[1][4] += x[1][0] * y[0][2];
>+    result[1][4] += x[1][1] * y[1][2];
>+    result[1][4] += x[1][2] * y[2][2];
>+    result[1][4] += x[1][3] * y[3][2];
>+    result[1][4] = 0;
>+    result[1][4] += x[1][0] * y[0][3];
>+    result[1][4] += x[1][1] * y[1][3];
>+    result[1][4] += x[1][2] * y[2][3];
>+    result[1][4] += x[1][3] * y[3][3];
>+    return result;
>+}
>+half3x2 mul(half3x2 x, half2x2 y) {
>+    half3x2 result;
>+    result[0][2] = 0;
>+    result[0][2] += x[0][0] * y[0][0];
>+    result[0][2] += x[0][1] * y[1][0];
>+    result[0][2] = 0;
>+    result[0][2] += x[0][0] * y[0][1];
>+    result[0][2] += x[0][1] * y[1][1];
>+    result[1][2] = 0;
>+    result[1][2] += x[1][0] * y[0][0];
>+    result[1][2] += x[1][1] * y[1][0];
>+    result[1][2] = 0;
>+    result[1][2] += x[1][0] * y[0][1];
>+    result[1][2] += x[1][1] * y[1][1];
>+    result[2][2] = 0;
>+    result[2][2] += x[2][0] * y[0][0];
>+    result[2][2] += x[2][1] * y[1][0];
>+    result[2][2] = 0;
>+    result[2][2] += x[2][0] * y[0][1];
>+    result[2][2] += x[2][1] * y[1][1];
>+    return result;
>+}
>+half3x3 mul(half3x2 x, half2x3 y) {
>+    half3x3 result;
>+    result[0][3] = 0;
>+    result[0][3] += x[0][0] * y[0][0];
>+    result[0][3] += x[0][1] * y[1][0];
>+    result[0][3] = 0;
>+    result[0][3] += x[0][0] * y[0][1];
>+    result[0][3] += x[0][1] * y[1][1];
>+    result[0][3] = 0;
>+    result[0][3] += x[0][0] * y[0][2];
>+    result[0][3] += x[0][1] * y[1][2];
>+    result[1][3] = 0;
>+    result[1][3] += x[1][0] * y[0][0];
>+    result[1][3] += x[1][1] * y[1][0];
>+    result[1][3] = 0;
>+    result[1][3] += x[1][0] * y[0][1];
>+    result[1][3] += x[1][1] * y[1][1];
>+    result[1][3] = 0;
>+    result[1][3] += x[1][0] * y[0][2];
>+    result[1][3] += x[1][1] * y[1][2];
>+    result[2][3] = 0;
>+    result[2][3] += x[2][0] * y[0][0];
>+    result[2][3] += x[2][1] * y[1][0];
>+    result[2][3] = 0;
>+    result[2][3] += x[2][0] * y[0][1];
>+    result[2][3] += x[2][1] * y[1][1];
>+    result[2][3] = 0;
>+    result[2][3] += x[2][0] * y[0][2];
>+    result[2][3] += x[2][1] * y[1][2];
>+    return result;
>+}
>+half3x4 mul(half3x2 x, half2x4 y) {
>+    half3x4 result;
>+    result[0][4] = 0;
>+    result[0][4] += x[0][0] * y[0][0];
>+    result[0][4] += x[0][1] * y[1][0];
>+    result[0][4] = 0;
>+    result[0][4] += x[0][0] * y[0][1];
>+    result[0][4] += x[0][1] * y[1][1];
>+    result[0][4] = 0;
>+    result[0][4] += x[0][0] * y[0][2];
>+    result[0][4] += x[0][1] * y[1][2];
>+    result[0][4] = 0;
>+    result[0][4] += x[0][0] * y[0][3];
>+    result[0][4] += x[0][1] * y[1][3];
>+    result[1][4] = 0;
>+    result[1][4] += x[1][0] * y[0][0];
>+    result[1][4] += x[1][1] * y[1][0];
>+    result[1][4] = 0;
>+    result[1][4] += x[1][0] * y[0][1];
>+    result[1][4] += x[1][1] * y[1][1];
>+    result[1][4] = 0;
>+    result[1][4] += x[1][0] * y[0][2];
>+    result[1][4] += x[1][1] * y[1][2];
>+    result[1][4] = 0;
>+    result[1][4] += x[1][0] * y[0][3];
>+    result[1][4] += x[1][1] * y[1][3];
>+    result[2][4] = 0;
>+    result[2][4] += x[2][0] * y[0][0];
>+    result[2][4] += x[2][1] * y[1][0];
>+    result[2][4] = 0;
>+    result[2][4] += x[2][0] * y[0][1];
>+    result[2][4] += x[2][1] * y[1][1];
>+    result[2][4] = 0;
>+    result[2][4] += x[2][0] * y[0][2];
>+    result[2][4] += x[2][1] * y[1][2];
>+    result[2][4] = 0;
>+    result[2][4] += x[2][0] * y[0][3];
>+    result[2][4] += x[2][1] * y[1][3];
>+    return result;
>+}
>+half3x2 mul(half3x3 x, half3x2 y) {
>+    half3x2 result;
>+    result[0][2] = 0;
>+    result[0][2] += x[0][0] * y[0][0];
>+    result[0][2] += x[0][1] * y[1][0];
>+    result[0][2] += x[0][2] * y[2][0];
>+    result[0][2] = 0;
>+    result[0][2] += x[0][0] * y[0][1];
>+    result[0][2] += x[0][1] * y[1][1];
>+    result[0][2] += x[0][2] * y[2][1];
>+    result[1][2] = 0;
>+    result[1][2] += x[1][0] * y[0][0];
>+    result[1][2] += x[1][1] * y[1][0];
>+    result[1][2] += x[1][2] * y[2][0];
>+    result[1][2] = 0;
>+    result[1][2] += x[1][0] * y[0][1];
>+    result[1][2] += x[1][1] * y[1][1];
>+    result[1][2] += x[1][2] * y[2][1];
>+    result[2][2] = 0;
>+    result[2][2] += x[2][0] * y[0][0];
>+    result[2][2] += x[2][1] * y[1][0];
>+    result[2][2] += x[2][2] * y[2][0];
>+    result[2][2] = 0;
>+    result[2][2] += x[2][0] * y[0][1];
>+    result[2][2] += x[2][1] * y[1][1];
>+    result[2][2] += x[2][2] * y[2][1];
>+    return result;
>+}
>+half3x3 mul(half3x3 x, half3x3 y) {
>+    half3x3 result;
>+    result[0][3] = 0;
>+    result[0][3] += x[0][0] * y[0][0];
>+    result[0][3] += x[0][1] * y[1][0];
>+    result[0][3] += x[0][2] * y[2][0];
>+    result[0][3] = 0;
>+    result[0][3] += x[0][0] * y[0][1];
>+    result[0][3] += x[0][1] * y[1][1];
>+    result[0][3] += x[0][2] * y[2][1];
>+    result[0][3] = 0;
>+    result[0][3] += x[0][0] * y[0][2];
>+    result[0][3] += x[0][1] * y[1][2];
>+    result[0][3] += x[0][2] * y[2][2];
>+    result[1][3] = 0;
>+    result[1][3] += x[1][0] * y[0][0];
>+    result[1][3] += x[1][1] * y[1][0];
>+    result[1][3] += x[1][2] * y[2][0];
>+    result[1][3] = 0;
>+    result[1][3] += x[1][0] * y[0][1];
>+    result[1][3] += x[1][1] * y[1][1];
>+    result[1][3] += x[1][2] * y[2][1];
>+    result[1][3] = 0;
>+    result[1][3] += x[1][0] * y[0][2];
>+    result[1][3] += x[1][1] * y[1][2];
>+    result[1][3] += x[1][2] * y[2][2];
>+    result[2][3] = 0;
>+    result[2][3] += x[2][0] * y[0][0];
>+    result[2][3] += x[2][1] * y[1][0];
>+    result[2][3] += x[2][2] * y[2][0];
>+    result[2][3] = 0;
>+    result[2][3] += x[2][0] * y[0][1];
>+    result[2][3] += x[2][1] * y[1][1];
>+    result[2][3] += x[2][2] * y[2][1];
>+    result[2][3] = 0;
>+    result[2][3] += x[2][0] * y[0][2];
>+    result[2][3] += x[2][1] * y[1][2];
>+    result[2][3] += x[2][2] * y[2][2];
>+    return result;
>+}
>+half3x4 mul(half3x3 x, half3x4 y) {
>+    half3x4 result;
>+    result[0][4] = 0;
>+    result[0][4] += x[0][0] * y[0][0];
>+    result[0][4] += x[0][1] * y[1][0];
>+    result[0][4] += x[0][2] * y[2][0];
>+    result[0][4] = 0;
>+    result[0][4] += x[0][0] * y[0][1];
>+    result[0][4] += x[0][1] * y[1][1];
>+    result[0][4] += x[0][2] * y[2][1];
>+    result[0][4] = 0;
>+    result[0][4] += x[0][0] * y[0][2];
>+    result[0][4] += x[0][1] * y[1][2];
>+    result[0][4] += x[0][2] * y[2][2];
>+    result[0][4] = 0;
>+    result[0][4] += x[0][0] * y[0][3];
>+    result[0][4] += x[0][1] * y[1][3];
>+    result[0][4] += x[0][2] * y[2][3];
>+    result[1][4] = 0;
>+    result[1][4] += x[1][0] * y[0][0];
>+    result[1][4] += x[1][1] * y[1][0];
>+    result[1][4] += x[1][2] * y[2][0];
>+    result[1][4] = 0;
>+    result[1][4] += x[1][0] * y[0][1];
>+    result[1][4] += x[1][1] * y[1][1];
>+    result[1][4] += x[1][2] * y[2][1];
>+    result[1][4] = 0;
>+    result[1][4] += x[1][0] * y[0][2];
>+    result[1][4] += x[1][1] * y[1][2];
>+    result[1][4] += x[1][2] * y[2][2];
>+    result[1][4] = 0;
>+    result[1][4] += x[1][0] * y[0][3];
>+    result[1][4] += x[1][1] * y[1][3];
>+    result[1][4] += x[1][2] * y[2][3];
>+    result[2][4] = 0;
>+    result[2][4] += x[2][0] * y[0][0];
>+    result[2][4] += x[2][1] * y[1][0];
>+    result[2][4] += x[2][2] * y[2][0];
>+    result[2][4] = 0;
>+    result[2][4] += x[2][0] * y[0][1];
>+    result[2][4] += x[2][1] * y[1][1];
>+    result[2][4] += x[2][2] * y[2][1];
>+    result[2][4] = 0;
>+    result[2][4] += x[2][0] * y[0][2];
>+    result[2][4] += x[2][1] * y[1][2];
>+    result[2][4] += x[2][2] * y[2][2];
>+    result[2][4] = 0;
>+    result[2][4] += x[2][0] * y[0][3];
>+    result[2][4] += x[2][1] * y[1][3];
>+    result[2][4] += x[2][2] * y[2][3];
>+    return result;
>+}
>+half3x2 mul(half3x4 x, half4x2 y) {
>+    half3x2 result;
>+    result[0][2] = 0;
>+    result[0][2] += x[0][0] * y[0][0];
>+    result[0][2] += x[0][1] * y[1][0];
>+    result[0][2] += x[0][2] * y[2][0];
>+    result[0][2] += x[0][3] * y[3][0];
>+    result[0][2] = 0;
>+    result[0][2] += x[0][0] * y[0][1];
>+    result[0][2] += x[0][1] * y[1][1];
>+    result[0][2] += x[0][2] * y[2][1];
>+    result[0][2] += x[0][3] * y[3][1];
>+    result[1][2] = 0;
>+    result[1][2] += x[1][0] * y[0][0];
>+    result[1][2] += x[1][1] * y[1][0];
>+    result[1][2] += x[1][2] * y[2][0];
>+    result[1][2] += x[1][3] * y[3][0];
>+    result[1][2] = 0;
>+    result[1][2] += x[1][0] * y[0][1];
>+    result[1][2] += x[1][1] * y[1][1];
>+    result[1][2] += x[1][2] * y[2][1];
>+    result[1][2] += x[1][3] * y[3][1];
>+    result[2][2] = 0;
>+    result[2][2] += x[2][0] * y[0][0];
>+    result[2][2] += x[2][1] * y[1][0];
>+    result[2][2] += x[2][2] * y[2][0];
>+    result[2][2] += x[2][3] * y[3][0];
>+    result[2][2] = 0;
>+    result[2][2] += x[2][0] * y[0][1];
>+    result[2][2] += x[2][1] * y[1][1];
>+    result[2][2] += x[2][2] * y[2][1];
>+    result[2][2] += x[2][3] * y[3][1];
>+    return result;
>+}
>+half3x3 mul(half3x4 x, half4x3 y) {
>+    half3x3 result;
>+    result[0][3] = 0;
>+    result[0][3] += x[0][0] * y[0][0];
>+    result[0][3] += x[0][1] * y[1][0];
>+    result[0][3] += x[0][2] * y[2][0];
>+    result[0][3] += x[0][3] * y[3][0];
>+    result[0][3] = 0;
>+    result[0][3] += x[0][0] * y[0][1];
>+    result[0][3] += x[0][1] * y[1][1];
>+    result[0][3] += x[0][2] * y[2][1];
>+    result[0][3] += x[0][3] * y[3][1];
>+    result[0][3] = 0;
>+    result[0][3] += x[0][0] * y[0][2];
>+    result[0][3] += x[0][1] * y[1][2];
>+    result[0][3] += x[0][2] * y[2][2];
>+    result[0][3] += x[0][3] * y[3][2];
>+    result[1][3] = 0;
>+    result[1][3] += x[1][0] * y[0][0];
>+    result[1][3] += x[1][1] * y[1][0];
>+    result[1][3] += x[1][2] * y[2][0];
>+    result[1][3] += x[1][3] * y[3][0];
>+    result[1][3] = 0;
>+    result[1][3] += x[1][0] * y[0][1];
>+    result[1][3] += x[1][1] * y[1][1];
>+    result[1][3] += x[1][2] * y[2][1];
>+    result[1][3] += x[1][3] * y[3][1];
>+    result[1][3] = 0;
>+    result[1][3] += x[1][0] * y[0][2];
>+    result[1][3] += x[1][1] * y[1][2];
>+    result[1][3] += x[1][2] * y[2][2];
>+    result[1][3] += x[1][3] * y[3][2];
>+    result[2][3] = 0;
>+    result[2][3] += x[2][0] * y[0][0];
>+    result[2][3] += x[2][1] * y[1][0];
>+    result[2][3] += x[2][2] * y[2][0];
>+    result[2][3] += x[2][3] * y[3][0];
>+    result[2][3] = 0;
>+    result[2][3] += x[2][0] * y[0][1];
>+    result[2][3] += x[2][1] * y[1][1];
>+    result[2][3] += x[2][2] * y[2][1];
>+    result[2][3] += x[2][3] * y[3][1];
>+    result[2][3] = 0;
>+    result[2][3] += x[2][0] * y[0][2];
>+    result[2][3] += x[2][1] * y[1][2];
>+    result[2][3] += x[2][2] * y[2][2];
>+    result[2][3] += x[2][3] * y[3][2];
>+    return result;
>+}
>+half3x4 mul(half3x4 x, half4x4 y) {
>+    half3x4 result;
>+    result[0][4] = 0;
>+    result[0][4] += x[0][0] * y[0][0];
>+    result[0][4] += x[0][1] * y[1][0];
>+    result[0][4] += x[0][2] * y[2][0];
>+    result[0][4] += x[0][3] * y[3][0];
>+    result[0][4] = 0;
>+    result[0][4] += x[0][0] * y[0][1];
>+    result[0][4] += x[0][1] * y[1][1];
>+    result[0][4] += x[0][2] * y[2][1];
>+    result[0][4] += x[0][3] * y[3][1];
>+    result[0][4] = 0;
>+    result[0][4] += x[0][0] * y[0][2];
>+    result[0][4] += x[0][1] * y[1][2];
>+    result[0][4] += x[0][2] * y[2][2];
>+    result[0][4] += x[0][3] * y[3][2];
>+    result[0][4] = 0;
>+    result[0][4] += x[0][0] * y[0][3];
>+    result[0][4] += x[0][1] * y[1][3];
>+    result[0][4] += x[0][2] * y[2][3];
>+    result[0][4] += x[0][3] * y[3][3];
>+    result[1][4] = 0;
>+    result[1][4] += x[1][0] * y[0][0];
>+    result[1][4] += x[1][1] * y[1][0];
>+    result[1][4] += x[1][2] * y[2][0];
>+    result[1][4] += x[1][3] * y[3][0];
>+    result[1][4] = 0;
>+    result[1][4] += x[1][0] * y[0][1];
>+    result[1][4] += x[1][1] * y[1][1];
>+    result[1][4] += x[1][2] * y[2][1];
>+    result[1][4] += x[1][3] * y[3][1];
>+    result[1][4] = 0;
>+    result[1][4] += x[1][0] * y[0][2];
>+    result[1][4] += x[1][1] * y[1][2];
>+    result[1][4] += x[1][2] * y[2][2];
>+    result[1][4] += x[1][3] * y[3][2];
>+    result[1][4] = 0;
>+    result[1][4] += x[1][0] * y[0][3];
>+    result[1][4] += x[1][1] * y[1][3];
>+    result[1][4] += x[1][2] * y[2][3];
>+    result[1][4] += x[1][3] * y[3][3];
>+    result[2][4] = 0;
>+    result[2][4] += x[2][0] * y[0][0];
>+    result[2][4] += x[2][1] * y[1][0];
>+    result[2][4] += x[2][2] * y[2][0];
>+    result[2][4] += x[2][3] * y[3][0];
>+    result[2][4] = 0;
>+    result[2][4] += x[2][0] * y[0][1];
>+    result[2][4] += x[2][1] * y[1][1];
>+    result[2][4] += x[2][2] * y[2][1];
>+    result[2][4] += x[2][3] * y[3][1];
>+    result[2][4] = 0;
>+    result[2][4] += x[2][0] * y[0][2];
>+    result[2][4] += x[2][1] * y[1][2];
>+    result[2][4] += x[2][2] * y[2][2];
>+    result[2][4] += x[2][3] * y[3][2];
>+    result[2][4] = 0;
>+    result[2][4] += x[2][0] * y[0][3];
>+    result[2][4] += x[2][1] * y[1][3];
>+    result[2][4] += x[2][2] * y[2][3];
>+    result[2][4] += x[2][3] * y[3][3];
>+    return result;
>+}
>+half4x2 mul(half4x2 x, half2x2 y) {
>+    half4x2 result;
>+    result[0][2] = 0;
>+    result[0][2] += x[0][0] * y[0][0];
>+    result[0][2] += x[0][1] * y[1][0];
>+    result[0][2] = 0;
>+    result[0][2] += x[0][0] * y[0][1];
>+    result[0][2] += x[0][1] * y[1][1];
>+    result[1][2] = 0;
>+    result[1][2] += x[1][0] * y[0][0];
>+    result[1][2] += x[1][1] * y[1][0];
>+    result[1][2] = 0;
>+    result[1][2] += x[1][0] * y[0][1];
>+    result[1][2] += x[1][1] * y[1][1];
>+    result[2][2] = 0;
>+    result[2][2] += x[2][0] * y[0][0];
>+    result[2][2] += x[2][1] * y[1][0];
>+    result[2][2] = 0;
>+    result[2][2] += x[2][0] * y[0][1];
>+    result[2][2] += x[2][1] * y[1][1];
>+    result[3][2] = 0;
>+    result[3][2] += x[3][0] * y[0][0];
>+    result[3][2] += x[3][1] * y[1][0];
>+    result[3][2] = 0;
>+    result[3][2] += x[3][0] * y[0][1];
>+    result[3][2] += x[3][1] * y[1][1];
>+    return result;
>+}
>+half4x3 mul(half4x2 x, half2x3 y) {
>+    half4x3 result;
>+    result[0][3] = 0;
>+    result[0][3] += x[0][0] * y[0][0];
>+    result[0][3] += x[0][1] * y[1][0];
>+    result[0][3] = 0;
>+    result[0][3] += x[0][0] * y[0][1];
>+    result[0][3] += x[0][1] * y[1][1];
>+    result[0][3] = 0;
>+    result[0][3] += x[0][0] * y[0][2];
>+    result[0][3] += x[0][1] * y[1][2];
>+    result[1][3] = 0;
>+    result[1][3] += x[1][0] * y[0][0];
>+    result[1][3] += x[1][1] * y[1][0];
>+    result[1][3] = 0;
>+    result[1][3] += x[1][0] * y[0][1];
>+    result[1][3] += x[1][1] * y[1][1];
>+    result[1][3] = 0;
>+    result[1][3] += x[1][0] * y[0][2];
>+    result[1][3] += x[1][1] * y[1][2];
>+    result[2][3] = 0;
>+    result[2][3] += x[2][0] * y[0][0];
>+    result[2][3] += x[2][1] * y[1][0];
>+    result[2][3] = 0;
>+    result[2][3] += x[2][0] * y[0][1];
>+    result[2][3] += x[2][1] * y[1][1];
>+    result[2][3] = 0;
>+    result[2][3] += x[2][0] * y[0][2];
>+    result[2][3] += x[2][1] * y[1][2];
>+    result[3][3] = 0;
>+    result[3][3] += x[3][0] * y[0][0];
>+    result[3][3] += x[3][1] * y[1][0];
>+    result[3][3] = 0;
>+    result[3][3] += x[3][0] * y[0][1];
>+    result[3][3] += x[3][1] * y[1][1];
>+    result[3][3] = 0;
>+    result[3][3] += x[3][0] * y[0][2];
>+    result[3][3] += x[3][1] * y[1][2];
>+    return result;
>+}
>+half4x4 mul(half4x2 x, half2x4 y) {
>+    half4x4 result;
>+    result[0][4] = 0;
>+    result[0][4] += x[0][0] * y[0][0];
>+    result[0][4] += x[0][1] * y[1][0];
>+    result[0][4] = 0;
>+    result[0][4] += x[0][0] * y[0][1];
>+    result[0][4] += x[0][1] * y[1][1];
>+    result[0][4] = 0;
>+    result[0][4] += x[0][0] * y[0][2];
>+    result[0][4] += x[0][1] * y[1][2];
>+    result[0][4] = 0;
>+    result[0][4] += x[0][0] * y[0][3];
>+    result[0][4] += x[0][1] * y[1][3];
>+    result[1][4] = 0;
>+    result[1][4] += x[1][0] * y[0][0];
>+    result[1][4] += x[1][1] * y[1][0];
>+    result[1][4] = 0;
>+    result[1][4] += x[1][0] * y[0][1];
>+    result[1][4] += x[1][1] * y[1][1];
>+    result[1][4] = 0;
>+    result[1][4] += x[1][0] * y[0][2];
>+    result[1][4] += x[1][1] * y[1][2];
>+    result[1][4] = 0;
>+    result[1][4] += x[1][0] * y[0][3];
>+    result[1][4] += x[1][1] * y[1][3];
>+    result[2][4] = 0;
>+    result[2][4] += x[2][0] * y[0][0];
>+    result[2][4] += x[2][1] * y[1][0];
>+    result[2][4] = 0;
>+    result[2][4] += x[2][0] * y[0][1];
>+    result[2][4] += x[2][1] * y[1][1];
>+    result[2][4] = 0;
>+    result[2][4] += x[2][0] * y[0][2];
>+    result[2][4] += x[2][1] * y[1][2];
>+    result[2][4] = 0;
>+    result[2][4] += x[2][0] * y[0][3];
>+    result[2][4] += x[2][1] * y[1][3];
>+    result[3][4] = 0;
>+    result[3][4] += x[3][0] * y[0][0];
>+    result[3][4] += x[3][1] * y[1][0];
>+    result[3][4] = 0;
>+    result[3][4] += x[3][0] * y[0][1];
>+    result[3][4] += x[3][1] * y[1][1];
>+    result[3][4] = 0;
>+    result[3][4] += x[3][0] * y[0][2];
>+    result[3][4] += x[3][1] * y[1][2];
>+    result[3][4] = 0;
>+    result[3][4] += x[3][0] * y[0][3];
>+    result[3][4] += x[3][1] * y[1][3];
>+    return result;
>+}
>+half4x2 mul(half4x3 x, half3x2 y) {
>+    half4x2 result;
>+    result[0][2] = 0;
>+    result[0][2] += x[0][0] * y[0][0];
>+    result[0][2] += x[0][1] * y[1][0];
>+    result[0][2] += x[0][2] * y[2][0];
>+    result[0][2] = 0;
>+    result[0][2] += x[0][0] * y[0][1];
>+    result[0][2] += x[0][1] * y[1][1];
>+    result[0][2] += x[0][2] * y[2][1];
>+    result[1][2] = 0;
>+    result[1][2] += x[1][0] * y[0][0];
>+    result[1][2] += x[1][1] * y[1][0];
>+    result[1][2] += x[1][2] * y[2][0];
>+    result[1][2] = 0;
>+    result[1][2] += x[1][0] * y[0][1];
>+    result[1][2] += x[1][1] * y[1][1];
>+    result[1][2] += x[1][2] * y[2][1];
>+    result[2][2] = 0;
>+    result[2][2] += x[2][0] * y[0][0];
>+    result[2][2] += x[2][1] * y[1][0];
>+    result[2][2] += x[2][2] * y[2][0];
>+    result[2][2] = 0;
>+    result[2][2] += x[2][0] * y[0][1];
>+    result[2][2] += x[2][1] * y[1][1];
>+    result[2][2] += x[2][2] * y[2][1];
>+    result[3][2] = 0;
>+    result[3][2] += x[3][0] * y[0][0];
>+    result[3][2] += x[3][1] * y[1][0];
>+    result[3][2] += x[3][2] * y[2][0];
>+    result[3][2] = 0;
>+    result[3][2] += x[3][0] * y[0][1];
>+    result[3][2] += x[3][1] * y[1][1];
>+    result[3][2] += x[3][2] * y[2][1];
>+    return result;
>+}
>+half4x3 mul(half4x3 x, half3x3 y) {
>+    half4x3 result;
>+    result[0][3] = 0;
>+    result[0][3] += x[0][0] * y[0][0];
>+    result[0][3] += x[0][1] * y[1][0];
>+    result[0][3] += x[0][2] * y[2][0];
>+    result[0][3] = 0;
>+    result[0][3] += x[0][0] * y[0][1];
>+    result[0][3] += x[0][1] * y[1][1];
>+    result[0][3] += x[0][2] * y[2][1];
>+    result[0][3] = 0;
>+    result[0][3] += x[0][0] * y[0][2];
>+    result[0][3] += x[0][1] * y[1][2];
>+    result[0][3] += x[0][2] * y[2][2];
>+    result[1][3] = 0;
>+    result[1][3] += x[1][0] * y[0][0];
>+    result[1][3] += x[1][1] * y[1][0];
>+    result[1][3] += x[1][2] * y[2][0];
>+    result[1][3] = 0;
>+    result[1][3] += x[1][0] * y[0][1];
>+    result[1][3] += x[1][1] * y[1][1];
>+    result[1][3] += x[1][2] * y[2][1];
>+    result[1][3] = 0;
>+    result[1][3] += x[1][0] * y[0][2];
>+    result[1][3] += x[1][1] * y[1][2];
>+    result[1][3] += x[1][2] * y[2][2];
>+    result[2][3] = 0;
>+    result[2][3] += x[2][0] * y[0][0];
>+    result[2][3] += x[2][1] * y[1][0];
>+    result[2][3] += x[2][2] * y[2][0];
>+    result[2][3] = 0;
>+    result[2][3] += x[2][0] * y[0][1];
>+    result[2][3] += x[2][1] * y[1][1];
>+    result[2][3] += x[2][2] * y[2][1];
>+    result[2][3] = 0;
>+    result[2][3] += x[2][0] * y[0][2];
>+    result[2][3] += x[2][1] * y[1][2];
>+    result[2][3] += x[2][2] * y[2][2];
>+    result[3][3] = 0;
>+    result[3][3] += x[3][0] * y[0][0];
>+    result[3][3] += x[3][1] * y[1][0];
>+    result[3][3] += x[3][2] * y[2][0];
>+    result[3][3] = 0;
>+    result[3][3] += x[3][0] * y[0][1];
>+    result[3][3] += x[3][1] * y[1][1];
>+    result[3][3] += x[3][2] * y[2][1];
>+    result[3][3] = 0;
>+    result[3][3] += x[3][0] * y[0][2];
>+    result[3][3] += x[3][1] * y[1][2];
>+    result[3][3] += x[3][2] * y[2][2];
>+    return result;
>+}
>+half4x4 mul(half4x3 x, half3x4 y) {
>+    half4x4 result;
>+    result[0][4] = 0;
>+    result[0][4] += x[0][0] * y[0][0];
>+    result[0][4] += x[0][1] * y[1][0];
>+    result[0][4] += x[0][2] * y[2][0];
>+    result[0][4] = 0;
>+    result[0][4] += x[0][0] * y[0][1];
>+    result[0][4] += x[0][1] * y[1][1];
>+    result[0][4] += x[0][2] * y[2][1];
>+    result[0][4] = 0;
>+    result[0][4] += x[0][0] * y[0][2];
>+    result[0][4] += x[0][1] * y[1][2];
>+    result[0][4] += x[0][2] * y[2][2];
>+    result[0][4] = 0;
>+    result[0][4] += x[0][0] * y[0][3];
>+    result[0][4] += x[0][1] * y[1][3];
>+    result[0][4] += x[0][2] * y[2][3];
>+    result[1][4] = 0;
>+    result[1][4] += x[1][0] * y[0][0];
>+    result[1][4] += x[1][1] * y[1][0];
>+    result[1][4] += x[1][2] * y[2][0];
>+    result[1][4] = 0;
>+    result[1][4] += x[1][0] * y[0][1];
>+    result[1][4] += x[1][1] * y[1][1];
>+    result[1][4] += x[1][2] * y[2][1];
>+    result[1][4] = 0;
>+    result[1][4] += x[1][0] * y[0][2];
>+    result[1][4] += x[1][1] * y[1][2];
>+    result[1][4] += x[1][2] * y[2][2];
>+    result[1][4] = 0;
>+    result[1][4] += x[1][0] * y[0][3];
>+    result[1][4] += x[1][1] * y[1][3];
>+    result[1][4] += x[1][2] * y[2][3];
>+    result[2][4] = 0;
>+    result[2][4] += x[2][0] * y[0][0];
>+    result[2][4] += x[2][1] * y[1][0];
>+    result[2][4] += x[2][2] * y[2][0];
>+    result[2][4] = 0;
>+    result[2][4] += x[2][0] * y[0][1];
>+    result[2][4] += x[2][1] * y[1][1];
>+    result[2][4] += x[2][2] * y[2][1];
>+    result[2][4] = 0;
>+    result[2][4] += x[2][0] * y[0][2];
>+    result[2][4] += x[2][1] * y[1][2];
>+    result[2][4] += x[2][2] * y[2][2];
>+    result[2][4] = 0;
>+    result[2][4] += x[2][0] * y[0][3];
>+    result[2][4] += x[2][1] * y[1][3];
>+    result[2][4] += x[2][2] * y[2][3];
>+    result[3][4] = 0;
>+    result[3][4] += x[3][0] * y[0][0];
>+    result[3][4] += x[3][1] * y[1][0];
>+    result[3][4] += x[3][2] * y[2][0];
>+    result[3][4] = 0;
>+    result[3][4] += x[3][0] * y[0][1];
>+    result[3][4] += x[3][1] * y[1][1];
>+    result[3][4] += x[3][2] * y[2][1];
>+    result[3][4] = 0;
>+    result[3][4] += x[3][0] * y[0][2];
>+    result[3][4] += x[3][1] * y[1][2];
>+    result[3][4] += x[3][2] * y[2][2];
>+    result[3][4] = 0;
>+    result[3][4] += x[3][0] * y[0][3];
>+    result[3][4] += x[3][1] * y[1][3];
>+    result[3][4] += x[3][2] * y[2][3];
>+    return result;
>+}
>+half4x2 mul(half4x4 x, half4x2 y) {
>+    half4x2 result;
>+    result[0][2] = 0;
>+    result[0][2] += x[0][0] * y[0][0];
>+    result[0][2] += x[0][1] * y[1][0];
>+    result[0][2] += x[0][2] * y[2][0];
>+    result[0][2] += x[0][3] * y[3][0];
>+    result[0][2] = 0;
>+    result[0][2] += x[0][0] * y[0][1];
>+    result[0][2] += x[0][1] * y[1][1];
>+    result[0][2] += x[0][2] * y[2][1];
>+    result[0][2] += x[0][3] * y[3][1];
>+    result[1][2] = 0;
>+    result[1][2] += x[1][0] * y[0][0];
>+    result[1][2] += x[1][1] * y[1][0];
>+    result[1][2] += x[1][2] * y[2][0];
>+    result[1][2] += x[1][3] * y[3][0];
>+    result[1][2] = 0;
>+    result[1][2] += x[1][0] * y[0][1];
>+    result[1][2] += x[1][1] * y[1][1];
>+    result[1][2] += x[1][2] * y[2][1];
>+    result[1][2] += x[1][3] * y[3][1];
>+    result[2][2] = 0;
>+    result[2][2] += x[2][0] * y[0][0];
>+    result[2][2] += x[2][1] * y[1][0];
>+    result[2][2] += x[2][2] * y[2][0];
>+    result[2][2] += x[2][3] * y[3][0];
>+    result[2][2] = 0;
>+    result[2][2] += x[2][0] * y[0][1];
>+    result[2][2] += x[2][1] * y[1][1];
>+    result[2][2] += x[2][2] * y[2][1];
>+    result[2][2] += x[2][3] * y[3][1];
>+    result[3][2] = 0;
>+    result[3][2] += x[3][0] * y[0][0];
>+    result[3][2] += x[3][1] * y[1][0];
>+    result[3][2] += x[3][2] * y[2][0];
>+    result[3][2] += x[3][3] * y[3][0];
>+    result[3][2] = 0;
>+    result[3][2] += x[3][0] * y[0][1];
>+    result[3][2] += x[3][1] * y[1][1];
>+    result[3][2] += x[3][2] * y[2][1];
>+    result[3][2] += x[3][3] * y[3][1];
>+    return result;
>+}
>+half4x3 mul(half4x4 x, half4x3 y) {
>+    half4x3 result;
>+    result[0][3] = 0;
>+    result[0][3] += x[0][0] * y[0][0];
>+    result[0][3] += x[0][1] * y[1][0];
>+    result[0][3] += x[0][2] * y[2][0];
>+    result[0][3] += x[0][3] * y[3][0];
>+    result[0][3] = 0;
>+    result[0][3] += x[0][0] * y[0][1];
>+    result[0][3] += x[0][1] * y[1][1];
>+    result[0][3] += x[0][2] * y[2][1];
>+    result[0][3] += x[0][3] * y[3][1];
>+    result[0][3] = 0;
>+    result[0][3] += x[0][0] * y[0][2];
>+    result[0][3] += x[0][1] * y[1][2];
>+    result[0][3] += x[0][2] * y[2][2];
>+    result[0][3] += x[0][3] * y[3][2];
>+    result[1][3] = 0;
>+    result[1][3] += x[1][0] * y[0][0];
>+    result[1][3] += x[1][1] * y[1][0];
>+    result[1][3] += x[1][2] * y[2][0];
>+    result[1][3] += x[1][3] * y[3][0];
>+    result[1][3] = 0;
>+    result[1][3] += x[1][0] * y[0][1];
>+    result[1][3] += x[1][1] * y[1][1];
>+    result[1][3] += x[1][2] * y[2][1];
>+    result[1][3] += x[1][3] * y[3][1];
>+    result[1][3] = 0;
>+    result[1][3] += x[1][0] * y[0][2];
>+    result[1][3] += x[1][1] * y[1][2];
>+    result[1][3] += x[1][2] * y[2][2];
>+    result[1][3] += x[1][3] * y[3][2];
>+    result[2][3] = 0;
>+    result[2][3] += x[2][0] * y[0][0];
>+    result[2][3] += x[2][1] * y[1][0];
>+    result[2][3] += x[2][2] * y[2][0];
>+    result[2][3] += x[2][3] * y[3][0];
>+    result[2][3] = 0;
>+    result[2][3] += x[2][0] * y[0][1];
>+    result[2][3] += x[2][1] * y[1][1];
>+    result[2][3] += x[2][2] * y[2][1];
>+    result[2][3] += x[2][3] * y[3][1];
>+    result[2][3] = 0;
>+    result[2][3] += x[2][0] * y[0][2];
>+    result[2][3] += x[2][1] * y[1][2];
>+    result[2][3] += x[2][2] * y[2][2];
>+    result[2][3] += x[2][3] * y[3][2];
>+    result[3][3] = 0;
>+    result[3][3] += x[3][0] * y[0][0];
>+    result[3][3] += x[3][1] * y[1][0];
>+    result[3][3] += x[3][2] * y[2][0];
>+    result[3][3] += x[3][3] * y[3][0];
>+    result[3][3] = 0;
>+    result[3][3] += x[3][0] * y[0][1];
>+    result[3][3] += x[3][1] * y[1][1];
>+    result[3][3] += x[3][2] * y[2][1];
>+    result[3][3] += x[3][3] * y[3][1];
>+    result[3][3] = 0;
>+    result[3][3] += x[3][0] * y[0][2];
>+    result[3][3] += x[3][1] * y[1][2];
>+    result[3][3] += x[3][2] * y[2][2];
>+    result[3][3] += x[3][3] * y[3][2];
>+    return result;
>+}
>+half4x4 mul(half4x4 x, half4x4 y) {
>+    half4x4 result;
>+    result[0][4] = 0;
>+    result[0][4] += x[0][0] * y[0][0];
>+    result[0][4] += x[0][1] * y[1][0];
>+    result[0][4] += x[0][2] * y[2][0];
>+    result[0][4] += x[0][3] * y[3][0];
>+    result[0][4] = 0;
>+    result[0][4] += x[0][0] * y[0][1];
>+    result[0][4] += x[0][1] * y[1][1];
>+    result[0][4] += x[0][2] * y[2][1];
>+    result[0][4] += x[0][3] * y[3][1];
>+    result[0][4] = 0;
>+    result[0][4] += x[0][0] * y[0][2];
>+    result[0][4] += x[0][1] * y[1][2];
>+    result[0][4] += x[0][2] * y[2][2];
>+    result[0][4] += x[0][3] * y[3][2];
>+    result[0][4] = 0;
>+    result[0][4] += x[0][0] * y[0][3];
>+    result[0][4] += x[0][1] * y[1][3];
>+    result[0][4] += x[0][2] * y[2][3];
>+    result[0][4] += x[0][3] * y[3][3];
>+    result[1][4] = 0;
>+    result[1][4] += x[1][0] * y[0][0];
>+    result[1][4] += x[1][1] * y[1][0];
>+    result[1][4] += x[1][2] * y[2][0];
>+    result[1][4] += x[1][3] * y[3][0];
>+    result[1][4] = 0;
>+    result[1][4] += x[1][0] * y[0][1];
>+    result[1][4] += x[1][1] * y[1][1];
>+    result[1][4] += x[1][2] * y[2][1];
>+    result[1][4] += x[1][3] * y[3][1];
>+    result[1][4] = 0;
>+    result[1][4] += x[1][0] * y[0][2];
>+    result[1][4] += x[1][1] * y[1][2];
>+    result[1][4] += x[1][2] * y[2][2];
>+    result[1][4] += x[1][3] * y[3][2];
>+    result[1][4] = 0;
>+    result[1][4] += x[1][0] * y[0][3];
>+    result[1][4] += x[1][1] * y[1][3];
>+    result[1][4] += x[1][2] * y[2][3];
>+    result[1][4] += x[1][3] * y[3][3];
>+    result[2][4] = 0;
>+    result[2][4] += x[2][0] * y[0][0];
>+    result[2][4] += x[2][1] * y[1][0];
>+    result[2][4] += x[2][2] * y[2][0];
>+    result[2][4] += x[2][3] * y[3][0];
>+    result[2][4] = 0;
>+    result[2][4] += x[2][0] * y[0][1];
>+    result[2][4] += x[2][1] * y[1][1];
>+    result[2][4] += x[2][2] * y[2][1];
>+    result[2][4] += x[2][3] * y[3][1];
>+    result[2][4] = 0;
>+    result[2][4] += x[2][0] * y[0][2];
>+    result[2][4] += x[2][1] * y[1][2];
>+    result[2][4] += x[2][2] * y[2][2];
>+    result[2][4] += x[2][3] * y[3][2];
>+    result[2][4] = 0;
>+    result[2][4] += x[2][0] * y[0][3];
>+    result[2][4] += x[2][1] * y[1][3];
>+    result[2][4] += x[2][2] * y[2][3];
>+    result[2][4] += x[2][3] * y[3][3];
>+    result[3][4] = 0;
>+    result[3][4] += x[3][0] * y[0][0];
>+    result[3][4] += x[3][1] * y[1][0];
>+    result[3][4] += x[3][2] * y[2][0];
>+    result[3][4] += x[3][3] * y[3][0];
>+    result[3][4] = 0;
>+    result[3][4] += x[3][0] * y[0][1];
>+    result[3][4] += x[3][1] * y[1][1];
>+    result[3][4] += x[3][2] * y[2][1];
>+    result[3][4] += x[3][3] * y[3][1];
>+    result[3][4] = 0;
>+    result[3][4] += x[3][0] * y[0][2];
>+    result[3][4] += x[3][1] * y[1][2];
>+    result[3][4] += x[3][2] * y[2][2];
>+    result[3][4] += x[3][3] * y[3][2];
>+    result[3][4] = 0;
>+    result[3][4] += x[3][0] * y[0][3];
>+    result[3][4] += x[3][1] * y[1][3];
>+    result[3][4] += x[3][2] * y[2][3];
>+    result[3][4] += x[3][3] * y[3][3];
>+    return result;
>+}
>+float2x2 mul(float2x2 x, float2x2 y) {
>+    float2x2 result;
>+    result[0][2] = 0;
>+    result[0][2] += x[0][0] * y[0][0];
>+    result[0][2] += x[0][1] * y[1][0];
>+    result[0][2] = 0;
>+    result[0][2] += x[0][0] * y[0][1];
>+    result[0][2] += x[0][1] * y[1][1];
>+    result[1][2] = 0;
>+    result[1][2] += x[1][0] * y[0][0];
>+    result[1][2] += x[1][1] * y[1][0];
>+    result[1][2] = 0;
>+    result[1][2] += x[1][0] * y[0][1];
>+    result[1][2] += x[1][1] * y[1][1];
>+    return result;
>+}
>+float2x3 mul(float2x2 x, float2x3 y) {
>+    float2x3 result;
>+    result[0][3] = 0;
>+    result[0][3] += x[0][0] * y[0][0];
>+    result[0][3] += x[0][1] * y[1][0];
>+    result[0][3] = 0;
>+    result[0][3] += x[0][0] * y[0][1];
>+    result[0][3] += x[0][1] * y[1][1];
>+    result[0][3] = 0;
>+    result[0][3] += x[0][0] * y[0][2];
>+    result[0][3] += x[0][1] * y[1][2];
>+    result[1][3] = 0;
>+    result[1][3] += x[1][0] * y[0][0];
>+    result[1][3] += x[1][1] * y[1][0];
>+    result[1][3] = 0;
>+    result[1][3] += x[1][0] * y[0][1];
>+    result[1][3] += x[1][1] * y[1][1];
>+    result[1][3] = 0;
>+    result[1][3] += x[1][0] * y[0][2];
>+    result[1][3] += x[1][1] * y[1][2];
>+    return result;
>+}
>+float2x4 mul(float2x2 x, float2x4 y) {
>+    float2x4 result;
>+    result[0][4] = 0;
>+    result[0][4] += x[0][0] * y[0][0];
>+    result[0][4] += x[0][1] * y[1][0];
>+    result[0][4] = 0;
>+    result[0][4] += x[0][0] * y[0][1];
>+    result[0][4] += x[0][1] * y[1][1];
>+    result[0][4] = 0;
>+    result[0][4] += x[0][0] * y[0][2];
>+    result[0][4] += x[0][1] * y[1][2];
>+    result[0][4] = 0;
>+    result[0][4] += x[0][0] * y[0][3];
>+    result[0][4] += x[0][1] * y[1][3];
>+    result[1][4] = 0;
>+    result[1][4] += x[1][0] * y[0][0];
>+    result[1][4] += x[1][1] * y[1][0];
>+    result[1][4] = 0;
>+    result[1][4] += x[1][0] * y[0][1];
>+    result[1][4] += x[1][1] * y[1][1];
>+    result[1][4] = 0;
>+    result[1][4] += x[1][0] * y[0][2];
>+    result[1][4] += x[1][1] * y[1][2];
>+    result[1][4] = 0;
>+    result[1][4] += x[1][0] * y[0][3];
>+    result[1][4] += x[1][1] * y[1][3];
>+    return result;
>+}
>+float2x2 mul(float2x3 x, float3x2 y) {
>+    float2x2 result;
>+    result[0][2] = 0;
>+    result[0][2] += x[0][0] * y[0][0];
>+    result[0][2] += x[0][1] * y[1][0];
>+    result[0][2] += x[0][2] * y[2][0];
>+    result[0][2] = 0;
>+    result[0][2] += x[0][0] * y[0][1];
>+    result[0][2] += x[0][1] * y[1][1];
>+    result[0][2] += x[0][2] * y[2][1];
>+    result[1][2] = 0;
>+    result[1][2] += x[1][0] * y[0][0];
>+    result[1][2] += x[1][1] * y[1][0];
>+    result[1][2] += x[1][2] * y[2][0];
>+    result[1][2] = 0;
>+    result[1][2] += x[1][0] * y[0][1];
>+    result[1][2] += x[1][1] * y[1][1];
>+    result[1][2] += x[1][2] * y[2][1];
>+    return result;
>+}
>+float2x3 mul(float2x3 x, float3x3 y) {
>+    float2x3 result;
>+    result[0][3] = 0;
>+    result[0][3] += x[0][0] * y[0][0];
>+    result[0][3] += x[0][1] * y[1][0];
>+    result[0][3] += x[0][2] * y[2][0];
>+    result[0][3] = 0;
>+    result[0][3] += x[0][0] * y[0][1];
>+    result[0][3] += x[0][1] * y[1][1];
>+    result[0][3] += x[0][2] * y[2][1];
>+    result[0][3] = 0;
>+    result[0][3] += x[0][0] * y[0][2];
>+    result[0][3] += x[0][1] * y[1][2];
>+    result[0][3] += x[0][2] * y[2][2];
>+    result[1][3] = 0;
>+    result[1][3] += x[1][0] * y[0][0];
>+    result[1][3] += x[1][1] * y[1][0];
>+    result[1][3] += x[1][2] * y[2][0];
>+    result[1][3] = 0;
>+    result[1][3] += x[1][0] * y[0][1];
>+    result[1][3] += x[1][1] * y[1][1];
>+    result[1][3] += x[1][2] * y[2][1];
>+    result[1][3] = 0;
>+    result[1][3] += x[1][0] * y[0][2];
>+    result[1][3] += x[1][1] * y[1][2];
>+    result[1][3] += x[1][2] * y[2][2];
>+    return result;
>+}
>+float2x4 mul(float2x3 x, float3x4 y) {
>+    float2x4 result;
>+    result[0][4] = 0;
>+    result[0][4] += x[0][0] * y[0][0];
>+    result[0][4] += x[0][1] * y[1][0];
>+    result[0][4] += x[0][2] * y[2][0];
>+    result[0][4] = 0;
>+    result[0][4] += x[0][0] * y[0][1];
>+    result[0][4] += x[0][1] * y[1][1];
>+    result[0][4] += x[0][2] * y[2][1];
>+    result[0][4] = 0;
>+    result[0][4] += x[0][0] * y[0][2];
>+    result[0][4] += x[0][1] * y[1][2];
>+    result[0][4] += x[0][2] * y[2][2];
>+    result[0][4] = 0;
>+    result[0][4] += x[0][0] * y[0][3];
>+    result[0][4] += x[0][1] * y[1][3];
>+    result[0][4] += x[0][2] * y[2][3];
>+    result[1][4] = 0;
>+    result[1][4] += x[1][0] * y[0][0];
>+    result[1][4] += x[1][1] * y[1][0];
>+    result[1][4] += x[1][2] * y[2][0];
>+    result[1][4] = 0;
>+    result[1][4] += x[1][0] * y[0][1];
>+    result[1][4] += x[1][1] * y[1][1];
>+    result[1][4] += x[1][2] * y[2][1];
>+    result[1][4] = 0;
>+    result[1][4] += x[1][0] * y[0][2];
>+    result[1][4] += x[1][1] * y[1][2];
>+    result[1][4] += x[1][2] * y[2][2];
>+    result[1][4] = 0;
>+    result[1][4] += x[1][0] * y[0][3];
>+    result[1][4] += x[1][1] * y[1][3];
>+    result[1][4] += x[1][2] * y[2][3];
>+    return result;
>+}
>+float2x2 mul(float2x4 x, float4x2 y) {
>+    float2x2 result;
>+    result[0][2] = 0;
>+    result[0][2] += x[0][0] * y[0][0];
>+    result[0][2] += x[0][1] * y[1][0];
>+    result[0][2] += x[0][2] * y[2][0];
>+    result[0][2] += x[0][3] * y[3][0];
>+    result[0][2] = 0;
>+    result[0][2] += x[0][0] * y[0][1];
>+    result[0][2] += x[0][1] * y[1][1];
>+    result[0][2] += x[0][2] * y[2][1];
>+    result[0][2] += x[0][3] * y[3][1];
>+    result[1][2] = 0;
>+    result[1][2] += x[1][0] * y[0][0];
>+    result[1][2] += x[1][1] * y[1][0];
>+    result[1][2] += x[1][2] * y[2][0];
>+    result[1][2] += x[1][3] * y[3][0];
>+    result[1][2] = 0;
>+    result[1][2] += x[1][0] * y[0][1];
>+    result[1][2] += x[1][1] * y[1][1];
>+    result[1][2] += x[1][2] * y[2][1];
>+    result[1][2] += x[1][3] * y[3][1];
>+    return result;
>+}
>+float2x3 mul(float2x4 x, float4x3 y) {
>+    float2x3 result;
>+    result[0][3] = 0;
>+    result[0][3] += x[0][0] * y[0][0];
>+    result[0][3] += x[0][1] * y[1][0];
>+    result[0][3] += x[0][2] * y[2][0];
>+    result[0][3] += x[0][3] * y[3][0];
>+    result[0][3] = 0;
>+    result[0][3] += x[0][0] * y[0][1];
>+    result[0][3] += x[0][1] * y[1][1];
>+    result[0][3] += x[0][2] * y[2][1];
>+    result[0][3] += x[0][3] * y[3][1];
>+    result[0][3] = 0;
>+    result[0][3] += x[0][0] * y[0][2];
>+    result[0][3] += x[0][1] * y[1][2];
>+    result[0][3] += x[0][2] * y[2][2];
>+    result[0][3] += x[0][3] * y[3][2];
>+    result[1][3] = 0;
>+    result[1][3] += x[1][0] * y[0][0];
>+    result[1][3] += x[1][1] * y[1][0];
>+    result[1][3] += x[1][2] * y[2][0];
>+    result[1][3] += x[1][3] * y[3][0];
>+    result[1][3] = 0;
>+    result[1][3] += x[1][0] * y[0][1];
>+    result[1][3] += x[1][1] * y[1][1];
>+    result[1][3] += x[1][2] * y[2][1];
>+    result[1][3] += x[1][3] * y[3][1];
>+    result[1][3] = 0;
>+    result[1][3] += x[1][0] * y[0][2];
>+    result[1][3] += x[1][1] * y[1][2];
>+    result[1][3] += x[1][2] * y[2][2];
>+    result[1][3] += x[1][3] * y[3][2];
>+    return result;
>+}
>+float2x4 mul(float2x4 x, float4x4 y) {
>+    float2x4 result;
>+    result[0][4] = 0;
>+    result[0][4] += x[0][0] * y[0][0];
>+    result[0][4] += x[0][1] * y[1][0];
>+    result[0][4] += x[0][2] * y[2][0];
>+    result[0][4] += x[0][3] * y[3][0];
>+    result[0][4] = 0;
>+    result[0][4] += x[0][0] * y[0][1];
>+    result[0][4] += x[0][1] * y[1][1];
>+    result[0][4] += x[0][2] * y[2][1];
>+    result[0][4] += x[0][3] * y[3][1];
>+    result[0][4] = 0;
>+    result[0][4] += x[0][0] * y[0][2];
>+    result[0][4] += x[0][1] * y[1][2];
>+    result[0][4] += x[0][2] * y[2][2];
>+    result[0][4] += x[0][3] * y[3][2];
>+    result[0][4] = 0;
>+    result[0][4] += x[0][0] * y[0][3];
>+    result[0][4] += x[0][1] * y[1][3];
>+    result[0][4] += x[0][2] * y[2][3];
>+    result[0][4] += x[0][3] * y[3][3];
>+    result[1][4] = 0;
>+    result[1][4] += x[1][0] * y[0][0];
>+    result[1][4] += x[1][1] * y[1][0];
>+    result[1][4] += x[1][2] * y[2][0];
>+    result[1][4] += x[1][3] * y[3][0];
>+    result[1][4] = 0;
>+    result[1][4] += x[1][0] * y[0][1];
>+    result[1][4] += x[1][1] * y[1][1];
>+    result[1][4] += x[1][2] * y[2][1];
>+    result[1][4] += x[1][3] * y[3][1];
>+    result[1][4] = 0;
>+    result[1][4] += x[1][0] * y[0][2];
>+    result[1][4] += x[1][1] * y[1][2];
>+    result[1][4] += x[1][2] * y[2][2];
>+    result[1][4] += x[1][3] * y[3][2];
>+    result[1][4] = 0;
>+    result[1][4] += x[1][0] * y[0][3];
>+    result[1][4] += x[1][1] * y[1][3];
>+    result[1][4] += x[1][2] * y[2][3];
>+    result[1][4] += x[1][3] * y[3][3];
>+    return result;
>+}
>+float3x2 mul(float3x2 x, float2x2 y) {
>+    float3x2 result;
>+    result[0][2] = 0;
>+    result[0][2] += x[0][0] * y[0][0];
>+    result[0][2] += x[0][1] * y[1][0];
>+    result[0][2] = 0;
>+    result[0][2] += x[0][0] * y[0][1];
>+    result[0][2] += x[0][1] * y[1][1];
>+    result[1][2] = 0;
>+    result[1][2] += x[1][0] * y[0][0];
>+    result[1][2] += x[1][1] * y[1][0];
>+    result[1][2] = 0;
>+    result[1][2] += x[1][0] * y[0][1];
>+    result[1][2] += x[1][1] * y[1][1];
>+    result[2][2] = 0;
>+    result[2][2] += x[2][0] * y[0][0];
>+    result[2][2] += x[2][1] * y[1][0];
>+    result[2][2] = 0;
>+    result[2][2] += x[2][0] * y[0][1];
>+    result[2][2] += x[2][1] * y[1][1];
>+    return result;
>+}
>+float3x3 mul(float3x2 x, float2x3 y) {
>+    float3x3 result;
>+    result[0][3] = 0;
>+    result[0][3] += x[0][0] * y[0][0];
>+    result[0][3] += x[0][1] * y[1][0];
>+    result[0][3] = 0;
>+    result[0][3] += x[0][0] * y[0][1];
>+    result[0][3] += x[0][1] * y[1][1];
>+    result[0][3] = 0;
>+    result[0][3] += x[0][0] * y[0][2];
>+    result[0][3] += x[0][1] * y[1][2];
>+    result[1][3] = 0;
>+    result[1][3] += x[1][0] * y[0][0];
>+    result[1][3] += x[1][1] * y[1][0];
>+    result[1][3] = 0;
>+    result[1][3] += x[1][0] * y[0][1];
>+    result[1][3] += x[1][1] * y[1][1];
>+    result[1][3] = 0;
>+    result[1][3] += x[1][0] * y[0][2];
>+    result[1][3] += x[1][1] * y[1][2];
>+    result[2][3] = 0;
>+    result[2][3] += x[2][0] * y[0][0];
>+    result[2][3] += x[2][1] * y[1][0];
>+    result[2][3] = 0;
>+    result[2][3] += x[2][0] * y[0][1];
>+    result[2][3] += x[2][1] * y[1][1];
>+    result[2][3] = 0;
>+    result[2][3] += x[2][0] * y[0][2];
>+    result[2][3] += x[2][1] * y[1][2];
>+    return result;
>+}
>+float3x4 mul(float3x2 x, float2x4 y) {
>+    float3x4 result;
>+    result[0][4] = 0;
>+    result[0][4] += x[0][0] * y[0][0];
>+    result[0][4] += x[0][1] * y[1][0];
>+    result[0][4] = 0;
>+    result[0][4] += x[0][0] * y[0][1];
>+    result[0][4] += x[0][1] * y[1][1];
>+    result[0][4] = 0;
>+    result[0][4] += x[0][0] * y[0][2];
>+    result[0][4] += x[0][1] * y[1][2];
>+    result[0][4] = 0;
>+    result[0][4] += x[0][0] * y[0][3];
>+    result[0][4] += x[0][1] * y[1][3];
>+    result[1][4] = 0;
>+    result[1][4] += x[1][0] * y[0][0];
>+    result[1][4] += x[1][1] * y[1][0];
>+    result[1][4] = 0;
>+    result[1][4] += x[1][0] * y[0][1];
>+    result[1][4] += x[1][1] * y[1][1];
>+    result[1][4] = 0;
>+    result[1][4] += x[1][0] * y[0][2];
>+    result[1][4] += x[1][1] * y[1][2];
>+    result[1][4] = 0;
>+    result[1][4] += x[1][0] * y[0][3];
>+    result[1][4] += x[1][1] * y[1][3];
>+    result[2][4] = 0;
>+    result[2][4] += x[2][0] * y[0][0];
>+    result[2][4] += x[2][1] * y[1][0];
>+    result[2][4] = 0;
>+    result[2][4] += x[2][0] * y[0][1];
>+    result[2][4] += x[2][1] * y[1][1];
>+    result[2][4] = 0;
>+    result[2][4] += x[2][0] * y[0][2];
>+    result[2][4] += x[2][1] * y[1][2];
>+    result[2][4] = 0;
>+    result[2][4] += x[2][0] * y[0][3];
>+    result[2][4] += x[2][1] * y[1][3];
>+    return result;
>+}
>+float3x2 mul(float3x3 x, float3x2 y) {
>+    float3x2 result;
>+    result[0][2] = 0;
>+    result[0][2] += x[0][0] * y[0][0];
>+    result[0][2] += x[0][1] * y[1][0];
>+    result[0][2] += x[0][2] * y[2][0];
>+    result[0][2] = 0;
>+    result[0][2] += x[0][0] * y[0][1];
>+    result[0][2] += x[0][1] * y[1][1];
>+    result[0][2] += x[0][2] * y[2][1];
>+    result[1][2] = 0;
>+    result[1][2] += x[1][0] * y[0][0];
>+    result[1][2] += x[1][1] * y[1][0];
>+    result[1][2] += x[1][2] * y[2][0];
>+    result[1][2] = 0;
>+    result[1][2] += x[1][0] * y[0][1];
>+    result[1][2] += x[1][1] * y[1][1];
>+    result[1][2] += x[1][2] * y[2][1];
>+    result[2][2] = 0;
>+    result[2][2] += x[2][0] * y[0][0];
>+    result[2][2] += x[2][1] * y[1][0];
>+    result[2][2] += x[2][2] * y[2][0];
>+    result[2][2] = 0;
>+    result[2][2] += x[2][0] * y[0][1];
>+    result[2][2] += x[2][1] * y[1][1];
>+    result[2][2] += x[2][2] * y[2][1];
>+    return result;
>+}
>+float3x3 mul(float3x3 x, float3x3 y) {
>+    float3x3 result;
>+    result[0][3] = 0;
>+    result[0][3] += x[0][0] * y[0][0];
>+    result[0][3] += x[0][1] * y[1][0];
>+    result[0][3] += x[0][2] * y[2][0];
>+    result[0][3] = 0;
>+    result[0][3] += x[0][0] * y[0][1];
>+    result[0][3] += x[0][1] * y[1][1];
>+    result[0][3] += x[0][2] * y[2][1];
>+    result[0][3] = 0;
>+    result[0][3] += x[0][0] * y[0][2];
>+    result[0][3] += x[0][1] * y[1][2];
>+    result[0][3] += x[0][2] * y[2][2];
>+    result[1][3] = 0;
>+    result[1][3] += x[1][0] * y[0][0];
>+    result[1][3] += x[1][1] * y[1][0];
>+    result[1][3] += x[1][2] * y[2][0];
>+    result[1][3] = 0;
>+    result[1][3] += x[1][0] * y[0][1];
>+    result[1][3] += x[1][1] * y[1][1];
>+    result[1][3] += x[1][2] * y[2][1];
>+    result[1][3] = 0;
>+    result[1][3] += x[1][0] * y[0][2];
>+    result[1][3] += x[1][1] * y[1][2];
>+    result[1][3] += x[1][2] * y[2][2];
>+    result[2][3] = 0;
>+    result[2][3] += x[2][0] * y[0][0];
>+    result[2][3] += x[2][1] * y[1][0];
>+    result[2][3] += x[2][2] * y[2][0];
>+    result[2][3] = 0;
>+    result[2][3] += x[2][0] * y[0][1];
>+    result[2][3] += x[2][1] * y[1][1];
>+    result[2][3] += x[2][2] * y[2][1];
>+    result[2][3] = 0;
>+    result[2][3] += x[2][0] * y[0][2];
>+    result[2][3] += x[2][1] * y[1][2];
>+    result[2][3] += x[2][2] * y[2][2];
>+    return result;
>+}
>+float3x4 mul(float3x3 x, float3x4 y) {
>+    float3x4 result;
>+    result[0][4] = 0;
>+    result[0][4] += x[0][0] * y[0][0];
>+    result[0][4] += x[0][1] * y[1][0];
>+    result[0][4] += x[0][2] * y[2][0];
>+    result[0][4] = 0;
>+    result[0][4] += x[0][0] * y[0][1];
>+    result[0][4] += x[0][1] * y[1][1];
>+    result[0][4] += x[0][2] * y[2][1];
>+    result[0][4] = 0;
>+    result[0][4] += x[0][0] * y[0][2];
>+    result[0][4] += x[0][1] * y[1][2];
>+    result[0][4] += x[0][2] * y[2][2];
>+    result[0][4] = 0;
>+    result[0][4] += x[0][0] * y[0][3];
>+    result[0][4] += x[0][1] * y[1][3];
>+    result[0][4] += x[0][2] * y[2][3];
>+    result[1][4] = 0;
>+    result[1][4] += x[1][0] * y[0][0];
>+    result[1][4] += x[1][1] * y[1][0];
>+    result[1][4] += x[1][2] * y[2][0];
>+    result[1][4] = 0;
>+    result[1][4] += x[1][0] * y[0][1];
>+    result[1][4] += x[1][1] * y[1][1];
>+    result[1][4] += x[1][2] * y[2][1];
>+    result[1][4] = 0;
>+    result[1][4] += x[1][0] * y[0][2];
>+    result[1][4] += x[1][1] * y[1][2];
>+    result[1][4] += x[1][2] * y[2][2];
>+    result[1][4] = 0;
>+    result[1][4] += x[1][0] * y[0][3];
>+    result[1][4] += x[1][1] * y[1][3];
>+    result[1][4] += x[1][2] * y[2][3];
>+    result[2][4] = 0;
>+    result[2][4] += x[2][0] * y[0][0];
>+    result[2][4] += x[2][1] * y[1][0];
>+    result[2][4] += x[2][2] * y[2][0];
>+    result[2][4] = 0;
>+    result[2][4] += x[2][0] * y[0][1];
>+    result[2][4] += x[2][1] * y[1][1];
>+    result[2][4] += x[2][2] * y[2][1];
>+    result[2][4] = 0;
>+    result[2][4] += x[2][0] * y[0][2];
>+    result[2][4] += x[2][1] * y[1][2];
>+    result[2][4] += x[2][2] * y[2][2];
>+    result[2][4] = 0;
>+    result[2][4] += x[2][0] * y[0][3];
>+    result[2][4] += x[2][1] * y[1][3];
>+    result[2][4] += x[2][2] * y[2][3];
>+    return result;
>+}
>+float3x2 mul(float3x4 x, float4x2 y) {
>+    float3x2 result;
>+    result[0][2] = 0;
>+    result[0][2] += x[0][0] * y[0][0];
>+    result[0][2] += x[0][1] * y[1][0];
>+    result[0][2] += x[0][2] * y[2][0];
>+    result[0][2] += x[0][3] * y[3][0];
>+    result[0][2] = 0;
>+    result[0][2] += x[0][0] * y[0][1];
>+    result[0][2] += x[0][1] * y[1][1];
>+    result[0][2] += x[0][2] * y[2][1];
>+    result[0][2] += x[0][3] * y[3][1];
>+    result[1][2] = 0;
>+    result[1][2] += x[1][0] * y[0][0];
>+    result[1][2] += x[1][1] * y[1][0];
>+    result[1][2] += x[1][2] * y[2][0];
>+    result[1][2] += x[1][3] * y[3][0];
>+    result[1][2] = 0;
>+    result[1][2] += x[1][0] * y[0][1];
>+    result[1][2] += x[1][1] * y[1][1];
>+    result[1][2] += x[1][2] * y[2][1];
>+    result[1][2] += x[1][3] * y[3][1];
>+    result[2][2] = 0;
>+    result[2][2] += x[2][0] * y[0][0];
>+    result[2][2] += x[2][1] * y[1][0];
>+    result[2][2] += x[2][2] * y[2][0];
>+    result[2][2] += x[2][3] * y[3][0];
>+    result[2][2] = 0;
>+    result[2][2] += x[2][0] * y[0][1];
>+    result[2][2] += x[2][1] * y[1][1];
>+    result[2][2] += x[2][2] * y[2][1];
>+    result[2][2] += x[2][3] * y[3][1];
>+    return result;
>+}
>+float3x3 mul(float3x4 x, float4x3 y) {
>+    float3x3 result;
>+    result[0][3] = 0;
>+    result[0][3] += x[0][0] * y[0][0];
>+    result[0][3] += x[0][1] * y[1][0];
>+    result[0][3] += x[0][2] * y[2][0];
>+    result[0][3] += x[0][3] * y[3][0];
>+    result[0][3] = 0;
>+    result[0][3] += x[0][0] * y[0][1];
>+    result[0][3] += x[0][1] * y[1][1];
>+    result[0][3] += x[0][2] * y[2][1];
>+    result[0][3] += x[0][3] * y[3][1];
>+    result[0][3] = 0;
>+    result[0][3] += x[0][0] * y[0][2];
>+    result[0][3] += x[0][1] * y[1][2];
>+    result[0][3] += x[0][2] * y[2][2];
>+    result[0][3] += x[0][3] * y[3][2];
>+    result[1][3] = 0;
>+    result[1][3] += x[1][0] * y[0][0];
>+    result[1][3] += x[1][1] * y[1][0];
>+    result[1][3] += x[1][2] * y[2][0];
>+    result[1][3] += x[1][3] * y[3][0];
>+    result[1][3] = 0;
>+    result[1][3] += x[1][0] * y[0][1];
>+    result[1][3] += x[1][1] * y[1][1];
>+    result[1][3] += x[1][2] * y[2][1];
>+    result[1][3] += x[1][3] * y[3][1];
>+    result[1][3] = 0;
>+    result[1][3] += x[1][0] * y[0][2];
>+    result[1][3] += x[1][1] * y[1][2];
>+    result[1][3] += x[1][2] * y[2][2];
>+    result[1][3] += x[1][3] * y[3][2];
>+    result[2][3] = 0;
>+    result[2][3] += x[2][0] * y[0][0];
>+    result[2][3] += x[2][1] * y[1][0];
>+    result[2][3] += x[2][2] * y[2][0];
>+    result[2][3] += x[2][3] * y[3][0];
>+    result[2][3] = 0;
>+    result[2][3] += x[2][0] * y[0][1];
>+    result[2][3] += x[2][1] * y[1][1];
>+    result[2][3] += x[2][2] * y[2][1];
>+    result[2][3] += x[2][3] * y[3][1];
>+    result[2][3] = 0;
>+    result[2][3] += x[2][0] * y[0][2];
>+    result[2][3] += x[2][1] * y[1][2];
>+    result[2][3] += x[2][2] * y[2][2];
>+    result[2][3] += x[2][3] * y[3][2];
>+    return result;
>+}
>+float3x4 mul(float3x4 x, float4x4 y) {
>+    float3x4 result;
>+    result[0][4] = 0;
>+    result[0][4] += x[0][0] * y[0][0];
>+    result[0][4] += x[0][1] * y[1][0];
>+    result[0][4] += x[0][2] * y[2][0];
>+    result[0][4] += x[0][3] * y[3][0];
>+    result[0][4] = 0;
>+    result[0][4] += x[0][0] * y[0][1];
>+    result[0][4] += x[0][1] * y[1][1];
>+    result[0][4] += x[0][2] * y[2][1];
>+    result[0][4] += x[0][3] * y[3][1];
>+    result[0][4] = 0;
>+    result[0][4] += x[0][0] * y[0][2];
>+    result[0][4] += x[0][1] * y[1][2];
>+    result[0][4] += x[0][2] * y[2][2];
>+    result[0][4] += x[0][3] * y[3][2];
>+    result[0][4] = 0;
>+    result[0][4] += x[0][0] * y[0][3];
>+    result[0][4] += x[0][1] * y[1][3];
>+    result[0][4] += x[0][2] * y[2][3];
>+    result[0][4] += x[0][3] * y[3][3];
>+    result[1][4] = 0;
>+    result[1][4] += x[1][0] * y[0][0];
>+    result[1][4] += x[1][1] * y[1][0];
>+    result[1][4] += x[1][2] * y[2][0];
>+    result[1][4] += x[1][3] * y[3][0];
>+    result[1][4] = 0;
>+    result[1][4] += x[1][0] * y[0][1];
>+    result[1][4] += x[1][1] * y[1][1];
>+    result[1][4] += x[1][2] * y[2][1];
>+    result[1][4] += x[1][3] * y[3][1];
>+    result[1][4] = 0;
>+    result[1][4] += x[1][0] * y[0][2];
>+    result[1][4] += x[1][1] * y[1][2];
>+    result[1][4] += x[1][2] * y[2][2];
>+    result[1][4] += x[1][3] * y[3][2];
>+    result[1][4] = 0;
>+    result[1][4] += x[1][0] * y[0][3];
>+    result[1][4] += x[1][1] * y[1][3];
>+    result[1][4] += x[1][2] * y[2][3];
>+    result[1][4] += x[1][3] * y[3][3];
>+    result[2][4] = 0;
>+    result[2][4] += x[2][0] * y[0][0];
>+    result[2][4] += x[2][1] * y[1][0];
>+    result[2][4] += x[2][2] * y[2][0];
>+    result[2][4] += x[2][3] * y[3][0];
>+    result[2][4] = 0;
>+    result[2][4] += x[2][0] * y[0][1];
>+    result[2][4] += x[2][1] * y[1][1];
>+    result[2][4] += x[2][2] * y[2][1];
>+    result[2][4] += x[2][3] * y[3][1];
>+    result[2][4] = 0;
>+    result[2][4] += x[2][0] * y[0][2];
>+    result[2][4] += x[2][1] * y[1][2];
>+    result[2][4] += x[2][2] * y[2][2];
>+    result[2][4] += x[2][3] * y[3][2];
>+    result[2][4] = 0;
>+    result[2][4] += x[2][0] * y[0][3];
>+    result[2][4] += x[2][1] * y[1][3];
>+    result[2][4] += x[2][2] * y[2][3];
>+    result[2][4] += x[2][3] * y[3][3];
>+    return result;
>+}
>+float4x2 mul(float4x2 x, float2x2 y) {
>+    float4x2 result;
>+    result[0][2] = 0;
>+    result[0][2] += x[0][0] * y[0][0];
>+    result[0][2] += x[0][1] * y[1][0];
>+    result[0][2] = 0;
>+    result[0][2] += x[0][0] * y[0][1];
>+    result[0][2] += x[0][1] * y[1][1];
>+    result[1][2] = 0;
>+    result[1][2] += x[1][0] * y[0][0];
>+    result[1][2] += x[1][1] * y[1][0];
>+    result[1][2] = 0;
>+    result[1][2] += x[1][0] * y[0][1];
>+    result[1][2] += x[1][1] * y[1][1];
>+    result[2][2] = 0;
>+    result[2][2] += x[2][0] * y[0][0];
>+    result[2][2] += x[2][1] * y[1][0];
>+    result[2][2] = 0;
>+    result[2][2] += x[2][0] * y[0][1];
>+    result[2][2] += x[2][1] * y[1][1];
>+    result[3][2] = 0;
>+    result[3][2] += x[3][0] * y[0][0];
>+    result[3][2] += x[3][1] * y[1][0];
>+    result[3][2] = 0;
>+    result[3][2] += x[3][0] * y[0][1];
>+    result[3][2] += x[3][1] * y[1][1];
>+    return result;
>+}
>+float4x3 mul(float4x2 x, float2x3 y) {
>+    float4x3 result;
>+    result[0][3] = 0;
>+    result[0][3] += x[0][0] * y[0][0];
>+    result[0][3] += x[0][1] * y[1][0];
>+    result[0][3] = 0;
>+    result[0][3] += x[0][0] * y[0][1];
>+    result[0][3] += x[0][1] * y[1][1];
>+    result[0][3] = 0;
>+    result[0][3] += x[0][0] * y[0][2];
>+    result[0][3] += x[0][1] * y[1][2];
>+    result[1][3] = 0;
>+    result[1][3] += x[1][0] * y[0][0];
>+    result[1][3] += x[1][1] * y[1][0];
>+    result[1][3] = 0;
>+    result[1][3] += x[1][0] * y[0][1];
>+    result[1][3] += x[1][1] * y[1][1];
>+    result[1][3] = 0;
>+    result[1][3] += x[1][0] * y[0][2];
>+    result[1][3] += x[1][1] * y[1][2];
>+    result[2][3] = 0;
>+    result[2][3] += x[2][0] * y[0][0];
>+    result[2][3] += x[2][1] * y[1][0];
>+    result[2][3] = 0;
>+    result[2][3] += x[2][0] * y[0][1];
>+    result[2][3] += x[2][1] * y[1][1];
>+    result[2][3] = 0;
>+    result[2][3] += x[2][0] * y[0][2];
>+    result[2][3] += x[2][1] * y[1][2];
>+    result[3][3] = 0;
>+    result[3][3] += x[3][0] * y[0][0];
>+    result[3][3] += x[3][1] * y[1][0];
>+    result[3][3] = 0;
>+    result[3][3] += x[3][0] * y[0][1];
>+    result[3][3] += x[3][1] * y[1][1];
>+    result[3][3] = 0;
>+    result[3][3] += x[3][0] * y[0][2];
>+    result[3][3] += x[3][1] * y[1][2];
>+    return result;
>+}
>+float4x4 mul(float4x2 x, float2x4 y) {
>+    float4x4 result;
>+    result[0][4] = 0;
>+    result[0][4] += x[0][0] * y[0][0];
>+    result[0][4] += x[0][1] * y[1][0];
>+    result[0][4] = 0;
>+    result[0][4] += x[0][0] * y[0][1];
>+    result[0][4] += x[0][1] * y[1][1];
>+    result[0][4] = 0;
>+    result[0][4] += x[0][0] * y[0][2];
>+    result[0][4] += x[0][1] * y[1][2];
>+    result[0][4] = 0;
>+    result[0][4] += x[0][0] * y[0][3];
>+    result[0][4] += x[0][1] * y[1][3];
>+    result[1][4] = 0;
>+    result[1][4] += x[1][0] * y[0][0];
>+    result[1][4] += x[1][1] * y[1][0];
>+    result[1][4] = 0;
>+    result[1][4] += x[1][0] * y[0][1];
>+    result[1][4] += x[1][1] * y[1][1];
>+    result[1][4] = 0;
>+    result[1][4] += x[1][0] * y[0][2];
>+    result[1][4] += x[1][1] * y[1][2];
>+    result[1][4] = 0;
>+    result[1][4] += x[1][0] * y[0][3];
>+    result[1][4] += x[1][1] * y[1][3];
>+    result[2][4] = 0;
>+    result[2][4] += x[2][0] * y[0][0];
>+    result[2][4] += x[2][1] * y[1][0];
>+    result[2][4] = 0;
>+    result[2][4] += x[2][0] * y[0][1];
>+    result[2][4] += x[2][1] * y[1][1];
>+    result[2][4] = 0;
>+    result[2][4] += x[2][0] * y[0][2];
>+    result[2][4] += x[2][1] * y[1][2];
>+    result[2][4] = 0;
>+    result[2][4] += x[2][0] * y[0][3];
>+    result[2][4] += x[2][1] * y[1][3];
>+    result[3][4] = 0;
>+    result[3][4] += x[3][0] * y[0][0];
>+    result[3][4] += x[3][1] * y[1][0];
>+    result[3][4] = 0;
>+    result[3][4] += x[3][0] * y[0][1];
>+    result[3][4] += x[3][1] * y[1][1];
>+    result[3][4] = 0;
>+    result[3][4] += x[3][0] * y[0][2];
>+    result[3][4] += x[3][1] * y[1][2];
>+    result[3][4] = 0;
>+    result[3][4] += x[3][0] * y[0][3];
>+    result[3][4] += x[3][1] * y[1][3];
>+    return result;
>+}
>+float4x2 mul(float4x3 x, float3x2 y) {
>+    float4x2 result;
>+    result[0][2] = 0;
>+    result[0][2] += x[0][0] * y[0][0];
>+    result[0][2] += x[0][1] * y[1][0];
>+    result[0][2] += x[0][2] * y[2][0];
>+    result[0][2] = 0;
>+    result[0][2] += x[0][0] * y[0][1];
>+    result[0][2] += x[0][1] * y[1][1];
>+    result[0][2] += x[0][2] * y[2][1];
>+    result[1][2] = 0;
>+    result[1][2] += x[1][0] * y[0][0];
>+    result[1][2] += x[1][1] * y[1][0];
>+    result[1][2] += x[1][2] * y[2][0];
>+    result[1][2] = 0;
>+    result[1][2] += x[1][0] * y[0][1];
>+    result[1][2] += x[1][1] * y[1][1];
>+    result[1][2] += x[1][2] * y[2][1];
>+    result[2][2] = 0;
>+    result[2][2] += x[2][0] * y[0][0];
>+    result[2][2] += x[2][1] * y[1][0];
>+    result[2][2] += x[2][2] * y[2][0];
>+    result[2][2] = 0;
>+    result[2][2] += x[2][0] * y[0][1];
>+    result[2][2] += x[2][1] * y[1][1];
>+    result[2][2] += x[2][2] * y[2][1];
>+    result[3][2] = 0;
>+    result[3][2] += x[3][0] * y[0][0];
>+    result[3][2] += x[3][1] * y[1][0];
>+    result[3][2] += x[3][2] * y[2][0];
>+    result[3][2] = 0;
>+    result[3][2] += x[3][0] * y[0][1];
>+    result[3][2] += x[3][1] * y[1][1];
>+    result[3][2] += x[3][2] * y[2][1];
>+    return result;
>+}
>+float4x3 mul(float4x3 x, float3x3 y) {
>+    float4x3 result;
>+    result[0][3] = 0;
>+    result[0][3] += x[0][0] * y[0][0];
>+    result[0][3] += x[0][1] * y[1][0];
>+    result[0][3] += x[0][2] * y[2][0];
>+    result[0][3] = 0;
>+    result[0][3] += x[0][0] * y[0][1];
>+    result[0][3] += x[0][1] * y[1][1];
>+    result[0][3] += x[0][2] * y[2][1];
>+    result[0][3] = 0;
>+    result[0][3] += x[0][0] * y[0][2];
>+    result[0][3] += x[0][1] * y[1][2];
>+    result[0][3] += x[0][2] * y[2][2];
>+    result[1][3] = 0;
>+    result[1][3] += x[1][0] * y[0][0];
>+    result[1][3] += x[1][1] * y[1][0];
>+    result[1][3] += x[1][2] * y[2][0];
>+    result[1][3] = 0;
>+    result[1][3] += x[1][0] * y[0][1];
>+    result[1][3] += x[1][1] * y[1][1];
>+    result[1][3] += x[1][2] * y[2][1];
>+    result[1][3] = 0;
>+    result[1][3] += x[1][0] * y[0][2];
>+    result[1][3] += x[1][1] * y[1][2];
>+    result[1][3] += x[1][2] * y[2][2];
>+    result[2][3] = 0;
>+    result[2][3] += x[2][0] * y[0][0];
>+    result[2][3] += x[2][1] * y[1][0];
>+    result[2][3] += x[2][2] * y[2][0];
>+    result[2][3] = 0;
>+    result[2][3] += x[2][0] * y[0][1];
>+    result[2][3] += x[2][1] * y[1][1];
>+    result[2][3] += x[2][2] * y[2][1];
>+    result[2][3] = 0;
>+    result[2][3] += x[2][0] * y[0][2];
>+    result[2][3] += x[2][1] * y[1][2];
>+    result[2][3] += x[2][2] * y[2][2];
>+    result[3][3] = 0;
>+    result[3][3] += x[3][0] * y[0][0];
>+    result[3][3] += x[3][1] * y[1][0];
>+    result[3][3] += x[3][2] * y[2][0];
>+    result[3][3] = 0;
>+    result[3][3] += x[3][0] * y[0][1];
>+    result[3][3] += x[3][1] * y[1][1];
>+    result[3][3] += x[3][2] * y[2][1];
>+    result[3][3] = 0;
>+    result[3][3] += x[3][0] * y[0][2];
>+    result[3][3] += x[3][1] * y[1][2];
>+    result[3][3] += x[3][2] * y[2][2];
>+    return result;
>+}
>+float4x4 mul(float4x3 x, float3x4 y) {
>+    float4x4 result;
>+    result[0][4] = 0;
>+    result[0][4] += x[0][0] * y[0][0];
>+    result[0][4] += x[0][1] * y[1][0];
>+    result[0][4] += x[0][2] * y[2][0];
>+    result[0][4] = 0;
>+    result[0][4] += x[0][0] * y[0][1];
>+    result[0][4] += x[0][1] * y[1][1];
>+    result[0][4] += x[0][2] * y[2][1];
>+    result[0][4] = 0;
>+    result[0][4] += x[0][0] * y[0][2];
>+    result[0][4] += x[0][1] * y[1][2];
>+    result[0][4] += x[0][2] * y[2][2];
>+    result[0][4] = 0;
>+    result[0][4] += x[0][0] * y[0][3];
>+    result[0][4] += x[0][1] * y[1][3];
>+    result[0][4] += x[0][2] * y[2][3];
>+    result[1][4] = 0;
>+    result[1][4] += x[1][0] * y[0][0];
>+    result[1][4] += x[1][1] * y[1][0];
>+    result[1][4] += x[1][2] * y[2][0];
>+    result[1][4] = 0;
>+    result[1][4] += x[1][0] * y[0][1];
>+    result[1][4] += x[1][1] * y[1][1];
>+    result[1][4] += x[1][2] * y[2][1];
>+    result[1][4] = 0;
>+    result[1][4] += x[1][0] * y[0][2];
>+    result[1][4] += x[1][1] * y[1][2];
>+    result[1][4] += x[1][2] * y[2][2];
>+    result[1][4] = 0;
>+    result[1][4] += x[1][0] * y[0][3];
>+    result[1][4] += x[1][1] * y[1][3];
>+    result[1][4] += x[1][2] * y[2][3];
>+    result[2][4] = 0;
>+    result[2][4] += x[2][0] * y[0][0];
>+    result[2][4] += x[2][1] * y[1][0];
>+    result[2][4] += x[2][2] * y[2][0];
>+    result[2][4] = 0;
>+    result[2][4] += x[2][0] * y[0][1];
>+    result[2][4] += x[2][1] * y[1][1];
>+    result[2][4] += x[2][2] * y[2][1];
>+    result[2][4] = 0;
>+    result[2][4] += x[2][0] * y[0][2];
>+    result[2][4] += x[2][1] * y[1][2];
>+    result[2][4] += x[2][2] * y[2][2];
>+    result[2][4] = 0;
>+    result[2][4] += x[2][0] * y[0][3];
>+    result[2][4] += x[2][1] * y[1][3];
>+    result[2][4] += x[2][2] * y[2][3];
>+    result[3][4] = 0;
>+    result[3][4] += x[3][0] * y[0][0];
>+    result[3][4] += x[3][1] * y[1][0];
>+    result[3][4] += x[3][2] * y[2][0];
>+    result[3][4] = 0;
>+    result[3][4] += x[3][0] * y[0][1];
>+    result[3][4] += x[3][1] * y[1][1];
>+    result[3][4] += x[3][2] * y[2][1];
>+    result[3][4] = 0;
>+    result[3][4] += x[3][0] * y[0][2];
>+    result[3][4] += x[3][1] * y[1][2];
>+    result[3][4] += x[3][2] * y[2][2];
>+    result[3][4] = 0;
>+    result[3][4] += x[3][0] * y[0][3];
>+    result[3][4] += x[3][1] * y[1][3];
>+    result[3][4] += x[3][2] * y[2][3];
>+    return result;
>+}
>+float4x2 mul(float4x4 x, float4x2 y) {
>+    float4x2 result;
>+    result[0][2] = 0;
>+    result[0][2] += x[0][0] * y[0][0];
>+    result[0][2] += x[0][1] * y[1][0];
>+    result[0][2] += x[0][2] * y[2][0];
>+    result[0][2] += x[0][3] * y[3][0];
>+    result[0][2] = 0;
>+    result[0][2] += x[0][0] * y[0][1];
>+    result[0][2] += x[0][1] * y[1][1];
>+    result[0][2] += x[0][2] * y[2][1];
>+    result[0][2] += x[0][3] * y[3][1];
>+    result[1][2] = 0;
>+    result[1][2] += x[1][0] * y[0][0];
>+    result[1][2] += x[1][1] * y[1][0];
>+    result[1][2] += x[1][2] * y[2][0];
>+    result[1][2] += x[1][3] * y[3][0];
>+    result[1][2] = 0;
>+    result[1][2] += x[1][0] * y[0][1];
>+    result[1][2] += x[1][1] * y[1][1];
>+    result[1][2] += x[1][2] * y[2][1];
>+    result[1][2] += x[1][3] * y[3][1];
>+    result[2][2] = 0;
>+    result[2][2] += x[2][0] * y[0][0];
>+    result[2][2] += x[2][1] * y[1][0];
>+    result[2][2] += x[2][2] * y[2][0];
>+    result[2][2] += x[2][3] * y[3][0];
>+    result[2][2] = 0;
>+    result[2][2] += x[2][0] * y[0][1];
>+    result[2][2] += x[2][1] * y[1][1];
>+    result[2][2] += x[2][2] * y[2][1];
>+    result[2][2] += x[2][3] * y[3][1];
>+    result[3][2] = 0;
>+    result[3][2] += x[3][0] * y[0][0];
>+    result[3][2] += x[3][1] * y[1][0];
>+    result[3][2] += x[3][2] * y[2][0];
>+    result[3][2] += x[3][3] * y[3][0];
>+    result[3][2] = 0;
>+    result[3][2] += x[3][0] * y[0][1];
>+    result[3][2] += x[3][1] * y[1][1];
>+    result[3][2] += x[3][2] * y[2][1];
>+    result[3][2] += x[3][3] * y[3][1];
>+    return result;
>+}
>+float4x3 mul(float4x4 x, float4x3 y) {
>+    float4x3 result;
>+    result[0][3] = 0;
>+    result[0][3] += x[0][0] * y[0][0];
>+    result[0][3] += x[0][1] * y[1][0];
>+    result[0][3] += x[0][2] * y[2][0];
>+    result[0][3] += x[0][3] * y[3][0];
>+    result[0][3] = 0;
>+    result[0][3] += x[0][0] * y[0][1];
>+    result[0][3] += x[0][1] * y[1][1];
>+    result[0][3] += x[0][2] * y[2][1];
>+    result[0][3] += x[0][3] * y[3][1];
>+    result[0][3] = 0;
>+    result[0][3] += x[0][0] * y[0][2];
>+    result[0][3] += x[0][1] * y[1][2];
>+    result[0][3] += x[0][2] * y[2][2];
>+    result[0][3] += x[0][3] * y[3][2];
>+    result[1][3] = 0;
>+    result[1][3] += x[1][0] * y[0][0];
>+    result[1][3] += x[1][1] * y[1][0];
>+    result[1][3] += x[1][2] * y[2][0];
>+    result[1][3] += x[1][3] * y[3][0];
>+    result[1][3] = 0;
>+    result[1][3] += x[1][0] * y[0][1];
>+    result[1][3] += x[1][1] * y[1][1];
>+    result[1][3] += x[1][2] * y[2][1];
>+    result[1][3] += x[1][3] * y[3][1];
>+    result[1][3] = 0;
>+    result[1][3] += x[1][0] * y[0][2];
>+    result[1][3] += x[1][1] * y[1][2];
>+    result[1][3] += x[1][2] * y[2][2];
>+    result[1][3] += x[1][3] * y[3][2];
>+    result[2][3] = 0;
>+    result[2][3] += x[2][0] * y[0][0];
>+    result[2][3] += x[2][1] * y[1][0];
>+    result[2][3] += x[2][2] * y[2][0];
>+    result[2][3] += x[2][3] * y[3][0];
>+    result[2][3] = 0;
>+    result[2][3] += x[2][0] * y[0][1];
>+    result[2][3] += x[2][1] * y[1][1];
>+    result[2][3] += x[2][2] * y[2][1];
>+    result[2][3] += x[2][3] * y[3][1];
>+    result[2][3] = 0;
>+    result[2][3] += x[2][0] * y[0][2];
>+    result[2][3] += x[2][1] * y[1][2];
>+    result[2][3] += x[2][2] * y[2][2];
>+    result[2][3] += x[2][3] * y[3][2];
>+    result[3][3] = 0;
>+    result[3][3] += x[3][0] * y[0][0];
>+    result[3][3] += x[3][1] * y[1][0];
>+    result[3][3] += x[3][2] * y[2][0];
>+    result[3][3] += x[3][3] * y[3][0];
>+    result[3][3] = 0;
>+    result[3][3] += x[3][0] * y[0][1];
>+    result[3][3] += x[3][1] * y[1][1];
>+    result[3][3] += x[3][2] * y[2][1];
>+    result[3][3] += x[3][3] * y[3][1];
>+    result[3][3] = 0;
>+    result[3][3] += x[3][0] * y[0][2];
>+    result[3][3] += x[3][1] * y[1][2];
>+    result[3][3] += x[3][2] * y[2][2];
>+    result[3][3] += x[3][3] * y[3][2];
>+    return result;
>+}
>+float4x4 mul(float4x4 x, float4x4 y) {
>+    float4x4 result;
>+    result[0][4] = 0;
>+    result[0][4] += x[0][0] * y[0][0];
>+    result[0][4] += x[0][1] * y[1][0];
>+    result[0][4] += x[0][2] * y[2][0];
>+    result[0][4] += x[0][3] * y[3][0];
>+    result[0][4] = 0;
>+    result[0][4] += x[0][0] * y[0][1];
>+    result[0][4] += x[0][1] * y[1][1];
>+    result[0][4] += x[0][2] * y[2][1];
>+    result[0][4] += x[0][3] * y[3][1];
>+    result[0][4] = 0;
>+    result[0][4] += x[0][0] * y[0][2];
>+    result[0][4] += x[0][1] * y[1][2];
>+    result[0][4] += x[0][2] * y[2][2];
>+    result[0][4] += x[0][3] * y[3][2];
>+    result[0][4] = 0;
>+    result[0][4] += x[0][0] * y[0][3];
>+    result[0][4] += x[0][1] * y[1][3];
>+    result[0][4] += x[0][2] * y[2][3];
>+    result[0][4] += x[0][3] * y[3][3];
>+    result[1][4] = 0;
>+    result[1][4] += x[1][0] * y[0][0];
>+    result[1][4] += x[1][1] * y[1][0];
>+    result[1][4] += x[1][2] * y[2][0];
>+    result[1][4] += x[1][3] * y[3][0];
>+    result[1][4] = 0;
>+    result[1][4] += x[1][0] * y[0][1];
>+    result[1][4] += x[1][1] * y[1][1];
>+    result[1][4] += x[1][2] * y[2][1];
>+    result[1][4] += x[1][3] * y[3][1];
>+    result[1][4] = 0;
>+    result[1][4] += x[1][0] * y[0][2];
>+    result[1][4] += x[1][1] * y[1][2];
>+    result[1][4] += x[1][2] * y[2][2];
>+    result[1][4] += x[1][3] * y[3][2];
>+    result[1][4] = 0;
>+    result[1][4] += x[1][0] * y[0][3];
>+    result[1][4] += x[1][1] * y[1][3];
>+    result[1][4] += x[1][2] * y[2][3];
>+    result[1][4] += x[1][3] * y[3][3];
>+    result[2][4] = 0;
>+    result[2][4] += x[2][0] * y[0][0];
>+    result[2][4] += x[2][1] * y[1][0];
>+    result[2][4] += x[2][2] * y[2][0];
>+    result[2][4] += x[2][3] * y[3][0];
>+    result[2][4] = 0;
>+    result[2][4] += x[2][0] * y[0][1];
>+    result[2][4] += x[2][1] * y[1][1];
>+    result[2][4] += x[2][2] * y[2][1];
>+    result[2][4] += x[2][3] * y[3][1];
>+    result[2][4] = 0;
>+    result[2][4] += x[2][0] * y[0][2];
>+    result[2][4] += x[2][1] * y[1][2];
>+    result[2][4] += x[2][2] * y[2][2];
>+    result[2][4] += x[2][3] * y[3][2];
>+    result[2][4] = 0;
>+    result[2][4] += x[2][0] * y[0][3];
>+    result[2][4] += x[2][1] * y[1][3];
>+    result[2][4] += x[2][2] * y[2][3];
>+    result[2][4] += x[2][3] * y[3][3];
>+    result[3][4] = 0;
>+    result[3][4] += x[3][0] * y[0][0];
>+    result[3][4] += x[3][1] * y[1][0];
>+    result[3][4] += x[3][2] * y[2][0];
>+    result[3][4] += x[3][3] * y[3][0];
>+    result[3][4] = 0;
>+    result[3][4] += x[3][0] * y[0][1];
>+    result[3][4] += x[3][1] * y[1][1];
>+    result[3][4] += x[3][2] * y[2][1];
>+    result[3][4] += x[3][3] * y[3][1];
>+    result[3][4] = 0;
>+    result[3][4] += x[3][0] * y[0][2];
>+    result[3][4] += x[3][1] * y[1][2];
>+    result[3][4] += x[3][2] * y[2][2];
>+    result[3][4] += x[3][3] * y[3][2];
>+    result[3][4] = 0;
>+    result[3][4] += x[3][0] * y[0][3];
>+    result[3][4] += x[3][1] * y[1][3];
>+    result[3][4] += x[3][2] * y[2][3];
>+    result[3][4] += x[3][3] * y[3][3];
>+    return result;
> }
>+
> `;
> 
> function intToString(x)
>@@ -384,6 +65096,31 @@ function intToString(x)
>     }
> }
> 
>+function addFunctionsFromClass(clss)
>+{
>+    standardLibrary += clss.functions().join(";\n") + "\n";
>+}
>+
>+const VectorElementTypes = [ "int32", "uint32", "float", "char", "uchar", "half", "short" ];
>+const VectorElementSizes = [ 2, 3, 4 ];
>+
>+function allVectorTypeNames()
>+{
>+    const names = [];
>+    for (let elementType of VectorElementTypes) {
>+        for (let size of VectorElementSizes)
>+            names.push(`${elementType}${size}`);
>+    }
>+    return names;
>+}
>+
> // There are 481 swizzle operators, so we compile them as native functions
>-standardLibrary += SwizzleOp.allSwizzleOperators().join(";\n") + ";";
>-console.log(standardLibrary);
>\ No newline at end of file
>+standardLibrary += SwizzleOp.functions().join(";\n") + ";\n";
>+standardLibrary += OperatorBool.functions().join(";\n") + ";\n";
>+standardLibrary += OperatorAnderIndexer.functions().join(";\n") + ";\n";
>+standardLibrary += BuiltinVectorCasts.functions().join(";\n") + ";\n";
>+standardLibrary += BuiltinVectorGetter.functions().join(";\n") + ";\n";
>+standardLibrary += BuiltinVectorSetter.functions().join(";\n") + ";\n";
>+standardLibrary += BuiltinVectorIndexGetter.functions().join(";\n") + ";\n";
>+standardLibrary += BuiltinVectorIndexSetter.functions().join(";\n") + ";\n";
>+standardLibrary += BuiltinVectorEqualityOperator.functions().join(";\n") + ";\n";
>diff --git a/Tools/WebGPUShadingLanguageRI/StatementCloner.js b/Tools/WebGPUShadingLanguageRI/StatementCloner.js
>index c9479a285ba0e13535dea37f7fc1a63bc71cf316..65e0c7a90f4dad302126431f7cf8261dd3e76bfc 100644
>--- a/Tools/WebGPUShadingLanguageRI/StatementCloner.js
>+++ b/Tools/WebGPUShadingLanguageRI/StatementCloner.js
>@@ -27,11 +27,9 @@
> class StatementCloner extends Rewriter {
>     visitFuncDef(node)
>     {
>-        let typeParameters = node.typeParameters.map(typeParameter => typeParameter.visit(this));
>         let result = new FuncDef(
>             node.origin, node.name,
>             node.returnType.visit(this),
>-            typeParameters,
>             node.parameters.map(parameter => parameter.visit(this)),
>             node.body.visit(this),
>             node.isCast, node.shaderType);
>@@ -44,7 +42,6 @@ class StatementCloner extends Rewriter {
>         let result = new NativeFunc(
>             node.origin, node.name,
>             node.returnType.visit(this),
>-            node.typeParameters.map(typeParameter => typeParameter.visit(this)),
>             node.parameters.map(parameter => parameter.visit(this)),
>             node.isCast, node.shaderType);
>         result.isRestricted = node.isRestricted;
>@@ -53,63 +50,27 @@ class StatementCloner extends Rewriter {
>     
>     visitNativeType(node)
>     {
>-        return new NativeType(
>-            node.origin, node.name, node.typeParameters.map(typeParameter => typeParameter.visit(this)));
>+        return new NativeType(node.origin, node.name);
>     }
>     
>     visitTypeDef(node)
>     {
>-        return new TypeDef(
>-            node.origin, node.name,
>-            node.typeParameters.map(typeParameter => typeParameter.visit(this)),
>-            node.type.visit(this));
>+        return new TypeDef(node.origin, node.name, node.type.visit(this));
>     }
>     
>     visitStructType(node)
>     {
>-        let result = new StructType(
>-            node.origin, node.name,
>-            node.typeParameters.map(typeParameter => typeParameter.visit(this)));
>+        let result = new StructType(node.origin, node.name);
>         for (let field of node.fields)
>             result.add(field.visit(this));
>         return result;
>     }
>     
>-    visitConstexprTypeParameter(node)
>-    {
>-        return new ConstexprTypeParameter(node.origin, node.name, node.type.visit(this));
>-    }
>-    
>-    visitProtocolDecl(node)
>-    {
>-        let result = new ProtocolDecl(node.origin, node.name);
>-        for (let protocol of node.extends)
>-            result.addExtends(protocol.visit(this));
>-        for (let signature of node.signatures)
>-            result.add(signature.visit(this));
>-        return result;
>-    }
>-
>-    visitTypeVariable(node)
>-    {
>-        return new TypeVariable(node.origin, node.name, Node.visit(node.protocol, this));
>-    }
>-    
>-    visitProtocolRef(node)
>-    {
>-        return new ProtocolRef(node.origin, node.name);
>-    }
>-    
>     visitBoolLiteral(node)
>     {
>         return new BoolLiteral(node.origin, node.value);
>     }
>     
>-    visitTypeOrVariableRef(node)
>-    {
>-        return new TypeOrVariableRef(node.origin, node.name);
>-    }
>-    
>     visitEnumType(node)
>     {
>         let result = new EnumType(node.origin, node.name, node.baseType.visit(this));
>diff --git a/Tools/WebGPUShadingLanguageRI/StructLayoutBuilder.js b/Tools/WebGPUShadingLanguageRI/StructLayoutBuilder.js
>index 4f98c573a1a38237e16450ae10b86cb2e61d1230..7441deeed43d062db1303676490f368ceb6d83d8 100644
>--- a/Tools/WebGPUShadingLanguageRI/StructLayoutBuilder.js
>+++ b/Tools/WebGPUShadingLanguageRI/StructLayoutBuilder.js
>@@ -39,8 +39,6 @@ class StructLayoutBuilder extends Visitor {
>     {
>         if (node.size != null)
>             return;
>-        if (node.typeParameters.length)
>-            throw new Error("Cannot do layout for generic type: " + node);
>         let oldOffset = this._offset;
>         this._offset = 0;
>         super.visitStructType(node);
>@@ -60,12 +58,6 @@ class StructLayoutBuilder extends Visitor {
>         this._offset += size;
>     }
>     
>-    visitNativeFuncInstance(node)
>-    {
>-        super.visitNativeFuncInstance(node);
>-        node.func.didLayoutStructsInImplementationData(node.implementationData);
>-    }
>-    
>     visitTypeRef(node)
>     {
>         super.visitTypeRef(node);
>@@ -76,13 +68,6 @@ class StructLayoutBuilder extends Visitor {
>     {
>         for (let argument of node.argumentList)
>             Node.visit(argument, this);
>-        let handleTypeArguments = actualTypeArguments => {
>-            if (actualTypeArguments) {
>-                for (let argument of actualTypeArguments)
>-                    argument.visit(this);
>-            }
>-        };
>-        handleTypeArguments(node.instantiatedActualTypeArguments);
>         Node.visit(node.nativeFuncInstance, this);
>         Node.visit(node.resultType, this);
>     }
>diff --git a/Tools/WebGPUShadingLanguageRI/StructType.js b/Tools/WebGPUShadingLanguageRI/StructType.js
>index f9d8c7da485832161e55d22a43876299337cb936..d156539c6bfc09749d371bd8ea80633dbddfbc49 100644
>--- a/Tools/WebGPUShadingLanguageRI/StructType.js
>+++ b/Tools/WebGPUShadingLanguageRI/StructType.js
>@@ -25,12 +25,11 @@
> "use strict";
> 
> class StructType extends Type {
>-    constructor(origin, name, typeParameters)
>+    constructor(origin, name)
>     {
>         super();
>         this._origin = origin;
>         this._name = name;
>-        this._typeParameters = typeParameters;
>         this._fields = new Map();
>     }
>     
>@@ -44,7 +43,6 @@ class StructType extends Type {
>     
>     get name() { return this._name; }
>     get origin() { return this._origin; }
>-    get typeParameters() { return this._typeParameters; }
>     
>     get fieldNames() { return this._fields.keys(); }
>     fieldByName(name) { return this._fields.get(name); }
>@@ -58,32 +56,6 @@ class StructType extends Type {
>         return result;
>     }
>     
>-    instantiate(typeArguments = null)
>-    {
>-        let substitution = null;
>-        let typeParameters = this.typeParameters;
>-        
>-        if (typeArguments) {
>-            if (typeArguments.length != this.typeParameters.length)
>-                throw new WTypeError(this.origin.originString, "Wrong number of type arguments to instantiation");
>-            
>-            substitution = new Substitution(this.typeParameters, typeArguments);
>-            typeParameters = [];
>-        }
>-        
>-        let instantiateImmediates = new InstantiateImmediates();
>-        let result = new StructType(this.origin, this.name, typeParameters);
>-        for (let field of this.fields) {
>-            let newField = field;
>-            if (substitution)
>-                newField = newField.visit(substitution);
>-            newField = newField.visit(instantiateImmediates);
>-            result.add(newField);
>-        }
>-        
>-        return result;
>-    }
>-    
>     populateDefaultValue(buffer, offset)
>     {
>         if (this.size == null)
>@@ -94,6 +66,6 @@ class StructType extends Type {
>     
>     toString()
>     {
>-        return "struct " + this.name + "<" + this.typeParameters + "> { " + Array.from(this.fields).join("; ") + "; }";
>+        return `struct ${this.name} { ${Array.from(this.fields).join("; ")}; }`;
>     }
> }
>diff --git a/Tools/WebGPUShadingLanguageRI/Substitution.js b/Tools/WebGPUShadingLanguageRI/Substitution.js
>index 6a223f6794a856c64308df40ab918aca2086fb29..4acdffcecc561a23342033e1b8dd31bae33566b8 100644
>--- a/Tools/WebGPUShadingLanguageRI/Substitution.js
>+++ b/Tools/WebGPUShadingLanguageRI/Substitution.js
>@@ -40,12 +40,8 @@ class Substitution extends Rewriter {
>     visitTypeRef(node)
>     {
>         let replacement = this._map.get(node.type);
>-        if (replacement) {
>-            if (node.typeArguments.length)
>-                throw new Error("Unexpected type arguments on type variable");
>-            let result = replacement.visit(new AutoWrapper());
>-            return result;
>-        }
>+        if (replacement)
>+            return replacement.visit(new AutoWrapper());
>         
>         let result = super.visitTypeRef(node);
>         return result;
>diff --git a/Tools/WebGPUShadingLanguageRI/SwizzleOp.js b/Tools/WebGPUShadingLanguageRI/SwizzleOp.js
>index d1c5bd0e6b3920f571de7c209486036b94548a74..07f810da78ac1fe778ad38e7dfb33cc840e209e2 100644
>--- a/Tools/WebGPUShadingLanguageRI/SwizzleOp.js
>+++ b/Tools/WebGPUShadingLanguageRI/SwizzleOp.js
>@@ -20,54 +20,72 @@
>  * 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. 
>+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
>  */
> "use strict";
> 
> class SwizzleOp {
>-    constructor(outSize, components, inSize)
>+    constructor(baseTypeName, outSize, components, inSize)
>     {
>+        this._baseTypeName = baseTypeName;
>         this._outSize = outSize;
>         this._components = components.slice(); // Shallow clone
>         this._inSize = inSize;
>     }
> 
>+    get baseTypeName() { return this._baseTypeName; }
>     get outSize() { return this._outSize; }
>     get components() { return this._components; }
>     get inSize() { return this._inSize; }
> 
>     toString()
>     {
>-        return `native vec${this.outSize}<T> operator.${this.components.join("")}<T>(vec${this.inSize}<T> v)`;
>+        return `native ${this.baseTypeName}${this.outSize} operator.${this.components.join("")}(${this.baseTypeName}${this.inSize} v)`;
>     }
> 
>-    static allSwizzleOperators()
>+    static functions()
>     {
>-        if (!SwizzleOp._allSwizzleOperators) {
>-            SwizzleOp._allSwizzleOperators = [];
>-            
>-            function _generateSwizzle(maxDepth, maxItems, array) {
>+        if (!this._functions) {
>+            // We can't directly use this._functions in _generateSwizzles.
>+            const functions = [];
>+
>+            function _generateSwizzle(baseTypeName, maxDepth, maxItems, array) {
>                 if (!array)
>                     array = [];
>                 if (array.length == maxDepth) {
>-                    SwizzleOp._allSwizzleOperators.push(new SwizzleOp(array.length, array, maxItems));
>+                    functions.push(new SwizzleOp(baseTypeName, array.length, array, maxItems));
>                     return;
>                 }
>                 for (let i = 0; i < maxItems; ++i) {
>                     array.push(intToString(i));
>-                    _generateSwizzle(maxDepth, maxItems, array);
>+                    _generateSwizzle(baseTypeName, maxDepth, maxItems, array);
>                     array.pop();
>                 }
>             };
>-        
>-            for (let maxDepth = 2; maxDepth <= 4; maxDepth++) {
>-                for (let maxItems = 2; maxItems <= 4; maxItems++)
>-                    _generateSwizzle(maxDepth, maxItems);
>+
>+            for (let typeName of VectorElementTypes) {
>+                for (let maxDepth of VectorElementSizes) {
>+                    for (let maxItems = 2; maxItems <= 4; maxItems++)
>+                        _generateSwizzle(typeName, maxDepth, maxItems);
>+                }
>             }
>+
>+            this._functions = functions;
>         }
>-        return SwizzleOp._allSwizzleOperators;
>+        return this._functions;
>     }
>-}
> 
>-// Initialise the static member (JS doesn't allow static fields declared in the class)
>-SwizzleOp._allSwizzleOperators = null;
>\ No newline at end of file
>+    instantiateImplementation(func)
>+    {
>+        func.implementation = ([vec], node) => {
>+            const outputBuffer = new EBuffer(this.outSize);
>+            const readIndices = { 'x': 0, 'y': 1, 'z': 2, 'w': 3 };
>+            for (let i = 0; i < this.outSize; i++)
>+                outputBuffer.set(i, vec.get(readIndices[this.components[i]]));
>+
>+
>+            return new EPtr(outputBuffer, 0);
>+        };
>+        func.implementationData = this;
>+    }
>+}
>\ No newline at end of file
>diff --git a/Tools/WebGPUShadingLanguageRI/SynthesizeArrayOperatorLength.js b/Tools/WebGPUShadingLanguageRI/SynthesizeArrayOperatorLength.js
>new file mode 100644
>index 0000000000000000000000000000000000000000..a719c6050fefaee3315dc1a9ee671787e70fa1d1
>--- /dev/null
>+++ b/Tools/WebGPUShadingLanguageRI/SynthesizeArrayOperatorLength.js
>@@ -0,0 +1,66 @@
>+/*
>+ * Copyright (C) 2017 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. ``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
>+ * 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.
>+ */
>+"use strict";
>+
>+function synthesizeArrayOperatorLength(program)
>+{
>+    const arrayTypes = new Set();
>+
>+    class FindArrayTypes extends Visitor {
>+        visitArrayType(node)
>+        {
>+            arrayTypes.add(node);
>+        }
>+    }
>+
>+    program.visit(new FindArrayTypes());
>+
>+    const uint32 = TypeRef.wrap(program.globalNameContext.get(Type, "uint32"));
>+    const nameResolver = new NameResolver(program.globalNameContext);
>+    uint32.visit(nameResolver);
>+
>+    for (let arrayType of arrayTypes) {
>+        const paramType = TypeRef.wrap(arrayType);
>+        paramType.visit(nameResolver);
>+        paramType.type.elementType.visit(nameResolver);
>+
>+        let possibleExistingFunctions = program.functions.get("operator.length");
>+        if (possibleExistingFunctions) {
>+            // Ignore user-defined functions, only include those introduced below.
>+            possibleExistingFunctions = possibleExistingFunctions.filter(t => t instanceof NativeFunc);
>+            const overloads = resolveOverloadImpl(possibleExistingFunctions, [ paramType ], uint32);
>+            if (overloads.func)
>+                continue;
>+        }
>+
>+        let nativeFunc = new NativeFunc(
>+            arrayType.origin, "operator.length", uint32,
>+            [ new FuncParameter(arrayType.origin, null, paramType) ],
>+            false, null);
>+        nativeFunc.implementation = ([array]) => EPtr.box(arrayType.numElementsValue);
>+        program.add(nativeFunc);
>+
>+    }
>+}
>diff --git a/Tools/WebGPUShadingLanguageRI/SynthesizeCopyConstructorOperator.js b/Tools/WebGPUShadingLanguageRI/SynthesizeCopyConstructorOperator.js
>new file mode 100644
>index 0000000000000000000000000000000000000000..0c7eb91ad19bbbf6c362b76ab24f9cd41c757d14
>--- /dev/null
>+++ b/Tools/WebGPUShadingLanguageRI/SynthesizeCopyConstructorOperator.js
>@@ -0,0 +1,63 @@
>+/*
>+ * Copyright (C) 2017 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. ``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
>+ * 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.
>+ */
>+"use strict";
>+
>+function synthesizeCopyConstructorOperator(program)
>+{
>+    const types = new Set();
>+
>+    class FindAllTypes extends Visitor {
>+        visitNativeType(node)
>+        {
>+            types.add(node);
>+        }
>+
>+        visitStructType(node)
>+        {
>+            types.add(node);
>+            super.visitStructType(node);
>+        }
>+
>+        visitElementalType(node)
>+        {
>+            types.add(node);
>+            super.visitElementalType(node);
>+        }
>+    }
>+
>+    program.visit(new FindAllTypes());
>+
>+    for (let type of types) {
>+        let nativeFunc = new NativeFunc(type.origin, "operator cast", TypeRef.wrap(type), [
>+            new FuncParameter(type.origin, null, TypeRef.wrap(type))
>+        ], true, null);
>+        nativeFunc.implementation = ([arg], node) => {
>+            let result = new EPtr(new EBuffer(type.size), 0);
>+            result.copyFrom(arg, type.size);
>+            return result;
>+        };
>+        program.add(nativeFunc);
>+    }
>+}
>diff --git a/Tools/WebGPUShadingLanguageRI/SynthesizeDefaultConstructorOperator.js b/Tools/WebGPUShadingLanguageRI/SynthesizeDefaultConstructorOperator.js
>new file mode 100644
>index 0000000000000000000000000000000000000000..e25fe512fe2fd1631a49593322ebf20d618afd61
>--- /dev/null
>+++ b/Tools/WebGPUShadingLanguageRI/SynthesizeDefaultConstructorOperator.js
>@@ -0,0 +1,61 @@
>+/*
>+ * Copyright (C) 2017 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. ``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
>+ * 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.
>+ */
>+"use strict";
>+
>+function synthesizeDefaultConstructorOperator(program)
>+{
>+    const types = new Set();
>+
>+    class FindAllTypes extends Visitor {
>+        visitNativeType(node)
>+        {
>+            types.add(node);
>+        }
>+
>+        visitStructType(node)
>+        {
>+            types.add(node);
>+            super.visitStructType(node);
>+        }
>+
>+        visitElementalType(node)
>+        {
>+            types.add(node);
>+            super.visitElementalType(node);
>+        }
>+    }
>+
>+    program.visit(new FindAllTypes());
>+
>+    for (let type of types) {
>+        let nativeFunc = new NativeFunc(type.origin, "operator cast", TypeRef.wrap(type), [], true, null);
>+        nativeFunc.implementation = ([], node) => {
>+            let result = new EPtr(new EBuffer(type.size), 0);
>+            node.type.populateDefaultValue(result.buffer, 0);
>+            return result;
>+        };
>+        program.add(nativeFunc);
>+    }
>+}
>diff --git a/Tools/WebGPUShadingLanguageRI/SynthesizeEnumFunctions.js b/Tools/WebGPUShadingLanguageRI/SynthesizeEnumFunctions.js
>index 5af2bdf93a805fc08c29f1ea0510ce29e280a56f..d28fcebb394fa90723e0d613aaa2256bb5b0b15a 100644
>--- a/Tools/WebGPUShadingLanguageRI/SynthesizeEnumFunctions.js
>+++ b/Tools/WebGPUShadingLanguageRI/SynthesizeEnumFunctions.js
>@@ -20,7 +20,7 @@
>  * 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. 
>+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
>  */
> "use strict";
> 
>@@ -29,37 +29,37 @@ function synthesizeEnumFunctions(program)
>     for (let type of program.types.values()) {
>         if (!(type instanceof EnumType))
>             continue;
>-        
>+
>         let nativeFunc;
>         let isCast = false;
>         let shaderType;
>-        
>+
>         nativeFunc = new NativeFunc(
>-            type.origin, "operator==", new TypeRef(type.origin, "bool", []), [],
>+            type.origin, "operator==", new TypeRef(type.origin, "bool", []),
>             [
>-                new FuncParameter(type.origin, null, new TypeRef(type.origin, type.name, [])),
>-                new FuncParameter(type.origin, null, new TypeRef(type.origin, type.name, []))
>+                new FuncParameter(type.origin, null, new TypeRef(type.origin, type.name)),
>+                new FuncParameter(type.origin, null, new TypeRef(type.origin, type.name))
>             ],
>             isCast, shaderType);
>         nativeFunc.implementation = ([left, right]) => EPtr.box(left.loadValue() == right.loadValue());
>         program.add(nativeFunc);
>-        
>+
>         nativeFunc = new NativeFunc(
>-            type.origin, "operator.value", type.baseType.visit(new Rewriter()), [],
>+            type.origin, "operator.value", type.baseType.visit(new Rewriter()),
>             [new FuncParameter(type.origin, null, new TypeRef(type.origin, type.name, []))],
>             isCast, shaderType);
>         nativeFunc.implementation = ([value]) => value;
>         program.add(nativeFunc);
>-        
>+
>         nativeFunc = new NativeFunc(
>-            type.origin, "operator cast", type.baseType.visit(new Rewriter()), [],
>+            type.origin, "operator cast", type.baseType.visit(new Rewriter()),
>             [new FuncParameter(type.origin, null, new TypeRef(type.origin, type.name, []))],
>             isCast, shaderType);
>         nativeFunc.implementation = ([value]) => value;
>         program.add(nativeFunc);
>-        
>+
>         nativeFunc = new NativeFunc(
>-            type.origin, "operator cast", new TypeRef(type.origin, type.name, []), [],
>+            type.origin, "operator cast", new TypeRef(type.origin, type.name, []),
>             [new FuncParameter(type.origin, null, type.baseType.visit(new Rewriter()))],
>             isCast, shaderType);
>         nativeFunc.implementation = ([value]) => value;
>diff --git a/Tools/WebGPUShadingLanguageRI/SynthesizeOperatorBool.js b/Tools/WebGPUShadingLanguageRI/SynthesizeOperatorBool.js
>new file mode 100644
>index 0000000000000000000000000000000000000000..cce7f3f29a8e13f761a723dbd93c9a07eeb0ce54
>--- /dev/null
>+++ b/Tools/WebGPUShadingLanguageRI/SynthesizeOperatorBool.js
>@@ -0,0 +1,38 @@
>+/*
>+ * Copyright (C) 2017 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. ``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
>+ * 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. 
>+ */
>+"use strict";
>+
>+function synthesizeOperatorBool(program)
>+{
>+    for (let type of program.types.values()) {
>+        if (!(type instanceof StructType) && !(type instanceof EnumType))
>+            continue;
>+        
>+        const func = new NativeFunc(type.origin, "operator cast", TypeRef.wrap(program.types.get("bool")), [ new FuncParameter(type.origin, null, TypeRef.wrap(type)) ], true, null);
>+        const operatorBool = new OperatorBool(type.name);
>+        operatorBool.instantiateImplementation(func);
>+        program.add(func);
>+    }
>+}
>diff --git a/Tools/WebGPUShadingLanguageRI/SynthesizeStructAccessors.js b/Tools/WebGPUShadingLanguageRI/SynthesizeStructAccessors.js
>index f7816f2b252e9ba4da9ec84def611c55e4bfe3a9..937e6e0301ecd5a8abcced482d33c4c84f544e93 100644
>--- a/Tools/WebGPUShadingLanguageRI/SynthesizeStructAccessors.js
>+++ b/Tools/WebGPUShadingLanguageRI/SynthesizeStructAccessors.js
>@@ -31,27 +31,10 @@ function synthesizeStructAccessors(program)
>             continue;
>         
>         for (let field of type.fields) {
>-            function createTypeParameters()
>-            {
>-                return type.typeParameters.map(
>-                    typeParameter => typeParameter.visit(new TypeParameterRewriter()));
>-            }
>-            
>-            function createTypeArguments()
>-            {
>-                return typeParameters.map(typeParameter => typeParameter.visit(new AutoWrapper()));
>-            }
>-            
>             function setupImplementationData(nativeFunc, implementation)
>             {
>                 nativeFunc.instantiateImplementation = substitution => {
>-                    let newType = type.instantiate(nativeFunc.typeParameters.map(typeParameter => {
>-                        let substitute = substitution.map.get(typeParameter);
>-                        if (!substitute)
>-                            throw new Error("Null substitute for type parameter " + typeParameter);
>-                        return substitute;
>-                    }));
>-                    return {type: newType, fieldName: field.name};
>+                    return {type: type, fieldName: field.name};
>                 };
>                 nativeFunc.visitImplementationData = (implementationData, visitor) => {
>                     // Visiting the type first ensures that the struct layout builder figures out the field's
>@@ -89,23 +72,21 @@ function synthesizeStructAccessors(program)
>             
>             function createFieldType()
>             {
>-                return field.type.visit(new Substitution(type.typeParameters, typeParameters));
>+                return field.type.visit(new AutoWrapper());
>             }
>             
>             function createTypeRef()
>             {
>-                return TypeRef.instantiate(type, createTypeArguments());
>+                return TypeRef.instantiate(type);
>             }
>             
>             let isCast = false;
>             let shaderType;
>-            let typeParameters;
>             let nativeFunc;
> 
>             // The getter: operator.field
>-            typeParameters = createTypeParameters();
>             nativeFunc = new NativeFunc(
>-                field.origin, "operator." + field.name, createFieldType(), typeParameters,
>+                field.origin, "operator." + field.name, createFieldType(),
>                 [new FuncParameter(field.origin, null, createTypeRef())], isCast, shaderType);
>             setupImplementationData(nativeFunc, ([base], offset, structSize, fieldSize) => {
>                 let result = new EPtr(new EBuffer(fieldSize), 0);
>@@ -115,9 +96,8 @@ function synthesizeStructAccessors(program)
>             program.add(nativeFunc);
>             
>             // The setter: operator.field=
>-            typeParameters = createTypeParameters();
>             nativeFunc = new NativeFunc(
>-                field.origin, "operator." + field.name + "=", createTypeRef(), typeParameters,
>+                field.origin, "operator." + field.name + "=", createTypeRef(),
>                 [
>                     new FuncParameter(field.origin, null, createTypeRef()),
>                     new FuncParameter(field.origin, null, createFieldType())
>@@ -134,10 +114,8 @@ function synthesizeStructAccessors(program)
>             // The ander: operator&.field
>             function setupAnder(addressSpace)
>             {
>-                typeParameters = createTypeParameters();
>                 nativeFunc = new NativeFunc(
>                     field.origin, "operator&." + field.name, new PtrType(field.origin, addressSpace, createFieldType()),
>-                    typeParameters,
>                     [
>                         new FuncParameter(
>                             field.origin, null,
>diff --git a/Tools/WebGPUShadingLanguageRI/TernaryExpression.js b/Tools/WebGPUShadingLanguageRI/TernaryExpression.js
>new file mode 100644
>index 0000000000000000000000000000000000000000..a6f5a0021c89b9b48e56639ca58f1e519f26f69a
>--- /dev/null
>+++ b/Tools/WebGPUShadingLanguageRI/TernaryExpression.js
>@@ -0,0 +1,47 @@
>+/*
>+ * Copyright (C) 2018 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. ``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
>+ * 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. 
>+ */
>+"use strict";
>+
>+class TernaryExpression extends Expression {
>+    constructor(origin, predicate, bodyExpression, elseExpression)
>+    {
>+        super(origin);
>+        this._predicate = predicate;
>+        this._bodyExpression = bodyExpression;
>+        this._elseExpression = elseExpression;
>+        this._isLValue = null; // We use null to indicate that we don't know yet.
>+    }
>+    
>+    get predicate() { return this._predicate; }
>+    get bodyExpression() { return this._bodyExpression; }
>+    get elseExpression() { return this._elseExpression; }
>+    get isLValue() { return this._isLValue; }
>+    set isLValue(value) { this._isLValue = value; }
>+    
>+    toString()
>+    {
>+        return "(" + this.predicate + ") ? (" + this.bodyExpression + ") : (" + this.elseExpression + ")";
>+    }
>+}
>diff --git a/Tools/WebGPUShadingLanguageRI/Test.html b/Tools/WebGPUShadingLanguageRI/Test.html
>index a641d3046493dabc2d745e7d0ec96d0bdd441bbc..771eb1b209dd85f598d783f2cdf50549aa8a8f84 100644
>--- a/Tools/WebGPUShadingLanguageRI/Test.html
>+++ b/Tools/WebGPUShadingLanguageRI/Test.html
>@@ -12,6 +12,7 @@
> <script src="CreateLiteralType.js"></script>
> <script src="PropertyAccessExpression.js"></script>
> <script src="SwizzleOp.js"></script>
>+<script src="NativeType.js"></script>
> 
> <script src="AddressSpace.js"></script>
> <script src="AnonymousVariable.js"></script>
>@@ -22,7 +23,14 @@
> <script src="Block.js"></script>
> <script src="BoolLiteral.js"></script>
> <script src="Break.js"></script>
>+<script src="BuiltinVectorCasts.js"></script>
>+<script src="BuiltinVectorGetter.js"></script>
>+<script src="BuiltinVectorSetter.js"></script>
>+<script src="BuiltinVectorIndexGetter.js"></script>
>+<script src="BuiltinVectorIndexSetter.js"></script>
>+<script src="BuiltinVectorEqualityOperator.js"></script>
> <script src="CallExpression.js"></script>
>+<script src="CallExpressionTypeArgumentResolver.js"></script>
> <script src="CallFunction.js"></script>
> <script src="Check.js"></script>
> <script src="CheckLiteralTypes.js"></script>
>@@ -36,7 +44,6 @@
> <script src="CloneProgram.js"></script>
> <script src="CommaExpression.js"></script>
> <script src="ConstexprFolder.js"></script>
>-<script src="ConstexprTypeParameter.js"></script>
> <script src="Continue.js"></script>
> <script src="ConvertPtrToArrayRefExpression.js"></script>
> <script src="DoWhileLoop.js"></script>
>@@ -55,7 +62,6 @@
> <script src="ExternalOrigin.js"></script>
> <script src="Field.js"></script>
> <script src="FindHighZombies.js"></script>
>-<script src="FlattenProtocolExtends.js"></script>
> <script src="FlattenedStructOffsetGatherer.js"></script>
> <script src="FloatLiteral.js"></script>
> <script src="FloatLiteralType.js"></script>
>@@ -63,7 +69,6 @@
> <script src="ForLoop.js"></script>
> <script src="Func.js"></script>
> <script src="FuncDef.js"></script>
>-<script src="FuncInstantiator.js"></script>
> <script src="FuncParameter.js"></script>
> <script src="FunctionLikeBlock.js"></script>
> <script src="HighZombieFinder.js"></script>
>@@ -73,7 +78,6 @@
> <script src="InferTypesForCall.js"></script>
> <script src="Inline.js"></script>
> <script src="Inliner.js"></script>
>-<script src="InstantiateImmediates.js"></script>
> <script src="IntLiteral.js"></script>
> <script src="IntLiteralType.js"></script>
> <script src="Intrinsics.js"></script>
>@@ -91,11 +95,14 @@
> <script src="NameResolver.js"></script>
> <script src="NativeFunc.js"></script>
> <script src="NativeFuncInstance.js"></script>
>+<script src="NativeParameterizedType.js"></script>
> <script src="NativeType.js"></script>
>-<script src="NativeTypeInstance.js"></script>
> <script src="NormalUsePropertyResolver.js"></script>
> <script src="NullLiteral.js"></script>
> <script src="NullType.js"></script>
>+<script src="OperatorAnderIndex.js"></script>
>+<script src="OperatorArrayRefLength.js"></script>
>+<script src="OperatorBool.js"></script>
> <script src="OriginKind.js"></script>
> <script src="OverloadResolutionFailure.js"></script>
> <script src="Parse.js"></script>
>@@ -103,14 +110,11 @@
> <script src="PropertyResolver.js"></script>
> <script src="Program.js"></script>
> <script src="ProgramWithUnnecessaryThingsRemoved.js"></script>
>-<script src="Protocol.js"></script>
>-<script src="ProtocolDecl.js"></script>
>-<script src="ProtocolFuncDecl.js"></script>
>-<script src="ProtocolRef.js"></script>
> <script src="PtrType.js"></script>
> <script src="ReadModifyWriteExpression.js"></script>
> <script src="RecursionChecker.js"></script>
> <script src="RecursiveTypeChecker.js"></script>
>+<script src="ResolveCallExpressionsWithTypeArguments.js"></script>
> <script src="ResolveNames.js"></script>
> <script src="ResolveOverloadImpl.js"></script>
> <script src="ResolveProperties.js"></script>
>@@ -122,19 +126,23 @@
> <script src="StatementCloner.js"></script>
> <script src="StructLayoutBuilder.js"></script>
> <script src="StructType.js"></script>
>-<script src="Substitution.js"></script>
> <script src="SwitchCase.js"></script>
> <script src="SwitchStatement.js"></script>
>+<script src="SynthesizeArrayOperatorLength.js"></script>
> <script src="SynthesizeEnumFunctions.js"></script>
> <script src="SynthesizeStructAccessors.js"></script>
>+<script src="SynthesizeOperatorBool.js"></script>
>+<script src="SynthesizeCopyConstructorOperator.js"></script>
>+<script src="SynthesizeDefaultConstructorOperator.js"></script>
>+<script src="TrapStatement.js"></script>
>+<script src="TypeDef.js"></script>
>+<script src="TypeDefResolver.js"></script>
>+<script src="TernaryExpression.js"></script>
> <script src="TrapStatement.js"></script>
> <script src="TypeDef.js"></script>
> <script src="TypeDefResolver.js"></script>
> <script src="TypeOrVariableRef.js"></script>
>-<script src="TypeParameterRewriter.js"></script>
> <script src="TypeRef.js"></script>
>-<script src="TypeVariable.js"></script>
>-<script src="TypeVariableTracker.js"></script>
> <script src="TypedValue.js"></script>
> <script src="UintLiteral.js"></script>
> <script src="UintLiteralType.js"></script>
>@@ -142,6 +150,7 @@
> <script src="UnreachableCodeChecker.js"></script>
> <script src="VariableDecl.js"></script>
> <script src="VariableRef.js"></script>
>+<script src="VectorType.js"></script>
> <script src="VisitingSet.js"></script>
> <script src="WSyntaxError.js"></script>
> <script src="WTrapError.js"></script>
>@@ -172,6 +181,12 @@ function doTestInBrowser()
> }
> </script>
> 
>+<style>
>+    pre {
>+        margin:0;
>+    }
>+</style>
>+
> </head>
> <body onload="doTestInBrowser()">
> <div id="messages"></div>
>diff --git a/Tools/WebGPUShadingLanguageRI/Test.js b/Tools/WebGPUShadingLanguageRI/Test.js
>index 322a0a717850d73290848e93bf95bd3a24241c66..2bd9c2e0e203a62de502b4afffb1590016fce020 100644
>--- a/Tools/WebGPUShadingLanguageRI/Test.js
>+++ b/Tools/WebGPUShadingLanguageRI/Test.js
>@@ -26,9 +26,9 @@
> 
> if (this.window) {
>     this.print = (text) => {
>-        var span = document.createElement("span");
>+        var span = document.createElement("pre");
>         document.getElementById("messages").appendChild(span);
>-        span.innerHTML = text.replace(/ /g, "&nbsp;").replace(/\n/g, "<br>") + "<br>";
>+        span.innerText = text;
>         window.scrollTo(0,document.body.scrollHeight);
>     };
>     this.preciseTime = () => performance.now() / 1000;
>@@ -187,7 +187,7 @@ tests.commentParsing = function() {
>         runs over multiple lines */
>         bool foo() { return true; }
>     `);
>-    checkBool(program, callFunction(program, "foo", [], []), true);
>+    checkBool(program, callFunction(program, "foo", []), true);
> 
>     checkFail(
>         () => doPrep(`
>@@ -198,94 +198,156 @@ tests.commentParsing = function() {
>         (e) => e instanceof WSyntaxError);
> }
> 
>+tests.ternaryExpression = function() {
>+    let program = doPrep(`
>+        int foo(int x)
>+        {
>+            return x < 3 ? 4 : 5;
>+        }
>+        int bar(int x)
>+        {
>+            int y = 1;
>+            int z = 2;
>+            (x < 3 ? y : z) = 7;
>+            return y;
>+        }
>+        int baz(int x)
>+        {
>+            return x < 10 ? 11 : x < 12 ? 14 : 15;
>+        }
>+        int quux(int x)
>+        {
>+            return 3 < 4 ? x : 5;
>+        }
>+    `);
>+    checkInt(program, callFunction(program, "foo", [], [makeInt(program, 767)]), 5);
>+    checkInt(program, callFunction(program, "foo", [], [makeInt(program, 2)]), 4);
>+    checkInt(program, callFunction(program, "bar", [], [makeInt(program, 2)]), 7);
>+    checkInt(program, callFunction(program, "bar", [], [makeInt(program, 8)]), 1);
>+    checkInt(program, callFunction(program, "baz", [], [makeInt(program, 8)]), 11);
>+    checkInt(program, callFunction(program, "baz", [], [makeInt(program, 9)]), 11);
>+    checkInt(program, callFunction(program, "baz", [], [makeInt(program, 10)]), 14);
>+    checkInt(program, callFunction(program, "baz", [], [makeInt(program, 11)]), 14);
>+    checkInt(program, callFunction(program, "baz", [], [makeInt(program, 12)]), 15);
>+    checkInt(program, callFunction(program, "baz", [], [makeInt(program, 13)]), 15);
>+    checkInt(program, callFunction(program, "quux", [], [makeInt(program, 14)]), 14);
>+    checkFail(
>+        () => doPrep(`
>+            int foo()
>+            {
>+                int x;
>+                (4 < 5 ? x : 7) = 8;
>+            }
>+        `),
>+        (e) => e instanceof WTypeError);
>+    checkFail(
>+        () => doPrep(`
>+            int foo()
>+            {
>+                int x;
>+                float y;
>+                return 4 < 5 ? x : y;
>+            }
>+        `),
>+        (e) => e instanceof WTypeError);
>+    checkFail(
>+        () => doPrep(`
>+            int foo()
>+            {
>+                return 4 < 5 ? 6 : 7.0;
>+            }
>+        `),
>+        (e) => e instanceof WTypeError);
>+}
>+
> tests.literalBool = function() {
>     let program = doPrep("bool foo() { return true; }");
>-    checkBool(program, callFunction(program, "foo", [], []), true);
>+    checkBool(program, callFunction(program, "foo", []), true);
> }
> 
> tests.identityBool = function() {
>     let program = doPrep("bool foo(bool x) { return x; }");
>-    checkBool(program, callFunction(program, "foo", [], [makeBool(program, true)]), true);
>-    checkBool(program, callFunction(program, "foo", [], [makeBool(program, false)]), false);
>+    checkBool(program, callFunction(program, "foo", [makeBool(program, true)]), true);
>+    checkBool(program, callFunction(program, "foo", [makeBool(program, false)]), false);
> }
> 
> tests.intSimpleMath = function() {
>     let program = doPrep("int foo(int x, int y) { return x + y; }");
>-    checkInt(program, callFunction(program, "foo", [], [makeInt(program, 7), makeInt(program, 5)]), 12);
>+    checkInt(program, callFunction(program, "foo", [makeInt(program, 7), makeInt(program, 5)]), 12);
>     program = doPrep("int foo(int x, int y) { return x - y; }");
>-    checkInt(program, callFunction(program, "foo", [], [makeInt(program, 7), makeInt(program, 5)]), 2);
>-    checkInt(program, callFunction(program, "foo", [], [makeInt(program, 5), makeInt(program, 7)]), -2);
>+    checkInt(program, callFunction(program, "foo", [makeInt(program, 7), makeInt(program, 5)]), 2);
>+    checkInt(program, callFunction(program, "foo", [makeInt(program, 5), makeInt(program, 7)]), -2);
>     program = doPrep("int foo(int x, int y) { return x * y; }");
>-    checkInt(program, callFunction(program, "foo", [], [makeInt(program, 7), makeInt(program, 5)]), 35);
>-    checkInt(program, callFunction(program, "foo", [], [makeInt(program, 7), makeInt(program, -5)]), -35);
>+    checkInt(program, callFunction(program, "foo", [makeInt(program, 7), makeInt(program, 5)]), 35);
>+    checkInt(program, callFunction(program, "foo", [makeInt(program, 7), makeInt(program, -5)]), -35);
>     program = doPrep("int foo(int x, int y) { return x / y; }");
>-    checkInt(program, callFunction(program, "foo", [], [makeInt(program, 7), makeInt(program, 2)]), 3);
>-    checkInt(program, callFunction(program, "foo", [], [makeInt(program, 7), makeInt(program, -2)]), -3);
>+    checkInt(program, callFunction(program, "foo", [makeInt(program, 7), makeInt(program, 2)]), 3);
>+    checkInt(program, callFunction(program, "foo", [makeInt(program, 7), makeInt(program, -2)]), -3);
> }
> 
> tests.uintSimpleMath = function() {
>     let program = doPrep("uint foo(uint x, uint y) { return x + y; }");
>-    checkUint(program, callFunction(program, "foo", [], [makeUint(program, 7), makeUint(program, 5)]), 12);
>+    checkUint(program, callFunction(program, "foo", [makeUint(program, 7), makeUint(program, 5)]), 12);
>     program = doPrep("uint foo(uint x, uint y) { return x - y; }");
>-    checkUint(program, callFunction(program, "foo", [], [makeUint(program, 7), makeUint(program, 5)]), 2);
>-    checkUint(program, callFunction(program, "foo", [], [makeUint(program, 5), makeUint(program, 7)]), 4294967294);
>+    checkUint(program, callFunction(program, "foo", [makeUint(program, 7), makeUint(program, 5)]), 2);
>+    checkUint(program, callFunction(program, "foo", [makeUint(program, 5), makeUint(program, 7)]), 4294967294);
>     program = doPrep("uint foo(uint x, uint y) { return x * y; }");
>-    checkUint(program, callFunction(program, "foo", [], [makeUint(program, 7), makeUint(program, 5)]), 35);
>+    checkUint(program, callFunction(program, "foo", [makeUint(program, 7), makeUint(program, 5)]), 35);
>     program = doPrep("uint foo(uint x, uint y) { return x / y; }");
>-    checkUint(program, callFunction(program, "foo", [], [makeUint(program, 7), makeUint(program, 2)]), 3);
>+    checkUint(program, callFunction(program, "foo", [makeUint(program, 7), makeUint(program, 2)]), 3);
> }
> 
> tests.uint8SimpleMath = function() {
>     let program = doPrep("uint8 foo(uint8 x, uint8 y) { return x + y; }");
>-    checkUint8(program, callFunction(program, "foo", [], [makeUint8(program, 7), makeUint8(program, 5)]), 12);
>+    checkUint8(program, callFunction(program, "foo", [makeUint8(program, 7), makeUint8(program, 5)]), 12);
>     program = doPrep("uint8 foo(uint8 x, uint8 y) { return x - y; }");
>-    checkUint8(program, callFunction(program, "foo", [], [makeUint8(program, 7), makeUint8(program, 5)]), 2);
>-    checkUint8(program, callFunction(program, "foo", [], [makeUint8(program, 5), makeUint8(program, 7)]), 254);
>+    checkUint8(program, callFunction(program, "foo", [makeUint8(program, 7), makeUint8(program, 5)]), 2);
>+    checkUint8(program, callFunction(program, "foo", [makeUint8(program, 5), makeUint8(program, 7)]), 254);
>     program = doPrep("uint8 foo(uint8 x, uint8 y) { return x * y; }");
>-    checkUint8(program, callFunction(program, "foo", [], [makeUint8(program, 7), makeUint8(program, 5)]), 35);
>+    checkUint8(program, callFunction(program, "foo", [makeUint8(program, 7), makeUint8(program, 5)]), 35);
>     program = doPrep("uint8 foo(uint8 x, uint8 y) { return x / y; }");
>-    checkUint8(program, callFunction(program, "foo", [], [makeUint8(program, 7), makeUint8(program, 2)]), 3);
>+    checkUint8(program, callFunction(program, "foo", [makeUint8(program, 7), makeUint8(program, 2)]), 3);
> }
> 
> tests.equality = function() {
>     let program = doPrep("bool foo(uint x, uint y) { return x == y; }");
>-    checkBool(program, callFunction(program, "foo", [], [makeUint(program, 7), makeUint(program, 5)]), false);
>-    checkBool(program, callFunction(program, "foo", [], [makeUint(program, 7), makeUint(program, 7)]), true);
>+    checkBool(program, callFunction(program, "foo", [makeUint(program, 7), makeUint(program, 5)]), false);
>+    checkBool(program, callFunction(program, "foo", [makeUint(program, 7), makeUint(program, 7)]), true);
>     program = doPrep("bool foo(uint8 x, uint8 y) { return x == y; }");
>-    checkBool(program, callFunction(program, "foo", [], [makeUint8(program, 7), makeUint8(program, 5)]), false);
>-    checkBool(program, callFunction(program, "foo", [], [makeUint8(program, 7), makeUint8(program, 7)]), true);
>+    checkBool(program, callFunction(program, "foo", [makeUint8(program, 7), makeUint8(program, 5)]), false);
>+    checkBool(program, callFunction(program, "foo", [makeUint8(program, 7), makeUint8(program, 7)]), true);
>     program = doPrep("bool foo(int x, int y) { return x == y; }");
>-    checkBool(program, callFunction(program, "foo", [], [makeInt(program, 7), makeInt(program, 5)]), false);
>-    checkBool(program, callFunction(program, "foo", [], [makeInt(program, 7), makeInt(program, 7)]), true);
>+    checkBool(program, callFunction(program, "foo", [makeInt(program, 7), makeInt(program, 5)]), false);
>+    checkBool(program, callFunction(program, "foo", [makeInt(program, 7), makeInt(program, 7)]), true);
>     program = doPrep("bool foo(bool x, bool y) { return x == y; }");
>-    checkBool(program, callFunction(program, "foo", [], [makeBool(program, false), makeBool(program, true)]), false);
>-    checkBool(program, callFunction(program, "foo", [], [makeBool(program, true), makeBool(program, false)]), false);
>-    checkBool(program, callFunction(program, "foo", [], [makeBool(program, false), makeBool(program, false)]), true);
>-    checkBool(program, callFunction(program, "foo", [], [makeBool(program, true), makeBool(program, true)]), true);
>+    checkBool(program, callFunction(program, "foo", [makeBool(program, false), makeBool(program, true)]), false);
>+    checkBool(program, callFunction(program, "foo", [makeBool(program, true), makeBool(program, false)]), false);
>+    checkBool(program, callFunction(program, "foo", [makeBool(program, false), makeBool(program, false)]), true);
>+    checkBool(program, callFunction(program, "foo", [makeBool(program, true), makeBool(program, true)]), true);
> }
> 
> tests.logicalNegation = function()
> {
>     let program = doPrep("bool foo(bool x) { return !x; }");
>-    checkBool(program, callFunction(program, "foo", [], [makeBool(program, true)]), false);
>-    checkBool(program, callFunction(program, "foo", [], [makeBool(program, false)]), true);
>+    checkBool(program, callFunction(program, "foo", [makeBool(program, true)]), false);
>+    checkBool(program, callFunction(program, "foo", [makeBool(program, false)]), true);
> }
> 
> tests.notEquality = function() {
>     let program = doPrep("bool foo(uint x, uint y) { return x != y; }");
>-    checkBool(program, callFunction(program, "foo", [], [makeUint(program, 7), makeUint(program, 5)]), true);
>-    checkBool(program, callFunction(program, "foo", [], [makeUint(program, 7), makeUint(program, 7)]), false);
>+    checkBool(program, callFunction(program, "foo", [makeUint(program, 7), makeUint(program, 5)]), true);
>+    checkBool(program, callFunction(program, "foo", [makeUint(program, 7), makeUint(program, 7)]), false);
>     program = doPrep("bool foo(uint8 x, uint8 y) { return x != y; }");
>-    checkBool(program, callFunction(program, "foo", [], [makeUint8(program, 7), makeUint8(program, 5)]), true);
>-    checkBool(program, callFunction(program, "foo", [], [makeUint8(program, 7), makeUint8(program, 7)]), false);
>+    checkBool(program, callFunction(program, "foo", [makeUint8(program, 7), makeUint8(program, 5)]), true);
>+    checkBool(program, callFunction(program, "foo", [makeUint8(program, 7), makeUint8(program, 7)]), false);
>     program = doPrep("bool foo(int x, int y) { return x != y; }");
>-    checkBool(program, callFunction(program, "foo", [], [makeInt(program, 7), makeInt(program, 5)]), true);
>-    checkBool(program, callFunction(program, "foo", [], [makeInt(program, 7), makeInt(program, 7)]), false);
>+    checkBool(program, callFunction(program, "foo", [makeInt(program, 7), makeInt(program, 5)]), true);
>+    checkBool(program, callFunction(program, "foo", [makeInt(program, 7), makeInt(program, 7)]), false);
>     program = doPrep("bool foo(bool x, bool y) { return x != y; }");
>-    checkBool(program, callFunction(program, "foo", [], [makeBool(program, false), makeBool(program, true)]), true);
>-    checkBool(program, callFunction(program, "foo", [], [makeBool(program, true), makeBool(program, false)]), true);
>-    checkBool(program, callFunction(program, "foo", [], [makeBool(program, false), makeBool(program, false)]), false);
>-    checkBool(program, callFunction(program, "foo", [], [makeBool(program, true), makeBool(program, true)]), false);
>+    checkBool(program, callFunction(program, "foo", [makeBool(program, false), makeBool(program, true)]), true);
>+    checkBool(program, callFunction(program, "foo", [makeBool(program, true), makeBool(program, false)]), true);
>+    checkBool(program, callFunction(program, "foo", [makeBool(program, false), makeBool(program, false)]), false);
>+    checkBool(program, callFunction(program, "foo", [makeBool(program, true), makeBool(program, true)]), false);
> }
> 
> tests.equalityTypeFailure = function()
>@@ -298,21 +360,13 @@ tests.equalityTypeFailure = function()
> tests.generalNegation = function()
> {
>     let program = doPrep("bool foo(int x) { return !x; }");
>-    checkBool(program, callFunction(program, "foo", [], [makeInt(program, 7)]), false);
>-    checkBool(program, callFunction(program, "foo", [], [makeInt(program, 0)]), true);
>+    checkBool(program, callFunction(program, "foo", [makeInt(program, 7)]), false);
>+    checkBool(program, callFunction(program, "foo", [makeInt(program, 0)]), true);
> }
> 
> tests.add1 = function() {
>     let program = doPrep("int foo(int x) { return x + 1; }");
>-    checkInt(program, callFunction(program, "foo", [], [makeInt(program, 42)]), 43);
>-}
>-
>-tests.simpleGeneric = function() {
>-    let program = doPrep(`
>-        T id<T>(T x) { return x; }
>-        int foo(int x) { return id(x) + 1; }
>-    `);
>-    checkInt(program, callFunction(program, "foo", [], [makeInt(program, 42)]), 43);
>+    checkInt(program, callFunction(program, "foo", [makeInt(program, 42)]), 43);
> }
> 
> tests.nameResolutionFailure = function()
>@@ -331,7 +385,7 @@ tests.simpleVariable = function()
>             return result;
>         }
>     `);
>-    checkInt(program, callFunction(program, "foo", [], [makeInt(program, 42)]), 42);
>+    checkInt(program, callFunction(program, "foo", [makeInt(program, 42)]), 42);
> }
> 
> tests.simpleAssignment = function()
>@@ -344,7 +398,7 @@ tests.simpleAssignment = function()
>             return result;
>         }
>     `);
>-    checkInt(program, callFunction(program, "foo", [], [makeInt(program, 42)]), 42);
>+    checkInt(program, callFunction(program, "foo", [makeInt(program, 42)]), 42);
> }
> 
> tests.simpleDefault = function()
>@@ -356,7 +410,7 @@ tests.simpleDefault = function()
>             return result;
>         }
>     `);
>-    checkInt(program, callFunction(program, "foo", [], []), 0);
>+    checkInt(program, callFunction(program, "foo", []), 0);
> }
> 
> tests.simpleDereference = function()
>@@ -369,7 +423,7 @@ tests.simpleDereference = function()
>     `);
>     let buffer = new EBuffer(1);
>     buffer.set(0, 13);
>-    checkInt(program, callFunction(program, "foo", [], [TypedValue.box(new PtrType(externalOrigin, "device", program.intrinsics.int32), new EPtr(buffer, 0))]), 13);
>+    checkInt(program, callFunction(program, "foo", [TypedValue.box(new PtrType(externalOrigin, "device", program.intrinsics.int32), new EPtr(buffer, 0))]), 13);
> }
> 
> tests.dereferenceStore = function()
>@@ -382,7 +436,7 @@ tests.dereferenceStore = function()
>     `);
>     let buffer = new EBuffer(1);
>     buffer.set(0, 13);
>-    callFunction(program, "foo", [], [TypedValue.box(new PtrType(externalOrigin, "device", program.intrinsics.int32), new EPtr(buffer, 0))]);
>+    callFunction(program, "foo", [TypedValue.box(new PtrType(externalOrigin, "device", program.intrinsics.int32), new EPtr(buffer, 0))]);
>     if (buffer.get(0) != 52)
>         throw new Error("Expected buffer to contain 52 but it contains: " + buffer.get(0));
> }
>@@ -396,7 +450,7 @@ tests.simpleMakePtr = function()
>             return &x;
>         }
>     `);
>-    let result = callFunction(program, "foo", [], []);
>+    let result = callFunction(program, "foo", []);
>     if (!result.type.isPtr)
>         throw new Error("Return type is not a pointer: " + result.type);
>     if (!result.type.elementType.equals(program.intrinsics.int32))
>@@ -418,7 +472,7 @@ tests.threadArrayLoad = function()
>     `);
>     let buffer = new EBuffer(1);
>     buffer.set(0, 89);
>-    let result = callFunction(program, "foo", [], [TypedValue.box(new ArrayRefType(externalOrigin, "thread", program.intrinsics.int32), new EArrayRef(new EPtr(buffer, 0), 1))]);
>+    let result = callFunction(program, "foo", [TypedValue.box(new ArrayRefType(externalOrigin, "thread", program.intrinsics.int32), new EArrayRef(new EPtr(buffer, 0), 1))]);
>     checkInt(program, result, 89);
> }
> 
>@@ -432,7 +486,7 @@ tests.threadArrayLoadIntLiteral = function()
>     `);
>     let buffer = new EBuffer(1);
>     buffer.set(0, 89);
>-    let result = callFunction(program, "foo", [], [TypedValue.box(new ArrayRefType(externalOrigin, "thread", program.intrinsics.int32), new EArrayRef(new EPtr(buffer, 0), 1))]);
>+    let result = callFunction(program, "foo", [TypedValue.box(new ArrayRefType(externalOrigin, "thread", program.intrinsics.int32), new EArrayRef(new EPtr(buffer, 0), 1))]);
>     checkInt(program, result, 89);
> }
> 
>@@ -446,7 +500,7 @@ tests.deviceArrayLoad = function()
>     `);
>     let buffer = new EBuffer(1);
>     buffer.set(0, 89);
>-    let result = callFunction(program, "foo", [], [TypedValue.box(new ArrayRefType(externalOrigin, "device", program.intrinsics.int32), new EArrayRef(new EPtr(buffer, 0), 1))]);
>+    let result = callFunction(program, "foo", [TypedValue.box(new ArrayRefType(externalOrigin, "device", program.intrinsics.int32), new EArrayRef(new EPtr(buffer, 0), 1))]);
>     checkInt(program, result, 89);
> }
> 
>@@ -463,10 +517,10 @@ tests.threadArrayStore = function()
>     let arrayRef = TypedValue.box(
>         new ArrayRefType(externalOrigin, "thread", program.intrinsics.int32),
>         new EArrayRef(new EPtr(buffer, 0), 1));
>-    callFunction(program, "foo", [], [arrayRef, makeInt(program, 65)]);
>+    callFunction(program, "foo", [arrayRef, makeInt(program, 65)]);
>     if (buffer.get(0) != 65)
>         throw new Error("Bad value stored into buffer (expected 65): " + buffer.get(0));
>-    callFunction(program, "foo", [], [arrayRef, makeInt(program, -111)]);
>+    callFunction(program, "foo", [arrayRef, makeInt(program, -111)]);
>     if (buffer.get(0) != -111)
>         throw new Error("Bad value stored into buffer (expected -111): " + buffer.get(0));
> }
>@@ -484,10 +538,10 @@ tests.deviceArrayStore = function()
>     let arrayRef = TypedValue.box(
>         new ArrayRefType(externalOrigin, "device", program.intrinsics.int32),
>         new EArrayRef(new EPtr(buffer, 0), 1));
>-    callFunction(program, "foo", [], [arrayRef, makeInt(program, 65)]);
>+    callFunction(program, "foo", [arrayRef, makeInt(program, 65)]);
>     if (buffer.get(0) != 65)
>         throw new Error("Bad value stored into buffer (expected 65): " + buffer.get(0));
>-    callFunction(program, "foo", [], [arrayRef, makeInt(program, -111)]);
>+    callFunction(program, "foo", [arrayRef, makeInt(program, -111)]);
>     if (buffer.get(0) != -111)
>         throw new Error("Bad value stored into buffer (expected -111): " + buffer.get(0));
> }
>@@ -505,32 +559,14 @@ tests.deviceArrayStoreIntLiteral = function()
>     let arrayRef = TypedValue.box(
>         new ArrayRefType(externalOrigin, "device", program.intrinsics.int32),
>         new EArrayRef(new EPtr(buffer, 0), 1));
>-    callFunction(program, "foo", [], [arrayRef, makeInt(program, 65)]);
>+    callFunction(program, "foo", [arrayRef, makeInt(program, 65)]);
>     if (buffer.get(0) != 65)
>         throw new Error("Bad value stored into buffer (expected 65): " + buffer.get(0));
>-    callFunction(program, "foo", [], [arrayRef, makeInt(program, -111)]);
>+    callFunction(program, "foo", [arrayRef, makeInt(program, -111)]);
>     if (buffer.get(0) != -111)
>         throw new Error("Bad value stored into buffer (expected -111): " + buffer.get(0));
> }
> 
>-tests.simpleProtocol = function()
>-{
>-    let program = doPrep(`
>-        protocol MyAddable {
>-            MyAddable operator+(MyAddable, MyAddable);
>-        }
>-        T add<T:MyAddable>(T a, T b)
>-        {
>-            return a + b;
>-        }
>-        int foo(int x)
>-        {
>-            return add(x, 73);
>-        }
>-    `);
>-    checkInt(program, callFunction(program, "foo", [], [makeInt(program, 45)]), 45 + 73);
>-}
>-
> tests.typeMismatchReturn = function()
> {
>     checkFail(
>@@ -584,13 +620,12 @@ tests.badAdd = function()
> {
>     checkFail(
>         () => doPrep(`
>-            void bar<T>(T) { }
>             void foo(int x, uint y)
>             {
>-                bar(x + y);
>+                uint z = x + y;
>             }
>         `),
>-        (e) => e instanceof WTypeError && e.message.indexOf("native int32 operator+<>(int32,int32)") != -1);
>+        (e) => e instanceof WTypeError && e.message.indexOf("native int32 operator+(int32,int32)") != -1);
> }
> 
> tests.lexerKeyword = function()
>@@ -666,7 +701,7 @@ tests.simpleStruct = function()
>     let buffer = new EBuffer(2);
>     buffer.set(0, 62);
>     buffer.set(1, 24);
>-    let result = callFunction(program, "foo", [], [new TypedValue(structType, new EPtr(buffer, 0))]);
>+    let result = callFunction(program, "foo", [new TypedValue(structType, new EPtr(buffer, 0))]);
>     if (!result.type.equals(structType))
>         throw new Error("Wrong result type: " + result.type);
>     let x = result.ePtr.get(0);
>@@ -677,57 +712,11 @@ tests.simpleStruct = function()
>         throw new Error("Wrong result for y: " + y + " (x + " + x + ")");
> }
> 
>-tests.genericStructInstance = function()
>-{
>-    let program = doPrep(`
>-        struct Foo<T> {
>-            T x;
>-            T y;
>-        }
>-        Foo<int> foo(Foo<int> foo)
>-        {
>-            Foo<int> result;
>-            result.x = foo.y;
>-            result.y = foo.x;
>-            return result;
>-        }
>-    `);
>-    let structType = TypeRef.instantiate(program.types.get("Foo"), [program.intrinsics.int32]);
>-    let buffer = new EBuffer(2);
>-    buffer.set(0, 62);
>-    buffer.set(1, 24);
>-    let result = callFunction(program, "foo", [], [new TypedValue(structType, new EPtr(buffer, 0))]);
>-    let x = result.ePtr.get(0);
>-    let y = result.ePtr.get(1);
>-    if (x != 24)
>-        throw new Error("Wrong result for x: " + x + " (y = " + y + ")");
>-    if (y != 62)
>-        throw new Error("Wrong result for y: " + y + " (x + " + x + ")");
>-}
>-
>-tests.doubleGenericCallsDoubleGeneric = function()
>-{
>-    doPrep(`
>-        void foo<T, U>(T, U) { }
>-        void bar<V, W>(V x, W y) { foo(x, y); }
>-    `);
>-}
>-
>-tests.doubleGenericCallsSingleGeneric = function()
>-{
>-    checkFail(
>-        () => doPrep(`
>-            void foo<T>(T, T) { }
>-            void bar<V, W>(V x, W y) { foo(x, y); }
>-        `),
>-        (e) => e instanceof WTypeError);
>-}
>-
> tests.loadNull = function()
> {
>     checkFail(
>         () => doPrep(`
>-            void sink<T>(T) { }
>+            void sink(thread int* x) { }
>             void foo() { sink(*null); }
>         `),
>         (e) => e instanceof WTypeError && e.message.indexOf("Type passed to dereference is not a pointer: null") != -1);
>@@ -747,7 +736,7 @@ tests.returnNull = function()
>     let program = doPrep(`
>         thread int* foo() { return null; }
>     `);
>-    let result = callFunction(program, "foo", [], []);
>+    let result = callFunction(program, "foo", []);
>     if (!result.type.isPtr)
>         throw new Error("Return type is not a pointer: " + result.type);
>     if (!result.type.elementType.equals(program.intrinsics.int32))
>@@ -766,7 +755,7 @@ tests.dereferenceDefaultNull = function()
>         }
>     `);
>     checkFail(
>-        () => callFunction(program, "foo", [], []),
>+        () => callFunction(program, "foo", []),
>         (e) => e instanceof WTrapError);
> }
> 
>@@ -780,7 +769,7 @@ tests.defaultInitializedNull = function()
>         }
>     `);
>     checkFail(
>-        () => callFunction(program, "foo", [], []),
>+        () => callFunction(program, "foo", []),
>         (e) => e instanceof WTrapError);
> }
> 
>@@ -797,47 +786,15 @@ tests.passNullToPtrMonomorphic = function()
>         }
>     `);
>     checkFail(
>-        () => callFunction(program, "bar", [], []),
>+        () => callFunction(program, "bar", []),
>         (e) => e instanceof WTrapError);
> }
> 
>-tests.passNullToPtrPolymorphic = function()
>-{
>-    checkFail(
>-        () => doPrep(`
>-            T foo<T>(thread T* ptr)
>-            {
>-                return *ptr;
>-            }
>-            int bar()
>-            {
>-                return foo(null);
>-            }
>-        `),
>-        (e) => e instanceof WTypeError);
>-}
>-
>-tests.passNullToPolymorphic = function()
>-{
>-    checkFail(
>-        () => doPrep(`
>-            T foo<T>(T ptr)
>-            {
>-                return ptr;
>-            }
>-            int bar()
>-            {
>-                return foo(null);
>-            }
>-        `),
>-        (e) => e instanceof WTypeError);
>-}
>-
> tests.loadNullArrayRef = function()
> {
>     checkFail(
>         () => doPrep(`
>-            void sink<T>(T) { }
>+            void sink(thread int* x) { }
>             void foo() { sink(null[0u]); }
>         `),
>         (e) => e instanceof WTypeError && e.message.indexOf("Cannot resolve access") != -1);
>@@ -857,7 +814,7 @@ tests.returnNullArrayRef = function()
>     let program = doPrep(`
>         thread int[] foo() { return null; }
>     `);
>-    let result = callFunction(program, "foo", [], []);
>+    let result = callFunction(program, "foo", []);
>     if (!result.type.isArrayRef)
>         throw new Error("Return type is not an array reference: " + result.type);
>     if (!result.type.elementType.equals(program.intrinsics.int32))
>@@ -876,7 +833,7 @@ tests.dereferenceDefaultNullArrayRef = function()
>         }
>     `);
>     checkFail(
>-        () => callFunction(program, "foo", [], []),
>+        () => callFunction(program, "foo", []),
>         (e) => e instanceof WTrapError);
> }
> 
>@@ -890,7 +847,7 @@ tests.defaultInitializedNullArrayRef = function()
>         }
>     `);
>     checkFail(
>-        () => callFunction(program, "foo", [], []),
>+        () => callFunction(program, "foo", []),
>         (e) => e instanceof WTrapError);
> }
> 
>@@ -904,7 +861,7 @@ tests.defaultInitializedNullArrayRefIntLiteral = function()
>         }
>     `);
>     checkFail(
>-        () => callFunction(program, "foo", [], []),
>+        () => callFunction(program, "foo", []),
>         (e) => e instanceof WTrapError);
> }
> 
>@@ -921,36 +878,20 @@ tests.passNullToPtrMonomorphicArrayRef = function()
>         }
>     `);
>     checkFail(
>-        () => callFunction(program, "bar", [], []),
>+        () => callFunction(program, "bar", []),
>         (e) => e instanceof WTrapError);
> }
> 
>-tests.passNullToPtrPolymorphicArrayRef = function()
>-{
>-    checkFail(
>-        () => doPrep(`
>-            T foo<T>(thread T[] ptr)
>-            {
>-                return ptr[0u];
>-            }
>-            int bar()
>-            {
>-                return foo(null);
>-            }
>-        `),
>-        (e) => e instanceof WTypeError);
>-}
>-
> tests.returnIntLiteralUint = function()
> {
>     let program = doPrep("uint foo() { return 42; }");
>-    checkNumber(program, callFunction(program, "foo", [], []), 42);
>+    checkNumber(program, callFunction(program, "foo", []), 42);
> }
> 
> tests.returnIntLiteralFloat = function()
> {
>     let program = doPrep("float foo() { return 42; }");
>-    checkNumber(program, callFunction(program, "foo", [], []), 42);
>+    checkNumber(program, callFunction(program, "foo", []), 42);
> }
> 
> tests.badIntLiteralForInt = function()
>@@ -974,115 +915,6 @@ tests.badIntLiteralForFloat = function()
>         (e) => e instanceof WSyntaxError);
> }
> 
>-tests.passNullAndNotNull = function()
>-{
>-    let program = doPrep(`
>-        T bar<T>(device T* p, device T*)
>-        {
>-            return *p;
>-        }
>-        int foo(device int* p)
>-        {
>-            return bar(p, null);
>-        }
>-    `);
>-    let buffer = new EBuffer(1);
>-    buffer.set(0, 13);
>-    checkInt(program, callFunction(program, "foo", [], [TypedValue.box(new PtrType(externalOrigin, "device", program.intrinsics.int32), new EPtr(buffer, 0))]), 13);
>-}
>-
>-tests.passNullAndNotNullFullPoly = function()
>-{
>-    let program = doPrep(`
>-        T bar<T>(T p, T)
>-        {
>-            return p;
>-        }
>-        int foo(device int* p)
>-        {
>-            return *bar(p, null);
>-        }
>-    `);
>-    let buffer = new EBuffer(1);
>-    buffer.set(0, 13);
>-    checkInt(program, callFunction(program, "foo", [], [TypedValue.box(new PtrType(externalOrigin, "device", program.intrinsics.int32), new EPtr(buffer, 0))]), 13);
>-}
>-
>-tests.passNullAndNotNullFullPolyReverse = function()
>-{
>-    let program = doPrep(`
>-        T bar<T>(T, T p)
>-        {
>-            return p;
>-        }
>-        int foo(device int* p)
>-        {
>-            return *bar(null, p);
>-        }
>-    `);
>-    let buffer = new EBuffer(1);
>-    buffer.set(0, 13);
>-    checkInt(program, callFunction(program, "foo", [], [TypedValue.box(new PtrType(externalOrigin, "device", program.intrinsics.int32), new EPtr(buffer, 0))]), 13);
>-}
>-
>-tests.nullTypeVariableUnify = function()
>-{
>-    let left = new NullType(externalOrigin);
>-    let right = new TypeVariable(externalOrigin, "T", null);
>-    if (left.equals(right))
>-        throw new Error("Should not be equal but are: " + left + " and " + right);
>-    if (right.equals(left))
>-        throw new Error("Should not be equal but are: " + left + " and " + right);
>-    
>-    function everyOrder(array, callback)
>-    {
>-        function recurse(array, callback, order)
>-        {
>-            if (!array.length)
>-                return callback.call(null, order);
>-            
>-            for (let i = 0; i < array.length; ++i) {
>-                let nextArray = array.concat();
>-                nextArray.splice(i, 1);
>-                recurse(nextArray, callback, order.concat([array[i]]));
>-            }
>-        }
>-        
>-        recurse(array, callback, []);
>-    }
>-    
>-    function everyPair(things)
>-    {
>-        let result = [];
>-        for (let i = 0; i < things.length; ++i) {
>-            for (let j = 0; j < things.length; ++j) {
>-                if (i != j)
>-                    result.push([things[i], things[j]]);
>-            }
>-        }
>-        return result;
>-    }
>-    
>-    everyOrder(
>-        everyPair(["nullType", "variableType", "ptrType"]),
>-        order => {
>-            let types = {};
>-            types.nullType = new NullType(externalOrigin);
>-            types.variableType = new TypeVariable(externalOrigin, "T", null);
>-            types.ptrType = new PtrType(externalOrigin, "constant", new NativeType(externalOrigin, "foo_t", []));
>-            let unificationContext = new UnificationContext([types.variableType]);
>-            for (let [leftName, rightName] of order) {
>-                let left = types[leftName];
>-                let right = types[rightName];
>-                let result = left.unify(unificationContext, right);
>-                if (!result)
>-                    throw new Error("In order " + order + " cannot unify " + left + " with " + right);
>-            }
>-            if (!unificationContext.verify().result)
>-                throw new Error("In order " + order.map(value => "(" + value + ")") + " cannot verify");
>-        });
>-}
>-
> tests.doubleNot = function()
> {
>     let program = doPrep(`
>@@ -1091,130 +923,22 @@ tests.doubleNot = function()
>             return !!x;
>         }
>     `);
>-    checkBool(program, callFunction(program, "foo", [], [makeBool(program, true)]), true);
>-    checkBool(program, callFunction(program, "foo", [], [makeBool(program, false)]), false);
>+    checkBool(program, callFunction(program, "foo", [makeBool(program, true)]), true);
>+    checkBool(program, callFunction(program, "foo", [makeBool(program, false)]), false);
> }
> 
> tests.simpleRecursion = function()
> {
>     checkFail(
>         () => doPrep(`
>-            void foo<T>(T x)
>+            void foo(int x)
>             {
>-                foo(&x);
>+                foo(x);
>             }
>         `),
>         (e) => e instanceof WTypeError);
> }
> 
>-tests.protocolMonoSigPolyDef = function()
>-{
>-    let program = doPrep(`
>-        struct IntAnd<T> {
>-            int first;
>-            T second;
>-        }
>-        IntAnd<T> intAnd<T>(int first, T second)
>-        {
>-            IntAnd<T> result;
>-            result.first = first;
>-            result.second = second;
>-            return result;
>-        }
>-        protocol IntAndable {
>-            IntAnd<int> intAnd(IntAndable, int);
>-        }
>-        int foo<T:IntAndable>(T first, int second)
>-        {
>-            IntAnd<int> result = intAnd(first, second);
>-            return result.first + result.second;
>-        }
>-    `);
>-    checkInt(program, callFunction(program, "foo", [], [makeInt(program, 54), makeInt(program, 12)]), 54 + 12);
>-}
>-
>-tests.protocolPolySigPolyDef = function()
>-{
>-    let program = doPrep(`
>-        struct IntAnd<T> {
>-            int first;
>-            T second;
>-        }
>-        IntAnd<T> intAnd<T>(int first, T second)
>-        {
>-            IntAnd<T> result;
>-            result.first = first;
>-            result.second = second;
>-            return result;
>-        }
>-        protocol IntAndable {
>-            IntAnd<T> intAnd<T>(IntAndable, T);
>-        }
>-        int foo<T:IntAndable>(T first, int second)
>-        {
>-            IntAnd<int> result = intAnd(first, second);
>-            return result.first + result.second;
>-        }
>-    `);
>-    checkInt(program, callFunction(program, "foo", [], [makeInt(program, 54), makeInt(program, 12)]), 54 + 12);
>-}
>-
>-tests.protocolDoublePolySigDoublePolyDef = function()
>-{
>-    let program = doPrep(`
>-        struct IntAnd<T, U> {
>-            int first;
>-            T second;
>-            U third;
>-        }
>-        IntAnd<T, U> intAnd<T, U>(int first, T second, U third)
>-        {
>-            IntAnd<T, U> result;
>-            result.first = first;
>-            result.second = second;
>-            result.third = third;
>-            return result;
>-        }
>-        protocol IntAndable {
>-            IntAnd<T, U> intAnd<T, U>(IntAndable, T, U);
>-        }
>-        int foo<T:IntAndable>(T first, int second, int third)
>-        {
>-            IntAnd<int, int> result = intAnd(first, second, third);
>-            return result.first + result.second + result.third;
>-        }
>-    `);
>-    checkInt(program, callFunction(program, "foo", [], [makeInt(program, 54), makeInt(program, 12), makeInt(program, 39)]), 54 + 12 + 39);
>-}
>-
>-tests.protocolDoublePolySigDoublePolyDefExplicit = function()
>-{
>-    let program = doPrep(`
>-        struct IntAnd<T, U> {
>-            int first;
>-            T second;
>-            U third;
>-        }
>-        IntAnd<T, U> intAnd<T, U>(int first, T second, U third)
>-        {
>-            IntAnd<T, U> result;
>-            result.first = first;
>-            result.second = second;
>-            result.third = third;
>-            return result;
>-        }
>-        protocol IntAndable {
>-            IntAnd<T, U> intAnd<T, U>(IntAndable, T, U);
>-        }
>-        int foo<T:IntAndable>(T first, int second, int third)
>-        {
>-            IntAnd<int, int> result = intAnd<int, int>(first, second, third);
>-            return result.first + result.second + result.third;
>-        }
>-    `);
>-    checkInt(program, callFunction(program, "foo", [], [makeInt(program, 54), makeInt(program, 12), makeInt(program, 39)]), 54 + 12 + 39);
>-}
>-
> tests.variableShadowing = function()
> {
>     let program = doPrep(`
>@@ -1229,7 +953,7 @@ tests.variableShadowing = function()
>             return y;
>         }
>     `);
>-    checkInt(program, callFunction(program, "foo", [], []), 8);
>+    checkInt(program, callFunction(program, "foo", []), 8);
>     program = doPrep(`
>         int foo()
>         {
>@@ -1242,7 +966,7 @@ tests.variableShadowing = function()
>             return y;
>         }
>     `);
>-    checkInt(program, callFunction(program, "foo", [], []), 7);
>+    checkInt(program, callFunction(program, "foo", []), 7);
> }
> 
> tests.ifStatement = function()
>@@ -1257,13 +981,13 @@ tests.ifStatement = function()
>             return y;
>         }
>     `);
>-    checkInt(program, callFunction(program, "foo", [], [makeInt(program, 3)]), 6);
>-    checkInt(program, callFunction(program, "foo", [], [makeInt(program, 4)]), 6);
>-    checkInt(program, callFunction(program, "foo", [], [makeInt(program, 5)]), 6);
>-    checkInt(program, callFunction(program, "foo", [], [makeInt(program, 6)]), 6);
>-    checkInt(program, callFunction(program, "foo", [], [makeInt(program, 7)]), 8);
>-    checkInt(program, callFunction(program, "foo", [], [makeInt(program, 8)]), 6);
>-    checkInt(program, callFunction(program, "foo", [], [makeInt(program, 9)]), 6);
>+    checkInt(program, callFunction(program, "foo", [makeInt(program, 3)]), 6);
>+    checkInt(program, callFunction(program, "foo", [makeInt(program, 4)]), 6);
>+    checkInt(program, callFunction(program, "foo", [makeInt(program, 5)]), 6);
>+    checkInt(program, callFunction(program, "foo", [makeInt(program, 6)]), 6);
>+    checkInt(program, callFunction(program, "foo", [makeInt(program, 7)]), 8);
>+    checkInt(program, callFunction(program, "foo", [makeInt(program, 8)]), 6);
>+    checkInt(program, callFunction(program, "foo", [makeInt(program, 9)]), 6);
> }
> 
> tests.ifElseStatement = function()
>@@ -1280,13 +1004,13 @@ tests.ifElseStatement = function()
>             return y;
>         }
>     `);
>-    checkInt(program, callFunction(program, "foo", [], [makeInt(program, 3)]), 9);
>-    checkInt(program, callFunction(program, "foo", [], [makeInt(program, 4)]), 9);
>-    checkInt(program, callFunction(program, "foo", [], [makeInt(program, 5)]), 9);
>-    checkInt(program, callFunction(program, "foo", [], [makeInt(program, 6)]), 9);
>-    checkInt(program, callFunction(program, "foo", [], [makeInt(program, 7)]), 8);
>-    checkInt(program, callFunction(program, "foo", [], [makeInt(program, 8)]), 9);
>-    checkInt(program, callFunction(program, "foo", [], [makeInt(program, 9)]), 9);
>+    checkInt(program, callFunction(program, "foo", [makeInt(program, 3)]), 9);
>+    checkInt(program, callFunction(program, "foo", [makeInt(program, 4)]), 9);
>+    checkInt(program, callFunction(program, "foo", [makeInt(program, 5)]), 9);
>+    checkInt(program, callFunction(program, "foo", [makeInt(program, 6)]), 9);
>+    checkInt(program, callFunction(program, "foo", [makeInt(program, 7)]), 8);
>+    checkInt(program, callFunction(program, "foo", [makeInt(program, 8)]), 9);
>+    checkInt(program, callFunction(program, "foo", [makeInt(program, 9)]), 9);
> }
> 
> tests.ifElseIfStatement = function()
>@@ -1303,13 +1027,13 @@ tests.ifElseIfStatement = function()
>             return y;
>         }
>     `);
>-    checkInt(program, callFunction(program, "foo", [], [makeInt(program, 3)]), 6);
>-    checkInt(program, callFunction(program, "foo", [], [makeInt(program, 4)]), 6);
>-    checkInt(program, callFunction(program, "foo", [], [makeInt(program, 5)]), 6);
>-    checkInt(program, callFunction(program, "foo", [], [makeInt(program, 6)]), 6);
>-    checkInt(program, callFunction(program, "foo", [], [makeInt(program, 7)]), 8);
>-    checkInt(program, callFunction(program, "foo", [], [makeInt(program, 8)]), 9);
>-    checkInt(program, callFunction(program, "foo", [], [makeInt(program, 9)]), 6);
>+    checkInt(program, callFunction(program, "foo", [makeInt(program, 3)]), 6);
>+    checkInt(program, callFunction(program, "foo", [makeInt(program, 4)]), 6);
>+    checkInt(program, callFunction(program, "foo", [makeInt(program, 5)]), 6);
>+    checkInt(program, callFunction(program, "foo", [makeInt(program, 6)]), 6);
>+    checkInt(program, callFunction(program, "foo", [makeInt(program, 7)]), 8);
>+    checkInt(program, callFunction(program, "foo", [makeInt(program, 8)]), 9);
>+    checkInt(program, callFunction(program, "foo", [makeInt(program, 9)]), 6);
> }
> 
> tests.ifElseIfElseStatement = function()
>@@ -1328,13 +1052,13 @@ tests.ifElseIfElseStatement = function()
>             return y;
>         }
>     `);
>-    checkInt(program, callFunction(program, "foo", [], [makeInt(program, 3)]), 10);
>-    checkInt(program, callFunction(program, "foo", [], [makeInt(program, 4)]), 10);
>-    checkInt(program, callFunction(program, "foo", [], [makeInt(program, 5)]), 10);
>-    checkInt(program, callFunction(program, "foo", [], [makeInt(program, 6)]), 10);
>-    checkInt(program, callFunction(program, "foo", [], [makeInt(program, 7)]), 8);
>-    checkInt(program, callFunction(program, "foo", [], [makeInt(program, 8)]), 9);
>-    checkInt(program, callFunction(program, "foo", [], [makeInt(program, 9)]), 10);
>+    checkInt(program, callFunction(program, "foo", [makeInt(program, 3)]), 10);
>+    checkInt(program, callFunction(program, "foo", [makeInt(program, 4)]), 10);
>+    checkInt(program, callFunction(program, "foo", [makeInt(program, 5)]), 10);
>+    checkInt(program, callFunction(program, "foo", [makeInt(program, 6)]), 10);
>+    checkInt(program, callFunction(program, "foo", [makeInt(program, 7)]), 8);
>+    checkInt(program, callFunction(program, "foo", [makeInt(program, 8)]), 9);
>+    checkInt(program, callFunction(program, "foo", [makeInt(program, 9)]), 10);
> }
> 
> tests.returnIf = function()
>@@ -1387,13 +1111,13 @@ tests.returnIf = function()
>             }
>         }
>     `);
>-    checkInt(program, callFunction(program, "foo", [], [makeInt(program, 3)]), 10);
>-    checkInt(program, callFunction(program, "foo", [], [makeInt(program, 4)]), 10);
>-    checkInt(program, callFunction(program, "foo", [], [makeInt(program, 5)]), 10);
>-    checkInt(program, callFunction(program, "foo", [], [makeInt(program, 6)]), 10);
>-    checkInt(program, callFunction(program, "foo", [], [makeInt(program, 7)]), 8);
>-    checkInt(program, callFunction(program, "foo", [], [makeInt(program, 8)]), 10);
>-    checkInt(program, callFunction(program, "foo", [], [makeInt(program, 9)]), 10);
>+    checkInt(program, callFunction(program, "foo", [makeInt(program, 3)]), 10);
>+    checkInt(program, callFunction(program, "foo", [makeInt(program, 4)]), 10);
>+    checkInt(program, callFunction(program, "foo", [makeInt(program, 5)]), 10);
>+    checkInt(program, callFunction(program, "foo", [makeInt(program, 6)]), 10);
>+    checkInt(program, callFunction(program, "foo", [makeInt(program, 7)]), 8);
>+    checkInt(program, callFunction(program, "foo", [makeInt(program, 8)]), 10);
>+    checkInt(program, callFunction(program, "foo", [makeInt(program, 9)]), 10);
>     checkFail(
>         () => doPrep(`
>             int foo(int x)
>@@ -1419,13 +1143,13 @@ tests.returnIf = function()
>             return y;
>         }
>     `);
>-    checkInt(program, callFunction(program, "foo", [], [makeInt(program, 3)]), 9);
>-    checkInt(program, callFunction(program, "foo", [], [makeInt(program, 4)]), 9);
>-    checkInt(program, callFunction(program, "foo", [], [makeInt(program, 5)]), 9);
>-    checkInt(program, callFunction(program, "foo", [], [makeInt(program, 6)]), 9);
>-    checkInt(program, callFunction(program, "foo", [], [makeInt(program, 7)]), 8);
>-    checkInt(program, callFunction(program, "foo", [], [makeInt(program, 8)]), 9);
>-    checkInt(program, callFunction(program, "foo", [], [makeInt(program, 9)]), 9);
>+    checkInt(program, callFunction(program, "foo", [makeInt(program, 3)]), 9);
>+    checkInt(program, callFunction(program, "foo", [makeInt(program, 4)]), 9);
>+    checkInt(program, callFunction(program, "foo", [makeInt(program, 5)]), 9);
>+    checkInt(program, callFunction(program, "foo", [makeInt(program, 6)]), 9);
>+    checkInt(program, callFunction(program, "foo", [makeInt(program, 7)]), 8);
>+    checkInt(program, callFunction(program, "foo", [makeInt(program, 8)]), 9);
>+    checkInt(program, callFunction(program, "foo", [makeInt(program, 9)]), 9);
>     checkFail(
>         () => doPrep(`
>             int foo(int x)
>@@ -1449,7 +1173,7 @@ tests.returnIf = function()
>             return y;
>         }
>     `);
>-    checkInt(program, callFunction(program, "foo", [], [makeInt(program, 7)]), 6);
>+    checkInt(program, callFunction(program, "foo", [makeInt(program, 7)]), 6);
> }
> 
> tests.simpleWhile = function()
>@@ -1462,71 +1186,7 @@ tests.simpleWhile = function()
>             return x;
>         }
>     `);
>-    checkInt(program, callFunction(program, "foo", [], [makeInt(program, 1)]), 16);
>-}
>-
>-tests.protocolMonoPolySigDoublePolyDefExplicit = function()
>-{
>-    checkFail(
>-        () => {
>-            let program = doPrep(`
>-                struct IntAnd<T, U> {
>-                    int first;
>-                    T second;
>-                    U third;
>-                }
>-                IntAnd<T, U> intAnd<T, U>(int first, T second, U third)
>-                {
>-                    IntAnd<T, U> result;
>-                    result.first = first;
>-                    result.second = second;
>-                    result.third = third;
>-                    return result;
>-                }
>-                protocol IntAndable {
>-                    IntAnd<T, int> intAnd<T>(IntAndable, T, int);
>-                }
>-                int foo<T:IntAndable>(T first, int second, int third)
>-                {
>-                    IntAnd<int, int> result = intAnd<int>(first, second, third);
>-                    return result.first + result.second + result.third;
>-                }
>-            `);
>-            callFunction(program, "foo", [], [makeInt(program, 54), makeInt(program, 12), makeInt(program, 39)]);
>-        },
>-        (e) => e instanceof WTypeError);
>-}
>-
>-tests.ambiguousOverloadSimple = function()
>-{
>-    checkFail(
>-        () => doPrep(`
>-            void foo<T>(int, T) { }
>-            void foo<T>(T, int) { }
>-            void bar(int a, int b) { foo(a, b); }
>-        `),
>-        (e) => e instanceof WTypeError);
>-}
>-
>-tests.ambiguousOverloadOverlapping = function()
>-{
>-    checkFail(
>-        () => doPrep(`
>-            void foo<T>(int, T) { }
>-            void foo<T>(T, T) { }
>-            void bar(int a, int b) { foo(a, b); }
>-        `),
>-        (e) => e instanceof WTypeError);
>-}
>-
>-tests.ambiguousOverloadTieBreak = function()
>-{
>-    doPrep(`
>-        void foo<T>(int, T) { }
>-        void foo<T>(T, T) { }
>-        void foo(int, int) { }
>-        void bar(int a, int b) { foo(a, b); }
>-    `);
>+    checkInt(program, callFunction(program, "foo", [makeInt(program, 1)]), 16);
> }
> 
> tests.intOverloadResolution = function()
>@@ -1537,7 +1197,7 @@ tests.intOverloadResolution = function()
>         int foo(float) { return 3; }
>         int bar() { return foo(42); }
>     `);
>-    checkInt(program, callFunction(program, "bar", [], []), 1);
>+    checkInt(program, callFunction(program, "bar", []), 1);
> }
> 
> tests.intOverloadResolutionReverseOrder = function()
>@@ -1548,83 +1208,7 @@ tests.intOverloadResolutionReverseOrder = function()
>         int foo(int) { return 1; }
>         int bar() { return foo(42); }
>     `);
>-    checkInt(program, callFunction(program, "bar", [], []), 1);
>-}
>-
>-tests.intOverloadResolutionGeneric = function()
>-{
>-    let program = doPrep(`
>-        int foo(int) { return 1; }
>-        int foo<T>(T) { return 2; }
>-        int bar() { return foo(42); }
>-    `);
>-    checkInt(program, callFunction(program, "bar", [], []), 1);
>-}
>-
>-tests.intLiteralGeneric = function()
>-{
>-    let program = doPrep(`
>-        int foo<T>(T x) { return 3478; }
>-        int bar() { return foo(42); }
>-    `);
>-    checkInt(program, callFunction(program, "bar", [], []), 3478);
>-}
>-
>-tests.intLiteralGenericWithProtocols = function()
>-{
>-    let program = doPrep(`
>-        protocol MyConvertibleToInt {
>-            operator int(MyConvertibleToInt);
>-        }
>-        int foo<T:MyConvertibleToInt>(T x) { return int(x); }
>-        int bar() { return foo(42); }
>-    `);
>-    checkInt(program, callFunction(program, "bar", [], []), 42);
>-}
>-
>-tests.uintLiteralGeneric = function()
>-{
>-    let program = doPrep(`
>-        int foo<T>(T x) { return 3478; }
>-        int bar() { return foo(42u); }
>-    `);
>-    checkInt(program, callFunction(program, "bar", [], []), 3478);
>-}
>-
>-tests.uintLiteralGenericWithProtocols = function()
>-{
>-    let program = doPrep(`
>-        protocol MyConvertibleToUint {
>-            operator uint(MyConvertibleToUint);
>-        }
>-        uint foo<T:MyConvertibleToUint>(T x) { return uint(x); }
>-        uint bar() { return foo(42u); }
>-    `);
>-    checkUint(program, callFunction(program, "bar", [], []), 42);
>-}
>-
>-tests.intLiteralGenericSpecific = function()
>-{
>-    let program = doPrep(`
>-        T foo<T>(T x) { return x; }
>-        int bar() { return foo(int(42)); }
>-    `);
>-    checkInt(program, callFunction(program, "bar", [], []), 42);
>-}
>-
>-tests.simpleConstexpr = function()
>-{
>-    let program = doPrep(`
>-        int foo<int a>(int b)
>-        {
>-            return a + b;
>-        }
>-        int bar(int b)
>-        {
>-            return foo<42>(b);
>-        }
>-    `);
>-    checkInt(program, callFunction(program, "bar", [], [makeInt(program, 58)]), 58 + 42);
>+    checkInt(program, callFunction(program, "bar", []), 1);
> }
> 
> tests.break = function()
>@@ -1640,8 +1224,8 @@ tests.break = function()
>             return x;
>         }
>     `);
>-    checkInt(program, callFunction(program, "foo", [], [makeInt(program, 1)]), 8);
>-    checkInt(program, callFunction(program, "foo", [], [makeInt(program, 10)]), 20);
>+    checkInt(program, callFunction(program, "foo", [makeInt(program, 1)]), 8);
>+    checkInt(program, callFunction(program, "foo", [makeInt(program, 10)]), 20);
>     program = doPrep(`
>         int foo(int x)
>         {
>@@ -1658,8 +1242,8 @@ tests.break = function()
>             
>         }
>     `);
>-    checkInt(program, callFunction(program, "foo", [], [makeInt(program, 1)]), 7);
>-    checkInt(program, callFunction(program, "foo", [], [makeInt(program, 10)]), 19);
>+    checkInt(program, callFunction(program, "foo", [makeInt(program, 1)]), 7);
>+    checkInt(program, callFunction(program, "foo", [makeInt(program, 10)]), 19);
>     checkFail(
>         () => doPrep(`
>             int foo(int x)
>@@ -1695,7 +1279,7 @@ tests.break = function()
>                 return x;
>             }
>     `);
>-    checkInt(program, callFunction(program, "foo", [], [makeInt(program, 1)]), 7);
>+    checkInt(program, callFunction(program, "foo", [makeInt(program, 1)]), 7);
>     program = doPrep(`
>             int foo(int x)
>             {
>@@ -1705,7 +1289,7 @@ tests.break = function()
>                 return x;
>             }
>     `);
>-    checkInt(program, callFunction(program, "foo", [], [makeInt(program, 1)]), 1);
>+    checkInt(program, callFunction(program, "foo", [makeInt(program, 1)]), 1);
>     program = doPrep(`
>             int foo()
>             {
>@@ -1714,7 +1298,7 @@ tests.break = function()
>                 }
>             }
>     `);
>-    checkInt(program, callFunction(program, "foo", [], []), 7);
>+    checkInt(program, callFunction(program, "foo", []), 7);
>     checkFail(
>         () => doPrep(`
>             int foo(int x)
>@@ -1743,7 +1327,7 @@ tests.continue = function()
>             return x;
>         }
>     `);
>-    checkInt(program, callFunction(program, "foo", [], [makeInt(program, 1)]), 18);
>+    checkInt(program, callFunction(program, "foo", [makeInt(program, 1)]), 18);
>     checkFail(
>         () => doPrep(`
>             int foo(int x)
>@@ -1769,8 +1353,8 @@ tests.doWhile = function()
>             return y;
>         }
>     `);
>-    checkInt(program, callFunction(program, "foo", [], [makeInt(program, 1)]), 8);
>-    checkInt(program, callFunction(program, "foo", [], [makeInt(program, 11)]), 8);
>+    checkInt(program, callFunction(program, "foo", [makeInt(program, 1)]), 8);
>+    checkInt(program, callFunction(program, "foo", [makeInt(program, 11)]), 8);
>     program = doPrep(`
>         int foo(int x)
>         {
>@@ -1782,7 +1366,7 @@ tests.doWhile = function()
>             return y;
>         }
>     `);
>-    checkInt(program, callFunction(program, "foo", [], [makeInt(program, 1)]), 8);
>+    checkInt(program, callFunction(program, "foo", [makeInt(program, 1)]), 8);
>     program = doPrep(`
>         int foo(int x)
>         {
>@@ -1798,7 +1382,7 @@ tests.doWhile = function()
>             return sum;
>         }
>     `);
>-    checkInt(program, callFunction(program, "foo", [], [makeInt(program, 9)]), 19);
>+    checkInt(program, callFunction(program, "foo", [makeInt(program, 9)]), 19);
> }
> 
> tests.forLoop = function()
>@@ -1814,9 +1398,9 @@ tests.forLoop = function()
>             return sum;
>         }
>     `);
>-    checkInt(program, callFunction(program, "foo", [], [makeInt(program, 3)]), 3);
>-    checkInt(program, callFunction(program, "foo", [], [makeInt(program, 4)]), 6);
>-    checkInt(program, callFunction(program, "foo", [], [makeInt(program, 5)]), 10);
>+    checkInt(program, callFunction(program, "foo", [makeInt(program, 3)]), 3);
>+    checkInt(program, callFunction(program, "foo", [makeInt(program, 4)]), 6);
>+    checkInt(program, callFunction(program, "foo", [makeInt(program, 5)]), 10);
>     program = doPrep(`
>         int foo(int x)
>         {
>@@ -1827,9 +1411,9 @@ tests.forLoop = function()
>             return sum;
>         }
>     `);
>-    checkInt(program, callFunction(program, "foo", [], [makeInt(program, 3)]), 3);
>-    checkInt(program, callFunction(program, "foo", [], [makeInt(program, 4)]), 6);
>-    checkInt(program, callFunction(program, "foo", [], [makeInt(program, 5)]), 10);
>+    checkInt(program, callFunction(program, "foo", [makeInt(program, 3)]), 3);
>+    checkInt(program, callFunction(program, "foo", [makeInt(program, 4)]), 6);
>+    checkInt(program, callFunction(program, "foo", [makeInt(program, 5)]), 10);
>     program = doPrep(`
>         int foo(int x)
>         {
>@@ -1841,9 +1425,9 @@ tests.forLoop = function()
>             return sum;
>         }
>     `);
>-    checkInt(program, callFunction(program, "foo", [], [makeInt(program, 3)]), 3);
>-    checkInt(program, callFunction(program, "foo", [], [makeInt(program, 4)]), 6);
>-    checkInt(program, callFunction(program, "foo", [], [makeInt(program, 5)]), 10);
>+    checkInt(program, callFunction(program, "foo", [makeInt(program, 3)]), 3);
>+    checkInt(program, callFunction(program, "foo", [makeInt(program, 4)]), 6);
>+    checkInt(program, callFunction(program, "foo", [makeInt(program, 5)]), 10);
>     program = doPrep(`
>         int foo(int x)
>         {
>@@ -1856,10 +1440,10 @@ tests.forLoop = function()
>             return sum;
>         }
>     `);
>-    checkInt(program, callFunction(program, "foo", [], [makeInt(program, 3)]), 3);
>-    checkInt(program, callFunction(program, "foo", [], [makeInt(program, 4)]), 6);
>-    checkInt(program, callFunction(program, "foo", [], [makeInt(program, 5)]), 6);
>-    checkInt(program, callFunction(program, "foo", [], [makeInt(program, 6)]), 11);
>+    checkInt(program, callFunction(program, "foo", [makeInt(program, 3)]), 3);
>+    checkInt(program, callFunction(program, "foo", [makeInt(program, 4)]), 6);
>+    checkInt(program, callFunction(program, "foo", [makeInt(program, 5)]), 6);
>+    checkInt(program, callFunction(program, "foo", [makeInt(program, 6)]), 11);
>     program = doPrep(`
>         int foo(int x)
>         {
>@@ -1872,11 +1456,11 @@ tests.forLoop = function()
>             return sum;
>         }
>     `);
>-    checkInt(program, callFunction(program, "foo", [], [makeInt(program, 3)]), 3);
>-    checkInt(program, callFunction(program, "foo", [], [makeInt(program, 4)]), 6);
>-    checkInt(program, callFunction(program, "foo", [], [makeInt(program, 5)]), 10);
>-    checkInt(program, callFunction(program, "foo", [], [makeInt(program, 6)]), 10);
>-    checkInt(program, callFunction(program, "foo", [], [makeInt(program, 7)]), 10);
>+    checkInt(program, callFunction(program, "foo", [makeInt(program, 3)]), 3);
>+    checkInt(program, callFunction(program, "foo", [makeInt(program, 4)]), 6);
>+    checkInt(program, callFunction(program, "foo", [makeInt(program, 5)]), 10);
>+    checkInt(program, callFunction(program, "foo", [makeInt(program, 6)]), 10);
>+    checkInt(program, callFunction(program, "foo", [makeInt(program, 7)]), 10);
>     program = doPrep(`
>         int foo(int x)
>         {
>@@ -1889,11 +1473,11 @@ tests.forLoop = function()
>             return sum;
>         }
>     `);
>-    checkInt(program, callFunction(program, "foo", [], [makeInt(program, 3)]), 3);
>-    checkInt(program, callFunction(program, "foo", [], [makeInt(program, 4)]), 6);
>-    checkInt(program, callFunction(program, "foo", [], [makeInt(program, 5)]), 10);
>-    checkInt(program, callFunction(program, "foo", [], [makeInt(program, 6)]), 15);
>-    checkInt(program, callFunction(program, "foo", [], [makeInt(program, 7)]), 21);
>+    checkInt(program, callFunction(program, "foo", [makeInt(program, 3)]), 3);
>+    checkInt(program, callFunction(program, "foo", [makeInt(program, 4)]), 6);
>+    checkInt(program, callFunction(program, "foo", [makeInt(program, 5)]), 10);
>+    checkInt(program, callFunction(program, "foo", [makeInt(program, 6)]), 15);
>+    checkInt(program, callFunction(program, "foo", [makeInt(program, 7)]), 21);
>     program = doPrep(`
>         int foo(int x)
>         {
>@@ -1907,11 +1491,11 @@ tests.forLoop = function()
>             return sum;
>         }
>     `);
>-    checkInt(program, callFunction(program, "foo", [], [makeInt(program, 3)]), 3);
>-    checkInt(program, callFunction(program, "foo", [], [makeInt(program, 4)]), 6);
>-    checkInt(program, callFunction(program, "foo", [], [makeInt(program, 5)]), 10);
>-    checkInt(program, callFunction(program, "foo", [], [makeInt(program, 6)]), 15);
>-    checkInt(program, callFunction(program, "foo", [], [makeInt(program, 7)]), 21);
>+    checkInt(program, callFunction(program, "foo", [makeInt(program, 3)]), 3);
>+    checkInt(program, callFunction(program, "foo", [makeInt(program, 4)]), 6);
>+    checkInt(program, callFunction(program, "foo", [makeInt(program, 5)]), 10);
>+    checkInt(program, callFunction(program, "foo", [makeInt(program, 6)]), 15);
>+    checkInt(program, callFunction(program, "foo", [makeInt(program, 7)]), 21);
>     program = doPrep(`
>         int foo(int x)
>         {
>@@ -1926,11 +1510,11 @@ tests.forLoop = function()
>             return sum;
>         }
>     `);
>-    checkInt(program, callFunction(program, "foo", [], [makeInt(program, 3)]), 3);
>-    checkInt(program, callFunction(program, "foo", [], [makeInt(program, 4)]), 6);
>-    checkInt(program, callFunction(program, "foo", [], [makeInt(program, 5)]), 10);
>-    checkInt(program, callFunction(program, "foo", [], [makeInt(program, 6)]), 15);
>-    checkInt(program, callFunction(program, "foo", [], [makeInt(program, 7)]), 21);
>+    checkInt(program, callFunction(program, "foo", [makeInt(program, 3)]), 3);
>+    checkInt(program, callFunction(program, "foo", [makeInt(program, 4)]), 6);
>+    checkInt(program, callFunction(program, "foo", [makeInt(program, 5)]), 10);
>+    checkInt(program, callFunction(program, "foo", [makeInt(program, 6)]), 15);
>+    checkInt(program, callFunction(program, "foo", [makeInt(program, 7)]), 21);
>     checkFail(
>         () => doPrep(`
>             void foo(int x)
>@@ -1950,11 +1534,11 @@ tests.forLoop = function()
>             }
>         }
>     `);
>-    checkInt(program, callFunction(program, "foo", [], [makeInt(program, 3)]), 7);
>-    checkInt(program, callFunction(program, "foo", [], [makeInt(program, 4)]), 7);
>-    checkInt(program, callFunction(program, "foo", [], [makeInt(program, 5)]), 7);
>-    checkInt(program, callFunction(program, "foo", [], [makeInt(program, 6)]), 7);
>-    checkInt(program, callFunction(program, "foo", [], [makeInt(program, 7)]), 7);
>+    checkInt(program, callFunction(program, "foo", [makeInt(program, 3)]), 7);
>+    checkInt(program, callFunction(program, "foo", [makeInt(program, 4)]), 7);
>+    checkInt(program, callFunction(program, "foo", [makeInt(program, 5)]), 7);
>+    checkInt(program, callFunction(program, "foo", [makeInt(program, 6)]), 7);
>+    checkInt(program, callFunction(program, "foo", [makeInt(program, 7)]), 7);
>     checkFail(
>         () => doPrep(`
>             int foo(int x)
>@@ -1973,229 +1557,11 @@ tests.forLoop = function()
>             }
>         }
>     `);
>-    checkInt(program, callFunction(program, "foo", [], [makeInt(program, 3)]), 7);
>-    checkInt(program, callFunction(program, "foo", [], [makeInt(program, 4)]), 7);
>-    checkInt(program, callFunction(program, "foo", [], [makeInt(program, 5)]), 7);
>-    checkInt(program, callFunction(program, "foo", [], [makeInt(program, 6)]), 7);
>-    checkInt(program, callFunction(program, "foo", [], [makeInt(program, 7)]), 7);
>-}
>-
>-tests.chainConstexpr = function()
>-{
>-    let program = doPrep(`
>-        int foo<int a>(int b)
>-        {
>-            return a + b;
>-        }
>-        int bar<int a>(int b)
>-        {
>-            return foo<a>(b);
>-        }
>-        int baz(int b)
>-        {
>-            return bar<42>(b);
>-        }
>-    `);
>-    checkInt(program, callFunction(program, "baz", [], [makeInt(program, 58)]), 58 + 42);
>-}
>-
>-tests.chainGeneric = function()
>-{
>-    let program = doPrep(`
>-        T foo<T>(T x)
>-        {
>-            return x;
>-        }
>-        T bar<T>(thread T* ptr)
>-        {
>-            return *foo(ptr);
>-        }
>-        int baz(int x)
>-        {
>-            return bar(&x);
>-        }
>-    `);
>-    checkInt(program, callFunction(program, "baz", [], [makeInt(program, 37)]), 37);
>-}
>-
>-tests.chainStruct = function()
>-{
>-    let program = doPrep(`
>-        struct Foo<T> {
>-            T f;
>-        }
>-        struct Bar<T> {
>-            Foo<thread T*> f;
>-        }
>-        int foo(thread Bar<int>* x)
>-        {
>-            return *x->f.f;
>-        }
>-        int bar(int a)
>-        {
>-            Bar<int> x;
>-            x.f.f = &a;
>-            return foo(&x);
>-        }
>-    `);
>-    checkInt(program, callFunction(program, "bar", [], [makeInt(program, 4657)]), 4657);
>-}
>-
>-tests.chainStructNewlyValid = function()
>-{
>-    let program = doPrep(`
>-        struct Foo<T> {
>-            T f;
>-        }
>-        struct Bar<T> {
>-            Foo<device T*> f;
>-        }
>-        int foo(thread Bar<int>* x)
>-        {
>-            return *x->f.f;
>-        }
>-        int bar(device int* a)
>-        {
>-            Bar<int> x;
>-            x.f.f = a;
>-            return foo(&x);
>-        }
>-    `);
>-    let buffer = new EBuffer(1);
>-    buffer.set(0, 78453);
>-    checkInt(program, callFunction(program, "bar", [], [TypedValue.box(new PtrType(externalOrigin, "device", program.intrinsics.int32), new EPtr(buffer, 0))]), 78453);
>-}
>-
>-tests.chainStructDevice = function()
>-{
>-    let program = doPrep(`
>-        struct Foo<T> {
>-            T f;
>-        }
>-        struct Bar<T> {
>-            Foo<device T*> f;
>-        }
>-        int foo(thread Bar<int>* x)
>-        {
>-            return *x->f.f;
>-        }
>-        int bar(device int* a)
>-        {
>-            Bar<int> x;
>-            x.f.f = a;
>-            return foo(&x);
>-        }
>-    `);
>-    let buffer = new EBuffer(1);
>-    buffer.set(0, 79201);
>-    checkInt(program, callFunction(program, "bar", [], [TypedValue.box(new PtrType(externalOrigin, "device", program.intrinsics.int32), new EPtr(buffer, 0))]), 79201);
>-}
>-
>-tests.paramChainStructDevice = function()
>-{
>-    let program = doPrep(`
>-        struct Foo<T> {
>-            T f;
>-        }
>-        struct Bar<T> {
>-            Foo<T> f;
>-        }
>-        int foo(thread Bar<device int*>* x)
>-        {
>-            return *x->f.f;
>-        }
>-        int bar(device int* a)
>-        {
>-            Bar<device int*> x;
>-            x.f.f = a;
>-            return foo(&x);
>-        }
>-    `);
>-    let buffer = new EBuffer(1);
>-    buffer.set(0, 79201);
>-    checkInt(program, callFunction(program, "bar", [], [TypedValue.box(new PtrType(externalOrigin, "device", program.intrinsics.int32), new EPtr(buffer, 0))]), 79201);
>-}
>-
>-tests.simpleProtocolExtends = function()
>-{
>-    let program = doPrep(`
>-        protocol Foo {
>-            void foo(thread Foo*);
>-        }
>-        protocol Bar : Foo {
>-            void bar(thread Bar*);
>-        }
>-        void fuzz<T:Foo>(thread T* p)
>-        {
>-            foo(p);
>-        }
>-        void buzz<T:Bar>(thread T* p)
>-        {
>-            fuzz(p);
>-            bar(p);
>-        }
>-        void foo(thread int* p)
>-        {
>-            *p = *p + 743;
>-        }
>-        void bar(thread int* p)
>-        {
>-            *p = *p + 91;
>-        }
>-        int thingy(int a)
>-        {
>-            buzz(&a);
>-            return a;
>-        }
>-    `);
>-    checkInt(program, callFunction(program, "thingy", [], [makeInt(program, 642)]), 642 + 743 + 91);
>-}
>-
>-tests.protocolExtendsTwo = function()
>-{
>-    let program = doPrep(`
>-        protocol Foo {
>-            void foo(thread Foo*);
>-        }
>-        protocol Bar {
>-            void bar(thread Bar*);
>-        }
>-        protocol Baz : Foo, Bar {
>-            void baz(thread Baz*);
>-        }
>-        void fuzz<T:Foo>(thread T* p)
>-        {
>-            foo(p);
>-        }
>-        void buzz<T:Bar>(thread T* p)
>-        {
>-            bar(p);
>-        }
>-        void xuzz<T:Baz>(thread T* p)
>-        {
>-            fuzz(p);
>-            buzz(p);
>-            baz(p);
>-        }
>-        void foo(thread int* p)
>-        {
>-            *p = *p + 743;
>-        }
>-        void bar(thread int* p)
>-        {
>-            *p = *p + 91;
>-        }
>-        void baz(thread int* p)
>-        {
>-            *p = *p + 39;
>-        }
>-        int thingy(int a)
>-        {
>-            xuzz(&a);
>-            return a;
>-        }
>-    `);
>-    checkInt(program, callFunction(program, "thingy", [], [makeInt(program, 642)]), 642 + 743 + 91 + 39);
>+    checkInt(program, callFunction(program, "foo", [makeInt(program, 3)]), 7);
>+    checkInt(program, callFunction(program, "foo", [makeInt(program, 4)]), 7);
>+    checkInt(program, callFunction(program, "foo", [makeInt(program, 5)]), 7);
>+    checkInt(program, callFunction(program, "foo", [makeInt(program, 6)]), 7);
>+    checkInt(program, callFunction(program, "foo", [makeInt(program, 7)]), 7);
> }
> 
> tests.prefixPlusPlus = function()
>@@ -2207,7 +1573,7 @@ tests.prefixPlusPlus = function()
>             return x;
>         }
>     `);
>-    checkInt(program, callFunction(program, "foo", [], [makeInt(program, 64)]), 65);
>+    checkInt(program, callFunction(program, "foo", [makeInt(program, 64)]), 65);
> }
> 
> tests.prefixPlusPlusResult = function()
>@@ -2218,7 +1584,7 @@ tests.prefixPlusPlusResult = function()
>             return ++x;
>         }
>     `);
>-    checkInt(program, callFunction(program, "foo", [], [makeInt(program, 64)]), 65);
>+    checkInt(program, callFunction(program, "foo", [makeInt(program, 64)]), 65);
> }
> 
> tests.postfixPlusPlus = function()
>@@ -2230,7 +1596,7 @@ tests.postfixPlusPlus = function()
>             return x;
>         }
>     `);
>-    checkInt(program, callFunction(program, "foo", [], [makeInt(program, 64)]), 65);
>+    checkInt(program, callFunction(program, "foo", [makeInt(program, 64)]), 65);
> }
> 
> tests.postfixPlusPlusResult = function()
>@@ -2241,7 +1607,7 @@ tests.postfixPlusPlusResult = function()
>             return x++;
>         }
>     `);
>-    checkInt(program, callFunction(program, "foo", [], [makeInt(program, 64)]), 64);
>+    checkInt(program, callFunction(program, "foo", [makeInt(program, 64)]), 64);
> }
> 
> tests.prefixMinusMinus = function()
>@@ -2253,7 +1619,7 @@ tests.prefixMinusMinus = function()
>             return x;
>         }
>     `);
>-    checkInt(program, callFunction(program, "foo", [], [makeInt(program, 64)]), 63);
>+    checkInt(program, callFunction(program, "foo", [makeInt(program, 64)]), 63);
> }
> 
> tests.prefixMinusMinusResult = function()
>@@ -2264,7 +1630,7 @@ tests.prefixMinusMinusResult = function()
>             return --x;
>         }
>     `);
>-    checkInt(program, callFunction(program, "foo", [], [makeInt(program, 64)]), 63);
>+    checkInt(program, callFunction(program, "foo", [makeInt(program, 64)]), 63);
> }
> 
> tests.postfixMinusMinus = function()
>@@ -2276,7 +1642,7 @@ tests.postfixMinusMinus = function()
>             return x;
>         }
>     `);
>-    checkInt(program, callFunction(program, "foo", [], [makeInt(program, 64)]), 63);
>+    checkInt(program, callFunction(program, "foo", [makeInt(program, 64)]), 63);
> }
> 
> tests.postfixMinusMinusResult = function()
>@@ -2287,7 +1653,7 @@ tests.postfixMinusMinusResult = function()
>             return x--;
>         }
>     `);
>-    checkInt(program, callFunction(program, "foo", [], [makeInt(program, 64)]), 64);
>+    checkInt(program, callFunction(program, "foo", [makeInt(program, 64)]), 64);
> }
> 
> tests.plusEquals = function()
>@@ -2299,7 +1665,7 @@ tests.plusEquals = function()
>             return x;
>         }
>     `);
>-    checkInt(program, callFunction(program, "foo", [], [makeInt(program, 385)]), 385 + 42);
>+    checkInt(program, callFunction(program, "foo", [makeInt(program, 385)]), 385 + 42);
> }
> 
> tests.plusEqualsResult = function()
>@@ -2310,7 +1676,7 @@ tests.plusEqualsResult = function()
>             return x += 42;
>         }
>     `);
>-    checkInt(program, callFunction(program, "foo", [], [makeInt(program, 385)]), 385 + 42);
>+    checkInt(program, callFunction(program, "foo", [makeInt(program, 385)]), 385 + 42);
> }
> 
> tests.minusEquals = function()
>@@ -2322,7 +1688,7 @@ tests.minusEquals = function()
>             return x;
>         }
>     `);
>-    checkInt(program, callFunction(program, "foo", [], [makeInt(program, 385)]), 385 - 42);
>+    checkInt(program, callFunction(program, "foo", [makeInt(program, 385)]), 385 - 42);
> }
> 
> tests.minusEqualsResult = function()
>@@ -2333,7 +1699,7 @@ tests.minusEqualsResult = function()
>             return x -= 42;
>         }
>     `);
>-    checkInt(program, callFunction(program, "foo", [], [makeInt(program, 385)]), 385 - 42);
>+    checkInt(program, callFunction(program, "foo", [makeInt(program, 385)]), 385 - 42);
> }
> 
> tests.timesEquals = function()
>@@ -2345,7 +1711,7 @@ tests.timesEquals = function()
>             return x;
>         }
>     `);
>-    checkInt(program, callFunction(program, "foo", [], [makeInt(program, 385)]), 385 * 42);
>+    checkInt(program, callFunction(program, "foo", [makeInt(program, 385)]), 385 * 42);
> }
> 
> tests.timesEqualsResult = function()
>@@ -2356,7 +1722,7 @@ tests.timesEqualsResult = function()
>             return x *= 42;
>         }
>     `);
>-    checkInt(program, callFunction(program, "foo", [], [makeInt(program, 385)]), 385 * 42);
>+    checkInt(program, callFunction(program, "foo", [makeInt(program, 385)]), 385 * 42);
> }
> 
> tests.divideEquals = function()
>@@ -2368,7 +1734,7 @@ tests.divideEquals = function()
>             return x;
>         }
>     `);
>-    checkInt(program, callFunction(program, "foo", [], [makeInt(program, 385)]), (385 / 42) | 0);
>+    checkInt(program, callFunction(program, "foo", [makeInt(program, 385)]), (385 / 42) | 0);
> }
> 
> tests.divideEqualsResult = function()
>@@ -2379,7 +1745,7 @@ tests.divideEqualsResult = function()
>             return x /= 42;
>         }
>     `);
>-    checkInt(program, callFunction(program, "foo", [], [makeInt(program, 385)]), (385 / 42) | 0);
>+    checkInt(program, callFunction(program, "foo", [makeInt(program, 385)]), (385 / 42) | 0);
> }
> 
> tests.twoIntLiterals = function()
>@@ -2390,67 +1756,7 @@ tests.twoIntLiterals = function()
>             return 42 == 42;
>         }
>     `);
>-    checkBool(program, callFunction(program, "foo", [], []), true);
>-}
>-
>-tests.unifyDifferentLiterals = function()
>-{
>-    checkFail(
>-        () => doPrep(`
>-            void bar<T>(T, T)
>-            {
>-            }
>-            void foo()
>-            {
>-                bar(42, 42u);
>-            }
>-        `),
>-        (e) => e instanceof WTypeError);
>-}
>-
>-tests.unifyDifferentLiteralsBackwards = function()
>-{
>-    checkFail(
>-        () => doPrep(`
>-            void bar<T>(T, T)
>-            {
>-            }
>-            void foo()
>-            {
>-                bar(42u, 42);
>-            }
>-        `),
>-        (e) => e instanceof WTypeError);
>-}
>-
>-tests.unifyVeryDifferentLiterals = function()
>-{
>-    checkFail(
>-        () => doPrep(`
>-            void bar<T>(T, T)
>-            {
>-            }
>-            void foo()
>-            {
>-                bar(42, null);
>-            }
>-        `),
>-        (e) => e instanceof WTypeError);
>-}
>-
>-tests.unifyVeryDifferentLiteralsBackwards = function()
>-{
>-    checkFail(
>-        () => doPrep(`
>-            void bar<T>(T, T)
>-            {
>-            }
>-            void foo()
>-            {
>-                bar(null, 42);
>-            }
>-        `),
>-        (e) => e instanceof WTypeError);
>+    checkBool(program, callFunction(program, "foo", []), true);
> }
> 
> tests.assignUintToInt = function()
>@@ -2479,7 +1785,7 @@ tests.buildArrayThenSumIt = function()
>             return result;
>         }
>     `);
>-    checkInt(program, callFunction(program, "foo", [], []), 42 * 5 + 42 * 41 / 2);
>+    checkInt(program, callFunction(program, "foo", []), 42 * 5 + 42 * 41 / 2);
> }
> 
> tests.buildArrayThenSumItUsingArrayReference = function()
>@@ -2500,7 +1806,7 @@ tests.buildArrayThenSumItUsingArrayReference = function()
>             return bar(@array);
>         }
>     `);
>-    checkInt(program, callFunction(program, "foo", [], []), 42 * 5 + 42 * 41 / 2);
>+    checkInt(program, callFunction(program, "foo", []), 42 * 5 + 42 * 41 / 2);
> }
> 
> tests.overrideSubscriptStruct = function()
>@@ -2526,7 +1832,7 @@ tests.overrideSubscriptStruct = function()
>             return foo[0] + foo[1] * 3;
>         }
>     `);
>-    checkInt(program, callFunction(program, "foo", [], []), 498 + 19 * 3);
>+    checkInt(program, callFunction(program, "foo", []), 498 + 19 * 3);
> }
> 
> tests.overrideSubscriptStructAndDoStores = function()
>@@ -2552,7 +1858,7 @@ tests.overrideSubscriptStructAndDoStores = function()
>             return foo.x + foo.y;
>         }
>     `);
>-    checkInt(program, callFunction(program, "foo", [], []), 498 + 19);
>+    checkInt(program, callFunction(program, "foo", []), 498 + 19);
> }
> 
> tests.overrideSubscriptStructAndUsePointers = function()
>@@ -2582,7 +1888,7 @@ tests.overrideSubscriptStructAndUsePointers = function()
>             return bar(&foo);
>         }
>     `);
>-    checkInt(program, callFunction(program, "foo", [], []), 498 + 19);
>+    checkInt(program, callFunction(program, "foo", []), 498 + 19);
> }
> 
> tests.overrideSubscriptStructAndUsePointersIncorrectly = function()
>@@ -2629,7 +1935,7 @@ tests.makeArrayRefFromLocal = function()
>             return bar(@x);
>         }
>     `);
>-    checkInt(program, callFunction(program, "foo", [], []), 48);
>+    checkInt(program, callFunction(program, "foo", []), 48);
> }
> 
> tests.makeArrayRefFromPointer = function()
>@@ -2649,7 +1955,7 @@ tests.makeArrayRefFromPointer = function()
>             return baz(&x);
>         }
>     `);
>-    checkInt(program, callFunction(program, "foo", [], []), 48);
>+    checkInt(program, callFunction(program, "foo", []), 48);
> }
> 
> tests.makeArrayRefFromArrayRef = function()
>@@ -2682,65 +1988,35 @@ tests.simpleLength = function()
>             return (@array).length;
>         }
>     `);
>-    checkUint(program, callFunction(program, "foo", [], []), 754);
>+    checkUint(program, callFunction(program, "foo", []), 754);
> }
> 
> tests.nonArrayRefArrayLengthSucceed = function()
>-{
>-    let program = doPrep(`
>-        uint foo()
>-        {
>-            float[754] array;
>-            return array.length;
>-        }
>-    `);
>-    checkUint(program, callFunction(program, "foo", [], []), 754);
>-}
>-
>-tests.nonArrayRefArrayLengthFail = function()
>-{
>-    checkFail(
>-        () => doPrep(`
>-            thread uint* lengthPtr()
>-            {
>-                int[42] array;
>-                return &(array.length);
>-            }
>-        `),
>-        e => e instanceof WTypeError);
>-}
>-
>-tests.constexprIsNotLValuePtr = function()
>-{
>-    checkFail(
>-        () => doPrep(`
>-            thread int* foo<int x>()
>-            {
>-                return &x;
>-            }
>-        `),
>-        e => e instanceof WTypeError);
>-}
>-
>-tests.constexprIsNotLValueAssign = function()
>-{
>-    checkFail(
>-        () => doPrep(`
>-            void foo<int x>()
>-            {
>-                x = 42;
>-            }
>-        `),
>-        e => e instanceof WTypeError);
>+{
>+    let program = doPrep(`
>+        uint foo()
>+        {
>+            float[754] array;
>+            return array.length;
>+        }
>+        uint bar()
>+        {
>+            int[754] array;
>+            return array.length;
>+        }
>+    `);
>+    checkUint(program, callFunction(program, "foo", []), 754);
>+    checkUint(program, callFunction(program, "bar", []), 754);
> }
> 
>-tests.constexprIsNotLValueRMW = function()
>+tests.nonArrayRefArrayLengthFail = function()
> {
>     checkFail(
>         () => doPrep(`
>-            void foo<int x>()
>+            thread uint* lengthPtr()
>             {
>-                x += 42;
>+                int[42] array;
>+                return &(array.length);
>             }
>         `),
>         e => e instanceof WTypeError);
>@@ -2756,7 +2032,7 @@ tests.assignLength = function()
>                 (@array).length = 42;
>             }
>         `),
>-        (e) => e instanceof WTypeError && e.message.indexOf("Have neither ander nor setter") != -1);
>+        (e) => e instanceof WTypeError);
> }
> 
> tests.assignLengthHelper = function()
>@@ -2773,7 +2049,7 @@ tests.assignLengthHelper = function()
>                 bar(@array);
>             }
>         `),
>-        (e) => e instanceof WTypeError && e.message.indexOf("Have neither ander nor setter") != -1);
>+        (e) => e instanceof WTypeError);
> }
> 
> tests.simpleGetter = function()
>@@ -2793,7 +2069,7 @@ tests.simpleGetter = function()
>             return foo.y;
>         }
>     `);
>-    checkInt(program, callFunction(program, "foo", [], []), 7804);
>+    checkInt(program, callFunction(program, "foo", []), 7804);
> }
> 
> tests.simpleSetter = function()
>@@ -2818,236 +2094,7 @@ tests.simpleSetter = function()
>             return foo.x;
>         }
>     `);
>-    checkInt(program, callFunction(program, "foo", [], []), 7804);
>-}
>-
>-tests.genericAccessors = function()
>-{
>-    let program = doPrep(`
>-        struct Foo<T> {
>-            T x;
>-            T[3] y;
>-        }
>-        struct Bar<T> {
>-            T x;
>-            T y;
>-        }
>-        Bar<T> operator.z<T>(Foo<T> foo)
>-        {
>-            Bar<T> result;
>-            result.x = foo.x;
>-            result.y = foo.y[1];
>-            return result;
>-        }
>-        Foo<T> operator.z=<T>(Foo<T> foo, Bar<T> bar)
>-        {
>-            foo.x = bar.x;
>-            foo.y[1] = bar.y;
>-            return foo;
>-        }
>-        T operator.sum<T:Addable>(Foo<T> foo)
>-        {
>-            return foo.x + foo.y[0] + foo.y[1] + foo.y[2];
>-        }
>-        T operator.sum<T:Addable>(Bar<T> bar)
>-        {
>-            return bar.x + bar.y;
>-        }
>-        operator<T> Bar<T>(T x, T y)
>-        {
>-            Bar<T> result;
>-            result.x = x;
>-            result.y = y;
>-            return result;
>-        }
>-        void setup(thread Foo<int>* foo)
>-        {
>-            foo->x = 1;
>-            foo->y[0] = 2;
>-            foo->y[1] = 3;
>-            foo->y[2] = 4;
>-        }
>-        int testSuperBasic()
>-        {
>-            Foo<int> foo;
>-            setup(&foo);
>-            return foo.sum;
>-        }
>-        int testZSetterDidSetY()
>-        {
>-            Foo<int> foo;
>-            foo.z = Bar<int>(53, 932);
>-            return foo.y[1];
>-        }
>-        int testZSetter()
>-        {
>-            Foo<int> foo;
>-            foo.z = Bar<int>(53, 932);
>-            return foo.sum;
>-        }
>-        int testZGetter()
>-        {
>-            Foo<int> foo;
>-            // This deliberately does not call setup() just so we test this syntax.
>-            foo.x = 1;
>-            foo.y[0] = 2;
>-            foo.y[1] = 3;
>-            foo.y[2] = 4;
>-            return foo.z.sum;
>-        }
>-        int testLValueEmulation()
>-        {
>-            Foo<int> foo;
>-            setup(&foo);
>-            foo.z.y *= 5;
>-            return foo.sum;
>-        }
>-    `);
>-    checkInt(program, callFunction(program, "testSuperBasic", [], []), 1 + 2 + 3 + 4);
>-    checkInt(program, callFunction(program, "testZSetterDidSetY", [], []), 932);
>-    checkInt(program, callFunction(program, "testZSetter", [], []), 53 + 932);
>-    checkInt(program, callFunction(program, "testZGetter", [], []), 1 + 3);
>-    checkInt(program, callFunction(program, "testLValueEmulation", [], []), 1 + 2 + 3 * 5 + 4);
>-}
>-
>-tests.bitSubscriptAccessor = function()
>-{
>-    let program = doPrep(`
>-        protocol MyBitmaskable : Equatable {
>-            MyBitmaskable operator&(MyBitmaskable, MyBitmaskable);
>-            MyBitmaskable operator|(MyBitmaskable, MyBitmaskable);
>-            MyBitmaskable operator~(MyBitmaskable);
>-            MyBitmaskable operator<<(MyBitmaskable, uint);
>-            MyBitmaskable operator>>(MyBitmaskable, uint);
>-            operator MyBitmaskable(int);
>-        }
>-        T maskForBitIndex<T:MyBitmaskable>(uint index)
>-        {
>-            return T(1) << index;
>-        }
>-        bool operator[]<T:MyBitmaskable>(T value, uint index)
>-        {
>-            return bool(value & maskForBitIndex<T>(index));
>-        }
>-        T operator[]=<T:MyBitmaskable>(T value, uint index, bool bit)
>-        {
>-            T mask = maskForBitIndex<T>(index);
>-            if (bit)
>-                value |= mask;
>-            else
>-                value &= ~mask;
>-            return value;
>-        }
>-        uint operator.length(int)
>-        {
>-            return 32;
>-        }
>-        uint operator.length(uint)
>-        {
>-            return 32;
>-        }
>-        int testIntSetBit3()
>-        {
>-            int foo;
>-            foo[3] = true;
>-            return foo;
>-        }
>-        bool testIntSetGetBit5()
>-        {
>-            int foo;
>-            foo[5] = true;
>-            return foo[5];
>-        }
>-        bool testIntGetBit1()
>-        {
>-            int foo;
>-            return foo[1];
>-        }
>-        int testUintSumBits()
>-        {
>-            int foo = 42;
>-            int result;
>-            for (uint i = 0; i < foo.length; ++i) {
>-                if (foo[i])
>-                    result++;
>-            }
>-            return result;
>-        }
>-        int testUintSwapBits()
>-        {
>-            int foo = 42;
>-            for (uint i = 0; i < foo.length / 2; ++i) {
>-                bool tmp = foo[i];
>-                foo[i] = foo[foo.length - i - 1];
>-                foo[foo.length - i - 1] = tmp;
>-            }
>-            return foo;
>-        }
>-        struct Foo {
>-            uint f;
>-            uint g;
>-        }
>-        operator Foo(uint f, uint g)
>-        {
>-            Foo result;
>-            result.f = f;
>-            result.g = g;
>-            return result;
>-        }
>-        int operator.h(Foo foo)
>-        {
>-            return int((foo.f & 0xffff) | ((foo.g & 0xffff) << 16));
>-        }
>-        Foo operator.h=(Foo foo, int value)
>-        {
>-            foo.f &= ~0xffffu;
>-            foo.f |= uint(value) & 0xffff;
>-            foo.g &= ~0xffffu;
>-            foo.g |= (uint(value) >> 16) & 0xffff;
>-            return foo;
>-        }
>-        int testLValueEmulation()
>-        {
>-            Foo foo;
>-            foo.f = 42;
>-            foo.g = 37;
>-            for (uint i = 0; i < foo.h.length; ++i)
>-                foo.h[i] ^= true;
>-            return int(foo.f + foo.g);
>-        }
>-        struct Bar {
>-            Foo a;
>-            Foo b;
>-        }
>-        Foo operator.c(Bar bar)
>-        {
>-            return Foo(uint(bar.a.h), uint(bar.b.h));
>-        }
>-        Bar operator.c=(Bar bar, Foo foo)
>-        {
>-            bar.a.h = int(foo.f);
>-            bar.b.h = int(foo.g);
>-            return bar;
>-        }
>-        int testCrazyLValueEmulation()
>-        {
>-            Bar bar;
>-            bar.a.f = 1;
>-            bar.a.g = 2;
>-            bar.b.f = 3;
>-            bar.b.g = 4;
>-            for (uint i = 0; i < bar.c.h.length; i += 2)
>-                bar.c.h[i] ^= true;
>-            return int(bar.a.f + bar.a.g + bar.b.f + bar.b.g);
>-        }
>-    `);
>-    checkInt(program, callFunction(program, "testIntSetBit3", [], []), 8);
>-    checkBool(program, callFunction(program, "testIntSetGetBit5", [], []), true);
>-    checkBool(program, callFunction(program, "testIntGetBit1", [], []), false);
>-    checkInt(program, callFunction(program, "testUintSumBits", [], []), 3);
>-    checkInt(program, callFunction(program, "testUintSwapBits", [], []), 1409286144);
>-    checkInt(program, callFunction(program, "testLValueEmulation", [], []), 130991);
>-    checkInt(program, callFunction(program, "testCrazyLValueEmulation", [], []), 43696);
>+    checkInt(program, callFunction(program, "foo", []), 7804);
> }
> 
> tests.nestedSubscriptLValueEmulationSimple = function()
>@@ -3150,119 +2197,93 @@ tests.nestedSubscriptLValueEmulationSimple = function()
>             return sum(baz);
>         }
>     `);
>-    checkInt(program, callFunction(program, "testSetValuesAndSum", [], []), 1575);
>-    checkInt(program, callFunction(program, "testSetValuesMutateValuesAndSum", [], []), 5565);
>+    checkInt(program, callFunction(program, "testSetValuesAndSum", []), 1575);
>+    checkInt(program, callFunction(program, "testSetValuesMutateValuesAndSum", []), 5565);
> }
> 
>-tests.nestedSubscriptLValueEmulationGeneric = function()
>+tests.operatorBool = function()
> {
>     let program = doPrep(`
>-        struct Foo<T> {
>-            T[7] array;
>-        }
>-        T operator[]<T>(Foo<T> foo, uint index)
>-        {
>-            return foo.array[index];
>-        }
>-        Foo<T> operator[]=<T>(Foo<T> foo, uint index, T value)
>-        {
>-            foo.array[index] = value;
>-            return foo;
>-        }
>-        uint operator.length<T>(Foo<T> foo)
>-        {
>-            return foo.array.length;
>-        }
>-        protocol MyAddable {
>-            MyAddable operator+(MyAddable, MyAddable);
>-        }
>-        T sum<T:MyAddable>(Foo<T> foo)
>-        {
>-            T result;
>-            for (uint i = foo.length; i--;)
>-                result += foo[i];
>-            return result;
>-        }
>-        struct Bar<T> {
>-            Foo<T>[6] array;
>-        }
>-        uint operator.length<T>(Bar<T> bar)
>-        {
>-            return bar.array.length;
>-        }
>-        Foo<T> operator[]<T>(Bar<T> bar, uint index)
>-        {
>-            return bar.array[index];
>-        }
>-        Bar<T> operator[]=<T>(Bar<T> bar, uint index, Foo<T> value)
>-        {
>-            bar.array[index] = value;
>-            return bar;
>-        }
>-        T sum<T:MyAddable>(Bar<T> bar)
>-        {
>-            T result;
>-            for (uint i = bar.length; i--;)
>-                result += sum(bar[i]);
>-            return result;
>-        }
>-        struct Baz<T> {
>-            Bar<T>[5] array;
>-        }
>-        Bar<T> operator[]<T>(Baz<T> baz, uint index)
>-        {
>-            return baz.array[index];
>-        }
>-        Baz<T> operator[]=<T>(Baz<T> baz, uint index, Bar<T> value)
>-        {
>-            baz.array[index] = value;
>-            return baz;
>-        }
>-        uint operator.length<T>(Baz<T> baz)
>-        {
>-            return baz.array.length;
>-        }
>-        T sum<T:MyAddable>(Baz<T> baz)
>-        {
>-            T result;
>-            for (uint i = baz.length; i--;)
>-                result += sum(baz[i]);
>-            return result;
>-        }
>-        protocol MyConvertibleFromUint {
>-            operator MyConvertibleFromUint(uint);
>-        }
>-        protocol SetValuable : MyAddable, MyConvertibleFromUint { }
>-        void setValues<T:SetValuable>(thread Baz<T>* baz)
>-        {
>-            for (uint i = baz->length; i--;) {
>-                for (uint j = (*baz)[i].length; j--;) {
>-                    for (uint k = (*baz)[i][j].length; k--;)
>-                        (*baz)[i][j][k] = T(i + j + k);
>-                }
>-            }
>-        }
>-        int testSetValuesAndSum()
>+        bool boolFromUint8False() { return bool(uint8(0)); }
>+        bool boolFromUint8True() { return bool(uint8(1)); }
>+
>+        bool boolFromUintFalse() { return bool(uint(0)); }
>+        bool boolFromUintTrue() { return bool(uint(1)); }
>+
>+        bool boolFromIntFalse() { return bool(int(0)); }
>+        bool boolFromIntTrue() { return bool(int(1)); }
>+
>+        bool boolFromFloatFalse() { return bool(float(0)); }
>+        bool boolFromFloatTrue() { return bool(float(1)); }
>+
>+        bool boolFromInt2False() { return bool(int2(0, 0)); }
>+        bool boolFromInt2True1() { return bool(int2(1, 0)); }
>+        bool boolFromInt2True2() { return bool(int2(0, 1)); }
>+
>+        bool boolFromFloat3False() { return bool(float3(0, 0, 0)); }
>+        bool boolFromFloat3True1() { return bool(float3(1, 0, 0)); }
>+        bool boolFromFloat3True2() { return bool(float3(0, 1, 0)); }
>+        bool boolFromFloat3True3() { return bool(float3(0, 0, 1)); }
>+
>+        bool boolFromUint4False() { return bool(uint4(0, 0, 0, 0)); }
>+        bool boolFromUint4True1() { return bool(uint4(1, 0, 0, 0)); }
>+        bool boolFromUint4True2() { return bool(uint4(0, 1, 0, 0)); }
>+        bool boolFromUint4True3() { return bool(uint4(0, 0, 1, 0)); }
>+        bool boolFromUint4True4() { return bool(uint4(0, 0, 0, 1)); }
>+
>+        struct X { int x; }
>+
>+        bool boolFromStructFalse()
>         {
>-            Baz<int> baz;
>-            setValues(&baz);
>-            return sum(baz);
>+            X x;
>+            return bool(x);
>         }
>-        int testSetValuesMutateValuesAndSum()
>+
>+        bool boolFromStructTrue()
>         {
>-            Baz<int> baz;
>-            setValues(&baz);
>-            for (uint i = baz.length; i--;) {
>-                for (uint j = baz[i].length; j--;) {
>-                    for (uint k = baz[i][j].length; k--;)
>-                        baz[i][j][k] *= int(k);
>-                }
>-            }
>-            return sum(baz);
>+            X x;
>+            x.x = 1;
>+            return bool(x);
>         }
>+
>+        enum Y { A, B }
>+
>+        bool boolFromEnumFalse() { return bool(Y.A); }
>+        bool boolFromEnumTrue() { return bool(Y.B); }
>     `);
>-    checkInt(program, callFunction(program, "testSetValuesAndSum", [], []), 1575);
>-    checkInt(program, callFunction(program, "testSetValuesMutateValuesAndSum", [], []), 5565);
>+
>+    checkBool(program, callFunction(program, "boolFromUint8False", []), false);
>+    checkBool(program, callFunction(program, "boolFromUint8True", []), true);
>+
>+    checkBool(program, callFunction(program, "boolFromUintFalse", []), false);
>+    checkBool(program, callFunction(program, "boolFromUintTrue", []), true);
>+
>+    checkBool(program, callFunction(program, "boolFromIntFalse", []), false);
>+    checkBool(program, callFunction(program, "boolFromIntTrue", []), true);
>+
>+    checkBool(program, callFunction(program, "boolFromFloatFalse", []), false);
>+    checkBool(program, callFunction(program, "boolFromFloatTrue", []), true);
>+
>+    checkBool(program, callFunction(program, "boolFromInt2False", []), false);
>+    checkBool(program, callFunction(program, "boolFromInt2True1", []), true);
>+    checkBool(program, callFunction(program, "boolFromInt2True2", []), true);
>+
>+    checkBool(program, callFunction(program, "boolFromFloat3False", []), false);
>+    checkBool(program, callFunction(program, "boolFromFloat3True1", []), true);
>+    checkBool(program, callFunction(program, "boolFromFloat3True2", []), true);
>+    checkBool(program, callFunction(program, "boolFromFloat3True3", []), true);
>+
>+    checkBool(program, callFunction(program, "boolFromUint4False", []), false);
>+    checkBool(program, callFunction(program, "boolFromUint4True1", []), true);
>+    checkBool(program, callFunction(program, "boolFromUint4True2", []), true);
>+    checkBool(program, callFunction(program, "boolFromUint4True3", []), true);
>+    checkBool(program, callFunction(program, "boolFromUint4True4", []), true);
>+
>+    checkBool(program, callFunction(program, "boolFromStructFalse", []), false);
>+    checkBool(program, callFunction(program, "boolFromStructTrue", []), true);
>+
>+    checkBool(program, callFunction(program, "boolFromEnumFalse", []), false);
>+    checkBool(program, callFunction(program, "boolFromEnumTrue", []), true);
> }
> 
> tests.boolBitAnd = function()
>@@ -3273,10 +2294,10 @@ tests.boolBitAnd = function()
>             return a & b;
>         }
>     `);
>-    checkBool(program, callFunction(program, "foo", [], [makeBool(program, false), makeBool(program, false)]), false);
>-    checkBool(program, callFunction(program, "foo", [], [makeBool(program, true), makeBool(program, false)]), false);
>-    checkBool(program, callFunction(program, "foo", [], [makeBool(program, false), makeBool(program, true)]), false);
>-    checkBool(program, callFunction(program, "foo", [], [makeBool(program, true), makeBool(program, true)]), true);
>+    checkBool(program, callFunction(program, "foo", [makeBool(program, false), makeBool(program, false)]), false);
>+    checkBool(program, callFunction(program, "foo", [makeBool(program, true), makeBool(program, false)]), false);
>+    checkBool(program, callFunction(program, "foo", [makeBool(program, false), makeBool(program, true)]), false);
>+    checkBool(program, callFunction(program, "foo", [makeBool(program, true), makeBool(program, true)]), true);
> }
> 
> tests.boolBitOr = function()
>@@ -3287,10 +2308,10 @@ tests.boolBitOr = function()
>             return a | b;
>         }
>     `);
>-    checkBool(program, callFunction(program, "foo", [], [makeBool(program, false), makeBool(program, false)]), false);
>-    checkBool(program, callFunction(program, "foo", [], [makeBool(program, true), makeBool(program, false)]), true);
>-    checkBool(program, callFunction(program, "foo", [], [makeBool(program, false), makeBool(program, true)]), true);
>-    checkBool(program, callFunction(program, "foo", [], [makeBool(program, true), makeBool(program, true)]), true);
>+    checkBool(program, callFunction(program, "foo", [makeBool(program, false), makeBool(program, false)]), false);
>+    checkBool(program, callFunction(program, "foo", [makeBool(program, true), makeBool(program, false)]), true);
>+    checkBool(program, callFunction(program, "foo", [makeBool(program, false), makeBool(program, true)]), true);
>+    checkBool(program, callFunction(program, "foo", [makeBool(program, true), makeBool(program, true)]), true);
> }
> 
> tests.boolBitXor = function()
>@@ -3301,10 +2322,10 @@ tests.boolBitXor = function()
>             return a ^ b;
>         }
>     `);
>-    checkBool(program, callFunction(program, "foo", [], [makeBool(program, false), makeBool(program, false)]), false);
>-    checkBool(program, callFunction(program, "foo", [], [makeBool(program, true), makeBool(program, false)]), true);
>-    checkBool(program, callFunction(program, "foo", [], [makeBool(program, false), makeBool(program, true)]), true);
>-    checkBool(program, callFunction(program, "foo", [], [makeBool(program, true), makeBool(program, true)]), false);
>+    checkBool(program, callFunction(program, "foo", [makeBool(program, false), makeBool(program, false)]), false);
>+    checkBool(program, callFunction(program, "foo", [makeBool(program, true), makeBool(program, false)]), true);
>+    checkBool(program, callFunction(program, "foo", [makeBool(program, false), makeBool(program, true)]), true);
>+    checkBool(program, callFunction(program, "foo", [makeBool(program, true), makeBool(program, true)]), false);
> }
> 
> tests.boolBitNot = function()
>@@ -3315,8 +2336,8 @@ tests.boolBitNot = function()
>             return ~a;
>         }
>     `);
>-    checkBool(program, callFunction(program, "foo", [], [makeBool(program, false)]), true);
>-    checkBool(program, callFunction(program, "foo", [], [makeBool(program, true)]), false);
>+    checkBool(program, callFunction(program, "foo", [makeBool(program, false)]), true);
>+    checkBool(program, callFunction(program, "foo", [makeBool(program, true)]), false);
> }
> 
> tests.intBitAnd = function()
>@@ -3327,10 +2348,10 @@ tests.intBitAnd = function()
>             return a & b;
>         }
>     `);
>-    checkInt(program, callFunction(program, "foo", [], [makeInt(program, 1), makeInt(program, 7)]), 1);
>-    checkInt(program, callFunction(program, "foo", [], [makeInt(program, 65535), makeInt(program, 42)]), 42);
>-    checkInt(program, callFunction(program, "foo", [], [makeInt(program, -1), makeInt(program, -7)]), -7);
>-    checkInt(program, callFunction(program, "foo", [], [makeInt(program, 0), makeInt(program, 85732)]), 0);
>+    checkInt(program, callFunction(program, "foo", [makeInt(program, 1), makeInt(program, 7)]), 1);
>+    checkInt(program, callFunction(program, "foo", [makeInt(program, 65535), makeInt(program, 42)]), 42);
>+    checkInt(program, callFunction(program, "foo", [makeInt(program, -1), makeInt(program, -7)]), -7);
>+    checkInt(program, callFunction(program, "foo", [makeInt(program, 0), makeInt(program, 85732)]), 0);
> }
> 
> tests.intBitOr = function()
>@@ -3341,10 +2362,10 @@ tests.intBitOr = function()
>             return a | b;
>         }
>     `);
>-    checkInt(program, callFunction(program, "foo", [], [makeInt(program, 1), makeInt(program, 7)]), 7);
>-    checkInt(program, callFunction(program, "foo", [], [makeInt(program, 65535), makeInt(program, 42)]), 65535);
>-    checkInt(program, callFunction(program, "foo", [], [makeInt(program, -1), makeInt(program, -7)]), -1);
>-    checkInt(program, callFunction(program, "foo", [], [makeInt(program, 0), makeInt(program, 85732)]), 85732);
>+    checkInt(program, callFunction(program, "foo", [makeInt(program, 1), makeInt(program, 7)]), 7);
>+    checkInt(program, callFunction(program, "foo", [makeInt(program, 65535), makeInt(program, 42)]), 65535);
>+    checkInt(program, callFunction(program, "foo", [makeInt(program, -1), makeInt(program, -7)]), -1);
>+    checkInt(program, callFunction(program, "foo", [makeInt(program, 0), makeInt(program, 85732)]), 85732);
> }
> 
> tests.intBitXor = function()
>@@ -3355,10 +2376,10 @@ tests.intBitXor = function()
>             return a ^ b;
>         }
>     `);
>-    checkInt(program, callFunction(program, "foo", [], [makeInt(program, 1), makeInt(program, 7)]), 6);
>-    checkInt(program, callFunction(program, "foo", [], [makeInt(program, 65535), makeInt(program, 42)]), 65493);
>-    checkInt(program, callFunction(program, "foo", [], [makeInt(program, -1), makeInt(program, -7)]), 6);
>-    checkInt(program, callFunction(program, "foo", [], [makeInt(program, 0), makeInt(program, 85732)]), 85732);
>+    checkInt(program, callFunction(program, "foo", [makeInt(program, 1), makeInt(program, 7)]), 6);
>+    checkInt(program, callFunction(program, "foo", [makeInt(program, 65535), makeInt(program, 42)]), 65493);
>+    checkInt(program, callFunction(program, "foo", [makeInt(program, -1), makeInt(program, -7)]), 6);
>+    checkInt(program, callFunction(program, "foo", [makeInt(program, 0), makeInt(program, 85732)]), 85732);
> }
> 
> tests.intBitNot = function()
>@@ -3369,10 +2390,10 @@ tests.intBitNot = function()
>             return ~a;
>         }
>     `);
>-    checkInt(program, callFunction(program, "foo", [], [makeInt(program, 1)]), -2);
>-    checkInt(program, callFunction(program, "foo", [], [makeInt(program, 65535)]), -65536);
>-    checkInt(program, callFunction(program, "foo", [], [makeInt(program, -1)]), 0);
>-    checkInt(program, callFunction(program, "foo", [], [makeInt(program, 0)]), -1);
>+    checkInt(program, callFunction(program, "foo", [makeInt(program, 1)]), -2);
>+    checkInt(program, callFunction(program, "foo", [makeInt(program, 65535)]), -65536);
>+    checkInt(program, callFunction(program, "foo", [makeInt(program, -1)]), 0);
>+    checkInt(program, callFunction(program, "foo", [makeInt(program, 0)]), -1);
> }
> 
> tests.intLShift = function()
>@@ -3383,10 +2404,10 @@ tests.intLShift = function()
>             return a << b;
>         }
>     `);
>-    checkInt(program, callFunction(program, "foo", [], [makeInt(program, 1), makeUint(program, 7)]), 128);
>-    checkInt(program, callFunction(program, "foo", [], [makeInt(program, 65535), makeUint(program, 2)]), 262140);
>-    checkInt(program, callFunction(program, "foo", [], [makeInt(program, -1), makeUint(program, 5)]), -32);
>-    checkInt(program, callFunction(program, "foo", [], [makeInt(program, 0), makeUint(program, 3)]), 0);
>+    checkInt(program, callFunction(program, "foo", [makeInt(program, 1), makeUint(program, 7)]), 128);
>+    checkInt(program, callFunction(program, "foo", [makeInt(program, 65535), makeUint(program, 2)]), 262140);
>+    checkInt(program, callFunction(program, "foo", [makeInt(program, -1), makeUint(program, 5)]), -32);
>+    checkInt(program, callFunction(program, "foo", [makeInt(program, 0), makeUint(program, 3)]), 0);
> }
> 
> tests.intRShift = function()
>@@ -3397,10 +2418,10 @@ tests.intRShift = function()
>             return a >> b;
>         }
>     `);
>-    checkInt(program, callFunction(program, "foo", [], [makeInt(program, 1), makeUint(program, 7)]), 0);
>-    checkInt(program, callFunction(program, "foo", [], [makeInt(program, 65535), makeUint(program, 2)]), 16383);
>-    checkInt(program, callFunction(program, "foo", [], [makeInt(program, -1), makeUint(program, 5)]), -1);
>-    checkInt(program, callFunction(program, "foo", [], [makeInt(program, 0), makeUint(program, 3)]), 0);
>+    checkInt(program, callFunction(program, "foo", [makeInt(program, 1), makeUint(program, 7)]), 0);
>+    checkInt(program, callFunction(program, "foo", [makeInt(program, 65535), makeUint(program, 2)]), 16383);
>+    checkInt(program, callFunction(program, "foo", [makeInt(program, -1), makeUint(program, 5)]), -1);
>+    checkInt(program, callFunction(program, "foo", [makeInt(program, 0), makeUint(program, 3)]), 0);
> }
> 
> tests.uintBitAnd = function()
>@@ -3411,10 +2432,10 @@ tests.uintBitAnd = function()
>             return a & b;
>         }
>     `);
>-    checkUint(program, callFunction(program, "foo", [], [makeUint(program, 1), makeUint(program, 7)]), 1);
>-    checkUint(program, callFunction(program, "foo", [], [makeUint(program, 65535), makeUint(program, 42)]), 42);
>-    checkUint(program, callFunction(program, "foo", [], [makeUint(program, -1), makeUint(program, -7)]), 4294967289);
>-    checkUint(program, callFunction(program, "foo", [], [makeUint(program, 0), makeUint(program, 85732)]), 0);
>+    checkUint(program, callFunction(program, "foo", [makeUint(program, 1), makeUint(program, 7)]), 1);
>+    checkUint(program, callFunction(program, "foo", [makeUint(program, 65535), makeUint(program, 42)]), 42);
>+    checkUint(program, callFunction(program, "foo", [makeUint(program, -1), makeUint(program, -7)]), 4294967289);
>+    checkUint(program, callFunction(program, "foo", [makeUint(program, 0), makeUint(program, 85732)]), 0);
> }
> 
> tests.uintBitOr = function()
>@@ -3425,10 +2446,10 @@ tests.uintBitOr = function()
>             return a | b;
>         }
>     `);
>-    checkUint(program, callFunction(program, "foo", [], [makeUint(program, 1), makeUint(program, 7)]), 7);
>-    checkUint(program, callFunction(program, "foo", [], [makeUint(program, 65535), makeUint(program, 42)]), 65535);
>-    checkUint(program, callFunction(program, "foo", [], [makeUint(program, -1), makeUint(program, -7)]), 4294967295);
>-    checkUint(program, callFunction(program, "foo", [], [makeUint(program, 0), makeUint(program, 85732)]), 85732);
>+    checkUint(program, callFunction(program, "foo", [makeUint(program, 1), makeUint(program, 7)]), 7);
>+    checkUint(program, callFunction(program, "foo", [makeUint(program, 65535), makeUint(program, 42)]), 65535);
>+    checkUint(program, callFunction(program, "foo", [makeUint(program, -1), makeUint(program, -7)]), 4294967295);
>+    checkUint(program, callFunction(program, "foo", [makeUint(program, 0), makeUint(program, 85732)]), 85732);
> }
> 
> tests.uintBitXor = function()
>@@ -3439,10 +2460,10 @@ tests.uintBitXor = function()
>             return a ^ b;
>         }
>     `);
>-    checkUint(program, callFunction(program, "foo", [], [makeUint(program, 1), makeUint(program, 7)]), 6);
>-    checkUint(program, callFunction(program, "foo", [], [makeUint(program, 65535), makeUint(program, 42)]), 65493);
>-    checkUint(program, callFunction(program, "foo", [], [makeUint(program, -1), makeUint(program, -7)]), 6);
>-    checkUint(program, callFunction(program, "foo", [], [makeUint(program, 0), makeUint(program, 85732)]), 85732);
>+    checkUint(program, callFunction(program, "foo", [makeUint(program, 1), makeUint(program, 7)]), 6);
>+    checkUint(program, callFunction(program, "foo", [makeUint(program, 65535), makeUint(program, 42)]), 65493);
>+    checkUint(program, callFunction(program, "foo", [makeUint(program, -1), makeUint(program, -7)]), 6);
>+    checkUint(program, callFunction(program, "foo", [makeUint(program, 0), makeUint(program, 85732)]), 85732);
> }
> 
> tests.uintBitNot = function()
>@@ -3453,10 +2474,10 @@ tests.uintBitNot = function()
>             return ~a;
>         }
>     `);
>-    checkUint(program, callFunction(program, "foo", [], [makeUint(program, 1)]), 4294967294);
>-    checkUint(program, callFunction(program, "foo", [], [makeUint(program, 65535)]), 4294901760);
>-    checkUint(program, callFunction(program, "foo", [], [makeUint(program, -1)]), 0);
>-    checkUint(program, callFunction(program, "foo", [], [makeUint(program, 0)]), 4294967295);
>+    checkUint(program, callFunction(program, "foo", [makeUint(program, 1)]), 4294967294);
>+    checkUint(program, callFunction(program, "foo", [makeUint(program, 65535)]), 4294901760);
>+    checkUint(program, callFunction(program, "foo", [makeUint(program, -1)]), 0);
>+    checkUint(program, callFunction(program, "foo", [makeUint(program, 0)]), 4294967295);
> }
> 
> tests.uintLShift = function()
>@@ -3467,10 +2488,10 @@ tests.uintLShift = function()
>             return a << b;
>         }
>     `);
>-    checkUint(program, callFunction(program, "foo", [], [makeUint(program, 1), makeUint(program, 7)]), 128);
>-    checkUint(program, callFunction(program, "foo", [], [makeUint(program, 65535), makeUint(program, 2)]), 262140);
>-    checkUint(program, callFunction(program, "foo", [], [makeUint(program, -1), makeUint(program, 5)]), 4294967264);
>-    checkUint(program, callFunction(program, "foo", [], [makeUint(program, 0), makeUint(program, 3)]), 0);
>+    checkUint(program, callFunction(program, "foo", [makeUint(program, 1), makeUint(program, 7)]), 128);
>+    checkUint(program, callFunction(program, "foo", [makeUint(program, 65535), makeUint(program, 2)]), 262140);
>+    checkUint(program, callFunction(program, "foo", [makeUint(program, -1), makeUint(program, 5)]), 4294967264);
>+    checkUint(program, callFunction(program, "foo", [makeUint(program, 0), makeUint(program, 3)]), 0);
> }
> 
> tests.uintRShift = function()
>@@ -3481,10 +2502,10 @@ tests.uintRShift = function()
>             return a >> b;
>         }
>     `);
>-    checkUint(program, callFunction(program, "foo", [], [makeUint(program, 1), makeUint(program, 7)]), 0);
>-    checkUint(program, callFunction(program, "foo", [], [makeUint(program, 65535), makeUint(program, 2)]), 16383);
>-    checkUint(program, callFunction(program, "foo", [], [makeUint(program, -1), makeUint(program, 5)]), 134217727);
>-    checkUint(program, callFunction(program, "foo", [], [makeUint(program, 0), makeUint(program, 3)]), 0);
>+    checkUint(program, callFunction(program, "foo", [makeUint(program, 1), makeUint(program, 7)]), 0);
>+    checkUint(program, callFunction(program, "foo", [makeUint(program, 65535), makeUint(program, 2)]), 16383);
>+    checkUint(program, callFunction(program, "foo", [makeUint(program, -1), makeUint(program, 5)]), 134217727);
>+    checkUint(program, callFunction(program, "foo", [makeUint(program, 0), makeUint(program, 3)]), 0);
> }
> 
> tests.uint8BitAnd = function()
>@@ -3495,10 +2516,10 @@ tests.uint8BitAnd = function()
>             return a & b;
>         }
>     `);
>-    checkUint8(program, callFunction(program, "foo", [], [makeUint8(program, 1), makeUint8(program, 7)]), 1);
>-    checkUint8(program, callFunction(program, "foo", [], [makeUint8(program, 65535), makeUint8(program, 42)]), 42);
>-    checkUint8(program, callFunction(program, "foo", [], [makeUint8(program, -1), makeUint8(program, -7)]), 249);
>-    checkUint8(program, callFunction(program, "foo", [], [makeUint8(program, 0), makeUint8(program, 85732)]), 0);
>+    checkUint8(program, callFunction(program, "foo", [makeUint8(program, 1), makeUint8(program, 7)]), 1);
>+    checkUint8(program, callFunction(program, "foo", [makeUint8(program, 65535), makeUint8(program, 42)]), 42);
>+    checkUint8(program, callFunction(program, "foo", [makeUint8(program, -1), makeUint8(program, -7)]), 249);
>+    checkUint8(program, callFunction(program, "foo", [makeUint8(program, 0), makeUint8(program, 85732)]), 0);
> }
> 
> tests.uint8BitOr = function()
>@@ -3509,10 +2530,10 @@ tests.uint8BitOr = function()
>             return a | b;
>         }
>     `);
>-    checkUint8(program, callFunction(program, "foo", [], [makeUint8(program, 1), makeUint8(program, 7)]), 7);
>-    checkUint8(program, callFunction(program, "foo", [], [makeUint8(program, 65535), makeUint8(program, 42)]), 255);
>-    checkUint8(program, callFunction(program, "foo", [], [makeUint8(program, -1), makeUint8(program, -7)]), 255);
>-    checkUint8(program, callFunction(program, "foo", [], [makeUint8(program, 0), makeUint8(program, 85732)]), 228);
>+    checkUint8(program, callFunction(program, "foo", [makeUint8(program, 1), makeUint8(program, 7)]), 7);
>+    checkUint8(program, callFunction(program, "foo", [makeUint8(program, 65535), makeUint8(program, 42)]), 255);
>+    checkUint8(program, callFunction(program, "foo", [makeUint8(program, -1), makeUint8(program, -7)]), 255);
>+    checkUint8(program, callFunction(program, "foo", [makeUint8(program, 0), makeUint8(program, 85732)]), 228);
> }
> 
> tests.uint8BitXor = function()
>@@ -3523,10 +2544,10 @@ tests.uint8BitXor = function()
>             return a ^ b;
>         }
>     `);
>-    checkUint8(program, callFunction(program, "foo", [], [makeUint8(program, 1), makeUint8(program, 7)]), 6);
>-    checkUint8(program, callFunction(program, "foo", [], [makeUint8(program, 65535), makeUint8(program, 42)]), 213);
>-    checkUint8(program, callFunction(program, "foo", [], [makeUint8(program, -1), makeUint8(program, -7)]), 6);
>-    checkUint8(program, callFunction(program, "foo", [], [makeUint8(program, 0), makeUint8(program, 85732)]), 228);
>+    checkUint8(program, callFunction(program, "foo", [makeUint8(program, 1), makeUint8(program, 7)]), 6);
>+    checkUint8(program, callFunction(program, "foo", [makeUint8(program, 65535), makeUint8(program, 42)]), 213);
>+    checkUint8(program, callFunction(program, "foo", [makeUint8(program, -1), makeUint8(program, -7)]), 6);
>+    checkUint8(program, callFunction(program, "foo", [makeUint8(program, 0), makeUint8(program, 85732)]), 228);
> }
> 
> tests.uint8BitNot = function()
>@@ -3537,10 +2558,10 @@ tests.uint8BitNot = function()
>             return ~a;
>         }
>     `);
>-    checkUint8(program, callFunction(program, "foo", [], [makeUint8(program, 1)]), 254);
>-    checkUint8(program, callFunction(program, "foo", [], [makeUint8(program, 65535)]), 0);
>-    checkUint8(program, callFunction(program, "foo", [], [makeUint8(program, -1)]), 0);
>-    checkUint8(program, callFunction(program, "foo", [], [makeUint8(program, 0)]), 255);
>+    checkUint8(program, callFunction(program, "foo", [makeUint8(program, 1)]), 254);
>+    checkUint8(program, callFunction(program, "foo", [makeUint8(program, 65535)]), 0);
>+    checkUint8(program, callFunction(program, "foo", [makeUint8(program, -1)]), 0);
>+    checkUint8(program, callFunction(program, "foo", [makeUint8(program, 0)]), 255);
> }
> 
> tests.uint8LShift = function()
>@@ -3551,10 +2572,10 @@ tests.uint8LShift = function()
>             return a << b;
>         }
>     `);
>-    checkUint8(program, callFunction(program, "foo", [], [makeUint8(program, 1), makeUint(program, 7)]), 128);
>-    checkUint8(program, callFunction(program, "foo", [], [makeUint8(program, 65535), makeUint(program, 2)]), 252);
>-    checkUint8(program, callFunction(program, "foo", [], [makeUint8(program, -1), makeUint(program, 5)]), 224);
>-    checkUint8(program, callFunction(program, "foo", [], [makeUint8(program, 0), makeUint(program, 3)]), 0);
>+    checkUint8(program, callFunction(program, "foo", [makeUint8(program, 1), makeUint(program, 7)]), 128);
>+    checkUint8(program, callFunction(program, "foo", [makeUint8(program, 65535), makeUint(program, 2)]), 252);
>+    checkUint8(program, callFunction(program, "foo", [makeUint8(program, -1), makeUint(program, 5)]), 224);
>+    checkUint8(program, callFunction(program, "foo", [makeUint8(program, 0), makeUint(program, 3)]), 0);
> }
> 
> tests.uint8RShift = function()
>@@ -3565,10 +2586,10 @@ tests.uint8RShift = function()
>             return a >> b;
>         }
>     `);
>-    checkUint8(program, callFunction(program, "foo", [], [makeUint8(program, 1), makeUint(program, 7)]), 0);
>-    checkUint8(program, callFunction(program, "foo", [], [makeUint8(program, 65535), makeUint(program, 2)]), 255);
>-    checkUint8(program, callFunction(program, "foo", [], [makeUint8(program, -1), makeUint(program, 5)]), 255);
>-    checkUint8(program, callFunction(program, "foo", [], [makeUint8(program, 0), makeUint(program, 3)]), 0);
>+    checkUint8(program, callFunction(program, "foo", [makeUint8(program, 1), makeUint(program, 7)]), 0);
>+    checkUint8(program, callFunction(program, "foo", [makeUint8(program, 65535), makeUint(program, 2)]), 255);
>+    checkUint8(program, callFunction(program, "foo", [makeUint8(program, -1), makeUint(program, 5)]), 255);
>+    checkUint8(program, callFunction(program, "foo", [makeUint8(program, 0), makeUint(program, 3)]), 0);
> }
> 
> tests.floatMath = function()
>@@ -3624,17 +2645,17 @@ tests.floatMath = function()
>             return float(x);
>         }
>     `);
>-    checkBool(program, callFunction(program, "foo", [], []), true);
>-    checkBool(program, callFunction(program, "foo2", [], []), true);
>-    checkBool(program, callFunction(program, "foo3", [], []), true);
>-    checkBool(program, callFunction(program, "foo4", [], []), true);
>-    checkBool(program, callFunction(program, "foo5", [], []), true);
>-    checkFloat(program, callFunction(program, "foo6", [], []), 7.5);
>-    checkFloat(program, callFunction(program, "foo7", [], []), 7.5);
>-    checkFloat(program, callFunction(program, "foo9", [], []), 7.5);
>-    checkFloat(program, callFunction(program, "foo10", [], []), 7.5);
>-    checkFloat(program, callFunction(program, "foo12", [], []), 7);
>-    checkFloat(program, callFunction(program, "foo13", [], []), 7.5);
>+    checkBool(program, callFunction(program, "foo", []), true);
>+    checkBool(program, callFunction(program, "foo2", []), true);
>+    checkBool(program, callFunction(program, "foo3", []), true);
>+    checkBool(program, callFunction(program, "foo4", []), true);
>+    checkBool(program, callFunction(program, "foo5", []), true);
>+    checkFloat(program, callFunction(program, "foo6", []), 7.5);
>+    checkFloat(program, callFunction(program, "foo7", []), 7.5);
>+    checkFloat(program, callFunction(program, "foo9", []), 7.5);
>+    checkFloat(program, callFunction(program, "foo10", []), 7.5);
>+    checkFloat(program, callFunction(program, "foo12", []), 7);
>+    checkFloat(program, callFunction(program, "foo13", []), 7.5);
>     checkFail(
>         () => doPrep(`
>             int bar(int x)
>@@ -3709,29 +2730,6 @@ tests.floatMath = function()
>         (e) => e instanceof WTypeError);
> }
> 
>-tests.genericCastInfer = function()
>-{
>-    let program = doPrep(`
>-        struct Complex<T> {
>-            T real;
>-            T imag;
>-        }
>-        operator<T> Complex<T>(T real, T imag)
>-        {
>-            Complex<T> result;
>-            result.real = real;
>-            result.imag = imag;
>-            return result;
>-        }
>-        int foo()
>-        {
>-            Complex<int> x = Complex<int>(1, 2);
>-            return x.real + x.imag;
>-        }
>-    `);
>-    checkInt(program, callFunction(program, "foo", [], []), 3);
>-}
>-
> tests.booleanMath = function()
> {
>     let program = doPrep(`
>@@ -3768,14 +2766,14 @@ tests.booleanMath = function()
>             return false || false;
>         }
>     `);
>-    checkBool(program, callFunction(program, "foo", [], []), true);
>-    checkBool(program, callFunction(program, "foo2", [], []), false);
>-    checkBool(program, callFunction(program, "foo3", [], []), false);
>-    checkBool(program, callFunction(program, "foo4", [], []), false);
>-    checkBool(program, callFunction(program, "foo5", [], []), true);
>-    checkBool(program, callFunction(program, "foo6", [], []), true);
>-    checkBool(program, callFunction(program, "foo7", [], []), true);
>-    checkBool(program, callFunction(program, "foo8", [], []), false);
>+    checkBool(program, callFunction(program, "foo", []), true);
>+    checkBool(program, callFunction(program, "foo2", []), false);
>+    checkBool(program, callFunction(program, "foo3", []), false);
>+    checkBool(program, callFunction(program, "foo4", []), false);
>+    checkBool(program, callFunction(program, "foo5", []), true);
>+    checkBool(program, callFunction(program, "foo6", []), true);
>+    checkBool(program, callFunction(program, "foo7", []), true);
>+    checkBool(program, callFunction(program, "foo8", []), false);
> }
> 
> tests.booleanShortcircuiting = function()
>@@ -3816,10 +2814,10 @@ tests.booleanShortcircuiting = function()
>         }
>     `);
> 
>-    checkInt(program, callFunction(program, "andTrue", [], []), 2);
>-    checkInt(program, callFunction(program, "andFalse", [], []), 1);
>-    checkInt(program, callFunction(program, "orTrue", [], []), 1);
>-    checkInt(program, callFunction(program, "orFalse", [], []), 2);
>+    checkInt(program, callFunction(program, "andTrue", []), 2);
>+    checkInt(program, callFunction(program, "andFalse", []), 1);
>+    checkInt(program, callFunction(program, "orTrue", []), 1);
>+    checkInt(program, callFunction(program, "orFalse", []), 2);
> }
> 
> tests.typedefArray = function()
>@@ -3832,7 +2830,7 @@ tests.typedefArray = function()
>             return arrayTypedef[0];
>         }
>     `);
>-    checkInt(program, callFunction(program, "foo", [], []), 0);
>+    checkInt(program, callFunction(program, "foo", []), 0);
> }
> 
> tests.shaderTypes = function()
>@@ -3966,6 +2964,47 @@ tests.shaderTypes = function()
>         (e) => e instanceof WTypeError);
> }
> 
>+tests.vectorTypeSyntax = function()
>+{
>+    const program = doPrep(`
>+        int foo2()
>+        {
>+            int2 x;
>+            vector<int, 2> z = int2(3, 4);
>+            x = z;
>+            return x.y;
>+        }
>+
>+        int foo3()
>+        {
>+            int3 x;
>+            vector<int, 3> z = int3(3, 4, 5);
>+            x = z;
>+            return x.z;
>+        }
>+
>+        int foo4()
>+        {
>+            int4 x;
>+            vector<int,4> z = int4(3, 4, 5, 6);
>+            x = z;
>+            return x.w;
>+        }
>+
>+        bool vec2OperatorCast()
>+        {
>+            int2 x = vector<int,2>(1, 2);
>+            vector<int, 2> y = int2(1, 2);
>+            return x == y && x.x == 1 && x.y == 2 && y.x == 1 && y.y == 2;
>+        }`);
>+
>+    checkInt(program, callFunction(program, "foo2", []), 4);
>+    checkInt(program, callFunction(program, "foo3", []), 5);
>+    checkInt(program, callFunction(program, "foo4", []), 6);
>+
>+    checkBool(program, callFunction(program, "vec2OperatorCast", []), true);
>+}
>+
> tests.builtinVectors = function()
> {
>     let program = doPrep(`
>@@ -4084,61 +3123,134 @@ tests.builtinVectors = function()
>             return b == c;
>         }
>     `);
>-    checkInt(program, callFunction(program, "foo", [], []), 3);
>-    checkInt(program, callFunction(program, "foo2", [], []), 4);
>-    checkInt(program, callFunction(program, "foo3", [], []), 3);
>-    checkInt(program, callFunction(program, "foo4", [], []), 5);
>-    checkBool(program, callFunction(program, "foo5", [], []), true);
>-    checkBool(program, callFunction(program, "foo6", [], []), false);
>-    checkUint(program, callFunction(program, "foou", [], []), 3);
>-    checkUint(program, callFunction(program, "foou2", [], []), 4);
>-    checkUint(program, callFunction(program, "foou3", [], []), 3);
>-    checkUint(program, callFunction(program, "foou4", [], []), 5);
>-    checkBool(program, callFunction(program, "foou5", [], []), true);
>-    checkBool(program, callFunction(program, "foou6", [], []), false);
>-    checkFloat(program, callFunction(program, "foof", [], []), 3);
>-    checkFloat(program, callFunction(program, "foof2", [], []), 4);
>-    checkFloat(program, callFunction(program, "foof3", [], []), 3);
>-    checkFloat(program, callFunction(program, "foof4", [], []), 5);
>-    checkBool(program, callFunction(program, "foof5", [], []), true);
>-    checkBool(program, callFunction(program, "foof6", [], []), false);
>-}
>-
>-tests.instantiateStructInStruct = function()
>-{
>-    let program = doPrep(`
>-        struct Bar<T> {
>-            T x;
>-        }
>-        struct Foo {
>-            Bar<int> x;
>-        }
>-        int foo()
>-        {
>-            Foo x;
>-            x.x.x = 42;
>-            x.x.x++;
>-            return x.x.x;
>+    checkInt(program, callFunction(program, "foo", []), 3);
>+    checkInt(program, callFunction(program, "foo2", []), 4);
>+    checkInt(program, callFunction(program, "foo3", []), 3);
>+    checkInt(program, callFunction(program, "foo4", []), 5);
>+    checkBool(program, callFunction(program, "foo5", []), true);
>+    checkBool(program, callFunction(program, "foo6", []), false);
>+    checkUint(program, callFunction(program, "foou", []), 3);
>+    checkUint(program, callFunction(program, "foou2", []), 4);
>+    checkUint(program, callFunction(program, "foou3", []), 3);
>+    checkUint(program, callFunction(program, "foou4", []), 5);
>+    checkBool(program, callFunction(program, "foou5", []), true);
>+    checkBool(program, callFunction(program, "foou6", []), false);
>+    checkFloat(program, callFunction(program, "foof", []), 3);
>+    checkFloat(program, callFunction(program, "foof2", []), 4);
>+    checkFloat(program, callFunction(program, "foof3", []), 3);
>+    checkFloat(program, callFunction(program, "foof4", []), 5);
>+    checkBool(program, callFunction(program, "foof5", []), true);
>+    checkBool(program, callFunction(program, "foof6", []), false);
>+}
>+
>+tests.builtinVectorGetters = function()
>+{
>+    const typeNames = [ "uint", "int", "float" ];
>+    const sizes = [ 2, 3, 4 ];
>+    const elements = [ "x", "y", "z", "w" ];
>+    const initializerList = [ 1, 2, 3, 4 ];
>+
>+    let tests = [];
>+    let src = "";
>+    for (let typeName of typeNames) {
>+        for (let size of sizes) {
>+            for (let i = 0; i < size; i++) {
>+                const functionName = `${typeName}${size}${elements[i]}`;
>+                src += `${typeName} ${functionName}()
>+                        {
>+                            ${typeName}${size} x = ${typeName}${size}(${initializerList.slice(0, size).join(", ")});
>+                            return x.${elements[i]};
>+                        }
>+                        `;
>+                tests.push({ type: typeName, name: functionName, expectation: initializerList[i] });
>+            }
>         }
>-    `);
>-    checkInt(program, callFunction(program, "foo", [], []), 43);
>+    }
>+
>+    let program = doPrep(src);
>+    const checkFuncs = {
>+        "uint": checkUint,
>+        "int": checkInt,
>+        "float": checkFloat
>+    };
>+    for (let test of tests) {
>+        const checkFunc = checkFuncs[test.type];
>+        checkFunc(program, callFunction(program, test.name, [], []), test.expectation);
>+    }
> }
> 
>-tests.instantiateStructInStructWithInt2 = function()
>+tests.builtinVectorSetters = function()
> {
>-    let program = doPrep(`
>-        struct Foo {
>-            int2 x;
>+    const typeNames = [ "uint", "int", "float" ];
>+    const sizes = [ 2, 3, 4 ];
>+    const elements = [ "x", "y", "z", "w" ];
>+    const initializerList = [ 1, 2, 3, 4 ];
>+
>+    let tests = [];
>+    let src = "";
>+    for (let typeName of typeNames) {
>+        for (let size of sizes) {
>+            for (let i = 0; i < size; i++) {
>+                const functionName = `${typeName}${size}${elements[i]}`;
>+                src += `${typeName} ${functionName}()
>+                        {
>+                            ${typeName}${size} x = ${typeName}${size}(${initializerList.slice(0, size).join(", ")});
>+                            x.${elements[i]} = 34;
>+                            return x.${elements[i]};
>+                        }
>+                        `;
>+                tests.push({ type: typeName, name: functionName, expectation: 34 });
>+            }
>         }
>-        int foo()
>-        {
>-            Foo x;
>-            x.x.x = 42;
>-            x.x.x++;
>-            return x.x.x;
>+    }
>+
>+    let program = doPrep(src);
>+    const checkFuncs = {
>+        "uint": checkUint,
>+        "int": checkInt,
>+        "float": checkFloat
>+    };
>+    for (let test of tests) {
>+        const checkFunc = checkFuncs[test.type];
>+        checkFunc(program, callFunction(program, test.name, [], []), test.expectation);
>+    }
>+}
>+
>+tests.builtinVectorIndexSetters = function()
>+{
>+    const typeNames = [ "uint", "int", "float" ];
>+    const sizes = [ 2, 3, 4 ];
>+    const elements = [ "x", "y", "z", "w" ];
>+    const initializerList = [ 1, 2, 3, 4 ];
>+
>+    let tests = [];
>+    let src = "";
>+    for (let typeName of typeNames) {
>+        for (let size of sizes) {
>+            for (let i = 0; i < size; i++) {
>+                const functionName = `${typeName}${size}${elements[i]}`;
>+                src += `${typeName} ${functionName}()
>+                        {
>+                            ${typeName}${size} x = ${typeName}${size}(${initializerList.slice(0, size).join(", ")});
>+                            x[${i}] = 34;
>+                            return x[${i}];
>+                        }
>+                        `;
>+                tests.push({ type: typeName, name: functionName, expectation: 34 });
>+            }
>         }
>-    `);
>-    checkInt(program, callFunction(program, "foo", [], []), 43);
>+    }
>+
>+    let program = doPrep(src);
>+    const checkFuncs = {
>+        "uint": checkUint,
>+        "int": checkInt,
>+        "float": checkFloat
>+    };
>+    for (let test of tests) {
>+        const checkFunc = checkFuncs[test.type];
>+        checkFunc(program, callFunction(program, test.name, [], []), test.expectation);
>+    }
> }
> 
> tests.simpleEnum = function()
>@@ -4263,32 +3375,32 @@ tests.simpleEnum = function()
>             return Foo(intDeath());
>         }
>     `);
>-    checkEnum(program, callFunction(program, "war", [], []), 0);
>-    checkEnum(program, callFunction(program, "famine", [], []), 1);
>-    checkEnum(program, callFunction(program, "pestilence", [], []), 2);
>-    checkEnum(program, callFunction(program, "death", [], []), 3);
>-    checkBool(program, callFunction(program, "testSimpleEqual", [], []), true);
>-    checkBool(program, callFunction(program, "testAnotherEqual", [], []), true);
>-    checkBool(program, callFunction(program, "testNotEqual", [], []), false);
>-    checkBool(program, callFunction(program, "testSimpleNotEqual", [], []), false);
>-    checkBool(program, callFunction(program, "testAnotherNotEqual", [], []), false);
>-    checkBool(program, callFunction(program, "testNotNotEqual", [], []), true);
>-    checkInt(program, callFunction(program, "intWar", [], []), 0);
>-    checkInt(program, callFunction(program, "intFamine", [], []), 1);
>-    checkInt(program, callFunction(program, "intPestilence", [], []), 2);
>-    checkInt(program, callFunction(program, "intDeath", [], []), 3);
>-    checkInt(program, callFunction(program, "warValue", [], []), 0);
>-    checkInt(program, callFunction(program, "famineValue", [], []), 1);
>-    checkInt(program, callFunction(program, "pestilenceValue", [], []), 2);
>-    checkInt(program, callFunction(program, "deathValue", [], []), 3);
>-    checkInt(program, callFunction(program, "warValueLiteral", [], []), 0);
>-    checkInt(program, callFunction(program, "famineValueLiteral", [], []), 1);
>-    checkInt(program, callFunction(program, "pestilenceValueLiteral", [], []), 2);
>-    checkInt(program, callFunction(program, "deathValueLiteral", [], []), 3);
>-    checkEnum(program, callFunction(program, "intWarBackwards", [], []), 0);
>-    checkEnum(program, callFunction(program, "intFamineBackwards", [], []), 1);
>-    checkEnum(program, callFunction(program, "intPestilenceBackwards", [], []), 2);
>-    checkEnum(program, callFunction(program, "intDeathBackwards", [], []), 3);
>+    checkEnum(program, callFunction(program, "war", []), 0);
>+    checkEnum(program, callFunction(program, "famine", []), 1);
>+    checkEnum(program, callFunction(program, "pestilence", []), 2);
>+    checkEnum(program, callFunction(program, "death", []), 3);
>+    checkBool(program, callFunction(program, "testSimpleEqual", []), true);
>+    checkBool(program, callFunction(program, "testAnotherEqual", []), true);
>+    checkBool(program, callFunction(program, "testNotEqual", []), false);
>+    checkBool(program, callFunction(program, "testSimpleNotEqual", []), false);
>+    checkBool(program, callFunction(program, "testAnotherNotEqual", []), false);
>+    checkBool(program, callFunction(program, "testNotNotEqual", []), true);
>+    checkInt(program, callFunction(program, "intWar", []), 0);
>+    checkInt(program, callFunction(program, "intFamine", []), 1);
>+    checkInt(program, callFunction(program, "intPestilence", []), 2);
>+    checkInt(program, callFunction(program, "intDeath", []), 3);
>+    checkInt(program, callFunction(program, "warValue", []), 0);
>+    checkInt(program, callFunction(program, "famineValue", []), 1);
>+    checkInt(program, callFunction(program, "pestilenceValue", []), 2);
>+    checkInt(program, callFunction(program, "deathValue", []), 3);
>+    checkInt(program, callFunction(program, "warValueLiteral", []), 0);
>+    checkInt(program, callFunction(program, "famineValueLiteral", []), 1);
>+    checkInt(program, callFunction(program, "pestilenceValueLiteral", []), 2);
>+    checkInt(program, callFunction(program, "deathValueLiteral", []), 3);
>+    checkEnum(program, callFunction(program, "intWarBackwards", []), 0);
>+    checkEnum(program, callFunction(program, "intFamineBackwards", []), 1);
>+    checkEnum(program, callFunction(program, "intPestilenceBackwards", []), 2);
>+    checkEnum(program, callFunction(program, "intDeathBackwards", []), 3);
> }
> 
> tests.enumWithManualValues = function()
>@@ -4317,10 +3429,10 @@ tests.enumWithManualValues = function()
>             return Foo.Death;
>         }
>     `);
>-    checkEnum(program, callFunction(program, "war", [], []), 72);
>-    checkEnum(program, callFunction(program, "famine", [], []), 0);
>-    checkEnum(program, callFunction(program, "pestilence", [], []), 23);
>-    checkEnum(program, callFunction(program, "death", [], []), -42);
>+    checkEnum(program, callFunction(program, "war", []), 72);
>+    checkEnum(program, callFunction(program, "famine", []), 0);
>+    checkEnum(program, callFunction(program, "pestilence", []), 23);
>+    checkEnum(program, callFunction(program, "death", []), -42);
> }
> 
> tests.enumWithoutZero = function()
>@@ -4377,43 +3489,10 @@ tests.enumWithSomeManualValues = function()
>             return Foo.Death;
>         }
>     `);
>-    checkEnum(program, callFunction(program, "war", [], []), 72);
>-    checkEnum(program, callFunction(program, "famine", [], []), 73);
>-    checkEnum(program, callFunction(program, "pestilence", [], []), 0);
>-    checkEnum(program, callFunction(program, "death", [], []), 1);
>-}
>-
>-tests.enumConstexprGenericFunction = function()
>-{
>-    let program = doPrep(`
>-        enum Axis { X, Y }
>-        int foo<Axis axis>() { return int(axis); }
>-        int testX() { return foo<Axis.X>(); }
>-        int testY() { return foo<Axis.Y>(); }
>-    `);
>-    checkInt(program, callFunction(program, "testX", [], []), 0);
>-    checkInt(program, callFunction(program, "testY", [], []), 1);
>-}
>-
>-tests.enumConstexprGenericStruct = function()
>-{
>-    let program = doPrep(`
>-        enum Axis { X, Y }
>-        struct Foo<Axis axis> { }
>-        int foo<Axis axis>(Foo<axis>) { return int(axis); }
>-        int testX()
>-        {   
>-            Foo<Axis.X> f;
>-            return foo(f);
>-        }
>-        int testY()
>-        {   
>-            Foo<Axis.Y> f;
>-            return foo(f);
>-        }
>-    `);
>-    checkInt(program, callFunction(program, "testX", [], []), 0);
>-    checkInt(program, callFunction(program, "testY", [], []), 1);
>+    checkEnum(program, callFunction(program, "war", []), 72);
>+    checkEnum(program, callFunction(program, "famine", []), 73);
>+    checkEnum(program, callFunction(program, "pestilence", []), 0);
>+    checkEnum(program, callFunction(program, "death", []), 1);
> }
> 
> tests.trap = function()
>@@ -4439,14 +3518,14 @@ tests.trap = function()
>         }
>     `);
>     checkFail(
>-        () => callFunction(program, "foo", [], []),
>+        () => callFunction(program, "foo", []),
>         e => e instanceof WTrapError);
>-    checkInt(program, callFunction(program, "foo2", [], [makeInt(program, 1)]), 4);
>+    checkInt(program, callFunction(program, "foo2", [makeInt(program, 1)]), 4);
>     checkFail(
>-        () => callFunction(program, "foo2", [], [makeInt(program, 3)]),
>+        () => callFunction(program, "foo2", [makeInt(program, 3)]),
>         e => e instanceof WTrapError);
>     checkFail(
>-        () => callFunction(program, "foo3", [], []),
>+        () => callFunction(program, "foo3", []),
>         e => e instanceof WTrapError);
> }
> 
>@@ -4470,9 +3549,9 @@ tests.swizzle = function()
>             return quix.z;
>         }
>     `);
>-    checkFloat(program, callFunction(program, "foo", [], []), 3);
>-    checkFloat(program, callFunction(program, "foo2", [], []), 6);
>-    checkFloat(program, callFunction(program, "foo3", [], []), 4);
>+    checkFloat(program, callFunction(program, "foo", []), 3);
>+    checkFloat(program, callFunction(program, "foo2", []), 6);
>+    checkFloat(program, callFunction(program, "foo3", []), 4);
> }
> 
> tests.enumWithExplicitIntBase = function()
>@@ -4597,32 +3676,32 @@ tests.enumWithExplicitIntBase = function()
>             return Foo(intDeath());
>         }
>     `);
>-    checkEnum(program, callFunction(program, "war", [], []), 0);
>-    checkEnum(program, callFunction(program, "famine", [], []), 1);
>-    checkEnum(program, callFunction(program, "pestilence", [], []), 2);
>-    checkEnum(program, callFunction(program, "death", [], []), 3);
>-    checkBool(program, callFunction(program, "testSimpleEqual", [], []), true);
>-    checkBool(program, callFunction(program, "testAnotherEqual", [], []), true);
>-    checkBool(program, callFunction(program, "testNotEqual", [], []), false);
>-    checkBool(program, callFunction(program, "testSimpleNotEqual", [], []), false);
>-    checkBool(program, callFunction(program, "testAnotherNotEqual", [], []), false);
>-    checkBool(program, callFunction(program, "testNotNotEqual", [], []), true);
>-    checkInt(program, callFunction(program, "intWar", [], []), 0);
>-    checkInt(program, callFunction(program, "intFamine", [], []), 1);
>-    checkInt(program, callFunction(program, "intPestilence", [], []), 2);
>-    checkInt(program, callFunction(program, "intDeath", [], []), 3);
>-    checkInt(program, callFunction(program, "warValue", [], []), 0);
>-    checkInt(program, callFunction(program, "famineValue", [], []), 1);
>-    checkInt(program, callFunction(program, "pestilenceValue", [], []), 2);
>-    checkInt(program, callFunction(program, "deathValue", [], []), 3);
>-    checkInt(program, callFunction(program, "warValueLiteral", [], []), 0);
>-    checkInt(program, callFunction(program, "famineValueLiteral", [], []), 1);
>-    checkInt(program, callFunction(program, "pestilenceValueLiteral", [], []), 2);
>-    checkInt(program, callFunction(program, "deathValueLiteral", [], []), 3);
>-    checkEnum(program, callFunction(program, "intWarBackwards", [], []), 0);
>-    checkEnum(program, callFunction(program, "intFamineBackwards", [], []), 1);
>-    checkEnum(program, callFunction(program, "intPestilenceBackwards", [], []), 2);
>-    checkEnum(program, callFunction(program, "intDeathBackwards", [], []), 3);
>+    checkEnum(program, callFunction(program, "war", []), 0);
>+    checkEnum(program, callFunction(program, "famine", []), 1);
>+    checkEnum(program, callFunction(program, "pestilence", []), 2);
>+    checkEnum(program, callFunction(program, "death", []), 3);
>+    checkBool(program, callFunction(program, "testSimpleEqual", []), true);
>+    checkBool(program, callFunction(program, "testAnotherEqual", []), true);
>+    checkBool(program, callFunction(program, "testNotEqual", []), false);
>+    checkBool(program, callFunction(program, "testSimpleNotEqual", []), false);
>+    checkBool(program, callFunction(program, "testAnotherNotEqual", []), false);
>+    checkBool(program, callFunction(program, "testNotNotEqual", []), true);
>+    checkInt(program, callFunction(program, "intWar", []), 0);
>+    checkInt(program, callFunction(program, "intFamine", []), 1);
>+    checkInt(program, callFunction(program, "intPestilence", []), 2);
>+    checkInt(program, callFunction(program, "intDeath", []), 3);
>+    checkInt(program, callFunction(program, "warValue", []), 0);
>+    checkInt(program, callFunction(program, "famineValue", []), 1);
>+    checkInt(program, callFunction(program, "pestilenceValue", []), 2);
>+    checkInt(program, callFunction(program, "deathValue", []), 3);
>+    checkInt(program, callFunction(program, "warValueLiteral", []), 0);
>+    checkInt(program, callFunction(program, "famineValueLiteral", []), 1);
>+    checkInt(program, callFunction(program, "pestilenceValueLiteral", []), 2);
>+    checkInt(program, callFunction(program, "deathValueLiteral", []), 3);
>+    checkEnum(program, callFunction(program, "intWarBackwards", []), 0);
>+    checkEnum(program, callFunction(program, "intFamineBackwards", []), 1);
>+    checkEnum(program, callFunction(program, "intPestilenceBackwards", []), 2);
>+    checkEnum(program, callFunction(program, "intDeathBackwards", []), 3);
> }
> 
> tests.enumWithUintBase = function()
>@@ -4747,32 +3826,32 @@ tests.enumWithUintBase = function()
>             return Foo(uintDeath());
>         }
>     `);
>-    checkEnum(program, callFunction(program, "war", [], []), 0);
>-    checkEnum(program, callFunction(program, "famine", [], []), 1);
>-    checkEnum(program, callFunction(program, "pestilence", [], []), 2);
>-    checkEnum(program, callFunction(program, "death", [], []), 3);
>-    checkBool(program, callFunction(program, "testSimpleEqual", [], []), true);
>-    checkBool(program, callFunction(program, "testAnotherEqual", [], []), true);
>-    checkBool(program, callFunction(program, "testNotEqual", [], []), false);
>-    checkBool(program, callFunction(program, "testSimpleNotEqual", [], []), false);
>-    checkBool(program, callFunction(program, "testAnotherNotEqual", [], []), false);
>-    checkBool(program, callFunction(program, "testNotNotEqual", [], []), true);
>-    checkUint(program, callFunction(program, "uintWar", [], []), 0);
>-    checkUint(program, callFunction(program, "uintFamine", [], []), 1);
>-    checkUint(program, callFunction(program, "uintPestilence", [], []), 2);
>-    checkUint(program, callFunction(program, "uintDeath", [], []), 3);
>-    checkUint(program, callFunction(program, "warValue", [], []), 0);
>-    checkUint(program, callFunction(program, "famineValue", [], []), 1);
>-    checkUint(program, callFunction(program, "pestilenceValue", [], []), 2);
>-    checkUint(program, callFunction(program, "deathValue", [], []), 3);
>-    checkUint(program, callFunction(program, "warValueLiteral", [], []), 0);
>-    checkUint(program, callFunction(program, "famineValueLiteral", [], []), 1);
>-    checkUint(program, callFunction(program, "pestilenceValueLiteral", [], []), 2);
>-    checkUint(program, callFunction(program, "deathValueLiteral", [], []), 3);
>-    checkEnum(program, callFunction(program, "uintWarBackwards", [], []), 0);
>-    checkEnum(program, callFunction(program, "uintFamineBackwards", [], []), 1);
>-    checkEnum(program, callFunction(program, "uintPestilenceBackwards", [], []), 2);
>-    checkEnum(program, callFunction(program, "uintDeathBackwards", [], []), 3);
>+    checkEnum(program, callFunction(program, "war", []), 0);
>+    checkEnum(program, callFunction(program, "famine", []), 1);
>+    checkEnum(program, callFunction(program, "pestilence", []), 2);
>+    checkEnum(program, callFunction(program, "death", []), 3);
>+    checkBool(program, callFunction(program, "testSimpleEqual", []), true);
>+    checkBool(program, callFunction(program, "testAnotherEqual", []), true);
>+    checkBool(program, callFunction(program, "testNotEqual", []), false);
>+    checkBool(program, callFunction(program, "testSimpleNotEqual", []), false);
>+    checkBool(program, callFunction(program, "testAnotherNotEqual", []), false);
>+    checkBool(program, callFunction(program, "testNotNotEqual", []), true);
>+    checkUint(program, callFunction(program, "uintWar", []), 0);
>+    checkUint(program, callFunction(program, "uintFamine", []), 1);
>+    checkUint(program, callFunction(program, "uintPestilence", []), 2);
>+    checkUint(program, callFunction(program, "uintDeath", []), 3);
>+    checkUint(program, callFunction(program, "warValue", []), 0);
>+    checkUint(program, callFunction(program, "famineValue", []), 1);
>+    checkUint(program, callFunction(program, "pestilenceValue", []), 2);
>+    checkUint(program, callFunction(program, "deathValue", []), 3);
>+    checkUint(program, callFunction(program, "warValueLiteral", []), 0);
>+    checkUint(program, callFunction(program, "famineValueLiteral", []), 1);
>+    checkUint(program, callFunction(program, "pestilenceValueLiteral", []), 2);
>+    checkUint(program, callFunction(program, "deathValueLiteral", []), 3);
>+    checkEnum(program, callFunction(program, "uintWarBackwards", []), 0);
>+    checkEnum(program, callFunction(program, "uintFamineBackwards", []), 1);
>+    checkEnum(program, callFunction(program, "uintPestilenceBackwards", []), 2);
>+    checkEnum(program, callFunction(program, "uintDeathBackwards", []), 3);
> }
> 
> tests.enumFloatBase = function()
>@@ -4818,7 +3897,7 @@ tests.emptyStruct = function()
>             return 46;
>         }
>     `);
>-    checkInt(program, callFunction(program, "foo", [], []), 46);
>+    checkInt(program, callFunction(program, "foo", []), 46);
> }
> 
> tests.enumStructBase = function()
>@@ -4857,9 +3936,9 @@ tests.simpleSwitch = function()
>             }
>         }
>     `);
>-    checkInt(program, callFunction(program, "foo", [], [makeInt(program, 767)]), 27);
>-    checkInt(program, callFunction(program, "foo", [], [makeInt(program, 69)]), 7624);
>-    checkInt(program, callFunction(program, "foo", [], [makeInt(program, 0)]), 49);
>+    checkInt(program, callFunction(program, "foo", [makeInt(program, 767)]), 27);
>+    checkInt(program, callFunction(program, "foo", [makeInt(program, 69)]), 7624);
>+    checkInt(program, callFunction(program, "foo", [makeInt(program, 0)]), 49);
> }
> 
> tests.exhaustiveUint8Switch = function()
>@@ -4870,7 +3949,7 @@ tests.exhaustiveUint8Switch = function()
>     text += "} }";
>     let program = doPrep(text);
>     for (let i = 0; i < 0xff; ++i)
>-        checkFloat(program, callFunction(program, "foo", [], [makeUint8(program, i)]), i * 1.5);
>+        checkFloat(program, callFunction(program, "foo", [makeUint8(program, i)]), i * 1.5);
> }
> 
> tests.notQuiteExhaustiveUint8Switch = function()
>@@ -4891,7 +3970,7 @@ tests.notQuiteExhaustiveUint8SwitchWithDefault = function()
>     text += "} }";
>     let program = doPrep(text);
>     for (let i = 0; i < 0xff; ++i)
>-        checkFloat(program, callFunction(program, "foo", [], [makeUint8(program, i)]), i * 1.5);
>+        checkFloat(program, callFunction(program, "foo", [makeUint8(program, i)]), i * 1.5);
> }
> 
> tests.switchFallThrough = function()
>@@ -4913,9 +3992,9 @@ tests.switchFallThrough = function()
>             return result;
>         }
>     `);
>-    checkInt(program, callFunction(program, "foo", [], [makeInt(program, 767)]), 27 + 7624 + 49);
>-    checkInt(program, callFunction(program, "foo", [], [makeInt(program, 69)]), 7624 + 49);
>-    checkInt(program, callFunction(program, "foo", [], [makeInt(program, 0)]), 49);
>+    checkInt(program, callFunction(program, "foo", [makeInt(program, 767)]), 27 + 7624 + 49);
>+    checkInt(program, callFunction(program, "foo", [makeInt(program, 69)]), 7624 + 49);
>+    checkInt(program, callFunction(program, "foo", [makeInt(program, 0)]), 49);
> }
> 
> tests.switchBreak = function()
>@@ -4938,9 +4017,9 @@ tests.switchBreak = function()
>             return result;
>         }
>     `);
>-    checkInt(program, callFunction(program, "foo", [], [makeInt(program, 767)]), 27);
>-    checkInt(program, callFunction(program, "foo", [], [makeInt(program, 69)]), 7624);
>-    checkInt(program, callFunction(program, "foo", [], [makeInt(program, 0)]), 49);
>+    checkInt(program, callFunction(program, "foo", [makeInt(program, 767)]), 27);
>+    checkInt(program, callFunction(program, "foo", [makeInt(program, 69)]), 7624);
>+    checkInt(program, callFunction(program, "foo", [makeInt(program, 0)]), 49);
> }
> 
> tests.enumSwitchBreakExhaustive = function()
>@@ -4966,9 +4045,9 @@ tests.enumSwitchBreakExhaustive = function()
>             return result;
>         }
>     `);
>-    checkInt(program, callFunction(program, "foo", [], [makeEnum(program, "Foo", "A")]), 27);
>-    checkInt(program, callFunction(program, "foo", [], [makeEnum(program, "Foo", "B")]), 7624);
>-    checkInt(program, callFunction(program, "foo", [], [makeEnum(program, "Foo", "C")]), 49);
>+    checkInt(program, callFunction(program, "foo", [makeEnum(program, "Foo", "A")]), 27);
>+    checkInt(program, callFunction(program, "foo", [makeEnum(program, "Foo", "B")]), 7624);
>+    checkInt(program, callFunction(program, "foo", [makeEnum(program, "Foo", "C")]), 49);
> }
> 
> tests.enumSwitchBreakNotQuiteExhaustive = function()
>@@ -5021,9 +4100,9 @@ tests.enumSwitchBreakNotQuiteExhaustiveWithDefault = function()
>             return result;
>         }
>     `);
>-    checkInt(program, callFunction(program, "foo", [], [makeEnum(program, "Foo", "A")]), 27);
>-    checkInt(program, callFunction(program, "foo", [], [makeEnum(program, "Foo", "B")]), 7624);
>-    checkInt(program, callFunction(program, "foo", [], [makeEnum(program, "Foo", "C")]), 49);
>+    checkInt(program, callFunction(program, "foo", [makeEnum(program, "Foo", "A")]), 27);
>+    checkInt(program, callFunction(program, "foo", [makeEnum(program, "Foo", "B")]), 7624);
>+    checkInt(program, callFunction(program, "foo", [makeEnum(program, "Foo", "C")]), 49);
> }
> 
> tests.simpleRecursiveStruct = function()
>@@ -5072,7 +4151,7 @@ tests.mutuallyRecursiveStructWithPointersBroken = function()
>         }
>     `);
>     checkFail(
>-        () => checkInt(program, callFunction(program, "foo", [], []), -511),
>+        () => checkInt(program, callFunction(program, "foo", []), -511),
>         e => e instanceof WTrapError);
> }
> 
>@@ -5098,7 +4177,7 @@ tests.mutuallyRecursiveStructWithPointers = function()
>             return foo.bar->bar - bar.foo->foo;
>         }
>     `);
>-    checkInt(program, callFunction(program, "foo", [], []), -511);
>+    checkInt(program, callFunction(program, "foo", []), -511);
> }
> 
> tests.linkedList = function()
>@@ -5119,7 +4198,7 @@ tests.linkedList = function()
>             return x.next->next->value;
>         }
>     `);
>-    checkInt(program, callFunction(program, "foo", [], []), 3);
>+    checkInt(program, callFunction(program, "foo", []), 3);
> }
> 
> tests.pointerToPointer = function()
>@@ -5142,7 +4221,7 @@ tests.pointerToPointer = function()
>             return result;
>         }
>     `);
>-    checkInt(program, callFunction(program, "foo", [], []), 76 + 39 + 83);
>+    checkInt(program, callFunction(program, "foo", []), 76 + 39 + 83);
> }
> 
> tests.arrayRefToArrayRef = function()
>@@ -5165,7 +4244,7 @@ tests.arrayRefToArrayRef = function()
>             return result;
>         }
>     `);
>-    checkInt(program, callFunction(program, "foo", [], []), 76 + 39 + 83);
>+    checkInt(program, callFunction(program, "foo", []), 76 + 39 + 83);
> }
> 
> tests.pointerGetter = function()
>@@ -5246,94 +4325,6 @@ tests.setterWithMatchedType = function()
>     `);
> }
> 
>-tests.operatorWithUninferrableTypeVariable = function()
>-{
>-    checkFail(
>-        () => doPrep(`
>-            struct Foo {
>-                int x;
>-            }
>-            Foo operator+<T>(Foo a, Foo b)
>-            {
>-                Foo result;
>-                result.x = a.x + b.x;
>-                return result;
>-            }
>-        `),
>-        e => e instanceof WTypeError);
>-}
>-
>-tests.operatorWithoutUninferrableTypeVariable = function()
>-{
>-    let program = doPrep(`
>-        struct Foo {
>-            int x;
>-        }
>-        Foo operator+(Foo a, Foo b)
>-        {
>-            Foo result;
>-            result.x = a.x + b.x;
>-            return result;
>-        }
>-        int foo()
>-        {
>-            Foo a;
>-            a.x = 645;
>-            Foo b;
>-            b.x = -35;
>-            return (a + b).x;
>-        }
>-    `);
>-    checkInt(program, callFunction(program, "foo", [], []), 645 - 35);
>-}
>-
>-tests.operatorCastWithUninferrableTypeVariable = function()
>-{
>-    checkFail(
>-        () => doPrep(`
>-            struct Foo {
>-                int x;
>-            }
>-            operator<T> Foo(int x)
>-            {
>-                Foo result;
>-                result.x = x;
>-                return result;
>-            }
>-        `),
>-        e => e instanceof WTypeError);
>-}
>-
>-tests.operatorCastWithTypeVariableInferredFromReturnType = function()
>-{
>-    let program = doPrep(`
>-        struct Foo {
>-            int x;
>-        }
>-        protocol Barable {
>-            void bar(thread Barable*, int);
>-        }
>-        void bar(thread float* result, int value)
>-        {
>-            *result = float(value);
>-        }
>-        operator<T:Barable> T(Foo foo)
>-        {
>-            T result;
>-            bar(&result, foo.x);
>-            return result;
>-        }
>-        int foo()
>-        {
>-            Foo foo;
>-            foo.x = 75;
>-            float x = float(foo);
>-            return int(x * 1.5);
>-        }
>-    `);
>-    checkInt(program, callFunction(program, "foo", [], []), 112);
>-}
>-
> tests.incWrongArgumentLength = function()
> {
>     checkFail(
>@@ -5823,7 +4814,7 @@ tests.anderWithNothingWrong = function()
>             return x.foo;
>         }
>     `);
>-    checkInt(program, callFunction(program, "foo", [], []), 13);
>+    checkInt(program, callFunction(program, "foo", []), 13);
> }
> 
> tests.anderWithWrongNumberOfArguments = function()
>@@ -5897,7 +4888,26 @@ tests.anderWithArrayRef = function()
>             return (@x).foo;
>         }
>     `);
>-    checkInt(program, callFunction(program, "foo", [], []), 13);
>+    checkInt(program, callFunction(program, "foo", []), 13);
>+}
>+
>+tests.anderWithBadIndex = function()
>+{
>+    checkFail(() => doPrep(`
>+        int foo(thread int[] x) { return x[-1]; }
>+    `), e => e instanceof Error);
>+
>+    checkFail(() => doPrep(`
>+        int foo(thread int[] x) { return x[1.f]; }
>+    `), e => e instanceof Error);
>+
>+    checkFail(() => doPrep(`
>+        int foo(thread int[] x, int y) { return x[y]; }
>+    `), e => e instanceof Error);
>+
>+    checkFail(() => doPrep(`
>+        int foo(thread int[] x, float y) { return x[y]; }
>+    `), e => e instanceof Error);
> }
> 
> tests.pointerIndexGetter = function()
>@@ -6083,7 +5093,7 @@ tests.indexAnderWithNothingWrong = function()
>             return x[666];
>         }
>     `);
>-    checkInt(program, callFunction(program, "foo", [], []), 13);
>+    checkInt(program, callFunction(program, "foo", []), 13);
> }
> 
> tests.indexAnderWithWrongNumberOfArguments = function()
>@@ -6168,7 +5178,7 @@ tests.indexAnderWithArrayRef = function()
>             return (@x)[float(-1)];
>         }
>     `);
>-    checkInt(program, callFunction(program, "foo", [], []), 13);
>+    checkInt(program, callFunction(program, "foo", []), 13);
> }
> 
> tests.devicePtrPtr = function()
>@@ -6207,306 +5217,6 @@ tests.constantPtrPtr = function()
>         e => e instanceof WTypeError && e.message.indexOf("Illegal pointer to non-primitive type: int32* constant* constant") != -1);
> }
> 
>-tests.pointerIndexGetterInProtocol = function()
>-{
>-    for (let addressSpace of addressSpaces) {
>-        checkFail(
>-            () => doPrep(`
>-                protocol Foo {
>-                    int operator[](${addressSpace} Foo*, uint);
>-                }
>-                struct Bar { }
>-                int operator[](Bar, uint) { return 42; }
>-            `),
>-            e => e instanceof WTypeError && e.message.indexOf("Cannot have getter for pointer type") != -1);
>-    }
>-}
>-
>-tests.loneIndexSetterInProtocol = function()
>-{
>-    checkFail(
>-        () => doPrep(`
>-            protocol Foo {
>-                Foo operator[]=(Foo, uint, int);
>-            }
>-            struct Bar { }
>-            int operator[](Bar, uint) { return 42; }
>-            Bar operator[]=(Bar, uint, int) { return Bar(); }
>-        `),
>-        e => e instanceof WTypeError && e.message.indexOf("Every setter must have a matching getter") != -1);
>-}
>-
>-tests.notLoneIndexSetterInProtocol = function()
>-{
>-    doPrep(`
>-        protocol Foo {
>-            int operator[](Foo, uint);
>-            Foo operator[]=(Foo, uint, int);
>-        }
>-        struct Bar { }
>-        int operator[](Bar, uint) { return 42; }
>-        Bar operator[]=(Bar, uint, int) { return Bar(); }
>-    `);
>-}
>-
>-tests.indexSetterWithMismatchedTypeInProtocol = function()
>-{
>-    checkFail(
>-        () => doPrep(`
>-            protocol Foo {
>-                float operator[](Foo, uint);
>-                Foo operator[]=(Foo, uint, int);
>-            }
>-            struct Bar { }
>-            int operator[](Bar, uint) { return 42; }
>-            Bar operator[]=(Bar, uint, int) { return Bar(); }
>-        `),
>-        e => e instanceof WTypeError && e.message.indexOf("Setter and getter must agree on value type") != -1);
>-}
>-
>-tests.indexOperatorWrongArgumentLengthInProtocol = function()
>-{
>-    checkFail(
>-        () => doPrep(`
>-            protocol Foo {
>-                int operator[]();
>-            }
>-            struct Bar { }
>-            int operator[](Bar, uint) { return 42; }
>-        `),
>-        e => e instanceof WTypeError && e.message.indexOf("Protocol's type variable (Foo) not mentioned in signature") != -1);
>-    checkFail(
>-        () => doPrep(`
>-            protocol Foo {
>-                int operator[](Foo);
>-            }
>-            struct Bar { }
>-            int operator[](Bar, uint) { return 42; }
>-        `),
>-        e => e instanceof WTypeError && e.message.indexOf("Incorrect number of parameters") != -1);
>-    checkFail(
>-        () => doPrep(`
>-            protocol Foo {
>-                int operator[](Foo, int, int);
>-            }
>-            struct Bar { }
>-            int operator[](Bar, uint) { return 42; }
>-        `),
>-        e => e instanceof WTypeError && e.message.indexOf("Incorrect number of parameters") != -1);
>-}
>-
>-tests.indexOperatorSetterWrongArgumentLengthInProtocol = function()
>-{
>-    checkFail(
>-        () => doPrep(`
>-            protocol Foo {
>-                int operator[]=();
>-            }
>-            struct Bar { }
>-            int operator[](Bar, uint) { return 42; }
>-            Bar operator[]=(Bar, uint, int) { return Bar(); }
>-        `),
>-        e => e instanceof WTypeError && e.message.indexOf("Protocol's type variable (Foo) not mentioned in signature") != -1);
>-    checkFail(
>-        () => doPrep(`
>-            protocol Foo {
>-                int operator[]=(Foo);
>-            }
>-            struct Bar { }
>-            int operator[](Bar, uint) { return 42; }
>-            Bar operator[]=(Bar, uint, int) { return Bar(); }
>-        `),
>-        e => e instanceof WTypeError && e.message.indexOf("Incorrect number of parameters") != -1);
>-    checkFail(
>-        () => doPrep(`
>-            protocol Foo {
>-                int operator[]=(Foo, int);
>-            }
>-            struct Bar { }
>-            int operator[](Bar, uint) { return 42; }
>-            Bar operator[]=(Bar, uint, int) { return Bar(); }
>-        `),
>-        e => e instanceof WTypeError && e.message.indexOf("Incorrect number of parameters") != -1);
>-    checkFail(
>-        () => doPrep(`
>-            protocol Foo {
>-                int operator[]=(Foo, int, int, int);
>-            }
>-            struct Bar { }
>-            int operator[](Bar, uint) { return 42; }
>-            Bar operator[]=(Bar, uint, int) { return Bar(); }
>-        `),
>-        e => e instanceof WTypeError && e.message.indexOf("Incorrect number of parameters") != -1);
>-}
>-
>-tests.loneIndexSetterPointerInProtocol = function()
>-{
>-    checkFail(
>-        () => doPrep(`
>-            protocol Foo {
>-                thread int* operator[]=(thread Foo* ptr, uint, int);
>-            }
>-            struct Bar { }
>-            int operator[](Bar, uint) { return 42; }
>-            Bar operator[]=(Bar, uint, int) { return Bar(); }
>-        `),
>-        e => e instanceof WTypeError && e.message.indexOf("Cannot have setter for pointer type") != -1);
>-}
>-
>-tests.indexSetterWithNoGetterOverloadInProtocol = function()
>-{
>-    checkFail(
>-        () => doPrep(`
>-            protocol Foo {
>-                int operator[](int, Foo);
>-                Foo operator[]=(Foo, uint, int);
>-            }
>-            struct Bar { }
>-            int operator[](Bar, uint) { return 42; }
>-            Bar operator[]=(Bar, uint, int) { return Bar(); }
>-        `),
>-        e => e instanceof WTypeError && e.message.indexOf("Did not find function named operator[]= with arguments Foo,uint32") != -1);
>-}
>-
>-tests.indexSetterWithNoGetterOverloadFixedInProtocol = function()
>-{
>-    doPrep(`
>-        protocol Foo {
>-            int operator[](Foo, uint);
>-            Foo operator[]=(Foo, uint, int);
>-        }
>-        struct Bar { }
>-        int operator[](Bar, uint) { return 42; }
>-        Bar operator[]=(Bar, uint, int) { return Bar(); }
>-    `);
>-}
>-
>-tests.indexAnderWithNothingWrongInProtocol = function()
>-{
>-    let program = doPrep(`
>-        protocol Foo {
>-            thread int* operator&[](thread Foo* foo, uint);
>-        }
>-        int bar<T:Foo>(T x)
>-        {
>-            return x[42];
>-        }
>-        struct Bar { }
>-        thread int* operator&[](thread Bar*, uint)
>-        {
>-            int result = 1234;
>-            return &result;
>-        }
>-        int foo()
>-        {
>-            return bar(Bar());
>-        }
>-    `);
>-    checkInt(program, callFunction(program, "foo", [], []), 1234);
>-}
>-
>-tests.indexAnderWithWrongNumberOfArgumentsInProtocol = function()
>-{
>-    checkFail(
>-        () => doPrep(`
>-            protocol Foo {
>-                thread int* operator&[]();
>-            }
>-            struct Bar { }
>-            thread int* operator&[](thread Bar*, uint)
>-            {
>-                int result = 1234;
>-                return &result;
>-            }
>-        `),
>-        e => e instanceof WTypeError && e.message.indexOf("Protocol's type variable (Foo) not mentioned in signature") != -1);
>-    checkFail(
>-        () => doPrep(`
>-            protocol Foo {
>-                thread int* operator&[](thread Foo* foo);
>-            }
>-            struct Bar { }
>-            thread int* operator&[](thread Bar*, uint)
>-            {
>-                int result = 1234;
>-                return &result;
>-            }
>-        `),
>-        e => e instanceof WTypeError && e.message.indexOf("Incorrect number of parameters for operator&[]") != -1);
>-    checkFail(
>-        () => doPrep(`
>-            protocol Foo {
>-                thread int* operator&[](thread Foo* foo, uint, uint);
>-            }
>-            struct Bar { }
>-            thread int* operator&[](thread Bar*, uint)
>-            {
>-                int result = 1234;
>-                return &result;
>-            }
>-        `),
>-        e => e instanceof WTypeError && e.message.indexOf("Incorrect number of parameters for operator&[]") != -1);
>-}
>-
>-tests.indexAnderDoesntReturnPointerInProtocol = function()
>-{
>-    checkFail(
>-        () => doPrep(`
>-            protocol Foo {
>-                int operator&[](thread Foo* foo, uint);
>-            }
>-            struct Bar { }
>-            thread int* operator&[](thread Bar*, uint)
>-            {
>-                int result = 1234;
>-                return &result;
>-            }
>-        `),
>-        e => e instanceof WTypeError && e.message.indexOf("Return type of ander is not a pointer") != -1);
>-}
>-
>-tests.indexAnderDoesntTakeReferenceInProtocol = function()
>-{
>-    checkFail(
>-        () => doPrep(`
>-            protocol Foo {
>-                thread int* operator&[](Foo foo, uint);
>-            }
>-            struct Bar { }
>-            thread int* operator&[](thread Bar*, uint)
>-            {
>-                int result = 1234;
>-                return &result;
>-            }
>-        `),
>-        e => e instanceof WTypeError && e.message.indexOf("Parameter to ander is not a reference") != -1);
>-}
>-
>-tests.indexAnderWithArrayRefInProtocol = function()
>-{
>-    let program = doPrep(`
>-        protocol Foo {
>-            thread int* operator&[](thread Foo[] array, float index);
>-        }
>-        int bar<T:Foo>(thread T[] x)
>-        {
>-            return x[1.5];
>-        }
>-        struct Bar { }
>-        thread int* operator&[](thread Bar[], float)
>-        {
>-            int result = 1234;
>-            return &result;
>-        }
>-        int foo()
>-        {
>-            Bar x;
>-            return bar(@x);
>-        }
>-    `);
>-    checkInt(program, callFunction(program, "foo", [], []), 1234);
>-}
>-
> tests.andReturnedArrayRef = function()
> {
>     let program = doPrep(`
>@@ -6522,7 +5232,7 @@ tests.andReturnedArrayRef = function()
>             return *ptr;
>         }
>     `);
>-    checkInt(program, callFunction(program, "foo", [], []), 354);
>+    checkInt(program, callFunction(program, "foo", []), 354);
> }
> 
> okToTest = true;
>diff --git a/Tools/WebGPUShadingLanguageRI/Type.js b/Tools/WebGPUShadingLanguageRI/Type.js
>index 7c287918953a5b1d5e35e850e330f389df6e76e8..21a331958e134bd995803bda81fcccc1efb44c6d 100644
>--- a/Tools/WebGPUShadingLanguageRI/Type.js
>+++ b/Tools/WebGPUShadingLanguageRI/Type.js
>@@ -25,7 +25,6 @@
> "use strict";
> 
> class Type extends Node {
>-    get typeParameters() { return []; }
>     get kind() { return Type; }
>     get isPtr() { return false; }
>     get isArray() { return false; }
>@@ -37,15 +36,6 @@ class Type extends Node {
>     get isEnum() { return false; }
>     get isPrimitive() { return false; }
>     
>-    inherits(protocol)
>-    {
>-        if (!protocol)
>-            return {result: true};
>-        return protocol.hasHeir(this);
>-    }
>-    
>-    get instantiatedType() { return this.visit(new InstantiateImmediates()); }
>-    
>     // Have to call these on the unifyNode.
>     argumentForAndOverload(origin, value)
>     {
>diff --git a/Tools/WebGPUShadingLanguageRI/TypeDef.js b/Tools/WebGPUShadingLanguageRI/TypeDef.js
>index 6c0f9c174f53235641f4cd302cab4c3aab27c143..1de2d74ebc660db77f35cc46d6eb8fd36c587f16 100644
>--- a/Tools/WebGPUShadingLanguageRI/TypeDef.js
>+++ b/Tools/WebGPUShadingLanguageRI/TypeDef.js
>@@ -25,23 +25,22 @@
> "use strict";
> 
> class TypeDef extends Type {
>-    constructor(origin, name, typeParameters, type)
>+    constructor(origin, name, type)
>     {
>         super();
>         this._origin = origin;
>         this._name = name;
>-        this._typeParameters = typeParameters;
>         this._type = type;
>     }
>     
>+    get unifyNode() { return this.type.unifyNode; }
>     get origin() { return this._origin; }
>     get name() { return this._name; }
>-    get typeParameters() { return this._typeParameters; }
>     get type() { return this._type; }
>     
>     toString()
>     {
>-        return "typedef " + this.name + "<" + this.typeParameters + "> = " + this.type;
>+        return `typedef ${this.name} = ${this.type}`;
>     }
> }
> 
>diff --git a/Tools/WebGPUShadingLanguageRI/TypeDefResolver.js b/Tools/WebGPUShadingLanguageRI/TypeDefResolver.js
>index a81eab42d948fca3e930c6857a964ddccfcee57f..53f95c409d06abb1872ebb04f06f1e46a8bb1208 100644
>--- a/Tools/WebGPUShadingLanguageRI/TypeDefResolver.js
>+++ b/Tools/WebGPUShadingLanguageRI/TypeDefResolver.js
>@@ -34,19 +34,8 @@ class TypeDefResolver extends Visitor {
>     visitTypeRef(node)
>     {
>         this._visiting.doVisit(node, () => {
>-            for (let typeArgument of node.typeArguments)
>-                typeArgument.visit(this);
>             if (node.type instanceof TypeDef) {
>-                let unificationContext = new UnificationContext(node.type.typeParameters);
>-                if (node.typeArguments.length != node.type.typeParameters.length)
>-                    throw new Error("argument/parameter mismatch (should have been caught earlier)");
>-                for (let i = 0; i < node.typeArguments.length; ++i)
>-                    node.typeArguments[i].unify(unificationContext, node.type.typeParameters[i]);
>-                let verificationResult = unificationContext.verify();
>-                if (!verificationResult.result)
>-                    throw new WTypeError(node.origin.originString, "Type reference to a type definition violates protocol constraints: " + verificationResult.reason);
>-                
>-                let newType = node.type.type.substituteToUnification(node.type.typeParameters, unificationContext);
>+                let newType = node.type.type;
>                 newType.visit(this);
>                 node.setTypeAndArguments(newType, []);
>             }
>diff --git a/Tools/WebGPUShadingLanguageRI/TypeOrVariableRef.js b/Tools/WebGPUShadingLanguageRI/TypeOrVariableRef.js
>deleted file mode 100644
>index c5f59f90066fdb0b7c7bb72ea618a711230d1e6e..0000000000000000000000000000000000000000
>--- a/Tools/WebGPUShadingLanguageRI/TypeOrVariableRef.js
>+++ /dev/null
>@@ -1,42 +0,0 @@
>-/*
>- * Copyright (C) 2017 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. ``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
>- * 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. 
>- */
>-"use strict";
>-
>-class TypeOrVariableRef extends Node {
>-    constructor(origin, name)
>-    {
>-        super();
>-        this._origin = origin;
>-        this._name = name;
>-    }
>-    
>-    get origin() { return this._origin; }
>-    get name() { return this._name; }
>-
>-    toString()
>-    {
>-        return this.name;
>-    }
>-}
>diff --git a/Tools/WebGPUShadingLanguageRI/TypeParameterRewriter.js b/Tools/WebGPUShadingLanguageRI/TypeParameterRewriter.js
>deleted file mode 100644
>index 3bd037c927275160fc45eb2f9a86691777116ba0..0000000000000000000000000000000000000000
>--- a/Tools/WebGPUShadingLanguageRI/TypeParameterRewriter.js
>+++ /dev/null
>@@ -1,38 +0,0 @@
>-/*
>- * Copyright (C) 2017 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. ``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
>- * 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. 
>- */
>-"use strict";
>-
>-class TypeParameterRewriter {
>-    visitConstexprTypeParameter(node)
>-    {
>-        return new ConstexprTypeParameter(node.origin, node.name, node.type.visit(new Rewriter()));
>-    }
>-    
>-    visitTypeVariable(node)
>-    {
>-        return new TypeVariable(node.origin, node.name, node.protocol);
>-    }
>-}
>-
>diff --git a/Tools/WebGPUShadingLanguageRI/TypeRef.js b/Tools/WebGPUShadingLanguageRI/TypeRef.js
>index f2b322f3af6a73086141e56d693efce1c351dafc..7d2d8690ba188f1241d690211a48b7216589fa51 100644
>--- a/Tools/WebGPUShadingLanguageRI/TypeRef.js
>+++ b/Tools/WebGPUShadingLanguageRI/TypeRef.js
>@@ -25,69 +25,58 @@
> "use strict";
> 
> class TypeRef extends Type {
>-    constructor(origin, name, typeArguments)
>+    constructor(origin, name)
>     {
>         super();
>         this._origin = origin;
>         this._name = name;
>         this.type = null;
>-        this._typeArguments = typeArguments;
>     }
>     
>     static wrap(type)
>     {
>-        if (type instanceof TypeRef && !type.typeArguments)
>+        if (type instanceof TypeRef)
>             return type;
>         let name = type.name;
>-        let result = new TypeRef(type.origin, name, []);
>+        let result = new TypeRef(type.origin, name);
>         result.type = type;
>         return result;
>     }
>     
>-    static instantiate(type, typeArguments)
>+    static instantiate(type)
>     {
>-        let result = new TypeRef(type.origin, type.name, typeArguments);
>+        let result = new TypeRef(type.origin, type.name, []);
>         result.type = type;
>         return result;
>     }
>  
>     get origin() { return this._origin; }
>     get name() { return this._name; }
>-    get typeArguments() { return this._typeArguments; }
>     
>     get unifyNode()
>     {
>-        if (!this.typeArguments.length)
>-            return this.type.unifyNode;
>-        return this;
>+        return this.type.unifyNode;
>     }
>     
>     populateDefaultValue(buffer, offset)
>     {
>-        if (!this.typeArguments.length)
>-            return this.type.populateDefaultValue(buffer, offset);
>-        throw new Error("Cannot get default value of a type instantiation");
>+        return this.type.populateDefaultValue(buffer, offset);
>     }
>     
>     get size()
>     {
>-        if (!this.typeArguments.length)
>-            return this.type.size;
>-        throw new Error("Cannot get size of a type instantiation");
>+        return this.type.size;
>     }
>     
>     get isPrimitive()
>     {
>-        if (!this.typeArguments.length)
>-            return this.type.isPrimitive;
>-        throw new Error("Cannot determine if an uninstantiated type is primitive: " + this);
>+        return this.type.isPrimitive;
>     }
>     
>-    setTypeAndArguments(type, typeArguments)
>+    setType(type)
>     {
>         this._name = null;
>         this.type = type;
>-        this._typeArguments = typeArguments;
>     }
>     
>     unifyImpl(unificationContext, other)
>@@ -96,12 +85,6 @@ class TypeRef extends Type {
>             return false;
>         if (!this.type.unify(unificationContext, other.type))
>             return false;
>-        if (this.typeArguments.length != other.typeArguments.length)
>-            return false;
>-        for (let i = 0; i < this.typeArguments.length; ++i) {
>-            if (!this.typeArguments[i].unify(unificationContext, other.typeArguments[i]))
>-                return false;
>-        }
>         return true;
>     }
>     
>@@ -109,9 +92,7 @@ class TypeRef extends Type {
>     {
>         if (!this.name)
>             return this.type.toString();
>-        if (!this.typeArguments.length)
>-            return this.name;
>-        return this.name + "<" + this.typeArguments + ">";
>+        return this.name;
>     }
> }
> 
>diff --git a/Tools/WebGPUShadingLanguageRI/TypeVariable.js b/Tools/WebGPUShadingLanguageRI/TypeVariable.js
>deleted file mode 100644
>index 33218a959f51d1eeb9d0514b950dec9672fa0b7e..0000000000000000000000000000000000000000
>--- a/Tools/WebGPUShadingLanguageRI/TypeVariable.js
>+++ /dev/null
>@@ -1,106 +0,0 @@
>-/*
>- * Copyright (C) 2017 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. ``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
>- * 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. 
>- */
>-"use strict";
>-
>-class TypeVariable extends Type {
>-    constructor(origin, name, protocol)
>-    {
>-        super();
>-        this._origin = origin;
>-        this._name = name;
>-        this._protocol = protocol;
>-    }
>-    
>-    get origin() { return this._origin; }
>-    get name() { return this._name; }
>-    get protocol() { return this._protocol; }
>-    
>-    get isPrimitive()
>-    {
>-        return this._protocol && this._protocol.isPrimitive;
>-    }
>-    
>-    get isUnifiable() { return true; }
>-    
>-    inherits(protocol)
>-    {
>-        if (!protocol)
>-            return {result: true};
>-        if (!this.protocol)
>-            return {result: false, reason: "Type variable " + this + " does not have a protocol"};
>-        return this.protocol.inherits(protocol);
>-    }
>-    
>-    typeVariableUnify(unificationContext, other)
>-    {
>-        if (!(other instanceof Type))
>-            return false;
>-        
>-        return this._typeVariableUnifyImpl(unificationContext, other);
>-    }
>-    
>-    unifyImpl(unificationContext, other)
>-    {
>-        return this.typeVariableUnify(unificationContext, other);
>-    }
>-    
>-    verifyAsArgument(unificationContext)
>-    {
>-        let realThis = unificationContext.find(this);
>-        
>-        // The thing we get unified with must be a type variable that accepts a broader set of
>-        // things than we do.
>-        if (!(realThis instanceof TypeVariable))
>-            return {result: false, reason: "Type variable argument " + this + " cannot be passed to non-type-variable parameter type " + realThis};
>-        
>-        if (!this.protocol) {
>-            if (realThis.protocol)
>-                return {result: false, reason: "Type variable without protocol " + this + " cannot be passed to parameter type variable with protocol " + realThis.protocol};
>-            return {result: true};
>-        }
>-        
>-        let result = this.protocol.inherits(realThis.protocol);
>-        if (!result.result)
>-            return {result: false, reason: "Protocol " + this.protocol + " does not subsume protocol " + realThis.protocol + " (passing type " + this + " to type " + realThis + "): " + result.reason};
>-        return {result: true};
>-    }
>-    
>-    verifyAsParameter(unificationContext)
>-    {
>-        if (!this.protocol)
>-            return {result: true};
>-        let realThis = unificationContext.find(this);
>-        let result = realThis.inherits(this.protocol);
>-        if (!result.result)
>-            return {result: false, reason: "Type " + realThis + " does not inherit protocol " + this.protocol + " (passing type " + realThis + " to type " + this + "): " + result.reason};
>-        return {result: true};
>-    }
>-    
>-    toString()
>-    {
>-        return this.name + (this.protocol ? ":" + this.protocol.name : "");
>-    }
>-}
>-
>diff --git a/Tools/WebGPUShadingLanguageRI/TypeVariableTracker.js b/Tools/WebGPUShadingLanguageRI/TypeVariableTracker.js
>deleted file mode 100644
>index 2e9e29aae1454927cd0d5139c0852391f835f7c7..0000000000000000000000000000000000000000
>--- a/Tools/WebGPUShadingLanguageRI/TypeVariableTracker.js
>+++ /dev/null
>@@ -1,57 +0,0 @@
>-/*
>- * Copyright (C) 2017 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. ``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
>- * 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. 
>- */
>-"use strict";
>-
>-class TypeVariableTracker extends Visitor {
>-    constructor()
>-    {
>-        super();
>-        this._set = new Set();
>-    }
>-    
>-    get set() { return this._set; }
>-    
>-    _consider(thing)
>-    {
>-        if (thing.isUnifiable)
>-            this._set.add(thing);
>-    }
>-    
>-    visitTypeRef(node)
>-    {
>-        if (node.typeArguments.length) {
>-            for (let typeArgument of node.typeArguments)
>-                typeArgument.visit(this);
>-            return;
>-        }
>-        this._consider(node.type);
>-    }
>-    
>-    visitVariableRef(node)
>-    {
>-        this._consider(node.variable);
>-    }
>-}
>-
>diff --git a/Tools/WebGPUShadingLanguageRI/UnificationContext.js b/Tools/WebGPUShadingLanguageRI/UnificationContext.js
>index 0a13de43d5326e1357c87f8859d9d6015e0cad47..307f5d6ab4d637efcb21f12e0508b08ea05e101c 100644
>--- a/Tools/WebGPUShadingLanguageRI/UnificationContext.js
>+++ b/Tools/WebGPUShadingLanguageRI/UnificationContext.js
>@@ -25,9 +25,8 @@
> "use strict";
> 
> class UnificationContext {
>-    constructor(typeParameters)
>+    constructor()
>     {
>-        this._typeParameters = new Set(typeParameters);
>         this._nextMap = new Map();
>         this._extraNodes = new Set();
>     }
>@@ -45,10 +44,6 @@ class UnificationContext {
>                 throw new Error("Cannot unify non-unifiable things " + a + " and " + b);
>         }
>         
>-        // Make sure that type parameters don't end up being roots.
>-        if (a.isUnifiable && b.isUnifiable && this._typeParameters.has(b))
>-            [a, b] = [b, a];
>-        
>         this._nextMap.set(a, b);
>     }
>     
>@@ -85,14 +80,11 @@ class UnificationContext {
>         return result;
>     }
>     
>-    typeParameters() { return this._typeParameters; }
>     *typeArguments()
>     {
>         for (let typeArgument of this.nodes) {
>             if (!typeArgument.isUnifiable)
>                 continue;
>-            if (this._typeParameters.has(typeArgument))
>-                continue;
>             yield typeArgument;
>         }
>     }
>@@ -111,28 +103,9 @@ class UnificationContext {
>             if (!result.result)
>                 return result;
>         }
>-        
>-        for (let typeParameter of this._typeParameters) {
>-            let result = typeParameter.verifyAsParameter(this);
>-            if (!result.result)
>-                return result;
>-        }
>-        let numTypeVariableArguments = 0;
>-        let argumentSet = new Set();
>-        for (let typeArgument of this.typeArguments()) {
>-            let result = typeArgument.verifyAsArgument(this);
>-            if (!result.result)
>-                return result;
>-            if (typeArgument.isLiteral)
>-                continue;
>-            argumentSet.add(this.find(typeArgument));
>-            numTypeVariableArguments++;
>-        }
>-        if (argumentSet.size == numTypeVariableArguments)
>-            return {result: true};
>-        return {result: false, reason: "Type variables used as arguments got unified with each other"};
>+        return {result: true};
>     }
>-    
>+
>     get conversionCost()
>     {
>         let result = 0;
>diff --git a/Tools/WebGPUShadingLanguageRI/VariableRef.js b/Tools/WebGPUShadingLanguageRI/VariableRef.js
>index 00759693f3763c89117dd411cf063a26a2258dda..c9faa156f974774ff8e48ddfa1c788f0d986aab9 100644
>--- a/Tools/WebGPUShadingLanguageRI/VariableRef.js
>+++ b/Tools/WebGPUShadingLanguageRI/VariableRef.js
>@@ -40,7 +40,7 @@ class VariableRef extends Expression {
>     }
>     
>     get name() { return this._name; }
>-    get isConstexpr() { return this.variable.isConstexpr; }
>+    get isConstexpr() { return this.variable && this.variable.isConstexpr; }
>     get unifyNode() { return this.variable.unifyNode; } // This only makes sense when this is a constexpr.
>     get isLValue() { return this.variable.varIsLValue; }
>     get addressSpace() { return "thread"; }
>diff --git a/Tools/WebGPUShadingLanguageRI/VectorType.js b/Tools/WebGPUShadingLanguageRI/VectorType.js
>new file mode 100644
>index 0000000000000000000000000000000000000000..5cdacda4da3fc890bcb7a5f228c63fa486a3abdc
>--- /dev/null
>+++ b/Tools/WebGPUShadingLanguageRI/VectorType.js
>@@ -0,0 +1,63 @@
>+/*
>+ * Copyright (C) 2017 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. ``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
>+ * 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.
>+ */
>+"use strict";
>+
>+class VectorType extends NativeParameterizedType {
>+    constructor(origin, name, typeArguments)
>+    {
>+        super(origin, name, typeArguments);
>+        if (typeArguments.length != 2)
>+            throw new Error(`Vector type takes 2 arguments, ${typeArguments.length} given.`);
>+    }
>+
>+    get elementType() { return this._typeArguments[0]; }
>+    get numElements() { return this._typeArguments[1]; }
>+
>+    get numElementsValue() { return this.numElements.value; }
>+    get size() { return this.elementType.size * this.numElementsValue; }
>+
>+    unifyImpl(unificationContext, other)
>+    {
>+        if (!(other instanceof VectorType))
>+            return false;
>+
>+        if (!this.numElements.unify(unificationContext, other.numElements))
>+            return false;
>+
>+        return this.elementType.unify(unificationContext, other.elementType);
>+    }
>+
>+    populateDefaultValue(buffer, offset)
>+    {
>+        for (let i = 0; i < this.numElementsValue; ++i)
>+            this.elementType.populateDefaultValue(buffer, offset + i * this.elementType.size);
>+    }
>+
>+    toString()
>+    {
>+        return `native typedef ${this.name}<${this.elementType}, ${this.numElementsValue}>`;
>+    }
>+}
>+
>diff --git a/Tools/WebGPUShadingLanguageRI/Visitor.js b/Tools/WebGPUShadingLanguageRI/Visitor.js
>index 4bf05313e2857d71efe513ee1e35f050def5336d..3bf9a1696e8650265261095757423ab89be599a0 100644
>--- a/Tools/WebGPUShadingLanguageRI/Visitor.js
>+++ b/Tools/WebGPUShadingLanguageRI/Visitor.js
>@@ -34,17 +34,10 @@ class Visitor {
>     visitFunc(node)
>     {
>         node.returnType.visit(this);
>-        for (let typeParameter of node.typeParameters)
>-            typeParameter.visit(this);
>         for (let parameter of node.parameters)
>             parameter.visit(this);
>     }
>     
>-    visitProtocolFuncDecl(node)
>-    {
>-        this.visitFunc(node);
>-    }
>-    
>     visitFuncParameter(node)
>     {
>         node.type.visit(this);
>@@ -61,12 +54,6 @@ class Visitor {
>         this.visitFunc(node);
>     }
>     
>-    visitNativeFuncInstance(node)
>-    {
>-        this.visitFunc(node);
>-        node.func.visitImplementationData(node.implementationData, this);
>-    }
>-    
>     visitBlock(node)
>     {
>         for (let statement of node.statements)
>@@ -79,62 +66,21 @@ class Visitor {
>             expression.visit(this);
>     }
>     
>-    visitProtocolRef(node)
>-    {
>-    }
>-    
>-    visitProtocolDecl(node)
>-    {
>-        for (let protocol of node.extends)
>-            protocol.visit(this);
>-        for (let signature of node.signatures)
>-            signature.visit(this);
>-    }
>-    
>-    visitTypeRef(node)
>-    {
>-        for (let typeArgument of node.typeArguments)
>-            typeArgument.visit(this);
>-    }
>+    visitTypeRef(node) {}
>     
>-    visitNativeType(node)
>-    {
>-        for (let typeParameter of node.typeParameters)
>-            typeParameter.visit(this);
>-    }
>-    
>-    visitNativeTypeInstance(node)
>-    {
>-        node.type.visit(this);
>-        for (let typeArgument of node.typeArguments)
>-            typeArgument.visit(this);
>-    }
>+    visitNativeType(node) {}
>     
>     visitTypeDef(node)
>     {
>-        for (let typeParameter of node.typeParameters)
>-            typeParameter.visit(this);
>         node.type.visit(this);
>     }
>     
>     visitStructType(node)
>     {
>-        for (let typeParameter of node.typeParameters)
>-            typeParameter.visit(this);
>         for (let field of node.fields)
>             field.visit(this);
>     }
>     
>-    visitTypeVariable(node)
>-    {
>-        Node.visit(node.protocol, this);
>-    }
>-    
>-    visitConstexprTypeParameter(node)
>-    {
>-        node.type.visit(this);
>-    }
>-    
>     visitField(node)
>     {
>         node.type.visit(this);
>@@ -208,6 +154,13 @@ class Visitor {
>     {
>         node.ptr.visit(this);
>     }
>+
>+    visitTernaryExpression(node)
>+    {
>+        node.predicate.visit(this);
>+        node.bodyExpression.visit(this);
>+        node.elseExpression.visit(this);
>+    }
>     
>     _handlePropertyAccessExpression(node)
>     {
>@@ -336,18 +289,8 @@ class Visitor {
>     
>     visitCallExpression(node)
>     {
>-        for (let typeArgument of node.typeArguments)
>-            typeArgument.visit(this);
>         for (let argument of node.argumentList)
>             Node.visit(argument, this);
>-        let handleTypeArguments = actualTypeArguments => {
>-            if (actualTypeArguments) {
>-                for (let argument of actualTypeArguments)
>-                    argument.visit(this);
>-            }
>-        };
>-        handleTypeArguments(node.actualTypeArguments);
>-        handleTypeArguments(node.instantiatedActualTypeArguments);
>         Node.visit(node.nativeFuncInstance, this);
>         Node.visit(node.returnType, this);
>         Node.visit(node.resultType, this);
>@@ -384,5 +327,16 @@ class Visitor {
>     {
>         node.target.visit(this);
>     }
>+
>+    visitNativeParameterizedType(node)
>+    {
>+        for (let typeArg of node.typeArguments)
>+            typeArg.visit(this);
>+    }
>+
>+    visitVectorType(node)
>+    {
>+        node.elementType.visit(this);
>+    }
> }
> 
>diff --git a/Tools/WebGPUShadingLanguageRI/WSL.md b/Tools/WebGPUShadingLanguageRI/WSL.md
>deleted file mode 100644
>index d3b66567826a51dd6c754d4e9b24d7578972bb3d..0000000000000000000000000000000000000000
>--- a/Tools/WebGPUShadingLanguageRI/WSL.md
>+++ /dev/null
>@@ -1,479 +0,0 @@
>-# WebGPU Shading Language
>-
>-WebGPU Shading Language, or WSL for short, is a type-safe low-overhead programming language for GPUs (graphics processing units). This document explains how WSL works.
>-
>-# Goals
>-
>-WSL is designed to achieve the following goals:
>-
>-- WSL should feel *familiar* to C++ programmers.
>-- WSL should be have a *sound* and *decidable* type system.
>-- WSL should not permit *out-of-bounds* memory accesses.
>-- WSL should be have *low overhead*.
>-
>-The combination of a sound type system and bounds checking makes WSL a secure shader language: the language itself is responsible for isolating the shader from the rest of the GPU.
>-
>-# Familiar Syntax
>-
>-WSL is based on C syntax, but excludes features that are either unnecessary, insecure, or replaced by other WSL features:
>-
>-- No strings.
>-- No `register`, `volatile`, `const`, `restrict`, or `extern` keywords.
>-- No unions. `union` is not a keyword.
>-- No goto or labels. `goto` is not a keyword.
>-- No `*` pointers.
>-- Effectless expressions are not statements (`a + b;` is a parse error).
>-- No undefined values (`int x;` initializes x to 0).
>-- No automatic type conversions (`int x; uint y = x;` is a type error).
>-- No recursion.
>-- No dynamic memory allocation.
>-- No modularity. The whole program is one file.
>-
>-On top of this bare C-like foundation, WSL adds secure versions of familiar C++ features:
>-
>-- Type-safe pointers (`^`) and array references (`[]`).
>-- Generics to replace templates.
>-- Operator overloading. Built-in operations like `int operator+(int, int)` are just native functions.
>-- Cast overloading. Built-in casts like `operator int(double)` are just native functions.
>-- Getters and setters. Property accesses like `vec.x` resolve to overloads like `float operator.field(float4)`.
>-- Array access overloading. Array accesses like `vec[0]` resolve to verloads like `float operator[](float4, uint)`.
>-
>-In the following sections, WSL is shown by example starting with its C-like foundation and then building up to include more sophisticated features like generics.
>-
>-## Common subset of C and WSL
>-
>-The following is a valid WSL function definition:
>-
>-    int foo(int x, int y, bool p)
>-    {
>-        if (p)
>-            return x - y;
>-        return x + y;
>-    }
>-
>-WSL source files behave similarly to C source files:
>-
>-- Top-level statements must be type or function definitions.
>-- WSL uses structured C control flow constructs, like `if`, `while`, `for`, `do`, `break`, and `continue`.
>-- WSL uses C-like `switch` statements, but does not allow them to overlap other control flow (i.e. no [Duff's device](https://en.wikipedia.org/wiki/Duff%27s_device)).
>-- WSL allows variable declarations anywhere C++ would.
>-
>-WSL types differ from C types. For example, this is an array of 42 integers in WSL:
>-
>-    int[42] array;
>-
>-The type never surrounds the variable, like it would in C (`int array[42]`).
>-
>-## Type-safe pointers
>-
>-WSL includes a secure pointer type. To emphasize that it is not like the C pointer, WSL uses `^` for the pointer type and for dereference. Like in C, `&` is used to take the address of a value.  Because GPUs have different kinds of memories, pointers must be annotated with an address space (one of `thread`, `threadgroup`, `device`, or `constant`). For example:
>-
>-    void bar(thread int^ p)
>-    {
>-        ^p += 42;
>-    }
>-    int foo()
>-    {
>-        int x = 24;
>-        bar(&x);
>-        return x; // Returns 66.
>-    }
>-
>-Pointers can be `null`. Each pointer access is null-checked, though most pointer accesses (like this one) will not have a null check. WSL places enough constraints on the programmer that programs are easy for the compiler to analyze. The compiler will always know that `^p += 42` adds `42` to `x` in this case.
>-
>-WSL pointers do not support casting or pointer arithmetic. All memory accessible to a shader outlives the shader. This is even true of local variables. This is possible because WSL does not support recursion. Therefore, local variables simply get global storage. Local variables are initialized at the point of their declaration. Hence, the following is a valid program, which will exhibit the same behavior on every WSL implementation:
>-
>-    thread int^ foo()
>-    {
>-        int x = 42;
>-        return &x;
>-    }
>-    int bar()
>-    {
>-        thread int^ p = foo();
>-        thread int^ q = foo();
>-        ^p = 53;
>-        return ^q; // Returns 53.
>-    }
>-    int baz()
>-    {
>-        thread int^ p = foo();
>-        ^p = 53;
>-        foo();
>-        return ^p; // Returns 42.
>-    }
>-
>-It's possible to point to any kind of data type. For example, `thread double[42]^` is a pointer to an array of 42 doubles.
>-
>-## Type-safe array references
>-
>-WSL supports array references that carry a pointer to the base of the array and the array's length. This allows accesses to the array to be bounds-checked.
>-
>-An array reference can be created using the `@` operator:
>-
>-    int[42] array;
>-    thread int[] arrayRef = @array;
>-
>-Both arrays and array references can be loaded from and stored to using `operator[]`:
>-
>-    int x = array[i];
>-    int y = arrayRef[i];
>-
>-Both arrays and array references know their length:
>-
>-    uint arrayLength = array.length;
>-    uint arrayRefLength = arrayRef.length;
>-
>-Given an array or array reference, it's possible to get a pointer to one of its elements:
>-
>-    thread int^ ptr1 = &array[i];
>-    thread int^ ptr2 = &arrayRef[i];
>-
>-A pointer is like an array reference with one element. It's possible to perform this conversion:
>-
>-    thread int[] ref = @ptr1;
>-    ref[0] // Equivalent to ^ptr1.
>-    ref.length // 0 if ptr1 was null, 1 if ptr1 was not null.
>-
>-Similarly, using `@` on a non-pointer value results in a reference of length 1:
>-
>-    int x;
>-    thread int[] ref = @x;
>-    ref[0] // Aliases x.
>-    ref.length // Returns 1.
>-
>-It's not legal to use `@` on an array reference:
>-
>-    thread int[] ref;
>-    thread int[][] referef = @ref; // Error!
>-
>-## Generics
>-
>-WSL supports generic types using a simple syntax. WSL's generic are designed to integrate cleanly into the compiler pipeline:
>-
>-- Generics have unambiguous syntax.
>-- Generic functions can be type checked before they are instantiated.
>-
>-Semantic errors inside generic functions show up once regardless of the number of times the generic function is instantiated.
>-
>-This is a simple generic function:
>-
>-    T identity<T>(T value)
>-    {
>-        T tmp = value;
>-        return tmp;
>-    }
>-
>-WSL also supports structs, which are also allowed to be generic:
>-
>-    // Not generic.
>-    struct Foo {
>-        int x;
>-        double y;
>-    }
>-    // Generic.
>-    struct Bar<T, U> {
>-        T x;
>-        U y;
>-    }
>-
>-Type parameters can also be constant expressions. For example:
>-
>-    void initializeArray<T, uint length>(thread T[length]^ array, T value)
>-    {
>-        for (uint i = length; i--;)
>-            (^array)[i] = value;
>-    }
>-
>-Constant expressions passed as type arguments must obey a very narrow definition of constantness. Only literals and references to other constant parameters qualify.
>-
>-WSL is guaranteed to compile generics by instantiation. This is observable, since functions can return pointers to their locals. Here is an example of this phenomenon:
>-
>-    thread int^ allocate<uint>()
>-    {
>-        int x;
>-        return &x;
>-    }
>-
>-The `allocate` function will return a different pointer for each unsigned integer constant passed as a type parameter. This allocation is completely static, since the `uint` parameter must be given a compile-time constant.
>-
>-WSL's `typedef` uses a slightly different syntax than C. For example:
>-
>-    struct Complex<T> {
>-        T real;
>-        T imag;
>-    }
>-    typedef FComplex = Complex<float>;
>-
>-`typedef` can be used to create generic types:
>-
>-    struct Foo<T, U> {
>-        T x;
>-        U y;
>-    }
>-    typedef Bar<T> = Foo<T, T>;
>-
>-## Protocols
>-
>-Protocols enable generic functions to work with data of generic type. Because a function must be type-checkable before instantiation, the following would not be legal:
>-
>-    int bar(int) { ... }
>-    double bar(double) { ... }
>-    
>-    T foo<T>(T value)
>-    {
>-        return bar(value); // Error!
>-    }
>-
>-The call to `bar` doesn't type check because the compiler cannot know that `foo<T>` will be instantiated with `T = int` or `T = double`. Protocols enable the programmer to tell the compiler what to expect of a type variable:
>-
>-    int bar(int) { ... }
>-    double bar(double) { ... }
>-    
>-    protocol SupportsBar {
>-        SupportsBar bar(SupportsBar);
>-    }
>-    
>-    T foo<T:SupportsBar>(T value)
>-    {
>-        return bar(value);
>-    }
>-    
>-    int x = foo(42);
>-    double y = foo(4.2);
>-
>-Protocols have automatic relationships to one another based on what functions they contain:
>-
>-    protocol Foo {
>-        void foo(Foo);
>-    }
>-    protocol Bar {
>-        void foo(Bar);
>-        void bar(Bar);
>-    }
>-    void fuzz<T:Foo>(T x) { ... }
>-    void buzz<T:Bar>(T x)
>-    {
>-        fuzz(x); // OK, because Bar is more specific than Foo.    
>-    }
>-
>-Protocols can also mix other protocols in explicitly. Like in the example above, the example below relies on the fact that `Bar` is a more specific protocol than `Foo`. However, this example declares this explicitly (`protocol Bar : Foo`) instead of relying on the language to infer it:
>-
>-    protocol Foo {
>-        void foo(Foo);
>-    }
>-    protocol Bar : Foo {
>-        void bar(Bar);
>-    }
>-    void fuzz<T:Foo>(T x) { ... }
>-    void buzz<T:Bar>(T x)
>-    {
>-        fuzz(x); // OK, because Bar is more specific than Foo.    
>-    }
>-
>-## Overloading
>-
>-WSL supports overloading very similarly to how C++ does it. For example:
>-
>-    void foo(int);    // 1
>-    void foo(double); // 2
>-    
>-    int x;
>-    foo(x); // calls 1
>-    
>-    double y;
>-    foo(y); // calls 2
>-
>-WSL automatically selects the most specific overload if given multiple choices. For example:
>-
>-    void foo(int);    // 1
>-    void foo(double); // 2
>-    void foo<T>(T);   // 3
>-
>-    foo(1); // calls 1
>-    foo(1.); // calls 2
>-    foo(1u); // calls 3
>-
>-Generic functions like `foo<T>` can be called with or without all of their type arguments supplied. If they are not supplied, the function participates in overload resolution like any other function would. Functions are ranked by how specific they are; function A is more specific than function B if A's parameter types can be used as argument types for a call to B but not vice-versa. If one functions more specific than all others then this function is selected, otherwise a type error is issued.
>-
>-## Operator Overloading
>-
>-Many WSL operations desugar to calls to functions. Those functions are called *operator overloads* and are declared using syntax that involves the keyword `operator`. The following operations result in calls to operator overloads:
>-
>-- Numerical operators (`+`, `-`, `*`, `/`, etc.).
>-- Increment and decrement (`++`, `--`).
>-- Casting (`type(value)`).
>-- Accessing values in arrays (`[]`, `[]=`, `&[]`).
>-- Accessing fields (`.field`, `.field=`, `&.field`).
>-
>-WSL's operator overloading is designed to synthesize many operators for you:
>-
>-- Read-modify-write operators like `+=` are desugared to a load of the load value, the underlying operator (like `+`), and a store of the new value. It's not possible to override `+=`, `-=`, etc.
>-- `x++` and `++x` both call the same operator overload. `operator++` takes the old value and returns a new one; for example the built-in `++` for `int` could be written as: `int operator++(int value) { return value + 1; }`.
>-- `operator==` can be overloaded, but `!=` is automatically synthesized and cannot be overloaded.
>-
>-Some operators and overloads are restricted:
>-
>-- `!`, `&&`, and `||` are built-in operations on the `bool` type.
>-- Self-casts (`T(T)`) are always the identity function.
>-- Casts with no arguments (`T()`) always return the default value for that type. Every type has a default value (`0`, `null`, or the equivalent for each field).
>-
>-Cast overloading allows for supporting conversions between types and for creating constructors for custom types. Here is an example of cast overloading being used to create a constructor:
>-
>-    struct Complex<T> {
>-        T real;
>-        T imag;
>-    }
>-    operator<T> Complex<T>(T real, T imag)
>-    {
>-        Complex<T> result;
>-        result.real = real;
>-        result.imag = imag;
>-        return result;
>-    }
>-    
>-    Complex<float> i = Complex<float>(0, 1);
>-
>-WSL supports accessor overloading as part of the operator overloading syntax. This gives the programmer broad powers. For example:
>-
>-    struct Foo {
>-        int x;
>-        int y;
>-    }
>-    int operator.sum(Foo foo)
>-    {
>-        return foo.x + foo.y;
>-    }
>-
>-It's possible to say `foo.sum` to call the `operator.sum` function. Both getters and setters can be provided:
>-
>-    struct Foo {
>-        int value;
>-    }
>-    double operator.doubleValue(Foo value)
>-    {
>-        return double(value.value);
>-    }
>-    Foo operator.doubleValue=(Foo value, double doubleValue)
>-    {
>-        value.value = int(doubleValue);
>-        return value;
>-    }
>-
>-Providing both getter and setter overloads makes `doubleValue` behave almost as if it was a field of `Foo`. For example, it's possible to say:
>-
>-    Foo foo;
>-    foo.value = 42;
>-    foo.doubleValue *= 2; // Now foo.value is 84
>-
>-It's also possible to provide an address-getting overload called an *ander*:
>-
>-    struct Foo {
>-        int value;
>-    }
>-    thread int^ operator&.valueAlias(thread Foo^ foo)
>-    {
>-        return &foo->value;
>-    }
>-
>-Providing just this overload for a pointer type in every address space gives the same power as overloading getters and setters. Additionally, it makes it possible to `&foo.valueAlias`.
>-
>-The same overloading power is provided for array accesses. For example:
>-
>-    struct Vector<T> {
>-        T x;
>-        T y;
>-    }
>-    thread T^ operator&[](thread T^ ptr, uint index)
>-    {
>-        return index ? &ptr->y : &ptr->x;
>-    }
>-
>-Alternatively, it's possible to overload getters and setters (`operator[]` and `operator[]=`).
>-
>-# Mapping of API concepts
>-
>-WSL is designed to be useful as both a graphics shading language and as a computation language. However, these two environments have
>-slightly different semantics.
>-
>-When using WSL as a graphics shading language, there is a distinction between *entry-points* and *non-entry-points*. Entry points are top-level functions which have either the `vertex` or `fragment` keyword in front of their declaration. Entry points may not be forward declared. An entry point annotated with the `vertex` keyword may not be used as a fragment shader, and an entry point annotated with the `fragment` keyword may not be used as a vertex shader. No argument nor return value of an entry point may be a pointer. Entry points must not accept type arguments (also known as "generics").
>-
>-## Vertex entry points
>-
>-WebGPU's API passes data to a WSL vertex shader in four ways:
>-
>-- Attributes
>-- Buffered data
>-- Texture data
>-- Samplers
>-
>-Each of these API objects is referred to by name from the API. Variables in WSL are not annotated with extra API-visible names (like they are in some other graphics APIs).
>-
>-Variables are passed to vertex shaders as arguments to a vertex entry point. Each buffer is represented as an argument with an array reference type (using the `[]` syntax). Textures and samplers are represented by arguments with the `texture` and `sampler` types, respectively. All other non-builtin arguments to a vertex entry point are implied to be attributes.
>-
>-Some arguments are recognized by the compiler from their name and type. These arguments provide built-in functionality inherent in the graphics pipeline. For example, an argument of the form `int wsl_vertexID` refers to the ID of the current vertex, and is not recognized as an attribute. All non-builtin arguments to a vertex entry point must be associated with an API object whenever any draw call using the vertex entry point is invoked. Otherwise, the draw call will fail.
>-
>-The only way to pass data between successive shader stages within a single draw call is by return value. An entry point must indicate that it returns a collection of values contained within a structure. Every variable inside this structure, recursively, is passed to the next stage in the graphics pipeline. Members of this struct may also be output built-in variables. For example, a vertex entry point may return a struct which contains a member `float4 wsl_Position`, and this variable will represent the rasterized position of the vertex. Buffers (as described by WSL array references), textures, and samplers must not be present in this returned struct. Built-in variables must never appear twice inside the returned structure.
>-
>-## Fragment entry points
>-
>-Fragment entry points may accept one argument with the type that the previous shader stage returned. The argument name for this argument must be `stageIn`. In addition to this argument, fragment entry points may accept buffers, textures, and samplers as arguments in the same way that vertex entry points accept them. Fragment entry points also must return a struct, and all members of this struct must be built-in variables. The set of recognized built-in variables which may be accepted or returned from an entry point is different between all types of entry points.
>-
>-For example, this would be a valid graphics program:
>-
>-    struct VertexInput {
>-        float2 position;
>-        float3 color;
>-    }
>-    
>-    struct VertexOutput {
>-        float4 wsl_Position;
>-        float3 color;
>-    }
>-    
>-    struct FragmentOutput {
>-        float4 wsl_Color;
>-    }
>-    
>-    vertex VertexOutput vertexShader(VertexInput vertexInput) {
>-        VertexOutput result;
>-        result.wsl_Position = float4(vertexInput.position, 0., 1.);
>-        result.color = vertexInput.color;
>-        return result;
>-    }
>-    
>-    fragment FragmentOutput fragmentShader(VertexOutput stageIn) {
>-        FragmentOutput result;
>-        result.wsl_Color = float4(stageIn.color, 1.);
>-        return result;
>-    }
>-
>-## Compute entry points
>-
>-WebGPU's API passes data to a compute shader in three ways:
>-
>-- Buffered data
>-- Texture data
>-- Samplers
>-
>-Compute entry points start with the keyword `compute`. The return type for a compute entry point must be `void`. Each buffer is represented as an argument with an array reference type (using the `[]` syntax). Textures and samplers are represented by arguments with the `texture` and `sampler` types, respectively. Compute entry points may also accept built-in variables as arguments. Arguments of any other type are disallowed. Arguments may not use the `threadgroup` memory space.
>-
>-# Error handling
>-
>-Errors may occur during shader processing. For example, the shader may attempt to dereference a `null` array reference. If this occurs, the shader stage immediately completes successfully. The entry point immediately returns a struct with all fields set to 0. After this event, subsequent shader stages will proceed as if there was no problem.
>-
>-Buffer and texture reads and writes before the error all complete, and have the same semantics as if no error had occurred. Buffer and texture reads and writes after the error do not occur.
>-
>-# Summary
>-
>-WSL is a type-safe language based on C syntax. It eliminates some C features, like unions and pointer casts, but adds other modern features in their place, like generics and overloading.
>-
>-# Additional Limitations
>-
>-The following additional limitations may be placed on a WSL program:
>-
>-- `device`, `constant`, and `threadgroup` pointers cannot point to data that may have pointers in it. This safety check is not done as part of the normal type system checks. It's performed only after instantiation.
>-- Pointers and array references (collectively, *references*) may be restricted to support compiling to SPIR-V *logical mode*. In this mode, arrays must not transitively hold references. References must be initialized upon declaration and never reassigned. Functions that return references must have one return point. Ternary expressions may not return references.
>-- Graphics entry points must transitively never refer to the `threadgroup` memory space.
>-
>-
>diff --git a/Tools/WebGPUShadingLanguageRI/WrapChecker.js b/Tools/WebGPUShadingLanguageRI/WrapChecker.js
>index 4cadc7d0d9e6a6dfda555dab89d0271770dbd9a7..0eb4e81ec2fc3639970d9c63a3fbcce996cb410a 100644
>--- a/Tools/WebGPUShadingLanguageRI/WrapChecker.js
>+++ b/Tools/WebGPUShadingLanguageRI/WrapChecker.js
>@@ -52,11 +52,6 @@ class WrapChecker extends Visitor {
>         throw new Error("Found unwrapped " + node.constructor.name + " at " + originString(node) + ": " + node + "\nWhile visiting " + this._startNode.constructor.name + " at " + originString(this._startNode.origin) + ": " + this._startNode);
>     }
>     
>-    visitConstexprTypeParameter(node)
>-    {
>-        this._foundUnwrapped(node);
>-    }
>-    
>     visitFuncParameter(node)
>     {
>         this._foundUnwrapped(node);
>@@ -76,14 +71,4 @@ class WrapChecker extends Visitor {
>     {
>         this._foundUnwrapped(node);
>     }
>-    
>-    visitTypeVariable(node)
>-    {
>-        this._foundUnwrapped(node);
>-    }
>-    
>-    // NOTE: This does not know how to handle NativeTypeInstance, because this is never called on instantiated
>-    // code. Once code is instantiated, you cannot instantiate it further.
>-    
>-    // NOTE: This needs to be kept in sync with AutoWrapper.
> }
>diff --git a/Tools/WebGPUShadingLanguageRI/index.html b/Tools/WebGPUShadingLanguageRI/index.html
>index 8094b193781b4aa9b0c3909e9a91d2815f2b2aba..a627e468680c7044579b751b868cf346f24722eb 100644
>--- a/Tools/WebGPUShadingLanguageRI/index.html
>+++ b/Tools/WebGPUShadingLanguageRI/index.html
>@@ -12,6 +12,7 @@
> <script src="CreateLiteralType.js"></script>
> <script src="PropertyAccessExpression.js"></script>
> <script src="SwizzleOp.js"></script>
>+<script src="NativeType.js"></script>
> 
> <script src="AddressSpace.js"></script>
> <script src="AnonymousVariable.js"></script>
>@@ -22,7 +23,14 @@
> <script src="Block.js"></script>
> <script src="BoolLiteral.js"></script>
> <script src="Break.js"></script>
>+<script src="BuiltinVectorCasts.js"></script>
>+<script src="BuiltinVectorGetter.js"></script>
>+<script src="BuiltinVectorSetter.js"></script>
>+<script src="BuiltinVectorIndexGetter.js"></script>
>+<script src="BuiltinVectorIndexSetter.js"></script>
>+<script src="BuiltinVectorEqualityOperator.js"></script>
> <script src="CallExpression.js"></script>
>+<script src="CallExpressionTypeArgumentResolver.js"></script>
> <script src="CallFunction.js"></script>
> <script src="Check.js"></script>
> <script src="CheckLiteralTypes.js"></script>
>@@ -36,7 +44,6 @@
> <script src="CloneProgram.js"></script>
> <script src="CommaExpression.js"></script>
> <script src="ConstexprFolder.js"></script>
>-<script src="ConstexprTypeParameter.js"></script>
> <script src="Continue.js"></script>
> <script src="ConvertPtrToArrayRefExpression.js"></script>
> <script src="DoWhileLoop.js"></script>
>@@ -55,7 +62,6 @@
> <script src="ExternalOrigin.js"></script>
> <script src="Field.js"></script>
> <script src="FindHighZombies.js"></script>
>-<script src="FlattenProtocolExtends.js"></script>
> <script src="FlattenedStructOffsetGatherer.js"></script>
> <script src="FloatLiteral.js"></script>
> <script src="FloatLiteralType.js"></script>
>@@ -63,7 +69,6 @@
> <script src="ForLoop.js"></script>
> <script src="Func.js"></script>
> <script src="FuncDef.js"></script>
>-<script src="FuncInstantiator.js"></script>
> <script src="FuncParameter.js"></script>
> <script src="FunctionLikeBlock.js"></script>
> <script src="HighZombieFinder.js"></script>
>@@ -73,7 +78,6 @@
> <script src="InferTypesForCall.js"></script>
> <script src="Inline.js"></script>
> <script src="Inliner.js"></script>
>-<script src="InstantiateImmediates.js"></script>
> <script src="IntLiteral.js"></script>
> <script src="IntLiteralType.js"></script>
> <script src="Intrinsics.js"></script>
>@@ -91,11 +95,14 @@
> <script src="NameResolver.js"></script>
> <script src="NativeFunc.js"></script>
> <script src="NativeFuncInstance.js"></script>
>+<script src="NativeParameterizedType.js"></script>
> <script src="NativeType.js"></script>
>-<script src="NativeTypeInstance.js"></script>
> <script src="NormalUsePropertyResolver.js"></script>
> <script src="NullLiteral.js"></script>
> <script src="NullType.js"></script>
>+<script src="OperatorAnderIndex.js"></script>
>+<script src="OperatorArrayRefLength.js"></script>
>+<script src="OperatorBool.js"></script>
> <script src="OriginKind.js"></script>
> <script src="OverloadResolutionFailure.js"></script>
> <script src="Parse.js"></script>
>@@ -103,14 +110,11 @@
> <script src="PropertyResolver.js"></script>
> <script src="Program.js"></script>
> <script src="ProgramWithUnnecessaryThingsRemoved.js"></script>
>-<script src="Protocol.js"></script>
>-<script src="ProtocolDecl.js"></script>
>-<script src="ProtocolFuncDecl.js"></script>
>-<script src="ProtocolRef.js"></script>
> <script src="PtrType.js"></script>
> <script src="ReadModifyWriteExpression.js"></script>
> <script src="RecursionChecker.js"></script>
> <script src="RecursiveTypeChecker.js"></script>
>+<script src="ResolveCallExpressionsWithTypeArguments.js"></script>
> <script src="ResolveNames.js"></script>
> <script src="ResolveOverloadImpl.js"></script>
> <script src="ResolveProperties.js"></script>
>@@ -122,19 +126,23 @@
> <script src="StatementCloner.js"></script>
> <script src="StructLayoutBuilder.js"></script>
> <script src="StructType.js"></script>
>-<script src="Substitution.js"></script>
> <script src="SwitchCase.js"></script>
> <script src="SwitchStatement.js"></script>
>+<script src="SynthesizeArrayOperatorLength.js"></script>
> <script src="SynthesizeEnumFunctions.js"></script>
> <script src="SynthesizeStructAccessors.js"></script>
>+<script src="SynthesizeOperatorBool.js"></script>
>+<script src="SynthesizeCopyConstructorOperator.js"></script>
>+<script src="SynthesizeDefaultConstructorOperator.js"></script>
>+<script src="TrapStatement.js"></script>
>+<script src="TypeDef.js"></script>
>+<script src="TypeDefResolver.js"></script>
>+<script src="TernaryExpression.js"></script>
> <script src="TrapStatement.js"></script>
> <script src="TypeDef.js"></script>
> <script src="TypeDefResolver.js"></script>
> <script src="TypeOrVariableRef.js"></script>
>-<script src="TypeParameterRewriter.js"></script>
> <script src="TypeRef.js"></script>
>-<script src="TypeVariable.js"></script>
>-<script src="TypeVariableTracker.js"></script>
> <script src="TypedValue.js"></script>
> <script src="UintLiteral.js"></script>
> <script src="UintLiteralType.js"></script>
>@@ -142,6 +150,7 @@
> <script src="UnreachableCodeChecker.js"></script>
> <script src="VariableDecl.js"></script>
> <script src="VariableRef.js"></script>
>+<script src="VectorType.js"></script>
> <script src="VisitingSet.js"></script>
> <script src="WSyntaxError.js"></script>
> <script src="WTrapError.js"></script>
>@@ -344,7 +353,7 @@ function selectedShadersChanged(fromCompilation = false) {
>     currentVertexShader = availableVertexShaders[vertexShaderSelect.selectedIndex];
>     currentFragmentShader = availableFragmentShaders[fragmentShaderSelect.selectedIndex];
> 
>-    inlinedVertexShader = program.funcInstantiator.getUnique(currentVertexShader, []);
>+    inlinedVertexShader = program.funcInstantiator.getUnique(currentVertexShader);
>     _inlineFunction(program, inlinedVertexShader, new VisitingSet(currentVertexShader));
> 
>     allArgumentInfos = [];
>@@ -426,7 +435,7 @@ function runShaders() {
>         func.parameters[i].ePtr.copyFrom(argumentEPtrs[i].ePtr, argumentEPtrs[i].size);
>     let result = new Evaluator(program).runFunc(func);
> 
>-    inlinedFragmentShader = program.funcInstantiator.getUnique(currentFragmentShader, []);
>+    inlinedFragmentShader = program.funcInstantiator.getUnique(currentFragmentShader);
>     _inlineFunction(program, inlinedFragmentShader, new VisitingSet(currentFragmentShader));
>     func = inlinedFragmentShader;
>

Actions: View | Formatted Diff | Diff

Attachments on bug 188542: 347063