From baf2020a901d8d31cf22bd5581c02a7c6d066160 Mon Sep 17 00:00:00 2001 From: Xiaochun Tong Date: Fri, 22 Nov 2024 14:47:41 -0500 Subject: [PATCH] progress --- .gitignore | 3 +- Cargo.lock | 208 +- Cargo.toml | 10 +- README.md | 6 +- luisa_lang/_builtin_decor.py | 92 +- luisa_lang/codegen/cpp.py | 140 +- luisa_lang/codegen/cpp_lib.py | 2 +- luisa_lang/codegen/rust_api.py | 69 + luisa_lang/generics.py | 5 - luisa_lang/hir.py | 33 +- luisa_lang/math_types.py | 4344 +++++++++++++++++++++----------- luisa_lang/parse.py | 124 +- scripts/cpp_lib.hpp | 4049 ++++++++++++++++++++++++++++- scripts/gen_cpp_lib.py | 1034 +++++++- scripts/gen_math_types.py | 22 +- src/compiler.rs | 3 - src/hir.rs | 12 - src/lib.rs | 3 +- src/types.rs | 182 ++ 19 files changed, 8332 insertions(+), 2009 deletions(-) create mode 100644 luisa_lang/codegen/rust_api.py delete mode 100644 luisa_lang/generics.py delete mode 100644 src/compiler.rs delete mode 100644 src/hir.rs create mode 100644 src/types.rs diff --git a/.gitignore b/.gitignore index 065facb..7a9d1fe 100644 --- a/.gitignore +++ b/.gitignore @@ -164,4 +164,5 @@ cython_debug/ # Added by cargo /target -Cargo.lock \ No newline at end of file +Cargo.lock +scripts/cpp_lib.hpp \ No newline at end of file diff --git a/Cargo.lock b/Cargo.lock index 52417ed..8dffcd7 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -3,214 +3,14 @@ version = 3 [[package]] -name = "autocfg" -version = "1.3.0" +name = "glam" +version = "0.29.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "0c4b4d0bd25bd0b74681c0ad21497610ce1b7c91b1022cd21c80c6fbdd9476b0" - -[[package]] -name = "cfg-if" -version = "1.0.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd" - -[[package]] -name = "heck" -version = "0.5.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "2304e00983f87ffb38b55b444b5e3b60a884b5d30c0fca7d82fe33449bbe55ea" - -[[package]] -name = "indoc" -version = "2.0.5" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b248f5224d1d606005e02c97f5aa4e88eeb230488bcc03bc9ca4d7991399f2b5" - -[[package]] -name = "itoa" -version = "1.0.11" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "49f1f14873335454500d59611f1cf4a4b0f786f9ac11f4312a78e4cf2566695b" - -[[package]] -name = "libc" -version = "0.2.155" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "97b3888a4aecf77e811145cadf6eef5901f4782c53886191b2f693f24761847c" +checksum = "dc46dd3ec48fdd8e693a98d2b8bafae273a2d54c1de02a2a7e3d57d501f39677" [[package]] name = "luisa-python-lang" version = "0.1.0" dependencies = [ - "pyo3", - "serde", - "serde_json", -] - -[[package]] -name = "memoffset" -version = "0.9.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "488016bfae457b036d996092f6cb448677611ce4449e970ceaf42695203f218a" -dependencies = [ - "autocfg", + "glam", ] - -[[package]] -name = "once_cell" -version = "1.19.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "3fdb12b2476b595f9358c5161aa467c2438859caa136dec86c26fdd2efe17b92" - -[[package]] -name = "portable-atomic" -version = "1.6.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "7170ef9988bc169ba16dd36a7fa041e5c4cbeb6a35b76d4c03daded371eae7c0" - -[[package]] -name = "proc-macro2" -version = "1.0.86" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "5e719e8df665df0d1c8fbfd238015744736151d4445ec0836b8e628aae103b77" -dependencies = [ - "unicode-ident", -] - -[[package]] -name = "pyo3" -version = "0.22.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "1962a33ed2a201c637fc14a4e0fd4e06e6edfdeee6a5fede0dab55507ad74cf7" -dependencies = [ - "cfg-if", - "indoc", - "libc", - "memoffset", - "once_cell", - "portable-atomic", - "pyo3-build-config", - "pyo3-ffi", - "pyo3-macros", - "unindent", -] - -[[package]] -name = "pyo3-build-config" -version = "0.22.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ab7164b2202753bd33afc7f90a10355a719aa973d1f94502c50d06f3488bc420" -dependencies = [ - "once_cell", - "target-lexicon", -] - -[[package]] -name = "pyo3-ffi" -version = "0.22.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "c6424906ca49013c0829c5c1ed405e20e2da2dc78b82d198564880a704e6a7b7" -dependencies = [ - "libc", - "pyo3-build-config", -] - -[[package]] -name = "pyo3-macros" -version = "0.22.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "82b2f19e153122d64afd8ce7aaa72f06a00f52e34e1d1e74b6d71baea396460a" -dependencies = [ - "proc-macro2", - "pyo3-macros-backend", - "quote", - "syn", -] - -[[package]] -name = "pyo3-macros-backend" -version = "0.22.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "dd698c04cac17cf0fe63d47790ab311b8b25542f5cb976b65c374035c50f1eef" -dependencies = [ - "heck", - "proc-macro2", - "pyo3-build-config", - "quote", - "syn", -] - -[[package]] -name = "quote" -version = "1.0.36" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "0fa76aaf39101c457836aec0ce2316dbdc3ab723cdda1c6bd4e6ad4208acaca7" -dependencies = [ - "proc-macro2", -] - -[[package]] -name = "ryu" -version = "1.0.18" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f3cb5ba0dc43242ce17de99c180e96db90b235b8a9fdc9543c96d2209116bd9f" - -[[package]] -name = "serde" -version = "1.0.203" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "7253ab4de971e72fb7be983802300c30b5a7f0c2e56fab8abfc6a214307c0094" -dependencies = [ - "serde_derive", -] - -[[package]] -name = "serde_derive" -version = "1.0.203" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "500cbc0ebeb6f46627f50f3f5811ccf6bf00643be300b4c3eabc0ef55dc5b5ba" -dependencies = [ - "proc-macro2", - "quote", - "syn", -] - -[[package]] -name = "serde_json" -version = "1.0.118" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "d947f6b3163d8857ea16c4fa0dd4840d52f3041039a85decd46867eb1abef2e4" -dependencies = [ - "itoa", - "ryu", - "serde", -] - -[[package]] -name = "syn" -version = "2.0.68" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "901fa70d88b9d6c98022e23b4136f9f3e54e4662c3bc1bd1d84a42a9a0f0c1e9" -dependencies = [ - "proc-macro2", - "quote", - "unicode-ident", -] - -[[package]] -name = "target-lexicon" -version = "0.12.14" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "e1fc403891a21bcfb7c37834ba66a547a8f402146eba7265b5a6d88059c9ff2f" - -[[package]] -name = "unicode-ident" -version = "1.0.12" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "3354b9ac3fae1ff6755cb6db53683adb661634f67557942dea4facebec0fee4b" - -[[package]] -name = "unindent" -version = "0.2.3" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "c7de7d73e1754487cb58364ee906a499937a0dfabd86bcb980fa99ec8c8fa2ce" diff --git a/Cargo.toml b/Cargo.toml index 117a6ff..550cb57 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -4,9 +4,11 @@ version = "0.1.0" edition = "2021" [dependencies] -pyo3 = { version = "0.22", optional = true } -serde = { version = "1.0", features = ["derive"] } -serde_json = "1.0" +glam = { version = "0.29.2", optional = true } + + +[build-dependencies] [features] -jit = ["pyo3"] +default = ["glam"] +glam = ["dep:glam"] diff --git a/README.md b/README.md index 5d1e99a..a273f2e 100644 --- a/README.md +++ b/README.md @@ -25,7 +25,7 @@ import luisa_lang as lc ## Basic Syntax ### Difference from Python There are some notable differences between luisa_lang and Python: -- Variables have value semantics by default. Use `inout` to indicate that an argument that is passed by reference. +- Variables have value semantics by default. Use `byref` to indicate that an argument that is passed by reference. - Generic functions and structs are implemented via monomorphization (a.k.a instantiation) at compile time rather than via type erasure. - Overloading subscript operator and attribute access is different from Python. Only `__getitem__` and `__getattr__` are needed, which returns a local reference. @@ -55,9 +55,9 @@ a.x = 2.0 lc.print(f'{a.x} {b.x}') # prints 2.0 1.0 ``` -You can use `inout` to indicate that a variable is passed as a *local reference*. Assigning to an `inout` variable will update the original variable. +You can use `byref` to indicate that a variable is passed as a *local reference*. Assigning to an `byref` variable will update the original variable. ```python -@luisa.func(a=inout, b=inout) +@luisa.func(a=byref, b=byref) def swap(a: int, b: int): a, b = b, a diff --git a/luisa_lang/_builtin_decor.py b/luisa_lang/_builtin_decor.py index 4fe3c37..e7291e8 100644 --- a/luisa_lang/_builtin_decor.py +++ b/luisa_lang/_builtin_decor.py @@ -3,7 +3,7 @@ import typing from luisa_lang import hir import inspect -from luisa_lang.utils import get_full_name, get_union_args, unique_hash +from luisa_lang.utils import get_full_name, get_union_args, unique_hash, unwrap from luisa_lang.classinfo import MethodType, VarType, GenericInstance, UnionType, _get_cls_globalns, register_class, class_typeinfo from enum import auto, Enum from luisa_lang import classinfo, parse @@ -36,8 +36,9 @@ def intrinsic(name: str, ret_type: type[T], *args, **kwargs) -> T: "Did you mistakenly called a DSL function?" ) + def byval(value: T) -> T: - """pass a value by value""" + """pass a value by value, this is only a marker and should not be called""" raise NotImplementedError( "byval should not be called in host-side Python code. " @@ -46,7 +47,7 @@ def byval(value: T) -> T: def byref(value: T) -> T: - """pass a value by ref""" + """pass a value by ref, this is only a marker and should not be called""" raise NotImplementedError( "byref should not be called in host-side Python code. " @@ -54,6 +55,12 @@ def byref(value: T) -> T: ) +def _is_method(f): + if inspect.ismethod(f): + return True + return inspect.isfunction(f) and hasattr(f, '__qualname__') and '.' in f.__qualname__ + + class _ObjKind(Enum): BUILTIN_TYPE = auto() STRUCT = auto() @@ -61,14 +68,15 @@ class _ObjKind(Enum): KERNEL = auto() -def _make_func_template(f: Callable[..., Any], func_name: str, func_globals: Dict[str, Any], foreign_type_var_ns: Dict[TypeVar, hir.Type | hir.ComptimeValue], self_type: Optional[hir.Type] = None): +def _make_func_template(f: Callable[..., Any], func_name: str, func_sig: Optional[MethodType], func_globals: Dict[str, Any], foreign_type_var_ns: Dict[TypeVar, hir.Type | hir.ComptimeValue], props: hir.FuncProperties, self_type: Optional[hir.Type] = None): # parsing_ctx = _parse.ParsingContext(func_name, func_globals) # func_sig_parser = _parse.FuncParser(func_name, f, parsing_ctx, self_type) # func_sig = func_sig_parser.parsed_func # params = [v.name for v in func_sig_parser.params] # is_generic = func_sig_parser.p_ctx.type_vars != {} + if func_sig is None: + func_sig = classinfo.parse_func_signature(f, func_globals, []) - func_sig = classinfo.parse_func_signature(f, func_globals, []) func_sig_converted, sig_parser = parse.convert_func_signature( func_sig, func_name, func_globals, foreign_type_var_ns, {}, self_type) implicit_type_params = sig_parser.implicit_type_params @@ -82,6 +90,10 @@ def parsing_func(args: hir.FunctionTemplateResolvingArgs) -> hir.FunctionLike: hir.ComptimeValue] = foreign_type_var_ns.copy() mapped_implicit_type_params: Dict[str, hir.Type] = dict() + assert func_sig is not None + type_parser = parse.TypeParser(func_name, func_globals, type_var_ns, self_type, 'instantiate') + for (tv, t) in func_sig.env.items(): + type_var_ns[tv] = unwrap(type_parser.parse_type(t)) if is_generic: mapping = hir.match_func_template_args(func_sig_converted, args) if isinstance(mapping, hir.TypeInferenceError): @@ -103,13 +115,20 @@ def parsing_func(args: hir.FunctionTemplateResolvingArgs) -> hir.FunctionLike: mapped_type = mapping[gp] assert isinstance(mapped_type, hir.Type) mapped_implicit_type_params[name] = mapped_type + func_sig_instantiated, _p = parse.convert_func_signature( func_sig, func_name, func_globals, type_var_ns, mapped_implicit_type_params, self_type, mode='instantiate') + # print(func_name, func_sig) assert len( func_sig_instantiated.generic_params) == 0, f"generic params should be resolved but found {func_sig_instantiated.generic_params}" + assert not isinstance( + func_sig_instantiated.return_type, hir.SymbolicType) func_parser = parse.FuncParser( func_name, f, func_sig_instantiated, func_globals, type_var_ns, self_type) - return func_parser.parse_body() + ret = func_parser.parse_body() + ret.inline_hint = props.inline + ret.export = props.export + return ret params = [v[0] for v in func_sig.args] is_generic = len(func_sig_converted.generic_params) > 0 # print( @@ -124,13 +143,17 @@ def _dsl_func_impl(f: _TT, kind: _ObjKind, attrs: Dict[str, Any]) -> _TT: import sourceinspect assert inspect.isfunction(f), f"{f} is not a function" # print(hir.GlobalContext.get) - ctx = hir.GlobalContext.get() func_name = get_full_name(f) func_globals: Any = getattr(f, "__globals__", {}) - + props = _parse_func_kwargs(attrs) + is_method = _is_method(f) + setattr(f, '__luisa_func_props__', props) + if is_method: + return typing.cast(_TT, f) if kind == _ObjKind.FUNC: - template = _make_func_template(f, func_name, func_globals, {}) + template = _make_func_template( + f, func_name, None, func_globals, {}, props) ctx.functions[f] = template setattr(f, "__luisa_func__", template) return typing.cast(_TT, f) @@ -167,11 +190,16 @@ def parse_fields(tp: parse.TypeParser, self_ty: hir.Type): else: raise NotImplementedError() - def parse_methods(type_var_ns: Dict[TypeVar, hir.Type | Any], self_ty: hir.Type): + def parse_methods(type_var_ns: Dict[TypeVar, hir.Type | Any], self_ty: hir.Type,): for name in cls_info.methods: method_object = getattr(cls, name) + props: hir.FuncProperties + if hasattr(method_object, '__luisa_func_props__'): + props = getattr(method_object, '__luisa_func_props__') + else: + props = hir.FuncProperties() template = _make_func_template( - method_object, get_full_name(method_object), globalns, type_var_ns, self_type=self_ty) + method_object, get_full_name(method_object), cls_info.methods[name], globalns, type_var_ns, props, self_type=self_ty) if isinstance(self_ty, hir.BoundType): assert isinstance(self_ty.instantiated, hir.StructType) self_ty.instantiated.methods[name] = template @@ -279,29 +307,26 @@ def __init__(self, value: str): self.value = value -class FuncProperties: - inline: bool | Literal["always"] - export: bool - byref: Set[str] - - def __ini__(self, **kwargs): - self.byref = set() - inline = kwargs.get("inline", False) - if isinstance(inline, bool): - self.inline = inline - elif inline == "always": - self.inline = "always" - else: - raise ValueError(f"invalid value for inline: {inline}") +def _parse_func_kwargs(kwargs: Dict[str, Any]) -> hir.FuncProperties: + props = hir.FuncProperties() + props.byref = set() + inline = kwargs.get("inline", False) + if isinstance(inline, bool): + props.inline = inline + elif inline == "always": + props.inline = "always" + else: + raise ValueError(f"invalid value for inline: {inline}") - self.export = kwargs.get("export", False) - if not isinstance(self.export, bool): - raise ValueError(f"export should be a bool") + props.export = kwargs.get("export", False) + if not isinstance(props.export, bool): + raise ValueError(f"export should be a bool") - for k, v in kwargs.items(): - if k not in ["inline", "export"]: - if v is byref: - self.byref.add(k) + for k, v in kwargs.items(): + if k not in ["inline", "export"]: + if v is byref: + props.byref.add(k) + return props @overload @@ -316,6 +341,9 @@ def func(*args, **kwargs) -> _F | Callable[[_F], _F]: """ Mark a function as a DSL function. To mark an argument as byref, use the `var=byref` syntax in decorator arguments. + Acceptable kwargs: + - inline: bool | "always" # hint for inlining + - export: bool # hint for exporting (for bundled C++ codegen) Example: ```python diff --git a/luisa_lang/codegen/cpp.py b/luisa_lang/codegen/cpp.py index 0bba418..b8cf7fa 100644 --- a/luisa_lang/codegen/cpp.py +++ b/luisa_lang/codegen/cpp.py @@ -7,6 +7,14 @@ from luisa_lang.hir import get_dsl_func +@cache +def _get_cpp_lib() -> str: + from luisa_lang.codegen.cpp_lib import CPP_LIB_COMPRESSED + import bz2 + import base64 + return bz2.decompress(base64.b64decode(CPP_LIB_COMPRESSED)).decode('utf-8') + + class TypeCodeGenCache: cache: Dict[hir.Type, str] impl: ScratchBuffer @@ -31,11 +39,19 @@ def gen_impl(self, ty: hir.Type) -> str: else: return f"u{bits}" case hir.FloatType(bits=bits): - return f"f{bits}" + match bits: + case 16: + return 'lc_half' + case 32: + return 'lc_float' + case 64: + return 'lc_double' + case _: + raise RuntimeError("invalid float type") case hir.BoolType(): - return "bool" + return "lc_bool" case hir.VectorType(element=element, count=count): - return f"vec<{self.gen(element)}, {count}>" + return f"{self.gen(element)}{count}>" case hir.StructType(name=name, fields=fields): self.impl.writeln(f'struct {name} {{') for field in fields: @@ -187,7 +203,7 @@ def gen_function(self, func: hir.Function | Callable[..., Any]) -> str: return name def finalize_code(self) -> str: - return self.type_cache.impl.body + self.generated_code.body + return _get_cpp_lib() + self.type_cache.impl.body + self.generated_code.body class FuncCodeGen: @@ -215,7 +231,16 @@ def __init__(self, base: CppCodeGen, func: hir.Function) -> None: params = ",".join(self.gen_var( p) for p in func.params if not isinstance(p.type, hir.FunctionType)) assert func.return_type - self.signature = f'extern "C" auto {self.name}({params}) -> {base.type_cache.gen(func.return_type)}' + + self.signature = f'auto {self.name}({params}) -> {base.type_cache.gen(func.return_type)}' + if func.export: + self.signature = f'extern "C" {self.signature}' + if func.inline_hint == True: + self.signature = f"inline {self.signature}" + elif func.inline_hint == 'always': + self.signature = f"__lc_always_inline__ {self.signature}" + elif func.inline_hint == 'never': + self.signature = f"__lc_never_inline {self.signature}" self.body = ScratchBuffer() self.params = set(p.name for p in func.params) self.node_map = {} @@ -286,8 +311,11 @@ def impl() -> None: op = self.gen_func(call.op) args_s = ','.join(self.gen_value_or_ref( arg) for arg in call.args if not isinstance(arg.type, hir.FunctionType)) - self.body.writeln( - f"auto v{vid} ={op}({args_s});") + if call.type != hir.UnitType(): + self.body.writeln( + f"auto v{vid} = {op}({args_s});") + else: + self.body.writeln(f"{op}({args_s});") case hir.Constant() as constant: value = constant.value if isinstance(value, int): @@ -312,12 +340,98 @@ def impl() -> None: f"{ty} v{vid}{{ {','.join(self.gen_expr(e) for e in expr.args)} }};") case hir.TypeValue(): pass - case hir.Intrinsic(): - intrin_name = expr.name.replace('.', '_') - args_s = ','.join(self.gen_value_or_ref( - arg) for arg in expr.args) - self.body.writeln( - f"auto v{vid} = __intrin__{intrin_name}({args_s});") + case hir.Intrinsic() as intrin: + def do(): + intrin_name = intrin.name + comps = intrin_name.split('.') + gened_args = [self.gen_value_or_ref( + arg) for arg in intrin.args] + if comps[0] == 'cmp': + cmp_dict = { + '__eq__': '==', + '__ne__': '!=', + '__lt__': '<', + '__le__': '<=', + '__gt__': '>', + '__ge__': '>=', + } + if comps[1] in cmp_dict: + cmp = cmp_dict[comps[1]] + self.body.writeln( + f"auto v{vid} = {gened_args[0]} {cmp} {gened_args[1]};") + else: + raise NotImplementedError( + f"unsupported cmp intrinsic: {intrin_name}") + elif comps[0] == 'unary': + unary_dict = { + '__neg__': '-', + '__pos__': '+', + '__invert__': '~', + } + if comps[1] in unary_dict: + unary = unary_dict[comps[1]] + self.body.writeln( + f"auto v{vid} = {unary}{gened_args[0]};") + else: + raise NotImplementedError( + f"unsupported unary intrinsic: {intrin_name}") + elif comps[0] == 'binop': + binop_dict = { + '__add__': '+', + '__sub__': '-', + '__mul__': '*', + '__truediv__': '/', + '__floordiv__': '/', # TODO: fix floordiv + '__mod__': '%', + '__pow__': '**', + '__and__': '&', + '__or__': '|', + '__xor__': '^', + '__lshift__': '<<', + '__rshift__': '>>', + '__eq__': '==', + '__ne__': '!=', + '__lt__': '<', + '__le__': '<=', + '__gt__': '>', + '__ge__': '>=', + } + ibinop_dict = { + '__iadd__': '+=', + '__isub__': '-=', + '__imul__': '*=', + '__itruediv__': '/=', + '__ifloordiv__': '/=', # TODO: fix floordiv + '__imod__': '%=', + '__ipow__': '**=', + '__iand__': '&=', + '__ior__': '|=', + '__ixor__': '^=', + '__ilshift__': '<<=', + '__irshift__': '>>=', + } + if comps[1] in binop_dict: + binop = binop_dict[comps[1]] + self.body.writeln( + f"auto v{vid} = {gened_args[0]} {binop} {gened_args[1]};") + elif comps[1] in ibinop_dict: + binop = ibinop_dict[comps[1]] + self.body.writeln( + f"{gened_args[0]} {binop} {gened_args[1]}; auto& v{vid} = {gened_args[0]};") + else: + raise NotImplementedError( + f"unsupported binop intrinsic: {intrin_name}") + elif comps[0] == 'math': + args_s = ','.join(gened_args) + self.body.writeln( + f"auto v{vid} = lc_{comps[1]}({args_s});") + else: + intrin_name = intrin.name.replace('.', '_') + args_s = ','.join(gened_args) + self.body.writeln( + f"auto v{vid} = __intrin__{intrin_name}({args_s});") + + do() case _: raise NotImplementedError( f"unsupported expression: {expr}") diff --git a/luisa_lang/codegen/cpp_lib.py b/luisa_lang/codegen/cpp_lib.py index 8717742..41dfb4e 100644 --- a/luisa_lang/codegen/cpp_lib.py +++ b/luisa_lang/codegen/cpp_lib.py @@ -1 +1 @@ -CPP_LIB_COMPRESSED = '''QlpoOTFBWSZTWX4ZiUsAAGvfgEQSSX79TxplxS6/598qMAF5QAaqbUzRGT0EaYjI0PQJghkG0mg5gAAAAAAAAAASJEhkyARNpqe0oNDTTyj002pPKemkmCmkl2Hz6xh92PxRRFW93kNhepBBIFznr48Hbut1j2TlKV6z5ajo3MyWLRi9Jm2XIZewKmV+4Q4giRrdmTC5NRho0pkAYHpIqRg+AVobwGdzQznOeRVHHNKKr+EJEsZ+V6ELYvIhHhszWztY2R5yJ/plepNCoDeXHA80cUSJF4gaLoRrLkXFwSOF97VEA5HrmT2MmjYVmWFvPUpK0aBHcG7kWLcHPIva0JCMpn8IKKAgKuY4rjo6eoQFao8sDVi7MK+JXLpUJQGc6lC2vUjFZQHIYijQq9DbbcjIxHW+oC3LmTm8h4gxGkKgYQJYD4JZwgxNU9q7zPSvdrvZkMBA8aZpxqZVM0hMQwh9rWOFBSxsHnhuEcWp4V9MN/uCoK1SIjXiibCTJ/8XckU4UJB+GYlL''' \ No newline at end of file +CPP_LIB_COMPRESSED = """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""" \ No newline at end of file diff --git a/luisa_lang/codegen/rust_api.py b/luisa_lang/codegen/rust_api.py new file mode 100644 index 0000000..c030882 --- /dev/null +++ b/luisa_lang/codegen/rust_api.py @@ -0,0 +1,69 @@ +from typing import List, NamedTuple, Tuple, Dict, Any, Optional, Union +from luisa_lang.codegen import ScratchBuffer +from luisa_lang.codegen.cpp import mangle_name, Mangling +from luisa_lang import hir +from luisa_lang.utils import unique_hash +class TypeCodeGenCache: + cache: Dict[hir.Type, str] + impl: ScratchBuffer + + def __init__(self) -> None: + self.cache = {} + self.impl = ScratchBuffer(0) + + def gen(self, ty: hir.Type) -> str: + if ty in self.cache: + return self.cache[ty] + else: + res = self.gen_impl(ty) + self.cache[ty] = res + return res + + def gen_impl(self, ty: hir.Type) -> str: + match ty: + case hir.IntType(bits=bits, signed=signed): + if signed: + return f"i{bits}" + else: + return f"u{bits}" + case hir.FloatType(bits=bits): + return f"f{bits}" + case hir.BoolType(): + return "bool" + case hir.VectorType(element=element, count=count): + return f"vec<{self.gen(element)}, {count}>" + case hir.StructType(name=name, fields=fields): + self.impl.writeln(f'struct {name} {{') + for field in fields: + self.impl.writeln(f' {self.gen(field[1])} {field[0]};') + self.impl.writeln('};') + return name + case hir.UnitType(): + return 'void' + case hir.TupleType(): + def do(): + elements = [self.gen(e) for e in ty.elements] + name = f'Tuple_{unique_hash("".join(elements))}' + self.impl.writeln(f'struct {name} {{') + for i, element in enumerate(elements): + self.impl.writeln(f' {element} _{i};') + self.impl.writeln('};') + return name + return do() + case hir.BoundType(): + assert ty.instantiated + return self.gen(ty.instantiated) + case hir.FunctionType(): + return '' + case hir.TypeConstructorType(): + return '' + case _: + raise NotImplementedError(f"unsupported type: {ty}") + +class RustAPIGenerator: + """ + Generates Rust API code for a given DSL module + """ + + def __init__(self): + pass \ No newline at end of file diff --git a/luisa_lang/generics.py b/luisa_lang/generics.py deleted file mode 100644 index 1788374..0000000 --- a/luisa_lang/generics.py +++ /dev/null @@ -1,5 +0,0 @@ -from typing import Any - - -def declval(val_or_type: Any) -> Any: - return None \ No newline at end of file diff --git a/luisa_lang/hir.py b/luisa_lang/hir.py index 2945dcd..e62f838 100644 --- a/luisa_lang/hir.py +++ b/luisa_lang/hir.py @@ -7,6 +7,7 @@ Any, Callable, List, + Literal, Optional, Set, Tuple, @@ -41,6 +42,16 @@ FunctionTemplateResolvingFunc = Callable[[ FunctionTemplateResolvingArgs], Union[FunctionLike, 'TemplateMatchingError']] +class FuncProperties: + inline: bool | Literal["always"] + export: bool + byref: Set[str] + + def __init__(self): + self.inline = False + self.export = False + self.byref = set() + class FunctionTemplate: """ @@ -56,6 +67,7 @@ class FunctionTemplate: is_generic: bool name: str params: List[str] + props: Optional[FuncProperties] """Function parameters (NOT type parameters)""" def __init__(self, name: str, params: List[str], parsing_func: FunctionTemplateResolvingFunc, is_generic: bool) -> None: @@ -64,6 +76,7 @@ def __init__(self, name: str, params: List[str], parsing_func: FunctionTemplateR self.params = params self.is_generic = is_generic self.name = name + self.props = None def resolve(self, args: FunctionTemplateResolvingArgs | None) -> Union[FunctionLike, 'TemplateMatchingError']: args = args or [] @@ -937,17 +950,6 @@ def __eq__(self, value: object) -> bool: def __hash__(self) -> int: return hash(self.value) - -# class FunctionValue(Value): -# func: FunctionLike | FunctionTemplate -# bounded_object: Optional[Ref] - -# def __init__(self, func: FunctionLike | FunctionTemplate, bounded_object: Optional[Ref], span: Optional[Span] = None) -> None: -# super().__init__(FunctionType(func, bounded_object is not None), span) -# self.func = func -# self.bounded_object = bounded_object - - class TypeValue(Value): def __init__(self, ty: Type, span: Optional[Span] = None) -> None: super().__init__(TypeConstructorType(ty), span) @@ -956,6 +958,9 @@ def inner_type(self) -> Type: assert isinstance(self.type, TypeConstructorType) return self.type.inner +class FunctionValue(Value): + def __init__(self, ty:FunctionType, span: Optional[Span] = None) -> None: + super().__init__(ty, span) class Alloca(Ref): """ @@ -983,9 +988,9 @@ def __init__(self, args: List[Value], type: Type, span: Optional[Span] = None) - class Intrinsic(Value): name: str - args: List[Value] + args: List[Value | Ref] - def __init__(self, name: str, args: List[Value], type: Type, span: Optional[Span] = None) -> None: + def __init__(self, name: str, args: List[Value | Ref], type: Type, span: Optional[Span] = None) -> None: super().__init__(type, span) self.name = name self.args = args @@ -1201,6 +1206,7 @@ class Function: locals: List[Var] complete: bool is_method: bool + inline_hint: Literal[True, 'always', 'never'] | None def __init__( self, @@ -1217,6 +1223,7 @@ def __init__( self.locals = [] self.complete = False self.is_method = is_method + self.inline_hint = None def match_template_args( diff --git a/luisa_lang/math_types.py b/luisa_lang/math_types.py index f46b832..4d7642e 100644 --- a/luisa_lang/math_types.py +++ b/luisa_lang/math_types.py @@ -1,6 +1,6 @@ # fmt: off import typing as tp -from luisa_lang._builtin_decor import intrinsic, func, builtin_type +from luisa_lang._builtin_decor import intrinsic, func, builtin_type, byref from luisa_lang.classinfo import register_class import luisa_lang.hir as _hir _ctx = _hir.GlobalContext.get() @@ -9,29 +9,52 @@ _F = tp.TypeVar("_F") _F1 = tp.TypeVar("_F1", "f32", "f64", "float2", "double2", "float3", "double3", "float4", "double4") class FloatBuiltin(tp.Generic[_F]): - def abs(self: _F) -> _F: return intrinsic('math.abs', _F) # type: ignore - def acos(self: _F) -> _F: return intrinsic('math.acos', _F) # type: ignore - def acosh(self: _F) -> _F: return intrinsic('math.acosh', _F) # type: ignore - def asin(self: _F) -> _F: return intrinsic('math.asin', _F) # type: ignore - def asinh(self: _F) -> _F: return intrinsic('math.asinh', _F) # type: ignore - def atan(self: _F) -> _F: return intrinsic('math.atan', _F) # type: ignore - def atanh(self: _F) -> _F: return intrinsic('math.atanh', _F) # type: ignore - def ceil(self: _F) -> _F: return intrinsic('math.ceil', _F) # type: ignore - def cos(self: _F) -> _F: return intrinsic('math.cos', _F) # type: ignore - def cosh(self: _F) -> _F: return intrinsic('math.cosh', _F) # type: ignore - def exp(self: _F) -> _F: return intrinsic('math.exp', _F) # type: ignore - def floor(self: _F) -> _F: return intrinsic('math.floor', _F) # type: ignore - def log(self: _F) -> _F: return intrinsic('math.log', _F) # type: ignore - def log10(self: _F) -> _F: return intrinsic('math.log10', _F) # type: ignore - def log2(self: _F) -> _F: return intrinsic('math.log2', _F) # type: ignore - def sin(self: _F) -> _F: return intrinsic('math.sin', _F) # type: ignore - def sinh(self: _F) -> _F: return intrinsic('math.sinh', _F) # type: ignore - def sqrt(self: _F) -> _F: return intrinsic('math.sqrt', _F) # type: ignore - def tan(self: _F) -> _F: return intrinsic('math.tan', _F) # type: ignore - def tanh(self: _F) -> _F: return intrinsic('math.tanh', _F) # type: ignore - def trunc(self: _F) -> _F: return intrinsic('math.trunc', _F) # type: ignore - def atan2(self: _F, _other: _F) -> _F: return intrinsic('math.atan2', _F) # type: ignore - def copysign(self: _F, _other: _F) -> _F: return intrinsic('math.copysign', _F) # type: ignore + @func(inline='always') + def abs(self: _F) -> _F: return intrinsic('math.abs', _F, self) # type: ignore + @func(inline='always') + def acos(self: _F) -> _F: return intrinsic('math.acos', _F, self) # type: ignore + @func(inline='always') + def acosh(self: _F) -> _F: return intrinsic('math.acosh', _F, self) # type: ignore + @func(inline='always') + def asin(self: _F) -> _F: return intrinsic('math.asin', _F, self) # type: ignore + @func(inline='always') + def asinh(self: _F) -> _F: return intrinsic('math.asinh', _F, self) # type: ignore + @func(inline='always') + def atan(self: _F) -> _F: return intrinsic('math.atan', _F, self) # type: ignore + @func(inline='always') + def atanh(self: _F) -> _F: return intrinsic('math.atanh', _F, self) # type: ignore + @func(inline='always') + def ceil(self: _F) -> _F: return intrinsic('math.ceil', _F, self) # type: ignore + @func(inline='always') + def cos(self: _F) -> _F: return intrinsic('math.cos', _F, self) # type: ignore + @func(inline='always') + def cosh(self: _F) -> _F: return intrinsic('math.cosh', _F, self) # type: ignore + @func(inline='always') + def exp(self: _F) -> _F: return intrinsic('math.exp', _F, self) # type: ignore + @func(inline='always') + def floor(self: _F) -> _F: return intrinsic('math.floor', _F, self) # type: ignore + @func(inline='always') + def log(self: _F) -> _F: return intrinsic('math.log', _F, self) # type: ignore + @func(inline='always') + def log10(self: _F) -> _F: return intrinsic('math.log10', _F, self) # type: ignore + @func(inline='always') + def log2(self: _F) -> _F: return intrinsic('math.log2', _F, self) # type: ignore + @func(inline='always') + def sin(self: _F) -> _F: return intrinsic('math.sin', _F, self) # type: ignore + @func(inline='always') + def sinh(self: _F) -> _F: return intrinsic('math.sinh', _F, self) # type: ignore + @func(inline='always') + def sqrt(self: _F) -> _F: return intrinsic('math.sqrt', _F, self) # type: ignore + @func(inline='always') + def tan(self: _F) -> _F: return intrinsic('math.tan', _F, self) # type: ignore + @func(inline='always') + def tanh(self: _F) -> _F: return intrinsic('math.tanh', _F, self) # type: ignore + @func(inline='always') + def trunc(self: _F) -> _F: return intrinsic('math.trunc', _F, self) # type: ignore + @func(inline='always') + def atan2(self: _F, _other: _F) -> _F: return intrinsic('math.atan2', _F, self, other) # type: ignore + @func(inline='always') + def copysign(self: _F, _other: _F) -> _F: return intrinsic('math.copysign', _F, self, other) # type: ignore @func def abs(x: _F1) -> _F1: return x.abs() @@ -82,838 +105,1567 @@ def copysign(x: _F1, y: _F1) -> _F1: return x.copysign(y) register_class(FloatBuiltin) @builtin_type(_hir.FloatType(32)) class f32(FloatBuiltin['f32']): + @func(inline='always') def __init__(self, _value: tp.Union['f32', float]) -> None: self = intrinsic("init.f32", f32, _value) - def __add__(self, _other: tp.Union['f32', float]) -> 'f32': return intrinsic("binop.__add__.f32", f32, _other) - def __radd__(self, _other: tp.Union['f32', float]) -> 'f32': return intrinsic("binop.__radd__.f32", f32, _other) - def __iadd__(self, _other: tp.Union['f32', float]) -> 'f32': return intrinsic("binop.__iadd__.f32", f32, _other) - def __sub__(self, _other: tp.Union['f32', float]) -> 'f32': return intrinsic("binop.__sub__.f32", f32, _other) - def __rsub__(self, _other: tp.Union['f32', float]) -> 'f32': return intrinsic("binop.__rsub__.f32", f32, _other) - def __isub__(self, _other: tp.Union['f32', float]) -> 'f32': return intrinsic("binop.__isub__.f32", f32, _other) - def __mul__(self, _other: tp.Union['f32', float]) -> 'f32': return intrinsic("binop.__mul__.f32", f32, _other) - def __rmul__(self, _other: tp.Union['f32', float]) -> 'f32': return intrinsic("binop.__rmul__.f32", f32, _other) - def __imul__(self, _other: tp.Union['f32', float]) -> 'f32': return intrinsic("binop.__imul__.f32", f32, _other) - def __mod__(self, _other: tp.Union['f32', float]) -> 'f32': return intrinsic("binop.__mod__.f32", f32, _other) - def __rmod__(self, _other: tp.Union['f32', float]) -> 'f32': return intrinsic("binop.__rmod__.f32", f32, _other) - def __imod__(self, _other: tp.Union['f32', float]) -> 'f32': return intrinsic("binop.__imod__.f32", f32, _other) - def __lt__(self, _other: tp.Union['f32', float]) -> 'bool': return intrinsic("cmp.__lt__.f32", bool, _other) # type: ignore[override] - def __le__(self, _other: tp.Union['f32', float]) -> 'bool': return intrinsic("cmp.__le__.f32", bool, _other) # type: ignore[override] - def __gt__(self, _other: tp.Union['f32', float]) -> 'bool': return intrinsic("cmp.__gt__.f32", bool, _other) # type: ignore[override] - def __ge__(self, _other: tp.Union['f32', float]) -> 'bool': return intrinsic("cmp.__ge__.f32", bool, _other) # type: ignore[override] - def __eq__(self, _other: tp.Union['f32', float]) -> 'bool': return intrinsic("cmp.__eq__.f32", bool, _other) # type: ignore[override] - def __ne__(self, _other: tp.Union['f32', float]) -> 'bool': return intrinsic("cmp.__ne__.f32", bool, _other) # type: ignore[override] - def __truediv__(self, _other: tp.Union['f32', float]) -> 'f32': return intrinsic("binop.__truediv__.f32", f32, _other) - def __rtruediv__(self, _other: tp.Union['f32', float]) -> 'f32': return intrinsic("binop.__rtruediv__.f32", f32, _other) - def __itruediv__(self, _other: tp.Union['f32', float]) -> 'f32': return intrinsic("binop.__itruediv__.f32", f32, _other) - def __pow__(self, _other: tp.Union['f32', float]) -> 'f32': return intrinsic("binop.__pow__.f32", f32, _other) - def __rpow__(self, _other: tp.Union['f32', float]) -> 'f32': return intrinsic("binop.__rpow__.f32", f32, _other) - def __ipow__(self, _other: tp.Union['f32', float]) -> 'f32': return intrinsic("binop.__ipow__.f32", f32, _other) - def __floordiv__(self, _other: tp.Union['f32', float]) -> 'f32': return intrinsic("binop.__floordiv__.f32", f32, _other) - def __rfloordiv__(self, _other: tp.Union['f32', float]) -> 'f32': return intrinsic("binop.__rfloordiv__.f32", f32, _other) - def __neg__(self) -> 'f32': return intrinsic("unary.neg.f32", f32) - def __pos__(self) -> 'f32': return intrinsic("unary.pos.f32", f32) + @func(inline='always') + def __add__(self, _other: tp.Union['f32', float]) -> 'f32': return intrinsic("binop.__add__.f32", f32, self, _other) + @func(inline='always') + def __radd__(self, _other: tp.Union['f32', float]) -> 'f32': return intrinsic("binop.__radd__.f32", f32, self, _other) + @func(inline='always') + def __iadd__(self, _other: tp.Union['f32', float]) -> 'f32': return intrinsic("binop.__iadd__.f32", f32, byref(self), _other) + @func(inline='always') + def __sub__(self, _other: tp.Union['f32', float]) -> 'f32': return intrinsic("binop.__sub__.f32", f32, self, _other) + @func(inline='always') + def __rsub__(self, _other: tp.Union['f32', float]) -> 'f32': return intrinsic("binop.__rsub__.f32", f32, self, _other) + @func(inline='always') + def __isub__(self, _other: tp.Union['f32', float]) -> 'f32': return intrinsic("binop.__isub__.f32", f32, byref(self), _other) + @func(inline='always') + def __mul__(self, _other: tp.Union['f32', float]) -> 'f32': return intrinsic("binop.__mul__.f32", f32, self, _other) + @func(inline='always') + def __rmul__(self, _other: tp.Union['f32', float]) -> 'f32': return intrinsic("binop.__rmul__.f32", f32, self, _other) + @func(inline='always') + def __imul__(self, _other: tp.Union['f32', float]) -> 'f32': return intrinsic("binop.__imul__.f32", f32, byref(self), _other) + @func(inline='always') + def __mod__(self, _other: tp.Union['f32', float]) -> 'f32': return intrinsic("binop.__mod__.f32", f32, self, _other) + @func(inline='always') + def __rmod__(self, _other: tp.Union['f32', float]) -> 'f32': return intrinsic("binop.__rmod__.f32", f32, self, _other) + @func(inline='always') + def __imod__(self, _other: tp.Union['f32', float]) -> 'f32': return intrinsic("binop.__imod__.f32", f32, byref(self), _other) + @func(inline='always') + def __lt__(self, _other: tp.Union['f32', float]) -> 'bool': return intrinsic("cmp.__lt__.f32", bool, self, _other) # type: ignore[override] + @func(inline='always') + def __le__(self, _other: tp.Union['f32', float]) -> 'bool': return intrinsic("cmp.__le__.f32", bool, self, _other) # type: ignore[override] + @func(inline='always') + def __gt__(self, _other: tp.Union['f32', float]) -> 'bool': return intrinsic("cmp.__gt__.f32", bool, self, _other) # type: ignore[override] + @func(inline='always') + def __ge__(self, _other: tp.Union['f32', float]) -> 'bool': return intrinsic("cmp.__ge__.f32", bool, self, _other) # type: ignore[override] + @func(inline='always') + def __eq__(self, _other: tp.Union['f32', float]) -> 'bool': return intrinsic("cmp.__eq__.f32", bool, self, _other) # type: ignore[override] + @func(inline='always') + def __ne__(self, _other: tp.Union['f32', float]) -> 'bool': return intrinsic("cmp.__ne__.f32", bool, self, _other) # type: ignore[override] + @func(inline='always') + def __truediv__(self, _other: tp.Union['f32', float]) -> 'f32': return intrinsic("binop.__truediv__.f32", f32, self, _other) + @func(inline='always') + def __rtruediv__(self, _other: tp.Union['f32', float]) -> 'f32': return intrinsic("binop.__rtruediv__.f32", f32, self, _other) + @func(inline='always') + def __itruediv__(self, _other: tp.Union['f32', float]) -> 'f32': return intrinsic("binop.__itruediv__.f32", f32, byref(self), _other) + @func(inline='always') + def __pow__(self, _other: tp.Union['f32', float]) -> 'f32': return intrinsic("binop.__pow__.f32", f32, self, _other) + @func(inline='always') + def __rpow__(self, _other: tp.Union['f32', float]) -> 'f32': return intrinsic("binop.__rpow__.f32", f32, self, _other) + @func(inline='always') + def __ipow__(self, _other: tp.Union['f32', float]) -> 'f32': return intrinsic("binop.__ipow__.f32", f32, byref(self), _other) + @func(inline='always') + def __floordiv__(self, _other: tp.Union['f32', float]) -> 'f32': return intrinsic("binop.__floordiv__.f32", f32, self, _other) + @func(inline='always') + def __rfloordiv__(self, _other: tp.Union['f32', float]) -> 'f32': return intrinsic("binop.__rfloordiv__.f32", f32, self, _other) + @func(inline='always') + def __neg__(self) -> 'f32': return intrinsic("unary.__neg__.f32", f32, self) + @func(inline='always') + def __pos__(self) -> 'f32': return intrinsic("unary.__pos__.f32", f32, self) @builtin_type(_hir.FloatType(64)) class f64(FloatBuiltin['f64']): + @func(inline='always') def __init__(self, _value: tp.Union['f64', float]) -> None: self = intrinsic("init.f64", f64, _value) - def __add__(self, _other: tp.Union['f64', float]) -> 'f64': return intrinsic("binop.__add__.f64", f64, _other) - def __radd__(self, _other: tp.Union['f64', float]) -> 'f64': return intrinsic("binop.__radd__.f64", f64, _other) - def __iadd__(self, _other: tp.Union['f64', float]) -> 'f64': return intrinsic("binop.__iadd__.f64", f64, _other) - def __sub__(self, _other: tp.Union['f64', float]) -> 'f64': return intrinsic("binop.__sub__.f64", f64, _other) - def __rsub__(self, _other: tp.Union['f64', float]) -> 'f64': return intrinsic("binop.__rsub__.f64", f64, _other) - def __isub__(self, _other: tp.Union['f64', float]) -> 'f64': return intrinsic("binop.__isub__.f64", f64, _other) - def __mul__(self, _other: tp.Union['f64', float]) -> 'f64': return intrinsic("binop.__mul__.f64", f64, _other) - def __rmul__(self, _other: tp.Union['f64', float]) -> 'f64': return intrinsic("binop.__rmul__.f64", f64, _other) - def __imul__(self, _other: tp.Union['f64', float]) -> 'f64': return intrinsic("binop.__imul__.f64", f64, _other) - def __mod__(self, _other: tp.Union['f64', float]) -> 'f64': return intrinsic("binop.__mod__.f64", f64, _other) - def __rmod__(self, _other: tp.Union['f64', float]) -> 'f64': return intrinsic("binop.__rmod__.f64", f64, _other) - def __imod__(self, _other: tp.Union['f64', float]) -> 'f64': return intrinsic("binop.__imod__.f64", f64, _other) - def __lt__(self, _other: tp.Union['f64', float]) -> 'bool': return intrinsic("cmp.__lt__.f64", bool, _other) # type: ignore[override] - def __le__(self, _other: tp.Union['f64', float]) -> 'bool': return intrinsic("cmp.__le__.f64", bool, _other) # type: ignore[override] - def __gt__(self, _other: tp.Union['f64', float]) -> 'bool': return intrinsic("cmp.__gt__.f64", bool, _other) # type: ignore[override] - def __ge__(self, _other: tp.Union['f64', float]) -> 'bool': return intrinsic("cmp.__ge__.f64", bool, _other) # type: ignore[override] - def __eq__(self, _other: tp.Union['f64', float]) -> 'bool': return intrinsic("cmp.__eq__.f64", bool, _other) # type: ignore[override] - def __ne__(self, _other: tp.Union['f64', float]) -> 'bool': return intrinsic("cmp.__ne__.f64", bool, _other) # type: ignore[override] - def __truediv__(self, _other: tp.Union['f64', float]) -> 'f64': return intrinsic("binop.__truediv__.f64", f64, _other) - def __rtruediv__(self, _other: tp.Union['f64', float]) -> 'f64': return intrinsic("binop.__rtruediv__.f64", f64, _other) - def __itruediv__(self, _other: tp.Union['f64', float]) -> 'f64': return intrinsic("binop.__itruediv__.f64", f64, _other) - def __pow__(self, _other: tp.Union['f64', float]) -> 'f64': return intrinsic("binop.__pow__.f64", f64, _other) - def __rpow__(self, _other: tp.Union['f64', float]) -> 'f64': return intrinsic("binop.__rpow__.f64", f64, _other) - def __ipow__(self, _other: tp.Union['f64', float]) -> 'f64': return intrinsic("binop.__ipow__.f64", f64, _other) - def __floordiv__(self, _other: tp.Union['f64', float]) -> 'f64': return intrinsic("binop.__floordiv__.f64", f64, _other) - def __rfloordiv__(self, _other: tp.Union['f64', float]) -> 'f64': return intrinsic("binop.__rfloordiv__.f64", f64, _other) - def __neg__(self) -> 'f64': return intrinsic("unary.neg.f64", f64) - def __pos__(self) -> 'f64': return intrinsic("unary.pos.f64", f64) + @func(inline='always') + def __add__(self, _other: tp.Union['f64', float]) -> 'f64': return intrinsic("binop.__add__.f64", f64, self, _other) + @func(inline='always') + def __radd__(self, _other: tp.Union['f64', float]) -> 'f64': return intrinsic("binop.__radd__.f64", f64, self, _other) + @func(inline='always') + def __iadd__(self, _other: tp.Union['f64', float]) -> 'f64': return intrinsic("binop.__iadd__.f64", f64, byref(self), _other) + @func(inline='always') + def __sub__(self, _other: tp.Union['f64', float]) -> 'f64': return intrinsic("binop.__sub__.f64", f64, self, _other) + @func(inline='always') + def __rsub__(self, _other: tp.Union['f64', float]) -> 'f64': return intrinsic("binop.__rsub__.f64", f64, self, _other) + @func(inline='always') + def __isub__(self, _other: tp.Union['f64', float]) -> 'f64': return intrinsic("binop.__isub__.f64", f64, byref(self), _other) + @func(inline='always') + def __mul__(self, _other: tp.Union['f64', float]) -> 'f64': return intrinsic("binop.__mul__.f64", f64, self, _other) + @func(inline='always') + def __rmul__(self, _other: tp.Union['f64', float]) -> 'f64': return intrinsic("binop.__rmul__.f64", f64, self, _other) + @func(inline='always') + def __imul__(self, _other: tp.Union['f64', float]) -> 'f64': return intrinsic("binop.__imul__.f64", f64, byref(self), _other) + @func(inline='always') + def __mod__(self, _other: tp.Union['f64', float]) -> 'f64': return intrinsic("binop.__mod__.f64", f64, self, _other) + @func(inline='always') + def __rmod__(self, _other: tp.Union['f64', float]) -> 'f64': return intrinsic("binop.__rmod__.f64", f64, self, _other) + @func(inline='always') + def __imod__(self, _other: tp.Union['f64', float]) -> 'f64': return intrinsic("binop.__imod__.f64", f64, byref(self), _other) + @func(inline='always') + def __lt__(self, _other: tp.Union['f64', float]) -> 'bool': return intrinsic("cmp.__lt__.f64", bool, self, _other) # type: ignore[override] + @func(inline='always') + def __le__(self, _other: tp.Union['f64', float]) -> 'bool': return intrinsic("cmp.__le__.f64", bool, self, _other) # type: ignore[override] + @func(inline='always') + def __gt__(self, _other: tp.Union['f64', float]) -> 'bool': return intrinsic("cmp.__gt__.f64", bool, self, _other) # type: ignore[override] + @func(inline='always') + def __ge__(self, _other: tp.Union['f64', float]) -> 'bool': return intrinsic("cmp.__ge__.f64", bool, self, _other) # type: ignore[override] + @func(inline='always') + def __eq__(self, _other: tp.Union['f64', float]) -> 'bool': return intrinsic("cmp.__eq__.f64", bool, self, _other) # type: ignore[override] + @func(inline='always') + def __ne__(self, _other: tp.Union['f64', float]) -> 'bool': return intrinsic("cmp.__ne__.f64", bool, self, _other) # type: ignore[override] + @func(inline='always') + def __truediv__(self, _other: tp.Union['f64', float]) -> 'f64': return intrinsic("binop.__truediv__.f64", f64, self, _other) + @func(inline='always') + def __rtruediv__(self, _other: tp.Union['f64', float]) -> 'f64': return intrinsic("binop.__rtruediv__.f64", f64, self, _other) + @func(inline='always') + def __itruediv__(self, _other: tp.Union['f64', float]) -> 'f64': return intrinsic("binop.__itruediv__.f64", f64, byref(self), _other) + @func(inline='always') + def __pow__(self, _other: tp.Union['f64', float]) -> 'f64': return intrinsic("binop.__pow__.f64", f64, self, _other) + @func(inline='always') + def __rpow__(self, _other: tp.Union['f64', float]) -> 'f64': return intrinsic("binop.__rpow__.f64", f64, self, _other) + @func(inline='always') + def __ipow__(self, _other: tp.Union['f64', float]) -> 'f64': return intrinsic("binop.__ipow__.f64", f64, byref(self), _other) + @func(inline='always') + def __floordiv__(self, _other: tp.Union['f64', float]) -> 'f64': return intrinsic("binop.__floordiv__.f64", f64, self, _other) + @func(inline='always') + def __rfloordiv__(self, _other: tp.Union['f64', float]) -> 'f64': return intrinsic("binop.__rfloordiv__.f64", f64, self, _other) + @func(inline='always') + def __neg__(self) -> 'f64': return intrinsic("unary.__neg__.f64", f64, self) + @func(inline='always') + def __pos__(self) -> 'f64': return intrinsic("unary.__pos__.f64", f64, self) @builtin_type(_hir.IntType(8, True)) class i8: + @func(inline='always') def __init__(self, _value: tp.Union['i8', int]) -> None: self = intrinsic("init.i8", i8, _value) - def __add__(self, _other: tp.Union['i8', int]) -> 'i8': return intrinsic("binop.__add__.i8", i8, _other) - def __radd__(self, _other: tp.Union['i8', int]) -> 'i8': return intrinsic("binop.__radd__.i8", i8, _other) - def __iadd__(self, _other: tp.Union['i8', int]) -> 'i8': return intrinsic("binop.__iadd__.i8", i8, _other) - def __sub__(self, _other: tp.Union['i8', int]) -> 'i8': return intrinsic("binop.__sub__.i8", i8, _other) - def __rsub__(self, _other: tp.Union['i8', int]) -> 'i8': return intrinsic("binop.__rsub__.i8", i8, _other) - def __isub__(self, _other: tp.Union['i8', int]) -> 'i8': return intrinsic("binop.__isub__.i8", i8, _other) - def __mul__(self, _other: tp.Union['i8', int]) -> 'i8': return intrinsic("binop.__mul__.i8", i8, _other) - def __rmul__(self, _other: tp.Union['i8', int]) -> 'i8': return intrinsic("binop.__rmul__.i8", i8, _other) - def __imul__(self, _other: tp.Union['i8', int]) -> 'i8': return intrinsic("binop.__imul__.i8", i8, _other) - def __mod__(self, _other: tp.Union['i8', int]) -> 'i8': return intrinsic("binop.__mod__.i8", i8, _other) - def __rmod__(self, _other: tp.Union['i8', int]) -> 'i8': return intrinsic("binop.__rmod__.i8", i8, _other) - def __imod__(self, _other: tp.Union['i8', int]) -> 'i8': return intrinsic("binop.__imod__.i8", i8, _other) - def __lt__(self, _other: tp.Union['i8', int]) -> 'bool': return intrinsic("cmp.__lt__.i8", bool, _other) # type: ignore[override] - def __le__(self, _other: tp.Union['i8', int]) -> 'bool': return intrinsic("cmp.__le__.i8", bool, _other) # type: ignore[override] - def __gt__(self, _other: tp.Union['i8', int]) -> 'bool': return intrinsic("cmp.__gt__.i8", bool, _other) # type: ignore[override] - def __ge__(self, _other: tp.Union['i8', int]) -> 'bool': return intrinsic("cmp.__ge__.i8", bool, _other) # type: ignore[override] - def __eq__(self, _other: tp.Union['i8', int]) -> 'bool': return intrinsic("cmp.__eq__.i8", bool, _other) # type: ignore[override] - def __ne__(self, _other: tp.Union['i8', int]) -> 'bool': return intrinsic("cmp.__ne__.i8", bool, _other) # type: ignore[override] - def __floordiv__(self, _other: tp.Union['i8', int]) -> 'i8': return intrinsic("binop.__floordiv__.i8", i8, _other) - def __rfloordiv__(self, _other: tp.Union['i8', int]) -> 'i8': return intrinsic("binop.__rfloordiv__.i8", i8, _other) - def __ifloordiv__(self, _other: tp.Union['i8', int]) -> 'i8': return intrinsic("binop.__ifloordiv__.i8", i8, _other) - def __lshift__(self, _other: tp.Union['i8', int]) -> 'i8': return intrinsic("binop.__lshift__.i8", i8, _other) - def __rlshift__(self, _other: tp.Union['i8', int]) -> 'i8': return intrinsic("binop.__rlshift__.i8", i8, _other) - def __ilshift__(self, _other: tp.Union['i8', int]) -> 'i8': return intrinsic("binop.__ilshift__.i8", i8, _other) - def __rshift__(self, _other: tp.Union['i8', int]) -> 'i8': return intrinsic("binop.__rshift__.i8", i8, _other) - def __rrshift__(self, _other: tp.Union['i8', int]) -> 'i8': return intrinsic("binop.__rrshift__.i8", i8, _other) - def __irshift__(self, _other: tp.Union['i8', int]) -> 'i8': return intrinsic("binop.__irshift__.i8", i8, _other) - def __and__(self, _other: tp.Union['i8', int]) -> 'i8': return intrinsic("binop.__and__.i8", i8, _other) - def __rand__(self, _other: tp.Union['i8', int]) -> 'i8': return intrinsic("binop.__rand__.i8", i8, _other) - def __iand__(self, _other: tp.Union['i8', int]) -> 'i8': return intrinsic("binop.__iand__.i8", i8, _other) - def __or__(self, _other: tp.Union['i8', int]) -> 'i8': return intrinsic("binop.__or__.i8", i8, _other) - def __ror__(self, _other: tp.Union['i8', int]) -> 'i8': return intrinsic("binop.__ror__.i8", i8, _other) - def __ior__(self, _other: tp.Union['i8', int]) -> 'i8': return intrinsic("binop.__ior__.i8", i8, _other) - def __xor__(self, _other: tp.Union['i8', int]) -> 'i8': return intrinsic("binop.__xor__.i8", i8, _other) - def __rxor__(self, _other: tp.Union['i8', int]) -> 'i8': return intrinsic("binop.__rxor__.i8", i8, _other) - def __ixor__(self, _other: tp.Union['i8', int]) -> 'i8': return intrinsic("binop.__ixor__.i8", i8, _other) - def __neg__(self) -> 'i8': return intrinsic("unary.neg.i8", i8) - def __pos__(self) -> 'i8': return intrinsic("unary.pos.i8", i8) - def __invert__(self) -> 'i8': return intrinsic("unary.invert.i8", i8) + @func(inline='always') + def __add__(self, _other: tp.Union['i8', int]) -> 'i8': return intrinsic("binop.__add__.i8", i8, self, _other) + @func(inline='always') + def __radd__(self, _other: tp.Union['i8', int]) -> 'i8': return intrinsic("binop.__radd__.i8", i8, self, _other) + @func(inline='always') + def __iadd__(self, _other: tp.Union['i8', int]) -> 'i8': return intrinsic("binop.__iadd__.i8", i8, byref(self), _other) + @func(inline='always') + def __sub__(self, _other: tp.Union['i8', int]) -> 'i8': return intrinsic("binop.__sub__.i8", i8, self, _other) + @func(inline='always') + def __rsub__(self, _other: tp.Union['i8', int]) -> 'i8': return intrinsic("binop.__rsub__.i8", i8, self, _other) + @func(inline='always') + def __isub__(self, _other: tp.Union['i8', int]) -> 'i8': return intrinsic("binop.__isub__.i8", i8, byref(self), _other) + @func(inline='always') + def __mul__(self, _other: tp.Union['i8', int]) -> 'i8': return intrinsic("binop.__mul__.i8", i8, self, _other) + @func(inline='always') + def __rmul__(self, _other: tp.Union['i8', int]) -> 'i8': return intrinsic("binop.__rmul__.i8", i8, self, _other) + @func(inline='always') + def __imul__(self, _other: tp.Union['i8', int]) -> 'i8': return intrinsic("binop.__imul__.i8", i8, byref(self), _other) + @func(inline='always') + def __mod__(self, _other: tp.Union['i8', int]) -> 'i8': return intrinsic("binop.__mod__.i8", i8, self, _other) + @func(inline='always') + def __rmod__(self, _other: tp.Union['i8', int]) -> 'i8': return intrinsic("binop.__rmod__.i8", i8, self, _other) + @func(inline='always') + def __imod__(self, _other: tp.Union['i8', int]) -> 'i8': return intrinsic("binop.__imod__.i8", i8, byref(self), _other) + @func(inline='always') + def __lt__(self, _other: tp.Union['i8', int]) -> 'bool': return intrinsic("cmp.__lt__.i8", bool, self, _other) # type: ignore[override] + @func(inline='always') + def __le__(self, _other: tp.Union['i8', int]) -> 'bool': return intrinsic("cmp.__le__.i8", bool, self, _other) # type: ignore[override] + @func(inline='always') + def __gt__(self, _other: tp.Union['i8', int]) -> 'bool': return intrinsic("cmp.__gt__.i8", bool, self, _other) # type: ignore[override] + @func(inline='always') + def __ge__(self, _other: tp.Union['i8', int]) -> 'bool': return intrinsic("cmp.__ge__.i8", bool, self, _other) # type: ignore[override] + @func(inline='always') + def __eq__(self, _other: tp.Union['i8', int]) -> 'bool': return intrinsic("cmp.__eq__.i8", bool, self, _other) # type: ignore[override] + @func(inline='always') + def __ne__(self, _other: tp.Union['i8', int]) -> 'bool': return intrinsic("cmp.__ne__.i8", bool, self, _other) # type: ignore[override] + @func(inline='always') + def __floordiv__(self, _other: tp.Union['i8', int]) -> 'i8': return intrinsic("binop.__floordiv__.i8", i8, self, _other) + @func(inline='always') + def __rfloordiv__(self, _other: tp.Union['i8', int]) -> 'i8': return intrinsic("binop.__rfloordiv__.i8", i8, self, _other) + @func(inline='always') + def __ifloordiv__(self, _other: tp.Union['i8', int]) -> 'i8': return intrinsic("binop.__ifloordiv__.i8", i8, byref(self), _other) + @func(inline='always') + def __lshift__(self, _other: tp.Union['i8', int]) -> 'i8': return intrinsic("binop.__lshift__.i8", i8, self, _other) + @func(inline='always') + def __rlshift__(self, _other: tp.Union['i8', int]) -> 'i8': return intrinsic("binop.__rlshift__.i8", i8, self, _other) + @func(inline='always') + def __ilshift__(self, _other: tp.Union['i8', int]) -> 'i8': return intrinsic("binop.__ilshift__.i8", i8, byref(self), _other) + @func(inline='always') + def __rshift__(self, _other: tp.Union['i8', int]) -> 'i8': return intrinsic("binop.__rshift__.i8", i8, self, _other) + @func(inline='always') + def __rrshift__(self, _other: tp.Union['i8', int]) -> 'i8': return intrinsic("binop.__rrshift__.i8", i8, self, _other) + @func(inline='always') + def __irshift__(self, _other: tp.Union['i8', int]) -> 'i8': return intrinsic("binop.__irshift__.i8", i8, byref(self), _other) + @func(inline='always') + def __and__(self, _other: tp.Union['i8', int]) -> 'i8': return intrinsic("binop.__and__.i8", i8, self, _other) + @func(inline='always') + def __rand__(self, _other: tp.Union['i8', int]) -> 'i8': return intrinsic("binop.__rand__.i8", i8, self, _other) + @func(inline='always') + def __iand__(self, _other: tp.Union['i8', int]) -> 'i8': return intrinsic("binop.__iand__.i8", i8, byref(self), _other) + @func(inline='always') + def __or__(self, _other: tp.Union['i8', int]) -> 'i8': return intrinsic("binop.__or__.i8", i8, self, _other) + @func(inline='always') + def __ror__(self, _other: tp.Union['i8', int]) -> 'i8': return intrinsic("binop.__ror__.i8", i8, self, _other) + @func(inline='always') + def __ior__(self, _other: tp.Union['i8', int]) -> 'i8': return intrinsic("binop.__ior__.i8", i8, byref(self), _other) + @func(inline='always') + def __xor__(self, _other: tp.Union['i8', int]) -> 'i8': return intrinsic("binop.__xor__.i8", i8, self, _other) + @func(inline='always') + def __rxor__(self, _other: tp.Union['i8', int]) -> 'i8': return intrinsic("binop.__rxor__.i8", i8, self, _other) + @func(inline='always') + def __ixor__(self, _other: tp.Union['i8', int]) -> 'i8': return intrinsic("binop.__ixor__.i8", i8, byref(self), _other) + @func(inline='always') + def __neg__(self) -> 'i8': return intrinsic("unary.__neg__.i8", i8, self) + @func(inline='always') + def __pos__(self) -> 'i8': return intrinsic("unary.__pos__.i8", i8, self) + @func(inline='always') + def __invert__(self) -> 'i8': return intrinsic("unary.__invert__.i8", i8, self) @builtin_type(_hir.IntType(8, False)) class u8: + @func(inline='always') def __init__(self, _value: tp.Union['u8', int]) -> None: self = intrinsic("init.u8", u8, _value) - def __add__(self, _other: tp.Union['u8', int]) -> 'u8': return intrinsic("binop.__add__.u8", u8, _other) - def __radd__(self, _other: tp.Union['u8', int]) -> 'u8': return intrinsic("binop.__radd__.u8", u8, _other) - def __iadd__(self, _other: tp.Union['u8', int]) -> 'u8': return intrinsic("binop.__iadd__.u8", u8, _other) - def __sub__(self, _other: tp.Union['u8', int]) -> 'u8': return intrinsic("binop.__sub__.u8", u8, _other) - def __rsub__(self, _other: tp.Union['u8', int]) -> 'u8': return intrinsic("binop.__rsub__.u8", u8, _other) - def __isub__(self, _other: tp.Union['u8', int]) -> 'u8': return intrinsic("binop.__isub__.u8", u8, _other) - def __mul__(self, _other: tp.Union['u8', int]) -> 'u8': return intrinsic("binop.__mul__.u8", u8, _other) - def __rmul__(self, _other: tp.Union['u8', int]) -> 'u8': return intrinsic("binop.__rmul__.u8", u8, _other) - def __imul__(self, _other: tp.Union['u8', int]) -> 'u8': return intrinsic("binop.__imul__.u8", u8, _other) - def __mod__(self, _other: tp.Union['u8', int]) -> 'u8': return intrinsic("binop.__mod__.u8", u8, _other) - def __rmod__(self, _other: tp.Union['u8', int]) -> 'u8': return intrinsic("binop.__rmod__.u8", u8, _other) - def __imod__(self, _other: tp.Union['u8', int]) -> 'u8': return intrinsic("binop.__imod__.u8", u8, _other) - def __lt__(self, _other: tp.Union['u8', int]) -> 'bool': return intrinsic("cmp.__lt__.u8", bool, _other) # type: ignore[override] - def __le__(self, _other: tp.Union['u8', int]) -> 'bool': return intrinsic("cmp.__le__.u8", bool, _other) # type: ignore[override] - def __gt__(self, _other: tp.Union['u8', int]) -> 'bool': return intrinsic("cmp.__gt__.u8", bool, _other) # type: ignore[override] - def __ge__(self, _other: tp.Union['u8', int]) -> 'bool': return intrinsic("cmp.__ge__.u8", bool, _other) # type: ignore[override] - def __eq__(self, _other: tp.Union['u8', int]) -> 'bool': return intrinsic("cmp.__eq__.u8", bool, _other) # type: ignore[override] - def __ne__(self, _other: tp.Union['u8', int]) -> 'bool': return intrinsic("cmp.__ne__.u8", bool, _other) # type: ignore[override] - def __floordiv__(self, _other: tp.Union['u8', int]) -> 'u8': return intrinsic("binop.__floordiv__.u8", u8, _other) - def __rfloordiv__(self, _other: tp.Union['u8', int]) -> 'u8': return intrinsic("binop.__rfloordiv__.u8", u8, _other) - def __ifloordiv__(self, _other: tp.Union['u8', int]) -> 'u8': return intrinsic("binop.__ifloordiv__.u8", u8, _other) - def __lshift__(self, _other: tp.Union['u8', int]) -> 'u8': return intrinsic("binop.__lshift__.u8", u8, _other) - def __rlshift__(self, _other: tp.Union['u8', int]) -> 'u8': return intrinsic("binop.__rlshift__.u8", u8, _other) - def __ilshift__(self, _other: tp.Union['u8', int]) -> 'u8': return intrinsic("binop.__ilshift__.u8", u8, _other) - def __rshift__(self, _other: tp.Union['u8', int]) -> 'u8': return intrinsic("binop.__rshift__.u8", u8, _other) - def __rrshift__(self, _other: tp.Union['u8', int]) -> 'u8': return intrinsic("binop.__rrshift__.u8", u8, _other) - def __irshift__(self, _other: tp.Union['u8', int]) -> 'u8': return intrinsic("binop.__irshift__.u8", u8, _other) - def __and__(self, _other: tp.Union['u8', int]) -> 'u8': return intrinsic("binop.__and__.u8", u8, _other) - def __rand__(self, _other: tp.Union['u8', int]) -> 'u8': return intrinsic("binop.__rand__.u8", u8, _other) - def __iand__(self, _other: tp.Union['u8', int]) -> 'u8': return intrinsic("binop.__iand__.u8", u8, _other) - def __or__(self, _other: tp.Union['u8', int]) -> 'u8': return intrinsic("binop.__or__.u8", u8, _other) - def __ror__(self, _other: tp.Union['u8', int]) -> 'u8': return intrinsic("binop.__ror__.u8", u8, _other) - def __ior__(self, _other: tp.Union['u8', int]) -> 'u8': return intrinsic("binop.__ior__.u8", u8, _other) - def __xor__(self, _other: tp.Union['u8', int]) -> 'u8': return intrinsic("binop.__xor__.u8", u8, _other) - def __rxor__(self, _other: tp.Union['u8', int]) -> 'u8': return intrinsic("binop.__rxor__.u8", u8, _other) - def __ixor__(self, _other: tp.Union['u8', int]) -> 'u8': return intrinsic("binop.__ixor__.u8", u8, _other) - def __neg__(self) -> 'u8': return intrinsic("unary.neg.u8", u8) - def __pos__(self) -> 'u8': return intrinsic("unary.pos.u8", u8) - def __invert__(self) -> 'u8': return intrinsic("unary.invert.u8", u8) + @func(inline='always') + def __add__(self, _other: tp.Union['u8', int]) -> 'u8': return intrinsic("binop.__add__.u8", u8, self, _other) + @func(inline='always') + def __radd__(self, _other: tp.Union['u8', int]) -> 'u8': return intrinsic("binop.__radd__.u8", u8, self, _other) + @func(inline='always') + def __iadd__(self, _other: tp.Union['u8', int]) -> 'u8': return intrinsic("binop.__iadd__.u8", u8, byref(self), _other) + @func(inline='always') + def __sub__(self, _other: tp.Union['u8', int]) -> 'u8': return intrinsic("binop.__sub__.u8", u8, self, _other) + @func(inline='always') + def __rsub__(self, _other: tp.Union['u8', int]) -> 'u8': return intrinsic("binop.__rsub__.u8", u8, self, _other) + @func(inline='always') + def __isub__(self, _other: tp.Union['u8', int]) -> 'u8': return intrinsic("binop.__isub__.u8", u8, byref(self), _other) + @func(inline='always') + def __mul__(self, _other: tp.Union['u8', int]) -> 'u8': return intrinsic("binop.__mul__.u8", u8, self, _other) + @func(inline='always') + def __rmul__(self, _other: tp.Union['u8', int]) -> 'u8': return intrinsic("binop.__rmul__.u8", u8, self, _other) + @func(inline='always') + def __imul__(self, _other: tp.Union['u8', int]) -> 'u8': return intrinsic("binop.__imul__.u8", u8, byref(self), _other) + @func(inline='always') + def __mod__(self, _other: tp.Union['u8', int]) -> 'u8': return intrinsic("binop.__mod__.u8", u8, self, _other) + @func(inline='always') + def __rmod__(self, _other: tp.Union['u8', int]) -> 'u8': return intrinsic("binop.__rmod__.u8", u8, self, _other) + @func(inline='always') + def __imod__(self, _other: tp.Union['u8', int]) -> 'u8': return intrinsic("binop.__imod__.u8", u8, byref(self), _other) + @func(inline='always') + def __lt__(self, _other: tp.Union['u8', int]) -> 'bool': return intrinsic("cmp.__lt__.u8", bool, self, _other) # type: ignore[override] + @func(inline='always') + def __le__(self, _other: tp.Union['u8', int]) -> 'bool': return intrinsic("cmp.__le__.u8", bool, self, _other) # type: ignore[override] + @func(inline='always') + def __gt__(self, _other: tp.Union['u8', int]) -> 'bool': return intrinsic("cmp.__gt__.u8", bool, self, _other) # type: ignore[override] + @func(inline='always') + def __ge__(self, _other: tp.Union['u8', int]) -> 'bool': return intrinsic("cmp.__ge__.u8", bool, self, _other) # type: ignore[override] + @func(inline='always') + def __eq__(self, _other: tp.Union['u8', int]) -> 'bool': return intrinsic("cmp.__eq__.u8", bool, self, _other) # type: ignore[override] + @func(inline='always') + def __ne__(self, _other: tp.Union['u8', int]) -> 'bool': return intrinsic("cmp.__ne__.u8", bool, self, _other) # type: ignore[override] + @func(inline='always') + def __floordiv__(self, _other: tp.Union['u8', int]) -> 'u8': return intrinsic("binop.__floordiv__.u8", u8, self, _other) + @func(inline='always') + def __rfloordiv__(self, _other: tp.Union['u8', int]) -> 'u8': return intrinsic("binop.__rfloordiv__.u8", u8, self, _other) + @func(inline='always') + def __ifloordiv__(self, _other: tp.Union['u8', int]) -> 'u8': return intrinsic("binop.__ifloordiv__.u8", u8, byref(self), _other) + @func(inline='always') + def __lshift__(self, _other: tp.Union['u8', int]) -> 'u8': return intrinsic("binop.__lshift__.u8", u8, self, _other) + @func(inline='always') + def __rlshift__(self, _other: tp.Union['u8', int]) -> 'u8': return intrinsic("binop.__rlshift__.u8", u8, self, _other) + @func(inline='always') + def __ilshift__(self, _other: tp.Union['u8', int]) -> 'u8': return intrinsic("binop.__ilshift__.u8", u8, byref(self), _other) + @func(inline='always') + def __rshift__(self, _other: tp.Union['u8', int]) -> 'u8': return intrinsic("binop.__rshift__.u8", u8, self, _other) + @func(inline='always') + def __rrshift__(self, _other: tp.Union['u8', int]) -> 'u8': return intrinsic("binop.__rrshift__.u8", u8, self, _other) + @func(inline='always') + def __irshift__(self, _other: tp.Union['u8', int]) -> 'u8': return intrinsic("binop.__irshift__.u8", u8, byref(self), _other) + @func(inline='always') + def __and__(self, _other: tp.Union['u8', int]) -> 'u8': return intrinsic("binop.__and__.u8", u8, self, _other) + @func(inline='always') + def __rand__(self, _other: tp.Union['u8', int]) -> 'u8': return intrinsic("binop.__rand__.u8", u8, self, _other) + @func(inline='always') + def __iand__(self, _other: tp.Union['u8', int]) -> 'u8': return intrinsic("binop.__iand__.u8", u8, byref(self), _other) + @func(inline='always') + def __or__(self, _other: tp.Union['u8', int]) -> 'u8': return intrinsic("binop.__or__.u8", u8, self, _other) + @func(inline='always') + def __ror__(self, _other: tp.Union['u8', int]) -> 'u8': return intrinsic("binop.__ror__.u8", u8, self, _other) + @func(inline='always') + def __ior__(self, _other: tp.Union['u8', int]) -> 'u8': return intrinsic("binop.__ior__.u8", u8, byref(self), _other) + @func(inline='always') + def __xor__(self, _other: tp.Union['u8', int]) -> 'u8': return intrinsic("binop.__xor__.u8", u8, self, _other) + @func(inline='always') + def __rxor__(self, _other: tp.Union['u8', int]) -> 'u8': return intrinsic("binop.__rxor__.u8", u8, self, _other) + @func(inline='always') + def __ixor__(self, _other: tp.Union['u8', int]) -> 'u8': return intrinsic("binop.__ixor__.u8", u8, byref(self), _other) + @func(inline='always') + def __neg__(self) -> 'u8': return intrinsic("unary.__neg__.u8", u8, self) + @func(inline='always') + def __pos__(self) -> 'u8': return intrinsic("unary.__pos__.u8", u8, self) + @func(inline='always') + def __invert__(self) -> 'u8': return intrinsic("unary.__invert__.u8", u8, self) @builtin_type(_hir.IntType(16, True)) class i16: + @func(inline='always') def __init__(self, _value: tp.Union['i16', int]) -> None: self = intrinsic("init.i16", i16, _value) - def __add__(self, _other: tp.Union['i16', int]) -> 'i16': return intrinsic("binop.__add__.i16", i16, _other) - def __radd__(self, _other: tp.Union['i16', int]) -> 'i16': return intrinsic("binop.__radd__.i16", i16, _other) - def __iadd__(self, _other: tp.Union['i16', int]) -> 'i16': return intrinsic("binop.__iadd__.i16", i16, _other) - def __sub__(self, _other: tp.Union['i16', int]) -> 'i16': return intrinsic("binop.__sub__.i16", i16, _other) - def __rsub__(self, _other: tp.Union['i16', int]) -> 'i16': return intrinsic("binop.__rsub__.i16", i16, _other) - def __isub__(self, _other: tp.Union['i16', int]) -> 'i16': return intrinsic("binop.__isub__.i16", i16, _other) - def __mul__(self, _other: tp.Union['i16', int]) -> 'i16': return intrinsic("binop.__mul__.i16", i16, _other) - def __rmul__(self, _other: tp.Union['i16', int]) -> 'i16': return intrinsic("binop.__rmul__.i16", i16, _other) - def __imul__(self, _other: tp.Union['i16', int]) -> 'i16': return intrinsic("binop.__imul__.i16", i16, _other) - def __mod__(self, _other: tp.Union['i16', int]) -> 'i16': return intrinsic("binop.__mod__.i16", i16, _other) - def __rmod__(self, _other: tp.Union['i16', int]) -> 'i16': return intrinsic("binop.__rmod__.i16", i16, _other) - def __imod__(self, _other: tp.Union['i16', int]) -> 'i16': return intrinsic("binop.__imod__.i16", i16, _other) - def __lt__(self, _other: tp.Union['i16', int]) -> 'bool': return intrinsic("cmp.__lt__.i16", bool, _other) # type: ignore[override] - def __le__(self, _other: tp.Union['i16', int]) -> 'bool': return intrinsic("cmp.__le__.i16", bool, _other) # type: ignore[override] - def __gt__(self, _other: tp.Union['i16', int]) -> 'bool': return intrinsic("cmp.__gt__.i16", bool, _other) # type: ignore[override] - def __ge__(self, _other: tp.Union['i16', int]) -> 'bool': return intrinsic("cmp.__ge__.i16", bool, _other) # type: ignore[override] - def __eq__(self, _other: tp.Union['i16', int]) -> 'bool': return intrinsic("cmp.__eq__.i16", bool, _other) # type: ignore[override] - def __ne__(self, _other: tp.Union['i16', int]) -> 'bool': return intrinsic("cmp.__ne__.i16", bool, _other) # type: ignore[override] - def __floordiv__(self, _other: tp.Union['i16', int]) -> 'i16': return intrinsic("binop.__floordiv__.i16", i16, _other) - def __rfloordiv__(self, _other: tp.Union['i16', int]) -> 'i16': return intrinsic("binop.__rfloordiv__.i16", i16, _other) - def __ifloordiv__(self, _other: tp.Union['i16', int]) -> 'i16': return intrinsic("binop.__ifloordiv__.i16", i16, _other) - def __lshift__(self, _other: tp.Union['i16', int]) -> 'i16': return intrinsic("binop.__lshift__.i16", i16, _other) - def __rlshift__(self, _other: tp.Union['i16', int]) -> 'i16': return intrinsic("binop.__rlshift__.i16", i16, _other) - def __ilshift__(self, _other: tp.Union['i16', int]) -> 'i16': return intrinsic("binop.__ilshift__.i16", i16, _other) - def __rshift__(self, _other: tp.Union['i16', int]) -> 'i16': return intrinsic("binop.__rshift__.i16", i16, _other) - def __rrshift__(self, _other: tp.Union['i16', int]) -> 'i16': return intrinsic("binop.__rrshift__.i16", i16, _other) - def __irshift__(self, _other: tp.Union['i16', int]) -> 'i16': return intrinsic("binop.__irshift__.i16", i16, _other) - def __and__(self, _other: tp.Union['i16', int]) -> 'i16': return intrinsic("binop.__and__.i16", i16, _other) - def __rand__(self, _other: tp.Union['i16', int]) -> 'i16': return intrinsic("binop.__rand__.i16", i16, _other) - def __iand__(self, _other: tp.Union['i16', int]) -> 'i16': return intrinsic("binop.__iand__.i16", i16, _other) - def __or__(self, _other: tp.Union['i16', int]) -> 'i16': return intrinsic("binop.__or__.i16", i16, _other) - def __ror__(self, _other: tp.Union['i16', int]) -> 'i16': return intrinsic("binop.__ror__.i16", i16, _other) - def __ior__(self, _other: tp.Union['i16', int]) -> 'i16': return intrinsic("binop.__ior__.i16", i16, _other) - def __xor__(self, _other: tp.Union['i16', int]) -> 'i16': return intrinsic("binop.__xor__.i16", i16, _other) - def __rxor__(self, _other: tp.Union['i16', int]) -> 'i16': return intrinsic("binop.__rxor__.i16", i16, _other) - def __ixor__(self, _other: tp.Union['i16', int]) -> 'i16': return intrinsic("binop.__ixor__.i16", i16, _other) - def __neg__(self) -> 'i16': return intrinsic("unary.neg.i16", i16) - def __pos__(self) -> 'i16': return intrinsic("unary.pos.i16", i16) - def __invert__(self) -> 'i16': return intrinsic("unary.invert.i16", i16) + @func(inline='always') + def __add__(self, _other: tp.Union['i16', int]) -> 'i16': return intrinsic("binop.__add__.i16", i16, self, _other) + @func(inline='always') + def __radd__(self, _other: tp.Union['i16', int]) -> 'i16': return intrinsic("binop.__radd__.i16", i16, self, _other) + @func(inline='always') + def __iadd__(self, _other: tp.Union['i16', int]) -> 'i16': return intrinsic("binop.__iadd__.i16", i16, byref(self), _other) + @func(inline='always') + def __sub__(self, _other: tp.Union['i16', int]) -> 'i16': return intrinsic("binop.__sub__.i16", i16, self, _other) + @func(inline='always') + def __rsub__(self, _other: tp.Union['i16', int]) -> 'i16': return intrinsic("binop.__rsub__.i16", i16, self, _other) + @func(inline='always') + def __isub__(self, _other: tp.Union['i16', int]) -> 'i16': return intrinsic("binop.__isub__.i16", i16, byref(self), _other) + @func(inline='always') + def __mul__(self, _other: tp.Union['i16', int]) -> 'i16': return intrinsic("binop.__mul__.i16", i16, self, _other) + @func(inline='always') + def __rmul__(self, _other: tp.Union['i16', int]) -> 'i16': return intrinsic("binop.__rmul__.i16", i16, self, _other) + @func(inline='always') + def __imul__(self, _other: tp.Union['i16', int]) -> 'i16': return intrinsic("binop.__imul__.i16", i16, byref(self), _other) + @func(inline='always') + def __mod__(self, _other: tp.Union['i16', int]) -> 'i16': return intrinsic("binop.__mod__.i16", i16, self, _other) + @func(inline='always') + def __rmod__(self, _other: tp.Union['i16', int]) -> 'i16': return intrinsic("binop.__rmod__.i16", i16, self, _other) + @func(inline='always') + def __imod__(self, _other: tp.Union['i16', int]) -> 'i16': return intrinsic("binop.__imod__.i16", i16, byref(self), _other) + @func(inline='always') + def __lt__(self, _other: tp.Union['i16', int]) -> 'bool': return intrinsic("cmp.__lt__.i16", bool, self, _other) # type: ignore[override] + @func(inline='always') + def __le__(self, _other: tp.Union['i16', int]) -> 'bool': return intrinsic("cmp.__le__.i16", bool, self, _other) # type: ignore[override] + @func(inline='always') + def __gt__(self, _other: tp.Union['i16', int]) -> 'bool': return intrinsic("cmp.__gt__.i16", bool, self, _other) # type: ignore[override] + @func(inline='always') + def __ge__(self, _other: tp.Union['i16', int]) -> 'bool': return intrinsic("cmp.__ge__.i16", bool, self, _other) # type: ignore[override] + @func(inline='always') + def __eq__(self, _other: tp.Union['i16', int]) -> 'bool': return intrinsic("cmp.__eq__.i16", bool, self, _other) # type: ignore[override] + @func(inline='always') + def __ne__(self, _other: tp.Union['i16', int]) -> 'bool': return intrinsic("cmp.__ne__.i16", bool, self, _other) # type: ignore[override] + @func(inline='always') + def __floordiv__(self, _other: tp.Union['i16', int]) -> 'i16': return intrinsic("binop.__floordiv__.i16", i16, self, _other) + @func(inline='always') + def __rfloordiv__(self, _other: tp.Union['i16', int]) -> 'i16': return intrinsic("binop.__rfloordiv__.i16", i16, self, _other) + @func(inline='always') + def __ifloordiv__(self, _other: tp.Union['i16', int]) -> 'i16': return intrinsic("binop.__ifloordiv__.i16", i16, byref(self), _other) + @func(inline='always') + def __lshift__(self, _other: tp.Union['i16', int]) -> 'i16': return intrinsic("binop.__lshift__.i16", i16, self, _other) + @func(inline='always') + def __rlshift__(self, _other: tp.Union['i16', int]) -> 'i16': return intrinsic("binop.__rlshift__.i16", i16, self, _other) + @func(inline='always') + def __ilshift__(self, _other: tp.Union['i16', int]) -> 'i16': return intrinsic("binop.__ilshift__.i16", i16, byref(self), _other) + @func(inline='always') + def __rshift__(self, _other: tp.Union['i16', int]) -> 'i16': return intrinsic("binop.__rshift__.i16", i16, self, _other) + @func(inline='always') + def __rrshift__(self, _other: tp.Union['i16', int]) -> 'i16': return intrinsic("binop.__rrshift__.i16", i16, self, _other) + @func(inline='always') + def __irshift__(self, _other: tp.Union['i16', int]) -> 'i16': return intrinsic("binop.__irshift__.i16", i16, byref(self), _other) + @func(inline='always') + def __and__(self, _other: tp.Union['i16', int]) -> 'i16': return intrinsic("binop.__and__.i16", i16, self, _other) + @func(inline='always') + def __rand__(self, _other: tp.Union['i16', int]) -> 'i16': return intrinsic("binop.__rand__.i16", i16, self, _other) + @func(inline='always') + def __iand__(self, _other: tp.Union['i16', int]) -> 'i16': return intrinsic("binop.__iand__.i16", i16, byref(self), _other) + @func(inline='always') + def __or__(self, _other: tp.Union['i16', int]) -> 'i16': return intrinsic("binop.__or__.i16", i16, self, _other) + @func(inline='always') + def __ror__(self, _other: tp.Union['i16', int]) -> 'i16': return intrinsic("binop.__ror__.i16", i16, self, _other) + @func(inline='always') + def __ior__(self, _other: tp.Union['i16', int]) -> 'i16': return intrinsic("binop.__ior__.i16", i16, byref(self), _other) + @func(inline='always') + def __xor__(self, _other: tp.Union['i16', int]) -> 'i16': return intrinsic("binop.__xor__.i16", i16, self, _other) + @func(inline='always') + def __rxor__(self, _other: tp.Union['i16', int]) -> 'i16': return intrinsic("binop.__rxor__.i16", i16, self, _other) + @func(inline='always') + def __ixor__(self, _other: tp.Union['i16', int]) -> 'i16': return intrinsic("binop.__ixor__.i16", i16, byref(self), _other) + @func(inline='always') + def __neg__(self) -> 'i16': return intrinsic("unary.__neg__.i16", i16, self) + @func(inline='always') + def __pos__(self) -> 'i16': return intrinsic("unary.__pos__.i16", i16, self) + @func(inline='always') + def __invert__(self) -> 'i16': return intrinsic("unary.__invert__.i16", i16, self) @builtin_type(_hir.IntType(16, False)) class u16: + @func(inline='always') def __init__(self, _value: tp.Union['u16', int]) -> None: self = intrinsic("init.u16", u16, _value) - def __add__(self, _other: tp.Union['u16', int]) -> 'u16': return intrinsic("binop.__add__.u16", u16, _other) - def __radd__(self, _other: tp.Union['u16', int]) -> 'u16': return intrinsic("binop.__radd__.u16", u16, _other) - def __iadd__(self, _other: tp.Union['u16', int]) -> 'u16': return intrinsic("binop.__iadd__.u16", u16, _other) - def __sub__(self, _other: tp.Union['u16', int]) -> 'u16': return intrinsic("binop.__sub__.u16", u16, _other) - def __rsub__(self, _other: tp.Union['u16', int]) -> 'u16': return intrinsic("binop.__rsub__.u16", u16, _other) - def __isub__(self, _other: tp.Union['u16', int]) -> 'u16': return intrinsic("binop.__isub__.u16", u16, _other) - def __mul__(self, _other: tp.Union['u16', int]) -> 'u16': return intrinsic("binop.__mul__.u16", u16, _other) - def __rmul__(self, _other: tp.Union['u16', int]) -> 'u16': return intrinsic("binop.__rmul__.u16", u16, _other) - def __imul__(self, _other: tp.Union['u16', int]) -> 'u16': return intrinsic("binop.__imul__.u16", u16, _other) - def __mod__(self, _other: tp.Union['u16', int]) -> 'u16': return intrinsic("binop.__mod__.u16", u16, _other) - def __rmod__(self, _other: tp.Union['u16', int]) -> 'u16': return intrinsic("binop.__rmod__.u16", u16, _other) - def __imod__(self, _other: tp.Union['u16', int]) -> 'u16': return intrinsic("binop.__imod__.u16", u16, _other) - def __lt__(self, _other: tp.Union['u16', int]) -> 'bool': return intrinsic("cmp.__lt__.u16", bool, _other) # type: ignore[override] - def __le__(self, _other: tp.Union['u16', int]) -> 'bool': return intrinsic("cmp.__le__.u16", bool, _other) # type: ignore[override] - def __gt__(self, _other: tp.Union['u16', int]) -> 'bool': return intrinsic("cmp.__gt__.u16", bool, _other) # type: ignore[override] - def __ge__(self, _other: tp.Union['u16', int]) -> 'bool': return intrinsic("cmp.__ge__.u16", bool, _other) # type: ignore[override] - def __eq__(self, _other: tp.Union['u16', int]) -> 'bool': return intrinsic("cmp.__eq__.u16", bool, _other) # type: ignore[override] - def __ne__(self, _other: tp.Union['u16', int]) -> 'bool': return intrinsic("cmp.__ne__.u16", bool, _other) # type: ignore[override] - def __floordiv__(self, _other: tp.Union['u16', int]) -> 'u16': return intrinsic("binop.__floordiv__.u16", u16, _other) - def __rfloordiv__(self, _other: tp.Union['u16', int]) -> 'u16': return intrinsic("binop.__rfloordiv__.u16", u16, _other) - def __ifloordiv__(self, _other: tp.Union['u16', int]) -> 'u16': return intrinsic("binop.__ifloordiv__.u16", u16, _other) - def __lshift__(self, _other: tp.Union['u16', int]) -> 'u16': return intrinsic("binop.__lshift__.u16", u16, _other) - def __rlshift__(self, _other: tp.Union['u16', int]) -> 'u16': return intrinsic("binop.__rlshift__.u16", u16, _other) - def __ilshift__(self, _other: tp.Union['u16', int]) -> 'u16': return intrinsic("binop.__ilshift__.u16", u16, _other) - def __rshift__(self, _other: tp.Union['u16', int]) -> 'u16': return intrinsic("binop.__rshift__.u16", u16, _other) - def __rrshift__(self, _other: tp.Union['u16', int]) -> 'u16': return intrinsic("binop.__rrshift__.u16", u16, _other) - def __irshift__(self, _other: tp.Union['u16', int]) -> 'u16': return intrinsic("binop.__irshift__.u16", u16, _other) - def __and__(self, _other: tp.Union['u16', int]) -> 'u16': return intrinsic("binop.__and__.u16", u16, _other) - def __rand__(self, _other: tp.Union['u16', int]) -> 'u16': return intrinsic("binop.__rand__.u16", u16, _other) - def __iand__(self, _other: tp.Union['u16', int]) -> 'u16': return intrinsic("binop.__iand__.u16", u16, _other) - def __or__(self, _other: tp.Union['u16', int]) -> 'u16': return intrinsic("binop.__or__.u16", u16, _other) - def __ror__(self, _other: tp.Union['u16', int]) -> 'u16': return intrinsic("binop.__ror__.u16", u16, _other) - def __ior__(self, _other: tp.Union['u16', int]) -> 'u16': return intrinsic("binop.__ior__.u16", u16, _other) - def __xor__(self, _other: tp.Union['u16', int]) -> 'u16': return intrinsic("binop.__xor__.u16", u16, _other) - def __rxor__(self, _other: tp.Union['u16', int]) -> 'u16': return intrinsic("binop.__rxor__.u16", u16, _other) - def __ixor__(self, _other: tp.Union['u16', int]) -> 'u16': return intrinsic("binop.__ixor__.u16", u16, _other) - def __neg__(self) -> 'u16': return intrinsic("unary.neg.u16", u16) - def __pos__(self) -> 'u16': return intrinsic("unary.pos.u16", u16) - def __invert__(self) -> 'u16': return intrinsic("unary.invert.u16", u16) + @func(inline='always') + def __add__(self, _other: tp.Union['u16', int]) -> 'u16': return intrinsic("binop.__add__.u16", u16, self, _other) + @func(inline='always') + def __radd__(self, _other: tp.Union['u16', int]) -> 'u16': return intrinsic("binop.__radd__.u16", u16, self, _other) + @func(inline='always') + def __iadd__(self, _other: tp.Union['u16', int]) -> 'u16': return intrinsic("binop.__iadd__.u16", u16, byref(self), _other) + @func(inline='always') + def __sub__(self, _other: tp.Union['u16', int]) -> 'u16': return intrinsic("binop.__sub__.u16", u16, self, _other) + @func(inline='always') + def __rsub__(self, _other: tp.Union['u16', int]) -> 'u16': return intrinsic("binop.__rsub__.u16", u16, self, _other) + @func(inline='always') + def __isub__(self, _other: tp.Union['u16', int]) -> 'u16': return intrinsic("binop.__isub__.u16", u16, byref(self), _other) + @func(inline='always') + def __mul__(self, _other: tp.Union['u16', int]) -> 'u16': return intrinsic("binop.__mul__.u16", u16, self, _other) + @func(inline='always') + def __rmul__(self, _other: tp.Union['u16', int]) -> 'u16': return intrinsic("binop.__rmul__.u16", u16, self, _other) + @func(inline='always') + def __imul__(self, _other: tp.Union['u16', int]) -> 'u16': return intrinsic("binop.__imul__.u16", u16, byref(self), _other) + @func(inline='always') + def __mod__(self, _other: tp.Union['u16', int]) -> 'u16': return intrinsic("binop.__mod__.u16", u16, self, _other) + @func(inline='always') + def __rmod__(self, _other: tp.Union['u16', int]) -> 'u16': return intrinsic("binop.__rmod__.u16", u16, self, _other) + @func(inline='always') + def __imod__(self, _other: tp.Union['u16', int]) -> 'u16': return intrinsic("binop.__imod__.u16", u16, byref(self), _other) + @func(inline='always') + def __lt__(self, _other: tp.Union['u16', int]) -> 'bool': return intrinsic("cmp.__lt__.u16", bool, self, _other) # type: ignore[override] + @func(inline='always') + def __le__(self, _other: tp.Union['u16', int]) -> 'bool': return intrinsic("cmp.__le__.u16", bool, self, _other) # type: ignore[override] + @func(inline='always') + def __gt__(self, _other: tp.Union['u16', int]) -> 'bool': return intrinsic("cmp.__gt__.u16", bool, self, _other) # type: ignore[override] + @func(inline='always') + def __ge__(self, _other: tp.Union['u16', int]) -> 'bool': return intrinsic("cmp.__ge__.u16", bool, self, _other) # type: ignore[override] + @func(inline='always') + def __eq__(self, _other: tp.Union['u16', int]) -> 'bool': return intrinsic("cmp.__eq__.u16", bool, self, _other) # type: ignore[override] + @func(inline='always') + def __ne__(self, _other: tp.Union['u16', int]) -> 'bool': return intrinsic("cmp.__ne__.u16", bool, self, _other) # type: ignore[override] + @func(inline='always') + def __floordiv__(self, _other: tp.Union['u16', int]) -> 'u16': return intrinsic("binop.__floordiv__.u16", u16, self, _other) + @func(inline='always') + def __rfloordiv__(self, _other: tp.Union['u16', int]) -> 'u16': return intrinsic("binop.__rfloordiv__.u16", u16, self, _other) + @func(inline='always') + def __ifloordiv__(self, _other: tp.Union['u16', int]) -> 'u16': return intrinsic("binop.__ifloordiv__.u16", u16, byref(self), _other) + @func(inline='always') + def __lshift__(self, _other: tp.Union['u16', int]) -> 'u16': return intrinsic("binop.__lshift__.u16", u16, self, _other) + @func(inline='always') + def __rlshift__(self, _other: tp.Union['u16', int]) -> 'u16': return intrinsic("binop.__rlshift__.u16", u16, self, _other) + @func(inline='always') + def __ilshift__(self, _other: tp.Union['u16', int]) -> 'u16': return intrinsic("binop.__ilshift__.u16", u16, byref(self), _other) + @func(inline='always') + def __rshift__(self, _other: tp.Union['u16', int]) -> 'u16': return intrinsic("binop.__rshift__.u16", u16, self, _other) + @func(inline='always') + def __rrshift__(self, _other: tp.Union['u16', int]) -> 'u16': return intrinsic("binop.__rrshift__.u16", u16, self, _other) + @func(inline='always') + def __irshift__(self, _other: tp.Union['u16', int]) -> 'u16': return intrinsic("binop.__irshift__.u16", u16, byref(self), _other) + @func(inline='always') + def __and__(self, _other: tp.Union['u16', int]) -> 'u16': return intrinsic("binop.__and__.u16", u16, self, _other) + @func(inline='always') + def __rand__(self, _other: tp.Union['u16', int]) -> 'u16': return intrinsic("binop.__rand__.u16", u16, self, _other) + @func(inline='always') + def __iand__(self, _other: tp.Union['u16', int]) -> 'u16': return intrinsic("binop.__iand__.u16", u16, byref(self), _other) + @func(inline='always') + def __or__(self, _other: tp.Union['u16', int]) -> 'u16': return intrinsic("binop.__or__.u16", u16, self, _other) + @func(inline='always') + def __ror__(self, _other: tp.Union['u16', int]) -> 'u16': return intrinsic("binop.__ror__.u16", u16, self, _other) + @func(inline='always') + def __ior__(self, _other: tp.Union['u16', int]) -> 'u16': return intrinsic("binop.__ior__.u16", u16, byref(self), _other) + @func(inline='always') + def __xor__(self, _other: tp.Union['u16', int]) -> 'u16': return intrinsic("binop.__xor__.u16", u16, self, _other) + @func(inline='always') + def __rxor__(self, _other: tp.Union['u16', int]) -> 'u16': return intrinsic("binop.__rxor__.u16", u16, self, _other) + @func(inline='always') + def __ixor__(self, _other: tp.Union['u16', int]) -> 'u16': return intrinsic("binop.__ixor__.u16", u16, byref(self), _other) + @func(inline='always') + def __neg__(self) -> 'u16': return intrinsic("unary.__neg__.u16", u16, self) + @func(inline='always') + def __pos__(self) -> 'u16': return intrinsic("unary.__pos__.u16", u16, self) + @func(inline='always') + def __invert__(self) -> 'u16': return intrinsic("unary.__invert__.u16", u16, self) @builtin_type(_hir.IntType(32, True)) class i32: + @func(inline='always') def __init__(self, _value: tp.Union['i32', int]) -> None: self = intrinsic("init.i32", i32, _value) - def __add__(self, _other: tp.Union['i32', int]) -> 'i32': return intrinsic("binop.__add__.i32", i32, _other) - def __radd__(self, _other: tp.Union['i32', int]) -> 'i32': return intrinsic("binop.__radd__.i32", i32, _other) - def __iadd__(self, _other: tp.Union['i32', int]) -> 'i32': return intrinsic("binop.__iadd__.i32", i32, _other) - def __sub__(self, _other: tp.Union['i32', int]) -> 'i32': return intrinsic("binop.__sub__.i32", i32, _other) - def __rsub__(self, _other: tp.Union['i32', int]) -> 'i32': return intrinsic("binop.__rsub__.i32", i32, _other) - def __isub__(self, _other: tp.Union['i32', int]) -> 'i32': return intrinsic("binop.__isub__.i32", i32, _other) - def __mul__(self, _other: tp.Union['i32', int]) -> 'i32': return intrinsic("binop.__mul__.i32", i32, _other) - def __rmul__(self, _other: tp.Union['i32', int]) -> 'i32': return intrinsic("binop.__rmul__.i32", i32, _other) - def __imul__(self, _other: tp.Union['i32', int]) -> 'i32': return intrinsic("binop.__imul__.i32", i32, _other) - def __mod__(self, _other: tp.Union['i32', int]) -> 'i32': return intrinsic("binop.__mod__.i32", i32, _other) - def __rmod__(self, _other: tp.Union['i32', int]) -> 'i32': return intrinsic("binop.__rmod__.i32", i32, _other) - def __imod__(self, _other: tp.Union['i32', int]) -> 'i32': return intrinsic("binop.__imod__.i32", i32, _other) - def __lt__(self, _other: tp.Union['i32', int]) -> 'bool': return intrinsic("cmp.__lt__.i32", bool, _other) # type: ignore[override] - def __le__(self, _other: tp.Union['i32', int]) -> 'bool': return intrinsic("cmp.__le__.i32", bool, _other) # type: ignore[override] - def __gt__(self, _other: tp.Union['i32', int]) -> 'bool': return intrinsic("cmp.__gt__.i32", bool, _other) # type: ignore[override] - def __ge__(self, _other: tp.Union['i32', int]) -> 'bool': return intrinsic("cmp.__ge__.i32", bool, _other) # type: ignore[override] - def __eq__(self, _other: tp.Union['i32', int]) -> 'bool': return intrinsic("cmp.__eq__.i32", bool, _other) # type: ignore[override] - def __ne__(self, _other: tp.Union['i32', int]) -> 'bool': return intrinsic("cmp.__ne__.i32", bool, _other) # type: ignore[override] - def __floordiv__(self, _other: tp.Union['i32', int]) -> 'i32': return intrinsic("binop.__floordiv__.i32", i32, _other) - def __rfloordiv__(self, _other: tp.Union['i32', int]) -> 'i32': return intrinsic("binop.__rfloordiv__.i32", i32, _other) - def __ifloordiv__(self, _other: tp.Union['i32', int]) -> 'i32': return intrinsic("binop.__ifloordiv__.i32", i32, _other) - def __lshift__(self, _other: tp.Union['i32', int]) -> 'i32': return intrinsic("binop.__lshift__.i32", i32, _other) - def __rlshift__(self, _other: tp.Union['i32', int]) -> 'i32': return intrinsic("binop.__rlshift__.i32", i32, _other) - def __ilshift__(self, _other: tp.Union['i32', int]) -> 'i32': return intrinsic("binop.__ilshift__.i32", i32, _other) - def __rshift__(self, _other: tp.Union['i32', int]) -> 'i32': return intrinsic("binop.__rshift__.i32", i32, _other) - def __rrshift__(self, _other: tp.Union['i32', int]) -> 'i32': return intrinsic("binop.__rrshift__.i32", i32, _other) - def __irshift__(self, _other: tp.Union['i32', int]) -> 'i32': return intrinsic("binop.__irshift__.i32", i32, _other) - def __and__(self, _other: tp.Union['i32', int]) -> 'i32': return intrinsic("binop.__and__.i32", i32, _other) - def __rand__(self, _other: tp.Union['i32', int]) -> 'i32': return intrinsic("binop.__rand__.i32", i32, _other) - def __iand__(self, _other: tp.Union['i32', int]) -> 'i32': return intrinsic("binop.__iand__.i32", i32, _other) - def __or__(self, _other: tp.Union['i32', int]) -> 'i32': return intrinsic("binop.__or__.i32", i32, _other) - def __ror__(self, _other: tp.Union['i32', int]) -> 'i32': return intrinsic("binop.__ror__.i32", i32, _other) - def __ior__(self, _other: tp.Union['i32', int]) -> 'i32': return intrinsic("binop.__ior__.i32", i32, _other) - def __xor__(self, _other: tp.Union['i32', int]) -> 'i32': return intrinsic("binop.__xor__.i32", i32, _other) - def __rxor__(self, _other: tp.Union['i32', int]) -> 'i32': return intrinsic("binop.__rxor__.i32", i32, _other) - def __ixor__(self, _other: tp.Union['i32', int]) -> 'i32': return intrinsic("binop.__ixor__.i32", i32, _other) - def __neg__(self) -> 'i32': return intrinsic("unary.neg.i32", i32) - def __pos__(self) -> 'i32': return intrinsic("unary.pos.i32", i32) - def __invert__(self) -> 'i32': return intrinsic("unary.invert.i32", i32) + @func(inline='always') + def __add__(self, _other: tp.Union['i32', int]) -> 'i32': return intrinsic("binop.__add__.i32", i32, self, _other) + @func(inline='always') + def __radd__(self, _other: tp.Union['i32', int]) -> 'i32': return intrinsic("binop.__radd__.i32", i32, self, _other) + @func(inline='always') + def __iadd__(self, _other: tp.Union['i32', int]) -> 'i32': return intrinsic("binop.__iadd__.i32", i32, byref(self), _other) + @func(inline='always') + def __sub__(self, _other: tp.Union['i32', int]) -> 'i32': return intrinsic("binop.__sub__.i32", i32, self, _other) + @func(inline='always') + def __rsub__(self, _other: tp.Union['i32', int]) -> 'i32': return intrinsic("binop.__rsub__.i32", i32, self, _other) + @func(inline='always') + def __isub__(self, _other: tp.Union['i32', int]) -> 'i32': return intrinsic("binop.__isub__.i32", i32, byref(self), _other) + @func(inline='always') + def __mul__(self, _other: tp.Union['i32', int]) -> 'i32': return intrinsic("binop.__mul__.i32", i32, self, _other) + @func(inline='always') + def __rmul__(self, _other: tp.Union['i32', int]) -> 'i32': return intrinsic("binop.__rmul__.i32", i32, self, _other) + @func(inline='always') + def __imul__(self, _other: tp.Union['i32', int]) -> 'i32': return intrinsic("binop.__imul__.i32", i32, byref(self), _other) + @func(inline='always') + def __mod__(self, _other: tp.Union['i32', int]) -> 'i32': return intrinsic("binop.__mod__.i32", i32, self, _other) + @func(inline='always') + def __rmod__(self, _other: tp.Union['i32', int]) -> 'i32': return intrinsic("binop.__rmod__.i32", i32, self, _other) + @func(inline='always') + def __imod__(self, _other: tp.Union['i32', int]) -> 'i32': return intrinsic("binop.__imod__.i32", i32, byref(self), _other) + @func(inline='always') + def __lt__(self, _other: tp.Union['i32', int]) -> 'bool': return intrinsic("cmp.__lt__.i32", bool, self, _other) # type: ignore[override] + @func(inline='always') + def __le__(self, _other: tp.Union['i32', int]) -> 'bool': return intrinsic("cmp.__le__.i32", bool, self, _other) # type: ignore[override] + @func(inline='always') + def __gt__(self, _other: tp.Union['i32', int]) -> 'bool': return intrinsic("cmp.__gt__.i32", bool, self, _other) # type: ignore[override] + @func(inline='always') + def __ge__(self, _other: tp.Union['i32', int]) -> 'bool': return intrinsic("cmp.__ge__.i32", bool, self, _other) # type: ignore[override] + @func(inline='always') + def __eq__(self, _other: tp.Union['i32', int]) -> 'bool': return intrinsic("cmp.__eq__.i32", bool, self, _other) # type: ignore[override] + @func(inline='always') + def __ne__(self, _other: tp.Union['i32', int]) -> 'bool': return intrinsic("cmp.__ne__.i32", bool, self, _other) # type: ignore[override] + @func(inline='always') + def __floordiv__(self, _other: tp.Union['i32', int]) -> 'i32': return intrinsic("binop.__floordiv__.i32", i32, self, _other) + @func(inline='always') + def __rfloordiv__(self, _other: tp.Union['i32', int]) -> 'i32': return intrinsic("binop.__rfloordiv__.i32", i32, self, _other) + @func(inline='always') + def __ifloordiv__(self, _other: tp.Union['i32', int]) -> 'i32': return intrinsic("binop.__ifloordiv__.i32", i32, byref(self), _other) + @func(inline='always') + def __lshift__(self, _other: tp.Union['i32', int]) -> 'i32': return intrinsic("binop.__lshift__.i32", i32, self, _other) + @func(inline='always') + def __rlshift__(self, _other: tp.Union['i32', int]) -> 'i32': return intrinsic("binop.__rlshift__.i32", i32, self, _other) + @func(inline='always') + def __ilshift__(self, _other: tp.Union['i32', int]) -> 'i32': return intrinsic("binop.__ilshift__.i32", i32, byref(self), _other) + @func(inline='always') + def __rshift__(self, _other: tp.Union['i32', int]) -> 'i32': return intrinsic("binop.__rshift__.i32", i32, self, _other) + @func(inline='always') + def __rrshift__(self, _other: tp.Union['i32', int]) -> 'i32': return intrinsic("binop.__rrshift__.i32", i32, self, _other) + @func(inline='always') + def __irshift__(self, _other: tp.Union['i32', int]) -> 'i32': return intrinsic("binop.__irshift__.i32", i32, byref(self), _other) + @func(inline='always') + def __and__(self, _other: tp.Union['i32', int]) -> 'i32': return intrinsic("binop.__and__.i32", i32, self, _other) + @func(inline='always') + def __rand__(self, _other: tp.Union['i32', int]) -> 'i32': return intrinsic("binop.__rand__.i32", i32, self, _other) + @func(inline='always') + def __iand__(self, _other: tp.Union['i32', int]) -> 'i32': return intrinsic("binop.__iand__.i32", i32, byref(self), _other) + @func(inline='always') + def __or__(self, _other: tp.Union['i32', int]) -> 'i32': return intrinsic("binop.__or__.i32", i32, self, _other) + @func(inline='always') + def __ror__(self, _other: tp.Union['i32', int]) -> 'i32': return intrinsic("binop.__ror__.i32", i32, self, _other) + @func(inline='always') + def __ior__(self, _other: tp.Union['i32', int]) -> 'i32': return intrinsic("binop.__ior__.i32", i32, byref(self), _other) + @func(inline='always') + def __xor__(self, _other: tp.Union['i32', int]) -> 'i32': return intrinsic("binop.__xor__.i32", i32, self, _other) + @func(inline='always') + def __rxor__(self, _other: tp.Union['i32', int]) -> 'i32': return intrinsic("binop.__rxor__.i32", i32, self, _other) + @func(inline='always') + def __ixor__(self, _other: tp.Union['i32', int]) -> 'i32': return intrinsic("binop.__ixor__.i32", i32, byref(self), _other) + @func(inline='always') + def __neg__(self) -> 'i32': return intrinsic("unary.__neg__.i32", i32, self) + @func(inline='always') + def __pos__(self) -> 'i32': return intrinsic("unary.__pos__.i32", i32, self) + @func(inline='always') + def __invert__(self) -> 'i32': return intrinsic("unary.__invert__.i32", i32, self) @builtin_type(_hir.IntType(32, False)) class u32: + @func(inline='always') def __init__(self, _value: tp.Union['u32', int]) -> None: self = intrinsic("init.u32", u32, _value) - def __add__(self, _other: tp.Union['u32', int]) -> 'u32': return intrinsic("binop.__add__.u32", u32, _other) - def __radd__(self, _other: tp.Union['u32', int]) -> 'u32': return intrinsic("binop.__radd__.u32", u32, _other) - def __iadd__(self, _other: tp.Union['u32', int]) -> 'u32': return intrinsic("binop.__iadd__.u32", u32, _other) - def __sub__(self, _other: tp.Union['u32', int]) -> 'u32': return intrinsic("binop.__sub__.u32", u32, _other) - def __rsub__(self, _other: tp.Union['u32', int]) -> 'u32': return intrinsic("binop.__rsub__.u32", u32, _other) - def __isub__(self, _other: tp.Union['u32', int]) -> 'u32': return intrinsic("binop.__isub__.u32", u32, _other) - def __mul__(self, _other: tp.Union['u32', int]) -> 'u32': return intrinsic("binop.__mul__.u32", u32, _other) - def __rmul__(self, _other: tp.Union['u32', int]) -> 'u32': return intrinsic("binop.__rmul__.u32", u32, _other) - def __imul__(self, _other: tp.Union['u32', int]) -> 'u32': return intrinsic("binop.__imul__.u32", u32, _other) - def __mod__(self, _other: tp.Union['u32', int]) -> 'u32': return intrinsic("binop.__mod__.u32", u32, _other) - def __rmod__(self, _other: tp.Union['u32', int]) -> 'u32': return intrinsic("binop.__rmod__.u32", u32, _other) - def __imod__(self, _other: tp.Union['u32', int]) -> 'u32': return intrinsic("binop.__imod__.u32", u32, _other) - def __lt__(self, _other: tp.Union['u32', int]) -> 'bool': return intrinsic("cmp.__lt__.u32", bool, _other) # type: ignore[override] - def __le__(self, _other: tp.Union['u32', int]) -> 'bool': return intrinsic("cmp.__le__.u32", bool, _other) # type: ignore[override] - def __gt__(self, _other: tp.Union['u32', int]) -> 'bool': return intrinsic("cmp.__gt__.u32", bool, _other) # type: ignore[override] - def __ge__(self, _other: tp.Union['u32', int]) -> 'bool': return intrinsic("cmp.__ge__.u32", bool, _other) # type: ignore[override] - def __eq__(self, _other: tp.Union['u32', int]) -> 'bool': return intrinsic("cmp.__eq__.u32", bool, _other) # type: ignore[override] - def __ne__(self, _other: tp.Union['u32', int]) -> 'bool': return intrinsic("cmp.__ne__.u32", bool, _other) # type: ignore[override] - def __floordiv__(self, _other: tp.Union['u32', int]) -> 'u32': return intrinsic("binop.__floordiv__.u32", u32, _other) - def __rfloordiv__(self, _other: tp.Union['u32', int]) -> 'u32': return intrinsic("binop.__rfloordiv__.u32", u32, _other) - def __ifloordiv__(self, _other: tp.Union['u32', int]) -> 'u32': return intrinsic("binop.__ifloordiv__.u32", u32, _other) - def __lshift__(self, _other: tp.Union['u32', int]) -> 'u32': return intrinsic("binop.__lshift__.u32", u32, _other) - def __rlshift__(self, _other: tp.Union['u32', int]) -> 'u32': return intrinsic("binop.__rlshift__.u32", u32, _other) - def __ilshift__(self, _other: tp.Union['u32', int]) -> 'u32': return intrinsic("binop.__ilshift__.u32", u32, _other) - def __rshift__(self, _other: tp.Union['u32', int]) -> 'u32': return intrinsic("binop.__rshift__.u32", u32, _other) - def __rrshift__(self, _other: tp.Union['u32', int]) -> 'u32': return intrinsic("binop.__rrshift__.u32", u32, _other) - def __irshift__(self, _other: tp.Union['u32', int]) -> 'u32': return intrinsic("binop.__irshift__.u32", u32, _other) - def __and__(self, _other: tp.Union['u32', int]) -> 'u32': return intrinsic("binop.__and__.u32", u32, _other) - def __rand__(self, _other: tp.Union['u32', int]) -> 'u32': return intrinsic("binop.__rand__.u32", u32, _other) - def __iand__(self, _other: tp.Union['u32', int]) -> 'u32': return intrinsic("binop.__iand__.u32", u32, _other) - def __or__(self, _other: tp.Union['u32', int]) -> 'u32': return intrinsic("binop.__or__.u32", u32, _other) - def __ror__(self, _other: tp.Union['u32', int]) -> 'u32': return intrinsic("binop.__ror__.u32", u32, _other) - def __ior__(self, _other: tp.Union['u32', int]) -> 'u32': return intrinsic("binop.__ior__.u32", u32, _other) - def __xor__(self, _other: tp.Union['u32', int]) -> 'u32': return intrinsic("binop.__xor__.u32", u32, _other) - def __rxor__(self, _other: tp.Union['u32', int]) -> 'u32': return intrinsic("binop.__rxor__.u32", u32, _other) - def __ixor__(self, _other: tp.Union['u32', int]) -> 'u32': return intrinsic("binop.__ixor__.u32", u32, _other) - def __neg__(self) -> 'u32': return intrinsic("unary.neg.u32", u32) - def __pos__(self) -> 'u32': return intrinsic("unary.pos.u32", u32) - def __invert__(self) -> 'u32': return intrinsic("unary.invert.u32", u32) + @func(inline='always') + def __add__(self, _other: tp.Union['u32', int]) -> 'u32': return intrinsic("binop.__add__.u32", u32, self, _other) + @func(inline='always') + def __radd__(self, _other: tp.Union['u32', int]) -> 'u32': return intrinsic("binop.__radd__.u32", u32, self, _other) + @func(inline='always') + def __iadd__(self, _other: tp.Union['u32', int]) -> 'u32': return intrinsic("binop.__iadd__.u32", u32, byref(self), _other) + @func(inline='always') + def __sub__(self, _other: tp.Union['u32', int]) -> 'u32': return intrinsic("binop.__sub__.u32", u32, self, _other) + @func(inline='always') + def __rsub__(self, _other: tp.Union['u32', int]) -> 'u32': return intrinsic("binop.__rsub__.u32", u32, self, _other) + @func(inline='always') + def __isub__(self, _other: tp.Union['u32', int]) -> 'u32': return intrinsic("binop.__isub__.u32", u32, byref(self), _other) + @func(inline='always') + def __mul__(self, _other: tp.Union['u32', int]) -> 'u32': return intrinsic("binop.__mul__.u32", u32, self, _other) + @func(inline='always') + def __rmul__(self, _other: tp.Union['u32', int]) -> 'u32': return intrinsic("binop.__rmul__.u32", u32, self, _other) + @func(inline='always') + def __imul__(self, _other: tp.Union['u32', int]) -> 'u32': return intrinsic("binop.__imul__.u32", u32, byref(self), _other) + @func(inline='always') + def __mod__(self, _other: tp.Union['u32', int]) -> 'u32': return intrinsic("binop.__mod__.u32", u32, self, _other) + @func(inline='always') + def __rmod__(self, _other: tp.Union['u32', int]) -> 'u32': return intrinsic("binop.__rmod__.u32", u32, self, _other) + @func(inline='always') + def __imod__(self, _other: tp.Union['u32', int]) -> 'u32': return intrinsic("binop.__imod__.u32", u32, byref(self), _other) + @func(inline='always') + def __lt__(self, _other: tp.Union['u32', int]) -> 'bool': return intrinsic("cmp.__lt__.u32", bool, self, _other) # type: ignore[override] + @func(inline='always') + def __le__(self, _other: tp.Union['u32', int]) -> 'bool': return intrinsic("cmp.__le__.u32", bool, self, _other) # type: ignore[override] + @func(inline='always') + def __gt__(self, _other: tp.Union['u32', int]) -> 'bool': return intrinsic("cmp.__gt__.u32", bool, self, _other) # type: ignore[override] + @func(inline='always') + def __ge__(self, _other: tp.Union['u32', int]) -> 'bool': return intrinsic("cmp.__ge__.u32", bool, self, _other) # type: ignore[override] + @func(inline='always') + def __eq__(self, _other: tp.Union['u32', int]) -> 'bool': return intrinsic("cmp.__eq__.u32", bool, self, _other) # type: ignore[override] + @func(inline='always') + def __ne__(self, _other: tp.Union['u32', int]) -> 'bool': return intrinsic("cmp.__ne__.u32", bool, self, _other) # type: ignore[override] + @func(inline='always') + def __floordiv__(self, _other: tp.Union['u32', int]) -> 'u32': return intrinsic("binop.__floordiv__.u32", u32, self, _other) + @func(inline='always') + def __rfloordiv__(self, _other: tp.Union['u32', int]) -> 'u32': return intrinsic("binop.__rfloordiv__.u32", u32, self, _other) + @func(inline='always') + def __ifloordiv__(self, _other: tp.Union['u32', int]) -> 'u32': return intrinsic("binop.__ifloordiv__.u32", u32, byref(self), _other) + @func(inline='always') + def __lshift__(self, _other: tp.Union['u32', int]) -> 'u32': return intrinsic("binop.__lshift__.u32", u32, self, _other) + @func(inline='always') + def __rlshift__(self, _other: tp.Union['u32', int]) -> 'u32': return intrinsic("binop.__rlshift__.u32", u32, self, _other) + @func(inline='always') + def __ilshift__(self, _other: tp.Union['u32', int]) -> 'u32': return intrinsic("binop.__ilshift__.u32", u32, byref(self), _other) + @func(inline='always') + def __rshift__(self, _other: tp.Union['u32', int]) -> 'u32': return intrinsic("binop.__rshift__.u32", u32, self, _other) + @func(inline='always') + def __rrshift__(self, _other: tp.Union['u32', int]) -> 'u32': return intrinsic("binop.__rrshift__.u32", u32, self, _other) + @func(inline='always') + def __irshift__(self, _other: tp.Union['u32', int]) -> 'u32': return intrinsic("binop.__irshift__.u32", u32, byref(self), _other) + @func(inline='always') + def __and__(self, _other: tp.Union['u32', int]) -> 'u32': return intrinsic("binop.__and__.u32", u32, self, _other) + @func(inline='always') + def __rand__(self, _other: tp.Union['u32', int]) -> 'u32': return intrinsic("binop.__rand__.u32", u32, self, _other) + @func(inline='always') + def __iand__(self, _other: tp.Union['u32', int]) -> 'u32': return intrinsic("binop.__iand__.u32", u32, byref(self), _other) + @func(inline='always') + def __or__(self, _other: tp.Union['u32', int]) -> 'u32': return intrinsic("binop.__or__.u32", u32, self, _other) + @func(inline='always') + def __ror__(self, _other: tp.Union['u32', int]) -> 'u32': return intrinsic("binop.__ror__.u32", u32, self, _other) + @func(inline='always') + def __ior__(self, _other: tp.Union['u32', int]) -> 'u32': return intrinsic("binop.__ior__.u32", u32, byref(self), _other) + @func(inline='always') + def __xor__(self, _other: tp.Union['u32', int]) -> 'u32': return intrinsic("binop.__xor__.u32", u32, self, _other) + @func(inline='always') + def __rxor__(self, _other: tp.Union['u32', int]) -> 'u32': return intrinsic("binop.__rxor__.u32", u32, self, _other) + @func(inline='always') + def __ixor__(self, _other: tp.Union['u32', int]) -> 'u32': return intrinsic("binop.__ixor__.u32", u32, byref(self), _other) + @func(inline='always') + def __neg__(self) -> 'u32': return intrinsic("unary.__neg__.u32", u32, self) + @func(inline='always') + def __pos__(self) -> 'u32': return intrinsic("unary.__pos__.u32", u32, self) + @func(inline='always') + def __invert__(self) -> 'u32': return intrinsic("unary.__invert__.u32", u32, self) @builtin_type(_hir.IntType(64, True)) class i64: + @func(inline='always') def __init__(self, _value: tp.Union['i64', int]) -> None: self = intrinsic("init.i64", i64, _value) - def __add__(self, _other: tp.Union['i64', int]) -> 'i64': return intrinsic("binop.__add__.i64", i64, _other) - def __radd__(self, _other: tp.Union['i64', int]) -> 'i64': return intrinsic("binop.__radd__.i64", i64, _other) - def __iadd__(self, _other: tp.Union['i64', int]) -> 'i64': return intrinsic("binop.__iadd__.i64", i64, _other) - def __sub__(self, _other: tp.Union['i64', int]) -> 'i64': return intrinsic("binop.__sub__.i64", i64, _other) - def __rsub__(self, _other: tp.Union['i64', int]) -> 'i64': return intrinsic("binop.__rsub__.i64", i64, _other) - def __isub__(self, _other: tp.Union['i64', int]) -> 'i64': return intrinsic("binop.__isub__.i64", i64, _other) - def __mul__(self, _other: tp.Union['i64', int]) -> 'i64': return intrinsic("binop.__mul__.i64", i64, _other) - def __rmul__(self, _other: tp.Union['i64', int]) -> 'i64': return intrinsic("binop.__rmul__.i64", i64, _other) - def __imul__(self, _other: tp.Union['i64', int]) -> 'i64': return intrinsic("binop.__imul__.i64", i64, _other) - def __mod__(self, _other: tp.Union['i64', int]) -> 'i64': return intrinsic("binop.__mod__.i64", i64, _other) - def __rmod__(self, _other: tp.Union['i64', int]) -> 'i64': return intrinsic("binop.__rmod__.i64", i64, _other) - def __imod__(self, _other: tp.Union['i64', int]) -> 'i64': return intrinsic("binop.__imod__.i64", i64, _other) - def __lt__(self, _other: tp.Union['i64', int]) -> 'bool': return intrinsic("cmp.__lt__.i64", bool, _other) # type: ignore[override] - def __le__(self, _other: tp.Union['i64', int]) -> 'bool': return intrinsic("cmp.__le__.i64", bool, _other) # type: ignore[override] - def __gt__(self, _other: tp.Union['i64', int]) -> 'bool': return intrinsic("cmp.__gt__.i64", bool, _other) # type: ignore[override] - def __ge__(self, _other: tp.Union['i64', int]) -> 'bool': return intrinsic("cmp.__ge__.i64", bool, _other) # type: ignore[override] - def __eq__(self, _other: tp.Union['i64', int]) -> 'bool': return intrinsic("cmp.__eq__.i64", bool, _other) # type: ignore[override] - def __ne__(self, _other: tp.Union['i64', int]) -> 'bool': return intrinsic("cmp.__ne__.i64", bool, _other) # type: ignore[override] - def __floordiv__(self, _other: tp.Union['i64', int]) -> 'i64': return intrinsic("binop.__floordiv__.i64", i64, _other) - def __rfloordiv__(self, _other: tp.Union['i64', int]) -> 'i64': return intrinsic("binop.__rfloordiv__.i64", i64, _other) - def __ifloordiv__(self, _other: tp.Union['i64', int]) -> 'i64': return intrinsic("binop.__ifloordiv__.i64", i64, _other) - def __lshift__(self, _other: tp.Union['i64', int]) -> 'i64': return intrinsic("binop.__lshift__.i64", i64, _other) - def __rlshift__(self, _other: tp.Union['i64', int]) -> 'i64': return intrinsic("binop.__rlshift__.i64", i64, _other) - def __ilshift__(self, _other: tp.Union['i64', int]) -> 'i64': return intrinsic("binop.__ilshift__.i64", i64, _other) - def __rshift__(self, _other: tp.Union['i64', int]) -> 'i64': return intrinsic("binop.__rshift__.i64", i64, _other) - def __rrshift__(self, _other: tp.Union['i64', int]) -> 'i64': return intrinsic("binop.__rrshift__.i64", i64, _other) - def __irshift__(self, _other: tp.Union['i64', int]) -> 'i64': return intrinsic("binop.__irshift__.i64", i64, _other) - def __and__(self, _other: tp.Union['i64', int]) -> 'i64': return intrinsic("binop.__and__.i64", i64, _other) - def __rand__(self, _other: tp.Union['i64', int]) -> 'i64': return intrinsic("binop.__rand__.i64", i64, _other) - def __iand__(self, _other: tp.Union['i64', int]) -> 'i64': return intrinsic("binop.__iand__.i64", i64, _other) - def __or__(self, _other: tp.Union['i64', int]) -> 'i64': return intrinsic("binop.__or__.i64", i64, _other) - def __ror__(self, _other: tp.Union['i64', int]) -> 'i64': return intrinsic("binop.__ror__.i64", i64, _other) - def __ior__(self, _other: tp.Union['i64', int]) -> 'i64': return intrinsic("binop.__ior__.i64", i64, _other) - def __xor__(self, _other: tp.Union['i64', int]) -> 'i64': return intrinsic("binop.__xor__.i64", i64, _other) - def __rxor__(self, _other: tp.Union['i64', int]) -> 'i64': return intrinsic("binop.__rxor__.i64", i64, _other) - def __ixor__(self, _other: tp.Union['i64', int]) -> 'i64': return intrinsic("binop.__ixor__.i64", i64, _other) - def __neg__(self) -> 'i64': return intrinsic("unary.neg.i64", i64) - def __pos__(self) -> 'i64': return intrinsic("unary.pos.i64", i64) - def __invert__(self) -> 'i64': return intrinsic("unary.invert.i64", i64) + @func(inline='always') + def __add__(self, _other: tp.Union['i64', int]) -> 'i64': return intrinsic("binop.__add__.i64", i64, self, _other) + @func(inline='always') + def __radd__(self, _other: tp.Union['i64', int]) -> 'i64': return intrinsic("binop.__radd__.i64", i64, self, _other) + @func(inline='always') + def __iadd__(self, _other: tp.Union['i64', int]) -> 'i64': return intrinsic("binop.__iadd__.i64", i64, byref(self), _other) + @func(inline='always') + def __sub__(self, _other: tp.Union['i64', int]) -> 'i64': return intrinsic("binop.__sub__.i64", i64, self, _other) + @func(inline='always') + def __rsub__(self, _other: tp.Union['i64', int]) -> 'i64': return intrinsic("binop.__rsub__.i64", i64, self, _other) + @func(inline='always') + def __isub__(self, _other: tp.Union['i64', int]) -> 'i64': return intrinsic("binop.__isub__.i64", i64, byref(self), _other) + @func(inline='always') + def __mul__(self, _other: tp.Union['i64', int]) -> 'i64': return intrinsic("binop.__mul__.i64", i64, self, _other) + @func(inline='always') + def __rmul__(self, _other: tp.Union['i64', int]) -> 'i64': return intrinsic("binop.__rmul__.i64", i64, self, _other) + @func(inline='always') + def __imul__(self, _other: tp.Union['i64', int]) -> 'i64': return intrinsic("binop.__imul__.i64", i64, byref(self), _other) + @func(inline='always') + def __mod__(self, _other: tp.Union['i64', int]) -> 'i64': return intrinsic("binop.__mod__.i64", i64, self, _other) + @func(inline='always') + def __rmod__(self, _other: tp.Union['i64', int]) -> 'i64': return intrinsic("binop.__rmod__.i64", i64, self, _other) + @func(inline='always') + def __imod__(self, _other: tp.Union['i64', int]) -> 'i64': return intrinsic("binop.__imod__.i64", i64, byref(self), _other) + @func(inline='always') + def __lt__(self, _other: tp.Union['i64', int]) -> 'bool': return intrinsic("cmp.__lt__.i64", bool, self, _other) # type: ignore[override] + @func(inline='always') + def __le__(self, _other: tp.Union['i64', int]) -> 'bool': return intrinsic("cmp.__le__.i64", bool, self, _other) # type: ignore[override] + @func(inline='always') + def __gt__(self, _other: tp.Union['i64', int]) -> 'bool': return intrinsic("cmp.__gt__.i64", bool, self, _other) # type: ignore[override] + @func(inline='always') + def __ge__(self, _other: tp.Union['i64', int]) -> 'bool': return intrinsic("cmp.__ge__.i64", bool, self, _other) # type: ignore[override] + @func(inline='always') + def __eq__(self, _other: tp.Union['i64', int]) -> 'bool': return intrinsic("cmp.__eq__.i64", bool, self, _other) # type: ignore[override] + @func(inline='always') + def __ne__(self, _other: tp.Union['i64', int]) -> 'bool': return intrinsic("cmp.__ne__.i64", bool, self, _other) # type: ignore[override] + @func(inline='always') + def __floordiv__(self, _other: tp.Union['i64', int]) -> 'i64': return intrinsic("binop.__floordiv__.i64", i64, self, _other) + @func(inline='always') + def __rfloordiv__(self, _other: tp.Union['i64', int]) -> 'i64': return intrinsic("binop.__rfloordiv__.i64", i64, self, _other) + @func(inline='always') + def __ifloordiv__(self, _other: tp.Union['i64', int]) -> 'i64': return intrinsic("binop.__ifloordiv__.i64", i64, byref(self), _other) + @func(inline='always') + def __lshift__(self, _other: tp.Union['i64', int]) -> 'i64': return intrinsic("binop.__lshift__.i64", i64, self, _other) + @func(inline='always') + def __rlshift__(self, _other: tp.Union['i64', int]) -> 'i64': return intrinsic("binop.__rlshift__.i64", i64, self, _other) + @func(inline='always') + def __ilshift__(self, _other: tp.Union['i64', int]) -> 'i64': return intrinsic("binop.__ilshift__.i64", i64, byref(self), _other) + @func(inline='always') + def __rshift__(self, _other: tp.Union['i64', int]) -> 'i64': return intrinsic("binop.__rshift__.i64", i64, self, _other) + @func(inline='always') + def __rrshift__(self, _other: tp.Union['i64', int]) -> 'i64': return intrinsic("binop.__rrshift__.i64", i64, self, _other) + @func(inline='always') + def __irshift__(self, _other: tp.Union['i64', int]) -> 'i64': return intrinsic("binop.__irshift__.i64", i64, byref(self), _other) + @func(inline='always') + def __and__(self, _other: tp.Union['i64', int]) -> 'i64': return intrinsic("binop.__and__.i64", i64, self, _other) + @func(inline='always') + def __rand__(self, _other: tp.Union['i64', int]) -> 'i64': return intrinsic("binop.__rand__.i64", i64, self, _other) + @func(inline='always') + def __iand__(self, _other: tp.Union['i64', int]) -> 'i64': return intrinsic("binop.__iand__.i64", i64, byref(self), _other) + @func(inline='always') + def __or__(self, _other: tp.Union['i64', int]) -> 'i64': return intrinsic("binop.__or__.i64", i64, self, _other) + @func(inline='always') + def __ror__(self, _other: tp.Union['i64', int]) -> 'i64': return intrinsic("binop.__ror__.i64", i64, self, _other) + @func(inline='always') + def __ior__(self, _other: tp.Union['i64', int]) -> 'i64': return intrinsic("binop.__ior__.i64", i64, byref(self), _other) + @func(inline='always') + def __xor__(self, _other: tp.Union['i64', int]) -> 'i64': return intrinsic("binop.__xor__.i64", i64, self, _other) + @func(inline='always') + def __rxor__(self, _other: tp.Union['i64', int]) -> 'i64': return intrinsic("binop.__rxor__.i64", i64, self, _other) + @func(inline='always') + def __ixor__(self, _other: tp.Union['i64', int]) -> 'i64': return intrinsic("binop.__ixor__.i64", i64, byref(self), _other) + @func(inline='always') + def __neg__(self) -> 'i64': return intrinsic("unary.__neg__.i64", i64, self) + @func(inline='always') + def __pos__(self) -> 'i64': return intrinsic("unary.__pos__.i64", i64, self) + @func(inline='always') + def __invert__(self) -> 'i64': return intrinsic("unary.__invert__.i64", i64, self) @builtin_type(_hir.IntType(64, False)) class u64: + @func(inline='always') def __init__(self, _value: tp.Union['u64', int]) -> None: self = intrinsic("init.u64", u64, _value) - def __add__(self, _other: tp.Union['u64', int]) -> 'u64': return intrinsic("binop.__add__.u64", u64, _other) - def __radd__(self, _other: tp.Union['u64', int]) -> 'u64': return intrinsic("binop.__radd__.u64", u64, _other) - def __iadd__(self, _other: tp.Union['u64', int]) -> 'u64': return intrinsic("binop.__iadd__.u64", u64, _other) - def __sub__(self, _other: tp.Union['u64', int]) -> 'u64': return intrinsic("binop.__sub__.u64", u64, _other) - def __rsub__(self, _other: tp.Union['u64', int]) -> 'u64': return intrinsic("binop.__rsub__.u64", u64, _other) - def __isub__(self, _other: tp.Union['u64', int]) -> 'u64': return intrinsic("binop.__isub__.u64", u64, _other) - def __mul__(self, _other: tp.Union['u64', int]) -> 'u64': return intrinsic("binop.__mul__.u64", u64, _other) - def __rmul__(self, _other: tp.Union['u64', int]) -> 'u64': return intrinsic("binop.__rmul__.u64", u64, _other) - def __imul__(self, _other: tp.Union['u64', int]) -> 'u64': return intrinsic("binop.__imul__.u64", u64, _other) - def __mod__(self, _other: tp.Union['u64', int]) -> 'u64': return intrinsic("binop.__mod__.u64", u64, _other) - def __rmod__(self, _other: tp.Union['u64', int]) -> 'u64': return intrinsic("binop.__rmod__.u64", u64, _other) - def __imod__(self, _other: tp.Union['u64', int]) -> 'u64': return intrinsic("binop.__imod__.u64", u64, _other) - def __lt__(self, _other: tp.Union['u64', int]) -> 'bool': return intrinsic("cmp.__lt__.u64", bool, _other) # type: ignore[override] - def __le__(self, _other: tp.Union['u64', int]) -> 'bool': return intrinsic("cmp.__le__.u64", bool, _other) # type: ignore[override] - def __gt__(self, _other: tp.Union['u64', int]) -> 'bool': return intrinsic("cmp.__gt__.u64", bool, _other) # type: ignore[override] - def __ge__(self, _other: tp.Union['u64', int]) -> 'bool': return intrinsic("cmp.__ge__.u64", bool, _other) # type: ignore[override] - def __eq__(self, _other: tp.Union['u64', int]) -> 'bool': return intrinsic("cmp.__eq__.u64", bool, _other) # type: ignore[override] - def __ne__(self, _other: tp.Union['u64', int]) -> 'bool': return intrinsic("cmp.__ne__.u64", bool, _other) # type: ignore[override] - def __floordiv__(self, _other: tp.Union['u64', int]) -> 'u64': return intrinsic("binop.__floordiv__.u64", u64, _other) - def __rfloordiv__(self, _other: tp.Union['u64', int]) -> 'u64': return intrinsic("binop.__rfloordiv__.u64", u64, _other) - def __ifloordiv__(self, _other: tp.Union['u64', int]) -> 'u64': return intrinsic("binop.__ifloordiv__.u64", u64, _other) - def __lshift__(self, _other: tp.Union['u64', int]) -> 'u64': return intrinsic("binop.__lshift__.u64", u64, _other) - def __rlshift__(self, _other: tp.Union['u64', int]) -> 'u64': return intrinsic("binop.__rlshift__.u64", u64, _other) - def __ilshift__(self, _other: tp.Union['u64', int]) -> 'u64': return intrinsic("binop.__ilshift__.u64", u64, _other) - def __rshift__(self, _other: tp.Union['u64', int]) -> 'u64': return intrinsic("binop.__rshift__.u64", u64, _other) - def __rrshift__(self, _other: tp.Union['u64', int]) -> 'u64': return intrinsic("binop.__rrshift__.u64", u64, _other) - def __irshift__(self, _other: tp.Union['u64', int]) -> 'u64': return intrinsic("binop.__irshift__.u64", u64, _other) - def __and__(self, _other: tp.Union['u64', int]) -> 'u64': return intrinsic("binop.__and__.u64", u64, _other) - def __rand__(self, _other: tp.Union['u64', int]) -> 'u64': return intrinsic("binop.__rand__.u64", u64, _other) - def __iand__(self, _other: tp.Union['u64', int]) -> 'u64': return intrinsic("binop.__iand__.u64", u64, _other) - def __or__(self, _other: tp.Union['u64', int]) -> 'u64': return intrinsic("binop.__or__.u64", u64, _other) - def __ror__(self, _other: tp.Union['u64', int]) -> 'u64': return intrinsic("binop.__ror__.u64", u64, _other) - def __ior__(self, _other: tp.Union['u64', int]) -> 'u64': return intrinsic("binop.__ior__.u64", u64, _other) - def __xor__(self, _other: tp.Union['u64', int]) -> 'u64': return intrinsic("binop.__xor__.u64", u64, _other) - def __rxor__(self, _other: tp.Union['u64', int]) -> 'u64': return intrinsic("binop.__rxor__.u64", u64, _other) - def __ixor__(self, _other: tp.Union['u64', int]) -> 'u64': return intrinsic("binop.__ixor__.u64", u64, _other) - def __neg__(self) -> 'u64': return intrinsic("unary.neg.u64", u64) - def __pos__(self) -> 'u64': return intrinsic("unary.pos.u64", u64) - def __invert__(self) -> 'u64': return intrinsic("unary.invert.u64", u64) + @func(inline='always') + def __add__(self, _other: tp.Union['u64', int]) -> 'u64': return intrinsic("binop.__add__.u64", u64, self, _other) + @func(inline='always') + def __radd__(self, _other: tp.Union['u64', int]) -> 'u64': return intrinsic("binop.__radd__.u64", u64, self, _other) + @func(inline='always') + def __iadd__(self, _other: tp.Union['u64', int]) -> 'u64': return intrinsic("binop.__iadd__.u64", u64, byref(self), _other) + @func(inline='always') + def __sub__(self, _other: tp.Union['u64', int]) -> 'u64': return intrinsic("binop.__sub__.u64", u64, self, _other) + @func(inline='always') + def __rsub__(self, _other: tp.Union['u64', int]) -> 'u64': return intrinsic("binop.__rsub__.u64", u64, self, _other) + @func(inline='always') + def __isub__(self, _other: tp.Union['u64', int]) -> 'u64': return intrinsic("binop.__isub__.u64", u64, byref(self), _other) + @func(inline='always') + def __mul__(self, _other: tp.Union['u64', int]) -> 'u64': return intrinsic("binop.__mul__.u64", u64, self, _other) + @func(inline='always') + def __rmul__(self, _other: tp.Union['u64', int]) -> 'u64': return intrinsic("binop.__rmul__.u64", u64, self, _other) + @func(inline='always') + def __imul__(self, _other: tp.Union['u64', int]) -> 'u64': return intrinsic("binop.__imul__.u64", u64, byref(self), _other) + @func(inline='always') + def __mod__(self, _other: tp.Union['u64', int]) -> 'u64': return intrinsic("binop.__mod__.u64", u64, self, _other) + @func(inline='always') + def __rmod__(self, _other: tp.Union['u64', int]) -> 'u64': return intrinsic("binop.__rmod__.u64", u64, self, _other) + @func(inline='always') + def __imod__(self, _other: tp.Union['u64', int]) -> 'u64': return intrinsic("binop.__imod__.u64", u64, byref(self), _other) + @func(inline='always') + def __lt__(self, _other: tp.Union['u64', int]) -> 'bool': return intrinsic("cmp.__lt__.u64", bool, self, _other) # type: ignore[override] + @func(inline='always') + def __le__(self, _other: tp.Union['u64', int]) -> 'bool': return intrinsic("cmp.__le__.u64", bool, self, _other) # type: ignore[override] + @func(inline='always') + def __gt__(self, _other: tp.Union['u64', int]) -> 'bool': return intrinsic("cmp.__gt__.u64", bool, self, _other) # type: ignore[override] + @func(inline='always') + def __ge__(self, _other: tp.Union['u64', int]) -> 'bool': return intrinsic("cmp.__ge__.u64", bool, self, _other) # type: ignore[override] + @func(inline='always') + def __eq__(self, _other: tp.Union['u64', int]) -> 'bool': return intrinsic("cmp.__eq__.u64", bool, self, _other) # type: ignore[override] + @func(inline='always') + def __ne__(self, _other: tp.Union['u64', int]) -> 'bool': return intrinsic("cmp.__ne__.u64", bool, self, _other) # type: ignore[override] + @func(inline='always') + def __floordiv__(self, _other: tp.Union['u64', int]) -> 'u64': return intrinsic("binop.__floordiv__.u64", u64, self, _other) + @func(inline='always') + def __rfloordiv__(self, _other: tp.Union['u64', int]) -> 'u64': return intrinsic("binop.__rfloordiv__.u64", u64, self, _other) + @func(inline='always') + def __ifloordiv__(self, _other: tp.Union['u64', int]) -> 'u64': return intrinsic("binop.__ifloordiv__.u64", u64, byref(self), _other) + @func(inline='always') + def __lshift__(self, _other: tp.Union['u64', int]) -> 'u64': return intrinsic("binop.__lshift__.u64", u64, self, _other) + @func(inline='always') + def __rlshift__(self, _other: tp.Union['u64', int]) -> 'u64': return intrinsic("binop.__rlshift__.u64", u64, self, _other) + @func(inline='always') + def __ilshift__(self, _other: tp.Union['u64', int]) -> 'u64': return intrinsic("binop.__ilshift__.u64", u64, byref(self), _other) + @func(inline='always') + def __rshift__(self, _other: tp.Union['u64', int]) -> 'u64': return intrinsic("binop.__rshift__.u64", u64, self, _other) + @func(inline='always') + def __rrshift__(self, _other: tp.Union['u64', int]) -> 'u64': return intrinsic("binop.__rrshift__.u64", u64, self, _other) + @func(inline='always') + def __irshift__(self, _other: tp.Union['u64', int]) -> 'u64': return intrinsic("binop.__irshift__.u64", u64, byref(self), _other) + @func(inline='always') + def __and__(self, _other: tp.Union['u64', int]) -> 'u64': return intrinsic("binop.__and__.u64", u64, self, _other) + @func(inline='always') + def __rand__(self, _other: tp.Union['u64', int]) -> 'u64': return intrinsic("binop.__rand__.u64", u64, self, _other) + @func(inline='always') + def __iand__(self, _other: tp.Union['u64', int]) -> 'u64': return intrinsic("binop.__iand__.u64", u64, byref(self), _other) + @func(inline='always') + def __or__(self, _other: tp.Union['u64', int]) -> 'u64': return intrinsic("binop.__or__.u64", u64, self, _other) + @func(inline='always') + def __ror__(self, _other: tp.Union['u64', int]) -> 'u64': return intrinsic("binop.__ror__.u64", u64, self, _other) + @func(inline='always') + def __ior__(self, _other: tp.Union['u64', int]) -> 'u64': return intrinsic("binop.__ior__.u64", u64, byref(self), _other) + @func(inline='always') + def __xor__(self, _other: tp.Union['u64', int]) -> 'u64': return intrinsic("binop.__xor__.u64", u64, self, _other) + @func(inline='always') + def __rxor__(self, _other: tp.Union['u64', int]) -> 'u64': return intrinsic("binop.__rxor__.u64", u64, self, _other) + @func(inline='always') + def __ixor__(self, _other: tp.Union['u64', int]) -> 'u64': return intrinsic("binop.__ixor__.u64", u64, byref(self), _other) + @func(inline='always') + def __neg__(self) -> 'u64': return intrinsic("unary.__neg__.u64", u64, self) + @func(inline='always') + def __pos__(self) -> 'u64': return intrinsic("unary.__pos__.u64", u64, self) + @func(inline='always') + def __invert__(self) -> 'u64': return intrinsic("unary.__invert__.u64", u64, self) @builtin_type(_hir.VectorType(tp.cast(_hir.ScalarType, _ctx.types[bool]), 2)) class bool2: x: bool y: bool def __init__(self, x: tp.Union['bool', bool] = False, y: tp.Union['bool', bool] = False) -> None: self = intrinsic("init.bool2", bool2, x, y) - def __eq__(self, _other: tp.Union['bool2', bool, bool]) -> 'bool2': return intrinsic("cmp.__eq__.bool2", bool2, _other) # type: ignore[override] - def __ne__(self, _other: tp.Union['bool2', bool, bool]) -> 'bool2': return intrinsic("cmp.__ne__.bool2", bool2, _other) # type: ignore[override] - def __and__(self, _other: tp.Union['bool2', bool, bool]) -> 'bool2': return intrinsic("binop.__and__.bool2", bool2, _other) - def __rand__(self, _other: tp.Union['bool2', bool, bool]) -> 'bool2': return intrinsic("binop.__rand__.bool2", bool2, _other) - def __iand__(self, _other: tp.Union['bool2', bool, bool]) -> 'bool2': return intrinsic("binop.__iand__.bool2", bool2, _other) - def __or__(self, _other: tp.Union['bool2', bool, bool]) -> 'bool2': return intrinsic("binop.__or__.bool2", bool2, _other) - def __ror__(self, _other: tp.Union['bool2', bool, bool]) -> 'bool2': return intrinsic("binop.__ror__.bool2", bool2, _other) - def __ior__(self, _other: tp.Union['bool2', bool, bool]) -> 'bool2': return intrinsic("binop.__ior__.bool2", bool2, _other) - def __xor__(self, _other: tp.Union['bool2', bool, bool]) -> 'bool2': return intrinsic("binop.__xor__.bool2", bool2, _other) - def __rxor__(self, _other: tp.Union['bool2', bool, bool]) -> 'bool2': return intrinsic("binop.__rxor__.bool2", bool2, _other) - def __ixor__(self, _other: tp.Union['bool2', bool, bool]) -> 'bool2': return intrinsic("binop.__ixor__.bool2", bool2, _other) + @func(inline='always') + def __eq__(self, _other: tp.Union['bool2', bool, bool]) -> 'bool2': return intrinsic("cmp.__eq__.bool2", bool2, self, _other) # type: ignore[override] + @func(inline='always') + def __ne__(self, _other: tp.Union['bool2', bool, bool]) -> 'bool2': return intrinsic("cmp.__ne__.bool2", bool2, self, _other) # type: ignore[override] + @func(inline='always') + def __and__(self, _other: tp.Union['bool2', bool, bool]) -> 'bool2': return intrinsic("binop.__and__.bool2", bool2, self, _other) + @func(inline='always') + def __rand__(self, _other: tp.Union['bool2', bool, bool]) -> 'bool2': return intrinsic("binop.__rand__.bool2", bool2, self, _other) + @func(inline='always') + def __iand__(self, _other: tp.Union['bool2', bool, bool]) -> 'bool2': return intrinsic("binop.__iand__.bool2", bool2, byref(self), _other) + @func(inline='always') + def __or__(self, _other: tp.Union['bool2', bool, bool]) -> 'bool2': return intrinsic("binop.__or__.bool2", bool2, self, _other) + @func(inline='always') + def __ror__(self, _other: tp.Union['bool2', bool, bool]) -> 'bool2': return intrinsic("binop.__ror__.bool2", bool2, self, _other) + @func(inline='always') + def __ior__(self, _other: tp.Union['bool2', bool, bool]) -> 'bool2': return intrinsic("binop.__ior__.bool2", bool2, byref(self), _other) + @func(inline='always') + def __xor__(self, _other: tp.Union['bool2', bool, bool]) -> 'bool2': return intrinsic("binop.__xor__.bool2", bool2, self, _other) + @func(inline='always') + def __rxor__(self, _other: tp.Union['bool2', bool, bool]) -> 'bool2': return intrinsic("binop.__rxor__.bool2", bool2, self, _other) + @func(inline='always') + def __ixor__(self, _other: tp.Union['bool2', bool, bool]) -> 'bool2': return intrinsic("binop.__ixor__.bool2", bool2, byref(self), _other) @builtin_type(_hir.VectorType(tp.cast(_hir.ScalarType, _ctx.types[f32]), 2)) class float2(FloatBuiltin['float2']): x: f32 y: f32 def __init__(self, x: tp.Union['f32', float] = 0.0, y: tp.Union['f32', float] = 0.0) -> None: self = intrinsic("init.float2", float2, x, y) - def __add__(self, _other: tp.Union['float2', f32, float]) -> 'float2': return intrinsic("binop.__add__.float2", float2, _other) - def __radd__(self, _other: tp.Union['float2', f32, float]) -> 'float2': return intrinsic("binop.__radd__.float2", float2, _other) - def __iadd__(self, _other: tp.Union['float2', f32, float]) -> 'float2': return intrinsic("binop.__iadd__.float2", float2, _other) - def __sub__(self, _other: tp.Union['float2', f32, float]) -> 'float2': return intrinsic("binop.__sub__.float2", float2, _other) - def __rsub__(self, _other: tp.Union['float2', f32, float]) -> 'float2': return intrinsic("binop.__rsub__.float2", float2, _other) - def __isub__(self, _other: tp.Union['float2', f32, float]) -> 'float2': return intrinsic("binop.__isub__.float2", float2, _other) - def __mul__(self, _other: tp.Union['float2', f32, float]) -> 'float2': return intrinsic("binop.__mul__.float2", float2, _other) - def __rmul__(self, _other: tp.Union['float2', f32, float]) -> 'float2': return intrinsic("binop.__rmul__.float2", float2, _other) - def __imul__(self, _other: tp.Union['float2', f32, float]) -> 'float2': return intrinsic("binop.__imul__.float2", float2, _other) - def __mod__(self, _other: tp.Union['float2', f32, float]) -> 'float2': return intrinsic("binop.__mod__.float2", float2, _other) - def __rmod__(self, _other: tp.Union['float2', f32, float]) -> 'float2': return intrinsic("binop.__rmod__.float2", float2, _other) - def __imod__(self, _other: tp.Union['float2', f32, float]) -> 'float2': return intrinsic("binop.__imod__.float2", float2, _other) - def __lt__(self, _other: tp.Union['float2', f32, float]) -> 'bool2': return intrinsic("cmp.__lt__.float2", bool2, _other) # type: ignore[override] - def __le__(self, _other: tp.Union['float2', f32, float]) -> 'bool2': return intrinsic("cmp.__le__.float2", bool2, _other) # type: ignore[override] - def __gt__(self, _other: tp.Union['float2', f32, float]) -> 'bool2': return intrinsic("cmp.__gt__.float2", bool2, _other) # type: ignore[override] - def __ge__(self, _other: tp.Union['float2', f32, float]) -> 'bool2': return intrinsic("cmp.__ge__.float2", bool2, _other) # type: ignore[override] - def __eq__(self, _other: tp.Union['float2', f32, float]) -> 'bool2': return intrinsic("cmp.__eq__.float2", bool2, _other) # type: ignore[override] - def __ne__(self, _other: tp.Union['float2', f32, float]) -> 'bool2': return intrinsic("cmp.__ne__.float2", bool2, _other) # type: ignore[override] - def __truediv__(self, _other: tp.Union['float2', f32, float]) -> 'float2': return intrinsic("binop.__truediv__.float2", float2, _other) - def __rtruediv__(self, _other: tp.Union['float2', f32, float]) -> 'float2': return intrinsic("binop.__rtruediv__.float2", float2, _other) - def __itruediv__(self, _other: tp.Union['float2', f32, float]) -> 'float2': return intrinsic("binop.__itruediv__.float2", float2, _other) - def __pow__(self, _other: tp.Union['float2', f32, float]) -> 'float2': return intrinsic("binop.__pow__.float2", float2, _other) - def __rpow__(self, _other: tp.Union['float2', f32, float]) -> 'float2': return intrinsic("binop.__rpow__.float2", float2, _other) - def __ipow__(self, _other: tp.Union['float2', f32, float]) -> 'float2': return intrinsic("binop.__ipow__.float2", float2, _other) - def __floordiv__(self, _other: tp.Union['float2', f32, float]) -> 'float2': return intrinsic("binop.__floordiv__.float2", float2, _other) - def __rfloordiv__(self, _other: tp.Union['float2', f32, float]) -> 'float2': return intrinsic("binop.__rfloordiv__.float2", float2, _other) + @func(inline='always') + def __add__(self, _other: tp.Union['float2', f32, float]) -> 'float2': return intrinsic("binop.__add__.float2", float2, self, _other) + @func(inline='always') + def __radd__(self, _other: tp.Union['float2', f32, float]) -> 'float2': return intrinsic("binop.__radd__.float2", float2, self, _other) + @func(inline='always') + def __iadd__(self, _other: tp.Union['float2', f32, float]) -> 'float2': return intrinsic("binop.__iadd__.float2", float2, byref(self), _other) + @func(inline='always') + def __sub__(self, _other: tp.Union['float2', f32, float]) -> 'float2': return intrinsic("binop.__sub__.float2", float2, self, _other) + @func(inline='always') + def __rsub__(self, _other: tp.Union['float2', f32, float]) -> 'float2': return intrinsic("binop.__rsub__.float2", float2, self, _other) + @func(inline='always') + def __isub__(self, _other: tp.Union['float2', f32, float]) -> 'float2': return intrinsic("binop.__isub__.float2", float2, byref(self), _other) + @func(inline='always') + def __mul__(self, _other: tp.Union['float2', f32, float]) -> 'float2': return intrinsic("binop.__mul__.float2", float2, self, _other) + @func(inline='always') + def __rmul__(self, _other: tp.Union['float2', f32, float]) -> 'float2': return intrinsic("binop.__rmul__.float2", float2, self, _other) + @func(inline='always') + def __imul__(self, _other: tp.Union['float2', f32, float]) -> 'float2': return intrinsic("binop.__imul__.float2", float2, byref(self), _other) + @func(inline='always') + def __mod__(self, _other: tp.Union['float2', f32, float]) -> 'float2': return intrinsic("binop.__mod__.float2", float2, self, _other) + @func(inline='always') + def __rmod__(self, _other: tp.Union['float2', f32, float]) -> 'float2': return intrinsic("binop.__rmod__.float2", float2, self, _other) + @func(inline='always') + def __imod__(self, _other: tp.Union['float2', f32, float]) -> 'float2': return intrinsic("binop.__imod__.float2", float2, byref(self), _other) + @func(inline='always') + def __lt__(self, _other: tp.Union['float2', f32, float]) -> 'bool2': return intrinsic("cmp.__lt__.float2", bool2, self, _other) # type: ignore[override] + @func(inline='always') + def __le__(self, _other: tp.Union['float2', f32, float]) -> 'bool2': return intrinsic("cmp.__le__.float2", bool2, self, _other) # type: ignore[override] + @func(inline='always') + def __gt__(self, _other: tp.Union['float2', f32, float]) -> 'bool2': return intrinsic("cmp.__gt__.float2", bool2, self, _other) # type: ignore[override] + @func(inline='always') + def __ge__(self, _other: tp.Union['float2', f32, float]) -> 'bool2': return intrinsic("cmp.__ge__.float2", bool2, self, _other) # type: ignore[override] + @func(inline='always') + def __eq__(self, _other: tp.Union['float2', f32, float]) -> 'bool2': return intrinsic("cmp.__eq__.float2", bool2, self, _other) # type: ignore[override] + @func(inline='always') + def __ne__(self, _other: tp.Union['float2', f32, float]) -> 'bool2': return intrinsic("cmp.__ne__.float2", bool2, self, _other) # type: ignore[override] + @func(inline='always') + def __truediv__(self, _other: tp.Union['float2', f32, float]) -> 'float2': return intrinsic("binop.__truediv__.float2", float2, self, _other) + @func(inline='always') + def __rtruediv__(self, _other: tp.Union['float2', f32, float]) -> 'float2': return intrinsic("binop.__rtruediv__.float2", float2, self, _other) + @func(inline='always') + def __itruediv__(self, _other: tp.Union['float2', f32, float]) -> 'float2': return intrinsic("binop.__itruediv__.float2", float2, byref(self), _other) + @func(inline='always') + def __pow__(self, _other: tp.Union['float2', f32, float]) -> 'float2': return intrinsic("binop.__pow__.float2", float2, self, _other) + @func(inline='always') + def __rpow__(self, _other: tp.Union['float2', f32, float]) -> 'float2': return intrinsic("binop.__rpow__.float2", float2, self, _other) + @func(inline='always') + def __ipow__(self, _other: tp.Union['float2', f32, float]) -> 'float2': return intrinsic("binop.__ipow__.float2", float2, byref(self), _other) + @func(inline='always') + def __floordiv__(self, _other: tp.Union['float2', f32, float]) -> 'float2': return intrinsic("binop.__floordiv__.float2", float2, self, _other) + @func(inline='always') + def __rfloordiv__(self, _other: tp.Union['float2', f32, float]) -> 'float2': return intrinsic("binop.__rfloordiv__.float2", float2, self, _other) @builtin_type(_hir.VectorType(tp.cast(_hir.ScalarType, _ctx.types[f64]), 2)) class double2(FloatBuiltin['double2']): x: f64 y: f64 def __init__(self, x: tp.Union['f64', float] = 0.0, y: tp.Union['f64', float] = 0.0) -> None: self = intrinsic("init.double2", double2, x, y) - def __add__(self, _other: tp.Union['double2', f64, float]) -> 'double2': return intrinsic("binop.__add__.double2", double2, _other) - def __radd__(self, _other: tp.Union['double2', f64, float]) -> 'double2': return intrinsic("binop.__radd__.double2", double2, _other) - def __iadd__(self, _other: tp.Union['double2', f64, float]) -> 'double2': return intrinsic("binop.__iadd__.double2", double2, _other) - def __sub__(self, _other: tp.Union['double2', f64, float]) -> 'double2': return intrinsic("binop.__sub__.double2", double2, _other) - def __rsub__(self, _other: tp.Union['double2', f64, float]) -> 'double2': return intrinsic("binop.__rsub__.double2", double2, _other) - def __isub__(self, _other: tp.Union['double2', f64, float]) -> 'double2': return intrinsic("binop.__isub__.double2", double2, _other) - def __mul__(self, _other: tp.Union['double2', f64, float]) -> 'double2': return intrinsic("binop.__mul__.double2", double2, _other) - def __rmul__(self, _other: tp.Union['double2', f64, float]) -> 'double2': return intrinsic("binop.__rmul__.double2", double2, _other) - def __imul__(self, _other: tp.Union['double2', f64, float]) -> 'double2': return intrinsic("binop.__imul__.double2", double2, _other) - def __mod__(self, _other: tp.Union['double2', f64, float]) -> 'double2': return intrinsic("binop.__mod__.double2", double2, _other) - def __rmod__(self, _other: tp.Union['double2', f64, float]) -> 'double2': return intrinsic("binop.__rmod__.double2", double2, _other) - def __imod__(self, _other: tp.Union['double2', f64, float]) -> 'double2': return intrinsic("binop.__imod__.double2", double2, _other) - def __lt__(self, _other: tp.Union['double2', f64, float]) -> 'bool2': return intrinsic("cmp.__lt__.double2", bool2, _other) # type: ignore[override] - def __le__(self, _other: tp.Union['double2', f64, float]) -> 'bool2': return intrinsic("cmp.__le__.double2", bool2, _other) # type: ignore[override] - def __gt__(self, _other: tp.Union['double2', f64, float]) -> 'bool2': return intrinsic("cmp.__gt__.double2", bool2, _other) # type: ignore[override] - def __ge__(self, _other: tp.Union['double2', f64, float]) -> 'bool2': return intrinsic("cmp.__ge__.double2", bool2, _other) # type: ignore[override] - def __eq__(self, _other: tp.Union['double2', f64, float]) -> 'bool2': return intrinsic("cmp.__eq__.double2", bool2, _other) # type: ignore[override] - def __ne__(self, _other: tp.Union['double2', f64, float]) -> 'bool2': return intrinsic("cmp.__ne__.double2", bool2, _other) # type: ignore[override] - def __truediv__(self, _other: tp.Union['double2', f64, float]) -> 'double2': return intrinsic("binop.__truediv__.double2", double2, _other) - def __rtruediv__(self, _other: tp.Union['double2', f64, float]) -> 'double2': return intrinsic("binop.__rtruediv__.double2", double2, _other) - def __itruediv__(self, _other: tp.Union['double2', f64, float]) -> 'double2': return intrinsic("binop.__itruediv__.double2", double2, _other) - def __pow__(self, _other: tp.Union['double2', f64, float]) -> 'double2': return intrinsic("binop.__pow__.double2", double2, _other) - def __rpow__(self, _other: tp.Union['double2', f64, float]) -> 'double2': return intrinsic("binop.__rpow__.double2", double2, _other) - def __ipow__(self, _other: tp.Union['double2', f64, float]) -> 'double2': return intrinsic("binop.__ipow__.double2", double2, _other) - def __floordiv__(self, _other: tp.Union['double2', f64, float]) -> 'double2': return intrinsic("binop.__floordiv__.double2", double2, _other) - def __rfloordiv__(self, _other: tp.Union['double2', f64, float]) -> 'double2': return intrinsic("binop.__rfloordiv__.double2", double2, _other) + @func(inline='always') + def __add__(self, _other: tp.Union['double2', f64, float]) -> 'double2': return intrinsic("binop.__add__.double2", double2, self, _other) + @func(inline='always') + def __radd__(self, _other: tp.Union['double2', f64, float]) -> 'double2': return intrinsic("binop.__radd__.double2", double2, self, _other) + @func(inline='always') + def __iadd__(self, _other: tp.Union['double2', f64, float]) -> 'double2': return intrinsic("binop.__iadd__.double2", double2, byref(self), _other) + @func(inline='always') + def __sub__(self, _other: tp.Union['double2', f64, float]) -> 'double2': return intrinsic("binop.__sub__.double2", double2, self, _other) + @func(inline='always') + def __rsub__(self, _other: tp.Union['double2', f64, float]) -> 'double2': return intrinsic("binop.__rsub__.double2", double2, self, _other) + @func(inline='always') + def __isub__(self, _other: tp.Union['double2', f64, float]) -> 'double2': return intrinsic("binop.__isub__.double2", double2, byref(self), _other) + @func(inline='always') + def __mul__(self, _other: tp.Union['double2', f64, float]) -> 'double2': return intrinsic("binop.__mul__.double2", double2, self, _other) + @func(inline='always') + def __rmul__(self, _other: tp.Union['double2', f64, float]) -> 'double2': return intrinsic("binop.__rmul__.double2", double2, self, _other) + @func(inline='always') + def __imul__(self, _other: tp.Union['double2', f64, float]) -> 'double2': return intrinsic("binop.__imul__.double2", double2, byref(self), _other) + @func(inline='always') + def __mod__(self, _other: tp.Union['double2', f64, float]) -> 'double2': return intrinsic("binop.__mod__.double2", double2, self, _other) + @func(inline='always') + def __rmod__(self, _other: tp.Union['double2', f64, float]) -> 'double2': return intrinsic("binop.__rmod__.double2", double2, self, _other) + @func(inline='always') + def __imod__(self, _other: tp.Union['double2', f64, float]) -> 'double2': return intrinsic("binop.__imod__.double2", double2, byref(self), _other) + @func(inline='always') + def __lt__(self, _other: tp.Union['double2', f64, float]) -> 'bool2': return intrinsic("cmp.__lt__.double2", bool2, self, _other) # type: ignore[override] + @func(inline='always') + def __le__(self, _other: tp.Union['double2', f64, float]) -> 'bool2': return intrinsic("cmp.__le__.double2", bool2, self, _other) # type: ignore[override] + @func(inline='always') + def __gt__(self, _other: tp.Union['double2', f64, float]) -> 'bool2': return intrinsic("cmp.__gt__.double2", bool2, self, _other) # type: ignore[override] + @func(inline='always') + def __ge__(self, _other: tp.Union['double2', f64, float]) -> 'bool2': return intrinsic("cmp.__ge__.double2", bool2, self, _other) # type: ignore[override] + @func(inline='always') + def __eq__(self, _other: tp.Union['double2', f64, float]) -> 'bool2': return intrinsic("cmp.__eq__.double2", bool2, self, _other) # type: ignore[override] + @func(inline='always') + def __ne__(self, _other: tp.Union['double2', f64, float]) -> 'bool2': return intrinsic("cmp.__ne__.double2", bool2, self, _other) # type: ignore[override] + @func(inline='always') + def __truediv__(self, _other: tp.Union['double2', f64, float]) -> 'double2': return intrinsic("binop.__truediv__.double2", double2, self, _other) + @func(inline='always') + def __rtruediv__(self, _other: tp.Union['double2', f64, float]) -> 'double2': return intrinsic("binop.__rtruediv__.double2", double2, self, _other) + @func(inline='always') + def __itruediv__(self, _other: tp.Union['double2', f64, float]) -> 'double2': return intrinsic("binop.__itruediv__.double2", double2, byref(self), _other) + @func(inline='always') + def __pow__(self, _other: tp.Union['double2', f64, float]) -> 'double2': return intrinsic("binop.__pow__.double2", double2, self, _other) + @func(inline='always') + def __rpow__(self, _other: tp.Union['double2', f64, float]) -> 'double2': return intrinsic("binop.__rpow__.double2", double2, self, _other) + @func(inline='always') + def __ipow__(self, _other: tp.Union['double2', f64, float]) -> 'double2': return intrinsic("binop.__ipow__.double2", double2, byref(self), _other) + @func(inline='always') + def __floordiv__(self, _other: tp.Union['double2', f64, float]) -> 'double2': return intrinsic("binop.__floordiv__.double2", double2, self, _other) + @func(inline='always') + def __rfloordiv__(self, _other: tp.Union['double2', f64, float]) -> 'double2': return intrinsic("binop.__rfloordiv__.double2", double2, self, _other) @builtin_type(_hir.VectorType(tp.cast(_hir.ScalarType, _ctx.types[i8]), 2)) class byte2: x: i8 y: i8 def __init__(self, x: tp.Union['i8', int] = 0, y: tp.Union['i8', int] = 0) -> None: self = intrinsic("init.byte2", byte2, x, y) - def __add__(self, _other: tp.Union['byte2', i8, int]) -> 'byte2': return intrinsic("binop.__add__.byte2", byte2, _other) - def __radd__(self, _other: tp.Union['byte2', i8, int]) -> 'byte2': return intrinsic("binop.__radd__.byte2", byte2, _other) - def __iadd__(self, _other: tp.Union['byte2', i8, int]) -> 'byte2': return intrinsic("binop.__iadd__.byte2", byte2, _other) - def __sub__(self, _other: tp.Union['byte2', i8, int]) -> 'byte2': return intrinsic("binop.__sub__.byte2", byte2, _other) - def __rsub__(self, _other: tp.Union['byte2', i8, int]) -> 'byte2': return intrinsic("binop.__rsub__.byte2", byte2, _other) - def __isub__(self, _other: tp.Union['byte2', i8, int]) -> 'byte2': return intrinsic("binop.__isub__.byte2", byte2, _other) - def __mul__(self, _other: tp.Union['byte2', i8, int]) -> 'byte2': return intrinsic("binop.__mul__.byte2", byte2, _other) - def __rmul__(self, _other: tp.Union['byte2', i8, int]) -> 'byte2': return intrinsic("binop.__rmul__.byte2", byte2, _other) - def __imul__(self, _other: tp.Union['byte2', i8, int]) -> 'byte2': return intrinsic("binop.__imul__.byte2", byte2, _other) - def __mod__(self, _other: tp.Union['byte2', i8, int]) -> 'byte2': return intrinsic("binop.__mod__.byte2", byte2, _other) - def __rmod__(self, _other: tp.Union['byte2', i8, int]) -> 'byte2': return intrinsic("binop.__rmod__.byte2", byte2, _other) - def __imod__(self, _other: tp.Union['byte2', i8, int]) -> 'byte2': return intrinsic("binop.__imod__.byte2", byte2, _other) - def __lt__(self, _other: tp.Union['byte2', i8, int]) -> 'bool2': return intrinsic("cmp.__lt__.byte2", bool2, _other) # type: ignore[override] - def __le__(self, _other: tp.Union['byte2', i8, int]) -> 'bool2': return intrinsic("cmp.__le__.byte2", bool2, _other) # type: ignore[override] - def __gt__(self, _other: tp.Union['byte2', i8, int]) -> 'bool2': return intrinsic("cmp.__gt__.byte2", bool2, _other) # type: ignore[override] - def __ge__(self, _other: tp.Union['byte2', i8, int]) -> 'bool2': return intrinsic("cmp.__ge__.byte2", bool2, _other) # type: ignore[override] - def __eq__(self, _other: tp.Union['byte2', i8, int]) -> 'bool2': return intrinsic("cmp.__eq__.byte2", bool2, _other) # type: ignore[override] - def __ne__(self, _other: tp.Union['byte2', i8, int]) -> 'bool2': return intrinsic("cmp.__ne__.byte2", bool2, _other) # type: ignore[override] - def __floordiv__(self, _other: tp.Union['byte2', i8, int]) -> 'byte2': return intrinsic("binop.__floordiv__.byte2", byte2, _other) - def __rfloordiv__(self, _other: tp.Union['byte2', i8, int]) -> 'byte2': return intrinsic("binop.__rfloordiv__.byte2", byte2, _other) - def __ifloordiv__(self, _other: tp.Union['byte2', i8, int]) -> 'byte2': return intrinsic("binop.__ifloordiv__.byte2", byte2, _other) - def __lshift__(self, _other: tp.Union['byte2', i8, int]) -> 'byte2': return intrinsic("binop.__lshift__.byte2", byte2, _other) - def __rlshift__(self, _other: tp.Union['byte2', i8, int]) -> 'byte2': return intrinsic("binop.__rlshift__.byte2", byte2, _other) - def __ilshift__(self, _other: tp.Union['byte2', i8, int]) -> 'byte2': return intrinsic("binop.__ilshift__.byte2", byte2, _other) - def __rshift__(self, _other: tp.Union['byte2', i8, int]) -> 'byte2': return intrinsic("binop.__rshift__.byte2", byte2, _other) - def __rrshift__(self, _other: tp.Union['byte2', i8, int]) -> 'byte2': return intrinsic("binop.__rrshift__.byte2", byte2, _other) - def __irshift__(self, _other: tp.Union['byte2', i8, int]) -> 'byte2': return intrinsic("binop.__irshift__.byte2", byte2, _other) - def __and__(self, _other: tp.Union['byte2', i8, int]) -> 'byte2': return intrinsic("binop.__and__.byte2", byte2, _other) - def __rand__(self, _other: tp.Union['byte2', i8, int]) -> 'byte2': return intrinsic("binop.__rand__.byte2", byte2, _other) - def __iand__(self, _other: tp.Union['byte2', i8, int]) -> 'byte2': return intrinsic("binop.__iand__.byte2", byte2, _other) - def __or__(self, _other: tp.Union['byte2', i8, int]) -> 'byte2': return intrinsic("binop.__or__.byte2", byte2, _other) - def __ror__(self, _other: tp.Union['byte2', i8, int]) -> 'byte2': return intrinsic("binop.__ror__.byte2", byte2, _other) - def __ior__(self, _other: tp.Union['byte2', i8, int]) -> 'byte2': return intrinsic("binop.__ior__.byte2", byte2, _other) - def __xor__(self, _other: tp.Union['byte2', i8, int]) -> 'byte2': return intrinsic("binop.__xor__.byte2", byte2, _other) - def __rxor__(self, _other: tp.Union['byte2', i8, int]) -> 'byte2': return intrinsic("binop.__rxor__.byte2", byte2, _other) - def __ixor__(self, _other: tp.Union['byte2', i8, int]) -> 'byte2': return intrinsic("binop.__ixor__.byte2", byte2, _other) + @func(inline='always') + def __add__(self, _other: tp.Union['byte2', i8, int]) -> 'byte2': return intrinsic("binop.__add__.byte2", byte2, self, _other) + @func(inline='always') + def __radd__(self, _other: tp.Union['byte2', i8, int]) -> 'byte2': return intrinsic("binop.__radd__.byte2", byte2, self, _other) + @func(inline='always') + def __iadd__(self, _other: tp.Union['byte2', i8, int]) -> 'byte2': return intrinsic("binop.__iadd__.byte2", byte2, byref(self), _other) + @func(inline='always') + def __sub__(self, _other: tp.Union['byte2', i8, int]) -> 'byte2': return intrinsic("binop.__sub__.byte2", byte2, self, _other) + @func(inline='always') + def __rsub__(self, _other: tp.Union['byte2', i8, int]) -> 'byte2': return intrinsic("binop.__rsub__.byte2", byte2, self, _other) + @func(inline='always') + def __isub__(self, _other: tp.Union['byte2', i8, int]) -> 'byte2': return intrinsic("binop.__isub__.byte2", byte2, byref(self), _other) + @func(inline='always') + def __mul__(self, _other: tp.Union['byte2', i8, int]) -> 'byte2': return intrinsic("binop.__mul__.byte2", byte2, self, _other) + @func(inline='always') + def __rmul__(self, _other: tp.Union['byte2', i8, int]) -> 'byte2': return intrinsic("binop.__rmul__.byte2", byte2, self, _other) + @func(inline='always') + def __imul__(self, _other: tp.Union['byte2', i8, int]) -> 'byte2': return intrinsic("binop.__imul__.byte2", byte2, byref(self), _other) + @func(inline='always') + def __mod__(self, _other: tp.Union['byte2', i8, int]) -> 'byte2': return intrinsic("binop.__mod__.byte2", byte2, self, _other) + @func(inline='always') + def __rmod__(self, _other: tp.Union['byte2', i8, int]) -> 'byte2': return intrinsic("binop.__rmod__.byte2", byte2, self, _other) + @func(inline='always') + def __imod__(self, _other: tp.Union['byte2', i8, int]) -> 'byte2': return intrinsic("binop.__imod__.byte2", byte2, byref(self), _other) + @func(inline='always') + def __lt__(self, _other: tp.Union['byte2', i8, int]) -> 'bool2': return intrinsic("cmp.__lt__.byte2", bool2, self, _other) # type: ignore[override] + @func(inline='always') + def __le__(self, _other: tp.Union['byte2', i8, int]) -> 'bool2': return intrinsic("cmp.__le__.byte2", bool2, self, _other) # type: ignore[override] + @func(inline='always') + def __gt__(self, _other: tp.Union['byte2', i8, int]) -> 'bool2': return intrinsic("cmp.__gt__.byte2", bool2, self, _other) # type: ignore[override] + @func(inline='always') + def __ge__(self, _other: tp.Union['byte2', i8, int]) -> 'bool2': return intrinsic("cmp.__ge__.byte2", bool2, self, _other) # type: ignore[override] + @func(inline='always') + def __eq__(self, _other: tp.Union['byte2', i8, int]) -> 'bool2': return intrinsic("cmp.__eq__.byte2", bool2, self, _other) # type: ignore[override] + @func(inline='always') + def __ne__(self, _other: tp.Union['byte2', i8, int]) -> 'bool2': return intrinsic("cmp.__ne__.byte2", bool2, self, _other) # type: ignore[override] + @func(inline='always') + def __floordiv__(self, _other: tp.Union['byte2', i8, int]) -> 'byte2': return intrinsic("binop.__floordiv__.byte2", byte2, self, _other) + @func(inline='always') + def __rfloordiv__(self, _other: tp.Union['byte2', i8, int]) -> 'byte2': return intrinsic("binop.__rfloordiv__.byte2", byte2, self, _other) + @func(inline='always') + def __ifloordiv__(self, _other: tp.Union['byte2', i8, int]) -> 'byte2': return intrinsic("binop.__ifloordiv__.byte2", byte2, byref(self), _other) + @func(inline='always') + def __lshift__(self, _other: tp.Union['byte2', i8, int]) -> 'byte2': return intrinsic("binop.__lshift__.byte2", byte2, self, _other) + @func(inline='always') + def __rlshift__(self, _other: tp.Union['byte2', i8, int]) -> 'byte2': return intrinsic("binop.__rlshift__.byte2", byte2, self, _other) + @func(inline='always') + def __ilshift__(self, _other: tp.Union['byte2', i8, int]) -> 'byte2': return intrinsic("binop.__ilshift__.byte2", byte2, byref(self), _other) + @func(inline='always') + def __rshift__(self, _other: tp.Union['byte2', i8, int]) -> 'byte2': return intrinsic("binop.__rshift__.byte2", byte2, self, _other) + @func(inline='always') + def __rrshift__(self, _other: tp.Union['byte2', i8, int]) -> 'byte2': return intrinsic("binop.__rrshift__.byte2", byte2, self, _other) + @func(inline='always') + def __irshift__(self, _other: tp.Union['byte2', i8, int]) -> 'byte2': return intrinsic("binop.__irshift__.byte2", byte2, byref(self), _other) + @func(inline='always') + def __and__(self, _other: tp.Union['byte2', i8, int]) -> 'byte2': return intrinsic("binop.__and__.byte2", byte2, self, _other) + @func(inline='always') + def __rand__(self, _other: tp.Union['byte2', i8, int]) -> 'byte2': return intrinsic("binop.__rand__.byte2", byte2, self, _other) + @func(inline='always') + def __iand__(self, _other: tp.Union['byte2', i8, int]) -> 'byte2': return intrinsic("binop.__iand__.byte2", byte2, byref(self), _other) + @func(inline='always') + def __or__(self, _other: tp.Union['byte2', i8, int]) -> 'byte2': return intrinsic("binop.__or__.byte2", byte2, self, _other) + @func(inline='always') + def __ror__(self, _other: tp.Union['byte2', i8, int]) -> 'byte2': return intrinsic("binop.__ror__.byte2", byte2, self, _other) + @func(inline='always') + def __ior__(self, _other: tp.Union['byte2', i8, int]) -> 'byte2': return intrinsic("binop.__ior__.byte2", byte2, byref(self), _other) + @func(inline='always') + def __xor__(self, _other: tp.Union['byte2', i8, int]) -> 'byte2': return intrinsic("binop.__xor__.byte2", byte2, self, _other) + @func(inline='always') + def __rxor__(self, _other: tp.Union['byte2', i8, int]) -> 'byte2': return intrinsic("binop.__rxor__.byte2", byte2, self, _other) + @func(inline='always') + def __ixor__(self, _other: tp.Union['byte2', i8, int]) -> 'byte2': return intrinsic("binop.__ixor__.byte2", byte2, byref(self), _other) @builtin_type(_hir.VectorType(tp.cast(_hir.ScalarType, _ctx.types[u8]), 2)) class ubyte2: x: u8 y: u8 def __init__(self, x: tp.Union['u8', int] = 0, y: tp.Union['u8', int] = 0) -> None: self = intrinsic("init.ubyte2", ubyte2, x, y) - def __add__(self, _other: tp.Union['ubyte2', u8, int]) -> 'ubyte2': return intrinsic("binop.__add__.ubyte2", ubyte2, _other) - def __radd__(self, _other: tp.Union['ubyte2', u8, int]) -> 'ubyte2': return intrinsic("binop.__radd__.ubyte2", ubyte2, _other) - def __iadd__(self, _other: tp.Union['ubyte2', u8, int]) -> 'ubyte2': return intrinsic("binop.__iadd__.ubyte2", ubyte2, _other) - def __sub__(self, _other: tp.Union['ubyte2', u8, int]) -> 'ubyte2': return intrinsic("binop.__sub__.ubyte2", ubyte2, _other) - def __rsub__(self, _other: tp.Union['ubyte2', u8, int]) -> 'ubyte2': return intrinsic("binop.__rsub__.ubyte2", ubyte2, _other) - def __isub__(self, _other: tp.Union['ubyte2', u8, int]) -> 'ubyte2': return intrinsic("binop.__isub__.ubyte2", ubyte2, _other) - def __mul__(self, _other: tp.Union['ubyte2', u8, int]) -> 'ubyte2': return intrinsic("binop.__mul__.ubyte2", ubyte2, _other) - def __rmul__(self, _other: tp.Union['ubyte2', u8, int]) -> 'ubyte2': return intrinsic("binop.__rmul__.ubyte2", ubyte2, _other) - def __imul__(self, _other: tp.Union['ubyte2', u8, int]) -> 'ubyte2': return intrinsic("binop.__imul__.ubyte2", ubyte2, _other) - def __mod__(self, _other: tp.Union['ubyte2', u8, int]) -> 'ubyte2': return intrinsic("binop.__mod__.ubyte2", ubyte2, _other) - def __rmod__(self, _other: tp.Union['ubyte2', u8, int]) -> 'ubyte2': return intrinsic("binop.__rmod__.ubyte2", ubyte2, _other) - def __imod__(self, _other: tp.Union['ubyte2', u8, int]) -> 'ubyte2': return intrinsic("binop.__imod__.ubyte2", ubyte2, _other) - def __lt__(self, _other: tp.Union['ubyte2', u8, int]) -> 'bool2': return intrinsic("cmp.__lt__.ubyte2", bool2, _other) # type: ignore[override] - def __le__(self, _other: tp.Union['ubyte2', u8, int]) -> 'bool2': return intrinsic("cmp.__le__.ubyte2", bool2, _other) # type: ignore[override] - def __gt__(self, _other: tp.Union['ubyte2', u8, int]) -> 'bool2': return intrinsic("cmp.__gt__.ubyte2", bool2, _other) # type: ignore[override] - def __ge__(self, _other: tp.Union['ubyte2', u8, int]) -> 'bool2': return intrinsic("cmp.__ge__.ubyte2", bool2, _other) # type: ignore[override] - def __eq__(self, _other: tp.Union['ubyte2', u8, int]) -> 'bool2': return intrinsic("cmp.__eq__.ubyte2", bool2, _other) # type: ignore[override] - def __ne__(self, _other: tp.Union['ubyte2', u8, int]) -> 'bool2': return intrinsic("cmp.__ne__.ubyte2", bool2, _other) # type: ignore[override] - def __floordiv__(self, _other: tp.Union['ubyte2', u8, int]) -> 'ubyte2': return intrinsic("binop.__floordiv__.ubyte2", ubyte2, _other) - def __rfloordiv__(self, _other: tp.Union['ubyte2', u8, int]) -> 'ubyte2': return intrinsic("binop.__rfloordiv__.ubyte2", ubyte2, _other) - def __ifloordiv__(self, _other: tp.Union['ubyte2', u8, int]) -> 'ubyte2': return intrinsic("binop.__ifloordiv__.ubyte2", ubyte2, _other) - def __lshift__(self, _other: tp.Union['ubyte2', u8, int]) -> 'ubyte2': return intrinsic("binop.__lshift__.ubyte2", ubyte2, _other) - def __rlshift__(self, _other: tp.Union['ubyte2', u8, int]) -> 'ubyte2': return intrinsic("binop.__rlshift__.ubyte2", ubyte2, _other) - def __ilshift__(self, _other: tp.Union['ubyte2', u8, int]) -> 'ubyte2': return intrinsic("binop.__ilshift__.ubyte2", ubyte2, _other) - def __rshift__(self, _other: tp.Union['ubyte2', u8, int]) -> 'ubyte2': return intrinsic("binop.__rshift__.ubyte2", ubyte2, _other) - def __rrshift__(self, _other: tp.Union['ubyte2', u8, int]) -> 'ubyte2': return intrinsic("binop.__rrshift__.ubyte2", ubyte2, _other) - def __irshift__(self, _other: tp.Union['ubyte2', u8, int]) -> 'ubyte2': return intrinsic("binop.__irshift__.ubyte2", ubyte2, _other) - def __and__(self, _other: tp.Union['ubyte2', u8, int]) -> 'ubyte2': return intrinsic("binop.__and__.ubyte2", ubyte2, _other) - def __rand__(self, _other: tp.Union['ubyte2', u8, int]) -> 'ubyte2': return intrinsic("binop.__rand__.ubyte2", ubyte2, _other) - def __iand__(self, _other: tp.Union['ubyte2', u8, int]) -> 'ubyte2': return intrinsic("binop.__iand__.ubyte2", ubyte2, _other) - def __or__(self, _other: tp.Union['ubyte2', u8, int]) -> 'ubyte2': return intrinsic("binop.__or__.ubyte2", ubyte2, _other) - def __ror__(self, _other: tp.Union['ubyte2', u8, int]) -> 'ubyte2': return intrinsic("binop.__ror__.ubyte2", ubyte2, _other) - def __ior__(self, _other: tp.Union['ubyte2', u8, int]) -> 'ubyte2': return intrinsic("binop.__ior__.ubyte2", ubyte2, _other) - def __xor__(self, _other: tp.Union['ubyte2', u8, int]) -> 'ubyte2': return intrinsic("binop.__xor__.ubyte2", ubyte2, _other) - def __rxor__(self, _other: tp.Union['ubyte2', u8, int]) -> 'ubyte2': return intrinsic("binop.__rxor__.ubyte2", ubyte2, _other) - def __ixor__(self, _other: tp.Union['ubyte2', u8, int]) -> 'ubyte2': return intrinsic("binop.__ixor__.ubyte2", ubyte2, _other) + @func(inline='always') + def __add__(self, _other: tp.Union['ubyte2', u8, int]) -> 'ubyte2': return intrinsic("binop.__add__.ubyte2", ubyte2, self, _other) + @func(inline='always') + def __radd__(self, _other: tp.Union['ubyte2', u8, int]) -> 'ubyte2': return intrinsic("binop.__radd__.ubyte2", ubyte2, self, _other) + @func(inline='always') + def __iadd__(self, _other: tp.Union['ubyte2', u8, int]) -> 'ubyte2': return intrinsic("binop.__iadd__.ubyte2", ubyte2, byref(self), _other) + @func(inline='always') + def __sub__(self, _other: tp.Union['ubyte2', u8, int]) -> 'ubyte2': return intrinsic("binop.__sub__.ubyte2", ubyte2, self, _other) + @func(inline='always') + def __rsub__(self, _other: tp.Union['ubyte2', u8, int]) -> 'ubyte2': return intrinsic("binop.__rsub__.ubyte2", ubyte2, self, _other) + @func(inline='always') + def __isub__(self, _other: tp.Union['ubyte2', u8, int]) -> 'ubyte2': return intrinsic("binop.__isub__.ubyte2", ubyte2, byref(self), _other) + @func(inline='always') + def __mul__(self, _other: tp.Union['ubyte2', u8, int]) -> 'ubyte2': return intrinsic("binop.__mul__.ubyte2", ubyte2, self, _other) + @func(inline='always') + def __rmul__(self, _other: tp.Union['ubyte2', u8, int]) -> 'ubyte2': return intrinsic("binop.__rmul__.ubyte2", ubyte2, self, _other) + @func(inline='always') + def __imul__(self, _other: tp.Union['ubyte2', u8, int]) -> 'ubyte2': return intrinsic("binop.__imul__.ubyte2", ubyte2, byref(self), _other) + @func(inline='always') + def __mod__(self, _other: tp.Union['ubyte2', u8, int]) -> 'ubyte2': return intrinsic("binop.__mod__.ubyte2", ubyte2, self, _other) + @func(inline='always') + def __rmod__(self, _other: tp.Union['ubyte2', u8, int]) -> 'ubyte2': return intrinsic("binop.__rmod__.ubyte2", ubyte2, self, _other) + @func(inline='always') + def __imod__(self, _other: tp.Union['ubyte2', u8, int]) -> 'ubyte2': return intrinsic("binop.__imod__.ubyte2", ubyte2, byref(self), _other) + @func(inline='always') + def __lt__(self, _other: tp.Union['ubyte2', u8, int]) -> 'bool2': return intrinsic("cmp.__lt__.ubyte2", bool2, self, _other) # type: ignore[override] + @func(inline='always') + def __le__(self, _other: tp.Union['ubyte2', u8, int]) -> 'bool2': return intrinsic("cmp.__le__.ubyte2", bool2, self, _other) # type: ignore[override] + @func(inline='always') + def __gt__(self, _other: tp.Union['ubyte2', u8, int]) -> 'bool2': return intrinsic("cmp.__gt__.ubyte2", bool2, self, _other) # type: ignore[override] + @func(inline='always') + def __ge__(self, _other: tp.Union['ubyte2', u8, int]) -> 'bool2': return intrinsic("cmp.__ge__.ubyte2", bool2, self, _other) # type: ignore[override] + @func(inline='always') + def __eq__(self, _other: tp.Union['ubyte2', u8, int]) -> 'bool2': return intrinsic("cmp.__eq__.ubyte2", bool2, self, _other) # type: ignore[override] + @func(inline='always') + def __ne__(self, _other: tp.Union['ubyte2', u8, int]) -> 'bool2': return intrinsic("cmp.__ne__.ubyte2", bool2, self, _other) # type: ignore[override] + @func(inline='always') + def __floordiv__(self, _other: tp.Union['ubyte2', u8, int]) -> 'ubyte2': return intrinsic("binop.__floordiv__.ubyte2", ubyte2, self, _other) + @func(inline='always') + def __rfloordiv__(self, _other: tp.Union['ubyte2', u8, int]) -> 'ubyte2': return intrinsic("binop.__rfloordiv__.ubyte2", ubyte2, self, _other) + @func(inline='always') + def __ifloordiv__(self, _other: tp.Union['ubyte2', u8, int]) -> 'ubyte2': return intrinsic("binop.__ifloordiv__.ubyte2", ubyte2, byref(self), _other) + @func(inline='always') + def __lshift__(self, _other: tp.Union['ubyte2', u8, int]) -> 'ubyte2': return intrinsic("binop.__lshift__.ubyte2", ubyte2, self, _other) + @func(inline='always') + def __rlshift__(self, _other: tp.Union['ubyte2', u8, int]) -> 'ubyte2': return intrinsic("binop.__rlshift__.ubyte2", ubyte2, self, _other) + @func(inline='always') + def __ilshift__(self, _other: tp.Union['ubyte2', u8, int]) -> 'ubyte2': return intrinsic("binop.__ilshift__.ubyte2", ubyte2, byref(self), _other) + @func(inline='always') + def __rshift__(self, _other: tp.Union['ubyte2', u8, int]) -> 'ubyte2': return intrinsic("binop.__rshift__.ubyte2", ubyte2, self, _other) + @func(inline='always') + def __rrshift__(self, _other: tp.Union['ubyte2', u8, int]) -> 'ubyte2': return intrinsic("binop.__rrshift__.ubyte2", ubyte2, self, _other) + @func(inline='always') + def __irshift__(self, _other: tp.Union['ubyte2', u8, int]) -> 'ubyte2': return intrinsic("binop.__irshift__.ubyte2", ubyte2, byref(self), _other) + @func(inline='always') + def __and__(self, _other: tp.Union['ubyte2', u8, int]) -> 'ubyte2': return intrinsic("binop.__and__.ubyte2", ubyte2, self, _other) + @func(inline='always') + def __rand__(self, _other: tp.Union['ubyte2', u8, int]) -> 'ubyte2': return intrinsic("binop.__rand__.ubyte2", ubyte2, self, _other) + @func(inline='always') + def __iand__(self, _other: tp.Union['ubyte2', u8, int]) -> 'ubyte2': return intrinsic("binop.__iand__.ubyte2", ubyte2, byref(self), _other) + @func(inline='always') + def __or__(self, _other: tp.Union['ubyte2', u8, int]) -> 'ubyte2': return intrinsic("binop.__or__.ubyte2", ubyte2, self, _other) + @func(inline='always') + def __ror__(self, _other: tp.Union['ubyte2', u8, int]) -> 'ubyte2': return intrinsic("binop.__ror__.ubyte2", ubyte2, self, _other) + @func(inline='always') + def __ior__(self, _other: tp.Union['ubyte2', u8, int]) -> 'ubyte2': return intrinsic("binop.__ior__.ubyte2", ubyte2, byref(self), _other) + @func(inline='always') + def __xor__(self, _other: tp.Union['ubyte2', u8, int]) -> 'ubyte2': return intrinsic("binop.__xor__.ubyte2", ubyte2, self, _other) + @func(inline='always') + def __rxor__(self, _other: tp.Union['ubyte2', u8, int]) -> 'ubyte2': return intrinsic("binop.__rxor__.ubyte2", ubyte2, self, _other) + @func(inline='always') + def __ixor__(self, _other: tp.Union['ubyte2', u8, int]) -> 'ubyte2': return intrinsic("binop.__ixor__.ubyte2", ubyte2, byref(self), _other) @builtin_type(_hir.VectorType(tp.cast(_hir.ScalarType, _ctx.types[i16]), 2)) class short2: x: i16 y: i16 def __init__(self, x: tp.Union['i16', int] = 0, y: tp.Union['i16', int] = 0) -> None: self = intrinsic("init.short2", short2, x, y) - def __add__(self, _other: tp.Union['short2', i16, int]) -> 'short2': return intrinsic("binop.__add__.short2", short2, _other) - def __radd__(self, _other: tp.Union['short2', i16, int]) -> 'short2': return intrinsic("binop.__radd__.short2", short2, _other) - def __iadd__(self, _other: tp.Union['short2', i16, int]) -> 'short2': return intrinsic("binop.__iadd__.short2", short2, _other) - def __sub__(self, _other: tp.Union['short2', i16, int]) -> 'short2': return intrinsic("binop.__sub__.short2", short2, _other) - def __rsub__(self, _other: tp.Union['short2', i16, int]) -> 'short2': return intrinsic("binop.__rsub__.short2", short2, _other) - def __isub__(self, _other: tp.Union['short2', i16, int]) -> 'short2': return intrinsic("binop.__isub__.short2", short2, _other) - def __mul__(self, _other: tp.Union['short2', i16, int]) -> 'short2': return intrinsic("binop.__mul__.short2", short2, _other) - def __rmul__(self, _other: tp.Union['short2', i16, int]) -> 'short2': return intrinsic("binop.__rmul__.short2", short2, _other) - def __imul__(self, _other: tp.Union['short2', i16, int]) -> 'short2': return intrinsic("binop.__imul__.short2", short2, _other) - def __mod__(self, _other: tp.Union['short2', i16, int]) -> 'short2': return intrinsic("binop.__mod__.short2", short2, _other) - def __rmod__(self, _other: tp.Union['short2', i16, int]) -> 'short2': return intrinsic("binop.__rmod__.short2", short2, _other) - def __imod__(self, _other: tp.Union['short2', i16, int]) -> 'short2': return intrinsic("binop.__imod__.short2", short2, _other) - def __lt__(self, _other: tp.Union['short2', i16, int]) -> 'bool2': return intrinsic("cmp.__lt__.short2", bool2, _other) # type: ignore[override] - def __le__(self, _other: tp.Union['short2', i16, int]) -> 'bool2': return intrinsic("cmp.__le__.short2", bool2, _other) # type: ignore[override] - def __gt__(self, _other: tp.Union['short2', i16, int]) -> 'bool2': return intrinsic("cmp.__gt__.short2", bool2, _other) # type: ignore[override] - def __ge__(self, _other: tp.Union['short2', i16, int]) -> 'bool2': return intrinsic("cmp.__ge__.short2", bool2, _other) # type: ignore[override] - def __eq__(self, _other: tp.Union['short2', i16, int]) -> 'bool2': return intrinsic("cmp.__eq__.short2", bool2, _other) # type: ignore[override] - def __ne__(self, _other: tp.Union['short2', i16, int]) -> 'bool2': return intrinsic("cmp.__ne__.short2", bool2, _other) # type: ignore[override] - def __floordiv__(self, _other: tp.Union['short2', i16, int]) -> 'short2': return intrinsic("binop.__floordiv__.short2", short2, _other) - def __rfloordiv__(self, _other: tp.Union['short2', i16, int]) -> 'short2': return intrinsic("binop.__rfloordiv__.short2", short2, _other) - def __ifloordiv__(self, _other: tp.Union['short2', i16, int]) -> 'short2': return intrinsic("binop.__ifloordiv__.short2", short2, _other) - def __lshift__(self, _other: tp.Union['short2', i16, int]) -> 'short2': return intrinsic("binop.__lshift__.short2", short2, _other) - def __rlshift__(self, _other: tp.Union['short2', i16, int]) -> 'short2': return intrinsic("binop.__rlshift__.short2", short2, _other) - def __ilshift__(self, _other: tp.Union['short2', i16, int]) -> 'short2': return intrinsic("binop.__ilshift__.short2", short2, _other) - def __rshift__(self, _other: tp.Union['short2', i16, int]) -> 'short2': return intrinsic("binop.__rshift__.short2", short2, _other) - def __rrshift__(self, _other: tp.Union['short2', i16, int]) -> 'short2': return intrinsic("binop.__rrshift__.short2", short2, _other) - def __irshift__(self, _other: tp.Union['short2', i16, int]) -> 'short2': return intrinsic("binop.__irshift__.short2", short2, _other) - def __and__(self, _other: tp.Union['short2', i16, int]) -> 'short2': return intrinsic("binop.__and__.short2", short2, _other) - def __rand__(self, _other: tp.Union['short2', i16, int]) -> 'short2': return intrinsic("binop.__rand__.short2", short2, _other) - def __iand__(self, _other: tp.Union['short2', i16, int]) -> 'short2': return intrinsic("binop.__iand__.short2", short2, _other) - def __or__(self, _other: tp.Union['short2', i16, int]) -> 'short2': return intrinsic("binop.__or__.short2", short2, _other) - def __ror__(self, _other: tp.Union['short2', i16, int]) -> 'short2': return intrinsic("binop.__ror__.short2", short2, _other) - def __ior__(self, _other: tp.Union['short2', i16, int]) -> 'short2': return intrinsic("binop.__ior__.short2", short2, _other) - def __xor__(self, _other: tp.Union['short2', i16, int]) -> 'short2': return intrinsic("binop.__xor__.short2", short2, _other) - def __rxor__(self, _other: tp.Union['short2', i16, int]) -> 'short2': return intrinsic("binop.__rxor__.short2", short2, _other) - def __ixor__(self, _other: tp.Union['short2', i16, int]) -> 'short2': return intrinsic("binop.__ixor__.short2", short2, _other) + @func(inline='always') + def __add__(self, _other: tp.Union['short2', i16, int]) -> 'short2': return intrinsic("binop.__add__.short2", short2, self, _other) + @func(inline='always') + def __radd__(self, _other: tp.Union['short2', i16, int]) -> 'short2': return intrinsic("binop.__radd__.short2", short2, self, _other) + @func(inline='always') + def __iadd__(self, _other: tp.Union['short2', i16, int]) -> 'short2': return intrinsic("binop.__iadd__.short2", short2, byref(self), _other) + @func(inline='always') + def __sub__(self, _other: tp.Union['short2', i16, int]) -> 'short2': return intrinsic("binop.__sub__.short2", short2, self, _other) + @func(inline='always') + def __rsub__(self, _other: tp.Union['short2', i16, int]) -> 'short2': return intrinsic("binop.__rsub__.short2", short2, self, _other) + @func(inline='always') + def __isub__(self, _other: tp.Union['short2', i16, int]) -> 'short2': return intrinsic("binop.__isub__.short2", short2, byref(self), _other) + @func(inline='always') + def __mul__(self, _other: tp.Union['short2', i16, int]) -> 'short2': return intrinsic("binop.__mul__.short2", short2, self, _other) + @func(inline='always') + def __rmul__(self, _other: tp.Union['short2', i16, int]) -> 'short2': return intrinsic("binop.__rmul__.short2", short2, self, _other) + @func(inline='always') + def __imul__(self, _other: tp.Union['short2', i16, int]) -> 'short2': return intrinsic("binop.__imul__.short2", short2, byref(self), _other) + @func(inline='always') + def __mod__(self, _other: tp.Union['short2', i16, int]) -> 'short2': return intrinsic("binop.__mod__.short2", short2, self, _other) + @func(inline='always') + def __rmod__(self, _other: tp.Union['short2', i16, int]) -> 'short2': return intrinsic("binop.__rmod__.short2", short2, self, _other) + @func(inline='always') + def __imod__(self, _other: tp.Union['short2', i16, int]) -> 'short2': return intrinsic("binop.__imod__.short2", short2, byref(self), _other) + @func(inline='always') + def __lt__(self, _other: tp.Union['short2', i16, int]) -> 'bool2': return intrinsic("cmp.__lt__.short2", bool2, self, _other) # type: ignore[override] + @func(inline='always') + def __le__(self, _other: tp.Union['short2', i16, int]) -> 'bool2': return intrinsic("cmp.__le__.short2", bool2, self, _other) # type: ignore[override] + @func(inline='always') + def __gt__(self, _other: tp.Union['short2', i16, int]) -> 'bool2': return intrinsic("cmp.__gt__.short2", bool2, self, _other) # type: ignore[override] + @func(inline='always') + def __ge__(self, _other: tp.Union['short2', i16, int]) -> 'bool2': return intrinsic("cmp.__ge__.short2", bool2, self, _other) # type: ignore[override] + @func(inline='always') + def __eq__(self, _other: tp.Union['short2', i16, int]) -> 'bool2': return intrinsic("cmp.__eq__.short2", bool2, self, _other) # type: ignore[override] + @func(inline='always') + def __ne__(self, _other: tp.Union['short2', i16, int]) -> 'bool2': return intrinsic("cmp.__ne__.short2", bool2, self, _other) # type: ignore[override] + @func(inline='always') + def __floordiv__(self, _other: tp.Union['short2', i16, int]) -> 'short2': return intrinsic("binop.__floordiv__.short2", short2, self, _other) + @func(inline='always') + def __rfloordiv__(self, _other: tp.Union['short2', i16, int]) -> 'short2': return intrinsic("binop.__rfloordiv__.short2", short2, self, _other) + @func(inline='always') + def __ifloordiv__(self, _other: tp.Union['short2', i16, int]) -> 'short2': return intrinsic("binop.__ifloordiv__.short2", short2, byref(self), _other) + @func(inline='always') + def __lshift__(self, _other: tp.Union['short2', i16, int]) -> 'short2': return intrinsic("binop.__lshift__.short2", short2, self, _other) + @func(inline='always') + def __rlshift__(self, _other: tp.Union['short2', i16, int]) -> 'short2': return intrinsic("binop.__rlshift__.short2", short2, self, _other) + @func(inline='always') + def __ilshift__(self, _other: tp.Union['short2', i16, int]) -> 'short2': return intrinsic("binop.__ilshift__.short2", short2, byref(self), _other) + @func(inline='always') + def __rshift__(self, _other: tp.Union['short2', i16, int]) -> 'short2': return intrinsic("binop.__rshift__.short2", short2, self, _other) + @func(inline='always') + def __rrshift__(self, _other: tp.Union['short2', i16, int]) -> 'short2': return intrinsic("binop.__rrshift__.short2", short2, self, _other) + @func(inline='always') + def __irshift__(self, _other: tp.Union['short2', i16, int]) -> 'short2': return intrinsic("binop.__irshift__.short2", short2, byref(self), _other) + @func(inline='always') + def __and__(self, _other: tp.Union['short2', i16, int]) -> 'short2': return intrinsic("binop.__and__.short2", short2, self, _other) + @func(inline='always') + def __rand__(self, _other: tp.Union['short2', i16, int]) -> 'short2': return intrinsic("binop.__rand__.short2", short2, self, _other) + @func(inline='always') + def __iand__(self, _other: tp.Union['short2', i16, int]) -> 'short2': return intrinsic("binop.__iand__.short2", short2, byref(self), _other) + @func(inline='always') + def __or__(self, _other: tp.Union['short2', i16, int]) -> 'short2': return intrinsic("binop.__or__.short2", short2, self, _other) + @func(inline='always') + def __ror__(self, _other: tp.Union['short2', i16, int]) -> 'short2': return intrinsic("binop.__ror__.short2", short2, self, _other) + @func(inline='always') + def __ior__(self, _other: tp.Union['short2', i16, int]) -> 'short2': return intrinsic("binop.__ior__.short2", short2, byref(self), _other) + @func(inline='always') + def __xor__(self, _other: tp.Union['short2', i16, int]) -> 'short2': return intrinsic("binop.__xor__.short2", short2, self, _other) + @func(inline='always') + def __rxor__(self, _other: tp.Union['short2', i16, int]) -> 'short2': return intrinsic("binop.__rxor__.short2", short2, self, _other) + @func(inline='always') + def __ixor__(self, _other: tp.Union['short2', i16, int]) -> 'short2': return intrinsic("binop.__ixor__.short2", short2, byref(self), _other) @builtin_type(_hir.VectorType(tp.cast(_hir.ScalarType, _ctx.types[u16]), 2)) class ushort2: x: u16 y: u16 def __init__(self, x: tp.Union['u16', int] = 0, y: tp.Union['u16', int] = 0) -> None: self = intrinsic("init.ushort2", ushort2, x, y) - def __add__(self, _other: tp.Union['ushort2', u16, int]) -> 'ushort2': return intrinsic("binop.__add__.ushort2", ushort2, _other) - def __radd__(self, _other: tp.Union['ushort2', u16, int]) -> 'ushort2': return intrinsic("binop.__radd__.ushort2", ushort2, _other) - def __iadd__(self, _other: tp.Union['ushort2', u16, int]) -> 'ushort2': return intrinsic("binop.__iadd__.ushort2", ushort2, _other) - def __sub__(self, _other: tp.Union['ushort2', u16, int]) -> 'ushort2': return intrinsic("binop.__sub__.ushort2", ushort2, _other) - def __rsub__(self, _other: tp.Union['ushort2', u16, int]) -> 'ushort2': return intrinsic("binop.__rsub__.ushort2", ushort2, _other) - def __isub__(self, _other: tp.Union['ushort2', u16, int]) -> 'ushort2': return intrinsic("binop.__isub__.ushort2", ushort2, _other) - def __mul__(self, _other: tp.Union['ushort2', u16, int]) -> 'ushort2': return intrinsic("binop.__mul__.ushort2", ushort2, _other) - def __rmul__(self, _other: tp.Union['ushort2', u16, int]) -> 'ushort2': return intrinsic("binop.__rmul__.ushort2", ushort2, _other) - def __imul__(self, _other: tp.Union['ushort2', u16, int]) -> 'ushort2': return intrinsic("binop.__imul__.ushort2", ushort2, _other) - def __mod__(self, _other: tp.Union['ushort2', u16, int]) -> 'ushort2': return intrinsic("binop.__mod__.ushort2", ushort2, _other) - def __rmod__(self, _other: tp.Union['ushort2', u16, int]) -> 'ushort2': return intrinsic("binop.__rmod__.ushort2", ushort2, _other) - def __imod__(self, _other: tp.Union['ushort2', u16, int]) -> 'ushort2': return intrinsic("binop.__imod__.ushort2", ushort2, _other) - def __lt__(self, _other: tp.Union['ushort2', u16, int]) -> 'bool2': return intrinsic("cmp.__lt__.ushort2", bool2, _other) # type: ignore[override] - def __le__(self, _other: tp.Union['ushort2', u16, int]) -> 'bool2': return intrinsic("cmp.__le__.ushort2", bool2, _other) # type: ignore[override] - def __gt__(self, _other: tp.Union['ushort2', u16, int]) -> 'bool2': return intrinsic("cmp.__gt__.ushort2", bool2, _other) # type: ignore[override] - def __ge__(self, _other: tp.Union['ushort2', u16, int]) -> 'bool2': return intrinsic("cmp.__ge__.ushort2", bool2, _other) # type: ignore[override] - def __eq__(self, _other: tp.Union['ushort2', u16, int]) -> 'bool2': return intrinsic("cmp.__eq__.ushort2", bool2, _other) # type: ignore[override] - def __ne__(self, _other: tp.Union['ushort2', u16, int]) -> 'bool2': return intrinsic("cmp.__ne__.ushort2", bool2, _other) # type: ignore[override] - def __floordiv__(self, _other: tp.Union['ushort2', u16, int]) -> 'ushort2': return intrinsic("binop.__floordiv__.ushort2", ushort2, _other) - def __rfloordiv__(self, _other: tp.Union['ushort2', u16, int]) -> 'ushort2': return intrinsic("binop.__rfloordiv__.ushort2", ushort2, _other) - def __ifloordiv__(self, _other: tp.Union['ushort2', u16, int]) -> 'ushort2': return intrinsic("binop.__ifloordiv__.ushort2", ushort2, _other) - def __lshift__(self, _other: tp.Union['ushort2', u16, int]) -> 'ushort2': return intrinsic("binop.__lshift__.ushort2", ushort2, _other) - def __rlshift__(self, _other: tp.Union['ushort2', u16, int]) -> 'ushort2': return intrinsic("binop.__rlshift__.ushort2", ushort2, _other) - def __ilshift__(self, _other: tp.Union['ushort2', u16, int]) -> 'ushort2': return intrinsic("binop.__ilshift__.ushort2", ushort2, _other) - def __rshift__(self, _other: tp.Union['ushort2', u16, int]) -> 'ushort2': return intrinsic("binop.__rshift__.ushort2", ushort2, _other) - def __rrshift__(self, _other: tp.Union['ushort2', u16, int]) -> 'ushort2': return intrinsic("binop.__rrshift__.ushort2", ushort2, _other) - def __irshift__(self, _other: tp.Union['ushort2', u16, int]) -> 'ushort2': return intrinsic("binop.__irshift__.ushort2", ushort2, _other) - def __and__(self, _other: tp.Union['ushort2', u16, int]) -> 'ushort2': return intrinsic("binop.__and__.ushort2", ushort2, _other) - def __rand__(self, _other: tp.Union['ushort2', u16, int]) -> 'ushort2': return intrinsic("binop.__rand__.ushort2", ushort2, _other) - def __iand__(self, _other: tp.Union['ushort2', u16, int]) -> 'ushort2': return intrinsic("binop.__iand__.ushort2", ushort2, _other) - def __or__(self, _other: tp.Union['ushort2', u16, int]) -> 'ushort2': return intrinsic("binop.__or__.ushort2", ushort2, _other) - def __ror__(self, _other: tp.Union['ushort2', u16, int]) -> 'ushort2': return intrinsic("binop.__ror__.ushort2", ushort2, _other) - def __ior__(self, _other: tp.Union['ushort2', u16, int]) -> 'ushort2': return intrinsic("binop.__ior__.ushort2", ushort2, _other) - def __xor__(self, _other: tp.Union['ushort2', u16, int]) -> 'ushort2': return intrinsic("binop.__xor__.ushort2", ushort2, _other) - def __rxor__(self, _other: tp.Union['ushort2', u16, int]) -> 'ushort2': return intrinsic("binop.__rxor__.ushort2", ushort2, _other) - def __ixor__(self, _other: tp.Union['ushort2', u16, int]) -> 'ushort2': return intrinsic("binop.__ixor__.ushort2", ushort2, _other) + @func(inline='always') + def __add__(self, _other: tp.Union['ushort2', u16, int]) -> 'ushort2': return intrinsic("binop.__add__.ushort2", ushort2, self, _other) + @func(inline='always') + def __radd__(self, _other: tp.Union['ushort2', u16, int]) -> 'ushort2': return intrinsic("binop.__radd__.ushort2", ushort2, self, _other) + @func(inline='always') + def __iadd__(self, _other: tp.Union['ushort2', u16, int]) -> 'ushort2': return intrinsic("binop.__iadd__.ushort2", ushort2, byref(self), _other) + @func(inline='always') + def __sub__(self, _other: tp.Union['ushort2', u16, int]) -> 'ushort2': return intrinsic("binop.__sub__.ushort2", ushort2, self, _other) + @func(inline='always') + def __rsub__(self, _other: tp.Union['ushort2', u16, int]) -> 'ushort2': return intrinsic("binop.__rsub__.ushort2", ushort2, self, _other) + @func(inline='always') + def __isub__(self, _other: tp.Union['ushort2', u16, int]) -> 'ushort2': return intrinsic("binop.__isub__.ushort2", ushort2, byref(self), _other) + @func(inline='always') + def __mul__(self, _other: tp.Union['ushort2', u16, int]) -> 'ushort2': return intrinsic("binop.__mul__.ushort2", ushort2, self, _other) + @func(inline='always') + def __rmul__(self, _other: tp.Union['ushort2', u16, int]) -> 'ushort2': return intrinsic("binop.__rmul__.ushort2", ushort2, self, _other) + @func(inline='always') + def __imul__(self, _other: tp.Union['ushort2', u16, int]) -> 'ushort2': return intrinsic("binop.__imul__.ushort2", ushort2, byref(self), _other) + @func(inline='always') + def __mod__(self, _other: tp.Union['ushort2', u16, int]) -> 'ushort2': return intrinsic("binop.__mod__.ushort2", ushort2, self, _other) + @func(inline='always') + def __rmod__(self, _other: tp.Union['ushort2', u16, int]) -> 'ushort2': return intrinsic("binop.__rmod__.ushort2", ushort2, self, _other) + @func(inline='always') + def __imod__(self, _other: tp.Union['ushort2', u16, int]) -> 'ushort2': return intrinsic("binop.__imod__.ushort2", ushort2, byref(self), _other) + @func(inline='always') + def __lt__(self, _other: tp.Union['ushort2', u16, int]) -> 'bool2': return intrinsic("cmp.__lt__.ushort2", bool2, self, _other) # type: ignore[override] + @func(inline='always') + def __le__(self, _other: tp.Union['ushort2', u16, int]) -> 'bool2': return intrinsic("cmp.__le__.ushort2", bool2, self, _other) # type: ignore[override] + @func(inline='always') + def __gt__(self, _other: tp.Union['ushort2', u16, int]) -> 'bool2': return intrinsic("cmp.__gt__.ushort2", bool2, self, _other) # type: ignore[override] + @func(inline='always') + def __ge__(self, _other: tp.Union['ushort2', u16, int]) -> 'bool2': return intrinsic("cmp.__ge__.ushort2", bool2, self, _other) # type: ignore[override] + @func(inline='always') + def __eq__(self, _other: tp.Union['ushort2', u16, int]) -> 'bool2': return intrinsic("cmp.__eq__.ushort2", bool2, self, _other) # type: ignore[override] + @func(inline='always') + def __ne__(self, _other: tp.Union['ushort2', u16, int]) -> 'bool2': return intrinsic("cmp.__ne__.ushort2", bool2, self, _other) # type: ignore[override] + @func(inline='always') + def __floordiv__(self, _other: tp.Union['ushort2', u16, int]) -> 'ushort2': return intrinsic("binop.__floordiv__.ushort2", ushort2, self, _other) + @func(inline='always') + def __rfloordiv__(self, _other: tp.Union['ushort2', u16, int]) -> 'ushort2': return intrinsic("binop.__rfloordiv__.ushort2", ushort2, self, _other) + @func(inline='always') + def __ifloordiv__(self, _other: tp.Union['ushort2', u16, int]) -> 'ushort2': return intrinsic("binop.__ifloordiv__.ushort2", ushort2, byref(self), _other) + @func(inline='always') + def __lshift__(self, _other: tp.Union['ushort2', u16, int]) -> 'ushort2': return intrinsic("binop.__lshift__.ushort2", ushort2, self, _other) + @func(inline='always') + def __rlshift__(self, _other: tp.Union['ushort2', u16, int]) -> 'ushort2': return intrinsic("binop.__rlshift__.ushort2", ushort2, self, _other) + @func(inline='always') + def __ilshift__(self, _other: tp.Union['ushort2', u16, int]) -> 'ushort2': return intrinsic("binop.__ilshift__.ushort2", ushort2, byref(self), _other) + @func(inline='always') + def __rshift__(self, _other: tp.Union['ushort2', u16, int]) -> 'ushort2': return intrinsic("binop.__rshift__.ushort2", ushort2, self, _other) + @func(inline='always') + def __rrshift__(self, _other: tp.Union['ushort2', u16, int]) -> 'ushort2': return intrinsic("binop.__rrshift__.ushort2", ushort2, self, _other) + @func(inline='always') + def __irshift__(self, _other: tp.Union['ushort2', u16, int]) -> 'ushort2': return intrinsic("binop.__irshift__.ushort2", ushort2, byref(self), _other) + @func(inline='always') + def __and__(self, _other: tp.Union['ushort2', u16, int]) -> 'ushort2': return intrinsic("binop.__and__.ushort2", ushort2, self, _other) + @func(inline='always') + def __rand__(self, _other: tp.Union['ushort2', u16, int]) -> 'ushort2': return intrinsic("binop.__rand__.ushort2", ushort2, self, _other) + @func(inline='always') + def __iand__(self, _other: tp.Union['ushort2', u16, int]) -> 'ushort2': return intrinsic("binop.__iand__.ushort2", ushort2, byref(self), _other) + @func(inline='always') + def __or__(self, _other: tp.Union['ushort2', u16, int]) -> 'ushort2': return intrinsic("binop.__or__.ushort2", ushort2, self, _other) + @func(inline='always') + def __ror__(self, _other: tp.Union['ushort2', u16, int]) -> 'ushort2': return intrinsic("binop.__ror__.ushort2", ushort2, self, _other) + @func(inline='always') + def __ior__(self, _other: tp.Union['ushort2', u16, int]) -> 'ushort2': return intrinsic("binop.__ior__.ushort2", ushort2, byref(self), _other) + @func(inline='always') + def __xor__(self, _other: tp.Union['ushort2', u16, int]) -> 'ushort2': return intrinsic("binop.__xor__.ushort2", ushort2, self, _other) + @func(inline='always') + def __rxor__(self, _other: tp.Union['ushort2', u16, int]) -> 'ushort2': return intrinsic("binop.__rxor__.ushort2", ushort2, self, _other) + @func(inline='always') + def __ixor__(self, _other: tp.Union['ushort2', u16, int]) -> 'ushort2': return intrinsic("binop.__ixor__.ushort2", ushort2, byref(self), _other) @builtin_type(_hir.VectorType(tp.cast(_hir.ScalarType, _ctx.types[i32]), 2)) class int2: x: i32 y: i32 def __init__(self, x: tp.Union['i32', int] = 0, y: tp.Union['i32', int] = 0) -> None: self = intrinsic("init.int2", int2, x, y) - def __add__(self, _other: tp.Union['int2', i32, int]) -> 'int2': return intrinsic("binop.__add__.int2", int2, _other) - def __radd__(self, _other: tp.Union['int2', i32, int]) -> 'int2': return intrinsic("binop.__radd__.int2", int2, _other) - def __iadd__(self, _other: tp.Union['int2', i32, int]) -> 'int2': return intrinsic("binop.__iadd__.int2", int2, _other) - def __sub__(self, _other: tp.Union['int2', i32, int]) -> 'int2': return intrinsic("binop.__sub__.int2", int2, _other) - def __rsub__(self, _other: tp.Union['int2', i32, int]) -> 'int2': return intrinsic("binop.__rsub__.int2", int2, _other) - def __isub__(self, _other: tp.Union['int2', i32, int]) -> 'int2': return intrinsic("binop.__isub__.int2", int2, _other) - def __mul__(self, _other: tp.Union['int2', i32, int]) -> 'int2': return intrinsic("binop.__mul__.int2", int2, _other) - def __rmul__(self, _other: tp.Union['int2', i32, int]) -> 'int2': return intrinsic("binop.__rmul__.int2", int2, _other) - def __imul__(self, _other: tp.Union['int2', i32, int]) -> 'int2': return intrinsic("binop.__imul__.int2", int2, _other) - def __mod__(self, _other: tp.Union['int2', i32, int]) -> 'int2': return intrinsic("binop.__mod__.int2", int2, _other) - def __rmod__(self, _other: tp.Union['int2', i32, int]) -> 'int2': return intrinsic("binop.__rmod__.int2", int2, _other) - def __imod__(self, _other: tp.Union['int2', i32, int]) -> 'int2': return intrinsic("binop.__imod__.int2", int2, _other) - def __lt__(self, _other: tp.Union['int2', i32, int]) -> 'bool2': return intrinsic("cmp.__lt__.int2", bool2, _other) # type: ignore[override] - def __le__(self, _other: tp.Union['int2', i32, int]) -> 'bool2': return intrinsic("cmp.__le__.int2", bool2, _other) # type: ignore[override] - def __gt__(self, _other: tp.Union['int2', i32, int]) -> 'bool2': return intrinsic("cmp.__gt__.int2", bool2, _other) # type: ignore[override] - def __ge__(self, _other: tp.Union['int2', i32, int]) -> 'bool2': return intrinsic("cmp.__ge__.int2", bool2, _other) # type: ignore[override] - def __eq__(self, _other: tp.Union['int2', i32, int]) -> 'bool2': return intrinsic("cmp.__eq__.int2", bool2, _other) # type: ignore[override] - def __ne__(self, _other: tp.Union['int2', i32, int]) -> 'bool2': return intrinsic("cmp.__ne__.int2", bool2, _other) # type: ignore[override] - def __floordiv__(self, _other: tp.Union['int2', i32, int]) -> 'int2': return intrinsic("binop.__floordiv__.int2", int2, _other) - def __rfloordiv__(self, _other: tp.Union['int2', i32, int]) -> 'int2': return intrinsic("binop.__rfloordiv__.int2", int2, _other) - def __ifloordiv__(self, _other: tp.Union['int2', i32, int]) -> 'int2': return intrinsic("binop.__ifloordiv__.int2", int2, _other) - def __lshift__(self, _other: tp.Union['int2', i32, int]) -> 'int2': return intrinsic("binop.__lshift__.int2", int2, _other) - def __rlshift__(self, _other: tp.Union['int2', i32, int]) -> 'int2': return intrinsic("binop.__rlshift__.int2", int2, _other) - def __ilshift__(self, _other: tp.Union['int2', i32, int]) -> 'int2': return intrinsic("binop.__ilshift__.int2", int2, _other) - def __rshift__(self, _other: tp.Union['int2', i32, int]) -> 'int2': return intrinsic("binop.__rshift__.int2", int2, _other) - def __rrshift__(self, _other: tp.Union['int2', i32, int]) -> 'int2': return intrinsic("binop.__rrshift__.int2", int2, _other) - def __irshift__(self, _other: tp.Union['int2', i32, int]) -> 'int2': return intrinsic("binop.__irshift__.int2", int2, _other) - def __and__(self, _other: tp.Union['int2', i32, int]) -> 'int2': return intrinsic("binop.__and__.int2", int2, _other) - def __rand__(self, _other: tp.Union['int2', i32, int]) -> 'int2': return intrinsic("binop.__rand__.int2", int2, _other) - def __iand__(self, _other: tp.Union['int2', i32, int]) -> 'int2': return intrinsic("binop.__iand__.int2", int2, _other) - def __or__(self, _other: tp.Union['int2', i32, int]) -> 'int2': return intrinsic("binop.__or__.int2", int2, _other) - def __ror__(self, _other: tp.Union['int2', i32, int]) -> 'int2': return intrinsic("binop.__ror__.int2", int2, _other) - def __ior__(self, _other: tp.Union['int2', i32, int]) -> 'int2': return intrinsic("binop.__ior__.int2", int2, _other) - def __xor__(self, _other: tp.Union['int2', i32, int]) -> 'int2': return intrinsic("binop.__xor__.int2", int2, _other) - def __rxor__(self, _other: tp.Union['int2', i32, int]) -> 'int2': return intrinsic("binop.__rxor__.int2", int2, _other) - def __ixor__(self, _other: tp.Union['int2', i32, int]) -> 'int2': return intrinsic("binop.__ixor__.int2", int2, _other) + @func(inline='always') + def __add__(self, _other: tp.Union['int2', i32, int]) -> 'int2': return intrinsic("binop.__add__.int2", int2, self, _other) + @func(inline='always') + def __radd__(self, _other: tp.Union['int2', i32, int]) -> 'int2': return intrinsic("binop.__radd__.int2", int2, self, _other) + @func(inline='always') + def __iadd__(self, _other: tp.Union['int2', i32, int]) -> 'int2': return intrinsic("binop.__iadd__.int2", int2, byref(self), _other) + @func(inline='always') + def __sub__(self, _other: tp.Union['int2', i32, int]) -> 'int2': return intrinsic("binop.__sub__.int2", int2, self, _other) + @func(inline='always') + def __rsub__(self, _other: tp.Union['int2', i32, int]) -> 'int2': return intrinsic("binop.__rsub__.int2", int2, self, _other) + @func(inline='always') + def __isub__(self, _other: tp.Union['int2', i32, int]) -> 'int2': return intrinsic("binop.__isub__.int2", int2, byref(self), _other) + @func(inline='always') + def __mul__(self, _other: tp.Union['int2', i32, int]) -> 'int2': return intrinsic("binop.__mul__.int2", int2, self, _other) + @func(inline='always') + def __rmul__(self, _other: tp.Union['int2', i32, int]) -> 'int2': return intrinsic("binop.__rmul__.int2", int2, self, _other) + @func(inline='always') + def __imul__(self, _other: tp.Union['int2', i32, int]) -> 'int2': return intrinsic("binop.__imul__.int2", int2, byref(self), _other) + @func(inline='always') + def __mod__(self, _other: tp.Union['int2', i32, int]) -> 'int2': return intrinsic("binop.__mod__.int2", int2, self, _other) + @func(inline='always') + def __rmod__(self, _other: tp.Union['int2', i32, int]) -> 'int2': return intrinsic("binop.__rmod__.int2", int2, self, _other) + @func(inline='always') + def __imod__(self, _other: tp.Union['int2', i32, int]) -> 'int2': return intrinsic("binop.__imod__.int2", int2, byref(self), _other) + @func(inline='always') + def __lt__(self, _other: tp.Union['int2', i32, int]) -> 'bool2': return intrinsic("cmp.__lt__.int2", bool2, self, _other) # type: ignore[override] + @func(inline='always') + def __le__(self, _other: tp.Union['int2', i32, int]) -> 'bool2': return intrinsic("cmp.__le__.int2", bool2, self, _other) # type: ignore[override] + @func(inline='always') + def __gt__(self, _other: tp.Union['int2', i32, int]) -> 'bool2': return intrinsic("cmp.__gt__.int2", bool2, self, _other) # type: ignore[override] + @func(inline='always') + def __ge__(self, _other: tp.Union['int2', i32, int]) -> 'bool2': return intrinsic("cmp.__ge__.int2", bool2, self, _other) # type: ignore[override] + @func(inline='always') + def __eq__(self, _other: tp.Union['int2', i32, int]) -> 'bool2': return intrinsic("cmp.__eq__.int2", bool2, self, _other) # type: ignore[override] + @func(inline='always') + def __ne__(self, _other: tp.Union['int2', i32, int]) -> 'bool2': return intrinsic("cmp.__ne__.int2", bool2, self, _other) # type: ignore[override] + @func(inline='always') + def __floordiv__(self, _other: tp.Union['int2', i32, int]) -> 'int2': return intrinsic("binop.__floordiv__.int2", int2, self, _other) + @func(inline='always') + def __rfloordiv__(self, _other: tp.Union['int2', i32, int]) -> 'int2': return intrinsic("binop.__rfloordiv__.int2", int2, self, _other) + @func(inline='always') + def __ifloordiv__(self, _other: tp.Union['int2', i32, int]) -> 'int2': return intrinsic("binop.__ifloordiv__.int2", int2, byref(self), _other) + @func(inline='always') + def __lshift__(self, _other: tp.Union['int2', i32, int]) -> 'int2': return intrinsic("binop.__lshift__.int2", int2, self, _other) + @func(inline='always') + def __rlshift__(self, _other: tp.Union['int2', i32, int]) -> 'int2': return intrinsic("binop.__rlshift__.int2", int2, self, _other) + @func(inline='always') + def __ilshift__(self, _other: tp.Union['int2', i32, int]) -> 'int2': return intrinsic("binop.__ilshift__.int2", int2, byref(self), _other) + @func(inline='always') + def __rshift__(self, _other: tp.Union['int2', i32, int]) -> 'int2': return intrinsic("binop.__rshift__.int2", int2, self, _other) + @func(inline='always') + def __rrshift__(self, _other: tp.Union['int2', i32, int]) -> 'int2': return intrinsic("binop.__rrshift__.int2", int2, self, _other) + @func(inline='always') + def __irshift__(self, _other: tp.Union['int2', i32, int]) -> 'int2': return intrinsic("binop.__irshift__.int2", int2, byref(self), _other) + @func(inline='always') + def __and__(self, _other: tp.Union['int2', i32, int]) -> 'int2': return intrinsic("binop.__and__.int2", int2, self, _other) + @func(inline='always') + def __rand__(self, _other: tp.Union['int2', i32, int]) -> 'int2': return intrinsic("binop.__rand__.int2", int2, self, _other) + @func(inline='always') + def __iand__(self, _other: tp.Union['int2', i32, int]) -> 'int2': return intrinsic("binop.__iand__.int2", int2, byref(self), _other) + @func(inline='always') + def __or__(self, _other: tp.Union['int2', i32, int]) -> 'int2': return intrinsic("binop.__or__.int2", int2, self, _other) + @func(inline='always') + def __ror__(self, _other: tp.Union['int2', i32, int]) -> 'int2': return intrinsic("binop.__ror__.int2", int2, self, _other) + @func(inline='always') + def __ior__(self, _other: tp.Union['int2', i32, int]) -> 'int2': return intrinsic("binop.__ior__.int2", int2, byref(self), _other) + @func(inline='always') + def __xor__(self, _other: tp.Union['int2', i32, int]) -> 'int2': return intrinsic("binop.__xor__.int2", int2, self, _other) + @func(inline='always') + def __rxor__(self, _other: tp.Union['int2', i32, int]) -> 'int2': return intrinsic("binop.__rxor__.int2", int2, self, _other) + @func(inline='always') + def __ixor__(self, _other: tp.Union['int2', i32, int]) -> 'int2': return intrinsic("binop.__ixor__.int2", int2, byref(self), _other) @builtin_type(_hir.VectorType(tp.cast(_hir.ScalarType, _ctx.types[u32]), 2)) class uint2: x: u32 y: u32 def __init__(self, x: tp.Union['u32', int] = 0, y: tp.Union['u32', int] = 0) -> None: self = intrinsic("init.uint2", uint2, x, y) - def __add__(self, _other: tp.Union['uint2', u32, int]) -> 'uint2': return intrinsic("binop.__add__.uint2", uint2, _other) - def __radd__(self, _other: tp.Union['uint2', u32, int]) -> 'uint2': return intrinsic("binop.__radd__.uint2", uint2, _other) - def __iadd__(self, _other: tp.Union['uint2', u32, int]) -> 'uint2': return intrinsic("binop.__iadd__.uint2", uint2, _other) - def __sub__(self, _other: tp.Union['uint2', u32, int]) -> 'uint2': return intrinsic("binop.__sub__.uint2", uint2, _other) - def __rsub__(self, _other: tp.Union['uint2', u32, int]) -> 'uint2': return intrinsic("binop.__rsub__.uint2", uint2, _other) - def __isub__(self, _other: tp.Union['uint2', u32, int]) -> 'uint2': return intrinsic("binop.__isub__.uint2", uint2, _other) - def __mul__(self, _other: tp.Union['uint2', u32, int]) -> 'uint2': return intrinsic("binop.__mul__.uint2", uint2, _other) - def __rmul__(self, _other: tp.Union['uint2', u32, int]) -> 'uint2': return intrinsic("binop.__rmul__.uint2", uint2, _other) - def __imul__(self, _other: tp.Union['uint2', u32, int]) -> 'uint2': return intrinsic("binop.__imul__.uint2", uint2, _other) - def __mod__(self, _other: tp.Union['uint2', u32, int]) -> 'uint2': return intrinsic("binop.__mod__.uint2", uint2, _other) - def __rmod__(self, _other: tp.Union['uint2', u32, int]) -> 'uint2': return intrinsic("binop.__rmod__.uint2", uint2, _other) - def __imod__(self, _other: tp.Union['uint2', u32, int]) -> 'uint2': return intrinsic("binop.__imod__.uint2", uint2, _other) - def __lt__(self, _other: tp.Union['uint2', u32, int]) -> 'bool2': return intrinsic("cmp.__lt__.uint2", bool2, _other) # type: ignore[override] - def __le__(self, _other: tp.Union['uint2', u32, int]) -> 'bool2': return intrinsic("cmp.__le__.uint2", bool2, _other) # type: ignore[override] - def __gt__(self, _other: tp.Union['uint2', u32, int]) -> 'bool2': return intrinsic("cmp.__gt__.uint2", bool2, _other) # type: ignore[override] - def __ge__(self, _other: tp.Union['uint2', u32, int]) -> 'bool2': return intrinsic("cmp.__ge__.uint2", bool2, _other) # type: ignore[override] - def __eq__(self, _other: tp.Union['uint2', u32, int]) -> 'bool2': return intrinsic("cmp.__eq__.uint2", bool2, _other) # type: ignore[override] - def __ne__(self, _other: tp.Union['uint2', u32, int]) -> 'bool2': return intrinsic("cmp.__ne__.uint2", bool2, _other) # type: ignore[override] - def __floordiv__(self, _other: tp.Union['uint2', u32, int]) -> 'uint2': return intrinsic("binop.__floordiv__.uint2", uint2, _other) - def __rfloordiv__(self, _other: tp.Union['uint2', u32, int]) -> 'uint2': return intrinsic("binop.__rfloordiv__.uint2", uint2, _other) - def __ifloordiv__(self, _other: tp.Union['uint2', u32, int]) -> 'uint2': return intrinsic("binop.__ifloordiv__.uint2", uint2, _other) - def __lshift__(self, _other: tp.Union['uint2', u32, int]) -> 'uint2': return intrinsic("binop.__lshift__.uint2", uint2, _other) - def __rlshift__(self, _other: tp.Union['uint2', u32, int]) -> 'uint2': return intrinsic("binop.__rlshift__.uint2", uint2, _other) - def __ilshift__(self, _other: tp.Union['uint2', u32, int]) -> 'uint2': return intrinsic("binop.__ilshift__.uint2", uint2, _other) - def __rshift__(self, _other: tp.Union['uint2', u32, int]) -> 'uint2': return intrinsic("binop.__rshift__.uint2", uint2, _other) - def __rrshift__(self, _other: tp.Union['uint2', u32, int]) -> 'uint2': return intrinsic("binop.__rrshift__.uint2", uint2, _other) - def __irshift__(self, _other: tp.Union['uint2', u32, int]) -> 'uint2': return intrinsic("binop.__irshift__.uint2", uint2, _other) - def __and__(self, _other: tp.Union['uint2', u32, int]) -> 'uint2': return intrinsic("binop.__and__.uint2", uint2, _other) - def __rand__(self, _other: tp.Union['uint2', u32, int]) -> 'uint2': return intrinsic("binop.__rand__.uint2", uint2, _other) - def __iand__(self, _other: tp.Union['uint2', u32, int]) -> 'uint2': return intrinsic("binop.__iand__.uint2", uint2, _other) - def __or__(self, _other: tp.Union['uint2', u32, int]) -> 'uint2': return intrinsic("binop.__or__.uint2", uint2, _other) - def __ror__(self, _other: tp.Union['uint2', u32, int]) -> 'uint2': return intrinsic("binop.__ror__.uint2", uint2, _other) - def __ior__(self, _other: tp.Union['uint2', u32, int]) -> 'uint2': return intrinsic("binop.__ior__.uint2", uint2, _other) - def __xor__(self, _other: tp.Union['uint2', u32, int]) -> 'uint2': return intrinsic("binop.__xor__.uint2", uint2, _other) - def __rxor__(self, _other: tp.Union['uint2', u32, int]) -> 'uint2': return intrinsic("binop.__rxor__.uint2", uint2, _other) - def __ixor__(self, _other: tp.Union['uint2', u32, int]) -> 'uint2': return intrinsic("binop.__ixor__.uint2", uint2, _other) + @func(inline='always') + def __add__(self, _other: tp.Union['uint2', u32, int]) -> 'uint2': return intrinsic("binop.__add__.uint2", uint2, self, _other) + @func(inline='always') + def __radd__(self, _other: tp.Union['uint2', u32, int]) -> 'uint2': return intrinsic("binop.__radd__.uint2", uint2, self, _other) + @func(inline='always') + def __iadd__(self, _other: tp.Union['uint2', u32, int]) -> 'uint2': return intrinsic("binop.__iadd__.uint2", uint2, byref(self), _other) + @func(inline='always') + def __sub__(self, _other: tp.Union['uint2', u32, int]) -> 'uint2': return intrinsic("binop.__sub__.uint2", uint2, self, _other) + @func(inline='always') + def __rsub__(self, _other: tp.Union['uint2', u32, int]) -> 'uint2': return intrinsic("binop.__rsub__.uint2", uint2, self, _other) + @func(inline='always') + def __isub__(self, _other: tp.Union['uint2', u32, int]) -> 'uint2': return intrinsic("binop.__isub__.uint2", uint2, byref(self), _other) + @func(inline='always') + def __mul__(self, _other: tp.Union['uint2', u32, int]) -> 'uint2': return intrinsic("binop.__mul__.uint2", uint2, self, _other) + @func(inline='always') + def __rmul__(self, _other: tp.Union['uint2', u32, int]) -> 'uint2': return intrinsic("binop.__rmul__.uint2", uint2, self, _other) + @func(inline='always') + def __imul__(self, _other: tp.Union['uint2', u32, int]) -> 'uint2': return intrinsic("binop.__imul__.uint2", uint2, byref(self), _other) + @func(inline='always') + def __mod__(self, _other: tp.Union['uint2', u32, int]) -> 'uint2': return intrinsic("binop.__mod__.uint2", uint2, self, _other) + @func(inline='always') + def __rmod__(self, _other: tp.Union['uint2', u32, int]) -> 'uint2': return intrinsic("binop.__rmod__.uint2", uint2, self, _other) + @func(inline='always') + def __imod__(self, _other: tp.Union['uint2', u32, int]) -> 'uint2': return intrinsic("binop.__imod__.uint2", uint2, byref(self), _other) + @func(inline='always') + def __lt__(self, _other: tp.Union['uint2', u32, int]) -> 'bool2': return intrinsic("cmp.__lt__.uint2", bool2, self, _other) # type: ignore[override] + @func(inline='always') + def __le__(self, _other: tp.Union['uint2', u32, int]) -> 'bool2': return intrinsic("cmp.__le__.uint2", bool2, self, _other) # type: ignore[override] + @func(inline='always') + def __gt__(self, _other: tp.Union['uint2', u32, int]) -> 'bool2': return intrinsic("cmp.__gt__.uint2", bool2, self, _other) # type: ignore[override] + @func(inline='always') + def __ge__(self, _other: tp.Union['uint2', u32, int]) -> 'bool2': return intrinsic("cmp.__ge__.uint2", bool2, self, _other) # type: ignore[override] + @func(inline='always') + def __eq__(self, _other: tp.Union['uint2', u32, int]) -> 'bool2': return intrinsic("cmp.__eq__.uint2", bool2, self, _other) # type: ignore[override] + @func(inline='always') + def __ne__(self, _other: tp.Union['uint2', u32, int]) -> 'bool2': return intrinsic("cmp.__ne__.uint2", bool2, self, _other) # type: ignore[override] + @func(inline='always') + def __floordiv__(self, _other: tp.Union['uint2', u32, int]) -> 'uint2': return intrinsic("binop.__floordiv__.uint2", uint2, self, _other) + @func(inline='always') + def __rfloordiv__(self, _other: tp.Union['uint2', u32, int]) -> 'uint2': return intrinsic("binop.__rfloordiv__.uint2", uint2, self, _other) + @func(inline='always') + def __ifloordiv__(self, _other: tp.Union['uint2', u32, int]) -> 'uint2': return intrinsic("binop.__ifloordiv__.uint2", uint2, byref(self), _other) + @func(inline='always') + def __lshift__(self, _other: tp.Union['uint2', u32, int]) -> 'uint2': return intrinsic("binop.__lshift__.uint2", uint2, self, _other) + @func(inline='always') + def __rlshift__(self, _other: tp.Union['uint2', u32, int]) -> 'uint2': return intrinsic("binop.__rlshift__.uint2", uint2, self, _other) + @func(inline='always') + def __ilshift__(self, _other: tp.Union['uint2', u32, int]) -> 'uint2': return intrinsic("binop.__ilshift__.uint2", uint2, byref(self), _other) + @func(inline='always') + def __rshift__(self, _other: tp.Union['uint2', u32, int]) -> 'uint2': return intrinsic("binop.__rshift__.uint2", uint2, self, _other) + @func(inline='always') + def __rrshift__(self, _other: tp.Union['uint2', u32, int]) -> 'uint2': return intrinsic("binop.__rrshift__.uint2", uint2, self, _other) + @func(inline='always') + def __irshift__(self, _other: tp.Union['uint2', u32, int]) -> 'uint2': return intrinsic("binop.__irshift__.uint2", uint2, byref(self), _other) + @func(inline='always') + def __and__(self, _other: tp.Union['uint2', u32, int]) -> 'uint2': return intrinsic("binop.__and__.uint2", uint2, self, _other) + @func(inline='always') + def __rand__(self, _other: tp.Union['uint2', u32, int]) -> 'uint2': return intrinsic("binop.__rand__.uint2", uint2, self, _other) + @func(inline='always') + def __iand__(self, _other: tp.Union['uint2', u32, int]) -> 'uint2': return intrinsic("binop.__iand__.uint2", uint2, byref(self), _other) + @func(inline='always') + def __or__(self, _other: tp.Union['uint2', u32, int]) -> 'uint2': return intrinsic("binop.__or__.uint2", uint2, self, _other) + @func(inline='always') + def __ror__(self, _other: tp.Union['uint2', u32, int]) -> 'uint2': return intrinsic("binop.__ror__.uint2", uint2, self, _other) + @func(inline='always') + def __ior__(self, _other: tp.Union['uint2', u32, int]) -> 'uint2': return intrinsic("binop.__ior__.uint2", uint2, byref(self), _other) + @func(inline='always') + def __xor__(self, _other: tp.Union['uint2', u32, int]) -> 'uint2': return intrinsic("binop.__xor__.uint2", uint2, self, _other) + @func(inline='always') + def __rxor__(self, _other: tp.Union['uint2', u32, int]) -> 'uint2': return intrinsic("binop.__rxor__.uint2", uint2, self, _other) + @func(inline='always') + def __ixor__(self, _other: tp.Union['uint2', u32, int]) -> 'uint2': return intrinsic("binop.__ixor__.uint2", uint2, byref(self), _other) @builtin_type(_hir.VectorType(tp.cast(_hir.ScalarType, _ctx.types[i64]), 2)) class long2: x: i64 y: i64 def __init__(self, x: tp.Union['i64', int] = 0, y: tp.Union['i64', int] = 0) -> None: self = intrinsic("init.long2", long2, x, y) - def __add__(self, _other: tp.Union['long2', i64, int]) -> 'long2': return intrinsic("binop.__add__.long2", long2, _other) - def __radd__(self, _other: tp.Union['long2', i64, int]) -> 'long2': return intrinsic("binop.__radd__.long2", long2, _other) - def __iadd__(self, _other: tp.Union['long2', i64, int]) -> 'long2': return intrinsic("binop.__iadd__.long2", long2, _other) - def __sub__(self, _other: tp.Union['long2', i64, int]) -> 'long2': return intrinsic("binop.__sub__.long2", long2, _other) - def __rsub__(self, _other: tp.Union['long2', i64, int]) -> 'long2': return intrinsic("binop.__rsub__.long2", long2, _other) - def __isub__(self, _other: tp.Union['long2', i64, int]) -> 'long2': return intrinsic("binop.__isub__.long2", long2, _other) - def __mul__(self, _other: tp.Union['long2', i64, int]) -> 'long2': return intrinsic("binop.__mul__.long2", long2, _other) - def __rmul__(self, _other: tp.Union['long2', i64, int]) -> 'long2': return intrinsic("binop.__rmul__.long2", long2, _other) - def __imul__(self, _other: tp.Union['long2', i64, int]) -> 'long2': return intrinsic("binop.__imul__.long2", long2, _other) - def __mod__(self, _other: tp.Union['long2', i64, int]) -> 'long2': return intrinsic("binop.__mod__.long2", long2, _other) - def __rmod__(self, _other: tp.Union['long2', i64, int]) -> 'long2': return intrinsic("binop.__rmod__.long2", long2, _other) - def __imod__(self, _other: tp.Union['long2', i64, int]) -> 'long2': return intrinsic("binop.__imod__.long2", long2, _other) - def __lt__(self, _other: tp.Union['long2', i64, int]) -> 'bool2': return intrinsic("cmp.__lt__.long2", bool2, _other) # type: ignore[override] - def __le__(self, _other: tp.Union['long2', i64, int]) -> 'bool2': return intrinsic("cmp.__le__.long2", bool2, _other) # type: ignore[override] - def __gt__(self, _other: tp.Union['long2', i64, int]) -> 'bool2': return intrinsic("cmp.__gt__.long2", bool2, _other) # type: ignore[override] - def __ge__(self, _other: tp.Union['long2', i64, int]) -> 'bool2': return intrinsic("cmp.__ge__.long2", bool2, _other) # type: ignore[override] - def __eq__(self, _other: tp.Union['long2', i64, int]) -> 'bool2': return intrinsic("cmp.__eq__.long2", bool2, _other) # type: ignore[override] - def __ne__(self, _other: tp.Union['long2', i64, int]) -> 'bool2': return intrinsic("cmp.__ne__.long2", bool2, _other) # type: ignore[override] - def __floordiv__(self, _other: tp.Union['long2', i64, int]) -> 'long2': return intrinsic("binop.__floordiv__.long2", long2, _other) - def __rfloordiv__(self, _other: tp.Union['long2', i64, int]) -> 'long2': return intrinsic("binop.__rfloordiv__.long2", long2, _other) - def __ifloordiv__(self, _other: tp.Union['long2', i64, int]) -> 'long2': return intrinsic("binop.__ifloordiv__.long2", long2, _other) - def __lshift__(self, _other: tp.Union['long2', i64, int]) -> 'long2': return intrinsic("binop.__lshift__.long2", long2, _other) - def __rlshift__(self, _other: tp.Union['long2', i64, int]) -> 'long2': return intrinsic("binop.__rlshift__.long2", long2, _other) - def __ilshift__(self, _other: tp.Union['long2', i64, int]) -> 'long2': return intrinsic("binop.__ilshift__.long2", long2, _other) - def __rshift__(self, _other: tp.Union['long2', i64, int]) -> 'long2': return intrinsic("binop.__rshift__.long2", long2, _other) - def __rrshift__(self, _other: tp.Union['long2', i64, int]) -> 'long2': return intrinsic("binop.__rrshift__.long2", long2, _other) - def __irshift__(self, _other: tp.Union['long2', i64, int]) -> 'long2': return intrinsic("binop.__irshift__.long2", long2, _other) - def __and__(self, _other: tp.Union['long2', i64, int]) -> 'long2': return intrinsic("binop.__and__.long2", long2, _other) - def __rand__(self, _other: tp.Union['long2', i64, int]) -> 'long2': return intrinsic("binop.__rand__.long2", long2, _other) - def __iand__(self, _other: tp.Union['long2', i64, int]) -> 'long2': return intrinsic("binop.__iand__.long2", long2, _other) - def __or__(self, _other: tp.Union['long2', i64, int]) -> 'long2': return intrinsic("binop.__or__.long2", long2, _other) - def __ror__(self, _other: tp.Union['long2', i64, int]) -> 'long2': return intrinsic("binop.__ror__.long2", long2, _other) - def __ior__(self, _other: tp.Union['long2', i64, int]) -> 'long2': return intrinsic("binop.__ior__.long2", long2, _other) - def __xor__(self, _other: tp.Union['long2', i64, int]) -> 'long2': return intrinsic("binop.__xor__.long2", long2, _other) - def __rxor__(self, _other: tp.Union['long2', i64, int]) -> 'long2': return intrinsic("binop.__rxor__.long2", long2, _other) - def __ixor__(self, _other: tp.Union['long2', i64, int]) -> 'long2': return intrinsic("binop.__ixor__.long2", long2, _other) + @func(inline='always') + def __add__(self, _other: tp.Union['long2', i64, int]) -> 'long2': return intrinsic("binop.__add__.long2", long2, self, _other) + @func(inline='always') + def __radd__(self, _other: tp.Union['long2', i64, int]) -> 'long2': return intrinsic("binop.__radd__.long2", long2, self, _other) + @func(inline='always') + def __iadd__(self, _other: tp.Union['long2', i64, int]) -> 'long2': return intrinsic("binop.__iadd__.long2", long2, byref(self), _other) + @func(inline='always') + def __sub__(self, _other: tp.Union['long2', i64, int]) -> 'long2': return intrinsic("binop.__sub__.long2", long2, self, _other) + @func(inline='always') + def __rsub__(self, _other: tp.Union['long2', i64, int]) -> 'long2': return intrinsic("binop.__rsub__.long2", long2, self, _other) + @func(inline='always') + def __isub__(self, _other: tp.Union['long2', i64, int]) -> 'long2': return intrinsic("binop.__isub__.long2", long2, byref(self), _other) + @func(inline='always') + def __mul__(self, _other: tp.Union['long2', i64, int]) -> 'long2': return intrinsic("binop.__mul__.long2", long2, self, _other) + @func(inline='always') + def __rmul__(self, _other: tp.Union['long2', i64, int]) -> 'long2': return intrinsic("binop.__rmul__.long2", long2, self, _other) + @func(inline='always') + def __imul__(self, _other: tp.Union['long2', i64, int]) -> 'long2': return intrinsic("binop.__imul__.long2", long2, byref(self), _other) + @func(inline='always') + def __mod__(self, _other: tp.Union['long2', i64, int]) -> 'long2': return intrinsic("binop.__mod__.long2", long2, self, _other) + @func(inline='always') + def __rmod__(self, _other: tp.Union['long2', i64, int]) -> 'long2': return intrinsic("binop.__rmod__.long2", long2, self, _other) + @func(inline='always') + def __imod__(self, _other: tp.Union['long2', i64, int]) -> 'long2': return intrinsic("binop.__imod__.long2", long2, byref(self), _other) + @func(inline='always') + def __lt__(self, _other: tp.Union['long2', i64, int]) -> 'bool2': return intrinsic("cmp.__lt__.long2", bool2, self, _other) # type: ignore[override] + @func(inline='always') + def __le__(self, _other: tp.Union['long2', i64, int]) -> 'bool2': return intrinsic("cmp.__le__.long2", bool2, self, _other) # type: ignore[override] + @func(inline='always') + def __gt__(self, _other: tp.Union['long2', i64, int]) -> 'bool2': return intrinsic("cmp.__gt__.long2", bool2, self, _other) # type: ignore[override] + @func(inline='always') + def __ge__(self, _other: tp.Union['long2', i64, int]) -> 'bool2': return intrinsic("cmp.__ge__.long2", bool2, self, _other) # type: ignore[override] + @func(inline='always') + def __eq__(self, _other: tp.Union['long2', i64, int]) -> 'bool2': return intrinsic("cmp.__eq__.long2", bool2, self, _other) # type: ignore[override] + @func(inline='always') + def __ne__(self, _other: tp.Union['long2', i64, int]) -> 'bool2': return intrinsic("cmp.__ne__.long2", bool2, self, _other) # type: ignore[override] + @func(inline='always') + def __floordiv__(self, _other: tp.Union['long2', i64, int]) -> 'long2': return intrinsic("binop.__floordiv__.long2", long2, self, _other) + @func(inline='always') + def __rfloordiv__(self, _other: tp.Union['long2', i64, int]) -> 'long2': return intrinsic("binop.__rfloordiv__.long2", long2, self, _other) + @func(inline='always') + def __ifloordiv__(self, _other: tp.Union['long2', i64, int]) -> 'long2': return intrinsic("binop.__ifloordiv__.long2", long2, byref(self), _other) + @func(inline='always') + def __lshift__(self, _other: tp.Union['long2', i64, int]) -> 'long2': return intrinsic("binop.__lshift__.long2", long2, self, _other) + @func(inline='always') + def __rlshift__(self, _other: tp.Union['long2', i64, int]) -> 'long2': return intrinsic("binop.__rlshift__.long2", long2, self, _other) + @func(inline='always') + def __ilshift__(self, _other: tp.Union['long2', i64, int]) -> 'long2': return intrinsic("binop.__ilshift__.long2", long2, byref(self), _other) + @func(inline='always') + def __rshift__(self, _other: tp.Union['long2', i64, int]) -> 'long2': return intrinsic("binop.__rshift__.long2", long2, self, _other) + @func(inline='always') + def __rrshift__(self, _other: tp.Union['long2', i64, int]) -> 'long2': return intrinsic("binop.__rrshift__.long2", long2, self, _other) + @func(inline='always') + def __irshift__(self, _other: tp.Union['long2', i64, int]) -> 'long2': return intrinsic("binop.__irshift__.long2", long2, byref(self), _other) + @func(inline='always') + def __and__(self, _other: tp.Union['long2', i64, int]) -> 'long2': return intrinsic("binop.__and__.long2", long2, self, _other) + @func(inline='always') + def __rand__(self, _other: tp.Union['long2', i64, int]) -> 'long2': return intrinsic("binop.__rand__.long2", long2, self, _other) + @func(inline='always') + def __iand__(self, _other: tp.Union['long2', i64, int]) -> 'long2': return intrinsic("binop.__iand__.long2", long2, byref(self), _other) + @func(inline='always') + def __or__(self, _other: tp.Union['long2', i64, int]) -> 'long2': return intrinsic("binop.__or__.long2", long2, self, _other) + @func(inline='always') + def __ror__(self, _other: tp.Union['long2', i64, int]) -> 'long2': return intrinsic("binop.__ror__.long2", long2, self, _other) + @func(inline='always') + def __ior__(self, _other: tp.Union['long2', i64, int]) -> 'long2': return intrinsic("binop.__ior__.long2", long2, byref(self), _other) + @func(inline='always') + def __xor__(self, _other: tp.Union['long2', i64, int]) -> 'long2': return intrinsic("binop.__xor__.long2", long2, self, _other) + @func(inline='always') + def __rxor__(self, _other: tp.Union['long2', i64, int]) -> 'long2': return intrinsic("binop.__rxor__.long2", long2, self, _other) + @func(inline='always') + def __ixor__(self, _other: tp.Union['long2', i64, int]) -> 'long2': return intrinsic("binop.__ixor__.long2", long2, byref(self), _other) @builtin_type(_hir.VectorType(tp.cast(_hir.ScalarType, _ctx.types[u64]), 2)) class ulong2: x: u64 y: u64 def __init__(self, x: tp.Union['u64', int] = 0, y: tp.Union['u64', int] = 0) -> None: self = intrinsic("init.ulong2", ulong2, x, y) - def __add__(self, _other: tp.Union['ulong2', u64, int]) -> 'ulong2': return intrinsic("binop.__add__.ulong2", ulong2, _other) - def __radd__(self, _other: tp.Union['ulong2', u64, int]) -> 'ulong2': return intrinsic("binop.__radd__.ulong2", ulong2, _other) - def __iadd__(self, _other: tp.Union['ulong2', u64, int]) -> 'ulong2': return intrinsic("binop.__iadd__.ulong2", ulong2, _other) - def __sub__(self, _other: tp.Union['ulong2', u64, int]) -> 'ulong2': return intrinsic("binop.__sub__.ulong2", ulong2, _other) - def __rsub__(self, _other: tp.Union['ulong2', u64, int]) -> 'ulong2': return intrinsic("binop.__rsub__.ulong2", ulong2, _other) - def __isub__(self, _other: tp.Union['ulong2', u64, int]) -> 'ulong2': return intrinsic("binop.__isub__.ulong2", ulong2, _other) - def __mul__(self, _other: tp.Union['ulong2', u64, int]) -> 'ulong2': return intrinsic("binop.__mul__.ulong2", ulong2, _other) - def __rmul__(self, _other: tp.Union['ulong2', u64, int]) -> 'ulong2': return intrinsic("binop.__rmul__.ulong2", ulong2, _other) - def __imul__(self, _other: tp.Union['ulong2', u64, int]) -> 'ulong2': return intrinsic("binop.__imul__.ulong2", ulong2, _other) - def __mod__(self, _other: tp.Union['ulong2', u64, int]) -> 'ulong2': return intrinsic("binop.__mod__.ulong2", ulong2, _other) - def __rmod__(self, _other: tp.Union['ulong2', u64, int]) -> 'ulong2': return intrinsic("binop.__rmod__.ulong2", ulong2, _other) - def __imod__(self, _other: tp.Union['ulong2', u64, int]) -> 'ulong2': return intrinsic("binop.__imod__.ulong2", ulong2, _other) - def __lt__(self, _other: tp.Union['ulong2', u64, int]) -> 'bool2': return intrinsic("cmp.__lt__.ulong2", bool2, _other) # type: ignore[override] - def __le__(self, _other: tp.Union['ulong2', u64, int]) -> 'bool2': return intrinsic("cmp.__le__.ulong2", bool2, _other) # type: ignore[override] - def __gt__(self, _other: tp.Union['ulong2', u64, int]) -> 'bool2': return intrinsic("cmp.__gt__.ulong2", bool2, _other) # type: ignore[override] - def __ge__(self, _other: tp.Union['ulong2', u64, int]) -> 'bool2': return intrinsic("cmp.__ge__.ulong2", bool2, _other) # type: ignore[override] - def __eq__(self, _other: tp.Union['ulong2', u64, int]) -> 'bool2': return intrinsic("cmp.__eq__.ulong2", bool2, _other) # type: ignore[override] - def __ne__(self, _other: tp.Union['ulong2', u64, int]) -> 'bool2': return intrinsic("cmp.__ne__.ulong2", bool2, _other) # type: ignore[override] - def __floordiv__(self, _other: tp.Union['ulong2', u64, int]) -> 'ulong2': return intrinsic("binop.__floordiv__.ulong2", ulong2, _other) - def __rfloordiv__(self, _other: tp.Union['ulong2', u64, int]) -> 'ulong2': return intrinsic("binop.__rfloordiv__.ulong2", ulong2, _other) - def __ifloordiv__(self, _other: tp.Union['ulong2', u64, int]) -> 'ulong2': return intrinsic("binop.__ifloordiv__.ulong2", ulong2, _other) - def __lshift__(self, _other: tp.Union['ulong2', u64, int]) -> 'ulong2': return intrinsic("binop.__lshift__.ulong2", ulong2, _other) - def __rlshift__(self, _other: tp.Union['ulong2', u64, int]) -> 'ulong2': return intrinsic("binop.__rlshift__.ulong2", ulong2, _other) - def __ilshift__(self, _other: tp.Union['ulong2', u64, int]) -> 'ulong2': return intrinsic("binop.__ilshift__.ulong2", ulong2, _other) - def __rshift__(self, _other: tp.Union['ulong2', u64, int]) -> 'ulong2': return intrinsic("binop.__rshift__.ulong2", ulong2, _other) - def __rrshift__(self, _other: tp.Union['ulong2', u64, int]) -> 'ulong2': return intrinsic("binop.__rrshift__.ulong2", ulong2, _other) - def __irshift__(self, _other: tp.Union['ulong2', u64, int]) -> 'ulong2': return intrinsic("binop.__irshift__.ulong2", ulong2, _other) - def __and__(self, _other: tp.Union['ulong2', u64, int]) -> 'ulong2': return intrinsic("binop.__and__.ulong2", ulong2, _other) - def __rand__(self, _other: tp.Union['ulong2', u64, int]) -> 'ulong2': return intrinsic("binop.__rand__.ulong2", ulong2, _other) - def __iand__(self, _other: tp.Union['ulong2', u64, int]) -> 'ulong2': return intrinsic("binop.__iand__.ulong2", ulong2, _other) - def __or__(self, _other: tp.Union['ulong2', u64, int]) -> 'ulong2': return intrinsic("binop.__or__.ulong2", ulong2, _other) - def __ror__(self, _other: tp.Union['ulong2', u64, int]) -> 'ulong2': return intrinsic("binop.__ror__.ulong2", ulong2, _other) - def __ior__(self, _other: tp.Union['ulong2', u64, int]) -> 'ulong2': return intrinsic("binop.__ior__.ulong2", ulong2, _other) - def __xor__(self, _other: tp.Union['ulong2', u64, int]) -> 'ulong2': return intrinsic("binop.__xor__.ulong2", ulong2, _other) - def __rxor__(self, _other: tp.Union['ulong2', u64, int]) -> 'ulong2': return intrinsic("binop.__rxor__.ulong2", ulong2, _other) - def __ixor__(self, _other: tp.Union['ulong2', u64, int]) -> 'ulong2': return intrinsic("binop.__ixor__.ulong2", ulong2, _other) + @func(inline='always') + def __add__(self, _other: tp.Union['ulong2', u64, int]) -> 'ulong2': return intrinsic("binop.__add__.ulong2", ulong2, self, _other) + @func(inline='always') + def __radd__(self, _other: tp.Union['ulong2', u64, int]) -> 'ulong2': return intrinsic("binop.__radd__.ulong2", ulong2, self, _other) + @func(inline='always') + def __iadd__(self, _other: tp.Union['ulong2', u64, int]) -> 'ulong2': return intrinsic("binop.__iadd__.ulong2", ulong2, byref(self), _other) + @func(inline='always') + def __sub__(self, _other: tp.Union['ulong2', u64, int]) -> 'ulong2': return intrinsic("binop.__sub__.ulong2", ulong2, self, _other) + @func(inline='always') + def __rsub__(self, _other: tp.Union['ulong2', u64, int]) -> 'ulong2': return intrinsic("binop.__rsub__.ulong2", ulong2, self, _other) + @func(inline='always') + def __isub__(self, _other: tp.Union['ulong2', u64, int]) -> 'ulong2': return intrinsic("binop.__isub__.ulong2", ulong2, byref(self), _other) + @func(inline='always') + def __mul__(self, _other: tp.Union['ulong2', u64, int]) -> 'ulong2': return intrinsic("binop.__mul__.ulong2", ulong2, self, _other) + @func(inline='always') + def __rmul__(self, _other: tp.Union['ulong2', u64, int]) -> 'ulong2': return intrinsic("binop.__rmul__.ulong2", ulong2, self, _other) + @func(inline='always') + def __imul__(self, _other: tp.Union['ulong2', u64, int]) -> 'ulong2': return intrinsic("binop.__imul__.ulong2", ulong2, byref(self), _other) + @func(inline='always') + def __mod__(self, _other: tp.Union['ulong2', u64, int]) -> 'ulong2': return intrinsic("binop.__mod__.ulong2", ulong2, self, _other) + @func(inline='always') + def __rmod__(self, _other: tp.Union['ulong2', u64, int]) -> 'ulong2': return intrinsic("binop.__rmod__.ulong2", ulong2, self, _other) + @func(inline='always') + def __imod__(self, _other: tp.Union['ulong2', u64, int]) -> 'ulong2': return intrinsic("binop.__imod__.ulong2", ulong2, byref(self), _other) + @func(inline='always') + def __lt__(self, _other: tp.Union['ulong2', u64, int]) -> 'bool2': return intrinsic("cmp.__lt__.ulong2", bool2, self, _other) # type: ignore[override] + @func(inline='always') + def __le__(self, _other: tp.Union['ulong2', u64, int]) -> 'bool2': return intrinsic("cmp.__le__.ulong2", bool2, self, _other) # type: ignore[override] + @func(inline='always') + def __gt__(self, _other: tp.Union['ulong2', u64, int]) -> 'bool2': return intrinsic("cmp.__gt__.ulong2", bool2, self, _other) # type: ignore[override] + @func(inline='always') + def __ge__(self, _other: tp.Union['ulong2', u64, int]) -> 'bool2': return intrinsic("cmp.__ge__.ulong2", bool2, self, _other) # type: ignore[override] + @func(inline='always') + def __eq__(self, _other: tp.Union['ulong2', u64, int]) -> 'bool2': return intrinsic("cmp.__eq__.ulong2", bool2, self, _other) # type: ignore[override] + @func(inline='always') + def __ne__(self, _other: tp.Union['ulong2', u64, int]) -> 'bool2': return intrinsic("cmp.__ne__.ulong2", bool2, self, _other) # type: ignore[override] + @func(inline='always') + def __floordiv__(self, _other: tp.Union['ulong2', u64, int]) -> 'ulong2': return intrinsic("binop.__floordiv__.ulong2", ulong2, self, _other) + @func(inline='always') + def __rfloordiv__(self, _other: tp.Union['ulong2', u64, int]) -> 'ulong2': return intrinsic("binop.__rfloordiv__.ulong2", ulong2, self, _other) + @func(inline='always') + def __ifloordiv__(self, _other: tp.Union['ulong2', u64, int]) -> 'ulong2': return intrinsic("binop.__ifloordiv__.ulong2", ulong2, byref(self), _other) + @func(inline='always') + def __lshift__(self, _other: tp.Union['ulong2', u64, int]) -> 'ulong2': return intrinsic("binop.__lshift__.ulong2", ulong2, self, _other) + @func(inline='always') + def __rlshift__(self, _other: tp.Union['ulong2', u64, int]) -> 'ulong2': return intrinsic("binop.__rlshift__.ulong2", ulong2, self, _other) + @func(inline='always') + def __ilshift__(self, _other: tp.Union['ulong2', u64, int]) -> 'ulong2': return intrinsic("binop.__ilshift__.ulong2", ulong2, byref(self), _other) + @func(inline='always') + def __rshift__(self, _other: tp.Union['ulong2', u64, int]) -> 'ulong2': return intrinsic("binop.__rshift__.ulong2", ulong2, self, _other) + @func(inline='always') + def __rrshift__(self, _other: tp.Union['ulong2', u64, int]) -> 'ulong2': return intrinsic("binop.__rrshift__.ulong2", ulong2, self, _other) + @func(inline='always') + def __irshift__(self, _other: tp.Union['ulong2', u64, int]) -> 'ulong2': return intrinsic("binop.__irshift__.ulong2", ulong2, byref(self), _other) + @func(inline='always') + def __and__(self, _other: tp.Union['ulong2', u64, int]) -> 'ulong2': return intrinsic("binop.__and__.ulong2", ulong2, self, _other) + @func(inline='always') + def __rand__(self, _other: tp.Union['ulong2', u64, int]) -> 'ulong2': return intrinsic("binop.__rand__.ulong2", ulong2, self, _other) + @func(inline='always') + def __iand__(self, _other: tp.Union['ulong2', u64, int]) -> 'ulong2': return intrinsic("binop.__iand__.ulong2", ulong2, byref(self), _other) + @func(inline='always') + def __or__(self, _other: tp.Union['ulong2', u64, int]) -> 'ulong2': return intrinsic("binop.__or__.ulong2", ulong2, self, _other) + @func(inline='always') + def __ror__(self, _other: tp.Union['ulong2', u64, int]) -> 'ulong2': return intrinsic("binop.__ror__.ulong2", ulong2, self, _other) + @func(inline='always') + def __ior__(self, _other: tp.Union['ulong2', u64, int]) -> 'ulong2': return intrinsic("binop.__ior__.ulong2", ulong2, byref(self), _other) + @func(inline='always') + def __xor__(self, _other: tp.Union['ulong2', u64, int]) -> 'ulong2': return intrinsic("binop.__xor__.ulong2", ulong2, self, _other) + @func(inline='always') + def __rxor__(self, _other: tp.Union['ulong2', u64, int]) -> 'ulong2': return intrinsic("binop.__rxor__.ulong2", ulong2, self, _other) + @func(inline='always') + def __ixor__(self, _other: tp.Union['ulong2', u64, int]) -> 'ulong2': return intrinsic("binop.__ixor__.ulong2", ulong2, byref(self), _other) @builtin_type(_hir.VectorType(tp.cast(_hir.ScalarType, _ctx.types[bool]), 3)) class bool3: @@ -921,17 +1673,28 @@ class bool3: y: bool z: bool def __init__(self, x: tp.Union['bool', bool] = False, y: tp.Union['bool', bool] = False, z: tp.Union['bool', bool] = False) -> None: self = intrinsic("init.bool3", bool3, x, y, z) - def __eq__(self, _other: tp.Union['bool3', bool, bool]) -> 'bool3': return intrinsic("cmp.__eq__.bool3", bool3, _other) # type: ignore[override] - def __ne__(self, _other: tp.Union['bool3', bool, bool]) -> 'bool3': return intrinsic("cmp.__ne__.bool3", bool3, _other) # type: ignore[override] - def __and__(self, _other: tp.Union['bool3', bool, bool]) -> 'bool3': return intrinsic("binop.__and__.bool3", bool3, _other) - def __rand__(self, _other: tp.Union['bool3', bool, bool]) -> 'bool3': return intrinsic("binop.__rand__.bool3", bool3, _other) - def __iand__(self, _other: tp.Union['bool3', bool, bool]) -> 'bool3': return intrinsic("binop.__iand__.bool3", bool3, _other) - def __or__(self, _other: tp.Union['bool3', bool, bool]) -> 'bool3': return intrinsic("binop.__or__.bool3", bool3, _other) - def __ror__(self, _other: tp.Union['bool3', bool, bool]) -> 'bool3': return intrinsic("binop.__ror__.bool3", bool3, _other) - def __ior__(self, _other: tp.Union['bool3', bool, bool]) -> 'bool3': return intrinsic("binop.__ior__.bool3", bool3, _other) - def __xor__(self, _other: tp.Union['bool3', bool, bool]) -> 'bool3': return intrinsic("binop.__xor__.bool3", bool3, _other) - def __rxor__(self, _other: tp.Union['bool3', bool, bool]) -> 'bool3': return intrinsic("binop.__rxor__.bool3", bool3, _other) - def __ixor__(self, _other: tp.Union['bool3', bool, bool]) -> 'bool3': return intrinsic("binop.__ixor__.bool3", bool3, _other) + @func(inline='always') + def __eq__(self, _other: tp.Union['bool3', bool, bool]) -> 'bool3': return intrinsic("cmp.__eq__.bool3", bool3, self, _other) # type: ignore[override] + @func(inline='always') + def __ne__(self, _other: tp.Union['bool3', bool, bool]) -> 'bool3': return intrinsic("cmp.__ne__.bool3", bool3, self, _other) # type: ignore[override] + @func(inline='always') + def __and__(self, _other: tp.Union['bool3', bool, bool]) -> 'bool3': return intrinsic("binop.__and__.bool3", bool3, self, _other) + @func(inline='always') + def __rand__(self, _other: tp.Union['bool3', bool, bool]) -> 'bool3': return intrinsic("binop.__rand__.bool3", bool3, self, _other) + @func(inline='always') + def __iand__(self, _other: tp.Union['bool3', bool, bool]) -> 'bool3': return intrinsic("binop.__iand__.bool3", bool3, byref(self), _other) + @func(inline='always') + def __or__(self, _other: tp.Union['bool3', bool, bool]) -> 'bool3': return intrinsic("binop.__or__.bool3", bool3, self, _other) + @func(inline='always') + def __ror__(self, _other: tp.Union['bool3', bool, bool]) -> 'bool3': return intrinsic("binop.__ror__.bool3", bool3, self, _other) + @func(inline='always') + def __ior__(self, _other: tp.Union['bool3', bool, bool]) -> 'bool3': return intrinsic("binop.__ior__.bool3", bool3, byref(self), _other) + @func(inline='always') + def __xor__(self, _other: tp.Union['bool3', bool, bool]) -> 'bool3': return intrinsic("binop.__xor__.bool3", bool3, self, _other) + @func(inline='always') + def __rxor__(self, _other: tp.Union['bool3', bool, bool]) -> 'bool3': return intrinsic("binop.__rxor__.bool3", bool3, self, _other) + @func(inline='always') + def __ixor__(self, _other: tp.Union['bool3', bool, bool]) -> 'bool3': return intrinsic("binop.__ixor__.bool3", bool3, byref(self), _other) @builtin_type(_hir.VectorType(tp.cast(_hir.ScalarType, _ctx.types[f32]), 3)) class float3(FloatBuiltin['float3']): @@ -939,32 +1702,58 @@ class float3(FloatBuiltin['float3']): y: f32 z: f32 def __init__(self, x: tp.Union['f32', float] = 0.0, y: tp.Union['f32', float] = 0.0, z: tp.Union['f32', float] = 0.0) -> None: self = intrinsic("init.float3", float3, x, y, z) - def __add__(self, _other: tp.Union['float3', f32, float]) -> 'float3': return intrinsic("binop.__add__.float3", float3, _other) - def __radd__(self, _other: tp.Union['float3', f32, float]) -> 'float3': return intrinsic("binop.__radd__.float3", float3, _other) - def __iadd__(self, _other: tp.Union['float3', f32, float]) -> 'float3': return intrinsic("binop.__iadd__.float3", float3, _other) - def __sub__(self, _other: tp.Union['float3', f32, float]) -> 'float3': return intrinsic("binop.__sub__.float3", float3, _other) - def __rsub__(self, _other: tp.Union['float3', f32, float]) -> 'float3': return intrinsic("binop.__rsub__.float3", float3, _other) - def __isub__(self, _other: tp.Union['float3', f32, float]) -> 'float3': return intrinsic("binop.__isub__.float3", float3, _other) - def __mul__(self, _other: tp.Union['float3', f32, float]) -> 'float3': return intrinsic("binop.__mul__.float3", float3, _other) - def __rmul__(self, _other: tp.Union['float3', f32, float]) -> 'float3': return intrinsic("binop.__rmul__.float3", float3, _other) - def __imul__(self, _other: tp.Union['float3', f32, float]) -> 'float3': return intrinsic("binop.__imul__.float3", float3, _other) - def __mod__(self, _other: tp.Union['float3', f32, float]) -> 'float3': return intrinsic("binop.__mod__.float3", float3, _other) - def __rmod__(self, _other: tp.Union['float3', f32, float]) -> 'float3': return intrinsic("binop.__rmod__.float3", float3, _other) - def __imod__(self, _other: tp.Union['float3', f32, float]) -> 'float3': return intrinsic("binop.__imod__.float3", float3, _other) - def __lt__(self, _other: tp.Union['float3', f32, float]) -> 'bool3': return intrinsic("cmp.__lt__.float3", bool3, _other) # type: ignore[override] - def __le__(self, _other: tp.Union['float3', f32, float]) -> 'bool3': return intrinsic("cmp.__le__.float3", bool3, _other) # type: ignore[override] - def __gt__(self, _other: tp.Union['float3', f32, float]) -> 'bool3': return intrinsic("cmp.__gt__.float3", bool3, _other) # type: ignore[override] - def __ge__(self, _other: tp.Union['float3', f32, float]) -> 'bool3': return intrinsic("cmp.__ge__.float3", bool3, _other) # type: ignore[override] - def __eq__(self, _other: tp.Union['float3', f32, float]) -> 'bool3': return intrinsic("cmp.__eq__.float3", bool3, _other) # type: ignore[override] - def __ne__(self, _other: tp.Union['float3', f32, float]) -> 'bool3': return intrinsic("cmp.__ne__.float3", bool3, _other) # type: ignore[override] - def __truediv__(self, _other: tp.Union['float3', f32, float]) -> 'float3': return intrinsic("binop.__truediv__.float3", float3, _other) - def __rtruediv__(self, _other: tp.Union['float3', f32, float]) -> 'float3': return intrinsic("binop.__rtruediv__.float3", float3, _other) - def __itruediv__(self, _other: tp.Union['float3', f32, float]) -> 'float3': return intrinsic("binop.__itruediv__.float3", float3, _other) - def __pow__(self, _other: tp.Union['float3', f32, float]) -> 'float3': return intrinsic("binop.__pow__.float3", float3, _other) - def __rpow__(self, _other: tp.Union['float3', f32, float]) -> 'float3': return intrinsic("binop.__rpow__.float3", float3, _other) - def __ipow__(self, _other: tp.Union['float3', f32, float]) -> 'float3': return intrinsic("binop.__ipow__.float3", float3, _other) - def __floordiv__(self, _other: tp.Union['float3', f32, float]) -> 'float3': return intrinsic("binop.__floordiv__.float3", float3, _other) - def __rfloordiv__(self, _other: tp.Union['float3', f32, float]) -> 'float3': return intrinsic("binop.__rfloordiv__.float3", float3, _other) + @func(inline='always') + def __add__(self, _other: tp.Union['float3', f32, float]) -> 'float3': return intrinsic("binop.__add__.float3", float3, self, _other) + @func(inline='always') + def __radd__(self, _other: tp.Union['float3', f32, float]) -> 'float3': return intrinsic("binop.__radd__.float3", float3, self, _other) + @func(inline='always') + def __iadd__(self, _other: tp.Union['float3', f32, float]) -> 'float3': return intrinsic("binop.__iadd__.float3", float3, byref(self), _other) + @func(inline='always') + def __sub__(self, _other: tp.Union['float3', f32, float]) -> 'float3': return intrinsic("binop.__sub__.float3", float3, self, _other) + @func(inline='always') + def __rsub__(self, _other: tp.Union['float3', f32, float]) -> 'float3': return intrinsic("binop.__rsub__.float3", float3, self, _other) + @func(inline='always') + def __isub__(self, _other: tp.Union['float3', f32, float]) -> 'float3': return intrinsic("binop.__isub__.float3", float3, byref(self), _other) + @func(inline='always') + def __mul__(self, _other: tp.Union['float3', f32, float]) -> 'float3': return intrinsic("binop.__mul__.float3", float3, self, _other) + @func(inline='always') + def __rmul__(self, _other: tp.Union['float3', f32, float]) -> 'float3': return intrinsic("binop.__rmul__.float3", float3, self, _other) + @func(inline='always') + def __imul__(self, _other: tp.Union['float3', f32, float]) -> 'float3': return intrinsic("binop.__imul__.float3", float3, byref(self), _other) + @func(inline='always') + def __mod__(self, _other: tp.Union['float3', f32, float]) -> 'float3': return intrinsic("binop.__mod__.float3", float3, self, _other) + @func(inline='always') + def __rmod__(self, _other: tp.Union['float3', f32, float]) -> 'float3': return intrinsic("binop.__rmod__.float3", float3, self, _other) + @func(inline='always') + def __imod__(self, _other: tp.Union['float3', f32, float]) -> 'float3': return intrinsic("binop.__imod__.float3", float3, byref(self), _other) + @func(inline='always') + def __lt__(self, _other: tp.Union['float3', f32, float]) -> 'bool3': return intrinsic("cmp.__lt__.float3", bool3, self, _other) # type: ignore[override] + @func(inline='always') + def __le__(self, _other: tp.Union['float3', f32, float]) -> 'bool3': return intrinsic("cmp.__le__.float3", bool3, self, _other) # type: ignore[override] + @func(inline='always') + def __gt__(self, _other: tp.Union['float3', f32, float]) -> 'bool3': return intrinsic("cmp.__gt__.float3", bool3, self, _other) # type: ignore[override] + @func(inline='always') + def __ge__(self, _other: tp.Union['float3', f32, float]) -> 'bool3': return intrinsic("cmp.__ge__.float3", bool3, self, _other) # type: ignore[override] + @func(inline='always') + def __eq__(self, _other: tp.Union['float3', f32, float]) -> 'bool3': return intrinsic("cmp.__eq__.float3", bool3, self, _other) # type: ignore[override] + @func(inline='always') + def __ne__(self, _other: tp.Union['float3', f32, float]) -> 'bool3': return intrinsic("cmp.__ne__.float3", bool3, self, _other) # type: ignore[override] + @func(inline='always') + def __truediv__(self, _other: tp.Union['float3', f32, float]) -> 'float3': return intrinsic("binop.__truediv__.float3", float3, self, _other) + @func(inline='always') + def __rtruediv__(self, _other: tp.Union['float3', f32, float]) -> 'float3': return intrinsic("binop.__rtruediv__.float3", float3, self, _other) + @func(inline='always') + def __itruediv__(self, _other: tp.Union['float3', f32, float]) -> 'float3': return intrinsic("binop.__itruediv__.float3", float3, byref(self), _other) + @func(inline='always') + def __pow__(self, _other: tp.Union['float3', f32, float]) -> 'float3': return intrinsic("binop.__pow__.float3", float3, self, _other) + @func(inline='always') + def __rpow__(self, _other: tp.Union['float3', f32, float]) -> 'float3': return intrinsic("binop.__rpow__.float3", float3, self, _other) + @func(inline='always') + def __ipow__(self, _other: tp.Union['float3', f32, float]) -> 'float3': return intrinsic("binop.__ipow__.float3", float3, byref(self), _other) + @func(inline='always') + def __floordiv__(self, _other: tp.Union['float3', f32, float]) -> 'float3': return intrinsic("binop.__floordiv__.float3", float3, self, _other) + @func(inline='always') + def __rfloordiv__(self, _other: tp.Union['float3', f32, float]) -> 'float3': return intrinsic("binop.__rfloordiv__.float3", float3, self, _other) @builtin_type(_hir.VectorType(tp.cast(_hir.ScalarType, _ctx.types[f64]), 3)) class double3(FloatBuiltin['double3']): @@ -972,32 +1761,58 @@ class double3(FloatBuiltin['double3']): y: f64 z: f64 def __init__(self, x: tp.Union['f64', float] = 0.0, y: tp.Union['f64', float] = 0.0, z: tp.Union['f64', float] = 0.0) -> None: self = intrinsic("init.double3", double3, x, y, z) - def __add__(self, _other: tp.Union['double3', f64, float]) -> 'double3': return intrinsic("binop.__add__.double3", double3, _other) - def __radd__(self, _other: tp.Union['double3', f64, float]) -> 'double3': return intrinsic("binop.__radd__.double3", double3, _other) - def __iadd__(self, _other: tp.Union['double3', f64, float]) -> 'double3': return intrinsic("binop.__iadd__.double3", double3, _other) - def __sub__(self, _other: tp.Union['double3', f64, float]) -> 'double3': return intrinsic("binop.__sub__.double3", double3, _other) - def __rsub__(self, _other: tp.Union['double3', f64, float]) -> 'double3': return intrinsic("binop.__rsub__.double3", double3, _other) - def __isub__(self, _other: tp.Union['double3', f64, float]) -> 'double3': return intrinsic("binop.__isub__.double3", double3, _other) - def __mul__(self, _other: tp.Union['double3', f64, float]) -> 'double3': return intrinsic("binop.__mul__.double3", double3, _other) - def __rmul__(self, _other: tp.Union['double3', f64, float]) -> 'double3': return intrinsic("binop.__rmul__.double3", double3, _other) - def __imul__(self, _other: tp.Union['double3', f64, float]) -> 'double3': return intrinsic("binop.__imul__.double3", double3, _other) - def __mod__(self, _other: tp.Union['double3', f64, float]) -> 'double3': return intrinsic("binop.__mod__.double3", double3, _other) - def __rmod__(self, _other: tp.Union['double3', f64, float]) -> 'double3': return intrinsic("binop.__rmod__.double3", double3, _other) - def __imod__(self, _other: tp.Union['double3', f64, float]) -> 'double3': return intrinsic("binop.__imod__.double3", double3, _other) - def __lt__(self, _other: tp.Union['double3', f64, float]) -> 'bool3': return intrinsic("cmp.__lt__.double3", bool3, _other) # type: ignore[override] - def __le__(self, _other: tp.Union['double3', f64, float]) -> 'bool3': return intrinsic("cmp.__le__.double3", bool3, _other) # type: ignore[override] - def __gt__(self, _other: tp.Union['double3', f64, float]) -> 'bool3': return intrinsic("cmp.__gt__.double3", bool3, _other) # type: ignore[override] - def __ge__(self, _other: tp.Union['double3', f64, float]) -> 'bool3': return intrinsic("cmp.__ge__.double3", bool3, _other) # type: ignore[override] - def __eq__(self, _other: tp.Union['double3', f64, float]) -> 'bool3': return intrinsic("cmp.__eq__.double3", bool3, _other) # type: ignore[override] - def __ne__(self, _other: tp.Union['double3', f64, float]) -> 'bool3': return intrinsic("cmp.__ne__.double3", bool3, _other) # type: ignore[override] - def __truediv__(self, _other: tp.Union['double3', f64, float]) -> 'double3': return intrinsic("binop.__truediv__.double3", double3, _other) - def __rtruediv__(self, _other: tp.Union['double3', f64, float]) -> 'double3': return intrinsic("binop.__rtruediv__.double3", double3, _other) - def __itruediv__(self, _other: tp.Union['double3', f64, float]) -> 'double3': return intrinsic("binop.__itruediv__.double3", double3, _other) - def __pow__(self, _other: tp.Union['double3', f64, float]) -> 'double3': return intrinsic("binop.__pow__.double3", double3, _other) - def __rpow__(self, _other: tp.Union['double3', f64, float]) -> 'double3': return intrinsic("binop.__rpow__.double3", double3, _other) - def __ipow__(self, _other: tp.Union['double3', f64, float]) -> 'double3': return intrinsic("binop.__ipow__.double3", double3, _other) - def __floordiv__(self, _other: tp.Union['double3', f64, float]) -> 'double3': return intrinsic("binop.__floordiv__.double3", double3, _other) - def __rfloordiv__(self, _other: tp.Union['double3', f64, float]) -> 'double3': return intrinsic("binop.__rfloordiv__.double3", double3, _other) + @func(inline='always') + def __add__(self, _other: tp.Union['double3', f64, float]) -> 'double3': return intrinsic("binop.__add__.double3", double3, self, _other) + @func(inline='always') + def __radd__(self, _other: tp.Union['double3', f64, float]) -> 'double3': return intrinsic("binop.__radd__.double3", double3, self, _other) + @func(inline='always') + def __iadd__(self, _other: tp.Union['double3', f64, float]) -> 'double3': return intrinsic("binop.__iadd__.double3", double3, byref(self), _other) + @func(inline='always') + def __sub__(self, _other: tp.Union['double3', f64, float]) -> 'double3': return intrinsic("binop.__sub__.double3", double3, self, _other) + @func(inline='always') + def __rsub__(self, _other: tp.Union['double3', f64, float]) -> 'double3': return intrinsic("binop.__rsub__.double3", double3, self, _other) + @func(inline='always') + def __isub__(self, _other: tp.Union['double3', f64, float]) -> 'double3': return intrinsic("binop.__isub__.double3", double3, byref(self), _other) + @func(inline='always') + def __mul__(self, _other: tp.Union['double3', f64, float]) -> 'double3': return intrinsic("binop.__mul__.double3", double3, self, _other) + @func(inline='always') + def __rmul__(self, _other: tp.Union['double3', f64, float]) -> 'double3': return intrinsic("binop.__rmul__.double3", double3, self, _other) + @func(inline='always') + def __imul__(self, _other: tp.Union['double3', f64, float]) -> 'double3': return intrinsic("binop.__imul__.double3", double3, byref(self), _other) + @func(inline='always') + def __mod__(self, _other: tp.Union['double3', f64, float]) -> 'double3': return intrinsic("binop.__mod__.double3", double3, self, _other) + @func(inline='always') + def __rmod__(self, _other: tp.Union['double3', f64, float]) -> 'double3': return intrinsic("binop.__rmod__.double3", double3, self, _other) + @func(inline='always') + def __imod__(self, _other: tp.Union['double3', f64, float]) -> 'double3': return intrinsic("binop.__imod__.double3", double3, byref(self), _other) + @func(inline='always') + def __lt__(self, _other: tp.Union['double3', f64, float]) -> 'bool3': return intrinsic("cmp.__lt__.double3", bool3, self, _other) # type: ignore[override] + @func(inline='always') + def __le__(self, _other: tp.Union['double3', f64, float]) -> 'bool3': return intrinsic("cmp.__le__.double3", bool3, self, _other) # type: ignore[override] + @func(inline='always') + def __gt__(self, _other: tp.Union['double3', f64, float]) -> 'bool3': return intrinsic("cmp.__gt__.double3", bool3, self, _other) # type: ignore[override] + @func(inline='always') + def __ge__(self, _other: tp.Union['double3', f64, float]) -> 'bool3': return intrinsic("cmp.__ge__.double3", bool3, self, _other) # type: ignore[override] + @func(inline='always') + def __eq__(self, _other: tp.Union['double3', f64, float]) -> 'bool3': return intrinsic("cmp.__eq__.double3", bool3, self, _other) # type: ignore[override] + @func(inline='always') + def __ne__(self, _other: tp.Union['double3', f64, float]) -> 'bool3': return intrinsic("cmp.__ne__.double3", bool3, self, _other) # type: ignore[override] + @func(inline='always') + def __truediv__(self, _other: tp.Union['double3', f64, float]) -> 'double3': return intrinsic("binop.__truediv__.double3", double3, self, _other) + @func(inline='always') + def __rtruediv__(self, _other: tp.Union['double3', f64, float]) -> 'double3': return intrinsic("binop.__rtruediv__.double3", double3, self, _other) + @func(inline='always') + def __itruediv__(self, _other: tp.Union['double3', f64, float]) -> 'double3': return intrinsic("binop.__itruediv__.double3", double3, byref(self), _other) + @func(inline='always') + def __pow__(self, _other: tp.Union['double3', f64, float]) -> 'double3': return intrinsic("binop.__pow__.double3", double3, self, _other) + @func(inline='always') + def __rpow__(self, _other: tp.Union['double3', f64, float]) -> 'double3': return intrinsic("binop.__rpow__.double3", double3, self, _other) + @func(inline='always') + def __ipow__(self, _other: tp.Union['double3', f64, float]) -> 'double3': return intrinsic("binop.__ipow__.double3", double3, byref(self), _other) + @func(inline='always') + def __floordiv__(self, _other: tp.Union['double3', f64, float]) -> 'double3': return intrinsic("binop.__floordiv__.double3", double3, self, _other) + @func(inline='always') + def __rfloordiv__(self, _other: tp.Union['double3', f64, float]) -> 'double3': return intrinsic("binop.__rfloordiv__.double3", double3, self, _other) @builtin_type(_hir.VectorType(tp.cast(_hir.ScalarType, _ctx.types[i8]), 3)) class byte3: @@ -1005,42 +1820,78 @@ class byte3: y: i8 z: i8 def __init__(self, x: tp.Union['i8', int] = 0, y: tp.Union['i8', int] = 0, z: tp.Union['i8', int] = 0) -> None: self = intrinsic("init.byte3", byte3, x, y, z) - def __add__(self, _other: tp.Union['byte3', i8, int]) -> 'byte3': return intrinsic("binop.__add__.byte3", byte3, _other) - def __radd__(self, _other: tp.Union['byte3', i8, int]) -> 'byte3': return intrinsic("binop.__radd__.byte3", byte3, _other) - def __iadd__(self, _other: tp.Union['byte3', i8, int]) -> 'byte3': return intrinsic("binop.__iadd__.byte3", byte3, _other) - def __sub__(self, _other: tp.Union['byte3', i8, int]) -> 'byte3': return intrinsic("binop.__sub__.byte3", byte3, _other) - def __rsub__(self, _other: tp.Union['byte3', i8, int]) -> 'byte3': return intrinsic("binop.__rsub__.byte3", byte3, _other) - def __isub__(self, _other: tp.Union['byte3', i8, int]) -> 'byte3': return intrinsic("binop.__isub__.byte3", byte3, _other) - def __mul__(self, _other: tp.Union['byte3', i8, int]) -> 'byte3': return intrinsic("binop.__mul__.byte3", byte3, _other) - def __rmul__(self, _other: tp.Union['byte3', i8, int]) -> 'byte3': return intrinsic("binop.__rmul__.byte3", byte3, _other) - def __imul__(self, _other: tp.Union['byte3', i8, int]) -> 'byte3': return intrinsic("binop.__imul__.byte3", byte3, _other) - def __mod__(self, _other: tp.Union['byte3', i8, int]) -> 'byte3': return intrinsic("binop.__mod__.byte3", byte3, _other) - def __rmod__(self, _other: tp.Union['byte3', i8, int]) -> 'byte3': return intrinsic("binop.__rmod__.byte3", byte3, _other) - def __imod__(self, _other: tp.Union['byte3', i8, int]) -> 'byte3': return intrinsic("binop.__imod__.byte3", byte3, _other) - def __lt__(self, _other: tp.Union['byte3', i8, int]) -> 'bool3': return intrinsic("cmp.__lt__.byte3", bool3, _other) # type: ignore[override] - def __le__(self, _other: tp.Union['byte3', i8, int]) -> 'bool3': return intrinsic("cmp.__le__.byte3", bool3, _other) # type: ignore[override] - def __gt__(self, _other: tp.Union['byte3', i8, int]) -> 'bool3': return intrinsic("cmp.__gt__.byte3", bool3, _other) # type: ignore[override] - def __ge__(self, _other: tp.Union['byte3', i8, int]) -> 'bool3': return intrinsic("cmp.__ge__.byte3", bool3, _other) # type: ignore[override] - def __eq__(self, _other: tp.Union['byte3', i8, int]) -> 'bool3': return intrinsic("cmp.__eq__.byte3", bool3, _other) # type: ignore[override] - def __ne__(self, _other: tp.Union['byte3', i8, int]) -> 'bool3': return intrinsic("cmp.__ne__.byte3", bool3, _other) # type: ignore[override] - def __floordiv__(self, _other: tp.Union['byte3', i8, int]) -> 'byte3': return intrinsic("binop.__floordiv__.byte3", byte3, _other) - def __rfloordiv__(self, _other: tp.Union['byte3', i8, int]) -> 'byte3': return intrinsic("binop.__rfloordiv__.byte3", byte3, _other) - def __ifloordiv__(self, _other: tp.Union['byte3', i8, int]) -> 'byte3': return intrinsic("binop.__ifloordiv__.byte3", byte3, _other) - def __lshift__(self, _other: tp.Union['byte3', i8, int]) -> 'byte3': return intrinsic("binop.__lshift__.byte3", byte3, _other) - def __rlshift__(self, _other: tp.Union['byte3', i8, int]) -> 'byte3': return intrinsic("binop.__rlshift__.byte3", byte3, _other) - def __ilshift__(self, _other: tp.Union['byte3', i8, int]) -> 'byte3': return intrinsic("binop.__ilshift__.byte3", byte3, _other) - def __rshift__(self, _other: tp.Union['byte3', i8, int]) -> 'byte3': return intrinsic("binop.__rshift__.byte3", byte3, _other) - def __rrshift__(self, _other: tp.Union['byte3', i8, int]) -> 'byte3': return intrinsic("binop.__rrshift__.byte3", byte3, _other) - def __irshift__(self, _other: tp.Union['byte3', i8, int]) -> 'byte3': return intrinsic("binop.__irshift__.byte3", byte3, _other) - def __and__(self, _other: tp.Union['byte3', i8, int]) -> 'byte3': return intrinsic("binop.__and__.byte3", byte3, _other) - def __rand__(self, _other: tp.Union['byte3', i8, int]) -> 'byte3': return intrinsic("binop.__rand__.byte3", byte3, _other) - def __iand__(self, _other: tp.Union['byte3', i8, int]) -> 'byte3': return intrinsic("binop.__iand__.byte3", byte3, _other) - def __or__(self, _other: tp.Union['byte3', i8, int]) -> 'byte3': return intrinsic("binop.__or__.byte3", byte3, _other) - def __ror__(self, _other: tp.Union['byte3', i8, int]) -> 'byte3': return intrinsic("binop.__ror__.byte3", byte3, _other) - def __ior__(self, _other: tp.Union['byte3', i8, int]) -> 'byte3': return intrinsic("binop.__ior__.byte3", byte3, _other) - def __xor__(self, _other: tp.Union['byte3', i8, int]) -> 'byte3': return intrinsic("binop.__xor__.byte3", byte3, _other) - def __rxor__(self, _other: tp.Union['byte3', i8, int]) -> 'byte3': return intrinsic("binop.__rxor__.byte3", byte3, _other) - def __ixor__(self, _other: tp.Union['byte3', i8, int]) -> 'byte3': return intrinsic("binop.__ixor__.byte3", byte3, _other) + @func(inline='always') + def __add__(self, _other: tp.Union['byte3', i8, int]) -> 'byte3': return intrinsic("binop.__add__.byte3", byte3, self, _other) + @func(inline='always') + def __radd__(self, _other: tp.Union['byte3', i8, int]) -> 'byte3': return intrinsic("binop.__radd__.byte3", byte3, self, _other) + @func(inline='always') + def __iadd__(self, _other: tp.Union['byte3', i8, int]) -> 'byte3': return intrinsic("binop.__iadd__.byte3", byte3, byref(self), _other) + @func(inline='always') + def __sub__(self, _other: tp.Union['byte3', i8, int]) -> 'byte3': return intrinsic("binop.__sub__.byte3", byte3, self, _other) + @func(inline='always') + def __rsub__(self, _other: tp.Union['byte3', i8, int]) -> 'byte3': return intrinsic("binop.__rsub__.byte3", byte3, self, _other) + @func(inline='always') + def __isub__(self, _other: tp.Union['byte3', i8, int]) -> 'byte3': return intrinsic("binop.__isub__.byte3", byte3, byref(self), _other) + @func(inline='always') + def __mul__(self, _other: tp.Union['byte3', i8, int]) -> 'byte3': return intrinsic("binop.__mul__.byte3", byte3, self, _other) + @func(inline='always') + def __rmul__(self, _other: tp.Union['byte3', i8, int]) -> 'byte3': return intrinsic("binop.__rmul__.byte3", byte3, self, _other) + @func(inline='always') + def __imul__(self, _other: tp.Union['byte3', i8, int]) -> 'byte3': return intrinsic("binop.__imul__.byte3", byte3, byref(self), _other) + @func(inline='always') + def __mod__(self, _other: tp.Union['byte3', i8, int]) -> 'byte3': return intrinsic("binop.__mod__.byte3", byte3, self, _other) + @func(inline='always') + def __rmod__(self, _other: tp.Union['byte3', i8, int]) -> 'byte3': return intrinsic("binop.__rmod__.byte3", byte3, self, _other) + @func(inline='always') + def __imod__(self, _other: tp.Union['byte3', i8, int]) -> 'byte3': return intrinsic("binop.__imod__.byte3", byte3, byref(self), _other) + @func(inline='always') + def __lt__(self, _other: tp.Union['byte3', i8, int]) -> 'bool3': return intrinsic("cmp.__lt__.byte3", bool3, self, _other) # type: ignore[override] + @func(inline='always') + def __le__(self, _other: tp.Union['byte3', i8, int]) -> 'bool3': return intrinsic("cmp.__le__.byte3", bool3, self, _other) # type: ignore[override] + @func(inline='always') + def __gt__(self, _other: tp.Union['byte3', i8, int]) -> 'bool3': return intrinsic("cmp.__gt__.byte3", bool3, self, _other) # type: ignore[override] + @func(inline='always') + def __ge__(self, _other: tp.Union['byte3', i8, int]) -> 'bool3': return intrinsic("cmp.__ge__.byte3", bool3, self, _other) # type: ignore[override] + @func(inline='always') + def __eq__(self, _other: tp.Union['byte3', i8, int]) -> 'bool3': return intrinsic("cmp.__eq__.byte3", bool3, self, _other) # type: ignore[override] + @func(inline='always') + def __ne__(self, _other: tp.Union['byte3', i8, int]) -> 'bool3': return intrinsic("cmp.__ne__.byte3", bool3, self, _other) # type: ignore[override] + @func(inline='always') + def __floordiv__(self, _other: tp.Union['byte3', i8, int]) -> 'byte3': return intrinsic("binop.__floordiv__.byte3", byte3, self, _other) + @func(inline='always') + def __rfloordiv__(self, _other: tp.Union['byte3', i8, int]) -> 'byte3': return intrinsic("binop.__rfloordiv__.byte3", byte3, self, _other) + @func(inline='always') + def __ifloordiv__(self, _other: tp.Union['byte3', i8, int]) -> 'byte3': return intrinsic("binop.__ifloordiv__.byte3", byte3, byref(self), _other) + @func(inline='always') + def __lshift__(self, _other: tp.Union['byte3', i8, int]) -> 'byte3': return intrinsic("binop.__lshift__.byte3", byte3, self, _other) + @func(inline='always') + def __rlshift__(self, _other: tp.Union['byte3', i8, int]) -> 'byte3': return intrinsic("binop.__rlshift__.byte3", byte3, self, _other) + @func(inline='always') + def __ilshift__(self, _other: tp.Union['byte3', i8, int]) -> 'byte3': return intrinsic("binop.__ilshift__.byte3", byte3, byref(self), _other) + @func(inline='always') + def __rshift__(self, _other: tp.Union['byte3', i8, int]) -> 'byte3': return intrinsic("binop.__rshift__.byte3", byte3, self, _other) + @func(inline='always') + def __rrshift__(self, _other: tp.Union['byte3', i8, int]) -> 'byte3': return intrinsic("binop.__rrshift__.byte3", byte3, self, _other) + @func(inline='always') + def __irshift__(self, _other: tp.Union['byte3', i8, int]) -> 'byte3': return intrinsic("binop.__irshift__.byte3", byte3, byref(self), _other) + @func(inline='always') + def __and__(self, _other: tp.Union['byte3', i8, int]) -> 'byte3': return intrinsic("binop.__and__.byte3", byte3, self, _other) + @func(inline='always') + def __rand__(self, _other: tp.Union['byte3', i8, int]) -> 'byte3': return intrinsic("binop.__rand__.byte3", byte3, self, _other) + @func(inline='always') + def __iand__(self, _other: tp.Union['byte3', i8, int]) -> 'byte3': return intrinsic("binop.__iand__.byte3", byte3, byref(self), _other) + @func(inline='always') + def __or__(self, _other: tp.Union['byte3', i8, int]) -> 'byte3': return intrinsic("binop.__or__.byte3", byte3, self, _other) + @func(inline='always') + def __ror__(self, _other: tp.Union['byte3', i8, int]) -> 'byte3': return intrinsic("binop.__ror__.byte3", byte3, self, _other) + @func(inline='always') + def __ior__(self, _other: tp.Union['byte3', i8, int]) -> 'byte3': return intrinsic("binop.__ior__.byte3", byte3, byref(self), _other) + @func(inline='always') + def __xor__(self, _other: tp.Union['byte3', i8, int]) -> 'byte3': return intrinsic("binop.__xor__.byte3", byte3, self, _other) + @func(inline='always') + def __rxor__(self, _other: tp.Union['byte3', i8, int]) -> 'byte3': return intrinsic("binop.__rxor__.byte3", byte3, self, _other) + @func(inline='always') + def __ixor__(self, _other: tp.Union['byte3', i8, int]) -> 'byte3': return intrinsic("binop.__ixor__.byte3", byte3, byref(self), _other) @builtin_type(_hir.VectorType(tp.cast(_hir.ScalarType, _ctx.types[u8]), 3)) class ubyte3: @@ -1048,42 +1899,78 @@ class ubyte3: y: u8 z: u8 def __init__(self, x: tp.Union['u8', int] = 0, y: tp.Union['u8', int] = 0, z: tp.Union['u8', int] = 0) -> None: self = intrinsic("init.ubyte3", ubyte3, x, y, z) - def __add__(self, _other: tp.Union['ubyte3', u8, int]) -> 'ubyte3': return intrinsic("binop.__add__.ubyte3", ubyte3, _other) - def __radd__(self, _other: tp.Union['ubyte3', u8, int]) -> 'ubyte3': return intrinsic("binop.__radd__.ubyte3", ubyte3, _other) - def __iadd__(self, _other: tp.Union['ubyte3', u8, int]) -> 'ubyte3': return intrinsic("binop.__iadd__.ubyte3", ubyte3, _other) - def __sub__(self, _other: tp.Union['ubyte3', u8, int]) -> 'ubyte3': return intrinsic("binop.__sub__.ubyte3", ubyte3, _other) - def __rsub__(self, _other: tp.Union['ubyte3', u8, int]) -> 'ubyte3': return intrinsic("binop.__rsub__.ubyte3", ubyte3, _other) - def __isub__(self, _other: tp.Union['ubyte3', u8, int]) -> 'ubyte3': return intrinsic("binop.__isub__.ubyte3", ubyte3, _other) - def __mul__(self, _other: tp.Union['ubyte3', u8, int]) -> 'ubyte3': return intrinsic("binop.__mul__.ubyte3", ubyte3, _other) - def __rmul__(self, _other: tp.Union['ubyte3', u8, int]) -> 'ubyte3': return intrinsic("binop.__rmul__.ubyte3", ubyte3, _other) - def __imul__(self, _other: tp.Union['ubyte3', u8, int]) -> 'ubyte3': return intrinsic("binop.__imul__.ubyte3", ubyte3, _other) - def __mod__(self, _other: tp.Union['ubyte3', u8, int]) -> 'ubyte3': return intrinsic("binop.__mod__.ubyte3", ubyte3, _other) - def __rmod__(self, _other: tp.Union['ubyte3', u8, int]) -> 'ubyte3': return intrinsic("binop.__rmod__.ubyte3", ubyte3, _other) - def __imod__(self, _other: tp.Union['ubyte3', u8, int]) -> 'ubyte3': return intrinsic("binop.__imod__.ubyte3", ubyte3, _other) - def __lt__(self, _other: tp.Union['ubyte3', u8, int]) -> 'bool3': return intrinsic("cmp.__lt__.ubyte3", bool3, _other) # type: ignore[override] - def __le__(self, _other: tp.Union['ubyte3', u8, int]) -> 'bool3': return intrinsic("cmp.__le__.ubyte3", bool3, _other) # type: ignore[override] - def __gt__(self, _other: tp.Union['ubyte3', u8, int]) -> 'bool3': return intrinsic("cmp.__gt__.ubyte3", bool3, _other) # type: ignore[override] - def __ge__(self, _other: tp.Union['ubyte3', u8, int]) -> 'bool3': return intrinsic("cmp.__ge__.ubyte3", bool3, _other) # type: ignore[override] - def __eq__(self, _other: tp.Union['ubyte3', u8, int]) -> 'bool3': return intrinsic("cmp.__eq__.ubyte3", bool3, _other) # type: ignore[override] - def __ne__(self, _other: tp.Union['ubyte3', u8, int]) -> 'bool3': return intrinsic("cmp.__ne__.ubyte3", bool3, _other) # type: ignore[override] - def __floordiv__(self, _other: tp.Union['ubyte3', u8, int]) -> 'ubyte3': return intrinsic("binop.__floordiv__.ubyte3", ubyte3, _other) - def __rfloordiv__(self, _other: tp.Union['ubyte3', u8, int]) -> 'ubyte3': return intrinsic("binop.__rfloordiv__.ubyte3", ubyte3, _other) - def __ifloordiv__(self, _other: tp.Union['ubyte3', u8, int]) -> 'ubyte3': return intrinsic("binop.__ifloordiv__.ubyte3", ubyte3, _other) - def __lshift__(self, _other: tp.Union['ubyte3', u8, int]) -> 'ubyte3': return intrinsic("binop.__lshift__.ubyte3", ubyte3, _other) - def __rlshift__(self, _other: tp.Union['ubyte3', u8, int]) -> 'ubyte3': return intrinsic("binop.__rlshift__.ubyte3", ubyte3, _other) - def __ilshift__(self, _other: tp.Union['ubyte3', u8, int]) -> 'ubyte3': return intrinsic("binop.__ilshift__.ubyte3", ubyte3, _other) - def __rshift__(self, _other: tp.Union['ubyte3', u8, int]) -> 'ubyte3': return intrinsic("binop.__rshift__.ubyte3", ubyte3, _other) - def __rrshift__(self, _other: tp.Union['ubyte3', u8, int]) -> 'ubyte3': return intrinsic("binop.__rrshift__.ubyte3", ubyte3, _other) - def __irshift__(self, _other: tp.Union['ubyte3', u8, int]) -> 'ubyte3': return intrinsic("binop.__irshift__.ubyte3", ubyte3, _other) - def __and__(self, _other: tp.Union['ubyte3', u8, int]) -> 'ubyte3': return intrinsic("binop.__and__.ubyte3", ubyte3, _other) - def __rand__(self, _other: tp.Union['ubyte3', u8, int]) -> 'ubyte3': return intrinsic("binop.__rand__.ubyte3", ubyte3, _other) - def __iand__(self, _other: tp.Union['ubyte3', u8, int]) -> 'ubyte3': return intrinsic("binop.__iand__.ubyte3", ubyte3, _other) - def __or__(self, _other: tp.Union['ubyte3', u8, int]) -> 'ubyte3': return intrinsic("binop.__or__.ubyte3", ubyte3, _other) - def __ror__(self, _other: tp.Union['ubyte3', u8, int]) -> 'ubyte3': return intrinsic("binop.__ror__.ubyte3", ubyte3, _other) - def __ior__(self, _other: tp.Union['ubyte3', u8, int]) -> 'ubyte3': return intrinsic("binop.__ior__.ubyte3", ubyte3, _other) - def __xor__(self, _other: tp.Union['ubyte3', u8, int]) -> 'ubyte3': return intrinsic("binop.__xor__.ubyte3", ubyte3, _other) - def __rxor__(self, _other: tp.Union['ubyte3', u8, int]) -> 'ubyte3': return intrinsic("binop.__rxor__.ubyte3", ubyte3, _other) - def __ixor__(self, _other: tp.Union['ubyte3', u8, int]) -> 'ubyte3': return intrinsic("binop.__ixor__.ubyte3", ubyte3, _other) + @func(inline='always') + def __add__(self, _other: tp.Union['ubyte3', u8, int]) -> 'ubyte3': return intrinsic("binop.__add__.ubyte3", ubyte3, self, _other) + @func(inline='always') + def __radd__(self, _other: tp.Union['ubyte3', u8, int]) -> 'ubyte3': return intrinsic("binop.__radd__.ubyte3", ubyte3, self, _other) + @func(inline='always') + def __iadd__(self, _other: tp.Union['ubyte3', u8, int]) -> 'ubyte3': return intrinsic("binop.__iadd__.ubyte3", ubyte3, byref(self), _other) + @func(inline='always') + def __sub__(self, _other: tp.Union['ubyte3', u8, int]) -> 'ubyte3': return intrinsic("binop.__sub__.ubyte3", ubyte3, self, _other) + @func(inline='always') + def __rsub__(self, _other: tp.Union['ubyte3', u8, int]) -> 'ubyte3': return intrinsic("binop.__rsub__.ubyte3", ubyte3, self, _other) + @func(inline='always') + def __isub__(self, _other: tp.Union['ubyte3', u8, int]) -> 'ubyte3': return intrinsic("binop.__isub__.ubyte3", ubyte3, byref(self), _other) + @func(inline='always') + def __mul__(self, _other: tp.Union['ubyte3', u8, int]) -> 'ubyte3': return intrinsic("binop.__mul__.ubyte3", ubyte3, self, _other) + @func(inline='always') + def __rmul__(self, _other: tp.Union['ubyte3', u8, int]) -> 'ubyte3': return intrinsic("binop.__rmul__.ubyte3", ubyte3, self, _other) + @func(inline='always') + def __imul__(self, _other: tp.Union['ubyte3', u8, int]) -> 'ubyte3': return intrinsic("binop.__imul__.ubyte3", ubyte3, byref(self), _other) + @func(inline='always') + def __mod__(self, _other: tp.Union['ubyte3', u8, int]) -> 'ubyte3': return intrinsic("binop.__mod__.ubyte3", ubyte3, self, _other) + @func(inline='always') + def __rmod__(self, _other: tp.Union['ubyte3', u8, int]) -> 'ubyte3': return intrinsic("binop.__rmod__.ubyte3", ubyte3, self, _other) + @func(inline='always') + def __imod__(self, _other: tp.Union['ubyte3', u8, int]) -> 'ubyte3': return intrinsic("binop.__imod__.ubyte3", ubyte3, byref(self), _other) + @func(inline='always') + def __lt__(self, _other: tp.Union['ubyte3', u8, int]) -> 'bool3': return intrinsic("cmp.__lt__.ubyte3", bool3, self, _other) # type: ignore[override] + @func(inline='always') + def __le__(self, _other: tp.Union['ubyte3', u8, int]) -> 'bool3': return intrinsic("cmp.__le__.ubyte3", bool3, self, _other) # type: ignore[override] + @func(inline='always') + def __gt__(self, _other: tp.Union['ubyte3', u8, int]) -> 'bool3': return intrinsic("cmp.__gt__.ubyte3", bool3, self, _other) # type: ignore[override] + @func(inline='always') + def __ge__(self, _other: tp.Union['ubyte3', u8, int]) -> 'bool3': return intrinsic("cmp.__ge__.ubyte3", bool3, self, _other) # type: ignore[override] + @func(inline='always') + def __eq__(self, _other: tp.Union['ubyte3', u8, int]) -> 'bool3': return intrinsic("cmp.__eq__.ubyte3", bool3, self, _other) # type: ignore[override] + @func(inline='always') + def __ne__(self, _other: tp.Union['ubyte3', u8, int]) -> 'bool3': return intrinsic("cmp.__ne__.ubyte3", bool3, self, _other) # type: ignore[override] + @func(inline='always') + def __floordiv__(self, _other: tp.Union['ubyte3', u8, int]) -> 'ubyte3': return intrinsic("binop.__floordiv__.ubyte3", ubyte3, self, _other) + @func(inline='always') + def __rfloordiv__(self, _other: tp.Union['ubyte3', u8, int]) -> 'ubyte3': return intrinsic("binop.__rfloordiv__.ubyte3", ubyte3, self, _other) + @func(inline='always') + def __ifloordiv__(self, _other: tp.Union['ubyte3', u8, int]) -> 'ubyte3': return intrinsic("binop.__ifloordiv__.ubyte3", ubyte3, byref(self), _other) + @func(inline='always') + def __lshift__(self, _other: tp.Union['ubyte3', u8, int]) -> 'ubyte3': return intrinsic("binop.__lshift__.ubyte3", ubyte3, self, _other) + @func(inline='always') + def __rlshift__(self, _other: tp.Union['ubyte3', u8, int]) -> 'ubyte3': return intrinsic("binop.__rlshift__.ubyte3", ubyte3, self, _other) + @func(inline='always') + def __ilshift__(self, _other: tp.Union['ubyte3', u8, int]) -> 'ubyte3': return intrinsic("binop.__ilshift__.ubyte3", ubyte3, byref(self), _other) + @func(inline='always') + def __rshift__(self, _other: tp.Union['ubyte3', u8, int]) -> 'ubyte3': return intrinsic("binop.__rshift__.ubyte3", ubyte3, self, _other) + @func(inline='always') + def __rrshift__(self, _other: tp.Union['ubyte3', u8, int]) -> 'ubyte3': return intrinsic("binop.__rrshift__.ubyte3", ubyte3, self, _other) + @func(inline='always') + def __irshift__(self, _other: tp.Union['ubyte3', u8, int]) -> 'ubyte3': return intrinsic("binop.__irshift__.ubyte3", ubyte3, byref(self), _other) + @func(inline='always') + def __and__(self, _other: tp.Union['ubyte3', u8, int]) -> 'ubyte3': return intrinsic("binop.__and__.ubyte3", ubyte3, self, _other) + @func(inline='always') + def __rand__(self, _other: tp.Union['ubyte3', u8, int]) -> 'ubyte3': return intrinsic("binop.__rand__.ubyte3", ubyte3, self, _other) + @func(inline='always') + def __iand__(self, _other: tp.Union['ubyte3', u8, int]) -> 'ubyte3': return intrinsic("binop.__iand__.ubyte3", ubyte3, byref(self), _other) + @func(inline='always') + def __or__(self, _other: tp.Union['ubyte3', u8, int]) -> 'ubyte3': return intrinsic("binop.__or__.ubyte3", ubyte3, self, _other) + @func(inline='always') + def __ror__(self, _other: tp.Union['ubyte3', u8, int]) -> 'ubyte3': return intrinsic("binop.__ror__.ubyte3", ubyte3, self, _other) + @func(inline='always') + def __ior__(self, _other: tp.Union['ubyte3', u8, int]) -> 'ubyte3': return intrinsic("binop.__ior__.ubyte3", ubyte3, byref(self), _other) + @func(inline='always') + def __xor__(self, _other: tp.Union['ubyte3', u8, int]) -> 'ubyte3': return intrinsic("binop.__xor__.ubyte3", ubyte3, self, _other) + @func(inline='always') + def __rxor__(self, _other: tp.Union['ubyte3', u8, int]) -> 'ubyte3': return intrinsic("binop.__rxor__.ubyte3", ubyte3, self, _other) + @func(inline='always') + def __ixor__(self, _other: tp.Union['ubyte3', u8, int]) -> 'ubyte3': return intrinsic("binop.__ixor__.ubyte3", ubyte3, byref(self), _other) @builtin_type(_hir.VectorType(tp.cast(_hir.ScalarType, _ctx.types[i16]), 3)) class short3: @@ -1091,42 +1978,78 @@ class short3: y: i16 z: i16 def __init__(self, x: tp.Union['i16', int] = 0, y: tp.Union['i16', int] = 0, z: tp.Union['i16', int] = 0) -> None: self = intrinsic("init.short3", short3, x, y, z) - def __add__(self, _other: tp.Union['short3', i16, int]) -> 'short3': return intrinsic("binop.__add__.short3", short3, _other) - def __radd__(self, _other: tp.Union['short3', i16, int]) -> 'short3': return intrinsic("binop.__radd__.short3", short3, _other) - def __iadd__(self, _other: tp.Union['short3', i16, int]) -> 'short3': return intrinsic("binop.__iadd__.short3", short3, _other) - def __sub__(self, _other: tp.Union['short3', i16, int]) -> 'short3': return intrinsic("binop.__sub__.short3", short3, _other) - def __rsub__(self, _other: tp.Union['short3', i16, int]) -> 'short3': return intrinsic("binop.__rsub__.short3", short3, _other) - def __isub__(self, _other: tp.Union['short3', i16, int]) -> 'short3': return intrinsic("binop.__isub__.short3", short3, _other) - def __mul__(self, _other: tp.Union['short3', i16, int]) -> 'short3': return intrinsic("binop.__mul__.short3", short3, _other) - def __rmul__(self, _other: tp.Union['short3', i16, int]) -> 'short3': return intrinsic("binop.__rmul__.short3", short3, _other) - def __imul__(self, _other: tp.Union['short3', i16, int]) -> 'short3': return intrinsic("binop.__imul__.short3", short3, _other) - def __mod__(self, _other: tp.Union['short3', i16, int]) -> 'short3': return intrinsic("binop.__mod__.short3", short3, _other) - def __rmod__(self, _other: tp.Union['short3', i16, int]) -> 'short3': return intrinsic("binop.__rmod__.short3", short3, _other) - def __imod__(self, _other: tp.Union['short3', i16, int]) -> 'short3': return intrinsic("binop.__imod__.short3", short3, _other) - def __lt__(self, _other: tp.Union['short3', i16, int]) -> 'bool3': return intrinsic("cmp.__lt__.short3", bool3, _other) # type: ignore[override] - def __le__(self, _other: tp.Union['short3', i16, int]) -> 'bool3': return intrinsic("cmp.__le__.short3", bool3, _other) # type: ignore[override] - def __gt__(self, _other: tp.Union['short3', i16, int]) -> 'bool3': return intrinsic("cmp.__gt__.short3", bool3, _other) # type: ignore[override] - def __ge__(self, _other: tp.Union['short3', i16, int]) -> 'bool3': return intrinsic("cmp.__ge__.short3", bool3, _other) # type: ignore[override] - def __eq__(self, _other: tp.Union['short3', i16, int]) -> 'bool3': return intrinsic("cmp.__eq__.short3", bool3, _other) # type: ignore[override] - def __ne__(self, _other: tp.Union['short3', i16, int]) -> 'bool3': return intrinsic("cmp.__ne__.short3", bool3, _other) # type: ignore[override] - def __floordiv__(self, _other: tp.Union['short3', i16, int]) -> 'short3': return intrinsic("binop.__floordiv__.short3", short3, _other) - def __rfloordiv__(self, _other: tp.Union['short3', i16, int]) -> 'short3': return intrinsic("binop.__rfloordiv__.short3", short3, _other) - def __ifloordiv__(self, _other: tp.Union['short3', i16, int]) -> 'short3': return intrinsic("binop.__ifloordiv__.short3", short3, _other) - def __lshift__(self, _other: tp.Union['short3', i16, int]) -> 'short3': return intrinsic("binop.__lshift__.short3", short3, _other) - def __rlshift__(self, _other: tp.Union['short3', i16, int]) -> 'short3': return intrinsic("binop.__rlshift__.short3", short3, _other) - def __ilshift__(self, _other: tp.Union['short3', i16, int]) -> 'short3': return intrinsic("binop.__ilshift__.short3", short3, _other) - def __rshift__(self, _other: tp.Union['short3', i16, int]) -> 'short3': return intrinsic("binop.__rshift__.short3", short3, _other) - def __rrshift__(self, _other: tp.Union['short3', i16, int]) -> 'short3': return intrinsic("binop.__rrshift__.short3", short3, _other) - def __irshift__(self, _other: tp.Union['short3', i16, int]) -> 'short3': return intrinsic("binop.__irshift__.short3", short3, _other) - def __and__(self, _other: tp.Union['short3', i16, int]) -> 'short3': return intrinsic("binop.__and__.short3", short3, _other) - def __rand__(self, _other: tp.Union['short3', i16, int]) -> 'short3': return intrinsic("binop.__rand__.short3", short3, _other) - def __iand__(self, _other: tp.Union['short3', i16, int]) -> 'short3': return intrinsic("binop.__iand__.short3", short3, _other) - def __or__(self, _other: tp.Union['short3', i16, int]) -> 'short3': return intrinsic("binop.__or__.short3", short3, _other) - def __ror__(self, _other: tp.Union['short3', i16, int]) -> 'short3': return intrinsic("binop.__ror__.short3", short3, _other) - def __ior__(self, _other: tp.Union['short3', i16, int]) -> 'short3': return intrinsic("binop.__ior__.short3", short3, _other) - def __xor__(self, _other: tp.Union['short3', i16, int]) -> 'short3': return intrinsic("binop.__xor__.short3", short3, _other) - def __rxor__(self, _other: tp.Union['short3', i16, int]) -> 'short3': return intrinsic("binop.__rxor__.short3", short3, _other) - def __ixor__(self, _other: tp.Union['short3', i16, int]) -> 'short3': return intrinsic("binop.__ixor__.short3", short3, _other) + @func(inline='always') + def __add__(self, _other: tp.Union['short3', i16, int]) -> 'short3': return intrinsic("binop.__add__.short3", short3, self, _other) + @func(inline='always') + def __radd__(self, _other: tp.Union['short3', i16, int]) -> 'short3': return intrinsic("binop.__radd__.short3", short3, self, _other) + @func(inline='always') + def __iadd__(self, _other: tp.Union['short3', i16, int]) -> 'short3': return intrinsic("binop.__iadd__.short3", short3, byref(self), _other) + @func(inline='always') + def __sub__(self, _other: tp.Union['short3', i16, int]) -> 'short3': return intrinsic("binop.__sub__.short3", short3, self, _other) + @func(inline='always') + def __rsub__(self, _other: tp.Union['short3', i16, int]) -> 'short3': return intrinsic("binop.__rsub__.short3", short3, self, _other) + @func(inline='always') + def __isub__(self, _other: tp.Union['short3', i16, int]) -> 'short3': return intrinsic("binop.__isub__.short3", short3, byref(self), _other) + @func(inline='always') + def __mul__(self, _other: tp.Union['short3', i16, int]) -> 'short3': return intrinsic("binop.__mul__.short3", short3, self, _other) + @func(inline='always') + def __rmul__(self, _other: tp.Union['short3', i16, int]) -> 'short3': return intrinsic("binop.__rmul__.short3", short3, self, _other) + @func(inline='always') + def __imul__(self, _other: tp.Union['short3', i16, int]) -> 'short3': return intrinsic("binop.__imul__.short3", short3, byref(self), _other) + @func(inline='always') + def __mod__(self, _other: tp.Union['short3', i16, int]) -> 'short3': return intrinsic("binop.__mod__.short3", short3, self, _other) + @func(inline='always') + def __rmod__(self, _other: tp.Union['short3', i16, int]) -> 'short3': return intrinsic("binop.__rmod__.short3", short3, self, _other) + @func(inline='always') + def __imod__(self, _other: tp.Union['short3', i16, int]) -> 'short3': return intrinsic("binop.__imod__.short3", short3, byref(self), _other) + @func(inline='always') + def __lt__(self, _other: tp.Union['short3', i16, int]) -> 'bool3': return intrinsic("cmp.__lt__.short3", bool3, self, _other) # type: ignore[override] + @func(inline='always') + def __le__(self, _other: tp.Union['short3', i16, int]) -> 'bool3': return intrinsic("cmp.__le__.short3", bool3, self, _other) # type: ignore[override] + @func(inline='always') + def __gt__(self, _other: tp.Union['short3', i16, int]) -> 'bool3': return intrinsic("cmp.__gt__.short3", bool3, self, _other) # type: ignore[override] + @func(inline='always') + def __ge__(self, _other: tp.Union['short3', i16, int]) -> 'bool3': return intrinsic("cmp.__ge__.short3", bool3, self, _other) # type: ignore[override] + @func(inline='always') + def __eq__(self, _other: tp.Union['short3', i16, int]) -> 'bool3': return intrinsic("cmp.__eq__.short3", bool3, self, _other) # type: ignore[override] + @func(inline='always') + def __ne__(self, _other: tp.Union['short3', i16, int]) -> 'bool3': return intrinsic("cmp.__ne__.short3", bool3, self, _other) # type: ignore[override] + @func(inline='always') + def __floordiv__(self, _other: tp.Union['short3', i16, int]) -> 'short3': return intrinsic("binop.__floordiv__.short3", short3, self, _other) + @func(inline='always') + def __rfloordiv__(self, _other: tp.Union['short3', i16, int]) -> 'short3': return intrinsic("binop.__rfloordiv__.short3", short3, self, _other) + @func(inline='always') + def __ifloordiv__(self, _other: tp.Union['short3', i16, int]) -> 'short3': return intrinsic("binop.__ifloordiv__.short3", short3, byref(self), _other) + @func(inline='always') + def __lshift__(self, _other: tp.Union['short3', i16, int]) -> 'short3': return intrinsic("binop.__lshift__.short3", short3, self, _other) + @func(inline='always') + def __rlshift__(self, _other: tp.Union['short3', i16, int]) -> 'short3': return intrinsic("binop.__rlshift__.short3", short3, self, _other) + @func(inline='always') + def __ilshift__(self, _other: tp.Union['short3', i16, int]) -> 'short3': return intrinsic("binop.__ilshift__.short3", short3, byref(self), _other) + @func(inline='always') + def __rshift__(self, _other: tp.Union['short3', i16, int]) -> 'short3': return intrinsic("binop.__rshift__.short3", short3, self, _other) + @func(inline='always') + def __rrshift__(self, _other: tp.Union['short3', i16, int]) -> 'short3': return intrinsic("binop.__rrshift__.short3", short3, self, _other) + @func(inline='always') + def __irshift__(self, _other: tp.Union['short3', i16, int]) -> 'short3': return intrinsic("binop.__irshift__.short3", short3, byref(self), _other) + @func(inline='always') + def __and__(self, _other: tp.Union['short3', i16, int]) -> 'short3': return intrinsic("binop.__and__.short3", short3, self, _other) + @func(inline='always') + def __rand__(self, _other: tp.Union['short3', i16, int]) -> 'short3': return intrinsic("binop.__rand__.short3", short3, self, _other) + @func(inline='always') + def __iand__(self, _other: tp.Union['short3', i16, int]) -> 'short3': return intrinsic("binop.__iand__.short3", short3, byref(self), _other) + @func(inline='always') + def __or__(self, _other: tp.Union['short3', i16, int]) -> 'short3': return intrinsic("binop.__or__.short3", short3, self, _other) + @func(inline='always') + def __ror__(self, _other: tp.Union['short3', i16, int]) -> 'short3': return intrinsic("binop.__ror__.short3", short3, self, _other) + @func(inline='always') + def __ior__(self, _other: tp.Union['short3', i16, int]) -> 'short3': return intrinsic("binop.__ior__.short3", short3, byref(self), _other) + @func(inline='always') + def __xor__(self, _other: tp.Union['short3', i16, int]) -> 'short3': return intrinsic("binop.__xor__.short3", short3, self, _other) + @func(inline='always') + def __rxor__(self, _other: tp.Union['short3', i16, int]) -> 'short3': return intrinsic("binop.__rxor__.short3", short3, self, _other) + @func(inline='always') + def __ixor__(self, _other: tp.Union['short3', i16, int]) -> 'short3': return intrinsic("binop.__ixor__.short3", short3, byref(self), _other) @builtin_type(_hir.VectorType(tp.cast(_hir.ScalarType, _ctx.types[u16]), 3)) class ushort3: @@ -1134,42 +2057,78 @@ class ushort3: y: u16 z: u16 def __init__(self, x: tp.Union['u16', int] = 0, y: tp.Union['u16', int] = 0, z: tp.Union['u16', int] = 0) -> None: self = intrinsic("init.ushort3", ushort3, x, y, z) - def __add__(self, _other: tp.Union['ushort3', u16, int]) -> 'ushort3': return intrinsic("binop.__add__.ushort3", ushort3, _other) - def __radd__(self, _other: tp.Union['ushort3', u16, int]) -> 'ushort3': return intrinsic("binop.__radd__.ushort3", ushort3, _other) - def __iadd__(self, _other: tp.Union['ushort3', u16, int]) -> 'ushort3': return intrinsic("binop.__iadd__.ushort3", ushort3, _other) - def __sub__(self, _other: tp.Union['ushort3', u16, int]) -> 'ushort3': return intrinsic("binop.__sub__.ushort3", ushort3, _other) - def __rsub__(self, _other: tp.Union['ushort3', u16, int]) -> 'ushort3': return intrinsic("binop.__rsub__.ushort3", ushort3, _other) - def __isub__(self, _other: tp.Union['ushort3', u16, int]) -> 'ushort3': return intrinsic("binop.__isub__.ushort3", ushort3, _other) - def __mul__(self, _other: tp.Union['ushort3', u16, int]) -> 'ushort3': return intrinsic("binop.__mul__.ushort3", ushort3, _other) - def __rmul__(self, _other: tp.Union['ushort3', u16, int]) -> 'ushort3': return intrinsic("binop.__rmul__.ushort3", ushort3, _other) - def __imul__(self, _other: tp.Union['ushort3', u16, int]) -> 'ushort3': return intrinsic("binop.__imul__.ushort3", ushort3, _other) - def __mod__(self, _other: tp.Union['ushort3', u16, int]) -> 'ushort3': return intrinsic("binop.__mod__.ushort3", ushort3, _other) - def __rmod__(self, _other: tp.Union['ushort3', u16, int]) -> 'ushort3': return intrinsic("binop.__rmod__.ushort3", ushort3, _other) - def __imod__(self, _other: tp.Union['ushort3', u16, int]) -> 'ushort3': return intrinsic("binop.__imod__.ushort3", ushort3, _other) - def __lt__(self, _other: tp.Union['ushort3', u16, int]) -> 'bool3': return intrinsic("cmp.__lt__.ushort3", bool3, _other) # type: ignore[override] - def __le__(self, _other: tp.Union['ushort3', u16, int]) -> 'bool3': return intrinsic("cmp.__le__.ushort3", bool3, _other) # type: ignore[override] - def __gt__(self, _other: tp.Union['ushort3', u16, int]) -> 'bool3': return intrinsic("cmp.__gt__.ushort3", bool3, _other) # type: ignore[override] - def __ge__(self, _other: tp.Union['ushort3', u16, int]) -> 'bool3': return intrinsic("cmp.__ge__.ushort3", bool3, _other) # type: ignore[override] - def __eq__(self, _other: tp.Union['ushort3', u16, int]) -> 'bool3': return intrinsic("cmp.__eq__.ushort3", bool3, _other) # type: ignore[override] - def __ne__(self, _other: tp.Union['ushort3', u16, int]) -> 'bool3': return intrinsic("cmp.__ne__.ushort3", bool3, _other) # type: ignore[override] - def __floordiv__(self, _other: tp.Union['ushort3', u16, int]) -> 'ushort3': return intrinsic("binop.__floordiv__.ushort3", ushort3, _other) - def __rfloordiv__(self, _other: tp.Union['ushort3', u16, int]) -> 'ushort3': return intrinsic("binop.__rfloordiv__.ushort3", ushort3, _other) - def __ifloordiv__(self, _other: tp.Union['ushort3', u16, int]) -> 'ushort3': return intrinsic("binop.__ifloordiv__.ushort3", ushort3, _other) - def __lshift__(self, _other: tp.Union['ushort3', u16, int]) -> 'ushort3': return intrinsic("binop.__lshift__.ushort3", ushort3, _other) - def __rlshift__(self, _other: tp.Union['ushort3', u16, int]) -> 'ushort3': return intrinsic("binop.__rlshift__.ushort3", ushort3, _other) - def __ilshift__(self, _other: tp.Union['ushort3', u16, int]) -> 'ushort3': return intrinsic("binop.__ilshift__.ushort3", ushort3, _other) - def __rshift__(self, _other: tp.Union['ushort3', u16, int]) -> 'ushort3': return intrinsic("binop.__rshift__.ushort3", ushort3, _other) - def __rrshift__(self, _other: tp.Union['ushort3', u16, int]) -> 'ushort3': return intrinsic("binop.__rrshift__.ushort3", ushort3, _other) - def __irshift__(self, _other: tp.Union['ushort3', u16, int]) -> 'ushort3': return intrinsic("binop.__irshift__.ushort3", ushort3, _other) - def __and__(self, _other: tp.Union['ushort3', u16, int]) -> 'ushort3': return intrinsic("binop.__and__.ushort3", ushort3, _other) - def __rand__(self, _other: tp.Union['ushort3', u16, int]) -> 'ushort3': return intrinsic("binop.__rand__.ushort3", ushort3, _other) - def __iand__(self, _other: tp.Union['ushort3', u16, int]) -> 'ushort3': return intrinsic("binop.__iand__.ushort3", ushort3, _other) - def __or__(self, _other: tp.Union['ushort3', u16, int]) -> 'ushort3': return intrinsic("binop.__or__.ushort3", ushort3, _other) - def __ror__(self, _other: tp.Union['ushort3', u16, int]) -> 'ushort3': return intrinsic("binop.__ror__.ushort3", ushort3, _other) - def __ior__(self, _other: tp.Union['ushort3', u16, int]) -> 'ushort3': return intrinsic("binop.__ior__.ushort3", ushort3, _other) - def __xor__(self, _other: tp.Union['ushort3', u16, int]) -> 'ushort3': return intrinsic("binop.__xor__.ushort3", ushort3, _other) - def __rxor__(self, _other: tp.Union['ushort3', u16, int]) -> 'ushort3': return intrinsic("binop.__rxor__.ushort3", ushort3, _other) - def __ixor__(self, _other: tp.Union['ushort3', u16, int]) -> 'ushort3': return intrinsic("binop.__ixor__.ushort3", ushort3, _other) + @func(inline='always') + def __add__(self, _other: tp.Union['ushort3', u16, int]) -> 'ushort3': return intrinsic("binop.__add__.ushort3", ushort3, self, _other) + @func(inline='always') + def __radd__(self, _other: tp.Union['ushort3', u16, int]) -> 'ushort3': return intrinsic("binop.__radd__.ushort3", ushort3, self, _other) + @func(inline='always') + def __iadd__(self, _other: tp.Union['ushort3', u16, int]) -> 'ushort3': return intrinsic("binop.__iadd__.ushort3", ushort3, byref(self), _other) + @func(inline='always') + def __sub__(self, _other: tp.Union['ushort3', u16, int]) -> 'ushort3': return intrinsic("binop.__sub__.ushort3", ushort3, self, _other) + @func(inline='always') + def __rsub__(self, _other: tp.Union['ushort3', u16, int]) -> 'ushort3': return intrinsic("binop.__rsub__.ushort3", ushort3, self, _other) + @func(inline='always') + def __isub__(self, _other: tp.Union['ushort3', u16, int]) -> 'ushort3': return intrinsic("binop.__isub__.ushort3", ushort3, byref(self), _other) + @func(inline='always') + def __mul__(self, _other: tp.Union['ushort3', u16, int]) -> 'ushort3': return intrinsic("binop.__mul__.ushort3", ushort3, self, _other) + @func(inline='always') + def __rmul__(self, _other: tp.Union['ushort3', u16, int]) -> 'ushort3': return intrinsic("binop.__rmul__.ushort3", ushort3, self, _other) + @func(inline='always') + def __imul__(self, _other: tp.Union['ushort3', u16, int]) -> 'ushort3': return intrinsic("binop.__imul__.ushort3", ushort3, byref(self), _other) + @func(inline='always') + def __mod__(self, _other: tp.Union['ushort3', u16, int]) -> 'ushort3': return intrinsic("binop.__mod__.ushort3", ushort3, self, _other) + @func(inline='always') + def __rmod__(self, _other: tp.Union['ushort3', u16, int]) -> 'ushort3': return intrinsic("binop.__rmod__.ushort3", ushort3, self, _other) + @func(inline='always') + def __imod__(self, _other: tp.Union['ushort3', u16, int]) -> 'ushort3': return intrinsic("binop.__imod__.ushort3", ushort3, byref(self), _other) + @func(inline='always') + def __lt__(self, _other: tp.Union['ushort3', u16, int]) -> 'bool3': return intrinsic("cmp.__lt__.ushort3", bool3, self, _other) # type: ignore[override] + @func(inline='always') + def __le__(self, _other: tp.Union['ushort3', u16, int]) -> 'bool3': return intrinsic("cmp.__le__.ushort3", bool3, self, _other) # type: ignore[override] + @func(inline='always') + def __gt__(self, _other: tp.Union['ushort3', u16, int]) -> 'bool3': return intrinsic("cmp.__gt__.ushort3", bool3, self, _other) # type: ignore[override] + @func(inline='always') + def __ge__(self, _other: tp.Union['ushort3', u16, int]) -> 'bool3': return intrinsic("cmp.__ge__.ushort3", bool3, self, _other) # type: ignore[override] + @func(inline='always') + def __eq__(self, _other: tp.Union['ushort3', u16, int]) -> 'bool3': return intrinsic("cmp.__eq__.ushort3", bool3, self, _other) # type: ignore[override] + @func(inline='always') + def __ne__(self, _other: tp.Union['ushort3', u16, int]) -> 'bool3': return intrinsic("cmp.__ne__.ushort3", bool3, self, _other) # type: ignore[override] + @func(inline='always') + def __floordiv__(self, _other: tp.Union['ushort3', u16, int]) -> 'ushort3': return intrinsic("binop.__floordiv__.ushort3", ushort3, self, _other) + @func(inline='always') + def __rfloordiv__(self, _other: tp.Union['ushort3', u16, int]) -> 'ushort3': return intrinsic("binop.__rfloordiv__.ushort3", ushort3, self, _other) + @func(inline='always') + def __ifloordiv__(self, _other: tp.Union['ushort3', u16, int]) -> 'ushort3': return intrinsic("binop.__ifloordiv__.ushort3", ushort3, byref(self), _other) + @func(inline='always') + def __lshift__(self, _other: tp.Union['ushort3', u16, int]) -> 'ushort3': return intrinsic("binop.__lshift__.ushort3", ushort3, self, _other) + @func(inline='always') + def __rlshift__(self, _other: tp.Union['ushort3', u16, int]) -> 'ushort3': return intrinsic("binop.__rlshift__.ushort3", ushort3, self, _other) + @func(inline='always') + def __ilshift__(self, _other: tp.Union['ushort3', u16, int]) -> 'ushort3': return intrinsic("binop.__ilshift__.ushort3", ushort3, byref(self), _other) + @func(inline='always') + def __rshift__(self, _other: tp.Union['ushort3', u16, int]) -> 'ushort3': return intrinsic("binop.__rshift__.ushort3", ushort3, self, _other) + @func(inline='always') + def __rrshift__(self, _other: tp.Union['ushort3', u16, int]) -> 'ushort3': return intrinsic("binop.__rrshift__.ushort3", ushort3, self, _other) + @func(inline='always') + def __irshift__(self, _other: tp.Union['ushort3', u16, int]) -> 'ushort3': return intrinsic("binop.__irshift__.ushort3", ushort3, byref(self), _other) + @func(inline='always') + def __and__(self, _other: tp.Union['ushort3', u16, int]) -> 'ushort3': return intrinsic("binop.__and__.ushort3", ushort3, self, _other) + @func(inline='always') + def __rand__(self, _other: tp.Union['ushort3', u16, int]) -> 'ushort3': return intrinsic("binop.__rand__.ushort3", ushort3, self, _other) + @func(inline='always') + def __iand__(self, _other: tp.Union['ushort3', u16, int]) -> 'ushort3': return intrinsic("binop.__iand__.ushort3", ushort3, byref(self), _other) + @func(inline='always') + def __or__(self, _other: tp.Union['ushort3', u16, int]) -> 'ushort3': return intrinsic("binop.__or__.ushort3", ushort3, self, _other) + @func(inline='always') + def __ror__(self, _other: tp.Union['ushort3', u16, int]) -> 'ushort3': return intrinsic("binop.__ror__.ushort3", ushort3, self, _other) + @func(inline='always') + def __ior__(self, _other: tp.Union['ushort3', u16, int]) -> 'ushort3': return intrinsic("binop.__ior__.ushort3", ushort3, byref(self), _other) + @func(inline='always') + def __xor__(self, _other: tp.Union['ushort3', u16, int]) -> 'ushort3': return intrinsic("binop.__xor__.ushort3", ushort3, self, _other) + @func(inline='always') + def __rxor__(self, _other: tp.Union['ushort3', u16, int]) -> 'ushort3': return intrinsic("binop.__rxor__.ushort3", ushort3, self, _other) + @func(inline='always') + def __ixor__(self, _other: tp.Union['ushort3', u16, int]) -> 'ushort3': return intrinsic("binop.__ixor__.ushort3", ushort3, byref(self), _other) @builtin_type(_hir.VectorType(tp.cast(_hir.ScalarType, _ctx.types[i32]), 3)) class int3: @@ -1177,42 +2136,78 @@ class int3: y: i32 z: i32 def __init__(self, x: tp.Union['i32', int] = 0, y: tp.Union['i32', int] = 0, z: tp.Union['i32', int] = 0) -> None: self = intrinsic("init.int3", int3, x, y, z) - def __add__(self, _other: tp.Union['int3', i32, int]) -> 'int3': return intrinsic("binop.__add__.int3", int3, _other) - def __radd__(self, _other: tp.Union['int3', i32, int]) -> 'int3': return intrinsic("binop.__radd__.int3", int3, _other) - def __iadd__(self, _other: tp.Union['int3', i32, int]) -> 'int3': return intrinsic("binop.__iadd__.int3", int3, _other) - def __sub__(self, _other: tp.Union['int3', i32, int]) -> 'int3': return intrinsic("binop.__sub__.int3", int3, _other) - def __rsub__(self, _other: tp.Union['int3', i32, int]) -> 'int3': return intrinsic("binop.__rsub__.int3", int3, _other) - def __isub__(self, _other: tp.Union['int3', i32, int]) -> 'int3': return intrinsic("binop.__isub__.int3", int3, _other) - def __mul__(self, _other: tp.Union['int3', i32, int]) -> 'int3': return intrinsic("binop.__mul__.int3", int3, _other) - def __rmul__(self, _other: tp.Union['int3', i32, int]) -> 'int3': return intrinsic("binop.__rmul__.int3", int3, _other) - def __imul__(self, _other: tp.Union['int3', i32, int]) -> 'int3': return intrinsic("binop.__imul__.int3", int3, _other) - def __mod__(self, _other: tp.Union['int3', i32, int]) -> 'int3': return intrinsic("binop.__mod__.int3", int3, _other) - def __rmod__(self, _other: tp.Union['int3', i32, int]) -> 'int3': return intrinsic("binop.__rmod__.int3", int3, _other) - def __imod__(self, _other: tp.Union['int3', i32, int]) -> 'int3': return intrinsic("binop.__imod__.int3", int3, _other) - def __lt__(self, _other: tp.Union['int3', i32, int]) -> 'bool3': return intrinsic("cmp.__lt__.int3", bool3, _other) # type: ignore[override] - def __le__(self, _other: tp.Union['int3', i32, int]) -> 'bool3': return intrinsic("cmp.__le__.int3", bool3, _other) # type: ignore[override] - def __gt__(self, _other: tp.Union['int3', i32, int]) -> 'bool3': return intrinsic("cmp.__gt__.int3", bool3, _other) # type: ignore[override] - def __ge__(self, _other: tp.Union['int3', i32, int]) -> 'bool3': return intrinsic("cmp.__ge__.int3", bool3, _other) # type: ignore[override] - def __eq__(self, _other: tp.Union['int3', i32, int]) -> 'bool3': return intrinsic("cmp.__eq__.int3", bool3, _other) # type: ignore[override] - def __ne__(self, _other: tp.Union['int3', i32, int]) -> 'bool3': return intrinsic("cmp.__ne__.int3", bool3, _other) # type: ignore[override] - def __floordiv__(self, _other: tp.Union['int3', i32, int]) -> 'int3': return intrinsic("binop.__floordiv__.int3", int3, _other) - def __rfloordiv__(self, _other: tp.Union['int3', i32, int]) -> 'int3': return intrinsic("binop.__rfloordiv__.int3", int3, _other) - def __ifloordiv__(self, _other: tp.Union['int3', i32, int]) -> 'int3': return intrinsic("binop.__ifloordiv__.int3", int3, _other) - def __lshift__(self, _other: tp.Union['int3', i32, int]) -> 'int3': return intrinsic("binop.__lshift__.int3", int3, _other) - def __rlshift__(self, _other: tp.Union['int3', i32, int]) -> 'int3': return intrinsic("binop.__rlshift__.int3", int3, _other) - def __ilshift__(self, _other: tp.Union['int3', i32, int]) -> 'int3': return intrinsic("binop.__ilshift__.int3", int3, _other) - def __rshift__(self, _other: tp.Union['int3', i32, int]) -> 'int3': return intrinsic("binop.__rshift__.int3", int3, _other) - def __rrshift__(self, _other: tp.Union['int3', i32, int]) -> 'int3': return intrinsic("binop.__rrshift__.int3", int3, _other) - def __irshift__(self, _other: tp.Union['int3', i32, int]) -> 'int3': return intrinsic("binop.__irshift__.int3", int3, _other) - def __and__(self, _other: tp.Union['int3', i32, int]) -> 'int3': return intrinsic("binop.__and__.int3", int3, _other) - def __rand__(self, _other: tp.Union['int3', i32, int]) -> 'int3': return intrinsic("binop.__rand__.int3", int3, _other) - def __iand__(self, _other: tp.Union['int3', i32, int]) -> 'int3': return intrinsic("binop.__iand__.int3", int3, _other) - def __or__(self, _other: tp.Union['int3', i32, int]) -> 'int3': return intrinsic("binop.__or__.int3", int3, _other) - def __ror__(self, _other: tp.Union['int3', i32, int]) -> 'int3': return intrinsic("binop.__ror__.int3", int3, _other) - def __ior__(self, _other: tp.Union['int3', i32, int]) -> 'int3': return intrinsic("binop.__ior__.int3", int3, _other) - def __xor__(self, _other: tp.Union['int3', i32, int]) -> 'int3': return intrinsic("binop.__xor__.int3", int3, _other) - def __rxor__(self, _other: tp.Union['int3', i32, int]) -> 'int3': return intrinsic("binop.__rxor__.int3", int3, _other) - def __ixor__(self, _other: tp.Union['int3', i32, int]) -> 'int3': return intrinsic("binop.__ixor__.int3", int3, _other) + @func(inline='always') + def __add__(self, _other: tp.Union['int3', i32, int]) -> 'int3': return intrinsic("binop.__add__.int3", int3, self, _other) + @func(inline='always') + def __radd__(self, _other: tp.Union['int3', i32, int]) -> 'int3': return intrinsic("binop.__radd__.int3", int3, self, _other) + @func(inline='always') + def __iadd__(self, _other: tp.Union['int3', i32, int]) -> 'int3': return intrinsic("binop.__iadd__.int3", int3, byref(self), _other) + @func(inline='always') + def __sub__(self, _other: tp.Union['int3', i32, int]) -> 'int3': return intrinsic("binop.__sub__.int3", int3, self, _other) + @func(inline='always') + def __rsub__(self, _other: tp.Union['int3', i32, int]) -> 'int3': return intrinsic("binop.__rsub__.int3", int3, self, _other) + @func(inline='always') + def __isub__(self, _other: tp.Union['int3', i32, int]) -> 'int3': return intrinsic("binop.__isub__.int3", int3, byref(self), _other) + @func(inline='always') + def __mul__(self, _other: tp.Union['int3', i32, int]) -> 'int3': return intrinsic("binop.__mul__.int3", int3, self, _other) + @func(inline='always') + def __rmul__(self, _other: tp.Union['int3', i32, int]) -> 'int3': return intrinsic("binop.__rmul__.int3", int3, self, _other) + @func(inline='always') + def __imul__(self, _other: tp.Union['int3', i32, int]) -> 'int3': return intrinsic("binop.__imul__.int3", int3, byref(self), _other) + @func(inline='always') + def __mod__(self, _other: tp.Union['int3', i32, int]) -> 'int3': return intrinsic("binop.__mod__.int3", int3, self, _other) + @func(inline='always') + def __rmod__(self, _other: tp.Union['int3', i32, int]) -> 'int3': return intrinsic("binop.__rmod__.int3", int3, self, _other) + @func(inline='always') + def __imod__(self, _other: tp.Union['int3', i32, int]) -> 'int3': return intrinsic("binop.__imod__.int3", int3, byref(self), _other) + @func(inline='always') + def __lt__(self, _other: tp.Union['int3', i32, int]) -> 'bool3': return intrinsic("cmp.__lt__.int3", bool3, self, _other) # type: ignore[override] + @func(inline='always') + def __le__(self, _other: tp.Union['int3', i32, int]) -> 'bool3': return intrinsic("cmp.__le__.int3", bool3, self, _other) # type: ignore[override] + @func(inline='always') + def __gt__(self, _other: tp.Union['int3', i32, int]) -> 'bool3': return intrinsic("cmp.__gt__.int3", bool3, self, _other) # type: ignore[override] + @func(inline='always') + def __ge__(self, _other: tp.Union['int3', i32, int]) -> 'bool3': return intrinsic("cmp.__ge__.int3", bool3, self, _other) # type: ignore[override] + @func(inline='always') + def __eq__(self, _other: tp.Union['int3', i32, int]) -> 'bool3': return intrinsic("cmp.__eq__.int3", bool3, self, _other) # type: ignore[override] + @func(inline='always') + def __ne__(self, _other: tp.Union['int3', i32, int]) -> 'bool3': return intrinsic("cmp.__ne__.int3", bool3, self, _other) # type: ignore[override] + @func(inline='always') + def __floordiv__(self, _other: tp.Union['int3', i32, int]) -> 'int3': return intrinsic("binop.__floordiv__.int3", int3, self, _other) + @func(inline='always') + def __rfloordiv__(self, _other: tp.Union['int3', i32, int]) -> 'int3': return intrinsic("binop.__rfloordiv__.int3", int3, self, _other) + @func(inline='always') + def __ifloordiv__(self, _other: tp.Union['int3', i32, int]) -> 'int3': return intrinsic("binop.__ifloordiv__.int3", int3, byref(self), _other) + @func(inline='always') + def __lshift__(self, _other: tp.Union['int3', i32, int]) -> 'int3': return intrinsic("binop.__lshift__.int3", int3, self, _other) + @func(inline='always') + def __rlshift__(self, _other: tp.Union['int3', i32, int]) -> 'int3': return intrinsic("binop.__rlshift__.int3", int3, self, _other) + @func(inline='always') + def __ilshift__(self, _other: tp.Union['int3', i32, int]) -> 'int3': return intrinsic("binop.__ilshift__.int3", int3, byref(self), _other) + @func(inline='always') + def __rshift__(self, _other: tp.Union['int3', i32, int]) -> 'int3': return intrinsic("binop.__rshift__.int3", int3, self, _other) + @func(inline='always') + def __rrshift__(self, _other: tp.Union['int3', i32, int]) -> 'int3': return intrinsic("binop.__rrshift__.int3", int3, self, _other) + @func(inline='always') + def __irshift__(self, _other: tp.Union['int3', i32, int]) -> 'int3': return intrinsic("binop.__irshift__.int3", int3, byref(self), _other) + @func(inline='always') + def __and__(self, _other: tp.Union['int3', i32, int]) -> 'int3': return intrinsic("binop.__and__.int3", int3, self, _other) + @func(inline='always') + def __rand__(self, _other: tp.Union['int3', i32, int]) -> 'int3': return intrinsic("binop.__rand__.int3", int3, self, _other) + @func(inline='always') + def __iand__(self, _other: tp.Union['int3', i32, int]) -> 'int3': return intrinsic("binop.__iand__.int3", int3, byref(self), _other) + @func(inline='always') + def __or__(self, _other: tp.Union['int3', i32, int]) -> 'int3': return intrinsic("binop.__or__.int3", int3, self, _other) + @func(inline='always') + def __ror__(self, _other: tp.Union['int3', i32, int]) -> 'int3': return intrinsic("binop.__ror__.int3", int3, self, _other) + @func(inline='always') + def __ior__(self, _other: tp.Union['int3', i32, int]) -> 'int3': return intrinsic("binop.__ior__.int3", int3, byref(self), _other) + @func(inline='always') + def __xor__(self, _other: tp.Union['int3', i32, int]) -> 'int3': return intrinsic("binop.__xor__.int3", int3, self, _other) + @func(inline='always') + def __rxor__(self, _other: tp.Union['int3', i32, int]) -> 'int3': return intrinsic("binop.__rxor__.int3", int3, self, _other) + @func(inline='always') + def __ixor__(self, _other: tp.Union['int3', i32, int]) -> 'int3': return intrinsic("binop.__ixor__.int3", int3, byref(self), _other) @builtin_type(_hir.VectorType(tp.cast(_hir.ScalarType, _ctx.types[u32]), 3)) class uint3: @@ -1220,42 +2215,78 @@ class uint3: y: u32 z: u32 def __init__(self, x: tp.Union['u32', int] = 0, y: tp.Union['u32', int] = 0, z: tp.Union['u32', int] = 0) -> None: self = intrinsic("init.uint3", uint3, x, y, z) - def __add__(self, _other: tp.Union['uint3', u32, int]) -> 'uint3': return intrinsic("binop.__add__.uint3", uint3, _other) - def __radd__(self, _other: tp.Union['uint3', u32, int]) -> 'uint3': return intrinsic("binop.__radd__.uint3", uint3, _other) - def __iadd__(self, _other: tp.Union['uint3', u32, int]) -> 'uint3': return intrinsic("binop.__iadd__.uint3", uint3, _other) - def __sub__(self, _other: tp.Union['uint3', u32, int]) -> 'uint3': return intrinsic("binop.__sub__.uint3", uint3, _other) - def __rsub__(self, _other: tp.Union['uint3', u32, int]) -> 'uint3': return intrinsic("binop.__rsub__.uint3", uint3, _other) - def __isub__(self, _other: tp.Union['uint3', u32, int]) -> 'uint3': return intrinsic("binop.__isub__.uint3", uint3, _other) - def __mul__(self, _other: tp.Union['uint3', u32, int]) -> 'uint3': return intrinsic("binop.__mul__.uint3", uint3, _other) - def __rmul__(self, _other: tp.Union['uint3', u32, int]) -> 'uint3': return intrinsic("binop.__rmul__.uint3", uint3, _other) - def __imul__(self, _other: tp.Union['uint3', u32, int]) -> 'uint3': return intrinsic("binop.__imul__.uint3", uint3, _other) - def __mod__(self, _other: tp.Union['uint3', u32, int]) -> 'uint3': return intrinsic("binop.__mod__.uint3", uint3, _other) - def __rmod__(self, _other: tp.Union['uint3', u32, int]) -> 'uint3': return intrinsic("binop.__rmod__.uint3", uint3, _other) - def __imod__(self, _other: tp.Union['uint3', u32, int]) -> 'uint3': return intrinsic("binop.__imod__.uint3", uint3, _other) - def __lt__(self, _other: tp.Union['uint3', u32, int]) -> 'bool3': return intrinsic("cmp.__lt__.uint3", bool3, _other) # type: ignore[override] - def __le__(self, _other: tp.Union['uint3', u32, int]) -> 'bool3': return intrinsic("cmp.__le__.uint3", bool3, _other) # type: ignore[override] - def __gt__(self, _other: tp.Union['uint3', u32, int]) -> 'bool3': return intrinsic("cmp.__gt__.uint3", bool3, _other) # type: ignore[override] - def __ge__(self, _other: tp.Union['uint3', u32, int]) -> 'bool3': return intrinsic("cmp.__ge__.uint3", bool3, _other) # type: ignore[override] - def __eq__(self, _other: tp.Union['uint3', u32, int]) -> 'bool3': return intrinsic("cmp.__eq__.uint3", bool3, _other) # type: ignore[override] - def __ne__(self, _other: tp.Union['uint3', u32, int]) -> 'bool3': return intrinsic("cmp.__ne__.uint3", bool3, _other) # type: ignore[override] - def __floordiv__(self, _other: tp.Union['uint3', u32, int]) -> 'uint3': return intrinsic("binop.__floordiv__.uint3", uint3, _other) - def __rfloordiv__(self, _other: tp.Union['uint3', u32, int]) -> 'uint3': return intrinsic("binop.__rfloordiv__.uint3", uint3, _other) - def __ifloordiv__(self, _other: tp.Union['uint3', u32, int]) -> 'uint3': return intrinsic("binop.__ifloordiv__.uint3", uint3, _other) - def __lshift__(self, _other: tp.Union['uint3', u32, int]) -> 'uint3': return intrinsic("binop.__lshift__.uint3", uint3, _other) - def __rlshift__(self, _other: tp.Union['uint3', u32, int]) -> 'uint3': return intrinsic("binop.__rlshift__.uint3", uint3, _other) - def __ilshift__(self, _other: tp.Union['uint3', u32, int]) -> 'uint3': return intrinsic("binop.__ilshift__.uint3", uint3, _other) - def __rshift__(self, _other: tp.Union['uint3', u32, int]) -> 'uint3': return intrinsic("binop.__rshift__.uint3", uint3, _other) - def __rrshift__(self, _other: tp.Union['uint3', u32, int]) -> 'uint3': return intrinsic("binop.__rrshift__.uint3", uint3, _other) - def __irshift__(self, _other: tp.Union['uint3', u32, int]) -> 'uint3': return intrinsic("binop.__irshift__.uint3", uint3, _other) - def __and__(self, _other: tp.Union['uint3', u32, int]) -> 'uint3': return intrinsic("binop.__and__.uint3", uint3, _other) - def __rand__(self, _other: tp.Union['uint3', u32, int]) -> 'uint3': return intrinsic("binop.__rand__.uint3", uint3, _other) - def __iand__(self, _other: tp.Union['uint3', u32, int]) -> 'uint3': return intrinsic("binop.__iand__.uint3", uint3, _other) - def __or__(self, _other: tp.Union['uint3', u32, int]) -> 'uint3': return intrinsic("binop.__or__.uint3", uint3, _other) - def __ror__(self, _other: tp.Union['uint3', u32, int]) -> 'uint3': return intrinsic("binop.__ror__.uint3", uint3, _other) - def __ior__(self, _other: tp.Union['uint3', u32, int]) -> 'uint3': return intrinsic("binop.__ior__.uint3", uint3, _other) - def __xor__(self, _other: tp.Union['uint3', u32, int]) -> 'uint3': return intrinsic("binop.__xor__.uint3", uint3, _other) - def __rxor__(self, _other: tp.Union['uint3', u32, int]) -> 'uint3': return intrinsic("binop.__rxor__.uint3", uint3, _other) - def __ixor__(self, _other: tp.Union['uint3', u32, int]) -> 'uint3': return intrinsic("binop.__ixor__.uint3", uint3, _other) + @func(inline='always') + def __add__(self, _other: tp.Union['uint3', u32, int]) -> 'uint3': return intrinsic("binop.__add__.uint3", uint3, self, _other) + @func(inline='always') + def __radd__(self, _other: tp.Union['uint3', u32, int]) -> 'uint3': return intrinsic("binop.__radd__.uint3", uint3, self, _other) + @func(inline='always') + def __iadd__(self, _other: tp.Union['uint3', u32, int]) -> 'uint3': return intrinsic("binop.__iadd__.uint3", uint3, byref(self), _other) + @func(inline='always') + def __sub__(self, _other: tp.Union['uint3', u32, int]) -> 'uint3': return intrinsic("binop.__sub__.uint3", uint3, self, _other) + @func(inline='always') + def __rsub__(self, _other: tp.Union['uint3', u32, int]) -> 'uint3': return intrinsic("binop.__rsub__.uint3", uint3, self, _other) + @func(inline='always') + def __isub__(self, _other: tp.Union['uint3', u32, int]) -> 'uint3': return intrinsic("binop.__isub__.uint3", uint3, byref(self), _other) + @func(inline='always') + def __mul__(self, _other: tp.Union['uint3', u32, int]) -> 'uint3': return intrinsic("binop.__mul__.uint3", uint3, self, _other) + @func(inline='always') + def __rmul__(self, _other: tp.Union['uint3', u32, int]) -> 'uint3': return intrinsic("binop.__rmul__.uint3", uint3, self, _other) + @func(inline='always') + def __imul__(self, _other: tp.Union['uint3', u32, int]) -> 'uint3': return intrinsic("binop.__imul__.uint3", uint3, byref(self), _other) + @func(inline='always') + def __mod__(self, _other: tp.Union['uint3', u32, int]) -> 'uint3': return intrinsic("binop.__mod__.uint3", uint3, self, _other) + @func(inline='always') + def __rmod__(self, _other: tp.Union['uint3', u32, int]) -> 'uint3': return intrinsic("binop.__rmod__.uint3", uint3, self, _other) + @func(inline='always') + def __imod__(self, _other: tp.Union['uint3', u32, int]) -> 'uint3': return intrinsic("binop.__imod__.uint3", uint3, byref(self), _other) + @func(inline='always') + def __lt__(self, _other: tp.Union['uint3', u32, int]) -> 'bool3': return intrinsic("cmp.__lt__.uint3", bool3, self, _other) # type: ignore[override] + @func(inline='always') + def __le__(self, _other: tp.Union['uint3', u32, int]) -> 'bool3': return intrinsic("cmp.__le__.uint3", bool3, self, _other) # type: ignore[override] + @func(inline='always') + def __gt__(self, _other: tp.Union['uint3', u32, int]) -> 'bool3': return intrinsic("cmp.__gt__.uint3", bool3, self, _other) # type: ignore[override] + @func(inline='always') + def __ge__(self, _other: tp.Union['uint3', u32, int]) -> 'bool3': return intrinsic("cmp.__ge__.uint3", bool3, self, _other) # type: ignore[override] + @func(inline='always') + def __eq__(self, _other: tp.Union['uint3', u32, int]) -> 'bool3': return intrinsic("cmp.__eq__.uint3", bool3, self, _other) # type: ignore[override] + @func(inline='always') + def __ne__(self, _other: tp.Union['uint3', u32, int]) -> 'bool3': return intrinsic("cmp.__ne__.uint3", bool3, self, _other) # type: ignore[override] + @func(inline='always') + def __floordiv__(self, _other: tp.Union['uint3', u32, int]) -> 'uint3': return intrinsic("binop.__floordiv__.uint3", uint3, self, _other) + @func(inline='always') + def __rfloordiv__(self, _other: tp.Union['uint3', u32, int]) -> 'uint3': return intrinsic("binop.__rfloordiv__.uint3", uint3, self, _other) + @func(inline='always') + def __ifloordiv__(self, _other: tp.Union['uint3', u32, int]) -> 'uint3': return intrinsic("binop.__ifloordiv__.uint3", uint3, byref(self), _other) + @func(inline='always') + def __lshift__(self, _other: tp.Union['uint3', u32, int]) -> 'uint3': return intrinsic("binop.__lshift__.uint3", uint3, self, _other) + @func(inline='always') + def __rlshift__(self, _other: tp.Union['uint3', u32, int]) -> 'uint3': return intrinsic("binop.__rlshift__.uint3", uint3, self, _other) + @func(inline='always') + def __ilshift__(self, _other: tp.Union['uint3', u32, int]) -> 'uint3': return intrinsic("binop.__ilshift__.uint3", uint3, byref(self), _other) + @func(inline='always') + def __rshift__(self, _other: tp.Union['uint3', u32, int]) -> 'uint3': return intrinsic("binop.__rshift__.uint3", uint3, self, _other) + @func(inline='always') + def __rrshift__(self, _other: tp.Union['uint3', u32, int]) -> 'uint3': return intrinsic("binop.__rrshift__.uint3", uint3, self, _other) + @func(inline='always') + def __irshift__(self, _other: tp.Union['uint3', u32, int]) -> 'uint3': return intrinsic("binop.__irshift__.uint3", uint3, byref(self), _other) + @func(inline='always') + def __and__(self, _other: tp.Union['uint3', u32, int]) -> 'uint3': return intrinsic("binop.__and__.uint3", uint3, self, _other) + @func(inline='always') + def __rand__(self, _other: tp.Union['uint3', u32, int]) -> 'uint3': return intrinsic("binop.__rand__.uint3", uint3, self, _other) + @func(inline='always') + def __iand__(self, _other: tp.Union['uint3', u32, int]) -> 'uint3': return intrinsic("binop.__iand__.uint3", uint3, byref(self), _other) + @func(inline='always') + def __or__(self, _other: tp.Union['uint3', u32, int]) -> 'uint3': return intrinsic("binop.__or__.uint3", uint3, self, _other) + @func(inline='always') + def __ror__(self, _other: tp.Union['uint3', u32, int]) -> 'uint3': return intrinsic("binop.__ror__.uint3", uint3, self, _other) + @func(inline='always') + def __ior__(self, _other: tp.Union['uint3', u32, int]) -> 'uint3': return intrinsic("binop.__ior__.uint3", uint3, byref(self), _other) + @func(inline='always') + def __xor__(self, _other: tp.Union['uint3', u32, int]) -> 'uint3': return intrinsic("binop.__xor__.uint3", uint3, self, _other) + @func(inline='always') + def __rxor__(self, _other: tp.Union['uint3', u32, int]) -> 'uint3': return intrinsic("binop.__rxor__.uint3", uint3, self, _other) + @func(inline='always') + def __ixor__(self, _other: tp.Union['uint3', u32, int]) -> 'uint3': return intrinsic("binop.__ixor__.uint3", uint3, byref(self), _other) @builtin_type(_hir.VectorType(tp.cast(_hir.ScalarType, _ctx.types[i64]), 3)) class long3: @@ -1263,42 +2294,78 @@ class long3: y: i64 z: i64 def __init__(self, x: tp.Union['i64', int] = 0, y: tp.Union['i64', int] = 0, z: tp.Union['i64', int] = 0) -> None: self = intrinsic("init.long3", long3, x, y, z) - def __add__(self, _other: tp.Union['long3', i64, int]) -> 'long3': return intrinsic("binop.__add__.long3", long3, _other) - def __radd__(self, _other: tp.Union['long3', i64, int]) -> 'long3': return intrinsic("binop.__radd__.long3", long3, _other) - def __iadd__(self, _other: tp.Union['long3', i64, int]) -> 'long3': return intrinsic("binop.__iadd__.long3", long3, _other) - def __sub__(self, _other: tp.Union['long3', i64, int]) -> 'long3': return intrinsic("binop.__sub__.long3", long3, _other) - def __rsub__(self, _other: tp.Union['long3', i64, int]) -> 'long3': return intrinsic("binop.__rsub__.long3", long3, _other) - def __isub__(self, _other: tp.Union['long3', i64, int]) -> 'long3': return intrinsic("binop.__isub__.long3", long3, _other) - def __mul__(self, _other: tp.Union['long3', i64, int]) -> 'long3': return intrinsic("binop.__mul__.long3", long3, _other) - def __rmul__(self, _other: tp.Union['long3', i64, int]) -> 'long3': return intrinsic("binop.__rmul__.long3", long3, _other) - def __imul__(self, _other: tp.Union['long3', i64, int]) -> 'long3': return intrinsic("binop.__imul__.long3", long3, _other) - def __mod__(self, _other: tp.Union['long3', i64, int]) -> 'long3': return intrinsic("binop.__mod__.long3", long3, _other) - def __rmod__(self, _other: tp.Union['long3', i64, int]) -> 'long3': return intrinsic("binop.__rmod__.long3", long3, _other) - def __imod__(self, _other: tp.Union['long3', i64, int]) -> 'long3': return intrinsic("binop.__imod__.long3", long3, _other) - def __lt__(self, _other: tp.Union['long3', i64, int]) -> 'bool3': return intrinsic("cmp.__lt__.long3", bool3, _other) # type: ignore[override] - def __le__(self, _other: tp.Union['long3', i64, int]) -> 'bool3': return intrinsic("cmp.__le__.long3", bool3, _other) # type: ignore[override] - def __gt__(self, _other: tp.Union['long3', i64, int]) -> 'bool3': return intrinsic("cmp.__gt__.long3", bool3, _other) # type: ignore[override] - def __ge__(self, _other: tp.Union['long3', i64, int]) -> 'bool3': return intrinsic("cmp.__ge__.long3", bool3, _other) # type: ignore[override] - def __eq__(self, _other: tp.Union['long3', i64, int]) -> 'bool3': return intrinsic("cmp.__eq__.long3", bool3, _other) # type: ignore[override] - def __ne__(self, _other: tp.Union['long3', i64, int]) -> 'bool3': return intrinsic("cmp.__ne__.long3", bool3, _other) # type: ignore[override] - def __floordiv__(self, _other: tp.Union['long3', i64, int]) -> 'long3': return intrinsic("binop.__floordiv__.long3", long3, _other) - def __rfloordiv__(self, _other: tp.Union['long3', i64, int]) -> 'long3': return intrinsic("binop.__rfloordiv__.long3", long3, _other) - def __ifloordiv__(self, _other: tp.Union['long3', i64, int]) -> 'long3': return intrinsic("binop.__ifloordiv__.long3", long3, _other) - def __lshift__(self, _other: tp.Union['long3', i64, int]) -> 'long3': return intrinsic("binop.__lshift__.long3", long3, _other) - def __rlshift__(self, _other: tp.Union['long3', i64, int]) -> 'long3': return intrinsic("binop.__rlshift__.long3", long3, _other) - def __ilshift__(self, _other: tp.Union['long3', i64, int]) -> 'long3': return intrinsic("binop.__ilshift__.long3", long3, _other) - def __rshift__(self, _other: tp.Union['long3', i64, int]) -> 'long3': return intrinsic("binop.__rshift__.long3", long3, _other) - def __rrshift__(self, _other: tp.Union['long3', i64, int]) -> 'long3': return intrinsic("binop.__rrshift__.long3", long3, _other) - def __irshift__(self, _other: tp.Union['long3', i64, int]) -> 'long3': return intrinsic("binop.__irshift__.long3", long3, _other) - def __and__(self, _other: tp.Union['long3', i64, int]) -> 'long3': return intrinsic("binop.__and__.long3", long3, _other) - def __rand__(self, _other: tp.Union['long3', i64, int]) -> 'long3': return intrinsic("binop.__rand__.long3", long3, _other) - def __iand__(self, _other: tp.Union['long3', i64, int]) -> 'long3': return intrinsic("binop.__iand__.long3", long3, _other) - def __or__(self, _other: tp.Union['long3', i64, int]) -> 'long3': return intrinsic("binop.__or__.long3", long3, _other) - def __ror__(self, _other: tp.Union['long3', i64, int]) -> 'long3': return intrinsic("binop.__ror__.long3", long3, _other) - def __ior__(self, _other: tp.Union['long3', i64, int]) -> 'long3': return intrinsic("binop.__ior__.long3", long3, _other) - def __xor__(self, _other: tp.Union['long3', i64, int]) -> 'long3': return intrinsic("binop.__xor__.long3", long3, _other) - def __rxor__(self, _other: tp.Union['long3', i64, int]) -> 'long3': return intrinsic("binop.__rxor__.long3", long3, _other) - def __ixor__(self, _other: tp.Union['long3', i64, int]) -> 'long3': return intrinsic("binop.__ixor__.long3", long3, _other) + @func(inline='always') + def __add__(self, _other: tp.Union['long3', i64, int]) -> 'long3': return intrinsic("binop.__add__.long3", long3, self, _other) + @func(inline='always') + def __radd__(self, _other: tp.Union['long3', i64, int]) -> 'long3': return intrinsic("binop.__radd__.long3", long3, self, _other) + @func(inline='always') + def __iadd__(self, _other: tp.Union['long3', i64, int]) -> 'long3': return intrinsic("binop.__iadd__.long3", long3, byref(self), _other) + @func(inline='always') + def __sub__(self, _other: tp.Union['long3', i64, int]) -> 'long3': return intrinsic("binop.__sub__.long3", long3, self, _other) + @func(inline='always') + def __rsub__(self, _other: tp.Union['long3', i64, int]) -> 'long3': return intrinsic("binop.__rsub__.long3", long3, self, _other) + @func(inline='always') + def __isub__(self, _other: tp.Union['long3', i64, int]) -> 'long3': return intrinsic("binop.__isub__.long3", long3, byref(self), _other) + @func(inline='always') + def __mul__(self, _other: tp.Union['long3', i64, int]) -> 'long3': return intrinsic("binop.__mul__.long3", long3, self, _other) + @func(inline='always') + def __rmul__(self, _other: tp.Union['long3', i64, int]) -> 'long3': return intrinsic("binop.__rmul__.long3", long3, self, _other) + @func(inline='always') + def __imul__(self, _other: tp.Union['long3', i64, int]) -> 'long3': return intrinsic("binop.__imul__.long3", long3, byref(self), _other) + @func(inline='always') + def __mod__(self, _other: tp.Union['long3', i64, int]) -> 'long3': return intrinsic("binop.__mod__.long3", long3, self, _other) + @func(inline='always') + def __rmod__(self, _other: tp.Union['long3', i64, int]) -> 'long3': return intrinsic("binop.__rmod__.long3", long3, self, _other) + @func(inline='always') + def __imod__(self, _other: tp.Union['long3', i64, int]) -> 'long3': return intrinsic("binop.__imod__.long3", long3, byref(self), _other) + @func(inline='always') + def __lt__(self, _other: tp.Union['long3', i64, int]) -> 'bool3': return intrinsic("cmp.__lt__.long3", bool3, self, _other) # type: ignore[override] + @func(inline='always') + def __le__(self, _other: tp.Union['long3', i64, int]) -> 'bool3': return intrinsic("cmp.__le__.long3", bool3, self, _other) # type: ignore[override] + @func(inline='always') + def __gt__(self, _other: tp.Union['long3', i64, int]) -> 'bool3': return intrinsic("cmp.__gt__.long3", bool3, self, _other) # type: ignore[override] + @func(inline='always') + def __ge__(self, _other: tp.Union['long3', i64, int]) -> 'bool3': return intrinsic("cmp.__ge__.long3", bool3, self, _other) # type: ignore[override] + @func(inline='always') + def __eq__(self, _other: tp.Union['long3', i64, int]) -> 'bool3': return intrinsic("cmp.__eq__.long3", bool3, self, _other) # type: ignore[override] + @func(inline='always') + def __ne__(self, _other: tp.Union['long3', i64, int]) -> 'bool3': return intrinsic("cmp.__ne__.long3", bool3, self, _other) # type: ignore[override] + @func(inline='always') + def __floordiv__(self, _other: tp.Union['long3', i64, int]) -> 'long3': return intrinsic("binop.__floordiv__.long3", long3, self, _other) + @func(inline='always') + def __rfloordiv__(self, _other: tp.Union['long3', i64, int]) -> 'long3': return intrinsic("binop.__rfloordiv__.long3", long3, self, _other) + @func(inline='always') + def __ifloordiv__(self, _other: tp.Union['long3', i64, int]) -> 'long3': return intrinsic("binop.__ifloordiv__.long3", long3, byref(self), _other) + @func(inline='always') + def __lshift__(self, _other: tp.Union['long3', i64, int]) -> 'long3': return intrinsic("binop.__lshift__.long3", long3, self, _other) + @func(inline='always') + def __rlshift__(self, _other: tp.Union['long3', i64, int]) -> 'long3': return intrinsic("binop.__rlshift__.long3", long3, self, _other) + @func(inline='always') + def __ilshift__(self, _other: tp.Union['long3', i64, int]) -> 'long3': return intrinsic("binop.__ilshift__.long3", long3, byref(self), _other) + @func(inline='always') + def __rshift__(self, _other: tp.Union['long3', i64, int]) -> 'long3': return intrinsic("binop.__rshift__.long3", long3, self, _other) + @func(inline='always') + def __rrshift__(self, _other: tp.Union['long3', i64, int]) -> 'long3': return intrinsic("binop.__rrshift__.long3", long3, self, _other) + @func(inline='always') + def __irshift__(self, _other: tp.Union['long3', i64, int]) -> 'long3': return intrinsic("binop.__irshift__.long3", long3, byref(self), _other) + @func(inline='always') + def __and__(self, _other: tp.Union['long3', i64, int]) -> 'long3': return intrinsic("binop.__and__.long3", long3, self, _other) + @func(inline='always') + def __rand__(self, _other: tp.Union['long3', i64, int]) -> 'long3': return intrinsic("binop.__rand__.long3", long3, self, _other) + @func(inline='always') + def __iand__(self, _other: tp.Union['long3', i64, int]) -> 'long3': return intrinsic("binop.__iand__.long3", long3, byref(self), _other) + @func(inline='always') + def __or__(self, _other: tp.Union['long3', i64, int]) -> 'long3': return intrinsic("binop.__or__.long3", long3, self, _other) + @func(inline='always') + def __ror__(self, _other: tp.Union['long3', i64, int]) -> 'long3': return intrinsic("binop.__ror__.long3", long3, self, _other) + @func(inline='always') + def __ior__(self, _other: tp.Union['long3', i64, int]) -> 'long3': return intrinsic("binop.__ior__.long3", long3, byref(self), _other) + @func(inline='always') + def __xor__(self, _other: tp.Union['long3', i64, int]) -> 'long3': return intrinsic("binop.__xor__.long3", long3, self, _other) + @func(inline='always') + def __rxor__(self, _other: tp.Union['long3', i64, int]) -> 'long3': return intrinsic("binop.__rxor__.long3", long3, self, _other) + @func(inline='always') + def __ixor__(self, _other: tp.Union['long3', i64, int]) -> 'long3': return intrinsic("binop.__ixor__.long3", long3, byref(self), _other) @builtin_type(_hir.VectorType(tp.cast(_hir.ScalarType, _ctx.types[u64]), 3)) class ulong3: @@ -1306,42 +2373,78 @@ class ulong3: y: u64 z: u64 def __init__(self, x: tp.Union['u64', int] = 0, y: tp.Union['u64', int] = 0, z: tp.Union['u64', int] = 0) -> None: self = intrinsic("init.ulong3", ulong3, x, y, z) - def __add__(self, _other: tp.Union['ulong3', u64, int]) -> 'ulong3': return intrinsic("binop.__add__.ulong3", ulong3, _other) - def __radd__(self, _other: tp.Union['ulong3', u64, int]) -> 'ulong3': return intrinsic("binop.__radd__.ulong3", ulong3, _other) - def __iadd__(self, _other: tp.Union['ulong3', u64, int]) -> 'ulong3': return intrinsic("binop.__iadd__.ulong3", ulong3, _other) - def __sub__(self, _other: tp.Union['ulong3', u64, int]) -> 'ulong3': return intrinsic("binop.__sub__.ulong3", ulong3, _other) - def __rsub__(self, _other: tp.Union['ulong3', u64, int]) -> 'ulong3': return intrinsic("binop.__rsub__.ulong3", ulong3, _other) - def __isub__(self, _other: tp.Union['ulong3', u64, int]) -> 'ulong3': return intrinsic("binop.__isub__.ulong3", ulong3, _other) - def __mul__(self, _other: tp.Union['ulong3', u64, int]) -> 'ulong3': return intrinsic("binop.__mul__.ulong3", ulong3, _other) - def __rmul__(self, _other: tp.Union['ulong3', u64, int]) -> 'ulong3': return intrinsic("binop.__rmul__.ulong3", ulong3, _other) - def __imul__(self, _other: tp.Union['ulong3', u64, int]) -> 'ulong3': return intrinsic("binop.__imul__.ulong3", ulong3, _other) - def __mod__(self, _other: tp.Union['ulong3', u64, int]) -> 'ulong3': return intrinsic("binop.__mod__.ulong3", ulong3, _other) - def __rmod__(self, _other: tp.Union['ulong3', u64, int]) -> 'ulong3': return intrinsic("binop.__rmod__.ulong3", ulong3, _other) - def __imod__(self, _other: tp.Union['ulong3', u64, int]) -> 'ulong3': return intrinsic("binop.__imod__.ulong3", ulong3, _other) - def __lt__(self, _other: tp.Union['ulong3', u64, int]) -> 'bool3': return intrinsic("cmp.__lt__.ulong3", bool3, _other) # type: ignore[override] - def __le__(self, _other: tp.Union['ulong3', u64, int]) -> 'bool3': return intrinsic("cmp.__le__.ulong3", bool3, _other) # type: ignore[override] - def __gt__(self, _other: tp.Union['ulong3', u64, int]) -> 'bool3': return intrinsic("cmp.__gt__.ulong3", bool3, _other) # type: ignore[override] - def __ge__(self, _other: tp.Union['ulong3', u64, int]) -> 'bool3': return intrinsic("cmp.__ge__.ulong3", bool3, _other) # type: ignore[override] - def __eq__(self, _other: tp.Union['ulong3', u64, int]) -> 'bool3': return intrinsic("cmp.__eq__.ulong3", bool3, _other) # type: ignore[override] - def __ne__(self, _other: tp.Union['ulong3', u64, int]) -> 'bool3': return intrinsic("cmp.__ne__.ulong3", bool3, _other) # type: ignore[override] - def __floordiv__(self, _other: tp.Union['ulong3', u64, int]) -> 'ulong3': return intrinsic("binop.__floordiv__.ulong3", ulong3, _other) - def __rfloordiv__(self, _other: tp.Union['ulong3', u64, int]) -> 'ulong3': return intrinsic("binop.__rfloordiv__.ulong3", ulong3, _other) - def __ifloordiv__(self, _other: tp.Union['ulong3', u64, int]) -> 'ulong3': return intrinsic("binop.__ifloordiv__.ulong3", ulong3, _other) - def __lshift__(self, _other: tp.Union['ulong3', u64, int]) -> 'ulong3': return intrinsic("binop.__lshift__.ulong3", ulong3, _other) - def __rlshift__(self, _other: tp.Union['ulong3', u64, int]) -> 'ulong3': return intrinsic("binop.__rlshift__.ulong3", ulong3, _other) - def __ilshift__(self, _other: tp.Union['ulong3', u64, int]) -> 'ulong3': return intrinsic("binop.__ilshift__.ulong3", ulong3, _other) - def __rshift__(self, _other: tp.Union['ulong3', u64, int]) -> 'ulong3': return intrinsic("binop.__rshift__.ulong3", ulong3, _other) - def __rrshift__(self, _other: tp.Union['ulong3', u64, int]) -> 'ulong3': return intrinsic("binop.__rrshift__.ulong3", ulong3, _other) - def __irshift__(self, _other: tp.Union['ulong3', u64, int]) -> 'ulong3': return intrinsic("binop.__irshift__.ulong3", ulong3, _other) - def __and__(self, _other: tp.Union['ulong3', u64, int]) -> 'ulong3': return intrinsic("binop.__and__.ulong3", ulong3, _other) - def __rand__(self, _other: tp.Union['ulong3', u64, int]) -> 'ulong3': return intrinsic("binop.__rand__.ulong3", ulong3, _other) - def __iand__(self, _other: tp.Union['ulong3', u64, int]) -> 'ulong3': return intrinsic("binop.__iand__.ulong3", ulong3, _other) - def __or__(self, _other: tp.Union['ulong3', u64, int]) -> 'ulong3': return intrinsic("binop.__or__.ulong3", ulong3, _other) - def __ror__(self, _other: tp.Union['ulong3', u64, int]) -> 'ulong3': return intrinsic("binop.__ror__.ulong3", ulong3, _other) - def __ior__(self, _other: tp.Union['ulong3', u64, int]) -> 'ulong3': return intrinsic("binop.__ior__.ulong3", ulong3, _other) - def __xor__(self, _other: tp.Union['ulong3', u64, int]) -> 'ulong3': return intrinsic("binop.__xor__.ulong3", ulong3, _other) - def __rxor__(self, _other: tp.Union['ulong3', u64, int]) -> 'ulong3': return intrinsic("binop.__rxor__.ulong3", ulong3, _other) - def __ixor__(self, _other: tp.Union['ulong3', u64, int]) -> 'ulong3': return intrinsic("binop.__ixor__.ulong3", ulong3, _other) + @func(inline='always') + def __add__(self, _other: tp.Union['ulong3', u64, int]) -> 'ulong3': return intrinsic("binop.__add__.ulong3", ulong3, self, _other) + @func(inline='always') + def __radd__(self, _other: tp.Union['ulong3', u64, int]) -> 'ulong3': return intrinsic("binop.__radd__.ulong3", ulong3, self, _other) + @func(inline='always') + def __iadd__(self, _other: tp.Union['ulong3', u64, int]) -> 'ulong3': return intrinsic("binop.__iadd__.ulong3", ulong3, byref(self), _other) + @func(inline='always') + def __sub__(self, _other: tp.Union['ulong3', u64, int]) -> 'ulong3': return intrinsic("binop.__sub__.ulong3", ulong3, self, _other) + @func(inline='always') + def __rsub__(self, _other: tp.Union['ulong3', u64, int]) -> 'ulong3': return intrinsic("binop.__rsub__.ulong3", ulong3, self, _other) + @func(inline='always') + def __isub__(self, _other: tp.Union['ulong3', u64, int]) -> 'ulong3': return intrinsic("binop.__isub__.ulong3", ulong3, byref(self), _other) + @func(inline='always') + def __mul__(self, _other: tp.Union['ulong3', u64, int]) -> 'ulong3': return intrinsic("binop.__mul__.ulong3", ulong3, self, _other) + @func(inline='always') + def __rmul__(self, _other: tp.Union['ulong3', u64, int]) -> 'ulong3': return intrinsic("binop.__rmul__.ulong3", ulong3, self, _other) + @func(inline='always') + def __imul__(self, _other: tp.Union['ulong3', u64, int]) -> 'ulong3': return intrinsic("binop.__imul__.ulong3", ulong3, byref(self), _other) + @func(inline='always') + def __mod__(self, _other: tp.Union['ulong3', u64, int]) -> 'ulong3': return intrinsic("binop.__mod__.ulong3", ulong3, self, _other) + @func(inline='always') + def __rmod__(self, _other: tp.Union['ulong3', u64, int]) -> 'ulong3': return intrinsic("binop.__rmod__.ulong3", ulong3, self, _other) + @func(inline='always') + def __imod__(self, _other: tp.Union['ulong3', u64, int]) -> 'ulong3': return intrinsic("binop.__imod__.ulong3", ulong3, byref(self), _other) + @func(inline='always') + def __lt__(self, _other: tp.Union['ulong3', u64, int]) -> 'bool3': return intrinsic("cmp.__lt__.ulong3", bool3, self, _other) # type: ignore[override] + @func(inline='always') + def __le__(self, _other: tp.Union['ulong3', u64, int]) -> 'bool3': return intrinsic("cmp.__le__.ulong3", bool3, self, _other) # type: ignore[override] + @func(inline='always') + def __gt__(self, _other: tp.Union['ulong3', u64, int]) -> 'bool3': return intrinsic("cmp.__gt__.ulong3", bool3, self, _other) # type: ignore[override] + @func(inline='always') + def __ge__(self, _other: tp.Union['ulong3', u64, int]) -> 'bool3': return intrinsic("cmp.__ge__.ulong3", bool3, self, _other) # type: ignore[override] + @func(inline='always') + def __eq__(self, _other: tp.Union['ulong3', u64, int]) -> 'bool3': return intrinsic("cmp.__eq__.ulong3", bool3, self, _other) # type: ignore[override] + @func(inline='always') + def __ne__(self, _other: tp.Union['ulong3', u64, int]) -> 'bool3': return intrinsic("cmp.__ne__.ulong3", bool3, self, _other) # type: ignore[override] + @func(inline='always') + def __floordiv__(self, _other: tp.Union['ulong3', u64, int]) -> 'ulong3': return intrinsic("binop.__floordiv__.ulong3", ulong3, self, _other) + @func(inline='always') + def __rfloordiv__(self, _other: tp.Union['ulong3', u64, int]) -> 'ulong3': return intrinsic("binop.__rfloordiv__.ulong3", ulong3, self, _other) + @func(inline='always') + def __ifloordiv__(self, _other: tp.Union['ulong3', u64, int]) -> 'ulong3': return intrinsic("binop.__ifloordiv__.ulong3", ulong3, byref(self), _other) + @func(inline='always') + def __lshift__(self, _other: tp.Union['ulong3', u64, int]) -> 'ulong3': return intrinsic("binop.__lshift__.ulong3", ulong3, self, _other) + @func(inline='always') + def __rlshift__(self, _other: tp.Union['ulong3', u64, int]) -> 'ulong3': return intrinsic("binop.__rlshift__.ulong3", ulong3, self, _other) + @func(inline='always') + def __ilshift__(self, _other: tp.Union['ulong3', u64, int]) -> 'ulong3': return intrinsic("binop.__ilshift__.ulong3", ulong3, byref(self), _other) + @func(inline='always') + def __rshift__(self, _other: tp.Union['ulong3', u64, int]) -> 'ulong3': return intrinsic("binop.__rshift__.ulong3", ulong3, self, _other) + @func(inline='always') + def __rrshift__(self, _other: tp.Union['ulong3', u64, int]) -> 'ulong3': return intrinsic("binop.__rrshift__.ulong3", ulong3, self, _other) + @func(inline='always') + def __irshift__(self, _other: tp.Union['ulong3', u64, int]) -> 'ulong3': return intrinsic("binop.__irshift__.ulong3", ulong3, byref(self), _other) + @func(inline='always') + def __and__(self, _other: tp.Union['ulong3', u64, int]) -> 'ulong3': return intrinsic("binop.__and__.ulong3", ulong3, self, _other) + @func(inline='always') + def __rand__(self, _other: tp.Union['ulong3', u64, int]) -> 'ulong3': return intrinsic("binop.__rand__.ulong3", ulong3, self, _other) + @func(inline='always') + def __iand__(self, _other: tp.Union['ulong3', u64, int]) -> 'ulong3': return intrinsic("binop.__iand__.ulong3", ulong3, byref(self), _other) + @func(inline='always') + def __or__(self, _other: tp.Union['ulong3', u64, int]) -> 'ulong3': return intrinsic("binop.__or__.ulong3", ulong3, self, _other) + @func(inline='always') + def __ror__(self, _other: tp.Union['ulong3', u64, int]) -> 'ulong3': return intrinsic("binop.__ror__.ulong3", ulong3, self, _other) + @func(inline='always') + def __ior__(self, _other: tp.Union['ulong3', u64, int]) -> 'ulong3': return intrinsic("binop.__ior__.ulong3", ulong3, byref(self), _other) + @func(inline='always') + def __xor__(self, _other: tp.Union['ulong3', u64, int]) -> 'ulong3': return intrinsic("binop.__xor__.ulong3", ulong3, self, _other) + @func(inline='always') + def __rxor__(self, _other: tp.Union['ulong3', u64, int]) -> 'ulong3': return intrinsic("binop.__rxor__.ulong3", ulong3, self, _other) + @func(inline='always') + def __ixor__(self, _other: tp.Union['ulong3', u64, int]) -> 'ulong3': return intrinsic("binop.__ixor__.ulong3", ulong3, byref(self), _other) @builtin_type(_hir.VectorType(tp.cast(_hir.ScalarType, _ctx.types[bool]), 4)) class bool4: @@ -1350,17 +2453,28 @@ class bool4: z: bool w: bool def __init__(self, x: tp.Union['bool', bool] = False, y: tp.Union['bool', bool] = False, z: tp.Union['bool', bool] = False, w: tp.Union['bool', bool] = False) -> None: self = intrinsic("init.bool4", bool4, x, y, z, w) - def __eq__(self, _other: tp.Union['bool4', bool, bool]) -> 'bool4': return intrinsic("cmp.__eq__.bool4", bool4, _other) # type: ignore[override] - def __ne__(self, _other: tp.Union['bool4', bool, bool]) -> 'bool4': return intrinsic("cmp.__ne__.bool4", bool4, _other) # type: ignore[override] - def __and__(self, _other: tp.Union['bool4', bool, bool]) -> 'bool4': return intrinsic("binop.__and__.bool4", bool4, _other) - def __rand__(self, _other: tp.Union['bool4', bool, bool]) -> 'bool4': return intrinsic("binop.__rand__.bool4", bool4, _other) - def __iand__(self, _other: tp.Union['bool4', bool, bool]) -> 'bool4': return intrinsic("binop.__iand__.bool4", bool4, _other) - def __or__(self, _other: tp.Union['bool4', bool, bool]) -> 'bool4': return intrinsic("binop.__or__.bool4", bool4, _other) - def __ror__(self, _other: tp.Union['bool4', bool, bool]) -> 'bool4': return intrinsic("binop.__ror__.bool4", bool4, _other) - def __ior__(self, _other: tp.Union['bool4', bool, bool]) -> 'bool4': return intrinsic("binop.__ior__.bool4", bool4, _other) - def __xor__(self, _other: tp.Union['bool4', bool, bool]) -> 'bool4': return intrinsic("binop.__xor__.bool4", bool4, _other) - def __rxor__(self, _other: tp.Union['bool4', bool, bool]) -> 'bool4': return intrinsic("binop.__rxor__.bool4", bool4, _other) - def __ixor__(self, _other: tp.Union['bool4', bool, bool]) -> 'bool4': return intrinsic("binop.__ixor__.bool4", bool4, _other) + @func(inline='always') + def __eq__(self, _other: tp.Union['bool4', bool, bool]) -> 'bool4': return intrinsic("cmp.__eq__.bool4", bool4, self, _other) # type: ignore[override] + @func(inline='always') + def __ne__(self, _other: tp.Union['bool4', bool, bool]) -> 'bool4': return intrinsic("cmp.__ne__.bool4", bool4, self, _other) # type: ignore[override] + @func(inline='always') + def __and__(self, _other: tp.Union['bool4', bool, bool]) -> 'bool4': return intrinsic("binop.__and__.bool4", bool4, self, _other) + @func(inline='always') + def __rand__(self, _other: tp.Union['bool4', bool, bool]) -> 'bool4': return intrinsic("binop.__rand__.bool4", bool4, self, _other) + @func(inline='always') + def __iand__(self, _other: tp.Union['bool4', bool, bool]) -> 'bool4': return intrinsic("binop.__iand__.bool4", bool4, byref(self), _other) + @func(inline='always') + def __or__(self, _other: tp.Union['bool4', bool, bool]) -> 'bool4': return intrinsic("binop.__or__.bool4", bool4, self, _other) + @func(inline='always') + def __ror__(self, _other: tp.Union['bool4', bool, bool]) -> 'bool4': return intrinsic("binop.__ror__.bool4", bool4, self, _other) + @func(inline='always') + def __ior__(self, _other: tp.Union['bool4', bool, bool]) -> 'bool4': return intrinsic("binop.__ior__.bool4", bool4, byref(self), _other) + @func(inline='always') + def __xor__(self, _other: tp.Union['bool4', bool, bool]) -> 'bool4': return intrinsic("binop.__xor__.bool4", bool4, self, _other) + @func(inline='always') + def __rxor__(self, _other: tp.Union['bool4', bool, bool]) -> 'bool4': return intrinsic("binop.__rxor__.bool4", bool4, self, _other) + @func(inline='always') + def __ixor__(self, _other: tp.Union['bool4', bool, bool]) -> 'bool4': return intrinsic("binop.__ixor__.bool4", bool4, byref(self), _other) @builtin_type(_hir.VectorType(tp.cast(_hir.ScalarType, _ctx.types[f32]), 4)) class float4(FloatBuiltin['float4']): @@ -1369,32 +2483,58 @@ class float4(FloatBuiltin['float4']): z: f32 w: f32 def __init__(self, x: tp.Union['f32', float] = 0.0, y: tp.Union['f32', float] = 0.0, z: tp.Union['f32', float] = 0.0, w: tp.Union['f32', float] = 0.0) -> None: self = intrinsic("init.float4", float4, x, y, z, w) - def __add__(self, _other: tp.Union['float4', f32, float]) -> 'float4': return intrinsic("binop.__add__.float4", float4, _other) - def __radd__(self, _other: tp.Union['float4', f32, float]) -> 'float4': return intrinsic("binop.__radd__.float4", float4, _other) - def __iadd__(self, _other: tp.Union['float4', f32, float]) -> 'float4': return intrinsic("binop.__iadd__.float4", float4, _other) - def __sub__(self, _other: tp.Union['float4', f32, float]) -> 'float4': return intrinsic("binop.__sub__.float4", float4, _other) - def __rsub__(self, _other: tp.Union['float4', f32, float]) -> 'float4': return intrinsic("binop.__rsub__.float4", float4, _other) - def __isub__(self, _other: tp.Union['float4', f32, float]) -> 'float4': return intrinsic("binop.__isub__.float4", float4, _other) - def __mul__(self, _other: tp.Union['float4', f32, float]) -> 'float4': return intrinsic("binop.__mul__.float4", float4, _other) - def __rmul__(self, _other: tp.Union['float4', f32, float]) -> 'float4': return intrinsic("binop.__rmul__.float4", float4, _other) - def __imul__(self, _other: tp.Union['float4', f32, float]) -> 'float4': return intrinsic("binop.__imul__.float4", float4, _other) - def __mod__(self, _other: tp.Union['float4', f32, float]) -> 'float4': return intrinsic("binop.__mod__.float4", float4, _other) - def __rmod__(self, _other: tp.Union['float4', f32, float]) -> 'float4': return intrinsic("binop.__rmod__.float4", float4, _other) - def __imod__(self, _other: tp.Union['float4', f32, float]) -> 'float4': return intrinsic("binop.__imod__.float4", float4, _other) - def __lt__(self, _other: tp.Union['float4', f32, float]) -> 'bool4': return intrinsic("cmp.__lt__.float4", bool4, _other) # type: ignore[override] - def __le__(self, _other: tp.Union['float4', f32, float]) -> 'bool4': return intrinsic("cmp.__le__.float4", bool4, _other) # type: ignore[override] - def __gt__(self, _other: tp.Union['float4', f32, float]) -> 'bool4': return intrinsic("cmp.__gt__.float4", bool4, _other) # type: ignore[override] - def __ge__(self, _other: tp.Union['float4', f32, float]) -> 'bool4': return intrinsic("cmp.__ge__.float4", bool4, _other) # type: ignore[override] - def __eq__(self, _other: tp.Union['float4', f32, float]) -> 'bool4': return intrinsic("cmp.__eq__.float4", bool4, _other) # type: ignore[override] - def __ne__(self, _other: tp.Union['float4', f32, float]) -> 'bool4': return intrinsic("cmp.__ne__.float4", bool4, _other) # type: ignore[override] - def __truediv__(self, _other: tp.Union['float4', f32, float]) -> 'float4': return intrinsic("binop.__truediv__.float4", float4, _other) - def __rtruediv__(self, _other: tp.Union['float4', f32, float]) -> 'float4': return intrinsic("binop.__rtruediv__.float4", float4, _other) - def __itruediv__(self, _other: tp.Union['float4', f32, float]) -> 'float4': return intrinsic("binop.__itruediv__.float4", float4, _other) - def __pow__(self, _other: tp.Union['float4', f32, float]) -> 'float4': return intrinsic("binop.__pow__.float4", float4, _other) - def __rpow__(self, _other: tp.Union['float4', f32, float]) -> 'float4': return intrinsic("binop.__rpow__.float4", float4, _other) - def __ipow__(self, _other: tp.Union['float4', f32, float]) -> 'float4': return intrinsic("binop.__ipow__.float4", float4, _other) - def __floordiv__(self, _other: tp.Union['float4', f32, float]) -> 'float4': return intrinsic("binop.__floordiv__.float4", float4, _other) - def __rfloordiv__(self, _other: tp.Union['float4', f32, float]) -> 'float4': return intrinsic("binop.__rfloordiv__.float4", float4, _other) + @func(inline='always') + def __add__(self, _other: tp.Union['float4', f32, float]) -> 'float4': return intrinsic("binop.__add__.float4", float4, self, _other) + @func(inline='always') + def __radd__(self, _other: tp.Union['float4', f32, float]) -> 'float4': return intrinsic("binop.__radd__.float4", float4, self, _other) + @func(inline='always') + def __iadd__(self, _other: tp.Union['float4', f32, float]) -> 'float4': return intrinsic("binop.__iadd__.float4", float4, byref(self), _other) + @func(inline='always') + def __sub__(self, _other: tp.Union['float4', f32, float]) -> 'float4': return intrinsic("binop.__sub__.float4", float4, self, _other) + @func(inline='always') + def __rsub__(self, _other: tp.Union['float4', f32, float]) -> 'float4': return intrinsic("binop.__rsub__.float4", float4, self, _other) + @func(inline='always') + def __isub__(self, _other: tp.Union['float4', f32, float]) -> 'float4': return intrinsic("binop.__isub__.float4", float4, byref(self), _other) + @func(inline='always') + def __mul__(self, _other: tp.Union['float4', f32, float]) -> 'float4': return intrinsic("binop.__mul__.float4", float4, self, _other) + @func(inline='always') + def __rmul__(self, _other: tp.Union['float4', f32, float]) -> 'float4': return intrinsic("binop.__rmul__.float4", float4, self, _other) + @func(inline='always') + def __imul__(self, _other: tp.Union['float4', f32, float]) -> 'float4': return intrinsic("binop.__imul__.float4", float4, byref(self), _other) + @func(inline='always') + def __mod__(self, _other: tp.Union['float4', f32, float]) -> 'float4': return intrinsic("binop.__mod__.float4", float4, self, _other) + @func(inline='always') + def __rmod__(self, _other: tp.Union['float4', f32, float]) -> 'float4': return intrinsic("binop.__rmod__.float4", float4, self, _other) + @func(inline='always') + def __imod__(self, _other: tp.Union['float4', f32, float]) -> 'float4': return intrinsic("binop.__imod__.float4", float4, byref(self), _other) + @func(inline='always') + def __lt__(self, _other: tp.Union['float4', f32, float]) -> 'bool4': return intrinsic("cmp.__lt__.float4", bool4, self, _other) # type: ignore[override] + @func(inline='always') + def __le__(self, _other: tp.Union['float4', f32, float]) -> 'bool4': return intrinsic("cmp.__le__.float4", bool4, self, _other) # type: ignore[override] + @func(inline='always') + def __gt__(self, _other: tp.Union['float4', f32, float]) -> 'bool4': return intrinsic("cmp.__gt__.float4", bool4, self, _other) # type: ignore[override] + @func(inline='always') + def __ge__(self, _other: tp.Union['float4', f32, float]) -> 'bool4': return intrinsic("cmp.__ge__.float4", bool4, self, _other) # type: ignore[override] + @func(inline='always') + def __eq__(self, _other: tp.Union['float4', f32, float]) -> 'bool4': return intrinsic("cmp.__eq__.float4", bool4, self, _other) # type: ignore[override] + @func(inline='always') + def __ne__(self, _other: tp.Union['float4', f32, float]) -> 'bool4': return intrinsic("cmp.__ne__.float4", bool4, self, _other) # type: ignore[override] + @func(inline='always') + def __truediv__(self, _other: tp.Union['float4', f32, float]) -> 'float4': return intrinsic("binop.__truediv__.float4", float4, self, _other) + @func(inline='always') + def __rtruediv__(self, _other: tp.Union['float4', f32, float]) -> 'float4': return intrinsic("binop.__rtruediv__.float4", float4, self, _other) + @func(inline='always') + def __itruediv__(self, _other: tp.Union['float4', f32, float]) -> 'float4': return intrinsic("binop.__itruediv__.float4", float4, byref(self), _other) + @func(inline='always') + def __pow__(self, _other: tp.Union['float4', f32, float]) -> 'float4': return intrinsic("binop.__pow__.float4", float4, self, _other) + @func(inline='always') + def __rpow__(self, _other: tp.Union['float4', f32, float]) -> 'float4': return intrinsic("binop.__rpow__.float4", float4, self, _other) + @func(inline='always') + def __ipow__(self, _other: tp.Union['float4', f32, float]) -> 'float4': return intrinsic("binop.__ipow__.float4", float4, byref(self), _other) + @func(inline='always') + def __floordiv__(self, _other: tp.Union['float4', f32, float]) -> 'float4': return intrinsic("binop.__floordiv__.float4", float4, self, _other) + @func(inline='always') + def __rfloordiv__(self, _other: tp.Union['float4', f32, float]) -> 'float4': return intrinsic("binop.__rfloordiv__.float4", float4, self, _other) @builtin_type(_hir.VectorType(tp.cast(_hir.ScalarType, _ctx.types[f64]), 4)) class double4(FloatBuiltin['double4']): @@ -1403,32 +2543,58 @@ class double4(FloatBuiltin['double4']): z: f64 w: f64 def __init__(self, x: tp.Union['f64', float] = 0.0, y: tp.Union['f64', float] = 0.0, z: tp.Union['f64', float] = 0.0, w: tp.Union['f64', float] = 0.0) -> None: self = intrinsic("init.double4", double4, x, y, z, w) - def __add__(self, _other: tp.Union['double4', f64, float]) -> 'double4': return intrinsic("binop.__add__.double4", double4, _other) - def __radd__(self, _other: tp.Union['double4', f64, float]) -> 'double4': return intrinsic("binop.__radd__.double4", double4, _other) - def __iadd__(self, _other: tp.Union['double4', f64, float]) -> 'double4': return intrinsic("binop.__iadd__.double4", double4, _other) - def __sub__(self, _other: tp.Union['double4', f64, float]) -> 'double4': return intrinsic("binop.__sub__.double4", double4, _other) - def __rsub__(self, _other: tp.Union['double4', f64, float]) -> 'double4': return intrinsic("binop.__rsub__.double4", double4, _other) - def __isub__(self, _other: tp.Union['double4', f64, float]) -> 'double4': return intrinsic("binop.__isub__.double4", double4, _other) - def __mul__(self, _other: tp.Union['double4', f64, float]) -> 'double4': return intrinsic("binop.__mul__.double4", double4, _other) - def __rmul__(self, _other: tp.Union['double4', f64, float]) -> 'double4': return intrinsic("binop.__rmul__.double4", double4, _other) - def __imul__(self, _other: tp.Union['double4', f64, float]) -> 'double4': return intrinsic("binop.__imul__.double4", double4, _other) - def __mod__(self, _other: tp.Union['double4', f64, float]) -> 'double4': return intrinsic("binop.__mod__.double4", double4, _other) - def __rmod__(self, _other: tp.Union['double4', f64, float]) -> 'double4': return intrinsic("binop.__rmod__.double4", double4, _other) - def __imod__(self, _other: tp.Union['double4', f64, float]) -> 'double4': return intrinsic("binop.__imod__.double4", double4, _other) - def __lt__(self, _other: tp.Union['double4', f64, float]) -> 'bool4': return intrinsic("cmp.__lt__.double4", bool4, _other) # type: ignore[override] - def __le__(self, _other: tp.Union['double4', f64, float]) -> 'bool4': return intrinsic("cmp.__le__.double4", bool4, _other) # type: ignore[override] - def __gt__(self, _other: tp.Union['double4', f64, float]) -> 'bool4': return intrinsic("cmp.__gt__.double4", bool4, _other) # type: ignore[override] - def __ge__(self, _other: tp.Union['double4', f64, float]) -> 'bool4': return intrinsic("cmp.__ge__.double4", bool4, _other) # type: ignore[override] - def __eq__(self, _other: tp.Union['double4', f64, float]) -> 'bool4': return intrinsic("cmp.__eq__.double4", bool4, _other) # type: ignore[override] - def __ne__(self, _other: tp.Union['double4', f64, float]) -> 'bool4': return intrinsic("cmp.__ne__.double4", bool4, _other) # type: ignore[override] - def __truediv__(self, _other: tp.Union['double4', f64, float]) -> 'double4': return intrinsic("binop.__truediv__.double4", double4, _other) - def __rtruediv__(self, _other: tp.Union['double4', f64, float]) -> 'double4': return intrinsic("binop.__rtruediv__.double4", double4, _other) - def __itruediv__(self, _other: tp.Union['double4', f64, float]) -> 'double4': return intrinsic("binop.__itruediv__.double4", double4, _other) - def __pow__(self, _other: tp.Union['double4', f64, float]) -> 'double4': return intrinsic("binop.__pow__.double4", double4, _other) - def __rpow__(self, _other: tp.Union['double4', f64, float]) -> 'double4': return intrinsic("binop.__rpow__.double4", double4, _other) - def __ipow__(self, _other: tp.Union['double4', f64, float]) -> 'double4': return intrinsic("binop.__ipow__.double4", double4, _other) - def __floordiv__(self, _other: tp.Union['double4', f64, float]) -> 'double4': return intrinsic("binop.__floordiv__.double4", double4, _other) - def __rfloordiv__(self, _other: tp.Union['double4', f64, float]) -> 'double4': return intrinsic("binop.__rfloordiv__.double4", double4, _other) + @func(inline='always') + def __add__(self, _other: tp.Union['double4', f64, float]) -> 'double4': return intrinsic("binop.__add__.double4", double4, self, _other) + @func(inline='always') + def __radd__(self, _other: tp.Union['double4', f64, float]) -> 'double4': return intrinsic("binop.__radd__.double4", double4, self, _other) + @func(inline='always') + def __iadd__(self, _other: tp.Union['double4', f64, float]) -> 'double4': return intrinsic("binop.__iadd__.double4", double4, byref(self), _other) + @func(inline='always') + def __sub__(self, _other: tp.Union['double4', f64, float]) -> 'double4': return intrinsic("binop.__sub__.double4", double4, self, _other) + @func(inline='always') + def __rsub__(self, _other: tp.Union['double4', f64, float]) -> 'double4': return intrinsic("binop.__rsub__.double4", double4, self, _other) + @func(inline='always') + def __isub__(self, _other: tp.Union['double4', f64, float]) -> 'double4': return intrinsic("binop.__isub__.double4", double4, byref(self), _other) + @func(inline='always') + def __mul__(self, _other: tp.Union['double4', f64, float]) -> 'double4': return intrinsic("binop.__mul__.double4", double4, self, _other) + @func(inline='always') + def __rmul__(self, _other: tp.Union['double4', f64, float]) -> 'double4': return intrinsic("binop.__rmul__.double4", double4, self, _other) + @func(inline='always') + def __imul__(self, _other: tp.Union['double4', f64, float]) -> 'double4': return intrinsic("binop.__imul__.double4", double4, byref(self), _other) + @func(inline='always') + def __mod__(self, _other: tp.Union['double4', f64, float]) -> 'double4': return intrinsic("binop.__mod__.double4", double4, self, _other) + @func(inline='always') + def __rmod__(self, _other: tp.Union['double4', f64, float]) -> 'double4': return intrinsic("binop.__rmod__.double4", double4, self, _other) + @func(inline='always') + def __imod__(self, _other: tp.Union['double4', f64, float]) -> 'double4': return intrinsic("binop.__imod__.double4", double4, byref(self), _other) + @func(inline='always') + def __lt__(self, _other: tp.Union['double4', f64, float]) -> 'bool4': return intrinsic("cmp.__lt__.double4", bool4, self, _other) # type: ignore[override] + @func(inline='always') + def __le__(self, _other: tp.Union['double4', f64, float]) -> 'bool4': return intrinsic("cmp.__le__.double4", bool4, self, _other) # type: ignore[override] + @func(inline='always') + def __gt__(self, _other: tp.Union['double4', f64, float]) -> 'bool4': return intrinsic("cmp.__gt__.double4", bool4, self, _other) # type: ignore[override] + @func(inline='always') + def __ge__(self, _other: tp.Union['double4', f64, float]) -> 'bool4': return intrinsic("cmp.__ge__.double4", bool4, self, _other) # type: ignore[override] + @func(inline='always') + def __eq__(self, _other: tp.Union['double4', f64, float]) -> 'bool4': return intrinsic("cmp.__eq__.double4", bool4, self, _other) # type: ignore[override] + @func(inline='always') + def __ne__(self, _other: tp.Union['double4', f64, float]) -> 'bool4': return intrinsic("cmp.__ne__.double4", bool4, self, _other) # type: ignore[override] + @func(inline='always') + def __truediv__(self, _other: tp.Union['double4', f64, float]) -> 'double4': return intrinsic("binop.__truediv__.double4", double4, self, _other) + @func(inline='always') + def __rtruediv__(self, _other: tp.Union['double4', f64, float]) -> 'double4': return intrinsic("binop.__rtruediv__.double4", double4, self, _other) + @func(inline='always') + def __itruediv__(self, _other: tp.Union['double4', f64, float]) -> 'double4': return intrinsic("binop.__itruediv__.double4", double4, byref(self), _other) + @func(inline='always') + def __pow__(self, _other: tp.Union['double4', f64, float]) -> 'double4': return intrinsic("binop.__pow__.double4", double4, self, _other) + @func(inline='always') + def __rpow__(self, _other: tp.Union['double4', f64, float]) -> 'double4': return intrinsic("binop.__rpow__.double4", double4, self, _other) + @func(inline='always') + def __ipow__(self, _other: tp.Union['double4', f64, float]) -> 'double4': return intrinsic("binop.__ipow__.double4", double4, byref(self), _other) + @func(inline='always') + def __floordiv__(self, _other: tp.Union['double4', f64, float]) -> 'double4': return intrinsic("binop.__floordiv__.double4", double4, self, _other) + @func(inline='always') + def __rfloordiv__(self, _other: tp.Union['double4', f64, float]) -> 'double4': return intrinsic("binop.__rfloordiv__.double4", double4, self, _other) @builtin_type(_hir.VectorType(tp.cast(_hir.ScalarType, _ctx.types[i8]), 4)) class byte4: @@ -1437,42 +2603,78 @@ class byte4: z: i8 w: i8 def __init__(self, x: tp.Union['i8', int] = 0, y: tp.Union['i8', int] = 0, z: tp.Union['i8', int] = 0, w: tp.Union['i8', int] = 0) -> None: self = intrinsic("init.byte4", byte4, x, y, z, w) - def __add__(self, _other: tp.Union['byte4', i8, int]) -> 'byte4': return intrinsic("binop.__add__.byte4", byte4, _other) - def __radd__(self, _other: tp.Union['byte4', i8, int]) -> 'byte4': return intrinsic("binop.__radd__.byte4", byte4, _other) - def __iadd__(self, _other: tp.Union['byte4', i8, int]) -> 'byte4': return intrinsic("binop.__iadd__.byte4", byte4, _other) - def __sub__(self, _other: tp.Union['byte4', i8, int]) -> 'byte4': return intrinsic("binop.__sub__.byte4", byte4, _other) - def __rsub__(self, _other: tp.Union['byte4', i8, int]) -> 'byte4': return intrinsic("binop.__rsub__.byte4", byte4, _other) - def __isub__(self, _other: tp.Union['byte4', i8, int]) -> 'byte4': return intrinsic("binop.__isub__.byte4", byte4, _other) - def __mul__(self, _other: tp.Union['byte4', i8, int]) -> 'byte4': return intrinsic("binop.__mul__.byte4", byte4, _other) - def __rmul__(self, _other: tp.Union['byte4', i8, int]) -> 'byte4': return intrinsic("binop.__rmul__.byte4", byte4, _other) - def __imul__(self, _other: tp.Union['byte4', i8, int]) -> 'byte4': return intrinsic("binop.__imul__.byte4", byte4, _other) - def __mod__(self, _other: tp.Union['byte4', i8, int]) -> 'byte4': return intrinsic("binop.__mod__.byte4", byte4, _other) - def __rmod__(self, _other: tp.Union['byte4', i8, int]) -> 'byte4': return intrinsic("binop.__rmod__.byte4", byte4, _other) - def __imod__(self, _other: tp.Union['byte4', i8, int]) -> 'byte4': return intrinsic("binop.__imod__.byte4", byte4, _other) - def __lt__(self, _other: tp.Union['byte4', i8, int]) -> 'bool4': return intrinsic("cmp.__lt__.byte4", bool4, _other) # type: ignore[override] - def __le__(self, _other: tp.Union['byte4', i8, int]) -> 'bool4': return intrinsic("cmp.__le__.byte4", bool4, _other) # type: ignore[override] - def __gt__(self, _other: tp.Union['byte4', i8, int]) -> 'bool4': return intrinsic("cmp.__gt__.byte4", bool4, _other) # type: ignore[override] - def __ge__(self, _other: tp.Union['byte4', i8, int]) -> 'bool4': return intrinsic("cmp.__ge__.byte4", bool4, _other) # type: ignore[override] - def __eq__(self, _other: tp.Union['byte4', i8, int]) -> 'bool4': return intrinsic("cmp.__eq__.byte4", bool4, _other) # type: ignore[override] - def __ne__(self, _other: tp.Union['byte4', i8, int]) -> 'bool4': return intrinsic("cmp.__ne__.byte4", bool4, _other) # type: ignore[override] - def __floordiv__(self, _other: tp.Union['byte4', i8, int]) -> 'byte4': return intrinsic("binop.__floordiv__.byte4", byte4, _other) - def __rfloordiv__(self, _other: tp.Union['byte4', i8, int]) -> 'byte4': return intrinsic("binop.__rfloordiv__.byte4", byte4, _other) - def __ifloordiv__(self, _other: tp.Union['byte4', i8, int]) -> 'byte4': return intrinsic("binop.__ifloordiv__.byte4", byte4, _other) - def __lshift__(self, _other: tp.Union['byte4', i8, int]) -> 'byte4': return intrinsic("binop.__lshift__.byte4", byte4, _other) - def __rlshift__(self, _other: tp.Union['byte4', i8, int]) -> 'byte4': return intrinsic("binop.__rlshift__.byte4", byte4, _other) - def __ilshift__(self, _other: tp.Union['byte4', i8, int]) -> 'byte4': return intrinsic("binop.__ilshift__.byte4", byte4, _other) - def __rshift__(self, _other: tp.Union['byte4', i8, int]) -> 'byte4': return intrinsic("binop.__rshift__.byte4", byte4, _other) - def __rrshift__(self, _other: tp.Union['byte4', i8, int]) -> 'byte4': return intrinsic("binop.__rrshift__.byte4", byte4, _other) - def __irshift__(self, _other: tp.Union['byte4', i8, int]) -> 'byte4': return intrinsic("binop.__irshift__.byte4", byte4, _other) - def __and__(self, _other: tp.Union['byte4', i8, int]) -> 'byte4': return intrinsic("binop.__and__.byte4", byte4, _other) - def __rand__(self, _other: tp.Union['byte4', i8, int]) -> 'byte4': return intrinsic("binop.__rand__.byte4", byte4, _other) - def __iand__(self, _other: tp.Union['byte4', i8, int]) -> 'byte4': return intrinsic("binop.__iand__.byte4", byte4, _other) - def __or__(self, _other: tp.Union['byte4', i8, int]) -> 'byte4': return intrinsic("binop.__or__.byte4", byte4, _other) - def __ror__(self, _other: tp.Union['byte4', i8, int]) -> 'byte4': return intrinsic("binop.__ror__.byte4", byte4, _other) - def __ior__(self, _other: tp.Union['byte4', i8, int]) -> 'byte4': return intrinsic("binop.__ior__.byte4", byte4, _other) - def __xor__(self, _other: tp.Union['byte4', i8, int]) -> 'byte4': return intrinsic("binop.__xor__.byte4", byte4, _other) - def __rxor__(self, _other: tp.Union['byte4', i8, int]) -> 'byte4': return intrinsic("binop.__rxor__.byte4", byte4, _other) - def __ixor__(self, _other: tp.Union['byte4', i8, int]) -> 'byte4': return intrinsic("binop.__ixor__.byte4", byte4, _other) + @func(inline='always') + def __add__(self, _other: tp.Union['byte4', i8, int]) -> 'byte4': return intrinsic("binop.__add__.byte4", byte4, self, _other) + @func(inline='always') + def __radd__(self, _other: tp.Union['byte4', i8, int]) -> 'byte4': return intrinsic("binop.__radd__.byte4", byte4, self, _other) + @func(inline='always') + def __iadd__(self, _other: tp.Union['byte4', i8, int]) -> 'byte4': return intrinsic("binop.__iadd__.byte4", byte4, byref(self), _other) + @func(inline='always') + def __sub__(self, _other: tp.Union['byte4', i8, int]) -> 'byte4': return intrinsic("binop.__sub__.byte4", byte4, self, _other) + @func(inline='always') + def __rsub__(self, _other: tp.Union['byte4', i8, int]) -> 'byte4': return intrinsic("binop.__rsub__.byte4", byte4, self, _other) + @func(inline='always') + def __isub__(self, _other: tp.Union['byte4', i8, int]) -> 'byte4': return intrinsic("binop.__isub__.byte4", byte4, byref(self), _other) + @func(inline='always') + def __mul__(self, _other: tp.Union['byte4', i8, int]) -> 'byte4': return intrinsic("binop.__mul__.byte4", byte4, self, _other) + @func(inline='always') + def __rmul__(self, _other: tp.Union['byte4', i8, int]) -> 'byte4': return intrinsic("binop.__rmul__.byte4", byte4, self, _other) + @func(inline='always') + def __imul__(self, _other: tp.Union['byte4', i8, int]) -> 'byte4': return intrinsic("binop.__imul__.byte4", byte4, byref(self), _other) + @func(inline='always') + def __mod__(self, _other: tp.Union['byte4', i8, int]) -> 'byte4': return intrinsic("binop.__mod__.byte4", byte4, self, _other) + @func(inline='always') + def __rmod__(self, _other: tp.Union['byte4', i8, int]) -> 'byte4': return intrinsic("binop.__rmod__.byte4", byte4, self, _other) + @func(inline='always') + def __imod__(self, _other: tp.Union['byte4', i8, int]) -> 'byte4': return intrinsic("binop.__imod__.byte4", byte4, byref(self), _other) + @func(inline='always') + def __lt__(self, _other: tp.Union['byte4', i8, int]) -> 'bool4': return intrinsic("cmp.__lt__.byte4", bool4, self, _other) # type: ignore[override] + @func(inline='always') + def __le__(self, _other: tp.Union['byte4', i8, int]) -> 'bool4': return intrinsic("cmp.__le__.byte4", bool4, self, _other) # type: ignore[override] + @func(inline='always') + def __gt__(self, _other: tp.Union['byte4', i8, int]) -> 'bool4': return intrinsic("cmp.__gt__.byte4", bool4, self, _other) # type: ignore[override] + @func(inline='always') + def __ge__(self, _other: tp.Union['byte4', i8, int]) -> 'bool4': return intrinsic("cmp.__ge__.byte4", bool4, self, _other) # type: ignore[override] + @func(inline='always') + def __eq__(self, _other: tp.Union['byte4', i8, int]) -> 'bool4': return intrinsic("cmp.__eq__.byte4", bool4, self, _other) # type: ignore[override] + @func(inline='always') + def __ne__(self, _other: tp.Union['byte4', i8, int]) -> 'bool4': return intrinsic("cmp.__ne__.byte4", bool4, self, _other) # type: ignore[override] + @func(inline='always') + def __floordiv__(self, _other: tp.Union['byte4', i8, int]) -> 'byte4': return intrinsic("binop.__floordiv__.byte4", byte4, self, _other) + @func(inline='always') + def __rfloordiv__(self, _other: tp.Union['byte4', i8, int]) -> 'byte4': return intrinsic("binop.__rfloordiv__.byte4", byte4, self, _other) + @func(inline='always') + def __ifloordiv__(self, _other: tp.Union['byte4', i8, int]) -> 'byte4': return intrinsic("binop.__ifloordiv__.byte4", byte4, byref(self), _other) + @func(inline='always') + def __lshift__(self, _other: tp.Union['byte4', i8, int]) -> 'byte4': return intrinsic("binop.__lshift__.byte4", byte4, self, _other) + @func(inline='always') + def __rlshift__(self, _other: tp.Union['byte4', i8, int]) -> 'byte4': return intrinsic("binop.__rlshift__.byte4", byte4, self, _other) + @func(inline='always') + def __ilshift__(self, _other: tp.Union['byte4', i8, int]) -> 'byte4': return intrinsic("binop.__ilshift__.byte4", byte4, byref(self), _other) + @func(inline='always') + def __rshift__(self, _other: tp.Union['byte4', i8, int]) -> 'byte4': return intrinsic("binop.__rshift__.byte4", byte4, self, _other) + @func(inline='always') + def __rrshift__(self, _other: tp.Union['byte4', i8, int]) -> 'byte4': return intrinsic("binop.__rrshift__.byte4", byte4, self, _other) + @func(inline='always') + def __irshift__(self, _other: tp.Union['byte4', i8, int]) -> 'byte4': return intrinsic("binop.__irshift__.byte4", byte4, byref(self), _other) + @func(inline='always') + def __and__(self, _other: tp.Union['byte4', i8, int]) -> 'byte4': return intrinsic("binop.__and__.byte4", byte4, self, _other) + @func(inline='always') + def __rand__(self, _other: tp.Union['byte4', i8, int]) -> 'byte4': return intrinsic("binop.__rand__.byte4", byte4, self, _other) + @func(inline='always') + def __iand__(self, _other: tp.Union['byte4', i8, int]) -> 'byte4': return intrinsic("binop.__iand__.byte4", byte4, byref(self), _other) + @func(inline='always') + def __or__(self, _other: tp.Union['byte4', i8, int]) -> 'byte4': return intrinsic("binop.__or__.byte4", byte4, self, _other) + @func(inline='always') + def __ror__(self, _other: tp.Union['byte4', i8, int]) -> 'byte4': return intrinsic("binop.__ror__.byte4", byte4, self, _other) + @func(inline='always') + def __ior__(self, _other: tp.Union['byte4', i8, int]) -> 'byte4': return intrinsic("binop.__ior__.byte4", byte4, byref(self), _other) + @func(inline='always') + def __xor__(self, _other: tp.Union['byte4', i8, int]) -> 'byte4': return intrinsic("binop.__xor__.byte4", byte4, self, _other) + @func(inline='always') + def __rxor__(self, _other: tp.Union['byte4', i8, int]) -> 'byte4': return intrinsic("binop.__rxor__.byte4", byte4, self, _other) + @func(inline='always') + def __ixor__(self, _other: tp.Union['byte4', i8, int]) -> 'byte4': return intrinsic("binop.__ixor__.byte4", byte4, byref(self), _other) @builtin_type(_hir.VectorType(tp.cast(_hir.ScalarType, _ctx.types[u8]), 4)) class ubyte4: @@ -1481,42 +2683,78 @@ class ubyte4: z: u8 w: u8 def __init__(self, x: tp.Union['u8', int] = 0, y: tp.Union['u8', int] = 0, z: tp.Union['u8', int] = 0, w: tp.Union['u8', int] = 0) -> None: self = intrinsic("init.ubyte4", ubyte4, x, y, z, w) - def __add__(self, _other: tp.Union['ubyte4', u8, int]) -> 'ubyte4': return intrinsic("binop.__add__.ubyte4", ubyte4, _other) - def __radd__(self, _other: tp.Union['ubyte4', u8, int]) -> 'ubyte4': return intrinsic("binop.__radd__.ubyte4", ubyte4, _other) - def __iadd__(self, _other: tp.Union['ubyte4', u8, int]) -> 'ubyte4': return intrinsic("binop.__iadd__.ubyte4", ubyte4, _other) - def __sub__(self, _other: tp.Union['ubyte4', u8, int]) -> 'ubyte4': return intrinsic("binop.__sub__.ubyte4", ubyte4, _other) - def __rsub__(self, _other: tp.Union['ubyte4', u8, int]) -> 'ubyte4': return intrinsic("binop.__rsub__.ubyte4", ubyte4, _other) - def __isub__(self, _other: tp.Union['ubyte4', u8, int]) -> 'ubyte4': return intrinsic("binop.__isub__.ubyte4", ubyte4, _other) - def __mul__(self, _other: tp.Union['ubyte4', u8, int]) -> 'ubyte4': return intrinsic("binop.__mul__.ubyte4", ubyte4, _other) - def __rmul__(self, _other: tp.Union['ubyte4', u8, int]) -> 'ubyte4': return intrinsic("binop.__rmul__.ubyte4", ubyte4, _other) - def __imul__(self, _other: tp.Union['ubyte4', u8, int]) -> 'ubyte4': return intrinsic("binop.__imul__.ubyte4", ubyte4, _other) - def __mod__(self, _other: tp.Union['ubyte4', u8, int]) -> 'ubyte4': return intrinsic("binop.__mod__.ubyte4", ubyte4, _other) - def __rmod__(self, _other: tp.Union['ubyte4', u8, int]) -> 'ubyte4': return intrinsic("binop.__rmod__.ubyte4", ubyte4, _other) - def __imod__(self, _other: tp.Union['ubyte4', u8, int]) -> 'ubyte4': return intrinsic("binop.__imod__.ubyte4", ubyte4, _other) - def __lt__(self, _other: tp.Union['ubyte4', u8, int]) -> 'bool4': return intrinsic("cmp.__lt__.ubyte4", bool4, _other) # type: ignore[override] - def __le__(self, _other: tp.Union['ubyte4', u8, int]) -> 'bool4': return intrinsic("cmp.__le__.ubyte4", bool4, _other) # type: ignore[override] - def __gt__(self, _other: tp.Union['ubyte4', u8, int]) -> 'bool4': return intrinsic("cmp.__gt__.ubyte4", bool4, _other) # type: ignore[override] - def __ge__(self, _other: tp.Union['ubyte4', u8, int]) -> 'bool4': return intrinsic("cmp.__ge__.ubyte4", bool4, _other) # type: ignore[override] - def __eq__(self, _other: tp.Union['ubyte4', u8, int]) -> 'bool4': return intrinsic("cmp.__eq__.ubyte4", bool4, _other) # type: ignore[override] - def __ne__(self, _other: tp.Union['ubyte4', u8, int]) -> 'bool4': return intrinsic("cmp.__ne__.ubyte4", bool4, _other) # type: ignore[override] - def __floordiv__(self, _other: tp.Union['ubyte4', u8, int]) -> 'ubyte4': return intrinsic("binop.__floordiv__.ubyte4", ubyte4, _other) - def __rfloordiv__(self, _other: tp.Union['ubyte4', u8, int]) -> 'ubyte4': return intrinsic("binop.__rfloordiv__.ubyte4", ubyte4, _other) - def __ifloordiv__(self, _other: tp.Union['ubyte4', u8, int]) -> 'ubyte4': return intrinsic("binop.__ifloordiv__.ubyte4", ubyte4, _other) - def __lshift__(self, _other: tp.Union['ubyte4', u8, int]) -> 'ubyte4': return intrinsic("binop.__lshift__.ubyte4", ubyte4, _other) - def __rlshift__(self, _other: tp.Union['ubyte4', u8, int]) -> 'ubyte4': return intrinsic("binop.__rlshift__.ubyte4", ubyte4, _other) - def __ilshift__(self, _other: tp.Union['ubyte4', u8, int]) -> 'ubyte4': return intrinsic("binop.__ilshift__.ubyte4", ubyte4, _other) - def __rshift__(self, _other: tp.Union['ubyte4', u8, int]) -> 'ubyte4': return intrinsic("binop.__rshift__.ubyte4", ubyte4, _other) - def __rrshift__(self, _other: tp.Union['ubyte4', u8, int]) -> 'ubyte4': return intrinsic("binop.__rrshift__.ubyte4", ubyte4, _other) - def __irshift__(self, _other: tp.Union['ubyte4', u8, int]) -> 'ubyte4': return intrinsic("binop.__irshift__.ubyte4", ubyte4, _other) - def __and__(self, _other: tp.Union['ubyte4', u8, int]) -> 'ubyte4': return intrinsic("binop.__and__.ubyte4", ubyte4, _other) - def __rand__(self, _other: tp.Union['ubyte4', u8, int]) -> 'ubyte4': return intrinsic("binop.__rand__.ubyte4", ubyte4, _other) - def __iand__(self, _other: tp.Union['ubyte4', u8, int]) -> 'ubyte4': return intrinsic("binop.__iand__.ubyte4", ubyte4, _other) - def __or__(self, _other: tp.Union['ubyte4', u8, int]) -> 'ubyte4': return intrinsic("binop.__or__.ubyte4", ubyte4, _other) - def __ror__(self, _other: tp.Union['ubyte4', u8, int]) -> 'ubyte4': return intrinsic("binop.__ror__.ubyte4", ubyte4, _other) - def __ior__(self, _other: tp.Union['ubyte4', u8, int]) -> 'ubyte4': return intrinsic("binop.__ior__.ubyte4", ubyte4, _other) - def __xor__(self, _other: tp.Union['ubyte4', u8, int]) -> 'ubyte4': return intrinsic("binop.__xor__.ubyte4", ubyte4, _other) - def __rxor__(self, _other: tp.Union['ubyte4', u8, int]) -> 'ubyte4': return intrinsic("binop.__rxor__.ubyte4", ubyte4, _other) - def __ixor__(self, _other: tp.Union['ubyte4', u8, int]) -> 'ubyte4': return intrinsic("binop.__ixor__.ubyte4", ubyte4, _other) + @func(inline='always') + def __add__(self, _other: tp.Union['ubyte4', u8, int]) -> 'ubyte4': return intrinsic("binop.__add__.ubyte4", ubyte4, self, _other) + @func(inline='always') + def __radd__(self, _other: tp.Union['ubyte4', u8, int]) -> 'ubyte4': return intrinsic("binop.__radd__.ubyte4", ubyte4, self, _other) + @func(inline='always') + def __iadd__(self, _other: tp.Union['ubyte4', u8, int]) -> 'ubyte4': return intrinsic("binop.__iadd__.ubyte4", ubyte4, byref(self), _other) + @func(inline='always') + def __sub__(self, _other: tp.Union['ubyte4', u8, int]) -> 'ubyte4': return intrinsic("binop.__sub__.ubyte4", ubyte4, self, _other) + @func(inline='always') + def __rsub__(self, _other: tp.Union['ubyte4', u8, int]) -> 'ubyte4': return intrinsic("binop.__rsub__.ubyte4", ubyte4, self, _other) + @func(inline='always') + def __isub__(self, _other: tp.Union['ubyte4', u8, int]) -> 'ubyte4': return intrinsic("binop.__isub__.ubyte4", ubyte4, byref(self), _other) + @func(inline='always') + def __mul__(self, _other: tp.Union['ubyte4', u8, int]) -> 'ubyte4': return intrinsic("binop.__mul__.ubyte4", ubyte4, self, _other) + @func(inline='always') + def __rmul__(self, _other: tp.Union['ubyte4', u8, int]) -> 'ubyte4': return intrinsic("binop.__rmul__.ubyte4", ubyte4, self, _other) + @func(inline='always') + def __imul__(self, _other: tp.Union['ubyte4', u8, int]) -> 'ubyte4': return intrinsic("binop.__imul__.ubyte4", ubyte4, byref(self), _other) + @func(inline='always') + def __mod__(self, _other: tp.Union['ubyte4', u8, int]) -> 'ubyte4': return intrinsic("binop.__mod__.ubyte4", ubyte4, self, _other) + @func(inline='always') + def __rmod__(self, _other: tp.Union['ubyte4', u8, int]) -> 'ubyte4': return intrinsic("binop.__rmod__.ubyte4", ubyte4, self, _other) + @func(inline='always') + def __imod__(self, _other: tp.Union['ubyte4', u8, int]) -> 'ubyte4': return intrinsic("binop.__imod__.ubyte4", ubyte4, byref(self), _other) + @func(inline='always') + def __lt__(self, _other: tp.Union['ubyte4', u8, int]) -> 'bool4': return intrinsic("cmp.__lt__.ubyte4", bool4, self, _other) # type: ignore[override] + @func(inline='always') + def __le__(self, _other: tp.Union['ubyte4', u8, int]) -> 'bool4': return intrinsic("cmp.__le__.ubyte4", bool4, self, _other) # type: ignore[override] + @func(inline='always') + def __gt__(self, _other: tp.Union['ubyte4', u8, int]) -> 'bool4': return intrinsic("cmp.__gt__.ubyte4", bool4, self, _other) # type: ignore[override] + @func(inline='always') + def __ge__(self, _other: tp.Union['ubyte4', u8, int]) -> 'bool4': return intrinsic("cmp.__ge__.ubyte4", bool4, self, _other) # type: ignore[override] + @func(inline='always') + def __eq__(self, _other: tp.Union['ubyte4', u8, int]) -> 'bool4': return intrinsic("cmp.__eq__.ubyte4", bool4, self, _other) # type: ignore[override] + @func(inline='always') + def __ne__(self, _other: tp.Union['ubyte4', u8, int]) -> 'bool4': return intrinsic("cmp.__ne__.ubyte4", bool4, self, _other) # type: ignore[override] + @func(inline='always') + def __floordiv__(self, _other: tp.Union['ubyte4', u8, int]) -> 'ubyte4': return intrinsic("binop.__floordiv__.ubyte4", ubyte4, self, _other) + @func(inline='always') + def __rfloordiv__(self, _other: tp.Union['ubyte4', u8, int]) -> 'ubyte4': return intrinsic("binop.__rfloordiv__.ubyte4", ubyte4, self, _other) + @func(inline='always') + def __ifloordiv__(self, _other: tp.Union['ubyte4', u8, int]) -> 'ubyte4': return intrinsic("binop.__ifloordiv__.ubyte4", ubyte4, byref(self), _other) + @func(inline='always') + def __lshift__(self, _other: tp.Union['ubyte4', u8, int]) -> 'ubyte4': return intrinsic("binop.__lshift__.ubyte4", ubyte4, self, _other) + @func(inline='always') + def __rlshift__(self, _other: tp.Union['ubyte4', u8, int]) -> 'ubyte4': return intrinsic("binop.__rlshift__.ubyte4", ubyte4, self, _other) + @func(inline='always') + def __ilshift__(self, _other: tp.Union['ubyte4', u8, int]) -> 'ubyte4': return intrinsic("binop.__ilshift__.ubyte4", ubyte4, byref(self), _other) + @func(inline='always') + def __rshift__(self, _other: tp.Union['ubyte4', u8, int]) -> 'ubyte4': return intrinsic("binop.__rshift__.ubyte4", ubyte4, self, _other) + @func(inline='always') + def __rrshift__(self, _other: tp.Union['ubyte4', u8, int]) -> 'ubyte4': return intrinsic("binop.__rrshift__.ubyte4", ubyte4, self, _other) + @func(inline='always') + def __irshift__(self, _other: tp.Union['ubyte4', u8, int]) -> 'ubyte4': return intrinsic("binop.__irshift__.ubyte4", ubyte4, byref(self), _other) + @func(inline='always') + def __and__(self, _other: tp.Union['ubyte4', u8, int]) -> 'ubyte4': return intrinsic("binop.__and__.ubyte4", ubyte4, self, _other) + @func(inline='always') + def __rand__(self, _other: tp.Union['ubyte4', u8, int]) -> 'ubyte4': return intrinsic("binop.__rand__.ubyte4", ubyte4, self, _other) + @func(inline='always') + def __iand__(self, _other: tp.Union['ubyte4', u8, int]) -> 'ubyte4': return intrinsic("binop.__iand__.ubyte4", ubyte4, byref(self), _other) + @func(inline='always') + def __or__(self, _other: tp.Union['ubyte4', u8, int]) -> 'ubyte4': return intrinsic("binop.__or__.ubyte4", ubyte4, self, _other) + @func(inline='always') + def __ror__(self, _other: tp.Union['ubyte4', u8, int]) -> 'ubyte4': return intrinsic("binop.__ror__.ubyte4", ubyte4, self, _other) + @func(inline='always') + def __ior__(self, _other: tp.Union['ubyte4', u8, int]) -> 'ubyte4': return intrinsic("binop.__ior__.ubyte4", ubyte4, byref(self), _other) + @func(inline='always') + def __xor__(self, _other: tp.Union['ubyte4', u8, int]) -> 'ubyte4': return intrinsic("binop.__xor__.ubyte4", ubyte4, self, _other) + @func(inline='always') + def __rxor__(self, _other: tp.Union['ubyte4', u8, int]) -> 'ubyte4': return intrinsic("binop.__rxor__.ubyte4", ubyte4, self, _other) + @func(inline='always') + def __ixor__(self, _other: tp.Union['ubyte4', u8, int]) -> 'ubyte4': return intrinsic("binop.__ixor__.ubyte4", ubyte4, byref(self), _other) @builtin_type(_hir.VectorType(tp.cast(_hir.ScalarType, _ctx.types[i16]), 4)) class short4: @@ -1525,42 +2763,78 @@ class short4: z: i16 w: i16 def __init__(self, x: tp.Union['i16', int] = 0, y: tp.Union['i16', int] = 0, z: tp.Union['i16', int] = 0, w: tp.Union['i16', int] = 0) -> None: self = intrinsic("init.short4", short4, x, y, z, w) - def __add__(self, _other: tp.Union['short4', i16, int]) -> 'short4': return intrinsic("binop.__add__.short4", short4, _other) - def __radd__(self, _other: tp.Union['short4', i16, int]) -> 'short4': return intrinsic("binop.__radd__.short4", short4, _other) - def __iadd__(self, _other: tp.Union['short4', i16, int]) -> 'short4': return intrinsic("binop.__iadd__.short4", short4, _other) - def __sub__(self, _other: tp.Union['short4', i16, int]) -> 'short4': return intrinsic("binop.__sub__.short4", short4, _other) - def __rsub__(self, _other: tp.Union['short4', i16, int]) -> 'short4': return intrinsic("binop.__rsub__.short4", short4, _other) - def __isub__(self, _other: tp.Union['short4', i16, int]) -> 'short4': return intrinsic("binop.__isub__.short4", short4, _other) - def __mul__(self, _other: tp.Union['short4', i16, int]) -> 'short4': return intrinsic("binop.__mul__.short4", short4, _other) - def __rmul__(self, _other: tp.Union['short4', i16, int]) -> 'short4': return intrinsic("binop.__rmul__.short4", short4, _other) - def __imul__(self, _other: tp.Union['short4', i16, int]) -> 'short4': return intrinsic("binop.__imul__.short4", short4, _other) - def __mod__(self, _other: tp.Union['short4', i16, int]) -> 'short4': return intrinsic("binop.__mod__.short4", short4, _other) - def __rmod__(self, _other: tp.Union['short4', i16, int]) -> 'short4': return intrinsic("binop.__rmod__.short4", short4, _other) - def __imod__(self, _other: tp.Union['short4', i16, int]) -> 'short4': return intrinsic("binop.__imod__.short4", short4, _other) - def __lt__(self, _other: tp.Union['short4', i16, int]) -> 'bool4': return intrinsic("cmp.__lt__.short4", bool4, _other) # type: ignore[override] - def __le__(self, _other: tp.Union['short4', i16, int]) -> 'bool4': return intrinsic("cmp.__le__.short4", bool4, _other) # type: ignore[override] - def __gt__(self, _other: tp.Union['short4', i16, int]) -> 'bool4': return intrinsic("cmp.__gt__.short4", bool4, _other) # type: ignore[override] - def __ge__(self, _other: tp.Union['short4', i16, int]) -> 'bool4': return intrinsic("cmp.__ge__.short4", bool4, _other) # type: ignore[override] - def __eq__(self, _other: tp.Union['short4', i16, int]) -> 'bool4': return intrinsic("cmp.__eq__.short4", bool4, _other) # type: ignore[override] - def __ne__(self, _other: tp.Union['short4', i16, int]) -> 'bool4': return intrinsic("cmp.__ne__.short4", bool4, _other) # type: ignore[override] - def __floordiv__(self, _other: tp.Union['short4', i16, int]) -> 'short4': return intrinsic("binop.__floordiv__.short4", short4, _other) - def __rfloordiv__(self, _other: tp.Union['short4', i16, int]) -> 'short4': return intrinsic("binop.__rfloordiv__.short4", short4, _other) - def __ifloordiv__(self, _other: tp.Union['short4', i16, int]) -> 'short4': return intrinsic("binop.__ifloordiv__.short4", short4, _other) - def __lshift__(self, _other: tp.Union['short4', i16, int]) -> 'short4': return intrinsic("binop.__lshift__.short4", short4, _other) - def __rlshift__(self, _other: tp.Union['short4', i16, int]) -> 'short4': return intrinsic("binop.__rlshift__.short4", short4, _other) - def __ilshift__(self, _other: tp.Union['short4', i16, int]) -> 'short4': return intrinsic("binop.__ilshift__.short4", short4, _other) - def __rshift__(self, _other: tp.Union['short4', i16, int]) -> 'short4': return intrinsic("binop.__rshift__.short4", short4, _other) - def __rrshift__(self, _other: tp.Union['short4', i16, int]) -> 'short4': return intrinsic("binop.__rrshift__.short4", short4, _other) - def __irshift__(self, _other: tp.Union['short4', i16, int]) -> 'short4': return intrinsic("binop.__irshift__.short4", short4, _other) - def __and__(self, _other: tp.Union['short4', i16, int]) -> 'short4': return intrinsic("binop.__and__.short4", short4, _other) - def __rand__(self, _other: tp.Union['short4', i16, int]) -> 'short4': return intrinsic("binop.__rand__.short4", short4, _other) - def __iand__(self, _other: tp.Union['short4', i16, int]) -> 'short4': return intrinsic("binop.__iand__.short4", short4, _other) - def __or__(self, _other: tp.Union['short4', i16, int]) -> 'short4': return intrinsic("binop.__or__.short4", short4, _other) - def __ror__(self, _other: tp.Union['short4', i16, int]) -> 'short4': return intrinsic("binop.__ror__.short4", short4, _other) - def __ior__(self, _other: tp.Union['short4', i16, int]) -> 'short4': return intrinsic("binop.__ior__.short4", short4, _other) - def __xor__(self, _other: tp.Union['short4', i16, int]) -> 'short4': return intrinsic("binop.__xor__.short4", short4, _other) - def __rxor__(self, _other: tp.Union['short4', i16, int]) -> 'short4': return intrinsic("binop.__rxor__.short4", short4, _other) - def __ixor__(self, _other: tp.Union['short4', i16, int]) -> 'short4': return intrinsic("binop.__ixor__.short4", short4, _other) + @func(inline='always') + def __add__(self, _other: tp.Union['short4', i16, int]) -> 'short4': return intrinsic("binop.__add__.short4", short4, self, _other) + @func(inline='always') + def __radd__(self, _other: tp.Union['short4', i16, int]) -> 'short4': return intrinsic("binop.__radd__.short4", short4, self, _other) + @func(inline='always') + def __iadd__(self, _other: tp.Union['short4', i16, int]) -> 'short4': return intrinsic("binop.__iadd__.short4", short4, byref(self), _other) + @func(inline='always') + def __sub__(self, _other: tp.Union['short4', i16, int]) -> 'short4': return intrinsic("binop.__sub__.short4", short4, self, _other) + @func(inline='always') + def __rsub__(self, _other: tp.Union['short4', i16, int]) -> 'short4': return intrinsic("binop.__rsub__.short4", short4, self, _other) + @func(inline='always') + def __isub__(self, _other: tp.Union['short4', i16, int]) -> 'short4': return intrinsic("binop.__isub__.short4", short4, byref(self), _other) + @func(inline='always') + def __mul__(self, _other: tp.Union['short4', i16, int]) -> 'short4': return intrinsic("binop.__mul__.short4", short4, self, _other) + @func(inline='always') + def __rmul__(self, _other: tp.Union['short4', i16, int]) -> 'short4': return intrinsic("binop.__rmul__.short4", short4, self, _other) + @func(inline='always') + def __imul__(self, _other: tp.Union['short4', i16, int]) -> 'short4': return intrinsic("binop.__imul__.short4", short4, byref(self), _other) + @func(inline='always') + def __mod__(self, _other: tp.Union['short4', i16, int]) -> 'short4': return intrinsic("binop.__mod__.short4", short4, self, _other) + @func(inline='always') + def __rmod__(self, _other: tp.Union['short4', i16, int]) -> 'short4': return intrinsic("binop.__rmod__.short4", short4, self, _other) + @func(inline='always') + def __imod__(self, _other: tp.Union['short4', i16, int]) -> 'short4': return intrinsic("binop.__imod__.short4", short4, byref(self), _other) + @func(inline='always') + def __lt__(self, _other: tp.Union['short4', i16, int]) -> 'bool4': return intrinsic("cmp.__lt__.short4", bool4, self, _other) # type: ignore[override] + @func(inline='always') + def __le__(self, _other: tp.Union['short4', i16, int]) -> 'bool4': return intrinsic("cmp.__le__.short4", bool4, self, _other) # type: ignore[override] + @func(inline='always') + def __gt__(self, _other: tp.Union['short4', i16, int]) -> 'bool4': return intrinsic("cmp.__gt__.short4", bool4, self, _other) # type: ignore[override] + @func(inline='always') + def __ge__(self, _other: tp.Union['short4', i16, int]) -> 'bool4': return intrinsic("cmp.__ge__.short4", bool4, self, _other) # type: ignore[override] + @func(inline='always') + def __eq__(self, _other: tp.Union['short4', i16, int]) -> 'bool4': return intrinsic("cmp.__eq__.short4", bool4, self, _other) # type: ignore[override] + @func(inline='always') + def __ne__(self, _other: tp.Union['short4', i16, int]) -> 'bool4': return intrinsic("cmp.__ne__.short4", bool4, self, _other) # type: ignore[override] + @func(inline='always') + def __floordiv__(self, _other: tp.Union['short4', i16, int]) -> 'short4': return intrinsic("binop.__floordiv__.short4", short4, self, _other) + @func(inline='always') + def __rfloordiv__(self, _other: tp.Union['short4', i16, int]) -> 'short4': return intrinsic("binop.__rfloordiv__.short4", short4, self, _other) + @func(inline='always') + def __ifloordiv__(self, _other: tp.Union['short4', i16, int]) -> 'short4': return intrinsic("binop.__ifloordiv__.short4", short4, byref(self), _other) + @func(inline='always') + def __lshift__(self, _other: tp.Union['short4', i16, int]) -> 'short4': return intrinsic("binop.__lshift__.short4", short4, self, _other) + @func(inline='always') + def __rlshift__(self, _other: tp.Union['short4', i16, int]) -> 'short4': return intrinsic("binop.__rlshift__.short4", short4, self, _other) + @func(inline='always') + def __ilshift__(self, _other: tp.Union['short4', i16, int]) -> 'short4': return intrinsic("binop.__ilshift__.short4", short4, byref(self), _other) + @func(inline='always') + def __rshift__(self, _other: tp.Union['short4', i16, int]) -> 'short4': return intrinsic("binop.__rshift__.short4", short4, self, _other) + @func(inline='always') + def __rrshift__(self, _other: tp.Union['short4', i16, int]) -> 'short4': return intrinsic("binop.__rrshift__.short4", short4, self, _other) + @func(inline='always') + def __irshift__(self, _other: tp.Union['short4', i16, int]) -> 'short4': return intrinsic("binop.__irshift__.short4", short4, byref(self), _other) + @func(inline='always') + def __and__(self, _other: tp.Union['short4', i16, int]) -> 'short4': return intrinsic("binop.__and__.short4", short4, self, _other) + @func(inline='always') + def __rand__(self, _other: tp.Union['short4', i16, int]) -> 'short4': return intrinsic("binop.__rand__.short4", short4, self, _other) + @func(inline='always') + def __iand__(self, _other: tp.Union['short4', i16, int]) -> 'short4': return intrinsic("binop.__iand__.short4", short4, byref(self), _other) + @func(inline='always') + def __or__(self, _other: tp.Union['short4', i16, int]) -> 'short4': return intrinsic("binop.__or__.short4", short4, self, _other) + @func(inline='always') + def __ror__(self, _other: tp.Union['short4', i16, int]) -> 'short4': return intrinsic("binop.__ror__.short4", short4, self, _other) + @func(inline='always') + def __ior__(self, _other: tp.Union['short4', i16, int]) -> 'short4': return intrinsic("binop.__ior__.short4", short4, byref(self), _other) + @func(inline='always') + def __xor__(self, _other: tp.Union['short4', i16, int]) -> 'short4': return intrinsic("binop.__xor__.short4", short4, self, _other) + @func(inline='always') + def __rxor__(self, _other: tp.Union['short4', i16, int]) -> 'short4': return intrinsic("binop.__rxor__.short4", short4, self, _other) + @func(inline='always') + def __ixor__(self, _other: tp.Union['short4', i16, int]) -> 'short4': return intrinsic("binop.__ixor__.short4", short4, byref(self), _other) @builtin_type(_hir.VectorType(tp.cast(_hir.ScalarType, _ctx.types[u16]), 4)) class ushort4: @@ -1569,42 +2843,78 @@ class ushort4: z: u16 w: u16 def __init__(self, x: tp.Union['u16', int] = 0, y: tp.Union['u16', int] = 0, z: tp.Union['u16', int] = 0, w: tp.Union['u16', int] = 0) -> None: self = intrinsic("init.ushort4", ushort4, x, y, z, w) - def __add__(self, _other: tp.Union['ushort4', u16, int]) -> 'ushort4': return intrinsic("binop.__add__.ushort4", ushort4, _other) - def __radd__(self, _other: tp.Union['ushort4', u16, int]) -> 'ushort4': return intrinsic("binop.__radd__.ushort4", ushort4, _other) - def __iadd__(self, _other: tp.Union['ushort4', u16, int]) -> 'ushort4': return intrinsic("binop.__iadd__.ushort4", ushort4, _other) - def __sub__(self, _other: tp.Union['ushort4', u16, int]) -> 'ushort4': return intrinsic("binop.__sub__.ushort4", ushort4, _other) - def __rsub__(self, _other: tp.Union['ushort4', u16, int]) -> 'ushort4': return intrinsic("binop.__rsub__.ushort4", ushort4, _other) - def __isub__(self, _other: tp.Union['ushort4', u16, int]) -> 'ushort4': return intrinsic("binop.__isub__.ushort4", ushort4, _other) - def __mul__(self, _other: tp.Union['ushort4', u16, int]) -> 'ushort4': return intrinsic("binop.__mul__.ushort4", ushort4, _other) - def __rmul__(self, _other: tp.Union['ushort4', u16, int]) -> 'ushort4': return intrinsic("binop.__rmul__.ushort4", ushort4, _other) - def __imul__(self, _other: tp.Union['ushort4', u16, int]) -> 'ushort4': return intrinsic("binop.__imul__.ushort4", ushort4, _other) - def __mod__(self, _other: tp.Union['ushort4', u16, int]) -> 'ushort4': return intrinsic("binop.__mod__.ushort4", ushort4, _other) - def __rmod__(self, _other: tp.Union['ushort4', u16, int]) -> 'ushort4': return intrinsic("binop.__rmod__.ushort4", ushort4, _other) - def __imod__(self, _other: tp.Union['ushort4', u16, int]) -> 'ushort4': return intrinsic("binop.__imod__.ushort4", ushort4, _other) - def __lt__(self, _other: tp.Union['ushort4', u16, int]) -> 'bool4': return intrinsic("cmp.__lt__.ushort4", bool4, _other) # type: ignore[override] - def __le__(self, _other: tp.Union['ushort4', u16, int]) -> 'bool4': return intrinsic("cmp.__le__.ushort4", bool4, _other) # type: ignore[override] - def __gt__(self, _other: tp.Union['ushort4', u16, int]) -> 'bool4': return intrinsic("cmp.__gt__.ushort4", bool4, _other) # type: ignore[override] - def __ge__(self, _other: tp.Union['ushort4', u16, int]) -> 'bool4': return intrinsic("cmp.__ge__.ushort4", bool4, _other) # type: ignore[override] - def __eq__(self, _other: tp.Union['ushort4', u16, int]) -> 'bool4': return intrinsic("cmp.__eq__.ushort4", bool4, _other) # type: ignore[override] - def __ne__(self, _other: tp.Union['ushort4', u16, int]) -> 'bool4': return intrinsic("cmp.__ne__.ushort4", bool4, _other) # type: ignore[override] - def __floordiv__(self, _other: tp.Union['ushort4', u16, int]) -> 'ushort4': return intrinsic("binop.__floordiv__.ushort4", ushort4, _other) - def __rfloordiv__(self, _other: tp.Union['ushort4', u16, int]) -> 'ushort4': return intrinsic("binop.__rfloordiv__.ushort4", ushort4, _other) - def __ifloordiv__(self, _other: tp.Union['ushort4', u16, int]) -> 'ushort4': return intrinsic("binop.__ifloordiv__.ushort4", ushort4, _other) - def __lshift__(self, _other: tp.Union['ushort4', u16, int]) -> 'ushort4': return intrinsic("binop.__lshift__.ushort4", ushort4, _other) - def __rlshift__(self, _other: tp.Union['ushort4', u16, int]) -> 'ushort4': return intrinsic("binop.__rlshift__.ushort4", ushort4, _other) - def __ilshift__(self, _other: tp.Union['ushort4', u16, int]) -> 'ushort4': return intrinsic("binop.__ilshift__.ushort4", ushort4, _other) - def __rshift__(self, _other: tp.Union['ushort4', u16, int]) -> 'ushort4': return intrinsic("binop.__rshift__.ushort4", ushort4, _other) - def __rrshift__(self, _other: tp.Union['ushort4', u16, int]) -> 'ushort4': return intrinsic("binop.__rrshift__.ushort4", ushort4, _other) - def __irshift__(self, _other: tp.Union['ushort4', u16, int]) -> 'ushort4': return intrinsic("binop.__irshift__.ushort4", ushort4, _other) - def __and__(self, _other: tp.Union['ushort4', u16, int]) -> 'ushort4': return intrinsic("binop.__and__.ushort4", ushort4, _other) - def __rand__(self, _other: tp.Union['ushort4', u16, int]) -> 'ushort4': return intrinsic("binop.__rand__.ushort4", ushort4, _other) - def __iand__(self, _other: tp.Union['ushort4', u16, int]) -> 'ushort4': return intrinsic("binop.__iand__.ushort4", ushort4, _other) - def __or__(self, _other: tp.Union['ushort4', u16, int]) -> 'ushort4': return intrinsic("binop.__or__.ushort4", ushort4, _other) - def __ror__(self, _other: tp.Union['ushort4', u16, int]) -> 'ushort4': return intrinsic("binop.__ror__.ushort4", ushort4, _other) - def __ior__(self, _other: tp.Union['ushort4', u16, int]) -> 'ushort4': return intrinsic("binop.__ior__.ushort4", ushort4, _other) - def __xor__(self, _other: tp.Union['ushort4', u16, int]) -> 'ushort4': return intrinsic("binop.__xor__.ushort4", ushort4, _other) - def __rxor__(self, _other: tp.Union['ushort4', u16, int]) -> 'ushort4': return intrinsic("binop.__rxor__.ushort4", ushort4, _other) - def __ixor__(self, _other: tp.Union['ushort4', u16, int]) -> 'ushort4': return intrinsic("binop.__ixor__.ushort4", ushort4, _other) + @func(inline='always') + def __add__(self, _other: tp.Union['ushort4', u16, int]) -> 'ushort4': return intrinsic("binop.__add__.ushort4", ushort4, self, _other) + @func(inline='always') + def __radd__(self, _other: tp.Union['ushort4', u16, int]) -> 'ushort4': return intrinsic("binop.__radd__.ushort4", ushort4, self, _other) + @func(inline='always') + def __iadd__(self, _other: tp.Union['ushort4', u16, int]) -> 'ushort4': return intrinsic("binop.__iadd__.ushort4", ushort4, byref(self), _other) + @func(inline='always') + def __sub__(self, _other: tp.Union['ushort4', u16, int]) -> 'ushort4': return intrinsic("binop.__sub__.ushort4", ushort4, self, _other) + @func(inline='always') + def __rsub__(self, _other: tp.Union['ushort4', u16, int]) -> 'ushort4': return intrinsic("binop.__rsub__.ushort4", ushort4, self, _other) + @func(inline='always') + def __isub__(self, _other: tp.Union['ushort4', u16, int]) -> 'ushort4': return intrinsic("binop.__isub__.ushort4", ushort4, byref(self), _other) + @func(inline='always') + def __mul__(self, _other: tp.Union['ushort4', u16, int]) -> 'ushort4': return intrinsic("binop.__mul__.ushort4", ushort4, self, _other) + @func(inline='always') + def __rmul__(self, _other: tp.Union['ushort4', u16, int]) -> 'ushort4': return intrinsic("binop.__rmul__.ushort4", ushort4, self, _other) + @func(inline='always') + def __imul__(self, _other: tp.Union['ushort4', u16, int]) -> 'ushort4': return intrinsic("binop.__imul__.ushort4", ushort4, byref(self), _other) + @func(inline='always') + def __mod__(self, _other: tp.Union['ushort4', u16, int]) -> 'ushort4': return intrinsic("binop.__mod__.ushort4", ushort4, self, _other) + @func(inline='always') + def __rmod__(self, _other: tp.Union['ushort4', u16, int]) -> 'ushort4': return intrinsic("binop.__rmod__.ushort4", ushort4, self, _other) + @func(inline='always') + def __imod__(self, _other: tp.Union['ushort4', u16, int]) -> 'ushort4': return intrinsic("binop.__imod__.ushort4", ushort4, byref(self), _other) + @func(inline='always') + def __lt__(self, _other: tp.Union['ushort4', u16, int]) -> 'bool4': return intrinsic("cmp.__lt__.ushort4", bool4, self, _other) # type: ignore[override] + @func(inline='always') + def __le__(self, _other: tp.Union['ushort4', u16, int]) -> 'bool4': return intrinsic("cmp.__le__.ushort4", bool4, self, _other) # type: ignore[override] + @func(inline='always') + def __gt__(self, _other: tp.Union['ushort4', u16, int]) -> 'bool4': return intrinsic("cmp.__gt__.ushort4", bool4, self, _other) # type: ignore[override] + @func(inline='always') + def __ge__(self, _other: tp.Union['ushort4', u16, int]) -> 'bool4': return intrinsic("cmp.__ge__.ushort4", bool4, self, _other) # type: ignore[override] + @func(inline='always') + def __eq__(self, _other: tp.Union['ushort4', u16, int]) -> 'bool4': return intrinsic("cmp.__eq__.ushort4", bool4, self, _other) # type: ignore[override] + @func(inline='always') + def __ne__(self, _other: tp.Union['ushort4', u16, int]) -> 'bool4': return intrinsic("cmp.__ne__.ushort4", bool4, self, _other) # type: ignore[override] + @func(inline='always') + def __floordiv__(self, _other: tp.Union['ushort4', u16, int]) -> 'ushort4': return intrinsic("binop.__floordiv__.ushort4", ushort4, self, _other) + @func(inline='always') + def __rfloordiv__(self, _other: tp.Union['ushort4', u16, int]) -> 'ushort4': return intrinsic("binop.__rfloordiv__.ushort4", ushort4, self, _other) + @func(inline='always') + def __ifloordiv__(self, _other: tp.Union['ushort4', u16, int]) -> 'ushort4': return intrinsic("binop.__ifloordiv__.ushort4", ushort4, byref(self), _other) + @func(inline='always') + def __lshift__(self, _other: tp.Union['ushort4', u16, int]) -> 'ushort4': return intrinsic("binop.__lshift__.ushort4", ushort4, self, _other) + @func(inline='always') + def __rlshift__(self, _other: tp.Union['ushort4', u16, int]) -> 'ushort4': return intrinsic("binop.__rlshift__.ushort4", ushort4, self, _other) + @func(inline='always') + def __ilshift__(self, _other: tp.Union['ushort4', u16, int]) -> 'ushort4': return intrinsic("binop.__ilshift__.ushort4", ushort4, byref(self), _other) + @func(inline='always') + def __rshift__(self, _other: tp.Union['ushort4', u16, int]) -> 'ushort4': return intrinsic("binop.__rshift__.ushort4", ushort4, self, _other) + @func(inline='always') + def __rrshift__(self, _other: tp.Union['ushort4', u16, int]) -> 'ushort4': return intrinsic("binop.__rrshift__.ushort4", ushort4, self, _other) + @func(inline='always') + def __irshift__(self, _other: tp.Union['ushort4', u16, int]) -> 'ushort4': return intrinsic("binop.__irshift__.ushort4", ushort4, byref(self), _other) + @func(inline='always') + def __and__(self, _other: tp.Union['ushort4', u16, int]) -> 'ushort4': return intrinsic("binop.__and__.ushort4", ushort4, self, _other) + @func(inline='always') + def __rand__(self, _other: tp.Union['ushort4', u16, int]) -> 'ushort4': return intrinsic("binop.__rand__.ushort4", ushort4, self, _other) + @func(inline='always') + def __iand__(self, _other: tp.Union['ushort4', u16, int]) -> 'ushort4': return intrinsic("binop.__iand__.ushort4", ushort4, byref(self), _other) + @func(inline='always') + def __or__(self, _other: tp.Union['ushort4', u16, int]) -> 'ushort4': return intrinsic("binop.__or__.ushort4", ushort4, self, _other) + @func(inline='always') + def __ror__(self, _other: tp.Union['ushort4', u16, int]) -> 'ushort4': return intrinsic("binop.__ror__.ushort4", ushort4, self, _other) + @func(inline='always') + def __ior__(self, _other: tp.Union['ushort4', u16, int]) -> 'ushort4': return intrinsic("binop.__ior__.ushort4", ushort4, byref(self), _other) + @func(inline='always') + def __xor__(self, _other: tp.Union['ushort4', u16, int]) -> 'ushort4': return intrinsic("binop.__xor__.ushort4", ushort4, self, _other) + @func(inline='always') + def __rxor__(self, _other: tp.Union['ushort4', u16, int]) -> 'ushort4': return intrinsic("binop.__rxor__.ushort4", ushort4, self, _other) + @func(inline='always') + def __ixor__(self, _other: tp.Union['ushort4', u16, int]) -> 'ushort4': return intrinsic("binop.__ixor__.ushort4", ushort4, byref(self), _other) @builtin_type(_hir.VectorType(tp.cast(_hir.ScalarType, _ctx.types[i32]), 4)) class int4: @@ -1613,42 +2923,78 @@ class int4: z: i32 w: i32 def __init__(self, x: tp.Union['i32', int] = 0, y: tp.Union['i32', int] = 0, z: tp.Union['i32', int] = 0, w: tp.Union['i32', int] = 0) -> None: self = intrinsic("init.int4", int4, x, y, z, w) - def __add__(self, _other: tp.Union['int4', i32, int]) -> 'int4': return intrinsic("binop.__add__.int4", int4, _other) - def __radd__(self, _other: tp.Union['int4', i32, int]) -> 'int4': return intrinsic("binop.__radd__.int4", int4, _other) - def __iadd__(self, _other: tp.Union['int4', i32, int]) -> 'int4': return intrinsic("binop.__iadd__.int4", int4, _other) - def __sub__(self, _other: tp.Union['int4', i32, int]) -> 'int4': return intrinsic("binop.__sub__.int4", int4, _other) - def __rsub__(self, _other: tp.Union['int4', i32, int]) -> 'int4': return intrinsic("binop.__rsub__.int4", int4, _other) - def __isub__(self, _other: tp.Union['int4', i32, int]) -> 'int4': return intrinsic("binop.__isub__.int4", int4, _other) - def __mul__(self, _other: tp.Union['int4', i32, int]) -> 'int4': return intrinsic("binop.__mul__.int4", int4, _other) - def __rmul__(self, _other: tp.Union['int4', i32, int]) -> 'int4': return intrinsic("binop.__rmul__.int4", int4, _other) - def __imul__(self, _other: tp.Union['int4', i32, int]) -> 'int4': return intrinsic("binop.__imul__.int4", int4, _other) - def __mod__(self, _other: tp.Union['int4', i32, int]) -> 'int4': return intrinsic("binop.__mod__.int4", int4, _other) - def __rmod__(self, _other: tp.Union['int4', i32, int]) -> 'int4': return intrinsic("binop.__rmod__.int4", int4, _other) - def __imod__(self, _other: tp.Union['int4', i32, int]) -> 'int4': return intrinsic("binop.__imod__.int4", int4, _other) - def __lt__(self, _other: tp.Union['int4', i32, int]) -> 'bool4': return intrinsic("cmp.__lt__.int4", bool4, _other) # type: ignore[override] - def __le__(self, _other: tp.Union['int4', i32, int]) -> 'bool4': return intrinsic("cmp.__le__.int4", bool4, _other) # type: ignore[override] - def __gt__(self, _other: tp.Union['int4', i32, int]) -> 'bool4': return intrinsic("cmp.__gt__.int4", bool4, _other) # type: ignore[override] - def __ge__(self, _other: tp.Union['int4', i32, int]) -> 'bool4': return intrinsic("cmp.__ge__.int4", bool4, _other) # type: ignore[override] - def __eq__(self, _other: tp.Union['int4', i32, int]) -> 'bool4': return intrinsic("cmp.__eq__.int4", bool4, _other) # type: ignore[override] - def __ne__(self, _other: tp.Union['int4', i32, int]) -> 'bool4': return intrinsic("cmp.__ne__.int4", bool4, _other) # type: ignore[override] - def __floordiv__(self, _other: tp.Union['int4', i32, int]) -> 'int4': return intrinsic("binop.__floordiv__.int4", int4, _other) - def __rfloordiv__(self, _other: tp.Union['int4', i32, int]) -> 'int4': return intrinsic("binop.__rfloordiv__.int4", int4, _other) - def __ifloordiv__(self, _other: tp.Union['int4', i32, int]) -> 'int4': return intrinsic("binop.__ifloordiv__.int4", int4, _other) - def __lshift__(self, _other: tp.Union['int4', i32, int]) -> 'int4': return intrinsic("binop.__lshift__.int4", int4, _other) - def __rlshift__(self, _other: tp.Union['int4', i32, int]) -> 'int4': return intrinsic("binop.__rlshift__.int4", int4, _other) - def __ilshift__(self, _other: tp.Union['int4', i32, int]) -> 'int4': return intrinsic("binop.__ilshift__.int4", int4, _other) - def __rshift__(self, _other: tp.Union['int4', i32, int]) -> 'int4': return intrinsic("binop.__rshift__.int4", int4, _other) - def __rrshift__(self, _other: tp.Union['int4', i32, int]) -> 'int4': return intrinsic("binop.__rrshift__.int4", int4, _other) - def __irshift__(self, _other: tp.Union['int4', i32, int]) -> 'int4': return intrinsic("binop.__irshift__.int4", int4, _other) - def __and__(self, _other: tp.Union['int4', i32, int]) -> 'int4': return intrinsic("binop.__and__.int4", int4, _other) - def __rand__(self, _other: tp.Union['int4', i32, int]) -> 'int4': return intrinsic("binop.__rand__.int4", int4, _other) - def __iand__(self, _other: tp.Union['int4', i32, int]) -> 'int4': return intrinsic("binop.__iand__.int4", int4, _other) - def __or__(self, _other: tp.Union['int4', i32, int]) -> 'int4': return intrinsic("binop.__or__.int4", int4, _other) - def __ror__(self, _other: tp.Union['int4', i32, int]) -> 'int4': return intrinsic("binop.__ror__.int4", int4, _other) - def __ior__(self, _other: tp.Union['int4', i32, int]) -> 'int4': return intrinsic("binop.__ior__.int4", int4, _other) - def __xor__(self, _other: tp.Union['int4', i32, int]) -> 'int4': return intrinsic("binop.__xor__.int4", int4, _other) - def __rxor__(self, _other: tp.Union['int4', i32, int]) -> 'int4': return intrinsic("binop.__rxor__.int4", int4, _other) - def __ixor__(self, _other: tp.Union['int4', i32, int]) -> 'int4': return intrinsic("binop.__ixor__.int4", int4, _other) + @func(inline='always') + def __add__(self, _other: tp.Union['int4', i32, int]) -> 'int4': return intrinsic("binop.__add__.int4", int4, self, _other) + @func(inline='always') + def __radd__(self, _other: tp.Union['int4', i32, int]) -> 'int4': return intrinsic("binop.__radd__.int4", int4, self, _other) + @func(inline='always') + def __iadd__(self, _other: tp.Union['int4', i32, int]) -> 'int4': return intrinsic("binop.__iadd__.int4", int4, byref(self), _other) + @func(inline='always') + def __sub__(self, _other: tp.Union['int4', i32, int]) -> 'int4': return intrinsic("binop.__sub__.int4", int4, self, _other) + @func(inline='always') + def __rsub__(self, _other: tp.Union['int4', i32, int]) -> 'int4': return intrinsic("binop.__rsub__.int4", int4, self, _other) + @func(inline='always') + def __isub__(self, _other: tp.Union['int4', i32, int]) -> 'int4': return intrinsic("binop.__isub__.int4", int4, byref(self), _other) + @func(inline='always') + def __mul__(self, _other: tp.Union['int4', i32, int]) -> 'int4': return intrinsic("binop.__mul__.int4", int4, self, _other) + @func(inline='always') + def __rmul__(self, _other: tp.Union['int4', i32, int]) -> 'int4': return intrinsic("binop.__rmul__.int4", int4, self, _other) + @func(inline='always') + def __imul__(self, _other: tp.Union['int4', i32, int]) -> 'int4': return intrinsic("binop.__imul__.int4", int4, byref(self), _other) + @func(inline='always') + def __mod__(self, _other: tp.Union['int4', i32, int]) -> 'int4': return intrinsic("binop.__mod__.int4", int4, self, _other) + @func(inline='always') + def __rmod__(self, _other: tp.Union['int4', i32, int]) -> 'int4': return intrinsic("binop.__rmod__.int4", int4, self, _other) + @func(inline='always') + def __imod__(self, _other: tp.Union['int4', i32, int]) -> 'int4': return intrinsic("binop.__imod__.int4", int4, byref(self), _other) + @func(inline='always') + def __lt__(self, _other: tp.Union['int4', i32, int]) -> 'bool4': return intrinsic("cmp.__lt__.int4", bool4, self, _other) # type: ignore[override] + @func(inline='always') + def __le__(self, _other: tp.Union['int4', i32, int]) -> 'bool4': return intrinsic("cmp.__le__.int4", bool4, self, _other) # type: ignore[override] + @func(inline='always') + def __gt__(self, _other: tp.Union['int4', i32, int]) -> 'bool4': return intrinsic("cmp.__gt__.int4", bool4, self, _other) # type: ignore[override] + @func(inline='always') + def __ge__(self, _other: tp.Union['int4', i32, int]) -> 'bool4': return intrinsic("cmp.__ge__.int4", bool4, self, _other) # type: ignore[override] + @func(inline='always') + def __eq__(self, _other: tp.Union['int4', i32, int]) -> 'bool4': return intrinsic("cmp.__eq__.int4", bool4, self, _other) # type: ignore[override] + @func(inline='always') + def __ne__(self, _other: tp.Union['int4', i32, int]) -> 'bool4': return intrinsic("cmp.__ne__.int4", bool4, self, _other) # type: ignore[override] + @func(inline='always') + def __floordiv__(self, _other: tp.Union['int4', i32, int]) -> 'int4': return intrinsic("binop.__floordiv__.int4", int4, self, _other) + @func(inline='always') + def __rfloordiv__(self, _other: tp.Union['int4', i32, int]) -> 'int4': return intrinsic("binop.__rfloordiv__.int4", int4, self, _other) + @func(inline='always') + def __ifloordiv__(self, _other: tp.Union['int4', i32, int]) -> 'int4': return intrinsic("binop.__ifloordiv__.int4", int4, byref(self), _other) + @func(inline='always') + def __lshift__(self, _other: tp.Union['int4', i32, int]) -> 'int4': return intrinsic("binop.__lshift__.int4", int4, self, _other) + @func(inline='always') + def __rlshift__(self, _other: tp.Union['int4', i32, int]) -> 'int4': return intrinsic("binop.__rlshift__.int4", int4, self, _other) + @func(inline='always') + def __ilshift__(self, _other: tp.Union['int4', i32, int]) -> 'int4': return intrinsic("binop.__ilshift__.int4", int4, byref(self), _other) + @func(inline='always') + def __rshift__(self, _other: tp.Union['int4', i32, int]) -> 'int4': return intrinsic("binop.__rshift__.int4", int4, self, _other) + @func(inline='always') + def __rrshift__(self, _other: tp.Union['int4', i32, int]) -> 'int4': return intrinsic("binop.__rrshift__.int4", int4, self, _other) + @func(inline='always') + def __irshift__(self, _other: tp.Union['int4', i32, int]) -> 'int4': return intrinsic("binop.__irshift__.int4", int4, byref(self), _other) + @func(inline='always') + def __and__(self, _other: tp.Union['int4', i32, int]) -> 'int4': return intrinsic("binop.__and__.int4", int4, self, _other) + @func(inline='always') + def __rand__(self, _other: tp.Union['int4', i32, int]) -> 'int4': return intrinsic("binop.__rand__.int4", int4, self, _other) + @func(inline='always') + def __iand__(self, _other: tp.Union['int4', i32, int]) -> 'int4': return intrinsic("binop.__iand__.int4", int4, byref(self), _other) + @func(inline='always') + def __or__(self, _other: tp.Union['int4', i32, int]) -> 'int4': return intrinsic("binop.__or__.int4", int4, self, _other) + @func(inline='always') + def __ror__(self, _other: tp.Union['int4', i32, int]) -> 'int4': return intrinsic("binop.__ror__.int4", int4, self, _other) + @func(inline='always') + def __ior__(self, _other: tp.Union['int4', i32, int]) -> 'int4': return intrinsic("binop.__ior__.int4", int4, byref(self), _other) + @func(inline='always') + def __xor__(self, _other: tp.Union['int4', i32, int]) -> 'int4': return intrinsic("binop.__xor__.int4", int4, self, _other) + @func(inline='always') + def __rxor__(self, _other: tp.Union['int4', i32, int]) -> 'int4': return intrinsic("binop.__rxor__.int4", int4, self, _other) + @func(inline='always') + def __ixor__(self, _other: tp.Union['int4', i32, int]) -> 'int4': return intrinsic("binop.__ixor__.int4", int4, byref(self), _other) @builtin_type(_hir.VectorType(tp.cast(_hir.ScalarType, _ctx.types[u32]), 4)) class uint4: @@ -1657,42 +3003,78 @@ class uint4: z: u32 w: u32 def __init__(self, x: tp.Union['u32', int] = 0, y: tp.Union['u32', int] = 0, z: tp.Union['u32', int] = 0, w: tp.Union['u32', int] = 0) -> None: self = intrinsic("init.uint4", uint4, x, y, z, w) - def __add__(self, _other: tp.Union['uint4', u32, int]) -> 'uint4': return intrinsic("binop.__add__.uint4", uint4, _other) - def __radd__(self, _other: tp.Union['uint4', u32, int]) -> 'uint4': return intrinsic("binop.__radd__.uint4", uint4, _other) - def __iadd__(self, _other: tp.Union['uint4', u32, int]) -> 'uint4': return intrinsic("binop.__iadd__.uint4", uint4, _other) - def __sub__(self, _other: tp.Union['uint4', u32, int]) -> 'uint4': return intrinsic("binop.__sub__.uint4", uint4, _other) - def __rsub__(self, _other: tp.Union['uint4', u32, int]) -> 'uint4': return intrinsic("binop.__rsub__.uint4", uint4, _other) - def __isub__(self, _other: tp.Union['uint4', u32, int]) -> 'uint4': return intrinsic("binop.__isub__.uint4", uint4, _other) - def __mul__(self, _other: tp.Union['uint4', u32, int]) -> 'uint4': return intrinsic("binop.__mul__.uint4", uint4, _other) - def __rmul__(self, _other: tp.Union['uint4', u32, int]) -> 'uint4': return intrinsic("binop.__rmul__.uint4", uint4, _other) - def __imul__(self, _other: tp.Union['uint4', u32, int]) -> 'uint4': return intrinsic("binop.__imul__.uint4", uint4, _other) - def __mod__(self, _other: tp.Union['uint4', u32, int]) -> 'uint4': return intrinsic("binop.__mod__.uint4", uint4, _other) - def __rmod__(self, _other: tp.Union['uint4', u32, int]) -> 'uint4': return intrinsic("binop.__rmod__.uint4", uint4, _other) - def __imod__(self, _other: tp.Union['uint4', u32, int]) -> 'uint4': return intrinsic("binop.__imod__.uint4", uint4, _other) - def __lt__(self, _other: tp.Union['uint4', u32, int]) -> 'bool4': return intrinsic("cmp.__lt__.uint4", bool4, _other) # type: ignore[override] - def __le__(self, _other: tp.Union['uint4', u32, int]) -> 'bool4': return intrinsic("cmp.__le__.uint4", bool4, _other) # type: ignore[override] - def __gt__(self, _other: tp.Union['uint4', u32, int]) -> 'bool4': return intrinsic("cmp.__gt__.uint4", bool4, _other) # type: ignore[override] - def __ge__(self, _other: tp.Union['uint4', u32, int]) -> 'bool4': return intrinsic("cmp.__ge__.uint4", bool4, _other) # type: ignore[override] - def __eq__(self, _other: tp.Union['uint4', u32, int]) -> 'bool4': return intrinsic("cmp.__eq__.uint4", bool4, _other) # type: ignore[override] - def __ne__(self, _other: tp.Union['uint4', u32, int]) -> 'bool4': return intrinsic("cmp.__ne__.uint4", bool4, _other) # type: ignore[override] - def __floordiv__(self, _other: tp.Union['uint4', u32, int]) -> 'uint4': return intrinsic("binop.__floordiv__.uint4", uint4, _other) - def __rfloordiv__(self, _other: tp.Union['uint4', u32, int]) -> 'uint4': return intrinsic("binop.__rfloordiv__.uint4", uint4, _other) - def __ifloordiv__(self, _other: tp.Union['uint4', u32, int]) -> 'uint4': return intrinsic("binop.__ifloordiv__.uint4", uint4, _other) - def __lshift__(self, _other: tp.Union['uint4', u32, int]) -> 'uint4': return intrinsic("binop.__lshift__.uint4", uint4, _other) - def __rlshift__(self, _other: tp.Union['uint4', u32, int]) -> 'uint4': return intrinsic("binop.__rlshift__.uint4", uint4, _other) - def __ilshift__(self, _other: tp.Union['uint4', u32, int]) -> 'uint4': return intrinsic("binop.__ilshift__.uint4", uint4, _other) - def __rshift__(self, _other: tp.Union['uint4', u32, int]) -> 'uint4': return intrinsic("binop.__rshift__.uint4", uint4, _other) - def __rrshift__(self, _other: tp.Union['uint4', u32, int]) -> 'uint4': return intrinsic("binop.__rrshift__.uint4", uint4, _other) - def __irshift__(self, _other: tp.Union['uint4', u32, int]) -> 'uint4': return intrinsic("binop.__irshift__.uint4", uint4, _other) - def __and__(self, _other: tp.Union['uint4', u32, int]) -> 'uint4': return intrinsic("binop.__and__.uint4", uint4, _other) - def __rand__(self, _other: tp.Union['uint4', u32, int]) -> 'uint4': return intrinsic("binop.__rand__.uint4", uint4, _other) - def __iand__(self, _other: tp.Union['uint4', u32, int]) -> 'uint4': return intrinsic("binop.__iand__.uint4", uint4, _other) - def __or__(self, _other: tp.Union['uint4', u32, int]) -> 'uint4': return intrinsic("binop.__or__.uint4", uint4, _other) - def __ror__(self, _other: tp.Union['uint4', u32, int]) -> 'uint4': return intrinsic("binop.__ror__.uint4", uint4, _other) - def __ior__(self, _other: tp.Union['uint4', u32, int]) -> 'uint4': return intrinsic("binop.__ior__.uint4", uint4, _other) - def __xor__(self, _other: tp.Union['uint4', u32, int]) -> 'uint4': return intrinsic("binop.__xor__.uint4", uint4, _other) - def __rxor__(self, _other: tp.Union['uint4', u32, int]) -> 'uint4': return intrinsic("binop.__rxor__.uint4", uint4, _other) - def __ixor__(self, _other: tp.Union['uint4', u32, int]) -> 'uint4': return intrinsic("binop.__ixor__.uint4", uint4, _other) + @func(inline='always') + def __add__(self, _other: tp.Union['uint4', u32, int]) -> 'uint4': return intrinsic("binop.__add__.uint4", uint4, self, _other) + @func(inline='always') + def __radd__(self, _other: tp.Union['uint4', u32, int]) -> 'uint4': return intrinsic("binop.__radd__.uint4", uint4, self, _other) + @func(inline='always') + def __iadd__(self, _other: tp.Union['uint4', u32, int]) -> 'uint4': return intrinsic("binop.__iadd__.uint4", uint4, byref(self), _other) + @func(inline='always') + def __sub__(self, _other: tp.Union['uint4', u32, int]) -> 'uint4': return intrinsic("binop.__sub__.uint4", uint4, self, _other) + @func(inline='always') + def __rsub__(self, _other: tp.Union['uint4', u32, int]) -> 'uint4': return intrinsic("binop.__rsub__.uint4", uint4, self, _other) + @func(inline='always') + def __isub__(self, _other: tp.Union['uint4', u32, int]) -> 'uint4': return intrinsic("binop.__isub__.uint4", uint4, byref(self), _other) + @func(inline='always') + def __mul__(self, _other: tp.Union['uint4', u32, int]) -> 'uint4': return intrinsic("binop.__mul__.uint4", uint4, self, _other) + @func(inline='always') + def __rmul__(self, _other: tp.Union['uint4', u32, int]) -> 'uint4': return intrinsic("binop.__rmul__.uint4", uint4, self, _other) + @func(inline='always') + def __imul__(self, _other: tp.Union['uint4', u32, int]) -> 'uint4': return intrinsic("binop.__imul__.uint4", uint4, byref(self), _other) + @func(inline='always') + def __mod__(self, _other: tp.Union['uint4', u32, int]) -> 'uint4': return intrinsic("binop.__mod__.uint4", uint4, self, _other) + @func(inline='always') + def __rmod__(self, _other: tp.Union['uint4', u32, int]) -> 'uint4': return intrinsic("binop.__rmod__.uint4", uint4, self, _other) + @func(inline='always') + def __imod__(self, _other: tp.Union['uint4', u32, int]) -> 'uint4': return intrinsic("binop.__imod__.uint4", uint4, byref(self), _other) + @func(inline='always') + def __lt__(self, _other: tp.Union['uint4', u32, int]) -> 'bool4': return intrinsic("cmp.__lt__.uint4", bool4, self, _other) # type: ignore[override] + @func(inline='always') + def __le__(self, _other: tp.Union['uint4', u32, int]) -> 'bool4': return intrinsic("cmp.__le__.uint4", bool4, self, _other) # type: ignore[override] + @func(inline='always') + def __gt__(self, _other: tp.Union['uint4', u32, int]) -> 'bool4': return intrinsic("cmp.__gt__.uint4", bool4, self, _other) # type: ignore[override] + @func(inline='always') + def __ge__(self, _other: tp.Union['uint4', u32, int]) -> 'bool4': return intrinsic("cmp.__ge__.uint4", bool4, self, _other) # type: ignore[override] + @func(inline='always') + def __eq__(self, _other: tp.Union['uint4', u32, int]) -> 'bool4': return intrinsic("cmp.__eq__.uint4", bool4, self, _other) # type: ignore[override] + @func(inline='always') + def __ne__(self, _other: tp.Union['uint4', u32, int]) -> 'bool4': return intrinsic("cmp.__ne__.uint4", bool4, self, _other) # type: ignore[override] + @func(inline='always') + def __floordiv__(self, _other: tp.Union['uint4', u32, int]) -> 'uint4': return intrinsic("binop.__floordiv__.uint4", uint4, self, _other) + @func(inline='always') + def __rfloordiv__(self, _other: tp.Union['uint4', u32, int]) -> 'uint4': return intrinsic("binop.__rfloordiv__.uint4", uint4, self, _other) + @func(inline='always') + def __ifloordiv__(self, _other: tp.Union['uint4', u32, int]) -> 'uint4': return intrinsic("binop.__ifloordiv__.uint4", uint4, byref(self), _other) + @func(inline='always') + def __lshift__(self, _other: tp.Union['uint4', u32, int]) -> 'uint4': return intrinsic("binop.__lshift__.uint4", uint4, self, _other) + @func(inline='always') + def __rlshift__(self, _other: tp.Union['uint4', u32, int]) -> 'uint4': return intrinsic("binop.__rlshift__.uint4", uint4, self, _other) + @func(inline='always') + def __ilshift__(self, _other: tp.Union['uint4', u32, int]) -> 'uint4': return intrinsic("binop.__ilshift__.uint4", uint4, byref(self), _other) + @func(inline='always') + def __rshift__(self, _other: tp.Union['uint4', u32, int]) -> 'uint4': return intrinsic("binop.__rshift__.uint4", uint4, self, _other) + @func(inline='always') + def __rrshift__(self, _other: tp.Union['uint4', u32, int]) -> 'uint4': return intrinsic("binop.__rrshift__.uint4", uint4, self, _other) + @func(inline='always') + def __irshift__(self, _other: tp.Union['uint4', u32, int]) -> 'uint4': return intrinsic("binop.__irshift__.uint4", uint4, byref(self), _other) + @func(inline='always') + def __and__(self, _other: tp.Union['uint4', u32, int]) -> 'uint4': return intrinsic("binop.__and__.uint4", uint4, self, _other) + @func(inline='always') + def __rand__(self, _other: tp.Union['uint4', u32, int]) -> 'uint4': return intrinsic("binop.__rand__.uint4", uint4, self, _other) + @func(inline='always') + def __iand__(self, _other: tp.Union['uint4', u32, int]) -> 'uint4': return intrinsic("binop.__iand__.uint4", uint4, byref(self), _other) + @func(inline='always') + def __or__(self, _other: tp.Union['uint4', u32, int]) -> 'uint4': return intrinsic("binop.__or__.uint4", uint4, self, _other) + @func(inline='always') + def __ror__(self, _other: tp.Union['uint4', u32, int]) -> 'uint4': return intrinsic("binop.__ror__.uint4", uint4, self, _other) + @func(inline='always') + def __ior__(self, _other: tp.Union['uint4', u32, int]) -> 'uint4': return intrinsic("binop.__ior__.uint4", uint4, byref(self), _other) + @func(inline='always') + def __xor__(self, _other: tp.Union['uint4', u32, int]) -> 'uint4': return intrinsic("binop.__xor__.uint4", uint4, self, _other) + @func(inline='always') + def __rxor__(self, _other: tp.Union['uint4', u32, int]) -> 'uint4': return intrinsic("binop.__rxor__.uint4", uint4, self, _other) + @func(inline='always') + def __ixor__(self, _other: tp.Union['uint4', u32, int]) -> 'uint4': return intrinsic("binop.__ixor__.uint4", uint4, byref(self), _other) @builtin_type(_hir.VectorType(tp.cast(_hir.ScalarType, _ctx.types[i64]), 4)) class long4: @@ -1701,42 +3083,78 @@ class long4: z: i64 w: i64 def __init__(self, x: tp.Union['i64', int] = 0, y: tp.Union['i64', int] = 0, z: tp.Union['i64', int] = 0, w: tp.Union['i64', int] = 0) -> None: self = intrinsic("init.long4", long4, x, y, z, w) - def __add__(self, _other: tp.Union['long4', i64, int]) -> 'long4': return intrinsic("binop.__add__.long4", long4, _other) - def __radd__(self, _other: tp.Union['long4', i64, int]) -> 'long4': return intrinsic("binop.__radd__.long4", long4, _other) - def __iadd__(self, _other: tp.Union['long4', i64, int]) -> 'long4': return intrinsic("binop.__iadd__.long4", long4, _other) - def __sub__(self, _other: tp.Union['long4', i64, int]) -> 'long4': return intrinsic("binop.__sub__.long4", long4, _other) - def __rsub__(self, _other: tp.Union['long4', i64, int]) -> 'long4': return intrinsic("binop.__rsub__.long4", long4, _other) - def __isub__(self, _other: tp.Union['long4', i64, int]) -> 'long4': return intrinsic("binop.__isub__.long4", long4, _other) - def __mul__(self, _other: tp.Union['long4', i64, int]) -> 'long4': return intrinsic("binop.__mul__.long4", long4, _other) - def __rmul__(self, _other: tp.Union['long4', i64, int]) -> 'long4': return intrinsic("binop.__rmul__.long4", long4, _other) - def __imul__(self, _other: tp.Union['long4', i64, int]) -> 'long4': return intrinsic("binop.__imul__.long4", long4, _other) - def __mod__(self, _other: tp.Union['long4', i64, int]) -> 'long4': return intrinsic("binop.__mod__.long4", long4, _other) - def __rmod__(self, _other: tp.Union['long4', i64, int]) -> 'long4': return intrinsic("binop.__rmod__.long4", long4, _other) - def __imod__(self, _other: tp.Union['long4', i64, int]) -> 'long4': return intrinsic("binop.__imod__.long4", long4, _other) - def __lt__(self, _other: tp.Union['long4', i64, int]) -> 'bool4': return intrinsic("cmp.__lt__.long4", bool4, _other) # type: ignore[override] - def __le__(self, _other: tp.Union['long4', i64, int]) -> 'bool4': return intrinsic("cmp.__le__.long4", bool4, _other) # type: ignore[override] - def __gt__(self, _other: tp.Union['long4', i64, int]) -> 'bool4': return intrinsic("cmp.__gt__.long4", bool4, _other) # type: ignore[override] - def __ge__(self, _other: tp.Union['long4', i64, int]) -> 'bool4': return intrinsic("cmp.__ge__.long4", bool4, _other) # type: ignore[override] - def __eq__(self, _other: tp.Union['long4', i64, int]) -> 'bool4': return intrinsic("cmp.__eq__.long4", bool4, _other) # type: ignore[override] - def __ne__(self, _other: tp.Union['long4', i64, int]) -> 'bool4': return intrinsic("cmp.__ne__.long4", bool4, _other) # type: ignore[override] - def __floordiv__(self, _other: tp.Union['long4', i64, int]) -> 'long4': return intrinsic("binop.__floordiv__.long4", long4, _other) - def __rfloordiv__(self, _other: tp.Union['long4', i64, int]) -> 'long4': return intrinsic("binop.__rfloordiv__.long4", long4, _other) - def __ifloordiv__(self, _other: tp.Union['long4', i64, int]) -> 'long4': return intrinsic("binop.__ifloordiv__.long4", long4, _other) - def __lshift__(self, _other: tp.Union['long4', i64, int]) -> 'long4': return intrinsic("binop.__lshift__.long4", long4, _other) - def __rlshift__(self, _other: tp.Union['long4', i64, int]) -> 'long4': return intrinsic("binop.__rlshift__.long4", long4, _other) - def __ilshift__(self, _other: tp.Union['long4', i64, int]) -> 'long4': return intrinsic("binop.__ilshift__.long4", long4, _other) - def __rshift__(self, _other: tp.Union['long4', i64, int]) -> 'long4': return intrinsic("binop.__rshift__.long4", long4, _other) - def __rrshift__(self, _other: tp.Union['long4', i64, int]) -> 'long4': return intrinsic("binop.__rrshift__.long4", long4, _other) - def __irshift__(self, _other: tp.Union['long4', i64, int]) -> 'long4': return intrinsic("binop.__irshift__.long4", long4, _other) - def __and__(self, _other: tp.Union['long4', i64, int]) -> 'long4': return intrinsic("binop.__and__.long4", long4, _other) - def __rand__(self, _other: tp.Union['long4', i64, int]) -> 'long4': return intrinsic("binop.__rand__.long4", long4, _other) - def __iand__(self, _other: tp.Union['long4', i64, int]) -> 'long4': return intrinsic("binop.__iand__.long4", long4, _other) - def __or__(self, _other: tp.Union['long4', i64, int]) -> 'long4': return intrinsic("binop.__or__.long4", long4, _other) - def __ror__(self, _other: tp.Union['long4', i64, int]) -> 'long4': return intrinsic("binop.__ror__.long4", long4, _other) - def __ior__(self, _other: tp.Union['long4', i64, int]) -> 'long4': return intrinsic("binop.__ior__.long4", long4, _other) - def __xor__(self, _other: tp.Union['long4', i64, int]) -> 'long4': return intrinsic("binop.__xor__.long4", long4, _other) - def __rxor__(self, _other: tp.Union['long4', i64, int]) -> 'long4': return intrinsic("binop.__rxor__.long4", long4, _other) - def __ixor__(self, _other: tp.Union['long4', i64, int]) -> 'long4': return intrinsic("binop.__ixor__.long4", long4, _other) + @func(inline='always') + def __add__(self, _other: tp.Union['long4', i64, int]) -> 'long4': return intrinsic("binop.__add__.long4", long4, self, _other) + @func(inline='always') + def __radd__(self, _other: tp.Union['long4', i64, int]) -> 'long4': return intrinsic("binop.__radd__.long4", long4, self, _other) + @func(inline='always') + def __iadd__(self, _other: tp.Union['long4', i64, int]) -> 'long4': return intrinsic("binop.__iadd__.long4", long4, byref(self), _other) + @func(inline='always') + def __sub__(self, _other: tp.Union['long4', i64, int]) -> 'long4': return intrinsic("binop.__sub__.long4", long4, self, _other) + @func(inline='always') + def __rsub__(self, _other: tp.Union['long4', i64, int]) -> 'long4': return intrinsic("binop.__rsub__.long4", long4, self, _other) + @func(inline='always') + def __isub__(self, _other: tp.Union['long4', i64, int]) -> 'long4': return intrinsic("binop.__isub__.long4", long4, byref(self), _other) + @func(inline='always') + def __mul__(self, _other: tp.Union['long4', i64, int]) -> 'long4': return intrinsic("binop.__mul__.long4", long4, self, _other) + @func(inline='always') + def __rmul__(self, _other: tp.Union['long4', i64, int]) -> 'long4': return intrinsic("binop.__rmul__.long4", long4, self, _other) + @func(inline='always') + def __imul__(self, _other: tp.Union['long4', i64, int]) -> 'long4': return intrinsic("binop.__imul__.long4", long4, byref(self), _other) + @func(inline='always') + def __mod__(self, _other: tp.Union['long4', i64, int]) -> 'long4': return intrinsic("binop.__mod__.long4", long4, self, _other) + @func(inline='always') + def __rmod__(self, _other: tp.Union['long4', i64, int]) -> 'long4': return intrinsic("binop.__rmod__.long4", long4, self, _other) + @func(inline='always') + def __imod__(self, _other: tp.Union['long4', i64, int]) -> 'long4': return intrinsic("binop.__imod__.long4", long4, byref(self), _other) + @func(inline='always') + def __lt__(self, _other: tp.Union['long4', i64, int]) -> 'bool4': return intrinsic("cmp.__lt__.long4", bool4, self, _other) # type: ignore[override] + @func(inline='always') + def __le__(self, _other: tp.Union['long4', i64, int]) -> 'bool4': return intrinsic("cmp.__le__.long4", bool4, self, _other) # type: ignore[override] + @func(inline='always') + def __gt__(self, _other: tp.Union['long4', i64, int]) -> 'bool4': return intrinsic("cmp.__gt__.long4", bool4, self, _other) # type: ignore[override] + @func(inline='always') + def __ge__(self, _other: tp.Union['long4', i64, int]) -> 'bool4': return intrinsic("cmp.__ge__.long4", bool4, self, _other) # type: ignore[override] + @func(inline='always') + def __eq__(self, _other: tp.Union['long4', i64, int]) -> 'bool4': return intrinsic("cmp.__eq__.long4", bool4, self, _other) # type: ignore[override] + @func(inline='always') + def __ne__(self, _other: tp.Union['long4', i64, int]) -> 'bool4': return intrinsic("cmp.__ne__.long4", bool4, self, _other) # type: ignore[override] + @func(inline='always') + def __floordiv__(self, _other: tp.Union['long4', i64, int]) -> 'long4': return intrinsic("binop.__floordiv__.long4", long4, self, _other) + @func(inline='always') + def __rfloordiv__(self, _other: tp.Union['long4', i64, int]) -> 'long4': return intrinsic("binop.__rfloordiv__.long4", long4, self, _other) + @func(inline='always') + def __ifloordiv__(self, _other: tp.Union['long4', i64, int]) -> 'long4': return intrinsic("binop.__ifloordiv__.long4", long4, byref(self), _other) + @func(inline='always') + def __lshift__(self, _other: tp.Union['long4', i64, int]) -> 'long4': return intrinsic("binop.__lshift__.long4", long4, self, _other) + @func(inline='always') + def __rlshift__(self, _other: tp.Union['long4', i64, int]) -> 'long4': return intrinsic("binop.__rlshift__.long4", long4, self, _other) + @func(inline='always') + def __ilshift__(self, _other: tp.Union['long4', i64, int]) -> 'long4': return intrinsic("binop.__ilshift__.long4", long4, byref(self), _other) + @func(inline='always') + def __rshift__(self, _other: tp.Union['long4', i64, int]) -> 'long4': return intrinsic("binop.__rshift__.long4", long4, self, _other) + @func(inline='always') + def __rrshift__(self, _other: tp.Union['long4', i64, int]) -> 'long4': return intrinsic("binop.__rrshift__.long4", long4, self, _other) + @func(inline='always') + def __irshift__(self, _other: tp.Union['long4', i64, int]) -> 'long4': return intrinsic("binop.__irshift__.long4", long4, byref(self), _other) + @func(inline='always') + def __and__(self, _other: tp.Union['long4', i64, int]) -> 'long4': return intrinsic("binop.__and__.long4", long4, self, _other) + @func(inline='always') + def __rand__(self, _other: tp.Union['long4', i64, int]) -> 'long4': return intrinsic("binop.__rand__.long4", long4, self, _other) + @func(inline='always') + def __iand__(self, _other: tp.Union['long4', i64, int]) -> 'long4': return intrinsic("binop.__iand__.long4", long4, byref(self), _other) + @func(inline='always') + def __or__(self, _other: tp.Union['long4', i64, int]) -> 'long4': return intrinsic("binop.__or__.long4", long4, self, _other) + @func(inline='always') + def __ror__(self, _other: tp.Union['long4', i64, int]) -> 'long4': return intrinsic("binop.__ror__.long4", long4, self, _other) + @func(inline='always') + def __ior__(self, _other: tp.Union['long4', i64, int]) -> 'long4': return intrinsic("binop.__ior__.long4", long4, byref(self), _other) + @func(inline='always') + def __xor__(self, _other: tp.Union['long4', i64, int]) -> 'long4': return intrinsic("binop.__xor__.long4", long4, self, _other) + @func(inline='always') + def __rxor__(self, _other: tp.Union['long4', i64, int]) -> 'long4': return intrinsic("binop.__rxor__.long4", long4, self, _other) + @func(inline='always') + def __ixor__(self, _other: tp.Union['long4', i64, int]) -> 'long4': return intrinsic("binop.__ixor__.long4", long4, byref(self), _other) @builtin_type(_hir.VectorType(tp.cast(_hir.ScalarType, _ctx.types[u64]), 4)) class ulong4: @@ -1745,41 +3163,77 @@ class ulong4: z: u64 w: u64 def __init__(self, x: tp.Union['u64', int] = 0, y: tp.Union['u64', int] = 0, z: tp.Union['u64', int] = 0, w: tp.Union['u64', int] = 0) -> None: self = intrinsic("init.ulong4", ulong4, x, y, z, w) - def __add__(self, _other: tp.Union['ulong4', u64, int]) -> 'ulong4': return intrinsic("binop.__add__.ulong4", ulong4, _other) - def __radd__(self, _other: tp.Union['ulong4', u64, int]) -> 'ulong4': return intrinsic("binop.__radd__.ulong4", ulong4, _other) - def __iadd__(self, _other: tp.Union['ulong4', u64, int]) -> 'ulong4': return intrinsic("binop.__iadd__.ulong4", ulong4, _other) - def __sub__(self, _other: tp.Union['ulong4', u64, int]) -> 'ulong4': return intrinsic("binop.__sub__.ulong4", ulong4, _other) - def __rsub__(self, _other: tp.Union['ulong4', u64, int]) -> 'ulong4': return intrinsic("binop.__rsub__.ulong4", ulong4, _other) - def __isub__(self, _other: tp.Union['ulong4', u64, int]) -> 'ulong4': return intrinsic("binop.__isub__.ulong4", ulong4, _other) - def __mul__(self, _other: tp.Union['ulong4', u64, int]) -> 'ulong4': return intrinsic("binop.__mul__.ulong4", ulong4, _other) - def __rmul__(self, _other: tp.Union['ulong4', u64, int]) -> 'ulong4': return intrinsic("binop.__rmul__.ulong4", ulong4, _other) - def __imul__(self, _other: tp.Union['ulong4', u64, int]) -> 'ulong4': return intrinsic("binop.__imul__.ulong4", ulong4, _other) - def __mod__(self, _other: tp.Union['ulong4', u64, int]) -> 'ulong4': return intrinsic("binop.__mod__.ulong4", ulong4, _other) - def __rmod__(self, _other: tp.Union['ulong4', u64, int]) -> 'ulong4': return intrinsic("binop.__rmod__.ulong4", ulong4, _other) - def __imod__(self, _other: tp.Union['ulong4', u64, int]) -> 'ulong4': return intrinsic("binop.__imod__.ulong4", ulong4, _other) - def __lt__(self, _other: tp.Union['ulong4', u64, int]) -> 'bool4': return intrinsic("cmp.__lt__.ulong4", bool4, _other) # type: ignore[override] - def __le__(self, _other: tp.Union['ulong4', u64, int]) -> 'bool4': return intrinsic("cmp.__le__.ulong4", bool4, _other) # type: ignore[override] - def __gt__(self, _other: tp.Union['ulong4', u64, int]) -> 'bool4': return intrinsic("cmp.__gt__.ulong4", bool4, _other) # type: ignore[override] - def __ge__(self, _other: tp.Union['ulong4', u64, int]) -> 'bool4': return intrinsic("cmp.__ge__.ulong4", bool4, _other) # type: ignore[override] - def __eq__(self, _other: tp.Union['ulong4', u64, int]) -> 'bool4': return intrinsic("cmp.__eq__.ulong4", bool4, _other) # type: ignore[override] - def __ne__(self, _other: tp.Union['ulong4', u64, int]) -> 'bool4': return intrinsic("cmp.__ne__.ulong4", bool4, _other) # type: ignore[override] - def __floordiv__(self, _other: tp.Union['ulong4', u64, int]) -> 'ulong4': return intrinsic("binop.__floordiv__.ulong4", ulong4, _other) - def __rfloordiv__(self, _other: tp.Union['ulong4', u64, int]) -> 'ulong4': return intrinsic("binop.__rfloordiv__.ulong4", ulong4, _other) - def __ifloordiv__(self, _other: tp.Union['ulong4', u64, int]) -> 'ulong4': return intrinsic("binop.__ifloordiv__.ulong4", ulong4, _other) - def __lshift__(self, _other: tp.Union['ulong4', u64, int]) -> 'ulong4': return intrinsic("binop.__lshift__.ulong4", ulong4, _other) - def __rlshift__(self, _other: tp.Union['ulong4', u64, int]) -> 'ulong4': return intrinsic("binop.__rlshift__.ulong4", ulong4, _other) - def __ilshift__(self, _other: tp.Union['ulong4', u64, int]) -> 'ulong4': return intrinsic("binop.__ilshift__.ulong4", ulong4, _other) - def __rshift__(self, _other: tp.Union['ulong4', u64, int]) -> 'ulong4': return intrinsic("binop.__rshift__.ulong4", ulong4, _other) - def __rrshift__(self, _other: tp.Union['ulong4', u64, int]) -> 'ulong4': return intrinsic("binop.__rrshift__.ulong4", ulong4, _other) - def __irshift__(self, _other: tp.Union['ulong4', u64, int]) -> 'ulong4': return intrinsic("binop.__irshift__.ulong4", ulong4, _other) - def __and__(self, _other: tp.Union['ulong4', u64, int]) -> 'ulong4': return intrinsic("binop.__and__.ulong4", ulong4, _other) - def __rand__(self, _other: tp.Union['ulong4', u64, int]) -> 'ulong4': return intrinsic("binop.__rand__.ulong4", ulong4, _other) - def __iand__(self, _other: tp.Union['ulong4', u64, int]) -> 'ulong4': return intrinsic("binop.__iand__.ulong4", ulong4, _other) - def __or__(self, _other: tp.Union['ulong4', u64, int]) -> 'ulong4': return intrinsic("binop.__or__.ulong4", ulong4, _other) - def __ror__(self, _other: tp.Union['ulong4', u64, int]) -> 'ulong4': return intrinsic("binop.__ror__.ulong4", ulong4, _other) - def __ior__(self, _other: tp.Union['ulong4', u64, int]) -> 'ulong4': return intrinsic("binop.__ior__.ulong4", ulong4, _other) - def __xor__(self, _other: tp.Union['ulong4', u64, int]) -> 'ulong4': return intrinsic("binop.__xor__.ulong4", ulong4, _other) - def __rxor__(self, _other: tp.Union['ulong4', u64, int]) -> 'ulong4': return intrinsic("binop.__rxor__.ulong4", ulong4, _other) - def __ixor__(self, _other: tp.Union['ulong4', u64, int]) -> 'ulong4': return intrinsic("binop.__ixor__.ulong4", ulong4, _other) + @func(inline='always') + def __add__(self, _other: tp.Union['ulong4', u64, int]) -> 'ulong4': return intrinsic("binop.__add__.ulong4", ulong4, self, _other) + @func(inline='always') + def __radd__(self, _other: tp.Union['ulong4', u64, int]) -> 'ulong4': return intrinsic("binop.__radd__.ulong4", ulong4, self, _other) + @func(inline='always') + def __iadd__(self, _other: tp.Union['ulong4', u64, int]) -> 'ulong4': return intrinsic("binop.__iadd__.ulong4", ulong4, byref(self), _other) + @func(inline='always') + def __sub__(self, _other: tp.Union['ulong4', u64, int]) -> 'ulong4': return intrinsic("binop.__sub__.ulong4", ulong4, self, _other) + @func(inline='always') + def __rsub__(self, _other: tp.Union['ulong4', u64, int]) -> 'ulong4': return intrinsic("binop.__rsub__.ulong4", ulong4, self, _other) + @func(inline='always') + def __isub__(self, _other: tp.Union['ulong4', u64, int]) -> 'ulong4': return intrinsic("binop.__isub__.ulong4", ulong4, byref(self), _other) + @func(inline='always') + def __mul__(self, _other: tp.Union['ulong4', u64, int]) -> 'ulong4': return intrinsic("binop.__mul__.ulong4", ulong4, self, _other) + @func(inline='always') + def __rmul__(self, _other: tp.Union['ulong4', u64, int]) -> 'ulong4': return intrinsic("binop.__rmul__.ulong4", ulong4, self, _other) + @func(inline='always') + def __imul__(self, _other: tp.Union['ulong4', u64, int]) -> 'ulong4': return intrinsic("binop.__imul__.ulong4", ulong4, byref(self), _other) + @func(inline='always') + def __mod__(self, _other: tp.Union['ulong4', u64, int]) -> 'ulong4': return intrinsic("binop.__mod__.ulong4", ulong4, self, _other) + @func(inline='always') + def __rmod__(self, _other: tp.Union['ulong4', u64, int]) -> 'ulong4': return intrinsic("binop.__rmod__.ulong4", ulong4, self, _other) + @func(inline='always') + def __imod__(self, _other: tp.Union['ulong4', u64, int]) -> 'ulong4': return intrinsic("binop.__imod__.ulong4", ulong4, byref(self), _other) + @func(inline='always') + def __lt__(self, _other: tp.Union['ulong4', u64, int]) -> 'bool4': return intrinsic("cmp.__lt__.ulong4", bool4, self, _other) # type: ignore[override] + @func(inline='always') + def __le__(self, _other: tp.Union['ulong4', u64, int]) -> 'bool4': return intrinsic("cmp.__le__.ulong4", bool4, self, _other) # type: ignore[override] + @func(inline='always') + def __gt__(self, _other: tp.Union['ulong4', u64, int]) -> 'bool4': return intrinsic("cmp.__gt__.ulong4", bool4, self, _other) # type: ignore[override] + @func(inline='always') + def __ge__(self, _other: tp.Union['ulong4', u64, int]) -> 'bool4': return intrinsic("cmp.__ge__.ulong4", bool4, self, _other) # type: ignore[override] + @func(inline='always') + def __eq__(self, _other: tp.Union['ulong4', u64, int]) -> 'bool4': return intrinsic("cmp.__eq__.ulong4", bool4, self, _other) # type: ignore[override] + @func(inline='always') + def __ne__(self, _other: tp.Union['ulong4', u64, int]) -> 'bool4': return intrinsic("cmp.__ne__.ulong4", bool4, self, _other) # type: ignore[override] + @func(inline='always') + def __floordiv__(self, _other: tp.Union['ulong4', u64, int]) -> 'ulong4': return intrinsic("binop.__floordiv__.ulong4", ulong4, self, _other) + @func(inline='always') + def __rfloordiv__(self, _other: tp.Union['ulong4', u64, int]) -> 'ulong4': return intrinsic("binop.__rfloordiv__.ulong4", ulong4, self, _other) + @func(inline='always') + def __ifloordiv__(self, _other: tp.Union['ulong4', u64, int]) -> 'ulong4': return intrinsic("binop.__ifloordiv__.ulong4", ulong4, byref(self), _other) + @func(inline='always') + def __lshift__(self, _other: tp.Union['ulong4', u64, int]) -> 'ulong4': return intrinsic("binop.__lshift__.ulong4", ulong4, self, _other) + @func(inline='always') + def __rlshift__(self, _other: tp.Union['ulong4', u64, int]) -> 'ulong4': return intrinsic("binop.__rlshift__.ulong4", ulong4, self, _other) + @func(inline='always') + def __ilshift__(self, _other: tp.Union['ulong4', u64, int]) -> 'ulong4': return intrinsic("binop.__ilshift__.ulong4", ulong4, byref(self), _other) + @func(inline='always') + def __rshift__(self, _other: tp.Union['ulong4', u64, int]) -> 'ulong4': return intrinsic("binop.__rshift__.ulong4", ulong4, self, _other) + @func(inline='always') + def __rrshift__(self, _other: tp.Union['ulong4', u64, int]) -> 'ulong4': return intrinsic("binop.__rrshift__.ulong4", ulong4, self, _other) + @func(inline='always') + def __irshift__(self, _other: tp.Union['ulong4', u64, int]) -> 'ulong4': return intrinsic("binop.__irshift__.ulong4", ulong4, byref(self), _other) + @func(inline='always') + def __and__(self, _other: tp.Union['ulong4', u64, int]) -> 'ulong4': return intrinsic("binop.__and__.ulong4", ulong4, self, _other) + @func(inline='always') + def __rand__(self, _other: tp.Union['ulong4', u64, int]) -> 'ulong4': return intrinsic("binop.__rand__.ulong4", ulong4, self, _other) + @func(inline='always') + def __iand__(self, _other: tp.Union['ulong4', u64, int]) -> 'ulong4': return intrinsic("binop.__iand__.ulong4", ulong4, byref(self), _other) + @func(inline='always') + def __or__(self, _other: tp.Union['ulong4', u64, int]) -> 'ulong4': return intrinsic("binop.__or__.ulong4", ulong4, self, _other) + @func(inline='always') + def __ror__(self, _other: tp.Union['ulong4', u64, int]) -> 'ulong4': return intrinsic("binop.__ror__.ulong4", ulong4, self, _other) + @func(inline='always') + def __ior__(self, _other: tp.Union['ulong4', u64, int]) -> 'ulong4': return intrinsic("binop.__ior__.ulong4", ulong4, byref(self), _other) + @func(inline='always') + def __xor__(self, _other: tp.Union['ulong4', u64, int]) -> 'ulong4': return intrinsic("binop.__xor__.ulong4", ulong4, self, _other) + @func(inline='always') + def __rxor__(self, _other: tp.Union['ulong4', u64, int]) -> 'ulong4': return intrinsic("binop.__rxor__.ulong4", ulong4, self, _other) + @func(inline='always') + def __ixor__(self, _other: tp.Union['ulong4', u64, int]) -> 'ulong4': return intrinsic("binop.__ixor__.ulong4", ulong4, byref(self), _other) __all__ = ['FLOAT_TYPES', 'FloatType', 'FloatBuiltin', 'abs', 'acos', 'acosh', 'asin', 'asinh', 'atan', 'atanh', 'ceil', 'cos', 'cosh', 'exp', 'floor', 'log', 'log10', 'log2', 'sin', 'sinh', 'sqrt', 'tan', 'tanh', 'trunc', 'atan2', 'copysign', 'f32', 'f64', 'i8', 'u8', 'i16', 'u16', 'i32', 'u32', 'i64', 'u64', 'bool2', 'float2', 'double2', 'byte2', 'ubyte2', 'short2', 'ushort2', 'int2', 'uint2', 'long2', 'ulong2', 'bool3', 'float3', 'double3', 'byte3', 'ubyte3', 'short3', 'ushort3', 'int3', 'uint3', 'long3', 'ulong3', 'bool4', 'float4', 'double4', 'byte4', 'ubyte4', 'short4', 'ushort4', 'int4', 'uint4', 'long4', 'ulong4'] diff --git a/luisa_lang/parse.py b/luisa_lang/parse.py index a86179d..40e043f 100644 --- a/luisa_lang/parse.py +++ b/luisa_lang/parse.py @@ -186,6 +186,7 @@ def _add_special_function(name: str, f: Callable[..., Any]) -> None: class FuncParser: + name: str func: object globalns: Dict[str, Any] @@ -250,12 +251,12 @@ def convert_constexpr(self, comptime_val: ComptimeValue, span: Optional[hir.Span raise hir.ParsingError( span, f"expected DSL function but got {value}") if dsl_func.is_generic: - return hir.Constant(dsl_func, type=hir.FunctionType(dsl_func, None), span=span) + return hir.FunctionValue(hir.FunctionType(dsl_func, None), span=span) else: resolved_f = dsl_func.resolve(None) assert not isinstance( resolved_f, hir.TemplateMatchingError) - return hir.Constant(resolved_f, type=hir.FunctionType(resolved_f, None), span=span) + return hir.FunctionValue(hir.FunctionType(resolved_f, None), span=span) # return hir.FunctionValue(resolved_f, None, span) elif isinstance(value, type): dsl_type = get_dsl_type(value) @@ -352,7 +353,7 @@ def get_index_type(self, span: Optional[hir.Span], base: hir.Type, index: hir.Va ty = base.member(hir.DynamicIndex()) return ty - def parse_access_ref(self, expr: ast.Subscript | ast.Attribute) -> hir.Ref | hir.TypeValue: + def parse_access_ref(self, expr: ast.Subscript | ast.Attribute) -> hir.Ref | hir.TypeValue | hir.FunctionValue: span = hir.Span.from_ast(expr) if isinstance(expr, ast.Subscript): value = self.parse_ref(expr.value) @@ -401,17 +402,31 @@ def parse_type_arg(expr: ast.expr) -> hir.Type: expr, f"indexing not supported for type {value.type}") elif isinstance(expr, ast.Attribute): value = self.parse_ref(expr.value) - assert isinstance(value, hir.Ref) - attr_name = expr.attr - assert value.type - member_ty = value.type.member(attr_name) - if not member_ty: + if isinstance(value, hir.Ref): + attr_name = expr.attr + assert value.type + member_ty = value.type.member(attr_name) + if not member_ty: + raise hir.ParsingError( + expr, f"member {attr_name} not found in type {value.type}") + if isinstance(member_ty, hir.FunctionType): + if not isinstance(value, hir.TypeValue): + member_ty.bound_object = value + return hir.FunctionValue(member_ty) + return self.cur_bb().append(hir.MemberRef(value, attr_name, type=member_ty, span=span)) + elif isinstance(value, hir.TypeValue): + member_ty = value.inner_type().member(expr.attr) + if not member_ty: + raise hir.ParsingError( + expr, f"member {expr.attr} not found in type {value.inner_type()}") + if isinstance(member_ty, hir.FunctionType): + return hir.FunctionValue(member_ty) + else: + raise hir.ParsingError( + expr, f"member {expr.attr} is not a function") + elif isinstance(value, hir.FunctionValue): raise hir.ParsingError( - expr, f"member {attr_name} not found in type {value.type}") - if isinstance(member_ty, hir.FunctionType): - if not isinstance(value, hir.TypeValue): - member_ty.bound_object = value - return self.cur_bb().append(hir.MemberRef(value, attr_name, type=member_ty, span=span)) + expr, "function value has no attributes") raise NotImplementedError() # unreachable # def parse_access(self, expr: ast.Subscript | ast.Attribute) -> hir.Value | ComptimeValue: @@ -501,33 +516,33 @@ def parse_call_impl(self, span: hir.Span | None, f: hir.FunctionLike | hir.Funct assert not isinstance(resolved_f, hir.TemplateMatchingError) else: resolved_f = f - if isinstance(resolved_f, hir.Function): - param_tys = [] - for p in resolved_f.params: - assert p.type, f"Parameter {p.name} has no type" - param_tys.append(p.type) - if len(param_tys) != len(args): + + param_tys = [] + for p in resolved_f.params: + assert p.type, f"Parameter {p.name} has no type" + param_tys.append(p.type) + if len(param_tys) != len(args): + raise hir.TypeInferenceError( + span, + f"Expected {len(param_tys)} arguments, got {len(args)}" + ) + for i, (param_ty, arg) in enumerate(zip(param_tys, args)): + assert arg.type is not None + if not hir.is_type_compatible_to(arg.type, param_ty): raise hir.TypeInferenceError( span, - f"Expected {len(param_tys)} arguments, got {len(args)}" + f"Argument {i} expected {param_ty}, got {arg.type}" ) - for i, (param_ty, arg) in enumerate(zip(param_tys, args)): - assert arg.type is not None - if not hir.is_type_compatible_to(arg.type, param_ty): - raise hir.TypeInferenceError( - span, - f"Argument {i} expected {param_ty}, got {arg.type}" - ) - assert resolved_f.return_type - return self.cur_bb().append(hir.Call(resolved_f, args, type=resolved_f.return_type, span=span)) - else: - args_ty = [] - for arg in args: - assert arg.type is not None - args_ty.append(arg.type) - ty = resolved_f.type_rule.infer(args_ty) - return self.cur_bb().append(hir.Call(resolved_f, args, type=ty, span=span)) - raise NotImplementedError() # unreachable + if resolved_f.params[i].semantic == hir.ParameterSemantic.BYREF: + if isinstance(arg, hir.Value): + tmp = self.cur_bb().append(hir.Alloca(arg.type, span)) + self.cur_bb().append(hir.Assign(tmp, arg, span)) + args[i] = tmp + else: + if isinstance(arg, hir.Ref): + args[i] = self.cur_bb().append(hir.Load(arg)) + assert resolved_f.return_type + return self.cur_bb().append(hir.Call(resolved_f, args, type=resolved_f.return_type, span=span)) def handle_special_functions(self, f: Callable[..., Any], expr: ast.Call) -> hir.Value | ComptimeValue: @@ -537,7 +552,17 @@ def do() -> hir.Intrinsic: if not isinstance(intrinsic_name, ast.Constant) or not isinstance(intrinsic_name.value, str): raise hir.ParsingError( expr, "intrinsic function expects a string literal as its first argument") - args = [self.parse_expr(arg) for arg in expr.args[1:]] + args:List[hir.Ref|hir.Value|hir.ComptimeValue] = [] + for a in expr.args[1:]: + if isinstance(a, ast.Call) and isinstance(a.func, ast.Name) and a.func.id == 'byref': + r = self.parse_ref(a.args[0]) + if isinstance(r, hir.Ref): + args.append(r) + else: + raise hir.ParsingError( + a, "expected reference but got value") + else: + args.append(self.parse_expr(a)) ret_type = args[0] if isinstance(ret_type, ComptimeValue): ret_type = self.try_convert_comptime_value( @@ -545,11 +570,11 @@ def do() -> hir.Intrinsic: if not isinstance(ret_type, hir.TypeValue): raise hir.ParsingError( expr, f"intrinsic function expects a type as its second argument but found {ret_type}") - if any([not isinstance(arg, hir.Value) for arg in args[1:]]): + if any([not isinstance(arg, (hir.Value, hir.Ref)) for arg in args[1:]]): raise hir.ParsingError( - expr, "intrinsic function expects values as its arguments") + expr, "intrinsic function expects values/refs as its arguments") return self.cur_bb().append( - hir.Intrinsic(intrinsic_name.value, cast(List[hir.Value], args[1:]), + hir.Intrinsic(intrinsic_name.value, cast(List[hir.Value|hir.Ref], args[1:]), ret_type.inner_type(), hir.Span.from_ast(expr))) return do() elif f is SPECIAL_FUNCTIONS_DICT['cast'] or f is SPECIAL_FUNCTIONS_DICT['bitcast']: @@ -644,9 +669,10 @@ def make_int(i: int) -> hir.Value: raise RuntimeError(f"Unsupported special function {f}") def parse_call(self, expr: ast.Call) -> hir.Value | ComptimeValue: - func: hir.Ref | ComptimeValue | hir.TypeValue | hir.Value = self.parse_ref(expr.func) # TODO: this should be a parse_ref + func: hir.Ref | ComptimeValue | hir.TypeValue | hir.Value = self.parse_ref( + expr.func) # TODO: this should be a parse_ref span = hir.Span.from_ast(expr) - + if isinstance(func, ComptimeValue): if func.value in SPECIAL_FUNCTIONS: return self.handle_special_functions(func.value, expr) @@ -808,7 +834,7 @@ def infer_binop(name: str, rname: str) -> hir.Value: raise e from e return infer_binop(ops[0], ops[1]) - def parse_ref(self, expr: ast.expr, new_var_hint: NewVarHint = False) -> hir.Ref | ComptimeValue | hir.TypeValue: + def parse_ref(self, expr: ast.expr, new_var_hint: NewVarHint = False) -> hir.Ref | ComptimeValue | hir.TypeValue | hir.FunctionValue: match expr: case ast.Name(): ret = self.parse_name(expr, new_var_hint) @@ -816,6 +842,8 @@ def parse_ref(self, expr: ast.expr, new_var_hint: NewVarHint = False) -> hir.Ref if isinstance(ret.type, hir.TypeConstructorType): assert isinstance(ret, hir.TypeValue) return ret + if isinstance(ret.type, hir.FunctionType): + return hir.FunctionValue(ret.type, hir.Span.from_ast(expr)) # raise hir.ParsingError( # expr, f"{type(ret)} cannot be used as reference") assert ret.type @@ -895,14 +923,16 @@ def check(i: int, val_type: hir.Type) -> None: if len(ref_targets) == 1: assert values.type check(0, values.type) - self.cur_bb().append(hir.Assign( - ref_targets[0], values)) + if not isinstance(values.type, (hir.FunctionType, hir.TypeConstructorType)): + self.cur_bb().append(hir.Assign( + ref_targets[0], values)) elif len(ref_targets) == length: for i, t in enumerate(ref_targets): e = extract_fn(values, i, targets[i]) assert e.type check(i, e.type) - self.cur_bb().append(hir.Assign(t, e)) + if not isinstance(e.type, (hir.FunctionType, hir.TypeConstructorType)): + self.cur_bb().append(hir.Assign(t, e)) else: if len(ref_targets) > length: raise hir.ParsingError( diff --git a/scripts/cpp_lib.hpp b/scripts/cpp_lib.hpp index 1ff65f8..bbcdf79 100644 --- a/scripts/cpp_lib.hpp +++ b/scripts/cpp_lib.hpp @@ -1,136 +1,3947 @@ -using i8 = char; -using u8 = unsigned char; -using i16 = short; -using u16 = unsigned short; -using i32 = int; -using u32 = unsigned int; -using i64 = long long; -using u64 = unsigned long long; -using f32 = float; -using f64 = double; - -template -constexpr bool is_same_v = false; +#define __device__ +#include +#include + +// inline directives + // if msvc +#ifdef _MSC_VER +#define __lc_always_inline__ __forceinline +#define __lc_never_inline__ __declspec(noinline) +#else +#define __lc_always_inline__ __attribute__((always_inline)) +#define __lc_never_inline__ __attribute__((noinline)) +#endif -template -constexpr bool is_same_v = true; + +int __float_as_int(float x) noexcept { return std::bit_cast(x); } +float __int_as_float(int x) noexcept { return std::bit_cast(x); } +float exp10f(float x) noexcept { return std::pow(10.0f, x); } +float rsqrtf(float x) noexcept { return 1.0f / std::sqrt(x); } +inline int __clz(unsigned int x) { + return __builtin_clz(x); +} +inline int __ctz(unsigned int x) { + return __builtin_ctz(x); +} +inline int __clzll(unsigned long long x) { + return __builtin_clzll(x); +} +inline int __ctzll(unsigned long long x) { + return __builtin_ctzll(x); +} +inline int __ffs(unsigned int x) { + return __builtin_ffs(x); +} +inline int __ffsll(unsigned long long x) { + return __builtin_ffsll(x); +} +inline int __popc(unsigned int x) { + return __builtin_popcount(x); +} +inline int __brev(unsigned int x) { + return __builtin_bswap32(x); +} +inline int __popcll(unsigned long long x) { + return __builtin_popcountll(x); +} +inline int __brevll(unsigned long long x) { + return __builtin_bswap64(x); +} -template -constexpr int compute_alignment() noexcept { +using lc_byte = char; +using lc_ubyte = unsigned char; +using lc_short = short; +using lc_ushort = unsigned short; +using lc_int = int; +using lc_uint = unsigned int; +using lc_float = float; +using lc_bool = bool; +using lc_long = long long; +using lc_ulong = unsigned long long; - if constexpr (is_same_v && N == 3) { - return alignof(i8) * 4; - } - if constexpr (is_same_v && N == 3) { - return alignof(u8) * 4; - } - if constexpr (is_same_v && N == 3) { - return alignof(i16) * 4; - } - if constexpr (is_same_v && N == 3) { - return alignof(u16) * 4; - } - if constexpr (is_same_v && N == 3) { - return alignof(i32) * 4; - } - if constexpr (is_same_v && N == 3) { - return alignof(u32) * 4; - } - if constexpr (is_same_v && N == 3) { - return alignof(i64) * 4; - } - if constexpr (is_same_v && N == 3) { - return alignof(u64) * 4; - } - if constexpr (is_same_v && N == 3) { - return alignof(f32) * 4; - } - if constexpr (is_same_v && N == 3) { - return alignof(f64) * 4; - } -return alignof(T) * N; +[[nodiscard]] __device__ inline bool isinf_impl(lc_float x) noexcept { +auto u = __float_as_int(x); +return u == 0x7f800000u | u == 0xff800000u; } +[[nodiscard]] __device__ inline bool isnan_impl(lc_float x) noexcept { +auto u = __float_as_int(x); +return ((u & 0x7F800000u) == 0x7F800000u) & ((u & 0x7FFFFFu) != 0u); +} +[[nodiscard]] __device__ inline lc_float powi_impl(lc_float x, lc_int y) noexcept { +lc_float r = 1.0f; +auto is_y_neg = y < 0; +auto y_abs = is_y_neg ? -y : y; -template -struct alignas(compute_alignment()) vec { - T data[N]{}; - vec() noexcept = default; - explicit vec(T value) noexcept { - for (int i = 0; i < N; ++i) { - data[i] = value; - } - } - T& operator[](int i) noexcept { - return data[i]; +while (y_abs) { + if (y_abs & 1) r *= x; + x *= x; + y_abs >>= 1; +} +return is_y_neg ? 1.0f / r : r; +} +[[nodiscard]] __device__ inline lc_float powf_impl(lc_float x, lc_float y) noexcept { +auto y_int = static_cast(y); +return y_int == y ? powi_impl(x, y_int) : powf(x, y); +} + + + +struct lc_half { +private: + union U { __fp16 h; lc_ushort bits; }; +public: + lc_ushort bits; + inline constexpr lc_half() noexcept : bits{0} {} + [[nodiscard]] static inline constexpr auto from_bits(lc_ushort bits) noexcept { + lc_half h; + h.bits = bits; + return h; } - T operator[](int i) const noexcept{ - return data[i]; + inline constexpr lc_half(float x) noexcept { + U u; + u.h = x; + bits = u.bits; } -#define VEC_OP(op, op_assign) \ - vec operator op(const vec& other) const noexcept \ - requires requires(T a, T b) { a op b; } { \ - vec result{}; \ - for (int i = 0; i < N; ++i) { \ - result[i] = data[i] op other.data[i]; \ - } \ - return result; \ - } \ - vec operator op(T scalar) const noexcept \ - requires requires(T a, T b) { a op b; } { \ - vec result{}; \ - for (int i = 0; i < N; ++i) { \ - result[i] = data[i] op scalar; \ - } \ - return result; \ - } \ - friend vec operator op(T scalar, const vec& v) noexcept \ - requires requires(T a, T b) { a op b; } { \ - return vec{scalar} op v; \ - } \ - vec operator op_assign(const vec& other) noexcept \ - requires requires(T a, T b) { a op_assign b; } { \ - for (int i = 0; i < N; ++i) { \ - data[i] op_assign other.data[i]; \ - } \ - return *this; \ - } \ - vec operator op_assign(T scalar) noexcept \ - requires requires(T a, T b) { a op_assign b; }{ \ - for (int i = 0; i < N; ++i) { \ - data[i] op_assign scalar; \ - } \ - return *this; \ + template + inline constexpr operator T() const noexcept { + U u; + u.bits = bits; + return static_cast(static_cast(u.h)); } - VEC_OP(+, +=) - VEC_OP(-, -=) - VEC_OP(*, *=) - VEC_OP(/, /=) - VEC_OP(%, %=) - + inline constexpr auto operator-() const noexcept { return from_bits(bits ^ 0x8000u); } + inline constexpr auto operator+() const noexcept { return *this; } + inline constexpr auto operator!() const noexcept { return bits == 0u || bits == 0x8000u; } +#define IMPL_HALF_BINOP(op) inline constexpr auto operator op(lc_half rhs) const noexcept { U u_lhs; u_lhs.bits = bits; U u_rhs; u_rhs.bits = rhs.bits; return lc_half{lc_float(u_lhs.h op u_rhs.h)}; } + IMPL_HALF_BINOP(+) + IMPL_HALF_BINOP(-) + IMPL_HALF_BINOP(*) + IMPL_HALF_BINOP(/) +#undef IMPL_HALF_BINOP +#define IMPL_HALF_CMP(op) inline constexpr auto operator op(lc_half rhs) const noexcept { return float(*this) op float(rhs); } + IMPL_HALF_CMP(==) + IMPL_HALF_CMP(!=) + IMPL_HALF_CMP(<) + IMPL_HALF_CMP(<=) + IMPL_HALF_CMP(>) + IMPL_HALF_CMP(>=) + +}; +static_assert(sizeof(lc_half) == 2); +[[nodiscard]] inline lc_short __half_as_short(lc_half x) noexcept { + return x.bits; +} +[[nodiscard]] inline lc_half __short_as_half(lc_short x) noexcept { + return lc_half::from_bits(x); +} +[[nodiscard]] inline lc_half __hmax(lc_half x, lc_half y) noexcept { return lc_half{lc_float(x) > lc_float(y) ? x : y}; } +[[nodiscard]] inline lc_half __hmin(lc_half x, lc_half y) noexcept { return lc_half{lc_float(x) < lc_float(y) ? x : y}; } +[[nodiscard]] inline lc_half __habs(lc_half x) noexcept { return lc_half{lc_float(x) < 0.0f ? -x : x}; } +[[nodiscard]] inline lc_half hexp2(lc_half x) noexcept { return lc_half{exp2f(lc_float(x))}; } +[[nodiscard]] inline lc_half hceil(lc_half x) noexcept { return lc_half{ceilf(lc_float(x))}; } +[[nodiscard]] inline lc_half hfloor(lc_half x) noexcept { return lc_half{floorf(lc_float(x))}; } +[[nodiscard]] inline lc_half htrunc(lc_half x) noexcept { return lc_half{truncf(lc_float(x))}; } +[[nodiscard]] inline lc_half hround(lc_half x) noexcept { return lc_half{roundf(lc_float(x))}; } +[[nodiscard]] inline lc_half hsqrt(lc_half x) noexcept { return lc_half{sqrtf(lc_float(x))}; } +[[nodiscard]] inline lc_half hrsqrt(lc_half x) noexcept { return lc_half{rsqrtf(lc_float(x))}; } +[[nodiscard]] inline lc_half __hfma(lc_half x, lc_half y, lc_half z) noexcept { return lc_half{fmaf(lc_float(x), lc_float(y), lc_float(z))}; } +[[nodiscard]] inline bool __hisnan(lc_half x) noexcept { return isnan_impl(lc_float(x)); } +[[nodiscard]] inline bool __hisinf(lc_half x) noexcept { return isinf_impl(lc_float(x)); } + +struct alignas(2) lc_byte2 { +lc_byte x, y; +__device__ inline constexpr lc_byte2() noexcept + : x{}, y{} {} +__device__ inline constexpr static auto zero() noexcept { return lc_byte2{}; } +__device__ inline constexpr static auto one() noexcept { return lc_byte2{1, 1}; } +__device__ inline explicit constexpr lc_byte2(lc_byte s) noexcept + : x{s}, y{s} {} +__device__ inline constexpr lc_byte2(lc_byte x, lc_byte y) noexcept + : x{x}, y{y} {} +__device__ inline constexpr auto &operator[](lc_uint i) noexcept { return (&x)[i]; } +__device__ inline constexpr auto operator[](lc_uint i) const noexcept { return (&x)[i]; } }; -template -requires requires(T a, T b) { a + b; } -T __builtin____add__(T x, T y) -{ - return x + y; +struct alignas(4) lc_byte3 { +lc_byte x, y, z; +__device__ inline constexpr lc_byte3() noexcept + : x{}, y{}, z{} {} +__device__ inline constexpr static auto zero() noexcept { return lc_byte3{}; } +__device__ inline constexpr static auto one() noexcept { return lc_byte3{1, 1, 1}; } +__device__ inline explicit constexpr lc_byte3(lc_byte s) noexcept + : x{s}, y{s}, z{s} {} +__device__ inline constexpr lc_byte3(lc_byte x, lc_byte y, lc_byte z) noexcept + : x{x}, y{y}, z{z} {} +__device__ inline constexpr auto &operator[](lc_uint i) noexcept { return (&x)[i]; } +__device__ inline constexpr auto operator[](lc_uint i) const noexcept { return (&x)[i]; } +}; + +struct alignas(4) lc_byte4 { +lc_byte x, y, z, w; +__device__ inline constexpr lc_byte4() noexcept + : x{}, y{}, z{}, w{} {} +__device__ inline constexpr static auto zero() noexcept { return lc_byte4{}; } +__device__ inline constexpr static auto one() noexcept { return lc_byte4{1, 1, 1, 1}; } +__device__ inline explicit constexpr lc_byte4(lc_byte s) noexcept + : x{s}, y{s}, z{s}, w{s} {} +__device__ inline constexpr lc_byte4(lc_byte x, lc_byte y, lc_byte z, lc_byte w) noexcept + : x{x}, y{y}, z{z}, w{w} {} +__device__ inline constexpr auto &operator[](lc_uint i) noexcept { return (&x)[i]; } +__device__ inline constexpr auto operator[](lc_uint i) const noexcept { return (&x)[i]; } +}; + +struct alignas(2) lc_ubyte2 { +lc_ubyte x, y; +__device__ inline constexpr lc_ubyte2() noexcept + : x{}, y{} {} +__device__ inline constexpr static auto zero() noexcept { return lc_ubyte2{}; } +__device__ inline constexpr static auto one() noexcept { return lc_ubyte2{1, 1}; } +__device__ inline explicit constexpr lc_ubyte2(lc_ubyte s) noexcept + : x{s}, y{s} {} +__device__ inline constexpr lc_ubyte2(lc_ubyte x, lc_ubyte y) noexcept + : x{x}, y{y} {} +__device__ inline constexpr auto &operator[](lc_uint i) noexcept { return (&x)[i]; } +__device__ inline constexpr auto operator[](lc_uint i) const noexcept { return (&x)[i]; } +}; + +struct alignas(4) lc_ubyte3 { +lc_ubyte x, y, z; +__device__ inline constexpr lc_ubyte3() noexcept + : x{}, y{}, z{} {} +__device__ inline constexpr static auto zero() noexcept { return lc_ubyte3{}; } +__device__ inline constexpr static auto one() noexcept { return lc_ubyte3{1, 1, 1}; } +__device__ inline explicit constexpr lc_ubyte3(lc_ubyte s) noexcept + : x{s}, y{s}, z{s} {} +__device__ inline constexpr lc_ubyte3(lc_ubyte x, lc_ubyte y, lc_ubyte z) noexcept + : x{x}, y{y}, z{z} {} +__device__ inline constexpr auto &operator[](lc_uint i) noexcept { return (&x)[i]; } +__device__ inline constexpr auto operator[](lc_uint i) const noexcept { return (&x)[i]; } +}; + +struct alignas(4) lc_ubyte4 { +lc_ubyte x, y, z, w; +__device__ inline constexpr lc_ubyte4() noexcept + : x{}, y{}, z{}, w{} {} +__device__ inline constexpr static auto zero() noexcept { return lc_ubyte4{}; } +__device__ inline constexpr static auto one() noexcept { return lc_ubyte4{1, 1, 1, 1}; } +__device__ inline explicit constexpr lc_ubyte4(lc_ubyte s) noexcept + : x{s}, y{s}, z{s}, w{s} {} +__device__ inline constexpr lc_ubyte4(lc_ubyte x, lc_ubyte y, lc_ubyte z, lc_ubyte w) noexcept + : x{x}, y{y}, z{z}, w{w} {} +__device__ inline constexpr auto &operator[](lc_uint i) noexcept { return (&x)[i]; } +__device__ inline constexpr auto operator[](lc_uint i) const noexcept { return (&x)[i]; } +}; + +struct alignas(4) lc_short2 { +lc_short x, y; +__device__ inline constexpr lc_short2() noexcept + : x{}, y{} {} +__device__ inline constexpr static auto zero() noexcept { return lc_short2{}; } +__device__ inline constexpr static auto one() noexcept { return lc_short2{1, 1}; } +__device__ inline explicit constexpr lc_short2(lc_short s) noexcept + : x{s}, y{s} {} +__device__ inline constexpr lc_short2(lc_short x, lc_short y) noexcept + : x{x}, y{y} {} +__device__ inline constexpr auto &operator[](lc_uint i) noexcept { return (&x)[i]; } +__device__ inline constexpr auto operator[](lc_uint i) const noexcept { return (&x)[i]; } +}; + +struct alignas(8) lc_short3 { +lc_short x, y, z; +__device__ inline constexpr lc_short3() noexcept + : x{}, y{}, z{} {} +__device__ inline constexpr static auto zero() noexcept { return lc_short3{}; } +__device__ inline constexpr static auto one() noexcept { return lc_short3{1, 1, 1}; } +__device__ inline explicit constexpr lc_short3(lc_short s) noexcept + : x{s}, y{s}, z{s} {} +__device__ inline constexpr lc_short3(lc_short x, lc_short y, lc_short z) noexcept + : x{x}, y{y}, z{z} {} +__device__ inline constexpr auto &operator[](lc_uint i) noexcept { return (&x)[i]; } +__device__ inline constexpr auto operator[](lc_uint i) const noexcept { return (&x)[i]; } +}; + +struct alignas(8) lc_short4 { +lc_short x, y, z, w; +__device__ inline constexpr lc_short4() noexcept + : x{}, y{}, z{}, w{} {} +__device__ inline constexpr static auto zero() noexcept { return lc_short4{}; } +__device__ inline constexpr static auto one() noexcept { return lc_short4{1, 1, 1, 1}; } +__device__ inline explicit constexpr lc_short4(lc_short s) noexcept + : x{s}, y{s}, z{s}, w{s} {} +__device__ inline constexpr lc_short4(lc_short x, lc_short y, lc_short z, lc_short w) noexcept + : x{x}, y{y}, z{z}, w{w} {} +__device__ inline constexpr auto &operator[](lc_uint i) noexcept { return (&x)[i]; } +__device__ inline constexpr auto operator[](lc_uint i) const noexcept { return (&x)[i]; } +}; + +struct alignas(4) lc_ushort2 { +lc_ushort x, y; +__device__ inline constexpr lc_ushort2() noexcept + : x{}, y{} {} +__device__ inline constexpr static auto zero() noexcept { return lc_ushort2{}; } +__device__ inline constexpr static auto one() noexcept { return lc_ushort2{1, 1}; } +__device__ inline explicit constexpr lc_ushort2(lc_ushort s) noexcept + : x{s}, y{s} {} +__device__ inline constexpr lc_ushort2(lc_ushort x, lc_ushort y) noexcept + : x{x}, y{y} {} +__device__ inline constexpr auto &operator[](lc_uint i) noexcept { return (&x)[i]; } +__device__ inline constexpr auto operator[](lc_uint i) const noexcept { return (&x)[i]; } +}; + +struct alignas(8) lc_ushort3 { +lc_ushort x, y, z; +__device__ inline constexpr lc_ushort3() noexcept + : x{}, y{}, z{} {} +__device__ inline constexpr static auto zero() noexcept { return lc_ushort3{}; } +__device__ inline constexpr static auto one() noexcept { return lc_ushort3{1, 1, 1}; } +__device__ inline explicit constexpr lc_ushort3(lc_ushort s) noexcept + : x{s}, y{s}, z{s} {} +__device__ inline constexpr lc_ushort3(lc_ushort x, lc_ushort y, lc_ushort z) noexcept + : x{x}, y{y}, z{z} {} +__device__ inline constexpr auto &operator[](lc_uint i) noexcept { return (&x)[i]; } +__device__ inline constexpr auto operator[](lc_uint i) const noexcept { return (&x)[i]; } +}; + +struct alignas(8) lc_ushort4 { +lc_ushort x, y, z, w; +__device__ inline constexpr lc_ushort4() noexcept + : x{}, y{}, z{}, w{} {} +__device__ inline constexpr static auto zero() noexcept { return lc_ushort4{}; } +__device__ inline constexpr static auto one() noexcept { return lc_ushort4{1, 1, 1, 1}; } +__device__ inline explicit constexpr lc_ushort4(lc_ushort s) noexcept + : x{s}, y{s}, z{s}, w{s} {} +__device__ inline constexpr lc_ushort4(lc_ushort x, lc_ushort y, lc_ushort z, lc_ushort w) noexcept + : x{x}, y{y}, z{z}, w{w} {} +__device__ inline constexpr auto &operator[](lc_uint i) noexcept { return (&x)[i]; } +__device__ inline constexpr auto operator[](lc_uint i) const noexcept { return (&x)[i]; } +}; + +struct alignas(8) lc_int2 { +lc_int x, y; +__device__ inline constexpr lc_int2() noexcept + : x{}, y{} {} +__device__ inline constexpr static auto zero() noexcept { return lc_int2{}; } +__device__ inline constexpr static auto one() noexcept { return lc_int2{1, 1}; } +__device__ inline explicit constexpr lc_int2(lc_int s) noexcept + : x{s}, y{s} {} +__device__ inline constexpr lc_int2(lc_int x, lc_int y) noexcept + : x{x}, y{y} {} +__device__ inline constexpr auto &operator[](lc_uint i) noexcept { return (&x)[i]; } +__device__ inline constexpr auto operator[](lc_uint i) const noexcept { return (&x)[i]; } +}; + +struct alignas(16) lc_int3 { +lc_int x, y, z; +__device__ inline constexpr lc_int3() noexcept + : x{}, y{}, z{} {} +__device__ inline constexpr static auto zero() noexcept { return lc_int3{}; } +__device__ inline constexpr static auto one() noexcept { return lc_int3{1, 1, 1}; } +__device__ inline explicit constexpr lc_int3(lc_int s) noexcept + : x{s}, y{s}, z{s} {} +__device__ inline constexpr lc_int3(lc_int x, lc_int y, lc_int z) noexcept + : x{x}, y{y}, z{z} {} +__device__ inline constexpr auto &operator[](lc_uint i) noexcept { return (&x)[i]; } +__device__ inline constexpr auto operator[](lc_uint i) const noexcept { return (&x)[i]; } +}; + +struct alignas(16) lc_int4 { +lc_int x, y, z, w; +__device__ inline constexpr lc_int4() noexcept + : x{}, y{}, z{}, w{} {} +__device__ inline constexpr static auto zero() noexcept { return lc_int4{}; } +__device__ inline constexpr static auto one() noexcept { return lc_int4{1, 1, 1, 1}; } +__device__ inline explicit constexpr lc_int4(lc_int s) noexcept + : x{s}, y{s}, z{s}, w{s} {} +__device__ inline constexpr lc_int4(lc_int x, lc_int y, lc_int z, lc_int w) noexcept + : x{x}, y{y}, z{z}, w{w} {} +__device__ inline constexpr auto &operator[](lc_uint i) noexcept { return (&x)[i]; } +__device__ inline constexpr auto operator[](lc_uint i) const noexcept { return (&x)[i]; } +}; + +struct alignas(8) lc_uint2 { +lc_uint x, y; +__device__ inline constexpr lc_uint2() noexcept + : x{}, y{} {} +__device__ inline constexpr static auto zero() noexcept { return lc_uint2{}; } +__device__ inline constexpr static auto one() noexcept { return lc_uint2{1, 1}; } +__device__ inline explicit constexpr lc_uint2(lc_uint s) noexcept + : x{s}, y{s} {} +__device__ inline constexpr lc_uint2(lc_uint x, lc_uint y) noexcept + : x{x}, y{y} {} +__device__ inline constexpr auto &operator[](lc_uint i) noexcept { return (&x)[i]; } +__device__ inline constexpr auto operator[](lc_uint i) const noexcept { return (&x)[i]; } +}; + +struct alignas(16) lc_uint3 { +lc_uint x, y, z; +__device__ inline constexpr lc_uint3() noexcept + : x{}, y{}, z{} {} +__device__ inline constexpr static auto zero() noexcept { return lc_uint3{}; } +__device__ inline constexpr static auto one() noexcept { return lc_uint3{1, 1, 1}; } +__device__ inline explicit constexpr lc_uint3(lc_uint s) noexcept + : x{s}, y{s}, z{s} {} +__device__ inline constexpr lc_uint3(lc_uint x, lc_uint y, lc_uint z) noexcept + : x{x}, y{y}, z{z} {} +__device__ inline constexpr auto &operator[](lc_uint i) noexcept { return (&x)[i]; } +__device__ inline constexpr auto operator[](lc_uint i) const noexcept { return (&x)[i]; } +}; + +struct alignas(16) lc_uint4 { +lc_uint x, y, z, w; +__device__ inline constexpr lc_uint4() noexcept + : x{}, y{}, z{}, w{} {} +__device__ inline constexpr static auto zero() noexcept { return lc_uint4{}; } +__device__ inline constexpr static auto one() noexcept { return lc_uint4{1, 1, 1, 1}; } +__device__ inline explicit constexpr lc_uint4(lc_uint s) noexcept + : x{s}, y{s}, z{s}, w{s} {} +__device__ inline constexpr lc_uint4(lc_uint x, lc_uint y, lc_uint z, lc_uint w) noexcept + : x{x}, y{y}, z{z}, w{w} {} +__device__ inline constexpr auto &operator[](lc_uint i) noexcept { return (&x)[i]; } +__device__ inline constexpr auto operator[](lc_uint i) const noexcept { return (&x)[i]; } +}; + +struct alignas(4) lc_half2 { +lc_half x, y; +__device__ inline constexpr lc_half2() noexcept + : x{}, y{} {} +__device__ inline constexpr static auto zero() noexcept { return lc_half2{}; } +__device__ inline constexpr static auto one() noexcept { return lc_half2{1, 1}; } +__device__ inline explicit constexpr lc_half2(lc_half s) noexcept + : x{s}, y{s} {} +__device__ inline constexpr lc_half2(lc_half x, lc_half y) noexcept + : x{x}, y{y} {} +__device__ inline constexpr auto &operator[](lc_uint i) noexcept { return (&x)[i]; } +__device__ inline constexpr auto operator[](lc_uint i) const noexcept { return (&x)[i]; } +}; + +struct alignas(8) lc_half3 { +lc_half x, y, z; +__device__ inline constexpr lc_half3() noexcept + : x{}, y{}, z{} {} +__device__ inline constexpr static auto zero() noexcept { return lc_half3{}; } +__device__ inline constexpr static auto one() noexcept { return lc_half3{1, 1, 1}; } +__device__ inline explicit constexpr lc_half3(lc_half s) noexcept + : x{s}, y{s}, z{s} {} +__device__ inline constexpr lc_half3(lc_half x, lc_half y, lc_half z) noexcept + : x{x}, y{y}, z{z} {} +__device__ inline constexpr auto &operator[](lc_uint i) noexcept { return (&x)[i]; } +__device__ inline constexpr auto operator[](lc_uint i) const noexcept { return (&x)[i]; } +}; + +struct alignas(8) lc_half4 { +lc_half x, y, z, w; +__device__ inline constexpr lc_half4() noexcept + : x{}, y{}, z{}, w{} {} +__device__ inline constexpr static auto zero() noexcept { return lc_half4{}; } +__device__ inline constexpr static auto one() noexcept { return lc_half4{1, 1, 1, 1}; } +__device__ inline explicit constexpr lc_half4(lc_half s) noexcept + : x{s}, y{s}, z{s}, w{s} {} +__device__ inline constexpr lc_half4(lc_half x, lc_half y, lc_half z, lc_half w) noexcept + : x{x}, y{y}, z{z}, w{w} {} +__device__ inline constexpr auto &operator[](lc_uint i) noexcept { return (&x)[i]; } +__device__ inline constexpr auto operator[](lc_uint i) const noexcept { return (&x)[i]; } +}; + +struct alignas(8) lc_float2 { +lc_float x, y; +__device__ inline constexpr lc_float2() noexcept + : x{}, y{} {} +__device__ inline constexpr static auto zero() noexcept { return lc_float2{}; } +__device__ inline constexpr static auto one() noexcept { return lc_float2{1, 1}; } +__device__ inline explicit constexpr lc_float2(lc_float s) noexcept + : x{s}, y{s} {} +__device__ inline constexpr lc_float2(lc_float x, lc_float y) noexcept + : x{x}, y{y} {} +__device__ inline constexpr auto &operator[](lc_uint i) noexcept { return (&x)[i]; } +__device__ inline constexpr auto operator[](lc_uint i) const noexcept { return (&x)[i]; } +}; + +struct alignas(16) lc_float3 { +lc_float x, y, z; +__device__ inline constexpr lc_float3() noexcept + : x{}, y{}, z{} {} +__device__ inline constexpr static auto zero() noexcept { return lc_float3{}; } +__device__ inline constexpr static auto one() noexcept { return lc_float3{1, 1, 1}; } +__device__ inline explicit constexpr lc_float3(lc_float s) noexcept + : x{s}, y{s}, z{s} {} +__device__ inline constexpr lc_float3(lc_float x, lc_float y, lc_float z) noexcept + : x{x}, y{y}, z{z} {} +__device__ inline constexpr auto &operator[](lc_uint i) noexcept { return (&x)[i]; } +__device__ inline constexpr auto operator[](lc_uint i) const noexcept { return (&x)[i]; } +}; + +struct alignas(16) lc_float4 { +lc_float x, y, z, w; +__device__ inline constexpr lc_float4() noexcept + : x{}, y{}, z{}, w{} {} +__device__ inline constexpr static auto zero() noexcept { return lc_float4{}; } +__device__ inline constexpr static auto one() noexcept { return lc_float4{1, 1, 1, 1}; } +__device__ inline explicit constexpr lc_float4(lc_float s) noexcept + : x{s}, y{s}, z{s}, w{s} {} +__device__ inline constexpr lc_float4(lc_float x, lc_float y, lc_float z, lc_float w) noexcept + : x{x}, y{y}, z{z}, w{w} {} +__device__ inline constexpr auto &operator[](lc_uint i) noexcept { return (&x)[i]; } +__device__ inline constexpr auto operator[](lc_uint i) const noexcept { return (&x)[i]; } +}; + +struct alignas(2) lc_bool2 { +lc_bool x, y; +__device__ inline constexpr lc_bool2() noexcept + : x{}, y{} {} +__device__ inline constexpr static auto zero() noexcept { return lc_bool2{}; } +__device__ inline constexpr static auto one() noexcept { return lc_bool2{1, 1}; } +__device__ inline explicit constexpr lc_bool2(lc_bool s) noexcept + : x{s}, y{s} {} +__device__ inline constexpr lc_bool2(lc_bool x, lc_bool y) noexcept + : x{x}, y{y} {} +__device__ inline constexpr auto &operator[](lc_uint i) noexcept { return (&x)[i]; } +__device__ inline constexpr auto operator[](lc_uint i) const noexcept { return (&x)[i]; } +}; + +struct alignas(4) lc_bool3 { +lc_bool x, y, z; +__device__ inline constexpr lc_bool3() noexcept + : x{}, y{}, z{} {} +__device__ inline constexpr static auto zero() noexcept { return lc_bool3{}; } +__device__ inline constexpr static auto one() noexcept { return lc_bool3{1, 1, 1}; } +__device__ inline explicit constexpr lc_bool3(lc_bool s) noexcept + : x{s}, y{s}, z{s} {} +__device__ inline constexpr lc_bool3(lc_bool x, lc_bool y, lc_bool z) noexcept + : x{x}, y{y}, z{z} {} +__device__ inline constexpr auto &operator[](lc_uint i) noexcept { return (&x)[i]; } +__device__ inline constexpr auto operator[](lc_uint i) const noexcept { return (&x)[i]; } +}; + +struct alignas(4) lc_bool4 { +lc_bool x, y, z, w; +__device__ inline constexpr lc_bool4() noexcept + : x{}, y{}, z{}, w{} {} +__device__ inline constexpr static auto zero() noexcept { return lc_bool4{}; } +__device__ inline constexpr static auto one() noexcept { return lc_bool4{1, 1, 1, 1}; } +__device__ inline explicit constexpr lc_bool4(lc_bool s) noexcept + : x{s}, y{s}, z{s}, w{s} {} +__device__ inline constexpr lc_bool4(lc_bool x, lc_bool y, lc_bool z, lc_bool w) noexcept + : x{x}, y{y}, z{z}, w{w} {} +__device__ inline constexpr auto &operator[](lc_uint i) noexcept { return (&x)[i]; } +__device__ inline constexpr auto operator[](lc_uint i) const noexcept { return (&x)[i]; } +}; + +struct alignas(16) lc_long2 { +lc_long x, y; +__device__ inline constexpr lc_long2() noexcept + : x{}, y{} {} +__device__ inline constexpr static auto zero() noexcept { return lc_long2{}; } +__device__ inline constexpr static auto one() noexcept { return lc_long2{1, 1}; } +__device__ inline explicit constexpr lc_long2(lc_long s) noexcept + : x{s}, y{s} {} +__device__ inline constexpr lc_long2(lc_long x, lc_long y) noexcept + : x{x}, y{y} {} +__device__ inline constexpr auto &operator[](lc_uint i) noexcept { return (&x)[i]; } +__device__ inline constexpr auto operator[](lc_uint i) const noexcept { return (&x)[i]; } +}; + +struct alignas(16) lc_long3 { +lc_long x, y, z; +__device__ inline constexpr lc_long3() noexcept + : x{}, y{}, z{} {} +__device__ inline constexpr static auto zero() noexcept { return lc_long3{}; } +__device__ inline constexpr static auto one() noexcept { return lc_long3{1, 1, 1}; } +__device__ inline explicit constexpr lc_long3(lc_long s) noexcept + : x{s}, y{s}, z{s} {} +__device__ inline constexpr lc_long3(lc_long x, lc_long y, lc_long z) noexcept + : x{x}, y{y}, z{z} {} +__device__ inline constexpr auto &operator[](lc_uint i) noexcept { return (&x)[i]; } +__device__ inline constexpr auto operator[](lc_uint i) const noexcept { return (&x)[i]; } +}; + +struct alignas(16) lc_long4 { +lc_long x, y, z, w; +__device__ inline constexpr lc_long4() noexcept + : x{}, y{}, z{}, w{} {} +__device__ inline constexpr static auto zero() noexcept { return lc_long4{}; } +__device__ inline constexpr static auto one() noexcept { return lc_long4{1, 1, 1, 1}; } +__device__ inline explicit constexpr lc_long4(lc_long s) noexcept + : x{s}, y{s}, z{s}, w{s} {} +__device__ inline constexpr lc_long4(lc_long x, lc_long y, lc_long z, lc_long w) noexcept + : x{x}, y{y}, z{z}, w{w} {} +__device__ inline constexpr auto &operator[](lc_uint i) noexcept { return (&x)[i]; } +__device__ inline constexpr auto operator[](lc_uint i) const noexcept { return (&x)[i]; } +}; + +struct alignas(16) lc_ulong2 { +lc_ulong x, y; +__device__ inline constexpr lc_ulong2() noexcept + : x{}, y{} {} +__device__ inline constexpr static auto zero() noexcept { return lc_ulong2{}; } +__device__ inline constexpr static auto one() noexcept { return lc_ulong2{1, 1}; } +__device__ inline explicit constexpr lc_ulong2(lc_ulong s) noexcept + : x{s}, y{s} {} +__device__ inline constexpr lc_ulong2(lc_ulong x, lc_ulong y) noexcept + : x{x}, y{y} {} +__device__ inline constexpr auto &operator[](lc_uint i) noexcept { return (&x)[i]; } +__device__ inline constexpr auto operator[](lc_uint i) const noexcept { return (&x)[i]; } +}; + +struct alignas(16) lc_ulong3 { +lc_ulong x, y, z; +__device__ inline constexpr lc_ulong3() noexcept + : x{}, y{}, z{} {} +__device__ inline constexpr static auto zero() noexcept { return lc_ulong3{}; } +__device__ inline constexpr static auto one() noexcept { return lc_ulong3{1, 1, 1}; } +__device__ inline explicit constexpr lc_ulong3(lc_ulong s) noexcept + : x{s}, y{s}, z{s} {} +__device__ inline constexpr lc_ulong3(lc_ulong x, lc_ulong y, lc_ulong z) noexcept + : x{x}, y{y}, z{z} {} +__device__ inline constexpr auto &operator[](lc_uint i) noexcept { return (&x)[i]; } +__device__ inline constexpr auto operator[](lc_uint i) const noexcept { return (&x)[i]; } +}; + +struct alignas(16) lc_ulong4 { +lc_ulong x, y, z, w; +__device__ inline constexpr lc_ulong4() noexcept + : x{}, y{}, z{}, w{} {} +__device__ inline constexpr static auto zero() noexcept { return lc_ulong4{}; } +__device__ inline constexpr static auto one() noexcept { return lc_ulong4{1, 1, 1, 1}; } +__device__ inline explicit constexpr lc_ulong4(lc_ulong s) noexcept + : x{s}, y{s}, z{s}, w{s} {} +__device__ inline constexpr lc_ulong4(lc_ulong x, lc_ulong y, lc_ulong z, lc_ulong w) noexcept + : x{x}, y{y}, z{z}, w{w} {} +__device__ inline constexpr auto &operator[](lc_uint i) noexcept { return (&x)[i]; } +__device__ inline constexpr auto operator[](lc_uint i) const noexcept { return (&x)[i]; } +}; + +[[nodiscard]] __device__ inline constexpr auto lc_make_byte2(lc_byte s = 0) noexcept { return lc_byte2{s, s}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_byte2(lc_byte x, lc_byte y) noexcept { return lc_byte2{x, y}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_byte2(lc_byte2 v) noexcept { return lc_byte2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_byte2(lc_byte3 v) noexcept { return lc_byte2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_byte2(lc_byte4 v) noexcept { return lc_byte2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_byte2(lc_ubyte2 v) noexcept { return lc_byte2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_byte2(lc_ubyte3 v) noexcept { return lc_byte2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_byte2(lc_ubyte4 v) noexcept { return lc_byte2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_byte2(lc_short2 v) noexcept { return lc_byte2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_byte2(lc_short3 v) noexcept { return lc_byte2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_byte2(lc_short4 v) noexcept { return lc_byte2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_byte2(lc_ushort2 v) noexcept { return lc_byte2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_byte2(lc_ushort3 v) noexcept { return lc_byte2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_byte2(lc_ushort4 v) noexcept { return lc_byte2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_byte2(lc_int2 v) noexcept { return lc_byte2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_byte2(lc_int3 v) noexcept { return lc_byte2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_byte2(lc_int4 v) noexcept { return lc_byte2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_byte2(lc_uint2 v) noexcept { return lc_byte2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_byte2(lc_uint3 v) noexcept { return lc_byte2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_byte2(lc_uint4 v) noexcept { return lc_byte2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_byte2(lc_half2 v) noexcept { return lc_byte2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_byte2(lc_half3 v) noexcept { return lc_byte2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_byte2(lc_half4 v) noexcept { return lc_byte2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_byte2(lc_float2 v) noexcept { return lc_byte2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_byte2(lc_float3 v) noexcept { return lc_byte2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_byte2(lc_float4 v) noexcept { return lc_byte2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_byte2(lc_bool2 v) noexcept { return lc_byte2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_byte2(lc_bool3 v) noexcept { return lc_byte2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_byte2(lc_bool4 v) noexcept { return lc_byte2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_byte2(lc_long2 v) noexcept { return lc_byte2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_byte2(lc_long3 v) noexcept { return lc_byte2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_byte2(lc_long4 v) noexcept { return lc_byte2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_byte2(lc_ulong2 v) noexcept { return lc_byte2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_byte2(lc_ulong3 v) noexcept { return lc_byte2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_byte2(lc_ulong4 v) noexcept { return lc_byte2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] inline __device__ constexpr auto lc_make_byte3(lc_byte s = 0) noexcept { return lc_byte3{s, s, s}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_byte3(lc_byte x, lc_byte y, lc_byte z) noexcept { return lc_byte3{x, y, z}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_byte3(lc_byte x, lc_byte2 yz) noexcept { return lc_byte3{x, yz.x, yz.y}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_byte3(lc_byte2 xy, lc_byte z) noexcept { return lc_byte3{xy.x, xy.y, z}; } +[[nodiscard]] __device__ constexpr auto lc_make_byte3(lc_byte3 v) noexcept { return lc_byte3{static_cast(v.x), static_cast(v.y), static_cast(v.z)}; } +[[nodiscard]] __device__ constexpr auto lc_make_byte3(lc_byte4 v) noexcept { return lc_byte3{static_cast(v.x), static_cast(v.y), static_cast(v.z)}; } +[[nodiscard]] __device__ constexpr auto lc_make_byte3(lc_ubyte3 v) noexcept { return lc_byte3{static_cast(v.x), static_cast(v.y), static_cast(v.z)}; } +[[nodiscard]] __device__ constexpr auto lc_make_byte3(lc_ubyte4 v) noexcept { return lc_byte3{static_cast(v.x), static_cast(v.y), static_cast(v.z)}; } +[[nodiscard]] __device__ constexpr auto lc_make_byte3(lc_short3 v) noexcept { return lc_byte3{static_cast(v.x), static_cast(v.y), static_cast(v.z)}; } +[[nodiscard]] __device__ constexpr auto lc_make_byte3(lc_short4 v) noexcept { return lc_byte3{static_cast(v.x), static_cast(v.y), static_cast(v.z)}; } +[[nodiscard]] __device__ constexpr auto lc_make_byte3(lc_ushort3 v) noexcept { return lc_byte3{static_cast(v.x), static_cast(v.y), static_cast(v.z)}; } +[[nodiscard]] __device__ constexpr auto lc_make_byte3(lc_ushort4 v) noexcept { return lc_byte3{static_cast(v.x), static_cast(v.y), static_cast(v.z)}; } +[[nodiscard]] __device__ constexpr auto lc_make_byte3(lc_int3 v) noexcept { return lc_byte3{static_cast(v.x), static_cast(v.y), static_cast(v.z)}; } +[[nodiscard]] __device__ constexpr auto lc_make_byte3(lc_int4 v) noexcept { return lc_byte3{static_cast(v.x), static_cast(v.y), static_cast(v.z)}; } +[[nodiscard]] __device__ constexpr auto lc_make_byte3(lc_uint3 v) noexcept { return lc_byte3{static_cast(v.x), static_cast(v.y), static_cast(v.z)}; } +[[nodiscard]] __device__ constexpr auto lc_make_byte3(lc_uint4 v) noexcept { return lc_byte3{static_cast(v.x), static_cast(v.y), static_cast(v.z)}; } +[[nodiscard]] __device__ constexpr auto lc_make_byte3(lc_half3 v) noexcept { return lc_byte3{static_cast(v.x), static_cast(v.y), static_cast(v.z)}; } +[[nodiscard]] __device__ constexpr auto lc_make_byte3(lc_half4 v) noexcept { return lc_byte3{static_cast(v.x), static_cast(v.y), static_cast(v.z)}; } +[[nodiscard]] __device__ constexpr auto lc_make_byte3(lc_float3 v) noexcept { return lc_byte3{static_cast(v.x), static_cast(v.y), static_cast(v.z)}; } +[[nodiscard]] __device__ constexpr auto lc_make_byte3(lc_float4 v) noexcept { return lc_byte3{static_cast(v.x), static_cast(v.y), static_cast(v.z)}; } +[[nodiscard]] __device__ constexpr auto lc_make_byte3(lc_bool3 v) noexcept { return lc_byte3{static_cast(v.x), static_cast(v.y), static_cast(v.z)}; } +[[nodiscard]] __device__ constexpr auto lc_make_byte3(lc_bool4 v) noexcept { return lc_byte3{static_cast(v.x), static_cast(v.y), static_cast(v.z)}; } +[[nodiscard]] __device__ constexpr auto lc_make_byte3(lc_long3 v) noexcept { return lc_byte3{static_cast(v.x), static_cast(v.y), static_cast(v.z)}; } +[[nodiscard]] __device__ constexpr auto lc_make_byte3(lc_long4 v) noexcept { return lc_byte3{static_cast(v.x), static_cast(v.y), static_cast(v.z)}; } +[[nodiscard]] __device__ constexpr auto lc_make_byte3(lc_ulong3 v) noexcept { return lc_byte3{static_cast(v.x), static_cast(v.y), static_cast(v.z)}; } +[[nodiscard]] __device__ constexpr auto lc_make_byte3(lc_ulong4 v) noexcept { return lc_byte3{static_cast(v.x), static_cast(v.y), static_cast(v.z)}; } +[[nodiscard]] inline __device__ constexpr auto lc_make_byte4(lc_byte s = 0) noexcept { return lc_byte4{s, s, s, s}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_byte4(lc_byte x, lc_byte y, lc_byte z, lc_byte w) noexcept { return lc_byte4{x, y, z, w}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_byte4(lc_byte x, lc_byte y, lc_byte2 zw) noexcept { return lc_byte4{x, y, zw.x, zw.y}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_byte4(lc_byte x, lc_byte2 yz, lc_byte w) noexcept { return lc_byte4{x, yz.x, yz.y, w}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_byte4(lc_byte2 xy, lc_byte z, lc_byte w) noexcept { return lc_byte4{xy.x, xy.y, z, w}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_byte4(lc_byte2 xy, lc_byte2 zw) noexcept { return lc_byte4{xy.x, xy.y, zw.x, zw.y}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_byte4(lc_byte x, lc_byte3 yzw) noexcept { return lc_byte4{x, yzw.x, yzw.y, yzw.z}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_byte4(lc_byte3 xyz, lc_byte w) noexcept { return lc_byte4{xyz.x, xyz.y, xyz.z, w}; } +[[nodiscard]] inline __device__ constexpr auto lc_make_byte4(lc_byte4 v) noexcept { return lc_byte4{static_cast(v.x), static_cast(v.y), static_cast(v.z), static_cast(v.w)}; } +[[nodiscard]] inline __device__ constexpr auto lc_make_byte4(lc_ubyte4 v) noexcept { return lc_byte4{static_cast(v.x), static_cast(v.y), static_cast(v.z), static_cast(v.w)}; } +[[nodiscard]] inline __device__ constexpr auto lc_make_byte4(lc_short4 v) noexcept { return lc_byte4{static_cast(v.x), static_cast(v.y), static_cast(v.z), static_cast(v.w)}; } +[[nodiscard]] inline __device__ constexpr auto lc_make_byte4(lc_ushort4 v) noexcept { return lc_byte4{static_cast(v.x), static_cast(v.y), static_cast(v.z), static_cast(v.w)}; } +[[nodiscard]] inline __device__ constexpr auto lc_make_byte4(lc_int4 v) noexcept { return lc_byte4{static_cast(v.x), static_cast(v.y), static_cast(v.z), static_cast(v.w)}; } +[[nodiscard]] inline __device__ constexpr auto lc_make_byte4(lc_uint4 v) noexcept { return lc_byte4{static_cast(v.x), static_cast(v.y), static_cast(v.z), static_cast(v.w)}; } +[[nodiscard]] inline __device__ constexpr auto lc_make_byte4(lc_half4 v) noexcept { return lc_byte4{static_cast(v.x), static_cast(v.y), static_cast(v.z), static_cast(v.w)}; } +[[nodiscard]] inline __device__ constexpr auto lc_make_byte4(lc_float4 v) noexcept { return lc_byte4{static_cast(v.x), static_cast(v.y), static_cast(v.z), static_cast(v.w)}; } +[[nodiscard]] inline __device__ constexpr auto lc_make_byte4(lc_bool4 v) noexcept { return lc_byte4{static_cast(v.x), static_cast(v.y), static_cast(v.z), static_cast(v.w)}; } +[[nodiscard]] inline __device__ constexpr auto lc_make_byte4(lc_long4 v) noexcept { return lc_byte4{static_cast(v.x), static_cast(v.y), static_cast(v.z), static_cast(v.w)}; } +[[nodiscard]] inline __device__ constexpr auto lc_make_byte4(lc_ulong4 v) noexcept { return lc_byte4{static_cast(v.x), static_cast(v.y), static_cast(v.z), static_cast(v.w)}; } + +[[nodiscard]] __device__ inline constexpr auto lc_make_ubyte2(lc_ubyte s = 0) noexcept { return lc_ubyte2{s, s}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_ubyte2(lc_ubyte x, lc_ubyte y) noexcept { return lc_ubyte2{x, y}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_ubyte2(lc_byte2 v) noexcept { return lc_ubyte2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_ubyte2(lc_byte3 v) noexcept { return lc_ubyte2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_ubyte2(lc_byte4 v) noexcept { return lc_ubyte2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_ubyte2(lc_ubyte2 v) noexcept { return lc_ubyte2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_ubyte2(lc_ubyte3 v) noexcept { return lc_ubyte2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_ubyte2(lc_ubyte4 v) noexcept { return lc_ubyte2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_ubyte2(lc_short2 v) noexcept { return lc_ubyte2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_ubyte2(lc_short3 v) noexcept { return lc_ubyte2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_ubyte2(lc_short4 v) noexcept { return lc_ubyte2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_ubyte2(lc_ushort2 v) noexcept { return lc_ubyte2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_ubyte2(lc_ushort3 v) noexcept { return lc_ubyte2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_ubyte2(lc_ushort4 v) noexcept { return lc_ubyte2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_ubyte2(lc_int2 v) noexcept { return lc_ubyte2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_ubyte2(lc_int3 v) noexcept { return lc_ubyte2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_ubyte2(lc_int4 v) noexcept { return lc_ubyte2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_ubyte2(lc_uint2 v) noexcept { return lc_ubyte2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_ubyte2(lc_uint3 v) noexcept { return lc_ubyte2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_ubyte2(lc_uint4 v) noexcept { return lc_ubyte2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_ubyte2(lc_half2 v) noexcept { return lc_ubyte2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_ubyte2(lc_half3 v) noexcept { return lc_ubyte2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_ubyte2(lc_half4 v) noexcept { return lc_ubyte2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_ubyte2(lc_float2 v) noexcept { return lc_ubyte2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_ubyte2(lc_float3 v) noexcept { return lc_ubyte2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_ubyte2(lc_float4 v) noexcept { return lc_ubyte2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_ubyte2(lc_bool2 v) noexcept { return lc_ubyte2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_ubyte2(lc_bool3 v) noexcept { return lc_ubyte2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_ubyte2(lc_bool4 v) noexcept { return lc_ubyte2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_ubyte2(lc_long2 v) noexcept { return lc_ubyte2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_ubyte2(lc_long3 v) noexcept { return lc_ubyte2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_ubyte2(lc_long4 v) noexcept { return lc_ubyte2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_ubyte2(lc_ulong2 v) noexcept { return lc_ubyte2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_ubyte2(lc_ulong3 v) noexcept { return lc_ubyte2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_ubyte2(lc_ulong4 v) noexcept { return lc_ubyte2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] inline __device__ constexpr auto lc_make_ubyte3(lc_ubyte s = 0) noexcept { return lc_ubyte3{s, s, s}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_ubyte3(lc_ubyte x, lc_ubyte y, lc_ubyte z) noexcept { return lc_ubyte3{x, y, z}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_ubyte3(lc_ubyte x, lc_ubyte2 yz) noexcept { return lc_ubyte3{x, yz.x, yz.y}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_ubyte3(lc_ubyte2 xy, lc_ubyte z) noexcept { return lc_ubyte3{xy.x, xy.y, z}; } +[[nodiscard]] __device__ constexpr auto lc_make_ubyte3(lc_byte3 v) noexcept { return lc_ubyte3{static_cast(v.x), static_cast(v.y), static_cast(v.z)}; } +[[nodiscard]] __device__ constexpr auto lc_make_ubyte3(lc_byte4 v) noexcept { return lc_ubyte3{static_cast(v.x), static_cast(v.y), static_cast(v.z)}; } +[[nodiscard]] __device__ constexpr auto lc_make_ubyte3(lc_ubyte3 v) noexcept { return lc_ubyte3{static_cast(v.x), static_cast(v.y), static_cast(v.z)}; } +[[nodiscard]] __device__ constexpr auto lc_make_ubyte3(lc_ubyte4 v) noexcept { return lc_ubyte3{static_cast(v.x), static_cast(v.y), static_cast(v.z)}; } +[[nodiscard]] __device__ constexpr auto lc_make_ubyte3(lc_short3 v) noexcept { return lc_ubyte3{static_cast(v.x), static_cast(v.y), static_cast(v.z)}; } +[[nodiscard]] __device__ constexpr auto lc_make_ubyte3(lc_short4 v) noexcept { return lc_ubyte3{static_cast(v.x), static_cast(v.y), static_cast(v.z)}; } +[[nodiscard]] __device__ constexpr auto lc_make_ubyte3(lc_ushort3 v) noexcept { return lc_ubyte3{static_cast(v.x), static_cast(v.y), static_cast(v.z)}; } +[[nodiscard]] __device__ constexpr auto lc_make_ubyte3(lc_ushort4 v) noexcept { return lc_ubyte3{static_cast(v.x), static_cast(v.y), static_cast(v.z)}; } +[[nodiscard]] __device__ constexpr auto lc_make_ubyte3(lc_int3 v) noexcept { return lc_ubyte3{static_cast(v.x), static_cast(v.y), static_cast(v.z)}; } +[[nodiscard]] __device__ constexpr auto lc_make_ubyte3(lc_int4 v) noexcept { return lc_ubyte3{static_cast(v.x), static_cast(v.y), static_cast(v.z)}; } +[[nodiscard]] __device__ constexpr auto lc_make_ubyte3(lc_uint3 v) noexcept { return lc_ubyte3{static_cast(v.x), static_cast(v.y), static_cast(v.z)}; } +[[nodiscard]] __device__ constexpr auto lc_make_ubyte3(lc_uint4 v) noexcept { return lc_ubyte3{static_cast(v.x), static_cast(v.y), static_cast(v.z)}; } +[[nodiscard]] __device__ constexpr auto lc_make_ubyte3(lc_half3 v) noexcept { return lc_ubyte3{static_cast(v.x), static_cast(v.y), static_cast(v.z)}; } +[[nodiscard]] __device__ constexpr auto lc_make_ubyte3(lc_half4 v) noexcept { return lc_ubyte3{static_cast(v.x), static_cast(v.y), static_cast(v.z)}; } +[[nodiscard]] __device__ constexpr auto lc_make_ubyte3(lc_float3 v) noexcept { return lc_ubyte3{static_cast(v.x), static_cast(v.y), static_cast(v.z)}; } +[[nodiscard]] __device__ constexpr auto lc_make_ubyte3(lc_float4 v) noexcept { return lc_ubyte3{static_cast(v.x), static_cast(v.y), static_cast(v.z)}; } +[[nodiscard]] __device__ constexpr auto lc_make_ubyte3(lc_bool3 v) noexcept { return lc_ubyte3{static_cast(v.x), static_cast(v.y), static_cast(v.z)}; } +[[nodiscard]] __device__ constexpr auto lc_make_ubyte3(lc_bool4 v) noexcept { return lc_ubyte3{static_cast(v.x), static_cast(v.y), static_cast(v.z)}; } +[[nodiscard]] __device__ constexpr auto lc_make_ubyte3(lc_long3 v) noexcept { return lc_ubyte3{static_cast(v.x), static_cast(v.y), static_cast(v.z)}; } +[[nodiscard]] __device__ constexpr auto lc_make_ubyte3(lc_long4 v) noexcept { return lc_ubyte3{static_cast(v.x), static_cast(v.y), static_cast(v.z)}; } +[[nodiscard]] __device__ constexpr auto lc_make_ubyte3(lc_ulong3 v) noexcept { return lc_ubyte3{static_cast(v.x), static_cast(v.y), static_cast(v.z)}; } +[[nodiscard]] __device__ constexpr auto lc_make_ubyte3(lc_ulong4 v) noexcept { return lc_ubyte3{static_cast(v.x), static_cast(v.y), static_cast(v.z)}; } +[[nodiscard]] inline __device__ constexpr auto lc_make_ubyte4(lc_ubyte s = 0) noexcept { return lc_ubyte4{s, s, s, s}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_ubyte4(lc_ubyte x, lc_ubyte y, lc_ubyte z, lc_ubyte w) noexcept { return lc_ubyte4{x, y, z, w}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_ubyte4(lc_ubyte x, lc_ubyte y, lc_ubyte2 zw) noexcept { return lc_ubyte4{x, y, zw.x, zw.y}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_ubyte4(lc_ubyte x, lc_ubyte2 yz, lc_ubyte w) noexcept { return lc_ubyte4{x, yz.x, yz.y, w}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_ubyte4(lc_ubyte2 xy, lc_ubyte z, lc_ubyte w) noexcept { return lc_ubyte4{xy.x, xy.y, z, w}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_ubyte4(lc_ubyte2 xy, lc_ubyte2 zw) noexcept { return lc_ubyte4{xy.x, xy.y, zw.x, zw.y}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_ubyte4(lc_ubyte x, lc_ubyte3 yzw) noexcept { return lc_ubyte4{x, yzw.x, yzw.y, yzw.z}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_ubyte4(lc_ubyte3 xyz, lc_ubyte w) noexcept { return lc_ubyte4{xyz.x, xyz.y, xyz.z, w}; } +[[nodiscard]] inline __device__ constexpr auto lc_make_ubyte4(lc_byte4 v) noexcept { return lc_ubyte4{static_cast(v.x), static_cast(v.y), static_cast(v.z), static_cast(v.w)}; } +[[nodiscard]] inline __device__ constexpr auto lc_make_ubyte4(lc_ubyte4 v) noexcept { return lc_ubyte4{static_cast(v.x), static_cast(v.y), static_cast(v.z), static_cast(v.w)}; } +[[nodiscard]] inline __device__ constexpr auto lc_make_ubyte4(lc_short4 v) noexcept { return lc_ubyte4{static_cast(v.x), static_cast(v.y), static_cast(v.z), static_cast(v.w)}; } +[[nodiscard]] inline __device__ constexpr auto lc_make_ubyte4(lc_ushort4 v) noexcept { return lc_ubyte4{static_cast(v.x), static_cast(v.y), static_cast(v.z), static_cast(v.w)}; } +[[nodiscard]] inline __device__ constexpr auto lc_make_ubyte4(lc_int4 v) noexcept { return lc_ubyte4{static_cast(v.x), static_cast(v.y), static_cast(v.z), static_cast(v.w)}; } +[[nodiscard]] inline __device__ constexpr auto lc_make_ubyte4(lc_uint4 v) noexcept { return lc_ubyte4{static_cast(v.x), static_cast(v.y), static_cast(v.z), static_cast(v.w)}; } +[[nodiscard]] inline __device__ constexpr auto lc_make_ubyte4(lc_half4 v) noexcept { return lc_ubyte4{static_cast(v.x), static_cast(v.y), static_cast(v.z), static_cast(v.w)}; } +[[nodiscard]] inline __device__ constexpr auto lc_make_ubyte4(lc_float4 v) noexcept { return lc_ubyte4{static_cast(v.x), static_cast(v.y), static_cast(v.z), static_cast(v.w)}; } +[[nodiscard]] inline __device__ constexpr auto lc_make_ubyte4(lc_bool4 v) noexcept { return lc_ubyte4{static_cast(v.x), static_cast(v.y), static_cast(v.z), static_cast(v.w)}; } +[[nodiscard]] inline __device__ constexpr auto lc_make_ubyte4(lc_long4 v) noexcept { return lc_ubyte4{static_cast(v.x), static_cast(v.y), static_cast(v.z), static_cast(v.w)}; } +[[nodiscard]] inline __device__ constexpr auto lc_make_ubyte4(lc_ulong4 v) noexcept { return lc_ubyte4{static_cast(v.x), static_cast(v.y), static_cast(v.z), static_cast(v.w)}; } + +[[nodiscard]] __device__ inline constexpr auto lc_make_short2(lc_short s = 0) noexcept { return lc_short2{s, s}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_short2(lc_short x, lc_short y) noexcept { return lc_short2{x, y}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_short2(lc_byte2 v) noexcept { return lc_short2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_short2(lc_byte3 v) noexcept { return lc_short2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_short2(lc_byte4 v) noexcept { return lc_short2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_short2(lc_ubyte2 v) noexcept { return lc_short2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_short2(lc_ubyte3 v) noexcept { return lc_short2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_short2(lc_ubyte4 v) noexcept { return lc_short2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_short2(lc_short2 v) noexcept { return lc_short2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_short2(lc_short3 v) noexcept { return lc_short2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_short2(lc_short4 v) noexcept { return lc_short2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_short2(lc_ushort2 v) noexcept { return lc_short2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_short2(lc_ushort3 v) noexcept { return lc_short2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_short2(lc_ushort4 v) noexcept { return lc_short2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_short2(lc_int2 v) noexcept { return lc_short2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_short2(lc_int3 v) noexcept { return lc_short2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_short2(lc_int4 v) noexcept { return lc_short2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_short2(lc_uint2 v) noexcept { return lc_short2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_short2(lc_uint3 v) noexcept { return lc_short2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_short2(lc_uint4 v) noexcept { return lc_short2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_short2(lc_half2 v) noexcept { return lc_short2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_short2(lc_half3 v) noexcept { return lc_short2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_short2(lc_half4 v) noexcept { return lc_short2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_short2(lc_float2 v) noexcept { return lc_short2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_short2(lc_float3 v) noexcept { return lc_short2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_short2(lc_float4 v) noexcept { return lc_short2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_short2(lc_bool2 v) noexcept { return lc_short2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_short2(lc_bool3 v) noexcept { return lc_short2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_short2(lc_bool4 v) noexcept { return lc_short2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_short2(lc_long2 v) noexcept { return lc_short2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_short2(lc_long3 v) noexcept { return lc_short2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_short2(lc_long4 v) noexcept { return lc_short2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_short2(lc_ulong2 v) noexcept { return lc_short2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_short2(lc_ulong3 v) noexcept { return lc_short2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_short2(lc_ulong4 v) noexcept { return lc_short2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] inline __device__ constexpr auto lc_make_short3(lc_short s = 0) noexcept { return lc_short3{s, s, s}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_short3(lc_short x, lc_short y, lc_short z) noexcept { return lc_short3{x, y, z}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_short3(lc_short x, lc_short2 yz) noexcept { return lc_short3{x, yz.x, yz.y}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_short3(lc_short2 xy, lc_short z) noexcept { return lc_short3{xy.x, xy.y, z}; } +[[nodiscard]] __device__ constexpr auto lc_make_short3(lc_byte3 v) noexcept { return lc_short3{static_cast(v.x), static_cast(v.y), static_cast(v.z)}; } +[[nodiscard]] __device__ constexpr auto lc_make_short3(lc_byte4 v) noexcept { return lc_short3{static_cast(v.x), static_cast(v.y), static_cast(v.z)}; } +[[nodiscard]] __device__ constexpr auto lc_make_short3(lc_ubyte3 v) noexcept { return lc_short3{static_cast(v.x), static_cast(v.y), static_cast(v.z)}; } +[[nodiscard]] __device__ constexpr auto lc_make_short3(lc_ubyte4 v) noexcept { return lc_short3{static_cast(v.x), static_cast(v.y), static_cast(v.z)}; } +[[nodiscard]] __device__ constexpr auto lc_make_short3(lc_short3 v) noexcept { return lc_short3{static_cast(v.x), static_cast(v.y), static_cast(v.z)}; } +[[nodiscard]] __device__ constexpr auto lc_make_short3(lc_short4 v) noexcept { return lc_short3{static_cast(v.x), static_cast(v.y), static_cast(v.z)}; } +[[nodiscard]] __device__ constexpr auto lc_make_short3(lc_ushort3 v) noexcept { return lc_short3{static_cast(v.x), static_cast(v.y), static_cast(v.z)}; } +[[nodiscard]] __device__ constexpr auto lc_make_short3(lc_ushort4 v) noexcept { return lc_short3{static_cast(v.x), static_cast(v.y), static_cast(v.z)}; } +[[nodiscard]] __device__ constexpr auto lc_make_short3(lc_int3 v) noexcept { return lc_short3{static_cast(v.x), static_cast(v.y), static_cast(v.z)}; } +[[nodiscard]] __device__ constexpr auto lc_make_short3(lc_int4 v) noexcept { return lc_short3{static_cast(v.x), static_cast(v.y), static_cast(v.z)}; } +[[nodiscard]] __device__ constexpr auto lc_make_short3(lc_uint3 v) noexcept { return lc_short3{static_cast(v.x), static_cast(v.y), static_cast(v.z)}; } +[[nodiscard]] __device__ constexpr auto lc_make_short3(lc_uint4 v) noexcept { return lc_short3{static_cast(v.x), static_cast(v.y), static_cast(v.z)}; } +[[nodiscard]] __device__ constexpr auto lc_make_short3(lc_half3 v) noexcept { return lc_short3{static_cast(v.x), static_cast(v.y), static_cast(v.z)}; } +[[nodiscard]] __device__ constexpr auto lc_make_short3(lc_half4 v) noexcept { return lc_short3{static_cast(v.x), static_cast(v.y), static_cast(v.z)}; } +[[nodiscard]] __device__ constexpr auto lc_make_short3(lc_float3 v) noexcept { return lc_short3{static_cast(v.x), static_cast(v.y), static_cast(v.z)}; } +[[nodiscard]] __device__ constexpr auto lc_make_short3(lc_float4 v) noexcept { return lc_short3{static_cast(v.x), static_cast(v.y), static_cast(v.z)}; } +[[nodiscard]] __device__ constexpr auto lc_make_short3(lc_bool3 v) noexcept { return lc_short3{static_cast(v.x), static_cast(v.y), static_cast(v.z)}; } +[[nodiscard]] __device__ constexpr auto lc_make_short3(lc_bool4 v) noexcept { return lc_short3{static_cast(v.x), static_cast(v.y), static_cast(v.z)}; } +[[nodiscard]] __device__ constexpr auto lc_make_short3(lc_long3 v) noexcept { return lc_short3{static_cast(v.x), static_cast(v.y), static_cast(v.z)}; } +[[nodiscard]] __device__ constexpr auto lc_make_short3(lc_long4 v) noexcept { return lc_short3{static_cast(v.x), static_cast(v.y), static_cast(v.z)}; } +[[nodiscard]] __device__ constexpr auto lc_make_short3(lc_ulong3 v) noexcept { return lc_short3{static_cast(v.x), static_cast(v.y), static_cast(v.z)}; } +[[nodiscard]] __device__ constexpr auto lc_make_short3(lc_ulong4 v) noexcept { return lc_short3{static_cast(v.x), static_cast(v.y), static_cast(v.z)}; } +[[nodiscard]] inline __device__ constexpr auto lc_make_short4(lc_short s = 0) noexcept { return lc_short4{s, s, s, s}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_short4(lc_short x, lc_short y, lc_short z, lc_short w) noexcept { return lc_short4{x, y, z, w}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_short4(lc_short x, lc_short y, lc_short2 zw) noexcept { return lc_short4{x, y, zw.x, zw.y}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_short4(lc_short x, lc_short2 yz, lc_short w) noexcept { return lc_short4{x, yz.x, yz.y, w}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_short4(lc_short2 xy, lc_short z, lc_short w) noexcept { return lc_short4{xy.x, xy.y, z, w}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_short4(lc_short2 xy, lc_short2 zw) noexcept { return lc_short4{xy.x, xy.y, zw.x, zw.y}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_short4(lc_short x, lc_short3 yzw) noexcept { return lc_short4{x, yzw.x, yzw.y, yzw.z}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_short4(lc_short3 xyz, lc_short w) noexcept { return lc_short4{xyz.x, xyz.y, xyz.z, w}; } +[[nodiscard]] inline __device__ constexpr auto lc_make_short4(lc_byte4 v) noexcept { return lc_short4{static_cast(v.x), static_cast(v.y), static_cast(v.z), static_cast(v.w)}; } +[[nodiscard]] inline __device__ constexpr auto lc_make_short4(lc_ubyte4 v) noexcept { return lc_short4{static_cast(v.x), static_cast(v.y), static_cast(v.z), static_cast(v.w)}; } +[[nodiscard]] inline __device__ constexpr auto lc_make_short4(lc_short4 v) noexcept { return lc_short4{static_cast(v.x), static_cast(v.y), static_cast(v.z), static_cast(v.w)}; } +[[nodiscard]] inline __device__ constexpr auto lc_make_short4(lc_ushort4 v) noexcept { return lc_short4{static_cast(v.x), static_cast(v.y), static_cast(v.z), static_cast(v.w)}; } +[[nodiscard]] inline __device__ constexpr auto lc_make_short4(lc_int4 v) noexcept { return lc_short4{static_cast(v.x), static_cast(v.y), static_cast(v.z), static_cast(v.w)}; } +[[nodiscard]] inline __device__ constexpr auto lc_make_short4(lc_uint4 v) noexcept { return lc_short4{static_cast(v.x), static_cast(v.y), static_cast(v.z), static_cast(v.w)}; } +[[nodiscard]] inline __device__ constexpr auto lc_make_short4(lc_half4 v) noexcept { return lc_short4{static_cast(v.x), static_cast(v.y), static_cast(v.z), static_cast(v.w)}; } +[[nodiscard]] inline __device__ constexpr auto lc_make_short4(lc_float4 v) noexcept { return lc_short4{static_cast(v.x), static_cast(v.y), static_cast(v.z), static_cast(v.w)}; } +[[nodiscard]] inline __device__ constexpr auto lc_make_short4(lc_bool4 v) noexcept { return lc_short4{static_cast(v.x), static_cast(v.y), static_cast(v.z), static_cast(v.w)}; } +[[nodiscard]] inline __device__ constexpr auto lc_make_short4(lc_long4 v) noexcept { return lc_short4{static_cast(v.x), static_cast(v.y), static_cast(v.z), static_cast(v.w)}; } +[[nodiscard]] inline __device__ constexpr auto lc_make_short4(lc_ulong4 v) noexcept { return lc_short4{static_cast(v.x), static_cast(v.y), static_cast(v.z), static_cast(v.w)}; } + +[[nodiscard]] __device__ inline constexpr auto lc_make_ushort2(lc_ushort s = 0) noexcept { return lc_ushort2{s, s}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_ushort2(lc_ushort x, lc_ushort y) noexcept { return lc_ushort2{x, y}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_ushort2(lc_byte2 v) noexcept { return lc_ushort2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_ushort2(lc_byte3 v) noexcept { return lc_ushort2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_ushort2(lc_byte4 v) noexcept { return lc_ushort2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_ushort2(lc_ubyte2 v) noexcept { return lc_ushort2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_ushort2(lc_ubyte3 v) noexcept { return lc_ushort2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_ushort2(lc_ubyte4 v) noexcept { return lc_ushort2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_ushort2(lc_short2 v) noexcept { return lc_ushort2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_ushort2(lc_short3 v) noexcept { return lc_ushort2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_ushort2(lc_short4 v) noexcept { return lc_ushort2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_ushort2(lc_ushort2 v) noexcept { return lc_ushort2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_ushort2(lc_ushort3 v) noexcept { return lc_ushort2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_ushort2(lc_ushort4 v) noexcept { return lc_ushort2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_ushort2(lc_int2 v) noexcept { return lc_ushort2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_ushort2(lc_int3 v) noexcept { return lc_ushort2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_ushort2(lc_int4 v) noexcept { return lc_ushort2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_ushort2(lc_uint2 v) noexcept { return lc_ushort2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_ushort2(lc_uint3 v) noexcept { return lc_ushort2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_ushort2(lc_uint4 v) noexcept { return lc_ushort2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_ushort2(lc_half2 v) noexcept { return lc_ushort2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_ushort2(lc_half3 v) noexcept { return lc_ushort2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_ushort2(lc_half4 v) noexcept { return lc_ushort2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_ushort2(lc_float2 v) noexcept { return lc_ushort2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_ushort2(lc_float3 v) noexcept { return lc_ushort2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_ushort2(lc_float4 v) noexcept { return lc_ushort2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_ushort2(lc_bool2 v) noexcept { return lc_ushort2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_ushort2(lc_bool3 v) noexcept { return lc_ushort2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_ushort2(lc_bool4 v) noexcept { return lc_ushort2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_ushort2(lc_long2 v) noexcept { return lc_ushort2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_ushort2(lc_long3 v) noexcept { return lc_ushort2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_ushort2(lc_long4 v) noexcept { return lc_ushort2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_ushort2(lc_ulong2 v) noexcept { return lc_ushort2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_ushort2(lc_ulong3 v) noexcept { return lc_ushort2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_ushort2(lc_ulong4 v) noexcept { return lc_ushort2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] inline __device__ constexpr auto lc_make_ushort3(lc_ushort s = 0) noexcept { return lc_ushort3{s, s, s}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_ushort3(lc_ushort x, lc_ushort y, lc_ushort z) noexcept { return lc_ushort3{x, y, z}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_ushort3(lc_ushort x, lc_ushort2 yz) noexcept { return lc_ushort3{x, yz.x, yz.y}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_ushort3(lc_ushort2 xy, lc_ushort z) noexcept { return lc_ushort3{xy.x, xy.y, z}; } +[[nodiscard]] __device__ constexpr auto lc_make_ushort3(lc_byte3 v) noexcept { return lc_ushort3{static_cast(v.x), static_cast(v.y), static_cast(v.z)}; } +[[nodiscard]] __device__ constexpr auto lc_make_ushort3(lc_byte4 v) noexcept { return lc_ushort3{static_cast(v.x), static_cast(v.y), static_cast(v.z)}; } +[[nodiscard]] __device__ constexpr auto lc_make_ushort3(lc_ubyte3 v) noexcept { return lc_ushort3{static_cast(v.x), static_cast(v.y), static_cast(v.z)}; } +[[nodiscard]] __device__ constexpr auto lc_make_ushort3(lc_ubyte4 v) noexcept { return lc_ushort3{static_cast(v.x), static_cast(v.y), static_cast(v.z)}; } +[[nodiscard]] __device__ constexpr auto lc_make_ushort3(lc_short3 v) noexcept { return lc_ushort3{static_cast(v.x), static_cast(v.y), static_cast(v.z)}; } +[[nodiscard]] __device__ constexpr auto lc_make_ushort3(lc_short4 v) noexcept { return lc_ushort3{static_cast(v.x), static_cast(v.y), static_cast(v.z)}; } +[[nodiscard]] __device__ constexpr auto lc_make_ushort3(lc_ushort3 v) noexcept { return lc_ushort3{static_cast(v.x), static_cast(v.y), static_cast(v.z)}; } +[[nodiscard]] __device__ constexpr auto lc_make_ushort3(lc_ushort4 v) noexcept { return lc_ushort3{static_cast(v.x), static_cast(v.y), static_cast(v.z)}; } +[[nodiscard]] __device__ constexpr auto lc_make_ushort3(lc_int3 v) noexcept { return lc_ushort3{static_cast(v.x), static_cast(v.y), static_cast(v.z)}; } +[[nodiscard]] __device__ constexpr auto lc_make_ushort3(lc_int4 v) noexcept { return lc_ushort3{static_cast(v.x), static_cast(v.y), static_cast(v.z)}; } +[[nodiscard]] __device__ constexpr auto lc_make_ushort3(lc_uint3 v) noexcept { return lc_ushort3{static_cast(v.x), static_cast(v.y), static_cast(v.z)}; } +[[nodiscard]] __device__ constexpr auto lc_make_ushort3(lc_uint4 v) noexcept { return lc_ushort3{static_cast(v.x), static_cast(v.y), static_cast(v.z)}; } +[[nodiscard]] __device__ constexpr auto lc_make_ushort3(lc_half3 v) noexcept { return lc_ushort3{static_cast(v.x), static_cast(v.y), static_cast(v.z)}; } +[[nodiscard]] __device__ constexpr auto lc_make_ushort3(lc_half4 v) noexcept { return lc_ushort3{static_cast(v.x), static_cast(v.y), static_cast(v.z)}; } +[[nodiscard]] __device__ constexpr auto lc_make_ushort3(lc_float3 v) noexcept { return lc_ushort3{static_cast(v.x), static_cast(v.y), static_cast(v.z)}; } +[[nodiscard]] __device__ constexpr auto lc_make_ushort3(lc_float4 v) noexcept { return lc_ushort3{static_cast(v.x), static_cast(v.y), static_cast(v.z)}; } +[[nodiscard]] __device__ constexpr auto lc_make_ushort3(lc_bool3 v) noexcept { return lc_ushort3{static_cast(v.x), static_cast(v.y), static_cast(v.z)}; } +[[nodiscard]] __device__ constexpr auto lc_make_ushort3(lc_bool4 v) noexcept { return lc_ushort3{static_cast(v.x), static_cast(v.y), static_cast(v.z)}; } +[[nodiscard]] __device__ constexpr auto lc_make_ushort3(lc_long3 v) noexcept { return lc_ushort3{static_cast(v.x), static_cast(v.y), static_cast(v.z)}; } +[[nodiscard]] __device__ constexpr auto lc_make_ushort3(lc_long4 v) noexcept { return lc_ushort3{static_cast(v.x), static_cast(v.y), static_cast(v.z)}; } +[[nodiscard]] __device__ constexpr auto lc_make_ushort3(lc_ulong3 v) noexcept { return lc_ushort3{static_cast(v.x), static_cast(v.y), static_cast(v.z)}; } +[[nodiscard]] __device__ constexpr auto lc_make_ushort3(lc_ulong4 v) noexcept { return lc_ushort3{static_cast(v.x), static_cast(v.y), static_cast(v.z)}; } +[[nodiscard]] inline __device__ constexpr auto lc_make_ushort4(lc_ushort s = 0) noexcept { return lc_ushort4{s, s, s, s}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_ushort4(lc_ushort x, lc_ushort y, lc_ushort z, lc_ushort w) noexcept { return lc_ushort4{x, y, z, w}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_ushort4(lc_ushort x, lc_ushort y, lc_ushort2 zw) noexcept { return lc_ushort4{x, y, zw.x, zw.y}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_ushort4(lc_ushort x, lc_ushort2 yz, lc_ushort w) noexcept { return lc_ushort4{x, yz.x, yz.y, w}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_ushort4(lc_ushort2 xy, lc_ushort z, lc_ushort w) noexcept { return lc_ushort4{xy.x, xy.y, z, w}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_ushort4(lc_ushort2 xy, lc_ushort2 zw) noexcept { return lc_ushort4{xy.x, xy.y, zw.x, zw.y}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_ushort4(lc_ushort x, lc_ushort3 yzw) noexcept { return lc_ushort4{x, yzw.x, yzw.y, yzw.z}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_ushort4(lc_ushort3 xyz, lc_ushort w) noexcept { return lc_ushort4{xyz.x, xyz.y, xyz.z, w}; } +[[nodiscard]] inline __device__ constexpr auto lc_make_ushort4(lc_byte4 v) noexcept { return lc_ushort4{static_cast(v.x), static_cast(v.y), static_cast(v.z), static_cast(v.w)}; } +[[nodiscard]] inline __device__ constexpr auto lc_make_ushort4(lc_ubyte4 v) noexcept { return lc_ushort4{static_cast(v.x), static_cast(v.y), static_cast(v.z), static_cast(v.w)}; } +[[nodiscard]] inline __device__ constexpr auto lc_make_ushort4(lc_short4 v) noexcept { return lc_ushort4{static_cast(v.x), static_cast(v.y), static_cast(v.z), static_cast(v.w)}; } +[[nodiscard]] inline __device__ constexpr auto lc_make_ushort4(lc_ushort4 v) noexcept { return lc_ushort4{static_cast(v.x), static_cast(v.y), static_cast(v.z), static_cast(v.w)}; } +[[nodiscard]] inline __device__ constexpr auto lc_make_ushort4(lc_int4 v) noexcept { return lc_ushort4{static_cast(v.x), static_cast(v.y), static_cast(v.z), static_cast(v.w)}; } +[[nodiscard]] inline __device__ constexpr auto lc_make_ushort4(lc_uint4 v) noexcept { return lc_ushort4{static_cast(v.x), static_cast(v.y), static_cast(v.z), static_cast(v.w)}; } +[[nodiscard]] inline __device__ constexpr auto lc_make_ushort4(lc_half4 v) noexcept { return lc_ushort4{static_cast(v.x), static_cast(v.y), static_cast(v.z), static_cast(v.w)}; } +[[nodiscard]] inline __device__ constexpr auto lc_make_ushort4(lc_float4 v) noexcept { return lc_ushort4{static_cast(v.x), static_cast(v.y), static_cast(v.z), static_cast(v.w)}; } +[[nodiscard]] inline __device__ constexpr auto lc_make_ushort4(lc_bool4 v) noexcept { return lc_ushort4{static_cast(v.x), static_cast(v.y), static_cast(v.z), static_cast(v.w)}; } +[[nodiscard]] inline __device__ constexpr auto lc_make_ushort4(lc_long4 v) noexcept { return lc_ushort4{static_cast(v.x), static_cast(v.y), static_cast(v.z), static_cast(v.w)}; } +[[nodiscard]] inline __device__ constexpr auto lc_make_ushort4(lc_ulong4 v) noexcept { return lc_ushort4{static_cast(v.x), static_cast(v.y), static_cast(v.z), static_cast(v.w)}; } + +[[nodiscard]] __device__ inline constexpr auto lc_make_int2(lc_int s = 0) noexcept { return lc_int2{s, s}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_int2(lc_int x, lc_int y) noexcept { return lc_int2{x, y}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_int2(lc_byte2 v) noexcept { return lc_int2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_int2(lc_byte3 v) noexcept { return lc_int2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_int2(lc_byte4 v) noexcept { return lc_int2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_int2(lc_ubyte2 v) noexcept { return lc_int2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_int2(lc_ubyte3 v) noexcept { return lc_int2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_int2(lc_ubyte4 v) noexcept { return lc_int2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_int2(lc_short2 v) noexcept { return lc_int2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_int2(lc_short3 v) noexcept { return lc_int2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_int2(lc_short4 v) noexcept { return lc_int2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_int2(lc_ushort2 v) noexcept { return lc_int2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_int2(lc_ushort3 v) noexcept { return lc_int2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_int2(lc_ushort4 v) noexcept { return lc_int2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_int2(lc_int2 v) noexcept { return lc_int2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_int2(lc_int3 v) noexcept { return lc_int2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_int2(lc_int4 v) noexcept { return lc_int2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_int2(lc_uint2 v) noexcept { return lc_int2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_int2(lc_uint3 v) noexcept { return lc_int2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_int2(lc_uint4 v) noexcept { return lc_int2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_int2(lc_half2 v) noexcept { return lc_int2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_int2(lc_half3 v) noexcept { return lc_int2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_int2(lc_half4 v) noexcept { return lc_int2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_int2(lc_float2 v) noexcept { return lc_int2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_int2(lc_float3 v) noexcept { return lc_int2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_int2(lc_float4 v) noexcept { return lc_int2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_int2(lc_bool2 v) noexcept { return lc_int2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_int2(lc_bool3 v) noexcept { return lc_int2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_int2(lc_bool4 v) noexcept { return lc_int2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_int2(lc_long2 v) noexcept { return lc_int2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_int2(lc_long3 v) noexcept { return lc_int2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_int2(lc_long4 v) noexcept { return lc_int2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_int2(lc_ulong2 v) noexcept { return lc_int2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_int2(lc_ulong3 v) noexcept { return lc_int2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_int2(lc_ulong4 v) noexcept { return lc_int2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] inline __device__ constexpr auto lc_make_int3(lc_int s = 0) noexcept { return lc_int3{s, s, s}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_int3(lc_int x, lc_int y, lc_int z) noexcept { return lc_int3{x, y, z}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_int3(lc_int x, lc_int2 yz) noexcept { return lc_int3{x, yz.x, yz.y}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_int3(lc_int2 xy, lc_int z) noexcept { return lc_int3{xy.x, xy.y, z}; } +[[nodiscard]] __device__ constexpr auto lc_make_int3(lc_byte3 v) noexcept { return lc_int3{static_cast(v.x), static_cast(v.y), static_cast(v.z)}; } +[[nodiscard]] __device__ constexpr auto lc_make_int3(lc_byte4 v) noexcept { return lc_int3{static_cast(v.x), static_cast(v.y), static_cast(v.z)}; } +[[nodiscard]] __device__ constexpr auto lc_make_int3(lc_ubyte3 v) noexcept { return lc_int3{static_cast(v.x), static_cast(v.y), static_cast(v.z)}; } +[[nodiscard]] __device__ constexpr auto lc_make_int3(lc_ubyte4 v) noexcept { return lc_int3{static_cast(v.x), static_cast(v.y), static_cast(v.z)}; } +[[nodiscard]] __device__ constexpr auto lc_make_int3(lc_short3 v) noexcept { return lc_int3{static_cast(v.x), static_cast(v.y), static_cast(v.z)}; } +[[nodiscard]] __device__ constexpr auto lc_make_int3(lc_short4 v) noexcept { return lc_int3{static_cast(v.x), static_cast(v.y), static_cast(v.z)}; } +[[nodiscard]] __device__ constexpr auto lc_make_int3(lc_ushort3 v) noexcept { return lc_int3{static_cast(v.x), static_cast(v.y), static_cast(v.z)}; } +[[nodiscard]] __device__ constexpr auto lc_make_int3(lc_ushort4 v) noexcept { return lc_int3{static_cast(v.x), static_cast(v.y), static_cast(v.z)}; } +[[nodiscard]] __device__ constexpr auto lc_make_int3(lc_int3 v) noexcept { return lc_int3{static_cast(v.x), static_cast(v.y), static_cast(v.z)}; } +[[nodiscard]] __device__ constexpr auto lc_make_int3(lc_int4 v) noexcept { return lc_int3{static_cast(v.x), static_cast(v.y), static_cast(v.z)}; } +[[nodiscard]] __device__ constexpr auto lc_make_int3(lc_uint3 v) noexcept { return lc_int3{static_cast(v.x), static_cast(v.y), static_cast(v.z)}; } +[[nodiscard]] __device__ constexpr auto lc_make_int3(lc_uint4 v) noexcept { return lc_int3{static_cast(v.x), static_cast(v.y), static_cast(v.z)}; } +[[nodiscard]] __device__ constexpr auto lc_make_int3(lc_half3 v) noexcept { return lc_int3{static_cast(v.x), static_cast(v.y), static_cast(v.z)}; } +[[nodiscard]] __device__ constexpr auto lc_make_int3(lc_half4 v) noexcept { return lc_int3{static_cast(v.x), static_cast(v.y), static_cast(v.z)}; } +[[nodiscard]] __device__ constexpr auto lc_make_int3(lc_float3 v) noexcept { return lc_int3{static_cast(v.x), static_cast(v.y), static_cast(v.z)}; } +[[nodiscard]] __device__ constexpr auto lc_make_int3(lc_float4 v) noexcept { return lc_int3{static_cast(v.x), static_cast(v.y), static_cast(v.z)}; } +[[nodiscard]] __device__ constexpr auto lc_make_int3(lc_bool3 v) noexcept { return lc_int3{static_cast(v.x), static_cast(v.y), static_cast(v.z)}; } +[[nodiscard]] __device__ constexpr auto lc_make_int3(lc_bool4 v) noexcept { return lc_int3{static_cast(v.x), static_cast(v.y), static_cast(v.z)}; } +[[nodiscard]] __device__ constexpr auto lc_make_int3(lc_long3 v) noexcept { return lc_int3{static_cast(v.x), static_cast(v.y), static_cast(v.z)}; } +[[nodiscard]] __device__ constexpr auto lc_make_int3(lc_long4 v) noexcept { return lc_int3{static_cast(v.x), static_cast(v.y), static_cast(v.z)}; } +[[nodiscard]] __device__ constexpr auto lc_make_int3(lc_ulong3 v) noexcept { return lc_int3{static_cast(v.x), static_cast(v.y), static_cast(v.z)}; } +[[nodiscard]] __device__ constexpr auto lc_make_int3(lc_ulong4 v) noexcept { return lc_int3{static_cast(v.x), static_cast(v.y), static_cast(v.z)}; } +[[nodiscard]] inline __device__ constexpr auto lc_make_int4(lc_int s = 0) noexcept { return lc_int4{s, s, s, s}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_int4(lc_int x, lc_int y, lc_int z, lc_int w) noexcept { return lc_int4{x, y, z, w}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_int4(lc_int x, lc_int y, lc_int2 zw) noexcept { return lc_int4{x, y, zw.x, zw.y}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_int4(lc_int x, lc_int2 yz, lc_int w) noexcept { return lc_int4{x, yz.x, yz.y, w}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_int4(lc_int2 xy, lc_int z, lc_int w) noexcept { return lc_int4{xy.x, xy.y, z, w}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_int4(lc_int2 xy, lc_int2 zw) noexcept { return lc_int4{xy.x, xy.y, zw.x, zw.y}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_int4(lc_int x, lc_int3 yzw) noexcept { return lc_int4{x, yzw.x, yzw.y, yzw.z}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_int4(lc_int3 xyz, lc_int w) noexcept { return lc_int4{xyz.x, xyz.y, xyz.z, w}; } +[[nodiscard]] inline __device__ constexpr auto lc_make_int4(lc_byte4 v) noexcept { return lc_int4{static_cast(v.x), static_cast(v.y), static_cast(v.z), static_cast(v.w)}; } +[[nodiscard]] inline __device__ constexpr auto lc_make_int4(lc_ubyte4 v) noexcept { return lc_int4{static_cast(v.x), static_cast(v.y), static_cast(v.z), static_cast(v.w)}; } +[[nodiscard]] inline __device__ constexpr auto lc_make_int4(lc_short4 v) noexcept { return lc_int4{static_cast(v.x), static_cast(v.y), static_cast(v.z), static_cast(v.w)}; } +[[nodiscard]] inline __device__ constexpr auto lc_make_int4(lc_ushort4 v) noexcept { return lc_int4{static_cast(v.x), static_cast(v.y), static_cast(v.z), static_cast(v.w)}; } +[[nodiscard]] inline __device__ constexpr auto lc_make_int4(lc_int4 v) noexcept { return lc_int4{static_cast(v.x), static_cast(v.y), static_cast(v.z), static_cast(v.w)}; } +[[nodiscard]] inline __device__ constexpr auto lc_make_int4(lc_uint4 v) noexcept { return lc_int4{static_cast(v.x), static_cast(v.y), static_cast(v.z), static_cast(v.w)}; } +[[nodiscard]] inline __device__ constexpr auto lc_make_int4(lc_half4 v) noexcept { return lc_int4{static_cast(v.x), static_cast(v.y), static_cast(v.z), static_cast(v.w)}; } +[[nodiscard]] inline __device__ constexpr auto lc_make_int4(lc_float4 v) noexcept { return lc_int4{static_cast(v.x), static_cast(v.y), static_cast(v.z), static_cast(v.w)}; } +[[nodiscard]] inline __device__ constexpr auto lc_make_int4(lc_bool4 v) noexcept { return lc_int4{static_cast(v.x), static_cast(v.y), static_cast(v.z), static_cast(v.w)}; } +[[nodiscard]] inline __device__ constexpr auto lc_make_int4(lc_long4 v) noexcept { return lc_int4{static_cast(v.x), static_cast(v.y), static_cast(v.z), static_cast(v.w)}; } +[[nodiscard]] inline __device__ constexpr auto lc_make_int4(lc_ulong4 v) noexcept { return lc_int4{static_cast(v.x), static_cast(v.y), static_cast(v.z), static_cast(v.w)}; } + +[[nodiscard]] __device__ inline constexpr auto lc_make_uint2(lc_uint s = 0) noexcept { return lc_uint2{s, s}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_uint2(lc_uint x, lc_uint y) noexcept { return lc_uint2{x, y}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_uint2(lc_byte2 v) noexcept { return lc_uint2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_uint2(lc_byte3 v) noexcept { return lc_uint2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_uint2(lc_byte4 v) noexcept { return lc_uint2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_uint2(lc_ubyte2 v) noexcept { return lc_uint2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_uint2(lc_ubyte3 v) noexcept { return lc_uint2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_uint2(lc_ubyte4 v) noexcept { return lc_uint2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_uint2(lc_short2 v) noexcept { return lc_uint2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_uint2(lc_short3 v) noexcept { return lc_uint2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_uint2(lc_short4 v) noexcept { return lc_uint2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_uint2(lc_ushort2 v) noexcept { return lc_uint2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_uint2(lc_ushort3 v) noexcept { return lc_uint2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_uint2(lc_ushort4 v) noexcept { return lc_uint2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_uint2(lc_int2 v) noexcept { return lc_uint2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_uint2(lc_int3 v) noexcept { return lc_uint2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_uint2(lc_int4 v) noexcept { return lc_uint2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_uint2(lc_uint2 v) noexcept { return lc_uint2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_uint2(lc_uint3 v) noexcept { return lc_uint2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_uint2(lc_uint4 v) noexcept { return lc_uint2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_uint2(lc_half2 v) noexcept { return lc_uint2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_uint2(lc_half3 v) noexcept { return lc_uint2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_uint2(lc_half4 v) noexcept { return lc_uint2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_uint2(lc_float2 v) noexcept { return lc_uint2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_uint2(lc_float3 v) noexcept { return lc_uint2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_uint2(lc_float4 v) noexcept { return lc_uint2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_uint2(lc_bool2 v) noexcept { return lc_uint2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_uint2(lc_bool3 v) noexcept { return lc_uint2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_uint2(lc_bool4 v) noexcept { return lc_uint2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_uint2(lc_long2 v) noexcept { return lc_uint2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_uint2(lc_long3 v) noexcept { return lc_uint2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_uint2(lc_long4 v) noexcept { return lc_uint2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_uint2(lc_ulong2 v) noexcept { return lc_uint2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_uint2(lc_ulong3 v) noexcept { return lc_uint2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_uint2(lc_ulong4 v) noexcept { return lc_uint2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] inline __device__ constexpr auto lc_make_uint3(lc_uint s = 0) noexcept { return lc_uint3{s, s, s}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_uint3(lc_uint x, lc_uint y, lc_uint z) noexcept { return lc_uint3{x, y, z}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_uint3(lc_uint x, lc_uint2 yz) noexcept { return lc_uint3{x, yz.x, yz.y}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_uint3(lc_uint2 xy, lc_uint z) noexcept { return lc_uint3{xy.x, xy.y, z}; } +[[nodiscard]] __device__ constexpr auto lc_make_uint3(lc_byte3 v) noexcept { return lc_uint3{static_cast(v.x), static_cast(v.y), static_cast(v.z)}; } +[[nodiscard]] __device__ constexpr auto lc_make_uint3(lc_byte4 v) noexcept { return lc_uint3{static_cast(v.x), static_cast(v.y), static_cast(v.z)}; } +[[nodiscard]] __device__ constexpr auto lc_make_uint3(lc_ubyte3 v) noexcept { return lc_uint3{static_cast(v.x), static_cast(v.y), static_cast(v.z)}; } +[[nodiscard]] __device__ constexpr auto lc_make_uint3(lc_ubyte4 v) noexcept { return lc_uint3{static_cast(v.x), static_cast(v.y), static_cast(v.z)}; } +[[nodiscard]] __device__ constexpr auto lc_make_uint3(lc_short3 v) noexcept { return lc_uint3{static_cast(v.x), static_cast(v.y), static_cast(v.z)}; } +[[nodiscard]] __device__ constexpr auto lc_make_uint3(lc_short4 v) noexcept { return lc_uint3{static_cast(v.x), static_cast(v.y), static_cast(v.z)}; } +[[nodiscard]] __device__ constexpr auto lc_make_uint3(lc_ushort3 v) noexcept { return lc_uint3{static_cast(v.x), static_cast(v.y), static_cast(v.z)}; } +[[nodiscard]] __device__ constexpr auto lc_make_uint3(lc_ushort4 v) noexcept { return lc_uint3{static_cast(v.x), static_cast(v.y), static_cast(v.z)}; } +[[nodiscard]] __device__ constexpr auto lc_make_uint3(lc_int3 v) noexcept { return lc_uint3{static_cast(v.x), static_cast(v.y), static_cast(v.z)}; } +[[nodiscard]] __device__ constexpr auto lc_make_uint3(lc_int4 v) noexcept { return lc_uint3{static_cast(v.x), static_cast(v.y), static_cast(v.z)}; } +[[nodiscard]] __device__ constexpr auto lc_make_uint3(lc_uint3 v) noexcept { return lc_uint3{static_cast(v.x), static_cast(v.y), static_cast(v.z)}; } +[[nodiscard]] __device__ constexpr auto lc_make_uint3(lc_uint4 v) noexcept { return lc_uint3{static_cast(v.x), static_cast(v.y), static_cast(v.z)}; } +[[nodiscard]] __device__ constexpr auto lc_make_uint3(lc_half3 v) noexcept { return lc_uint3{static_cast(v.x), static_cast(v.y), static_cast(v.z)}; } +[[nodiscard]] __device__ constexpr auto lc_make_uint3(lc_half4 v) noexcept { return lc_uint3{static_cast(v.x), static_cast(v.y), static_cast(v.z)}; } +[[nodiscard]] __device__ constexpr auto lc_make_uint3(lc_float3 v) noexcept { return lc_uint3{static_cast(v.x), static_cast(v.y), static_cast(v.z)}; } +[[nodiscard]] __device__ constexpr auto lc_make_uint3(lc_float4 v) noexcept { return lc_uint3{static_cast(v.x), static_cast(v.y), static_cast(v.z)}; } +[[nodiscard]] __device__ constexpr auto lc_make_uint3(lc_bool3 v) noexcept { return lc_uint3{static_cast(v.x), static_cast(v.y), static_cast(v.z)}; } +[[nodiscard]] __device__ constexpr auto lc_make_uint3(lc_bool4 v) noexcept { return lc_uint3{static_cast(v.x), static_cast(v.y), static_cast(v.z)}; } +[[nodiscard]] __device__ constexpr auto lc_make_uint3(lc_long3 v) noexcept { return lc_uint3{static_cast(v.x), static_cast(v.y), static_cast(v.z)}; } +[[nodiscard]] __device__ constexpr auto lc_make_uint3(lc_long4 v) noexcept { return lc_uint3{static_cast(v.x), static_cast(v.y), static_cast(v.z)}; } +[[nodiscard]] __device__ constexpr auto lc_make_uint3(lc_ulong3 v) noexcept { return lc_uint3{static_cast(v.x), static_cast(v.y), static_cast(v.z)}; } +[[nodiscard]] __device__ constexpr auto lc_make_uint3(lc_ulong4 v) noexcept { return lc_uint3{static_cast(v.x), static_cast(v.y), static_cast(v.z)}; } +[[nodiscard]] inline __device__ constexpr auto lc_make_uint4(lc_uint s = 0) noexcept { return lc_uint4{s, s, s, s}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_uint4(lc_uint x, lc_uint y, lc_uint z, lc_uint w) noexcept { return lc_uint4{x, y, z, w}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_uint4(lc_uint x, lc_uint y, lc_uint2 zw) noexcept { return lc_uint4{x, y, zw.x, zw.y}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_uint4(lc_uint x, lc_uint2 yz, lc_uint w) noexcept { return lc_uint4{x, yz.x, yz.y, w}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_uint4(lc_uint2 xy, lc_uint z, lc_uint w) noexcept { return lc_uint4{xy.x, xy.y, z, w}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_uint4(lc_uint2 xy, lc_uint2 zw) noexcept { return lc_uint4{xy.x, xy.y, zw.x, zw.y}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_uint4(lc_uint x, lc_uint3 yzw) noexcept { return lc_uint4{x, yzw.x, yzw.y, yzw.z}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_uint4(lc_uint3 xyz, lc_uint w) noexcept { return lc_uint4{xyz.x, xyz.y, xyz.z, w}; } +[[nodiscard]] inline __device__ constexpr auto lc_make_uint4(lc_byte4 v) noexcept { return lc_uint4{static_cast(v.x), static_cast(v.y), static_cast(v.z), static_cast(v.w)}; } +[[nodiscard]] inline __device__ constexpr auto lc_make_uint4(lc_ubyte4 v) noexcept { return lc_uint4{static_cast(v.x), static_cast(v.y), static_cast(v.z), static_cast(v.w)}; } +[[nodiscard]] inline __device__ constexpr auto lc_make_uint4(lc_short4 v) noexcept { return lc_uint4{static_cast(v.x), static_cast(v.y), static_cast(v.z), static_cast(v.w)}; } +[[nodiscard]] inline __device__ constexpr auto lc_make_uint4(lc_ushort4 v) noexcept { return lc_uint4{static_cast(v.x), static_cast(v.y), static_cast(v.z), static_cast(v.w)}; } +[[nodiscard]] inline __device__ constexpr auto lc_make_uint4(lc_int4 v) noexcept { return lc_uint4{static_cast(v.x), static_cast(v.y), static_cast(v.z), static_cast(v.w)}; } +[[nodiscard]] inline __device__ constexpr auto lc_make_uint4(lc_uint4 v) noexcept { return lc_uint4{static_cast(v.x), static_cast(v.y), static_cast(v.z), static_cast(v.w)}; } +[[nodiscard]] inline __device__ constexpr auto lc_make_uint4(lc_half4 v) noexcept { return lc_uint4{static_cast(v.x), static_cast(v.y), static_cast(v.z), static_cast(v.w)}; } +[[nodiscard]] inline __device__ constexpr auto lc_make_uint4(lc_float4 v) noexcept { return lc_uint4{static_cast(v.x), static_cast(v.y), static_cast(v.z), static_cast(v.w)}; } +[[nodiscard]] inline __device__ constexpr auto lc_make_uint4(lc_bool4 v) noexcept { return lc_uint4{static_cast(v.x), static_cast(v.y), static_cast(v.z), static_cast(v.w)}; } +[[nodiscard]] inline __device__ constexpr auto lc_make_uint4(lc_long4 v) noexcept { return lc_uint4{static_cast(v.x), static_cast(v.y), static_cast(v.z), static_cast(v.w)}; } +[[nodiscard]] inline __device__ constexpr auto lc_make_uint4(lc_ulong4 v) noexcept { return lc_uint4{static_cast(v.x), static_cast(v.y), static_cast(v.z), static_cast(v.w)}; } + +[[nodiscard]] __device__ inline constexpr auto lc_make_half2(lc_half s = 0) noexcept { return lc_half2{s, s}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_half2(lc_half x, lc_half y) noexcept { return lc_half2{x, y}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_half2(lc_byte2 v) noexcept { return lc_half2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_half2(lc_byte3 v) noexcept { return lc_half2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_half2(lc_byte4 v) noexcept { return lc_half2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_half2(lc_ubyte2 v) noexcept { return lc_half2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_half2(lc_ubyte3 v) noexcept { return lc_half2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_half2(lc_ubyte4 v) noexcept { return lc_half2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_half2(lc_short2 v) noexcept { return lc_half2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_half2(lc_short3 v) noexcept { return lc_half2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_half2(lc_short4 v) noexcept { return lc_half2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_half2(lc_ushort2 v) noexcept { return lc_half2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_half2(lc_ushort3 v) noexcept { return lc_half2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_half2(lc_ushort4 v) noexcept { return lc_half2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_half2(lc_int2 v) noexcept { return lc_half2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_half2(lc_int3 v) noexcept { return lc_half2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_half2(lc_int4 v) noexcept { return lc_half2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_half2(lc_uint2 v) noexcept { return lc_half2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_half2(lc_uint3 v) noexcept { return lc_half2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_half2(lc_uint4 v) noexcept { return lc_half2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_half2(lc_half2 v) noexcept { return lc_half2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_half2(lc_half3 v) noexcept { return lc_half2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_half2(lc_half4 v) noexcept { return lc_half2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_half2(lc_float2 v) noexcept { return lc_half2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_half2(lc_float3 v) noexcept { return lc_half2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_half2(lc_float4 v) noexcept { return lc_half2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_half2(lc_bool2 v) noexcept { return lc_half2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_half2(lc_bool3 v) noexcept { return lc_half2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_half2(lc_bool4 v) noexcept { return lc_half2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_half2(lc_long2 v) noexcept { return lc_half2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_half2(lc_long3 v) noexcept { return lc_half2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_half2(lc_long4 v) noexcept { return lc_half2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_half2(lc_ulong2 v) noexcept { return lc_half2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_half2(lc_ulong3 v) noexcept { return lc_half2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_half2(lc_ulong4 v) noexcept { return lc_half2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] inline __device__ constexpr auto lc_make_half3(lc_half s = 0) noexcept { return lc_half3{s, s, s}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_half3(lc_half x, lc_half y, lc_half z) noexcept { return lc_half3{x, y, z}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_half3(lc_half x, lc_half2 yz) noexcept { return lc_half3{x, yz.x, yz.y}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_half3(lc_half2 xy, lc_half z) noexcept { return lc_half3{xy.x, xy.y, z}; } +[[nodiscard]] __device__ constexpr auto lc_make_half3(lc_byte3 v) noexcept { return lc_half3{static_cast(v.x), static_cast(v.y), static_cast(v.z)}; } +[[nodiscard]] __device__ constexpr auto lc_make_half3(lc_byte4 v) noexcept { return lc_half3{static_cast(v.x), static_cast(v.y), static_cast(v.z)}; } +[[nodiscard]] __device__ constexpr auto lc_make_half3(lc_ubyte3 v) noexcept { return lc_half3{static_cast(v.x), static_cast(v.y), static_cast(v.z)}; } +[[nodiscard]] __device__ constexpr auto lc_make_half3(lc_ubyte4 v) noexcept { return lc_half3{static_cast(v.x), static_cast(v.y), static_cast(v.z)}; } +[[nodiscard]] __device__ constexpr auto lc_make_half3(lc_short3 v) noexcept { return lc_half3{static_cast(v.x), static_cast(v.y), static_cast(v.z)}; } +[[nodiscard]] __device__ constexpr auto lc_make_half3(lc_short4 v) noexcept { return lc_half3{static_cast(v.x), static_cast(v.y), static_cast(v.z)}; } +[[nodiscard]] __device__ constexpr auto lc_make_half3(lc_ushort3 v) noexcept { return lc_half3{static_cast(v.x), static_cast(v.y), static_cast(v.z)}; } +[[nodiscard]] __device__ constexpr auto lc_make_half3(lc_ushort4 v) noexcept { return lc_half3{static_cast(v.x), static_cast(v.y), static_cast(v.z)}; } +[[nodiscard]] __device__ constexpr auto lc_make_half3(lc_int3 v) noexcept { return lc_half3{static_cast(v.x), static_cast(v.y), static_cast(v.z)}; } +[[nodiscard]] __device__ constexpr auto lc_make_half3(lc_int4 v) noexcept { return lc_half3{static_cast(v.x), static_cast(v.y), static_cast(v.z)}; } +[[nodiscard]] __device__ constexpr auto lc_make_half3(lc_uint3 v) noexcept { return lc_half3{static_cast(v.x), static_cast(v.y), static_cast(v.z)}; } +[[nodiscard]] __device__ constexpr auto lc_make_half3(lc_uint4 v) noexcept { return lc_half3{static_cast(v.x), static_cast(v.y), static_cast(v.z)}; } +[[nodiscard]] __device__ constexpr auto lc_make_half3(lc_half3 v) noexcept { return lc_half3{static_cast(v.x), static_cast(v.y), static_cast(v.z)}; } +[[nodiscard]] __device__ constexpr auto lc_make_half3(lc_half4 v) noexcept { return lc_half3{static_cast(v.x), static_cast(v.y), static_cast(v.z)}; } +[[nodiscard]] __device__ constexpr auto lc_make_half3(lc_float3 v) noexcept { return lc_half3{static_cast(v.x), static_cast(v.y), static_cast(v.z)}; } +[[nodiscard]] __device__ constexpr auto lc_make_half3(lc_float4 v) noexcept { return lc_half3{static_cast(v.x), static_cast(v.y), static_cast(v.z)}; } +[[nodiscard]] __device__ constexpr auto lc_make_half3(lc_bool3 v) noexcept { return lc_half3{static_cast(v.x), static_cast(v.y), static_cast(v.z)}; } +[[nodiscard]] __device__ constexpr auto lc_make_half3(lc_bool4 v) noexcept { return lc_half3{static_cast(v.x), static_cast(v.y), static_cast(v.z)}; } +[[nodiscard]] __device__ constexpr auto lc_make_half3(lc_long3 v) noexcept { return lc_half3{static_cast(v.x), static_cast(v.y), static_cast(v.z)}; } +[[nodiscard]] __device__ constexpr auto lc_make_half3(lc_long4 v) noexcept { return lc_half3{static_cast(v.x), static_cast(v.y), static_cast(v.z)}; } +[[nodiscard]] __device__ constexpr auto lc_make_half3(lc_ulong3 v) noexcept { return lc_half3{static_cast(v.x), static_cast(v.y), static_cast(v.z)}; } +[[nodiscard]] __device__ constexpr auto lc_make_half3(lc_ulong4 v) noexcept { return lc_half3{static_cast(v.x), static_cast(v.y), static_cast(v.z)}; } +[[nodiscard]] inline __device__ constexpr auto lc_make_half4(lc_half s = 0) noexcept { return lc_half4{s, s, s, s}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_half4(lc_half x, lc_half y, lc_half z, lc_half w) noexcept { return lc_half4{x, y, z, w}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_half4(lc_half x, lc_half y, lc_half2 zw) noexcept { return lc_half4{x, y, zw.x, zw.y}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_half4(lc_half x, lc_half2 yz, lc_half w) noexcept { return lc_half4{x, yz.x, yz.y, w}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_half4(lc_half2 xy, lc_half z, lc_half w) noexcept { return lc_half4{xy.x, xy.y, z, w}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_half4(lc_half2 xy, lc_half2 zw) noexcept { return lc_half4{xy.x, xy.y, zw.x, zw.y}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_half4(lc_half x, lc_half3 yzw) noexcept { return lc_half4{x, yzw.x, yzw.y, yzw.z}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_half4(lc_half3 xyz, lc_half w) noexcept { return lc_half4{xyz.x, xyz.y, xyz.z, w}; } +[[nodiscard]] inline __device__ constexpr auto lc_make_half4(lc_byte4 v) noexcept { return lc_half4{static_cast(v.x), static_cast(v.y), static_cast(v.z), static_cast(v.w)}; } +[[nodiscard]] inline __device__ constexpr auto lc_make_half4(lc_ubyte4 v) noexcept { return lc_half4{static_cast(v.x), static_cast(v.y), static_cast(v.z), static_cast(v.w)}; } +[[nodiscard]] inline __device__ constexpr auto lc_make_half4(lc_short4 v) noexcept { return lc_half4{static_cast(v.x), static_cast(v.y), static_cast(v.z), static_cast(v.w)}; } +[[nodiscard]] inline __device__ constexpr auto lc_make_half4(lc_ushort4 v) noexcept { return lc_half4{static_cast(v.x), static_cast(v.y), static_cast(v.z), static_cast(v.w)}; } +[[nodiscard]] inline __device__ constexpr auto lc_make_half4(lc_int4 v) noexcept { return lc_half4{static_cast(v.x), static_cast(v.y), static_cast(v.z), static_cast(v.w)}; } +[[nodiscard]] inline __device__ constexpr auto lc_make_half4(lc_uint4 v) noexcept { return lc_half4{static_cast(v.x), static_cast(v.y), static_cast(v.z), static_cast(v.w)}; } +[[nodiscard]] inline __device__ constexpr auto lc_make_half4(lc_half4 v) noexcept { return lc_half4{static_cast(v.x), static_cast(v.y), static_cast(v.z), static_cast(v.w)}; } +[[nodiscard]] inline __device__ constexpr auto lc_make_half4(lc_float4 v) noexcept { return lc_half4{static_cast(v.x), static_cast(v.y), static_cast(v.z), static_cast(v.w)}; } +[[nodiscard]] inline __device__ constexpr auto lc_make_half4(lc_bool4 v) noexcept { return lc_half4{static_cast(v.x), static_cast(v.y), static_cast(v.z), static_cast(v.w)}; } +[[nodiscard]] inline __device__ constexpr auto lc_make_half4(lc_long4 v) noexcept { return lc_half4{static_cast(v.x), static_cast(v.y), static_cast(v.z), static_cast(v.w)}; } +[[nodiscard]] inline __device__ constexpr auto lc_make_half4(lc_ulong4 v) noexcept { return lc_half4{static_cast(v.x), static_cast(v.y), static_cast(v.z), static_cast(v.w)}; } + +[[nodiscard]] __device__ inline constexpr auto lc_make_float2(lc_float s = 0) noexcept { return lc_float2{s, s}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_float2(lc_float x, lc_float y) noexcept { return lc_float2{x, y}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_float2(lc_byte2 v) noexcept { return lc_float2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_float2(lc_byte3 v) noexcept { return lc_float2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_float2(lc_byte4 v) noexcept { return lc_float2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_float2(lc_ubyte2 v) noexcept { return lc_float2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_float2(lc_ubyte3 v) noexcept { return lc_float2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_float2(lc_ubyte4 v) noexcept { return lc_float2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_float2(lc_short2 v) noexcept { return lc_float2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_float2(lc_short3 v) noexcept { return lc_float2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_float2(lc_short4 v) noexcept { return lc_float2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_float2(lc_ushort2 v) noexcept { return lc_float2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_float2(lc_ushort3 v) noexcept { return lc_float2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_float2(lc_ushort4 v) noexcept { return lc_float2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_float2(lc_int2 v) noexcept { return lc_float2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_float2(lc_int3 v) noexcept { return lc_float2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_float2(lc_int4 v) noexcept { return lc_float2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_float2(lc_uint2 v) noexcept { return lc_float2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_float2(lc_uint3 v) noexcept { return lc_float2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_float2(lc_uint4 v) noexcept { return lc_float2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_float2(lc_half2 v) noexcept { return lc_float2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_float2(lc_half3 v) noexcept { return lc_float2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_float2(lc_half4 v) noexcept { return lc_float2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_float2(lc_float2 v) noexcept { return lc_float2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_float2(lc_float3 v) noexcept { return lc_float2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_float2(lc_float4 v) noexcept { return lc_float2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_float2(lc_bool2 v) noexcept { return lc_float2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_float2(lc_bool3 v) noexcept { return lc_float2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_float2(lc_bool4 v) noexcept { return lc_float2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_float2(lc_long2 v) noexcept { return lc_float2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_float2(lc_long3 v) noexcept { return lc_float2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_float2(lc_long4 v) noexcept { return lc_float2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_float2(lc_ulong2 v) noexcept { return lc_float2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_float2(lc_ulong3 v) noexcept { return lc_float2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_float2(lc_ulong4 v) noexcept { return lc_float2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] inline __device__ constexpr auto lc_make_float3(lc_float s = 0) noexcept { return lc_float3{s, s, s}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_float3(lc_float x, lc_float y, lc_float z) noexcept { return lc_float3{x, y, z}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_float3(lc_float x, lc_float2 yz) noexcept { return lc_float3{x, yz.x, yz.y}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_float3(lc_float2 xy, lc_float z) noexcept { return lc_float3{xy.x, xy.y, z}; } +[[nodiscard]] __device__ constexpr auto lc_make_float3(lc_byte3 v) noexcept { return lc_float3{static_cast(v.x), static_cast(v.y), static_cast(v.z)}; } +[[nodiscard]] __device__ constexpr auto lc_make_float3(lc_byte4 v) noexcept { return lc_float3{static_cast(v.x), static_cast(v.y), static_cast(v.z)}; } +[[nodiscard]] __device__ constexpr auto lc_make_float3(lc_ubyte3 v) noexcept { return lc_float3{static_cast(v.x), static_cast(v.y), static_cast(v.z)}; } +[[nodiscard]] __device__ constexpr auto lc_make_float3(lc_ubyte4 v) noexcept { return lc_float3{static_cast(v.x), static_cast(v.y), static_cast(v.z)}; } +[[nodiscard]] __device__ constexpr auto lc_make_float3(lc_short3 v) noexcept { return lc_float3{static_cast(v.x), static_cast(v.y), static_cast(v.z)}; } +[[nodiscard]] __device__ constexpr auto lc_make_float3(lc_short4 v) noexcept { return lc_float3{static_cast(v.x), static_cast(v.y), static_cast(v.z)}; } +[[nodiscard]] __device__ constexpr auto lc_make_float3(lc_ushort3 v) noexcept { return lc_float3{static_cast(v.x), static_cast(v.y), static_cast(v.z)}; } +[[nodiscard]] __device__ constexpr auto lc_make_float3(lc_ushort4 v) noexcept { return lc_float3{static_cast(v.x), static_cast(v.y), static_cast(v.z)}; } +[[nodiscard]] __device__ constexpr auto lc_make_float3(lc_int3 v) noexcept { return lc_float3{static_cast(v.x), static_cast(v.y), static_cast(v.z)}; } +[[nodiscard]] __device__ constexpr auto lc_make_float3(lc_int4 v) noexcept { return lc_float3{static_cast(v.x), static_cast(v.y), static_cast(v.z)}; } +[[nodiscard]] __device__ constexpr auto lc_make_float3(lc_uint3 v) noexcept { return lc_float3{static_cast(v.x), static_cast(v.y), static_cast(v.z)}; } +[[nodiscard]] __device__ constexpr auto lc_make_float3(lc_uint4 v) noexcept { return lc_float3{static_cast(v.x), static_cast(v.y), static_cast(v.z)}; } +[[nodiscard]] __device__ constexpr auto lc_make_float3(lc_half3 v) noexcept { return lc_float3{static_cast(v.x), static_cast(v.y), static_cast(v.z)}; } +[[nodiscard]] __device__ constexpr auto lc_make_float3(lc_half4 v) noexcept { return lc_float3{static_cast(v.x), static_cast(v.y), static_cast(v.z)}; } +[[nodiscard]] __device__ constexpr auto lc_make_float3(lc_float3 v) noexcept { return lc_float3{static_cast(v.x), static_cast(v.y), static_cast(v.z)}; } +[[nodiscard]] __device__ constexpr auto lc_make_float3(lc_float4 v) noexcept { return lc_float3{static_cast(v.x), static_cast(v.y), static_cast(v.z)}; } +[[nodiscard]] __device__ constexpr auto lc_make_float3(lc_bool3 v) noexcept { return lc_float3{static_cast(v.x), static_cast(v.y), static_cast(v.z)}; } +[[nodiscard]] __device__ constexpr auto lc_make_float3(lc_bool4 v) noexcept { return lc_float3{static_cast(v.x), static_cast(v.y), static_cast(v.z)}; } +[[nodiscard]] __device__ constexpr auto lc_make_float3(lc_long3 v) noexcept { return lc_float3{static_cast(v.x), static_cast(v.y), static_cast(v.z)}; } +[[nodiscard]] __device__ constexpr auto lc_make_float3(lc_long4 v) noexcept { return lc_float3{static_cast(v.x), static_cast(v.y), static_cast(v.z)}; } +[[nodiscard]] __device__ constexpr auto lc_make_float3(lc_ulong3 v) noexcept { return lc_float3{static_cast(v.x), static_cast(v.y), static_cast(v.z)}; } +[[nodiscard]] __device__ constexpr auto lc_make_float3(lc_ulong4 v) noexcept { return lc_float3{static_cast(v.x), static_cast(v.y), static_cast(v.z)}; } +[[nodiscard]] inline __device__ constexpr auto lc_make_float4(lc_float s = 0) noexcept { return lc_float4{s, s, s, s}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_float4(lc_float x, lc_float y, lc_float z, lc_float w) noexcept { return lc_float4{x, y, z, w}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_float4(lc_float x, lc_float y, lc_float2 zw) noexcept { return lc_float4{x, y, zw.x, zw.y}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_float4(lc_float x, lc_float2 yz, lc_float w) noexcept { return lc_float4{x, yz.x, yz.y, w}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_float4(lc_float2 xy, lc_float z, lc_float w) noexcept { return lc_float4{xy.x, xy.y, z, w}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_float4(lc_float2 xy, lc_float2 zw) noexcept { return lc_float4{xy.x, xy.y, zw.x, zw.y}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_float4(lc_float x, lc_float3 yzw) noexcept { return lc_float4{x, yzw.x, yzw.y, yzw.z}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_float4(lc_float3 xyz, lc_float w) noexcept { return lc_float4{xyz.x, xyz.y, xyz.z, w}; } +[[nodiscard]] inline __device__ constexpr auto lc_make_float4(lc_byte4 v) noexcept { return lc_float4{static_cast(v.x), static_cast(v.y), static_cast(v.z), static_cast(v.w)}; } +[[nodiscard]] inline __device__ constexpr auto lc_make_float4(lc_ubyte4 v) noexcept { return lc_float4{static_cast(v.x), static_cast(v.y), static_cast(v.z), static_cast(v.w)}; } +[[nodiscard]] inline __device__ constexpr auto lc_make_float4(lc_short4 v) noexcept { return lc_float4{static_cast(v.x), static_cast(v.y), static_cast(v.z), static_cast(v.w)}; } +[[nodiscard]] inline __device__ constexpr auto lc_make_float4(lc_ushort4 v) noexcept { return lc_float4{static_cast(v.x), static_cast(v.y), static_cast(v.z), static_cast(v.w)}; } +[[nodiscard]] inline __device__ constexpr auto lc_make_float4(lc_int4 v) noexcept { return lc_float4{static_cast(v.x), static_cast(v.y), static_cast(v.z), static_cast(v.w)}; } +[[nodiscard]] inline __device__ constexpr auto lc_make_float4(lc_uint4 v) noexcept { return lc_float4{static_cast(v.x), static_cast(v.y), static_cast(v.z), static_cast(v.w)}; } +[[nodiscard]] inline __device__ constexpr auto lc_make_float4(lc_half4 v) noexcept { return lc_float4{static_cast(v.x), static_cast(v.y), static_cast(v.z), static_cast(v.w)}; } +[[nodiscard]] inline __device__ constexpr auto lc_make_float4(lc_float4 v) noexcept { return lc_float4{static_cast(v.x), static_cast(v.y), static_cast(v.z), static_cast(v.w)}; } +[[nodiscard]] inline __device__ constexpr auto lc_make_float4(lc_bool4 v) noexcept { return lc_float4{static_cast(v.x), static_cast(v.y), static_cast(v.z), static_cast(v.w)}; } +[[nodiscard]] inline __device__ constexpr auto lc_make_float4(lc_long4 v) noexcept { return lc_float4{static_cast(v.x), static_cast(v.y), static_cast(v.z), static_cast(v.w)}; } +[[nodiscard]] inline __device__ constexpr auto lc_make_float4(lc_ulong4 v) noexcept { return lc_float4{static_cast(v.x), static_cast(v.y), static_cast(v.z), static_cast(v.w)}; } + +[[nodiscard]] __device__ inline constexpr auto lc_make_bool2(lc_bool s = 0) noexcept { return lc_bool2{s, s}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_bool2(lc_bool x, lc_bool y) noexcept { return lc_bool2{x, y}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_bool2(lc_byte2 v) noexcept { return lc_bool2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_bool2(lc_byte3 v) noexcept { return lc_bool2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_bool2(lc_byte4 v) noexcept { return lc_bool2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_bool2(lc_ubyte2 v) noexcept { return lc_bool2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_bool2(lc_ubyte3 v) noexcept { return lc_bool2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_bool2(lc_ubyte4 v) noexcept { return lc_bool2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_bool2(lc_short2 v) noexcept { return lc_bool2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_bool2(lc_short3 v) noexcept { return lc_bool2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_bool2(lc_short4 v) noexcept { return lc_bool2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_bool2(lc_ushort2 v) noexcept { return lc_bool2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_bool2(lc_ushort3 v) noexcept { return lc_bool2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_bool2(lc_ushort4 v) noexcept { return lc_bool2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_bool2(lc_int2 v) noexcept { return lc_bool2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_bool2(lc_int3 v) noexcept { return lc_bool2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_bool2(lc_int4 v) noexcept { return lc_bool2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_bool2(lc_uint2 v) noexcept { return lc_bool2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_bool2(lc_uint3 v) noexcept { return lc_bool2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_bool2(lc_uint4 v) noexcept { return lc_bool2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_bool2(lc_half2 v) noexcept { return lc_bool2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_bool2(lc_half3 v) noexcept { return lc_bool2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_bool2(lc_half4 v) noexcept { return lc_bool2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_bool2(lc_float2 v) noexcept { return lc_bool2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_bool2(lc_float3 v) noexcept { return lc_bool2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_bool2(lc_float4 v) noexcept { return lc_bool2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_bool2(lc_bool2 v) noexcept { return lc_bool2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_bool2(lc_bool3 v) noexcept { return lc_bool2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_bool2(lc_bool4 v) noexcept { return lc_bool2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_bool2(lc_long2 v) noexcept { return lc_bool2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_bool2(lc_long3 v) noexcept { return lc_bool2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_bool2(lc_long4 v) noexcept { return lc_bool2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_bool2(lc_ulong2 v) noexcept { return lc_bool2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_bool2(lc_ulong3 v) noexcept { return lc_bool2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_bool2(lc_ulong4 v) noexcept { return lc_bool2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] inline __device__ constexpr auto lc_make_bool3(lc_bool s = 0) noexcept { return lc_bool3{s, s, s}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_bool3(lc_bool x, lc_bool y, lc_bool z) noexcept { return lc_bool3{x, y, z}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_bool3(lc_bool x, lc_bool2 yz) noexcept { return lc_bool3{x, yz.x, yz.y}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_bool3(lc_bool2 xy, lc_bool z) noexcept { return lc_bool3{xy.x, xy.y, z}; } +[[nodiscard]] __device__ constexpr auto lc_make_bool3(lc_byte3 v) noexcept { return lc_bool3{static_cast(v.x), static_cast(v.y), static_cast(v.z)}; } +[[nodiscard]] __device__ constexpr auto lc_make_bool3(lc_byte4 v) noexcept { return lc_bool3{static_cast(v.x), static_cast(v.y), static_cast(v.z)}; } +[[nodiscard]] __device__ constexpr auto lc_make_bool3(lc_ubyte3 v) noexcept { return lc_bool3{static_cast(v.x), static_cast(v.y), static_cast(v.z)}; } +[[nodiscard]] __device__ constexpr auto lc_make_bool3(lc_ubyte4 v) noexcept { return lc_bool3{static_cast(v.x), static_cast(v.y), static_cast(v.z)}; } +[[nodiscard]] __device__ constexpr auto lc_make_bool3(lc_short3 v) noexcept { return lc_bool3{static_cast(v.x), static_cast(v.y), static_cast(v.z)}; } +[[nodiscard]] __device__ constexpr auto lc_make_bool3(lc_short4 v) noexcept { return lc_bool3{static_cast(v.x), static_cast(v.y), static_cast(v.z)}; } +[[nodiscard]] __device__ constexpr auto lc_make_bool3(lc_ushort3 v) noexcept { return lc_bool3{static_cast(v.x), static_cast(v.y), static_cast(v.z)}; } +[[nodiscard]] __device__ constexpr auto lc_make_bool3(lc_ushort4 v) noexcept { return lc_bool3{static_cast(v.x), static_cast(v.y), static_cast(v.z)}; } +[[nodiscard]] __device__ constexpr auto lc_make_bool3(lc_int3 v) noexcept { return lc_bool3{static_cast(v.x), static_cast(v.y), static_cast(v.z)}; } +[[nodiscard]] __device__ constexpr auto lc_make_bool3(lc_int4 v) noexcept { return lc_bool3{static_cast(v.x), static_cast(v.y), static_cast(v.z)}; } +[[nodiscard]] __device__ constexpr auto lc_make_bool3(lc_uint3 v) noexcept { return lc_bool3{static_cast(v.x), static_cast(v.y), static_cast(v.z)}; } +[[nodiscard]] __device__ constexpr auto lc_make_bool3(lc_uint4 v) noexcept { return lc_bool3{static_cast(v.x), static_cast(v.y), static_cast(v.z)}; } +[[nodiscard]] __device__ constexpr auto lc_make_bool3(lc_half3 v) noexcept { return lc_bool3{static_cast(v.x), static_cast(v.y), static_cast(v.z)}; } +[[nodiscard]] __device__ constexpr auto lc_make_bool3(lc_half4 v) noexcept { return lc_bool3{static_cast(v.x), static_cast(v.y), static_cast(v.z)}; } +[[nodiscard]] __device__ constexpr auto lc_make_bool3(lc_float3 v) noexcept { return lc_bool3{static_cast(v.x), static_cast(v.y), static_cast(v.z)}; } +[[nodiscard]] __device__ constexpr auto lc_make_bool3(lc_float4 v) noexcept { return lc_bool3{static_cast(v.x), static_cast(v.y), static_cast(v.z)}; } +[[nodiscard]] __device__ constexpr auto lc_make_bool3(lc_bool3 v) noexcept { return lc_bool3{static_cast(v.x), static_cast(v.y), static_cast(v.z)}; } +[[nodiscard]] __device__ constexpr auto lc_make_bool3(lc_bool4 v) noexcept { return lc_bool3{static_cast(v.x), static_cast(v.y), static_cast(v.z)}; } +[[nodiscard]] __device__ constexpr auto lc_make_bool3(lc_long3 v) noexcept { return lc_bool3{static_cast(v.x), static_cast(v.y), static_cast(v.z)}; } +[[nodiscard]] __device__ constexpr auto lc_make_bool3(lc_long4 v) noexcept { return lc_bool3{static_cast(v.x), static_cast(v.y), static_cast(v.z)}; } +[[nodiscard]] __device__ constexpr auto lc_make_bool3(lc_ulong3 v) noexcept { return lc_bool3{static_cast(v.x), static_cast(v.y), static_cast(v.z)}; } +[[nodiscard]] __device__ constexpr auto lc_make_bool3(lc_ulong4 v) noexcept { return lc_bool3{static_cast(v.x), static_cast(v.y), static_cast(v.z)}; } +[[nodiscard]] inline __device__ constexpr auto lc_make_bool4(lc_bool s = 0) noexcept { return lc_bool4{s, s, s, s}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_bool4(lc_bool x, lc_bool y, lc_bool z, lc_bool w) noexcept { return lc_bool4{x, y, z, w}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_bool4(lc_bool x, lc_bool y, lc_bool2 zw) noexcept { return lc_bool4{x, y, zw.x, zw.y}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_bool4(lc_bool x, lc_bool2 yz, lc_bool w) noexcept { return lc_bool4{x, yz.x, yz.y, w}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_bool4(lc_bool2 xy, lc_bool z, lc_bool w) noexcept { return lc_bool4{xy.x, xy.y, z, w}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_bool4(lc_bool2 xy, lc_bool2 zw) noexcept { return lc_bool4{xy.x, xy.y, zw.x, zw.y}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_bool4(lc_bool x, lc_bool3 yzw) noexcept { return lc_bool4{x, yzw.x, yzw.y, yzw.z}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_bool4(lc_bool3 xyz, lc_bool w) noexcept { return lc_bool4{xyz.x, xyz.y, xyz.z, w}; } +[[nodiscard]] inline __device__ constexpr auto lc_make_bool4(lc_byte4 v) noexcept { return lc_bool4{static_cast(v.x), static_cast(v.y), static_cast(v.z), static_cast(v.w)}; } +[[nodiscard]] inline __device__ constexpr auto lc_make_bool4(lc_ubyte4 v) noexcept { return lc_bool4{static_cast(v.x), static_cast(v.y), static_cast(v.z), static_cast(v.w)}; } +[[nodiscard]] inline __device__ constexpr auto lc_make_bool4(lc_short4 v) noexcept { return lc_bool4{static_cast(v.x), static_cast(v.y), static_cast(v.z), static_cast(v.w)}; } +[[nodiscard]] inline __device__ constexpr auto lc_make_bool4(lc_ushort4 v) noexcept { return lc_bool4{static_cast(v.x), static_cast(v.y), static_cast(v.z), static_cast(v.w)}; } +[[nodiscard]] inline __device__ constexpr auto lc_make_bool4(lc_int4 v) noexcept { return lc_bool4{static_cast(v.x), static_cast(v.y), static_cast(v.z), static_cast(v.w)}; } +[[nodiscard]] inline __device__ constexpr auto lc_make_bool4(lc_uint4 v) noexcept { return lc_bool4{static_cast(v.x), static_cast(v.y), static_cast(v.z), static_cast(v.w)}; } +[[nodiscard]] inline __device__ constexpr auto lc_make_bool4(lc_half4 v) noexcept { return lc_bool4{static_cast(v.x), static_cast(v.y), static_cast(v.z), static_cast(v.w)}; } +[[nodiscard]] inline __device__ constexpr auto lc_make_bool4(lc_float4 v) noexcept { return lc_bool4{static_cast(v.x), static_cast(v.y), static_cast(v.z), static_cast(v.w)}; } +[[nodiscard]] inline __device__ constexpr auto lc_make_bool4(lc_bool4 v) noexcept { return lc_bool4{static_cast(v.x), static_cast(v.y), static_cast(v.z), static_cast(v.w)}; } +[[nodiscard]] inline __device__ constexpr auto lc_make_bool4(lc_long4 v) noexcept { return lc_bool4{static_cast(v.x), static_cast(v.y), static_cast(v.z), static_cast(v.w)}; } +[[nodiscard]] inline __device__ constexpr auto lc_make_bool4(lc_ulong4 v) noexcept { return lc_bool4{static_cast(v.x), static_cast(v.y), static_cast(v.z), static_cast(v.w)}; } + +[[nodiscard]] __device__ inline constexpr auto lc_make_long2(lc_long s = 0) noexcept { return lc_long2{s, s}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_long2(lc_long x, lc_long y) noexcept { return lc_long2{x, y}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_long2(lc_byte2 v) noexcept { return lc_long2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_long2(lc_byte3 v) noexcept { return lc_long2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_long2(lc_byte4 v) noexcept { return lc_long2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_long2(lc_ubyte2 v) noexcept { return lc_long2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_long2(lc_ubyte3 v) noexcept { return lc_long2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_long2(lc_ubyte4 v) noexcept { return lc_long2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_long2(lc_short2 v) noexcept { return lc_long2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_long2(lc_short3 v) noexcept { return lc_long2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_long2(lc_short4 v) noexcept { return lc_long2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_long2(lc_ushort2 v) noexcept { return lc_long2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_long2(lc_ushort3 v) noexcept { return lc_long2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_long2(lc_ushort4 v) noexcept { return lc_long2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_long2(lc_int2 v) noexcept { return lc_long2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_long2(lc_int3 v) noexcept { return lc_long2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_long2(lc_int4 v) noexcept { return lc_long2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_long2(lc_uint2 v) noexcept { return lc_long2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_long2(lc_uint3 v) noexcept { return lc_long2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_long2(lc_uint4 v) noexcept { return lc_long2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_long2(lc_half2 v) noexcept { return lc_long2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_long2(lc_half3 v) noexcept { return lc_long2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_long2(lc_half4 v) noexcept { return lc_long2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_long2(lc_float2 v) noexcept { return lc_long2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_long2(lc_float3 v) noexcept { return lc_long2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_long2(lc_float4 v) noexcept { return lc_long2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_long2(lc_bool2 v) noexcept { return lc_long2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_long2(lc_bool3 v) noexcept { return lc_long2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_long2(lc_bool4 v) noexcept { return lc_long2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_long2(lc_long2 v) noexcept { return lc_long2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_long2(lc_long3 v) noexcept { return lc_long2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_long2(lc_long4 v) noexcept { return lc_long2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_long2(lc_ulong2 v) noexcept { return lc_long2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_long2(lc_ulong3 v) noexcept { return lc_long2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_long2(lc_ulong4 v) noexcept { return lc_long2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] inline __device__ constexpr auto lc_make_long3(lc_long s = 0) noexcept { return lc_long3{s, s, s}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_long3(lc_long x, lc_long y, lc_long z) noexcept { return lc_long3{x, y, z}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_long3(lc_long x, lc_long2 yz) noexcept { return lc_long3{x, yz.x, yz.y}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_long3(lc_long2 xy, lc_long z) noexcept { return lc_long3{xy.x, xy.y, z}; } +[[nodiscard]] __device__ constexpr auto lc_make_long3(lc_byte3 v) noexcept { return lc_long3{static_cast(v.x), static_cast(v.y), static_cast(v.z)}; } +[[nodiscard]] __device__ constexpr auto lc_make_long3(lc_byte4 v) noexcept { return lc_long3{static_cast(v.x), static_cast(v.y), static_cast(v.z)}; } +[[nodiscard]] __device__ constexpr auto lc_make_long3(lc_ubyte3 v) noexcept { return lc_long3{static_cast(v.x), static_cast(v.y), static_cast(v.z)}; } +[[nodiscard]] __device__ constexpr auto lc_make_long3(lc_ubyte4 v) noexcept { return lc_long3{static_cast(v.x), static_cast(v.y), static_cast(v.z)}; } +[[nodiscard]] __device__ constexpr auto lc_make_long3(lc_short3 v) noexcept { return lc_long3{static_cast(v.x), static_cast(v.y), static_cast(v.z)}; } +[[nodiscard]] __device__ constexpr auto lc_make_long3(lc_short4 v) noexcept { return lc_long3{static_cast(v.x), static_cast(v.y), static_cast(v.z)}; } +[[nodiscard]] __device__ constexpr auto lc_make_long3(lc_ushort3 v) noexcept { return lc_long3{static_cast(v.x), static_cast(v.y), static_cast(v.z)}; } +[[nodiscard]] __device__ constexpr auto lc_make_long3(lc_ushort4 v) noexcept { return lc_long3{static_cast(v.x), static_cast(v.y), static_cast(v.z)}; } +[[nodiscard]] __device__ constexpr auto lc_make_long3(lc_int3 v) noexcept { return lc_long3{static_cast(v.x), static_cast(v.y), static_cast(v.z)}; } +[[nodiscard]] __device__ constexpr auto lc_make_long3(lc_int4 v) noexcept { return lc_long3{static_cast(v.x), static_cast(v.y), static_cast(v.z)}; } +[[nodiscard]] __device__ constexpr auto lc_make_long3(lc_uint3 v) noexcept { return lc_long3{static_cast(v.x), static_cast(v.y), static_cast(v.z)}; } +[[nodiscard]] __device__ constexpr auto lc_make_long3(lc_uint4 v) noexcept { return lc_long3{static_cast(v.x), static_cast(v.y), static_cast(v.z)}; } +[[nodiscard]] __device__ constexpr auto lc_make_long3(lc_half3 v) noexcept { return lc_long3{static_cast(v.x), static_cast(v.y), static_cast(v.z)}; } +[[nodiscard]] __device__ constexpr auto lc_make_long3(lc_half4 v) noexcept { return lc_long3{static_cast(v.x), static_cast(v.y), static_cast(v.z)}; } +[[nodiscard]] __device__ constexpr auto lc_make_long3(lc_float3 v) noexcept { return lc_long3{static_cast(v.x), static_cast(v.y), static_cast(v.z)}; } +[[nodiscard]] __device__ constexpr auto lc_make_long3(lc_float4 v) noexcept { return lc_long3{static_cast(v.x), static_cast(v.y), static_cast(v.z)}; } +[[nodiscard]] __device__ constexpr auto lc_make_long3(lc_bool3 v) noexcept { return lc_long3{static_cast(v.x), static_cast(v.y), static_cast(v.z)}; } +[[nodiscard]] __device__ constexpr auto lc_make_long3(lc_bool4 v) noexcept { return lc_long3{static_cast(v.x), static_cast(v.y), static_cast(v.z)}; } +[[nodiscard]] __device__ constexpr auto lc_make_long3(lc_long3 v) noexcept { return lc_long3{static_cast(v.x), static_cast(v.y), static_cast(v.z)}; } +[[nodiscard]] __device__ constexpr auto lc_make_long3(lc_long4 v) noexcept { return lc_long3{static_cast(v.x), static_cast(v.y), static_cast(v.z)}; } +[[nodiscard]] __device__ constexpr auto lc_make_long3(lc_ulong3 v) noexcept { return lc_long3{static_cast(v.x), static_cast(v.y), static_cast(v.z)}; } +[[nodiscard]] __device__ constexpr auto lc_make_long3(lc_ulong4 v) noexcept { return lc_long3{static_cast(v.x), static_cast(v.y), static_cast(v.z)}; } +[[nodiscard]] inline __device__ constexpr auto lc_make_long4(lc_long s = 0) noexcept { return lc_long4{s, s, s, s}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_long4(lc_long x, lc_long y, lc_long z, lc_long w) noexcept { return lc_long4{x, y, z, w}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_long4(lc_long x, lc_long y, lc_long2 zw) noexcept { return lc_long4{x, y, zw.x, zw.y}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_long4(lc_long x, lc_long2 yz, lc_long w) noexcept { return lc_long4{x, yz.x, yz.y, w}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_long4(lc_long2 xy, lc_long z, lc_long w) noexcept { return lc_long4{xy.x, xy.y, z, w}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_long4(lc_long2 xy, lc_long2 zw) noexcept { return lc_long4{xy.x, xy.y, zw.x, zw.y}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_long4(lc_long x, lc_long3 yzw) noexcept { return lc_long4{x, yzw.x, yzw.y, yzw.z}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_long4(lc_long3 xyz, lc_long w) noexcept { return lc_long4{xyz.x, xyz.y, xyz.z, w}; } +[[nodiscard]] inline __device__ constexpr auto lc_make_long4(lc_byte4 v) noexcept { return lc_long4{static_cast(v.x), static_cast(v.y), static_cast(v.z), static_cast(v.w)}; } +[[nodiscard]] inline __device__ constexpr auto lc_make_long4(lc_ubyte4 v) noexcept { return lc_long4{static_cast(v.x), static_cast(v.y), static_cast(v.z), static_cast(v.w)}; } +[[nodiscard]] inline __device__ constexpr auto lc_make_long4(lc_short4 v) noexcept { return lc_long4{static_cast(v.x), static_cast(v.y), static_cast(v.z), static_cast(v.w)}; } +[[nodiscard]] inline __device__ constexpr auto lc_make_long4(lc_ushort4 v) noexcept { return lc_long4{static_cast(v.x), static_cast(v.y), static_cast(v.z), static_cast(v.w)}; } +[[nodiscard]] inline __device__ constexpr auto lc_make_long4(lc_int4 v) noexcept { return lc_long4{static_cast(v.x), static_cast(v.y), static_cast(v.z), static_cast(v.w)}; } +[[nodiscard]] inline __device__ constexpr auto lc_make_long4(lc_uint4 v) noexcept { return lc_long4{static_cast(v.x), static_cast(v.y), static_cast(v.z), static_cast(v.w)}; } +[[nodiscard]] inline __device__ constexpr auto lc_make_long4(lc_half4 v) noexcept { return lc_long4{static_cast(v.x), static_cast(v.y), static_cast(v.z), static_cast(v.w)}; } +[[nodiscard]] inline __device__ constexpr auto lc_make_long4(lc_float4 v) noexcept { return lc_long4{static_cast(v.x), static_cast(v.y), static_cast(v.z), static_cast(v.w)}; } +[[nodiscard]] inline __device__ constexpr auto lc_make_long4(lc_bool4 v) noexcept { return lc_long4{static_cast(v.x), static_cast(v.y), static_cast(v.z), static_cast(v.w)}; } +[[nodiscard]] inline __device__ constexpr auto lc_make_long4(lc_long4 v) noexcept { return lc_long4{static_cast(v.x), static_cast(v.y), static_cast(v.z), static_cast(v.w)}; } +[[nodiscard]] inline __device__ constexpr auto lc_make_long4(lc_ulong4 v) noexcept { return lc_long4{static_cast(v.x), static_cast(v.y), static_cast(v.z), static_cast(v.w)}; } + +[[nodiscard]] __device__ inline constexpr auto lc_make_ulong2(lc_ulong s = 0) noexcept { return lc_ulong2{s, s}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_ulong2(lc_ulong x, lc_ulong y) noexcept { return lc_ulong2{x, y}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_ulong2(lc_byte2 v) noexcept { return lc_ulong2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_ulong2(lc_byte3 v) noexcept { return lc_ulong2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_ulong2(lc_byte4 v) noexcept { return lc_ulong2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_ulong2(lc_ubyte2 v) noexcept { return lc_ulong2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_ulong2(lc_ubyte3 v) noexcept { return lc_ulong2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_ulong2(lc_ubyte4 v) noexcept { return lc_ulong2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_ulong2(lc_short2 v) noexcept { return lc_ulong2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_ulong2(lc_short3 v) noexcept { return lc_ulong2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_ulong2(lc_short4 v) noexcept { return lc_ulong2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_ulong2(lc_ushort2 v) noexcept { return lc_ulong2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_ulong2(lc_ushort3 v) noexcept { return lc_ulong2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_ulong2(lc_ushort4 v) noexcept { return lc_ulong2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_ulong2(lc_int2 v) noexcept { return lc_ulong2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_ulong2(lc_int3 v) noexcept { return lc_ulong2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_ulong2(lc_int4 v) noexcept { return lc_ulong2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_ulong2(lc_uint2 v) noexcept { return lc_ulong2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_ulong2(lc_uint3 v) noexcept { return lc_ulong2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_ulong2(lc_uint4 v) noexcept { return lc_ulong2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_ulong2(lc_half2 v) noexcept { return lc_ulong2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_ulong2(lc_half3 v) noexcept { return lc_ulong2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_ulong2(lc_half4 v) noexcept { return lc_ulong2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_ulong2(lc_float2 v) noexcept { return lc_ulong2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_ulong2(lc_float3 v) noexcept { return lc_ulong2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_ulong2(lc_float4 v) noexcept { return lc_ulong2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_ulong2(lc_bool2 v) noexcept { return lc_ulong2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_ulong2(lc_bool3 v) noexcept { return lc_ulong2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_ulong2(lc_bool4 v) noexcept { return lc_ulong2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_ulong2(lc_long2 v) noexcept { return lc_ulong2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_ulong2(lc_long3 v) noexcept { return lc_ulong2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_ulong2(lc_long4 v) noexcept { return lc_ulong2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_ulong2(lc_ulong2 v) noexcept { return lc_ulong2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_ulong2(lc_ulong3 v) noexcept { return lc_ulong2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_ulong2(lc_ulong4 v) noexcept { return lc_ulong2{static_cast(v.x), static_cast(v.y)}; } +[[nodiscard]] inline __device__ constexpr auto lc_make_ulong3(lc_ulong s = 0) noexcept { return lc_ulong3{s, s, s}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_ulong3(lc_ulong x, lc_ulong y, lc_ulong z) noexcept { return lc_ulong3{x, y, z}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_ulong3(lc_ulong x, lc_ulong2 yz) noexcept { return lc_ulong3{x, yz.x, yz.y}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_ulong3(lc_ulong2 xy, lc_ulong z) noexcept { return lc_ulong3{xy.x, xy.y, z}; } +[[nodiscard]] __device__ constexpr auto lc_make_ulong3(lc_byte3 v) noexcept { return lc_ulong3{static_cast(v.x), static_cast(v.y), static_cast(v.z)}; } +[[nodiscard]] __device__ constexpr auto lc_make_ulong3(lc_byte4 v) noexcept { return lc_ulong3{static_cast(v.x), static_cast(v.y), static_cast(v.z)}; } +[[nodiscard]] __device__ constexpr auto lc_make_ulong3(lc_ubyte3 v) noexcept { return lc_ulong3{static_cast(v.x), static_cast(v.y), static_cast(v.z)}; } +[[nodiscard]] __device__ constexpr auto lc_make_ulong3(lc_ubyte4 v) noexcept { return lc_ulong3{static_cast(v.x), static_cast(v.y), static_cast(v.z)}; } +[[nodiscard]] __device__ constexpr auto lc_make_ulong3(lc_short3 v) noexcept { return lc_ulong3{static_cast(v.x), static_cast(v.y), static_cast(v.z)}; } +[[nodiscard]] __device__ constexpr auto lc_make_ulong3(lc_short4 v) noexcept { return lc_ulong3{static_cast(v.x), static_cast(v.y), static_cast(v.z)}; } +[[nodiscard]] __device__ constexpr auto lc_make_ulong3(lc_ushort3 v) noexcept { return lc_ulong3{static_cast(v.x), static_cast(v.y), static_cast(v.z)}; } +[[nodiscard]] __device__ constexpr auto lc_make_ulong3(lc_ushort4 v) noexcept { return lc_ulong3{static_cast(v.x), static_cast(v.y), static_cast(v.z)}; } +[[nodiscard]] __device__ constexpr auto lc_make_ulong3(lc_int3 v) noexcept { return lc_ulong3{static_cast(v.x), static_cast(v.y), static_cast(v.z)}; } +[[nodiscard]] __device__ constexpr auto lc_make_ulong3(lc_int4 v) noexcept { return lc_ulong3{static_cast(v.x), static_cast(v.y), static_cast(v.z)}; } +[[nodiscard]] __device__ constexpr auto lc_make_ulong3(lc_uint3 v) noexcept { return lc_ulong3{static_cast(v.x), static_cast(v.y), static_cast(v.z)}; } +[[nodiscard]] __device__ constexpr auto lc_make_ulong3(lc_uint4 v) noexcept { return lc_ulong3{static_cast(v.x), static_cast(v.y), static_cast(v.z)}; } +[[nodiscard]] __device__ constexpr auto lc_make_ulong3(lc_half3 v) noexcept { return lc_ulong3{static_cast(v.x), static_cast(v.y), static_cast(v.z)}; } +[[nodiscard]] __device__ constexpr auto lc_make_ulong3(lc_half4 v) noexcept { return lc_ulong3{static_cast(v.x), static_cast(v.y), static_cast(v.z)}; } +[[nodiscard]] __device__ constexpr auto lc_make_ulong3(lc_float3 v) noexcept { return lc_ulong3{static_cast(v.x), static_cast(v.y), static_cast(v.z)}; } +[[nodiscard]] __device__ constexpr auto lc_make_ulong3(lc_float4 v) noexcept { return lc_ulong3{static_cast(v.x), static_cast(v.y), static_cast(v.z)}; } +[[nodiscard]] __device__ constexpr auto lc_make_ulong3(lc_bool3 v) noexcept { return lc_ulong3{static_cast(v.x), static_cast(v.y), static_cast(v.z)}; } +[[nodiscard]] __device__ constexpr auto lc_make_ulong3(lc_bool4 v) noexcept { return lc_ulong3{static_cast(v.x), static_cast(v.y), static_cast(v.z)}; } +[[nodiscard]] __device__ constexpr auto lc_make_ulong3(lc_long3 v) noexcept { return lc_ulong3{static_cast(v.x), static_cast(v.y), static_cast(v.z)}; } +[[nodiscard]] __device__ constexpr auto lc_make_ulong3(lc_long4 v) noexcept { return lc_ulong3{static_cast(v.x), static_cast(v.y), static_cast(v.z)}; } +[[nodiscard]] __device__ constexpr auto lc_make_ulong3(lc_ulong3 v) noexcept { return lc_ulong3{static_cast(v.x), static_cast(v.y), static_cast(v.z)}; } +[[nodiscard]] __device__ constexpr auto lc_make_ulong3(lc_ulong4 v) noexcept { return lc_ulong3{static_cast(v.x), static_cast(v.y), static_cast(v.z)}; } +[[nodiscard]] inline __device__ constexpr auto lc_make_ulong4(lc_ulong s = 0) noexcept { return lc_ulong4{s, s, s, s}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_ulong4(lc_ulong x, lc_ulong y, lc_ulong z, lc_ulong w) noexcept { return lc_ulong4{x, y, z, w}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_ulong4(lc_ulong x, lc_ulong y, lc_ulong2 zw) noexcept { return lc_ulong4{x, y, zw.x, zw.y}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_ulong4(lc_ulong x, lc_ulong2 yz, lc_ulong w) noexcept { return lc_ulong4{x, yz.x, yz.y, w}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_ulong4(lc_ulong2 xy, lc_ulong z, lc_ulong w) noexcept { return lc_ulong4{xy.x, xy.y, z, w}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_ulong4(lc_ulong2 xy, lc_ulong2 zw) noexcept { return lc_ulong4{xy.x, xy.y, zw.x, zw.y}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_ulong4(lc_ulong x, lc_ulong3 yzw) noexcept { return lc_ulong4{x, yzw.x, yzw.y, yzw.z}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_ulong4(lc_ulong3 xyz, lc_ulong w) noexcept { return lc_ulong4{xyz.x, xyz.y, xyz.z, w}; } +[[nodiscard]] inline __device__ constexpr auto lc_make_ulong4(lc_byte4 v) noexcept { return lc_ulong4{static_cast(v.x), static_cast(v.y), static_cast(v.z), static_cast(v.w)}; } +[[nodiscard]] inline __device__ constexpr auto lc_make_ulong4(lc_ubyte4 v) noexcept { return lc_ulong4{static_cast(v.x), static_cast(v.y), static_cast(v.z), static_cast(v.w)}; } +[[nodiscard]] inline __device__ constexpr auto lc_make_ulong4(lc_short4 v) noexcept { return lc_ulong4{static_cast(v.x), static_cast(v.y), static_cast(v.z), static_cast(v.w)}; } +[[nodiscard]] inline __device__ constexpr auto lc_make_ulong4(lc_ushort4 v) noexcept { return lc_ulong4{static_cast(v.x), static_cast(v.y), static_cast(v.z), static_cast(v.w)}; } +[[nodiscard]] inline __device__ constexpr auto lc_make_ulong4(lc_int4 v) noexcept { return lc_ulong4{static_cast(v.x), static_cast(v.y), static_cast(v.z), static_cast(v.w)}; } +[[nodiscard]] inline __device__ constexpr auto lc_make_ulong4(lc_uint4 v) noexcept { return lc_ulong4{static_cast(v.x), static_cast(v.y), static_cast(v.z), static_cast(v.w)}; } +[[nodiscard]] inline __device__ constexpr auto lc_make_ulong4(lc_half4 v) noexcept { return lc_ulong4{static_cast(v.x), static_cast(v.y), static_cast(v.z), static_cast(v.w)}; } +[[nodiscard]] inline __device__ constexpr auto lc_make_ulong4(lc_float4 v) noexcept { return lc_ulong4{static_cast(v.x), static_cast(v.y), static_cast(v.z), static_cast(v.w)}; } +[[nodiscard]] inline __device__ constexpr auto lc_make_ulong4(lc_bool4 v) noexcept { return lc_ulong4{static_cast(v.x), static_cast(v.y), static_cast(v.z), static_cast(v.w)}; } +[[nodiscard]] inline __device__ constexpr auto lc_make_ulong4(lc_long4 v) noexcept { return lc_ulong4{static_cast(v.x), static_cast(v.y), static_cast(v.z), static_cast(v.w)}; } +[[nodiscard]] inline __device__ constexpr auto lc_make_ulong4(lc_ulong4 v) noexcept { return lc_ulong4{static_cast(v.x), static_cast(v.y), static_cast(v.z), static_cast(v.w)}; } + +[[nodiscard]] inline __device__ constexpr auto operator!(lc_byte2 v) noexcept { return lc_make_bool2(!v.x, !v.y); } +[[nodiscard]] inline __device__ constexpr auto operator+(lc_byte2 v) noexcept { return lc_make_byte2(+v.x, +v.y); } +[[nodiscard]] inline __device__ constexpr auto operator-(lc_byte2 v) noexcept { return lc_make_byte2(-v.x, -v.y); } +[[nodiscard]] inline __device__ constexpr auto operator~(lc_byte2 v) noexcept { return lc_make_byte2(~v.x, ~v.y); } +[[nodiscard]] inline __device__ constexpr auto operator!(lc_byte3 v) noexcept { return lc_make_bool3(!v.x, !v.y, !v.z); } +[[nodiscard]] inline __device__ constexpr auto operator+(lc_byte3 v) noexcept { return lc_make_byte3(+v.x, +v.y, +v.z); } +[[nodiscard]] inline __device__ constexpr auto operator-(lc_byte3 v) noexcept { return lc_make_byte3(-v.x, -v.y, -v.z); } +[[nodiscard]] inline __device__ constexpr auto operator~(lc_byte3 v) noexcept { return lc_make_byte3(~v.x, ~v.y, ~v.z); } +[[nodiscard]] inline __device__ constexpr auto operator!(lc_byte4 v) noexcept { return lc_make_bool4(!v.x, !v.y, !v.z, !v.w); } +[[nodiscard]] inline __device__ constexpr auto operator+(lc_byte4 v) noexcept { return lc_make_byte4(+v.x, +v.y, +v.z, +v.w); } +[[nodiscard]] inline __device__ constexpr auto operator-(lc_byte4 v) noexcept { return lc_make_byte4(-v.x, -v.y, -v.z, -v.w); } +[[nodiscard]] inline __device__ constexpr auto operator~(lc_byte4 v) noexcept { return lc_make_byte4(~v.x, ~v.y, ~v.z, ~v.w); } + +[[nodiscard]] inline __device__ constexpr auto operator!(lc_ubyte2 v) noexcept { return lc_make_bool2(!v.x, !v.y); } +[[nodiscard]] inline __device__ constexpr auto operator+(lc_ubyte2 v) noexcept { return lc_make_ubyte2(+v.x, +v.y); } +[[nodiscard]] inline __device__ constexpr auto operator-(lc_ubyte2 v) noexcept { return lc_make_ubyte2(-v.x, -v.y); } +[[nodiscard]] inline __device__ constexpr auto operator~(lc_ubyte2 v) noexcept { return lc_make_ubyte2(~v.x, ~v.y); } +[[nodiscard]] inline __device__ constexpr auto operator!(lc_ubyte3 v) noexcept { return lc_make_bool3(!v.x, !v.y, !v.z); } +[[nodiscard]] inline __device__ constexpr auto operator+(lc_ubyte3 v) noexcept { return lc_make_ubyte3(+v.x, +v.y, +v.z); } +[[nodiscard]] inline __device__ constexpr auto operator-(lc_ubyte3 v) noexcept { return lc_make_ubyte3(-v.x, -v.y, -v.z); } +[[nodiscard]] inline __device__ constexpr auto operator~(lc_ubyte3 v) noexcept { return lc_make_ubyte3(~v.x, ~v.y, ~v.z); } +[[nodiscard]] inline __device__ constexpr auto operator!(lc_ubyte4 v) noexcept { return lc_make_bool4(!v.x, !v.y, !v.z, !v.w); } +[[nodiscard]] inline __device__ constexpr auto operator+(lc_ubyte4 v) noexcept { return lc_make_ubyte4(+v.x, +v.y, +v.z, +v.w); } +[[nodiscard]] inline __device__ constexpr auto operator-(lc_ubyte4 v) noexcept { return lc_make_ubyte4(-v.x, -v.y, -v.z, -v.w); } +[[nodiscard]] inline __device__ constexpr auto operator~(lc_ubyte4 v) noexcept { return lc_make_ubyte4(~v.x, ~v.y, ~v.z, ~v.w); } + +[[nodiscard]] inline __device__ constexpr auto operator!(lc_short2 v) noexcept { return lc_make_bool2(!v.x, !v.y); } +[[nodiscard]] inline __device__ constexpr auto operator+(lc_short2 v) noexcept { return lc_make_short2(+v.x, +v.y); } +[[nodiscard]] inline __device__ constexpr auto operator-(lc_short2 v) noexcept { return lc_make_short2(-v.x, -v.y); } +[[nodiscard]] inline __device__ constexpr auto operator~(lc_short2 v) noexcept { return lc_make_short2(~v.x, ~v.y); } +[[nodiscard]] inline __device__ constexpr auto operator!(lc_short3 v) noexcept { return lc_make_bool3(!v.x, !v.y, !v.z); } +[[nodiscard]] inline __device__ constexpr auto operator+(lc_short3 v) noexcept { return lc_make_short3(+v.x, +v.y, +v.z); } +[[nodiscard]] inline __device__ constexpr auto operator-(lc_short3 v) noexcept { return lc_make_short3(-v.x, -v.y, -v.z); } +[[nodiscard]] inline __device__ constexpr auto operator~(lc_short3 v) noexcept { return lc_make_short3(~v.x, ~v.y, ~v.z); } +[[nodiscard]] inline __device__ constexpr auto operator!(lc_short4 v) noexcept { return lc_make_bool4(!v.x, !v.y, !v.z, !v.w); } +[[nodiscard]] inline __device__ constexpr auto operator+(lc_short4 v) noexcept { return lc_make_short4(+v.x, +v.y, +v.z, +v.w); } +[[nodiscard]] inline __device__ constexpr auto operator-(lc_short4 v) noexcept { return lc_make_short4(-v.x, -v.y, -v.z, -v.w); } +[[nodiscard]] inline __device__ constexpr auto operator~(lc_short4 v) noexcept { return lc_make_short4(~v.x, ~v.y, ~v.z, ~v.w); } + +[[nodiscard]] inline __device__ constexpr auto operator!(lc_ushort2 v) noexcept { return lc_make_bool2(!v.x, !v.y); } +[[nodiscard]] inline __device__ constexpr auto operator+(lc_ushort2 v) noexcept { return lc_make_ushort2(+v.x, +v.y); } +[[nodiscard]] inline __device__ constexpr auto operator-(lc_ushort2 v) noexcept { return lc_make_ushort2(-v.x, -v.y); } +[[nodiscard]] inline __device__ constexpr auto operator~(lc_ushort2 v) noexcept { return lc_make_ushort2(~v.x, ~v.y); } +[[nodiscard]] inline __device__ constexpr auto operator!(lc_ushort3 v) noexcept { return lc_make_bool3(!v.x, !v.y, !v.z); } +[[nodiscard]] inline __device__ constexpr auto operator+(lc_ushort3 v) noexcept { return lc_make_ushort3(+v.x, +v.y, +v.z); } +[[nodiscard]] inline __device__ constexpr auto operator-(lc_ushort3 v) noexcept { return lc_make_ushort3(-v.x, -v.y, -v.z); } +[[nodiscard]] inline __device__ constexpr auto operator~(lc_ushort3 v) noexcept { return lc_make_ushort3(~v.x, ~v.y, ~v.z); } +[[nodiscard]] inline __device__ constexpr auto operator!(lc_ushort4 v) noexcept { return lc_make_bool4(!v.x, !v.y, !v.z, !v.w); } +[[nodiscard]] inline __device__ constexpr auto operator+(lc_ushort4 v) noexcept { return lc_make_ushort4(+v.x, +v.y, +v.z, +v.w); } +[[nodiscard]] inline __device__ constexpr auto operator-(lc_ushort4 v) noexcept { return lc_make_ushort4(-v.x, -v.y, -v.z, -v.w); } +[[nodiscard]] inline __device__ constexpr auto operator~(lc_ushort4 v) noexcept { return lc_make_ushort4(~v.x, ~v.y, ~v.z, ~v.w); } + +[[nodiscard]] inline __device__ constexpr auto operator!(lc_int2 v) noexcept { return lc_make_bool2(!v.x, !v.y); } +[[nodiscard]] inline __device__ constexpr auto operator+(lc_int2 v) noexcept { return lc_make_int2(+v.x, +v.y); } +[[nodiscard]] inline __device__ constexpr auto operator-(lc_int2 v) noexcept { return lc_make_int2(-v.x, -v.y); } +[[nodiscard]] inline __device__ constexpr auto operator~(lc_int2 v) noexcept { return lc_make_int2(~v.x, ~v.y); } +[[nodiscard]] inline __device__ constexpr auto operator!(lc_int3 v) noexcept { return lc_make_bool3(!v.x, !v.y, !v.z); } +[[nodiscard]] inline __device__ constexpr auto operator+(lc_int3 v) noexcept { return lc_make_int3(+v.x, +v.y, +v.z); } +[[nodiscard]] inline __device__ constexpr auto operator-(lc_int3 v) noexcept { return lc_make_int3(-v.x, -v.y, -v.z); } +[[nodiscard]] inline __device__ constexpr auto operator~(lc_int3 v) noexcept { return lc_make_int3(~v.x, ~v.y, ~v.z); } +[[nodiscard]] inline __device__ constexpr auto operator!(lc_int4 v) noexcept { return lc_make_bool4(!v.x, !v.y, !v.z, !v.w); } +[[nodiscard]] inline __device__ constexpr auto operator+(lc_int4 v) noexcept { return lc_make_int4(+v.x, +v.y, +v.z, +v.w); } +[[nodiscard]] inline __device__ constexpr auto operator-(lc_int4 v) noexcept { return lc_make_int4(-v.x, -v.y, -v.z, -v.w); } +[[nodiscard]] inline __device__ constexpr auto operator~(lc_int4 v) noexcept { return lc_make_int4(~v.x, ~v.y, ~v.z, ~v.w); } + +[[nodiscard]] inline __device__ constexpr auto operator!(lc_uint2 v) noexcept { return lc_make_bool2(!v.x, !v.y); } +[[nodiscard]] inline __device__ constexpr auto operator+(lc_uint2 v) noexcept { return lc_make_uint2(+v.x, +v.y); } +[[nodiscard]] inline __device__ constexpr auto operator-(lc_uint2 v) noexcept { return lc_make_uint2(-v.x, -v.y); } +[[nodiscard]] inline __device__ constexpr auto operator~(lc_uint2 v) noexcept { return lc_make_uint2(~v.x, ~v.y); } +[[nodiscard]] inline __device__ constexpr auto operator!(lc_uint3 v) noexcept { return lc_make_bool3(!v.x, !v.y, !v.z); } +[[nodiscard]] inline __device__ constexpr auto operator+(lc_uint3 v) noexcept { return lc_make_uint3(+v.x, +v.y, +v.z); } +[[nodiscard]] inline __device__ constexpr auto operator-(lc_uint3 v) noexcept { return lc_make_uint3(-v.x, -v.y, -v.z); } +[[nodiscard]] inline __device__ constexpr auto operator~(lc_uint3 v) noexcept { return lc_make_uint3(~v.x, ~v.y, ~v.z); } +[[nodiscard]] inline __device__ constexpr auto operator!(lc_uint4 v) noexcept { return lc_make_bool4(!v.x, !v.y, !v.z, !v.w); } +[[nodiscard]] inline __device__ constexpr auto operator+(lc_uint4 v) noexcept { return lc_make_uint4(+v.x, +v.y, +v.z, +v.w); } +[[nodiscard]] inline __device__ constexpr auto operator-(lc_uint4 v) noexcept { return lc_make_uint4(-v.x, -v.y, -v.z, -v.w); } +[[nodiscard]] inline __device__ constexpr auto operator~(lc_uint4 v) noexcept { return lc_make_uint4(~v.x, ~v.y, ~v.z, ~v.w); } + +[[nodiscard]] inline __device__ constexpr auto operator!(lc_half2 v) noexcept { return lc_make_bool2(!v.x, !v.y); } +[[nodiscard]] inline __device__ constexpr auto operator+(lc_half2 v) noexcept { return lc_make_half2(+v.x, +v.y); } +[[nodiscard]] inline __device__ constexpr auto operator-(lc_half2 v) noexcept { return lc_make_half2(-v.x, -v.y); } +[[nodiscard]] inline __device__ constexpr auto operator!(lc_half3 v) noexcept { return lc_make_bool3(!v.x, !v.y, !v.z); } +[[nodiscard]] inline __device__ constexpr auto operator+(lc_half3 v) noexcept { return lc_make_half3(+v.x, +v.y, +v.z); } +[[nodiscard]] inline __device__ constexpr auto operator-(lc_half3 v) noexcept { return lc_make_half3(-v.x, -v.y, -v.z); } +[[nodiscard]] inline __device__ constexpr auto operator!(lc_half4 v) noexcept { return lc_make_bool4(!v.x, !v.y, !v.z, !v.w); } +[[nodiscard]] inline __device__ constexpr auto operator+(lc_half4 v) noexcept { return lc_make_half4(+v.x, +v.y, +v.z, +v.w); } +[[nodiscard]] inline __device__ constexpr auto operator-(lc_half4 v) noexcept { return lc_make_half4(-v.x, -v.y, -v.z, -v.w); } + +[[nodiscard]] inline __device__ constexpr auto operator!(lc_float2 v) noexcept { return lc_make_bool2(!v.x, !v.y); } +[[nodiscard]] inline __device__ constexpr auto operator+(lc_float2 v) noexcept { return lc_make_float2(+v.x, +v.y); } +[[nodiscard]] inline __device__ constexpr auto operator-(lc_float2 v) noexcept { return lc_make_float2(-v.x, -v.y); } +[[nodiscard]] inline __device__ constexpr auto operator!(lc_float3 v) noexcept { return lc_make_bool3(!v.x, !v.y, !v.z); } +[[nodiscard]] inline __device__ constexpr auto operator+(lc_float3 v) noexcept { return lc_make_float3(+v.x, +v.y, +v.z); } +[[nodiscard]] inline __device__ constexpr auto operator-(lc_float3 v) noexcept { return lc_make_float3(-v.x, -v.y, -v.z); } +[[nodiscard]] inline __device__ constexpr auto operator!(lc_float4 v) noexcept { return lc_make_bool4(!v.x, !v.y, !v.z, !v.w); } +[[nodiscard]] inline __device__ constexpr auto operator+(lc_float4 v) noexcept { return lc_make_float4(+v.x, +v.y, +v.z, +v.w); } +[[nodiscard]] inline __device__ constexpr auto operator-(lc_float4 v) noexcept { return lc_make_float4(-v.x, -v.y, -v.z, -v.w); } + +[[nodiscard]] inline __device__ constexpr auto operator!(lc_bool2 v) noexcept { return lc_make_bool2(!v.x, !v.y); } +[[nodiscard]] inline __device__ constexpr auto operator!(lc_bool3 v) noexcept { return lc_make_bool3(!v.x, !v.y, !v.z); } +[[nodiscard]] inline __device__ constexpr auto operator!(lc_bool4 v) noexcept { return lc_make_bool4(!v.x, !v.y, !v.z, !v.w); } + +[[nodiscard]] inline __device__ constexpr auto operator!(lc_long2 v) noexcept { return lc_make_bool2(!v.x, !v.y); } +[[nodiscard]] inline __device__ constexpr auto operator+(lc_long2 v) noexcept { return lc_make_long2(+v.x, +v.y); } +[[nodiscard]] inline __device__ constexpr auto operator-(lc_long2 v) noexcept { return lc_make_long2(-v.x, -v.y); } +[[nodiscard]] inline __device__ constexpr auto operator~(lc_long2 v) noexcept { return lc_make_long2(~v.x, ~v.y); } +[[nodiscard]] inline __device__ constexpr auto operator!(lc_long3 v) noexcept { return lc_make_bool3(!v.x, !v.y, !v.z); } +[[nodiscard]] inline __device__ constexpr auto operator+(lc_long3 v) noexcept { return lc_make_long3(+v.x, +v.y, +v.z); } +[[nodiscard]] inline __device__ constexpr auto operator-(lc_long3 v) noexcept { return lc_make_long3(-v.x, -v.y, -v.z); } +[[nodiscard]] inline __device__ constexpr auto operator~(lc_long3 v) noexcept { return lc_make_long3(~v.x, ~v.y, ~v.z); } +[[nodiscard]] inline __device__ constexpr auto operator!(lc_long4 v) noexcept { return lc_make_bool4(!v.x, !v.y, !v.z, !v.w); } +[[nodiscard]] inline __device__ constexpr auto operator+(lc_long4 v) noexcept { return lc_make_long4(+v.x, +v.y, +v.z, +v.w); } +[[nodiscard]] inline __device__ constexpr auto operator-(lc_long4 v) noexcept { return lc_make_long4(-v.x, -v.y, -v.z, -v.w); } +[[nodiscard]] inline __device__ constexpr auto operator~(lc_long4 v) noexcept { return lc_make_long4(~v.x, ~v.y, ~v.z, ~v.w); } + +[[nodiscard]] inline __device__ constexpr auto operator!(lc_ulong2 v) noexcept { return lc_make_bool2(!v.x, !v.y); } +[[nodiscard]] inline __device__ constexpr auto operator+(lc_ulong2 v) noexcept { return lc_make_ulong2(+v.x, +v.y); } +[[nodiscard]] inline __device__ constexpr auto operator-(lc_ulong2 v) noexcept { return lc_make_ulong2(-v.x, -v.y); } +[[nodiscard]] inline __device__ constexpr auto operator~(lc_ulong2 v) noexcept { return lc_make_ulong2(~v.x, ~v.y); } +[[nodiscard]] inline __device__ constexpr auto operator!(lc_ulong3 v) noexcept { return lc_make_bool3(!v.x, !v.y, !v.z); } +[[nodiscard]] inline __device__ constexpr auto operator+(lc_ulong3 v) noexcept { return lc_make_ulong3(+v.x, +v.y, +v.z); } +[[nodiscard]] inline __device__ constexpr auto operator-(lc_ulong3 v) noexcept { return lc_make_ulong3(-v.x, -v.y, -v.z); } +[[nodiscard]] inline __device__ constexpr auto operator~(lc_ulong3 v) noexcept { return lc_make_ulong3(~v.x, ~v.y, ~v.z); } +[[nodiscard]] inline __device__ constexpr auto operator!(lc_ulong4 v) noexcept { return lc_make_bool4(!v.x, !v.y, !v.z, !v.w); } +[[nodiscard]] inline __device__ constexpr auto operator+(lc_ulong4 v) noexcept { return lc_make_ulong4(+v.x, +v.y, +v.z, +v.w); } +[[nodiscard]] inline __device__ constexpr auto operator-(lc_ulong4 v) noexcept { return lc_make_ulong4(-v.x, -v.y, -v.z, -v.w); } +[[nodiscard]] inline __device__ constexpr auto operator~(lc_ulong4 v) noexcept { return lc_make_ulong4(~v.x, ~v.y, ~v.z, ~v.w); } + +[[nodiscard]] inline __device__ constexpr auto operator==(lc_byte2 lhs, lc_byte2 rhs) noexcept { return lc_make_bool2(lhs.x == rhs.x, lhs.y == rhs.y); } +[[nodiscard]] inline __device__ constexpr auto operator==(lc_byte2 lhs, lc_byte rhs) noexcept { return lc_make_bool2(lhs.x == rhs, lhs.y == rhs); } +[[nodiscard]] inline __device__ constexpr auto operator==(lc_byte lhs, lc_byte2 rhs) noexcept { return lc_make_bool2(lhs == rhs.x, lhs == rhs.y); } +[[nodiscard]] inline __device__ constexpr auto operator==(lc_byte3 lhs, lc_byte3 rhs) noexcept { return lc_make_bool3(lhs.x == rhs.x, lhs.y == rhs.y, lhs.z == rhs.z); } +[[nodiscard]] inline __device__ constexpr auto operator==(lc_byte3 lhs, lc_byte rhs) noexcept { return lc_make_bool3(lhs.x == rhs, lhs.y == rhs, lhs.z == rhs); } +[[nodiscard]] inline __device__ constexpr auto operator==(lc_byte lhs, lc_byte3 rhs) noexcept { return lc_make_bool3(lhs == rhs.x, lhs == rhs.y, lhs == rhs.z); } +[[nodiscard]] inline __device__ constexpr auto operator==(lc_byte4 lhs, lc_byte4 rhs) noexcept { return lc_make_bool4(lhs.x == rhs.x, lhs.y == rhs.y, lhs.z == rhs.z, lhs.w == rhs.w); } +[[nodiscard]] inline __device__ constexpr auto operator==(lc_byte4 lhs, lc_byte rhs) noexcept { return lc_make_bool4(lhs.x == rhs, lhs.y == rhs, lhs.z == rhs, lhs.w == rhs); } +[[nodiscard]] inline __device__ constexpr auto operator==(lc_byte lhs, lc_byte4 rhs) noexcept { return lc_make_bool4(lhs == rhs.x, lhs == rhs.y, lhs == rhs.z, lhs == rhs.w); } +[[nodiscard]] inline __device__ constexpr auto operator==(lc_ubyte2 lhs, lc_ubyte2 rhs) noexcept { return lc_make_bool2(lhs.x == rhs.x, lhs.y == rhs.y); } +[[nodiscard]] inline __device__ constexpr auto operator==(lc_ubyte2 lhs, lc_ubyte rhs) noexcept { return lc_make_bool2(lhs.x == rhs, lhs.y == rhs); } +[[nodiscard]] inline __device__ constexpr auto operator==(lc_ubyte lhs, lc_ubyte2 rhs) noexcept { return lc_make_bool2(lhs == rhs.x, lhs == rhs.y); } +[[nodiscard]] inline __device__ constexpr auto operator==(lc_ubyte3 lhs, lc_ubyte3 rhs) noexcept { return lc_make_bool3(lhs.x == rhs.x, lhs.y == rhs.y, lhs.z == rhs.z); } +[[nodiscard]] inline __device__ constexpr auto operator==(lc_ubyte3 lhs, lc_ubyte rhs) noexcept { return lc_make_bool3(lhs.x == rhs, lhs.y == rhs, lhs.z == rhs); } +[[nodiscard]] inline __device__ constexpr auto operator==(lc_ubyte lhs, lc_ubyte3 rhs) noexcept { return lc_make_bool3(lhs == rhs.x, lhs == rhs.y, lhs == rhs.z); } +[[nodiscard]] inline __device__ constexpr auto operator==(lc_ubyte4 lhs, lc_ubyte4 rhs) noexcept { return lc_make_bool4(lhs.x == rhs.x, lhs.y == rhs.y, lhs.z == rhs.z, lhs.w == rhs.w); } +[[nodiscard]] inline __device__ constexpr auto operator==(lc_ubyte4 lhs, lc_ubyte rhs) noexcept { return lc_make_bool4(lhs.x == rhs, lhs.y == rhs, lhs.z == rhs, lhs.w == rhs); } +[[nodiscard]] inline __device__ constexpr auto operator==(lc_ubyte lhs, lc_ubyte4 rhs) noexcept { return lc_make_bool4(lhs == rhs.x, lhs == rhs.y, lhs == rhs.z, lhs == rhs.w); } +[[nodiscard]] inline __device__ constexpr auto operator==(lc_short2 lhs, lc_short2 rhs) noexcept { return lc_make_bool2(lhs.x == rhs.x, lhs.y == rhs.y); } +[[nodiscard]] inline __device__ constexpr auto operator==(lc_short2 lhs, lc_short rhs) noexcept { return lc_make_bool2(lhs.x == rhs, lhs.y == rhs); } +[[nodiscard]] inline __device__ constexpr auto operator==(lc_short lhs, lc_short2 rhs) noexcept { return lc_make_bool2(lhs == rhs.x, lhs == rhs.y); } +[[nodiscard]] inline __device__ constexpr auto operator==(lc_short3 lhs, lc_short3 rhs) noexcept { return lc_make_bool3(lhs.x == rhs.x, lhs.y == rhs.y, lhs.z == rhs.z); } +[[nodiscard]] inline __device__ constexpr auto operator==(lc_short3 lhs, lc_short rhs) noexcept { return lc_make_bool3(lhs.x == rhs, lhs.y == rhs, lhs.z == rhs); } +[[nodiscard]] inline __device__ constexpr auto operator==(lc_short lhs, lc_short3 rhs) noexcept { return lc_make_bool3(lhs == rhs.x, lhs == rhs.y, lhs == rhs.z); } +[[nodiscard]] inline __device__ constexpr auto operator==(lc_short4 lhs, lc_short4 rhs) noexcept { return lc_make_bool4(lhs.x == rhs.x, lhs.y == rhs.y, lhs.z == rhs.z, lhs.w == rhs.w); } +[[nodiscard]] inline __device__ constexpr auto operator==(lc_short4 lhs, lc_short rhs) noexcept { return lc_make_bool4(lhs.x == rhs, lhs.y == rhs, lhs.z == rhs, lhs.w == rhs); } +[[nodiscard]] inline __device__ constexpr auto operator==(lc_short lhs, lc_short4 rhs) noexcept { return lc_make_bool4(lhs == rhs.x, lhs == rhs.y, lhs == rhs.z, lhs == rhs.w); } +[[nodiscard]] inline __device__ constexpr auto operator==(lc_ushort2 lhs, lc_ushort2 rhs) noexcept { return lc_make_bool2(lhs.x == rhs.x, lhs.y == rhs.y); } +[[nodiscard]] inline __device__ constexpr auto operator==(lc_ushort2 lhs, lc_ushort rhs) noexcept { return lc_make_bool2(lhs.x == rhs, lhs.y == rhs); } +[[nodiscard]] inline __device__ constexpr auto operator==(lc_ushort lhs, lc_ushort2 rhs) noexcept { return lc_make_bool2(lhs == rhs.x, lhs == rhs.y); } +[[nodiscard]] inline __device__ constexpr auto operator==(lc_ushort3 lhs, lc_ushort3 rhs) noexcept { return lc_make_bool3(lhs.x == rhs.x, lhs.y == rhs.y, lhs.z == rhs.z); } +[[nodiscard]] inline __device__ constexpr auto operator==(lc_ushort3 lhs, lc_ushort rhs) noexcept { return lc_make_bool3(lhs.x == rhs, lhs.y == rhs, lhs.z == rhs); } +[[nodiscard]] inline __device__ constexpr auto operator==(lc_ushort lhs, lc_ushort3 rhs) noexcept { return lc_make_bool3(lhs == rhs.x, lhs == rhs.y, lhs == rhs.z); } +[[nodiscard]] inline __device__ constexpr auto operator==(lc_ushort4 lhs, lc_ushort4 rhs) noexcept { return lc_make_bool4(lhs.x == rhs.x, lhs.y == rhs.y, lhs.z == rhs.z, lhs.w == rhs.w); } +[[nodiscard]] inline __device__ constexpr auto operator==(lc_ushort4 lhs, lc_ushort rhs) noexcept { return lc_make_bool4(lhs.x == rhs, lhs.y == rhs, lhs.z == rhs, lhs.w == rhs); } +[[nodiscard]] inline __device__ constexpr auto operator==(lc_ushort lhs, lc_ushort4 rhs) noexcept { return lc_make_bool4(lhs == rhs.x, lhs == rhs.y, lhs == rhs.z, lhs == rhs.w); } +[[nodiscard]] inline __device__ constexpr auto operator==(lc_int2 lhs, lc_int2 rhs) noexcept { return lc_make_bool2(lhs.x == rhs.x, lhs.y == rhs.y); } +[[nodiscard]] inline __device__ constexpr auto operator==(lc_int2 lhs, lc_int rhs) noexcept { return lc_make_bool2(lhs.x == rhs, lhs.y == rhs); } +[[nodiscard]] inline __device__ constexpr auto operator==(lc_int lhs, lc_int2 rhs) noexcept { return lc_make_bool2(lhs == rhs.x, lhs == rhs.y); } +[[nodiscard]] inline __device__ constexpr auto operator==(lc_int3 lhs, lc_int3 rhs) noexcept { return lc_make_bool3(lhs.x == rhs.x, lhs.y == rhs.y, lhs.z == rhs.z); } +[[nodiscard]] inline __device__ constexpr auto operator==(lc_int3 lhs, lc_int rhs) noexcept { return lc_make_bool3(lhs.x == rhs, lhs.y == rhs, lhs.z == rhs); } +[[nodiscard]] inline __device__ constexpr auto operator==(lc_int lhs, lc_int3 rhs) noexcept { return lc_make_bool3(lhs == rhs.x, lhs == rhs.y, lhs == rhs.z); } +[[nodiscard]] inline __device__ constexpr auto operator==(lc_int4 lhs, lc_int4 rhs) noexcept { return lc_make_bool4(lhs.x == rhs.x, lhs.y == rhs.y, lhs.z == rhs.z, lhs.w == rhs.w); } +[[nodiscard]] inline __device__ constexpr auto operator==(lc_int4 lhs, lc_int rhs) noexcept { return lc_make_bool4(lhs.x == rhs, lhs.y == rhs, lhs.z == rhs, lhs.w == rhs); } +[[nodiscard]] inline __device__ constexpr auto operator==(lc_int lhs, lc_int4 rhs) noexcept { return lc_make_bool4(lhs == rhs.x, lhs == rhs.y, lhs == rhs.z, lhs == rhs.w); } +[[nodiscard]] inline __device__ constexpr auto operator==(lc_uint2 lhs, lc_uint2 rhs) noexcept { return lc_make_bool2(lhs.x == rhs.x, lhs.y == rhs.y); } +[[nodiscard]] inline __device__ constexpr auto operator==(lc_uint2 lhs, lc_uint rhs) noexcept { return lc_make_bool2(lhs.x == rhs, lhs.y == rhs); } +[[nodiscard]] inline __device__ constexpr auto operator==(lc_uint lhs, lc_uint2 rhs) noexcept { return lc_make_bool2(lhs == rhs.x, lhs == rhs.y); } +[[nodiscard]] inline __device__ constexpr auto operator==(lc_uint3 lhs, lc_uint3 rhs) noexcept { return lc_make_bool3(lhs.x == rhs.x, lhs.y == rhs.y, lhs.z == rhs.z); } +[[nodiscard]] inline __device__ constexpr auto operator==(lc_uint3 lhs, lc_uint rhs) noexcept { return lc_make_bool3(lhs.x == rhs, lhs.y == rhs, lhs.z == rhs); } +[[nodiscard]] inline __device__ constexpr auto operator==(lc_uint lhs, lc_uint3 rhs) noexcept { return lc_make_bool3(lhs == rhs.x, lhs == rhs.y, lhs == rhs.z); } +[[nodiscard]] inline __device__ constexpr auto operator==(lc_uint4 lhs, lc_uint4 rhs) noexcept { return lc_make_bool4(lhs.x == rhs.x, lhs.y == rhs.y, lhs.z == rhs.z, lhs.w == rhs.w); } +[[nodiscard]] inline __device__ constexpr auto operator==(lc_uint4 lhs, lc_uint rhs) noexcept { return lc_make_bool4(lhs.x == rhs, lhs.y == rhs, lhs.z == rhs, lhs.w == rhs); } +[[nodiscard]] inline __device__ constexpr auto operator==(lc_uint lhs, lc_uint4 rhs) noexcept { return lc_make_bool4(lhs == rhs.x, lhs == rhs.y, lhs == rhs.z, lhs == rhs.w); } +[[nodiscard]] inline __device__ constexpr auto operator==(lc_half2 lhs, lc_half2 rhs) noexcept { return lc_make_bool2(lhs.x == rhs.x, lhs.y == rhs.y); } +[[nodiscard]] inline __device__ constexpr auto operator==(lc_half2 lhs, lc_half rhs) noexcept { return lc_make_bool2(lhs.x == rhs, lhs.y == rhs); } +[[nodiscard]] inline __device__ constexpr auto operator==(lc_half lhs, lc_half2 rhs) noexcept { return lc_make_bool2(lhs == rhs.x, lhs == rhs.y); } +[[nodiscard]] inline __device__ constexpr auto operator==(lc_half3 lhs, lc_half3 rhs) noexcept { return lc_make_bool3(lhs.x == rhs.x, lhs.y == rhs.y, lhs.z == rhs.z); } +[[nodiscard]] inline __device__ constexpr auto operator==(lc_half3 lhs, lc_half rhs) noexcept { return lc_make_bool3(lhs.x == rhs, lhs.y == rhs, lhs.z == rhs); } +[[nodiscard]] inline __device__ constexpr auto operator==(lc_half lhs, lc_half3 rhs) noexcept { return lc_make_bool3(lhs == rhs.x, lhs == rhs.y, lhs == rhs.z); } +[[nodiscard]] inline __device__ constexpr auto operator==(lc_half4 lhs, lc_half4 rhs) noexcept { return lc_make_bool4(lhs.x == rhs.x, lhs.y == rhs.y, lhs.z == rhs.z, lhs.w == rhs.w); } +[[nodiscard]] inline __device__ constexpr auto operator==(lc_half4 lhs, lc_half rhs) noexcept { return lc_make_bool4(lhs.x == rhs, lhs.y == rhs, lhs.z == rhs, lhs.w == rhs); } +[[nodiscard]] inline __device__ constexpr auto operator==(lc_half lhs, lc_half4 rhs) noexcept { return lc_make_bool4(lhs == rhs.x, lhs == rhs.y, lhs == rhs.z, lhs == rhs.w); } +[[nodiscard]] inline __device__ constexpr auto operator==(lc_float2 lhs, lc_float2 rhs) noexcept { return lc_make_bool2(lhs.x == rhs.x, lhs.y == rhs.y); } +[[nodiscard]] inline __device__ constexpr auto operator==(lc_float2 lhs, lc_float rhs) noexcept { return lc_make_bool2(lhs.x == rhs, lhs.y == rhs); } +[[nodiscard]] inline __device__ constexpr auto operator==(lc_float lhs, lc_float2 rhs) noexcept { return lc_make_bool2(lhs == rhs.x, lhs == rhs.y); } +[[nodiscard]] inline __device__ constexpr auto operator==(lc_float3 lhs, lc_float3 rhs) noexcept { return lc_make_bool3(lhs.x == rhs.x, lhs.y == rhs.y, lhs.z == rhs.z); } +[[nodiscard]] inline __device__ constexpr auto operator==(lc_float3 lhs, lc_float rhs) noexcept { return lc_make_bool3(lhs.x == rhs, lhs.y == rhs, lhs.z == rhs); } +[[nodiscard]] inline __device__ constexpr auto operator==(lc_float lhs, lc_float3 rhs) noexcept { return lc_make_bool3(lhs == rhs.x, lhs == rhs.y, lhs == rhs.z); } +[[nodiscard]] inline __device__ constexpr auto operator==(lc_float4 lhs, lc_float4 rhs) noexcept { return lc_make_bool4(lhs.x == rhs.x, lhs.y == rhs.y, lhs.z == rhs.z, lhs.w == rhs.w); } +[[nodiscard]] inline __device__ constexpr auto operator==(lc_float4 lhs, lc_float rhs) noexcept { return lc_make_bool4(lhs.x == rhs, lhs.y == rhs, lhs.z == rhs, lhs.w == rhs); } +[[nodiscard]] inline __device__ constexpr auto operator==(lc_float lhs, lc_float4 rhs) noexcept { return lc_make_bool4(lhs == rhs.x, lhs == rhs.y, lhs == rhs.z, lhs == rhs.w); } +[[nodiscard]] inline __device__ constexpr auto operator==(lc_bool2 lhs, lc_bool2 rhs) noexcept { return lc_make_bool2(lhs.x == rhs.x, lhs.y == rhs.y); } +[[nodiscard]] inline __device__ constexpr auto operator==(lc_bool2 lhs, lc_bool rhs) noexcept { return lc_make_bool2(lhs.x == rhs, lhs.y == rhs); } +[[nodiscard]] inline __device__ constexpr auto operator==(lc_bool lhs, lc_bool2 rhs) noexcept { return lc_make_bool2(lhs == rhs.x, lhs == rhs.y); } +[[nodiscard]] inline __device__ constexpr auto operator==(lc_bool3 lhs, lc_bool3 rhs) noexcept { return lc_make_bool3(lhs.x == rhs.x, lhs.y == rhs.y, lhs.z == rhs.z); } +[[nodiscard]] inline __device__ constexpr auto operator==(lc_bool3 lhs, lc_bool rhs) noexcept { return lc_make_bool3(lhs.x == rhs, lhs.y == rhs, lhs.z == rhs); } +[[nodiscard]] inline __device__ constexpr auto operator==(lc_bool lhs, lc_bool3 rhs) noexcept { return lc_make_bool3(lhs == rhs.x, lhs == rhs.y, lhs == rhs.z); } +[[nodiscard]] inline __device__ constexpr auto operator==(lc_bool4 lhs, lc_bool4 rhs) noexcept { return lc_make_bool4(lhs.x == rhs.x, lhs.y == rhs.y, lhs.z == rhs.z, lhs.w == rhs.w); } +[[nodiscard]] inline __device__ constexpr auto operator==(lc_bool4 lhs, lc_bool rhs) noexcept { return lc_make_bool4(lhs.x == rhs, lhs.y == rhs, lhs.z == rhs, lhs.w == rhs); } +[[nodiscard]] inline __device__ constexpr auto operator==(lc_bool lhs, lc_bool4 rhs) noexcept { return lc_make_bool4(lhs == rhs.x, lhs == rhs.y, lhs == rhs.z, lhs == rhs.w); } +[[nodiscard]] inline __device__ constexpr auto operator==(lc_long2 lhs, lc_long2 rhs) noexcept { return lc_make_bool2(lhs.x == rhs.x, lhs.y == rhs.y); } +[[nodiscard]] inline __device__ constexpr auto operator==(lc_long2 lhs, lc_long rhs) noexcept { return lc_make_bool2(lhs.x == rhs, lhs.y == rhs); } +[[nodiscard]] inline __device__ constexpr auto operator==(lc_long lhs, lc_long2 rhs) noexcept { return lc_make_bool2(lhs == rhs.x, lhs == rhs.y); } +[[nodiscard]] inline __device__ constexpr auto operator==(lc_long3 lhs, lc_long3 rhs) noexcept { return lc_make_bool3(lhs.x == rhs.x, lhs.y == rhs.y, lhs.z == rhs.z); } +[[nodiscard]] inline __device__ constexpr auto operator==(lc_long3 lhs, lc_long rhs) noexcept { return lc_make_bool3(lhs.x == rhs, lhs.y == rhs, lhs.z == rhs); } +[[nodiscard]] inline __device__ constexpr auto operator==(lc_long lhs, lc_long3 rhs) noexcept { return lc_make_bool3(lhs == rhs.x, lhs == rhs.y, lhs == rhs.z); } +[[nodiscard]] inline __device__ constexpr auto operator==(lc_long4 lhs, lc_long4 rhs) noexcept { return lc_make_bool4(lhs.x == rhs.x, lhs.y == rhs.y, lhs.z == rhs.z, lhs.w == rhs.w); } +[[nodiscard]] inline __device__ constexpr auto operator==(lc_long4 lhs, lc_long rhs) noexcept { return lc_make_bool4(lhs.x == rhs, lhs.y == rhs, lhs.z == rhs, lhs.w == rhs); } +[[nodiscard]] inline __device__ constexpr auto operator==(lc_long lhs, lc_long4 rhs) noexcept { return lc_make_bool4(lhs == rhs.x, lhs == rhs.y, lhs == rhs.z, lhs == rhs.w); } +[[nodiscard]] inline __device__ constexpr auto operator==(lc_ulong2 lhs, lc_ulong2 rhs) noexcept { return lc_make_bool2(lhs.x == rhs.x, lhs.y == rhs.y); } +[[nodiscard]] inline __device__ constexpr auto operator==(lc_ulong2 lhs, lc_ulong rhs) noexcept { return lc_make_bool2(lhs.x == rhs, lhs.y == rhs); } +[[nodiscard]] inline __device__ constexpr auto operator==(lc_ulong lhs, lc_ulong2 rhs) noexcept { return lc_make_bool2(lhs == rhs.x, lhs == rhs.y); } +[[nodiscard]] inline __device__ constexpr auto operator==(lc_ulong3 lhs, lc_ulong3 rhs) noexcept { return lc_make_bool3(lhs.x == rhs.x, lhs.y == rhs.y, lhs.z == rhs.z); } +[[nodiscard]] inline __device__ constexpr auto operator==(lc_ulong3 lhs, lc_ulong rhs) noexcept { return lc_make_bool3(lhs.x == rhs, lhs.y == rhs, lhs.z == rhs); } +[[nodiscard]] inline __device__ constexpr auto operator==(lc_ulong lhs, lc_ulong3 rhs) noexcept { return lc_make_bool3(lhs == rhs.x, lhs == rhs.y, lhs == rhs.z); } +[[nodiscard]] inline __device__ constexpr auto operator==(lc_ulong4 lhs, lc_ulong4 rhs) noexcept { return lc_make_bool4(lhs.x == rhs.x, lhs.y == rhs.y, lhs.z == rhs.z, lhs.w == rhs.w); } +[[nodiscard]] inline __device__ constexpr auto operator==(lc_ulong4 lhs, lc_ulong rhs) noexcept { return lc_make_bool4(lhs.x == rhs, lhs.y == rhs, lhs.z == rhs, lhs.w == rhs); } +[[nodiscard]] inline __device__ constexpr auto operator==(lc_ulong lhs, lc_ulong4 rhs) noexcept { return lc_make_bool4(lhs == rhs.x, lhs == rhs.y, lhs == rhs.z, lhs == rhs.w); } + +[[nodiscard]] inline __device__ constexpr auto operator!=(lc_byte2 lhs, lc_byte2 rhs) noexcept { return lc_make_bool2(lhs.x != rhs.x, lhs.y != rhs.y); } +[[nodiscard]] inline __device__ constexpr auto operator!=(lc_byte2 lhs, lc_byte rhs) noexcept { return lc_make_bool2(lhs.x != rhs, lhs.y != rhs); } +[[nodiscard]] inline __device__ constexpr auto operator!=(lc_byte lhs, lc_byte2 rhs) noexcept { return lc_make_bool2(lhs != rhs.x, lhs != rhs.y); } +[[nodiscard]] inline __device__ constexpr auto operator!=(lc_byte3 lhs, lc_byte3 rhs) noexcept { return lc_make_bool3(lhs.x != rhs.x, lhs.y != rhs.y, lhs.z != rhs.z); } +[[nodiscard]] inline __device__ constexpr auto operator!=(lc_byte3 lhs, lc_byte rhs) noexcept { return lc_make_bool3(lhs.x != rhs, lhs.y != rhs, lhs.z != rhs); } +[[nodiscard]] inline __device__ constexpr auto operator!=(lc_byte lhs, lc_byte3 rhs) noexcept { return lc_make_bool3(lhs != rhs.x, lhs != rhs.y, lhs != rhs.z); } +[[nodiscard]] inline __device__ constexpr auto operator!=(lc_byte4 lhs, lc_byte4 rhs) noexcept { return lc_make_bool4(lhs.x != rhs.x, lhs.y != rhs.y, lhs.z != rhs.z, lhs.w != rhs.w); } +[[nodiscard]] inline __device__ constexpr auto operator!=(lc_byte4 lhs, lc_byte rhs) noexcept { return lc_make_bool4(lhs.x != rhs, lhs.y != rhs, lhs.z != rhs, lhs.w != rhs); } +[[nodiscard]] inline __device__ constexpr auto operator!=(lc_byte lhs, lc_byte4 rhs) noexcept { return lc_make_bool4(lhs != rhs.x, lhs != rhs.y, lhs != rhs.z, lhs != rhs.w); } +[[nodiscard]] inline __device__ constexpr auto operator!=(lc_ubyte2 lhs, lc_ubyte2 rhs) noexcept { return lc_make_bool2(lhs.x != rhs.x, lhs.y != rhs.y); } +[[nodiscard]] inline __device__ constexpr auto operator!=(lc_ubyte2 lhs, lc_ubyte rhs) noexcept { return lc_make_bool2(lhs.x != rhs, lhs.y != rhs); } +[[nodiscard]] inline __device__ constexpr auto operator!=(lc_ubyte lhs, lc_ubyte2 rhs) noexcept { return lc_make_bool2(lhs != rhs.x, lhs != rhs.y); } +[[nodiscard]] inline __device__ constexpr auto operator!=(lc_ubyte3 lhs, lc_ubyte3 rhs) noexcept { return lc_make_bool3(lhs.x != rhs.x, lhs.y != rhs.y, lhs.z != rhs.z); } +[[nodiscard]] inline __device__ constexpr auto operator!=(lc_ubyte3 lhs, lc_ubyte rhs) noexcept { return lc_make_bool3(lhs.x != rhs, lhs.y != rhs, lhs.z != rhs); } +[[nodiscard]] inline __device__ constexpr auto operator!=(lc_ubyte lhs, lc_ubyte3 rhs) noexcept { return lc_make_bool3(lhs != rhs.x, lhs != rhs.y, lhs != rhs.z); } +[[nodiscard]] inline __device__ constexpr auto operator!=(lc_ubyte4 lhs, lc_ubyte4 rhs) noexcept { return lc_make_bool4(lhs.x != rhs.x, lhs.y != rhs.y, lhs.z != rhs.z, lhs.w != rhs.w); } +[[nodiscard]] inline __device__ constexpr auto operator!=(lc_ubyte4 lhs, lc_ubyte rhs) noexcept { return lc_make_bool4(lhs.x != rhs, lhs.y != rhs, lhs.z != rhs, lhs.w != rhs); } +[[nodiscard]] inline __device__ constexpr auto operator!=(lc_ubyte lhs, lc_ubyte4 rhs) noexcept { return lc_make_bool4(lhs != rhs.x, lhs != rhs.y, lhs != rhs.z, lhs != rhs.w); } +[[nodiscard]] inline __device__ constexpr auto operator!=(lc_short2 lhs, lc_short2 rhs) noexcept { return lc_make_bool2(lhs.x != rhs.x, lhs.y != rhs.y); } +[[nodiscard]] inline __device__ constexpr auto operator!=(lc_short2 lhs, lc_short rhs) noexcept { return lc_make_bool2(lhs.x != rhs, lhs.y != rhs); } +[[nodiscard]] inline __device__ constexpr auto operator!=(lc_short lhs, lc_short2 rhs) noexcept { return lc_make_bool2(lhs != rhs.x, lhs != rhs.y); } +[[nodiscard]] inline __device__ constexpr auto operator!=(lc_short3 lhs, lc_short3 rhs) noexcept { return lc_make_bool3(lhs.x != rhs.x, lhs.y != rhs.y, lhs.z != rhs.z); } +[[nodiscard]] inline __device__ constexpr auto operator!=(lc_short3 lhs, lc_short rhs) noexcept { return lc_make_bool3(lhs.x != rhs, lhs.y != rhs, lhs.z != rhs); } +[[nodiscard]] inline __device__ constexpr auto operator!=(lc_short lhs, lc_short3 rhs) noexcept { return lc_make_bool3(lhs != rhs.x, lhs != rhs.y, lhs != rhs.z); } +[[nodiscard]] inline __device__ constexpr auto operator!=(lc_short4 lhs, lc_short4 rhs) noexcept { return lc_make_bool4(lhs.x != rhs.x, lhs.y != rhs.y, lhs.z != rhs.z, lhs.w != rhs.w); } +[[nodiscard]] inline __device__ constexpr auto operator!=(lc_short4 lhs, lc_short rhs) noexcept { return lc_make_bool4(lhs.x != rhs, lhs.y != rhs, lhs.z != rhs, lhs.w != rhs); } +[[nodiscard]] inline __device__ constexpr auto operator!=(lc_short lhs, lc_short4 rhs) noexcept { return lc_make_bool4(lhs != rhs.x, lhs != rhs.y, lhs != rhs.z, lhs != rhs.w); } +[[nodiscard]] inline __device__ constexpr auto operator!=(lc_ushort2 lhs, lc_ushort2 rhs) noexcept { return lc_make_bool2(lhs.x != rhs.x, lhs.y != rhs.y); } +[[nodiscard]] inline __device__ constexpr auto operator!=(lc_ushort2 lhs, lc_ushort rhs) noexcept { return lc_make_bool2(lhs.x != rhs, lhs.y != rhs); } +[[nodiscard]] inline __device__ constexpr auto operator!=(lc_ushort lhs, lc_ushort2 rhs) noexcept { return lc_make_bool2(lhs != rhs.x, lhs != rhs.y); } +[[nodiscard]] inline __device__ constexpr auto operator!=(lc_ushort3 lhs, lc_ushort3 rhs) noexcept { return lc_make_bool3(lhs.x != rhs.x, lhs.y != rhs.y, lhs.z != rhs.z); } +[[nodiscard]] inline __device__ constexpr auto operator!=(lc_ushort3 lhs, lc_ushort rhs) noexcept { return lc_make_bool3(lhs.x != rhs, lhs.y != rhs, lhs.z != rhs); } +[[nodiscard]] inline __device__ constexpr auto operator!=(lc_ushort lhs, lc_ushort3 rhs) noexcept { return lc_make_bool3(lhs != rhs.x, lhs != rhs.y, lhs != rhs.z); } +[[nodiscard]] inline __device__ constexpr auto operator!=(lc_ushort4 lhs, lc_ushort4 rhs) noexcept { return lc_make_bool4(lhs.x != rhs.x, lhs.y != rhs.y, lhs.z != rhs.z, lhs.w != rhs.w); } +[[nodiscard]] inline __device__ constexpr auto operator!=(lc_ushort4 lhs, lc_ushort rhs) noexcept { return lc_make_bool4(lhs.x != rhs, lhs.y != rhs, lhs.z != rhs, lhs.w != rhs); } +[[nodiscard]] inline __device__ constexpr auto operator!=(lc_ushort lhs, lc_ushort4 rhs) noexcept { return lc_make_bool4(lhs != rhs.x, lhs != rhs.y, lhs != rhs.z, lhs != rhs.w); } +[[nodiscard]] inline __device__ constexpr auto operator!=(lc_int2 lhs, lc_int2 rhs) noexcept { return lc_make_bool2(lhs.x != rhs.x, lhs.y != rhs.y); } +[[nodiscard]] inline __device__ constexpr auto operator!=(lc_int2 lhs, lc_int rhs) noexcept { return lc_make_bool2(lhs.x != rhs, lhs.y != rhs); } +[[nodiscard]] inline __device__ constexpr auto operator!=(lc_int lhs, lc_int2 rhs) noexcept { return lc_make_bool2(lhs != rhs.x, lhs != rhs.y); } +[[nodiscard]] inline __device__ constexpr auto operator!=(lc_int3 lhs, lc_int3 rhs) noexcept { return lc_make_bool3(lhs.x != rhs.x, lhs.y != rhs.y, lhs.z != rhs.z); } +[[nodiscard]] inline __device__ constexpr auto operator!=(lc_int3 lhs, lc_int rhs) noexcept { return lc_make_bool3(lhs.x != rhs, lhs.y != rhs, lhs.z != rhs); } +[[nodiscard]] inline __device__ constexpr auto operator!=(lc_int lhs, lc_int3 rhs) noexcept { return lc_make_bool3(lhs != rhs.x, lhs != rhs.y, lhs != rhs.z); } +[[nodiscard]] inline __device__ constexpr auto operator!=(lc_int4 lhs, lc_int4 rhs) noexcept { return lc_make_bool4(lhs.x != rhs.x, lhs.y != rhs.y, lhs.z != rhs.z, lhs.w != rhs.w); } +[[nodiscard]] inline __device__ constexpr auto operator!=(lc_int4 lhs, lc_int rhs) noexcept { return lc_make_bool4(lhs.x != rhs, lhs.y != rhs, lhs.z != rhs, lhs.w != rhs); } +[[nodiscard]] inline __device__ constexpr auto operator!=(lc_int lhs, lc_int4 rhs) noexcept { return lc_make_bool4(lhs != rhs.x, lhs != rhs.y, lhs != rhs.z, lhs != rhs.w); } +[[nodiscard]] inline __device__ constexpr auto operator!=(lc_uint2 lhs, lc_uint2 rhs) noexcept { return lc_make_bool2(lhs.x != rhs.x, lhs.y != rhs.y); } +[[nodiscard]] inline __device__ constexpr auto operator!=(lc_uint2 lhs, lc_uint rhs) noexcept { return lc_make_bool2(lhs.x != rhs, lhs.y != rhs); } +[[nodiscard]] inline __device__ constexpr auto operator!=(lc_uint lhs, lc_uint2 rhs) noexcept { return lc_make_bool2(lhs != rhs.x, lhs != rhs.y); } +[[nodiscard]] inline __device__ constexpr auto operator!=(lc_uint3 lhs, lc_uint3 rhs) noexcept { return lc_make_bool3(lhs.x != rhs.x, lhs.y != rhs.y, lhs.z != rhs.z); } +[[nodiscard]] inline __device__ constexpr auto operator!=(lc_uint3 lhs, lc_uint rhs) noexcept { return lc_make_bool3(lhs.x != rhs, lhs.y != rhs, lhs.z != rhs); } +[[nodiscard]] inline __device__ constexpr auto operator!=(lc_uint lhs, lc_uint3 rhs) noexcept { return lc_make_bool3(lhs != rhs.x, lhs != rhs.y, lhs != rhs.z); } +[[nodiscard]] inline __device__ constexpr auto operator!=(lc_uint4 lhs, lc_uint4 rhs) noexcept { return lc_make_bool4(lhs.x != rhs.x, lhs.y != rhs.y, lhs.z != rhs.z, lhs.w != rhs.w); } +[[nodiscard]] inline __device__ constexpr auto operator!=(lc_uint4 lhs, lc_uint rhs) noexcept { return lc_make_bool4(lhs.x != rhs, lhs.y != rhs, lhs.z != rhs, lhs.w != rhs); } +[[nodiscard]] inline __device__ constexpr auto operator!=(lc_uint lhs, lc_uint4 rhs) noexcept { return lc_make_bool4(lhs != rhs.x, lhs != rhs.y, lhs != rhs.z, lhs != rhs.w); } +[[nodiscard]] inline __device__ constexpr auto operator!=(lc_half2 lhs, lc_half2 rhs) noexcept { return lc_make_bool2(lhs.x != rhs.x, lhs.y != rhs.y); } +[[nodiscard]] inline __device__ constexpr auto operator!=(lc_half2 lhs, lc_half rhs) noexcept { return lc_make_bool2(lhs.x != rhs, lhs.y != rhs); } +[[nodiscard]] inline __device__ constexpr auto operator!=(lc_half lhs, lc_half2 rhs) noexcept { return lc_make_bool2(lhs != rhs.x, lhs != rhs.y); } +[[nodiscard]] inline __device__ constexpr auto operator!=(lc_half3 lhs, lc_half3 rhs) noexcept { return lc_make_bool3(lhs.x != rhs.x, lhs.y != rhs.y, lhs.z != rhs.z); } +[[nodiscard]] inline __device__ constexpr auto operator!=(lc_half3 lhs, lc_half rhs) noexcept { return lc_make_bool3(lhs.x != rhs, lhs.y != rhs, lhs.z != rhs); } +[[nodiscard]] inline __device__ constexpr auto operator!=(lc_half lhs, lc_half3 rhs) noexcept { return lc_make_bool3(lhs != rhs.x, lhs != rhs.y, lhs != rhs.z); } +[[nodiscard]] inline __device__ constexpr auto operator!=(lc_half4 lhs, lc_half4 rhs) noexcept { return lc_make_bool4(lhs.x != rhs.x, lhs.y != rhs.y, lhs.z != rhs.z, lhs.w != rhs.w); } +[[nodiscard]] inline __device__ constexpr auto operator!=(lc_half4 lhs, lc_half rhs) noexcept { return lc_make_bool4(lhs.x != rhs, lhs.y != rhs, lhs.z != rhs, lhs.w != rhs); } +[[nodiscard]] inline __device__ constexpr auto operator!=(lc_half lhs, lc_half4 rhs) noexcept { return lc_make_bool4(lhs != rhs.x, lhs != rhs.y, lhs != rhs.z, lhs != rhs.w); } +[[nodiscard]] inline __device__ constexpr auto operator!=(lc_float2 lhs, lc_float2 rhs) noexcept { return lc_make_bool2(lhs.x != rhs.x, lhs.y != rhs.y); } +[[nodiscard]] inline __device__ constexpr auto operator!=(lc_float2 lhs, lc_float rhs) noexcept { return lc_make_bool2(lhs.x != rhs, lhs.y != rhs); } +[[nodiscard]] inline __device__ constexpr auto operator!=(lc_float lhs, lc_float2 rhs) noexcept { return lc_make_bool2(lhs != rhs.x, lhs != rhs.y); } +[[nodiscard]] inline __device__ constexpr auto operator!=(lc_float3 lhs, lc_float3 rhs) noexcept { return lc_make_bool3(lhs.x != rhs.x, lhs.y != rhs.y, lhs.z != rhs.z); } +[[nodiscard]] inline __device__ constexpr auto operator!=(lc_float3 lhs, lc_float rhs) noexcept { return lc_make_bool3(lhs.x != rhs, lhs.y != rhs, lhs.z != rhs); } +[[nodiscard]] inline __device__ constexpr auto operator!=(lc_float lhs, lc_float3 rhs) noexcept { return lc_make_bool3(lhs != rhs.x, lhs != rhs.y, lhs != rhs.z); } +[[nodiscard]] inline __device__ constexpr auto operator!=(lc_float4 lhs, lc_float4 rhs) noexcept { return lc_make_bool4(lhs.x != rhs.x, lhs.y != rhs.y, lhs.z != rhs.z, lhs.w != rhs.w); } +[[nodiscard]] inline __device__ constexpr auto operator!=(lc_float4 lhs, lc_float rhs) noexcept { return lc_make_bool4(lhs.x != rhs, lhs.y != rhs, lhs.z != rhs, lhs.w != rhs); } +[[nodiscard]] inline __device__ constexpr auto operator!=(lc_float lhs, lc_float4 rhs) noexcept { return lc_make_bool4(lhs != rhs.x, lhs != rhs.y, lhs != rhs.z, lhs != rhs.w); } +[[nodiscard]] inline __device__ constexpr auto operator!=(lc_bool2 lhs, lc_bool2 rhs) noexcept { return lc_make_bool2(lhs.x != rhs.x, lhs.y != rhs.y); } +[[nodiscard]] inline __device__ constexpr auto operator!=(lc_bool2 lhs, lc_bool rhs) noexcept { return lc_make_bool2(lhs.x != rhs, lhs.y != rhs); } +[[nodiscard]] inline __device__ constexpr auto operator!=(lc_bool lhs, lc_bool2 rhs) noexcept { return lc_make_bool2(lhs != rhs.x, lhs != rhs.y); } +[[nodiscard]] inline __device__ constexpr auto operator!=(lc_bool3 lhs, lc_bool3 rhs) noexcept { return lc_make_bool3(lhs.x != rhs.x, lhs.y != rhs.y, lhs.z != rhs.z); } +[[nodiscard]] inline __device__ constexpr auto operator!=(lc_bool3 lhs, lc_bool rhs) noexcept { return lc_make_bool3(lhs.x != rhs, lhs.y != rhs, lhs.z != rhs); } +[[nodiscard]] inline __device__ constexpr auto operator!=(lc_bool lhs, lc_bool3 rhs) noexcept { return lc_make_bool3(lhs != rhs.x, lhs != rhs.y, lhs != rhs.z); } +[[nodiscard]] inline __device__ constexpr auto operator!=(lc_bool4 lhs, lc_bool4 rhs) noexcept { return lc_make_bool4(lhs.x != rhs.x, lhs.y != rhs.y, lhs.z != rhs.z, lhs.w != rhs.w); } +[[nodiscard]] inline __device__ constexpr auto operator!=(lc_bool4 lhs, lc_bool rhs) noexcept { return lc_make_bool4(lhs.x != rhs, lhs.y != rhs, lhs.z != rhs, lhs.w != rhs); } +[[nodiscard]] inline __device__ constexpr auto operator!=(lc_bool lhs, lc_bool4 rhs) noexcept { return lc_make_bool4(lhs != rhs.x, lhs != rhs.y, lhs != rhs.z, lhs != rhs.w); } +[[nodiscard]] inline __device__ constexpr auto operator!=(lc_long2 lhs, lc_long2 rhs) noexcept { return lc_make_bool2(lhs.x != rhs.x, lhs.y != rhs.y); } +[[nodiscard]] inline __device__ constexpr auto operator!=(lc_long2 lhs, lc_long rhs) noexcept { return lc_make_bool2(lhs.x != rhs, lhs.y != rhs); } +[[nodiscard]] inline __device__ constexpr auto operator!=(lc_long lhs, lc_long2 rhs) noexcept { return lc_make_bool2(lhs != rhs.x, lhs != rhs.y); } +[[nodiscard]] inline __device__ constexpr auto operator!=(lc_long3 lhs, lc_long3 rhs) noexcept { return lc_make_bool3(lhs.x != rhs.x, lhs.y != rhs.y, lhs.z != rhs.z); } +[[nodiscard]] inline __device__ constexpr auto operator!=(lc_long3 lhs, lc_long rhs) noexcept { return lc_make_bool3(lhs.x != rhs, lhs.y != rhs, lhs.z != rhs); } +[[nodiscard]] inline __device__ constexpr auto operator!=(lc_long lhs, lc_long3 rhs) noexcept { return lc_make_bool3(lhs != rhs.x, lhs != rhs.y, lhs != rhs.z); } +[[nodiscard]] inline __device__ constexpr auto operator!=(lc_long4 lhs, lc_long4 rhs) noexcept { return lc_make_bool4(lhs.x != rhs.x, lhs.y != rhs.y, lhs.z != rhs.z, lhs.w != rhs.w); } +[[nodiscard]] inline __device__ constexpr auto operator!=(lc_long4 lhs, lc_long rhs) noexcept { return lc_make_bool4(lhs.x != rhs, lhs.y != rhs, lhs.z != rhs, lhs.w != rhs); } +[[nodiscard]] inline __device__ constexpr auto operator!=(lc_long lhs, lc_long4 rhs) noexcept { return lc_make_bool4(lhs != rhs.x, lhs != rhs.y, lhs != rhs.z, lhs != rhs.w); } +[[nodiscard]] inline __device__ constexpr auto operator!=(lc_ulong2 lhs, lc_ulong2 rhs) noexcept { return lc_make_bool2(lhs.x != rhs.x, lhs.y != rhs.y); } +[[nodiscard]] inline __device__ constexpr auto operator!=(lc_ulong2 lhs, lc_ulong rhs) noexcept { return lc_make_bool2(lhs.x != rhs, lhs.y != rhs); } +[[nodiscard]] inline __device__ constexpr auto operator!=(lc_ulong lhs, lc_ulong2 rhs) noexcept { return lc_make_bool2(lhs != rhs.x, lhs != rhs.y); } +[[nodiscard]] inline __device__ constexpr auto operator!=(lc_ulong3 lhs, lc_ulong3 rhs) noexcept { return lc_make_bool3(lhs.x != rhs.x, lhs.y != rhs.y, lhs.z != rhs.z); } +[[nodiscard]] inline __device__ constexpr auto operator!=(lc_ulong3 lhs, lc_ulong rhs) noexcept { return lc_make_bool3(lhs.x != rhs, lhs.y != rhs, lhs.z != rhs); } +[[nodiscard]] inline __device__ constexpr auto operator!=(lc_ulong lhs, lc_ulong3 rhs) noexcept { return lc_make_bool3(lhs != rhs.x, lhs != rhs.y, lhs != rhs.z); } +[[nodiscard]] inline __device__ constexpr auto operator!=(lc_ulong4 lhs, lc_ulong4 rhs) noexcept { return lc_make_bool4(lhs.x != rhs.x, lhs.y != rhs.y, lhs.z != rhs.z, lhs.w != rhs.w); } +[[nodiscard]] inline __device__ constexpr auto operator!=(lc_ulong4 lhs, lc_ulong rhs) noexcept { return lc_make_bool4(lhs.x != rhs, lhs.y != rhs, lhs.z != rhs, lhs.w != rhs); } +[[nodiscard]] inline __device__ constexpr auto operator!=(lc_ulong lhs, lc_ulong4 rhs) noexcept { return lc_make_bool4(lhs != rhs.x, lhs != rhs.y, lhs != rhs.z, lhs != rhs.w); } + +[[nodiscard]] inline __device__ constexpr auto operator<(lc_short2 lhs, lc_short2 rhs) noexcept { return lc_make_bool2(lhs.x < rhs.x, lhs.y < rhs.y); } +[[nodiscard]] inline __device__ constexpr auto operator<(lc_short2 lhs, lc_short rhs) noexcept { return lc_make_bool2(lhs.x < rhs, lhs.y < rhs); } +[[nodiscard]] inline __device__ constexpr auto operator<(lc_short lhs, lc_short2 rhs) noexcept { return lc_make_bool2(lhs < rhs.x, lhs < rhs.y); } +[[nodiscard]] inline __device__ constexpr auto operator<(lc_short3 lhs, lc_short3 rhs) noexcept { return lc_make_bool3(lhs.x < rhs.x, lhs.y < rhs.y, lhs.z < rhs.z); } +[[nodiscard]] inline __device__ constexpr auto operator<(lc_short3 lhs, lc_short rhs) noexcept { return lc_make_bool3(lhs.x < rhs, lhs.y < rhs, lhs.z < rhs); } +[[nodiscard]] inline __device__ constexpr auto operator<(lc_short lhs, lc_short3 rhs) noexcept { return lc_make_bool3(lhs < rhs.x, lhs < rhs.y, lhs < rhs.z); } +[[nodiscard]] inline __device__ constexpr auto operator<(lc_short4 lhs, lc_short4 rhs) noexcept { return lc_make_bool4(lhs.x < rhs.x, lhs.y < rhs.y, lhs.z < rhs.z, lhs.w < rhs.w); } +[[nodiscard]] inline __device__ constexpr auto operator<(lc_short4 lhs, lc_short rhs) noexcept { return lc_make_bool4(lhs.x < rhs, lhs.y < rhs, lhs.z < rhs, lhs.w < rhs); } +[[nodiscard]] inline __device__ constexpr auto operator<(lc_short lhs, lc_short4 rhs) noexcept { return lc_make_bool4(lhs < rhs.x, lhs < rhs.y, lhs < rhs.z, lhs < rhs.w); } +[[nodiscard]] inline __device__ constexpr auto operator<(lc_ushort2 lhs, lc_ushort2 rhs) noexcept { return lc_make_bool2(lhs.x < rhs.x, lhs.y < rhs.y); } +[[nodiscard]] inline __device__ constexpr auto operator<(lc_ushort2 lhs, lc_ushort rhs) noexcept { return lc_make_bool2(lhs.x < rhs, lhs.y < rhs); } +[[nodiscard]] inline __device__ constexpr auto operator<(lc_ushort lhs, lc_ushort2 rhs) noexcept { return lc_make_bool2(lhs < rhs.x, lhs < rhs.y); } +[[nodiscard]] inline __device__ constexpr auto operator<(lc_ushort3 lhs, lc_ushort3 rhs) noexcept { return lc_make_bool3(lhs.x < rhs.x, lhs.y < rhs.y, lhs.z < rhs.z); } +[[nodiscard]] inline __device__ constexpr auto operator<(lc_ushort3 lhs, lc_ushort rhs) noexcept { return lc_make_bool3(lhs.x < rhs, lhs.y < rhs, lhs.z < rhs); } +[[nodiscard]] inline __device__ constexpr auto operator<(lc_ushort lhs, lc_ushort3 rhs) noexcept { return lc_make_bool3(lhs < rhs.x, lhs < rhs.y, lhs < rhs.z); } +[[nodiscard]] inline __device__ constexpr auto operator<(lc_ushort4 lhs, lc_ushort4 rhs) noexcept { return lc_make_bool4(lhs.x < rhs.x, lhs.y < rhs.y, lhs.z < rhs.z, lhs.w < rhs.w); } +[[nodiscard]] inline __device__ constexpr auto operator<(lc_ushort4 lhs, lc_ushort rhs) noexcept { return lc_make_bool4(lhs.x < rhs, lhs.y < rhs, lhs.z < rhs, lhs.w < rhs); } +[[nodiscard]] inline __device__ constexpr auto operator<(lc_ushort lhs, lc_ushort4 rhs) noexcept { return lc_make_bool4(lhs < rhs.x, lhs < rhs.y, lhs < rhs.z, lhs < rhs.w); } +[[nodiscard]] inline __device__ constexpr auto operator<(lc_int2 lhs, lc_int2 rhs) noexcept { return lc_make_bool2(lhs.x < rhs.x, lhs.y < rhs.y); } +[[nodiscard]] inline __device__ constexpr auto operator<(lc_int2 lhs, lc_int rhs) noexcept { return lc_make_bool2(lhs.x < rhs, lhs.y < rhs); } +[[nodiscard]] inline __device__ constexpr auto operator<(lc_int lhs, lc_int2 rhs) noexcept { return lc_make_bool2(lhs < rhs.x, lhs < rhs.y); } +[[nodiscard]] inline __device__ constexpr auto operator<(lc_int3 lhs, lc_int3 rhs) noexcept { return lc_make_bool3(lhs.x < rhs.x, lhs.y < rhs.y, lhs.z < rhs.z); } +[[nodiscard]] inline __device__ constexpr auto operator<(lc_int3 lhs, lc_int rhs) noexcept { return lc_make_bool3(lhs.x < rhs, lhs.y < rhs, lhs.z < rhs); } +[[nodiscard]] inline __device__ constexpr auto operator<(lc_int lhs, lc_int3 rhs) noexcept { return lc_make_bool3(lhs < rhs.x, lhs < rhs.y, lhs < rhs.z); } +[[nodiscard]] inline __device__ constexpr auto operator<(lc_int4 lhs, lc_int4 rhs) noexcept { return lc_make_bool4(lhs.x < rhs.x, lhs.y < rhs.y, lhs.z < rhs.z, lhs.w < rhs.w); } +[[nodiscard]] inline __device__ constexpr auto operator<(lc_int4 lhs, lc_int rhs) noexcept { return lc_make_bool4(lhs.x < rhs, lhs.y < rhs, lhs.z < rhs, lhs.w < rhs); } +[[nodiscard]] inline __device__ constexpr auto operator<(lc_int lhs, lc_int4 rhs) noexcept { return lc_make_bool4(lhs < rhs.x, lhs < rhs.y, lhs < rhs.z, lhs < rhs.w); } +[[nodiscard]] inline __device__ constexpr auto operator<(lc_uint2 lhs, lc_uint2 rhs) noexcept { return lc_make_bool2(lhs.x < rhs.x, lhs.y < rhs.y); } +[[nodiscard]] inline __device__ constexpr auto operator<(lc_uint2 lhs, lc_uint rhs) noexcept { return lc_make_bool2(lhs.x < rhs, lhs.y < rhs); } +[[nodiscard]] inline __device__ constexpr auto operator<(lc_uint lhs, lc_uint2 rhs) noexcept { return lc_make_bool2(lhs < rhs.x, lhs < rhs.y); } +[[nodiscard]] inline __device__ constexpr auto operator<(lc_uint3 lhs, lc_uint3 rhs) noexcept { return lc_make_bool3(lhs.x < rhs.x, lhs.y < rhs.y, lhs.z < rhs.z); } +[[nodiscard]] inline __device__ constexpr auto operator<(lc_uint3 lhs, lc_uint rhs) noexcept { return lc_make_bool3(lhs.x < rhs, lhs.y < rhs, lhs.z < rhs); } +[[nodiscard]] inline __device__ constexpr auto operator<(lc_uint lhs, lc_uint3 rhs) noexcept { return lc_make_bool3(lhs < rhs.x, lhs < rhs.y, lhs < rhs.z); } +[[nodiscard]] inline __device__ constexpr auto operator<(lc_uint4 lhs, lc_uint4 rhs) noexcept { return lc_make_bool4(lhs.x < rhs.x, lhs.y < rhs.y, lhs.z < rhs.z, lhs.w < rhs.w); } +[[nodiscard]] inline __device__ constexpr auto operator<(lc_uint4 lhs, lc_uint rhs) noexcept { return lc_make_bool4(lhs.x < rhs, lhs.y < rhs, lhs.z < rhs, lhs.w < rhs); } +[[nodiscard]] inline __device__ constexpr auto operator<(lc_uint lhs, lc_uint4 rhs) noexcept { return lc_make_bool4(lhs < rhs.x, lhs < rhs.y, lhs < rhs.z, lhs < rhs.w); } +[[nodiscard]] inline __device__ constexpr auto operator<(lc_half2 lhs, lc_half2 rhs) noexcept { return lc_make_bool2(lhs.x < rhs.x, lhs.y < rhs.y); } +[[nodiscard]] inline __device__ constexpr auto operator<(lc_half2 lhs, lc_half rhs) noexcept { return lc_make_bool2(lhs.x < rhs, lhs.y < rhs); } +[[nodiscard]] inline __device__ constexpr auto operator<(lc_half lhs, lc_half2 rhs) noexcept { return lc_make_bool2(lhs < rhs.x, lhs < rhs.y); } +[[nodiscard]] inline __device__ constexpr auto operator<(lc_half3 lhs, lc_half3 rhs) noexcept { return lc_make_bool3(lhs.x < rhs.x, lhs.y < rhs.y, lhs.z < rhs.z); } +[[nodiscard]] inline __device__ constexpr auto operator<(lc_half3 lhs, lc_half rhs) noexcept { return lc_make_bool3(lhs.x < rhs, lhs.y < rhs, lhs.z < rhs); } +[[nodiscard]] inline __device__ constexpr auto operator<(lc_half lhs, lc_half3 rhs) noexcept { return lc_make_bool3(lhs < rhs.x, lhs < rhs.y, lhs < rhs.z); } +[[nodiscard]] inline __device__ constexpr auto operator<(lc_half4 lhs, lc_half4 rhs) noexcept { return lc_make_bool4(lhs.x < rhs.x, lhs.y < rhs.y, lhs.z < rhs.z, lhs.w < rhs.w); } +[[nodiscard]] inline __device__ constexpr auto operator<(lc_half4 lhs, lc_half rhs) noexcept { return lc_make_bool4(lhs.x < rhs, lhs.y < rhs, lhs.z < rhs, lhs.w < rhs); } +[[nodiscard]] inline __device__ constexpr auto operator<(lc_half lhs, lc_half4 rhs) noexcept { return lc_make_bool4(lhs < rhs.x, lhs < rhs.y, lhs < rhs.z, lhs < rhs.w); } +[[nodiscard]] inline __device__ constexpr auto operator<(lc_float2 lhs, lc_float2 rhs) noexcept { return lc_make_bool2(lhs.x < rhs.x, lhs.y < rhs.y); } +[[nodiscard]] inline __device__ constexpr auto operator<(lc_float2 lhs, lc_float rhs) noexcept { return lc_make_bool2(lhs.x < rhs, lhs.y < rhs); } +[[nodiscard]] inline __device__ constexpr auto operator<(lc_float lhs, lc_float2 rhs) noexcept { return lc_make_bool2(lhs < rhs.x, lhs < rhs.y); } +[[nodiscard]] inline __device__ constexpr auto operator<(lc_float3 lhs, lc_float3 rhs) noexcept { return lc_make_bool3(lhs.x < rhs.x, lhs.y < rhs.y, lhs.z < rhs.z); } +[[nodiscard]] inline __device__ constexpr auto operator<(lc_float3 lhs, lc_float rhs) noexcept { return lc_make_bool3(lhs.x < rhs, lhs.y < rhs, lhs.z < rhs); } +[[nodiscard]] inline __device__ constexpr auto operator<(lc_float lhs, lc_float3 rhs) noexcept { return lc_make_bool3(lhs < rhs.x, lhs < rhs.y, lhs < rhs.z); } +[[nodiscard]] inline __device__ constexpr auto operator<(lc_float4 lhs, lc_float4 rhs) noexcept { return lc_make_bool4(lhs.x < rhs.x, lhs.y < rhs.y, lhs.z < rhs.z, lhs.w < rhs.w); } +[[nodiscard]] inline __device__ constexpr auto operator<(lc_float4 lhs, lc_float rhs) noexcept { return lc_make_bool4(lhs.x < rhs, lhs.y < rhs, lhs.z < rhs, lhs.w < rhs); } +[[nodiscard]] inline __device__ constexpr auto operator<(lc_float lhs, lc_float4 rhs) noexcept { return lc_make_bool4(lhs < rhs.x, lhs < rhs.y, lhs < rhs.z, lhs < rhs.w); } +[[nodiscard]] inline __device__ constexpr auto operator<(lc_long2 lhs, lc_long2 rhs) noexcept { return lc_make_bool2(lhs.x < rhs.x, lhs.y < rhs.y); } +[[nodiscard]] inline __device__ constexpr auto operator<(lc_long2 lhs, lc_long rhs) noexcept { return lc_make_bool2(lhs.x < rhs, lhs.y < rhs); } +[[nodiscard]] inline __device__ constexpr auto operator<(lc_long lhs, lc_long2 rhs) noexcept { return lc_make_bool2(lhs < rhs.x, lhs < rhs.y); } +[[nodiscard]] inline __device__ constexpr auto operator<(lc_long3 lhs, lc_long3 rhs) noexcept { return lc_make_bool3(lhs.x < rhs.x, lhs.y < rhs.y, lhs.z < rhs.z); } +[[nodiscard]] inline __device__ constexpr auto operator<(lc_long3 lhs, lc_long rhs) noexcept { return lc_make_bool3(lhs.x < rhs, lhs.y < rhs, lhs.z < rhs); } +[[nodiscard]] inline __device__ constexpr auto operator<(lc_long lhs, lc_long3 rhs) noexcept { return lc_make_bool3(lhs < rhs.x, lhs < rhs.y, lhs < rhs.z); } +[[nodiscard]] inline __device__ constexpr auto operator<(lc_long4 lhs, lc_long4 rhs) noexcept { return lc_make_bool4(lhs.x < rhs.x, lhs.y < rhs.y, lhs.z < rhs.z, lhs.w < rhs.w); } +[[nodiscard]] inline __device__ constexpr auto operator<(lc_long4 lhs, lc_long rhs) noexcept { return lc_make_bool4(lhs.x < rhs, lhs.y < rhs, lhs.z < rhs, lhs.w < rhs); } +[[nodiscard]] inline __device__ constexpr auto operator<(lc_long lhs, lc_long4 rhs) noexcept { return lc_make_bool4(lhs < rhs.x, lhs < rhs.y, lhs < rhs.z, lhs < rhs.w); } +[[nodiscard]] inline __device__ constexpr auto operator<(lc_ulong2 lhs, lc_ulong2 rhs) noexcept { return lc_make_bool2(lhs.x < rhs.x, lhs.y < rhs.y); } +[[nodiscard]] inline __device__ constexpr auto operator<(lc_ulong2 lhs, lc_ulong rhs) noexcept { return lc_make_bool2(lhs.x < rhs, lhs.y < rhs); } +[[nodiscard]] inline __device__ constexpr auto operator<(lc_ulong lhs, lc_ulong2 rhs) noexcept { return lc_make_bool2(lhs < rhs.x, lhs < rhs.y); } +[[nodiscard]] inline __device__ constexpr auto operator<(lc_ulong3 lhs, lc_ulong3 rhs) noexcept { return lc_make_bool3(lhs.x < rhs.x, lhs.y < rhs.y, lhs.z < rhs.z); } +[[nodiscard]] inline __device__ constexpr auto operator<(lc_ulong3 lhs, lc_ulong rhs) noexcept { return lc_make_bool3(lhs.x < rhs, lhs.y < rhs, lhs.z < rhs); } +[[nodiscard]] inline __device__ constexpr auto operator<(lc_ulong lhs, lc_ulong3 rhs) noexcept { return lc_make_bool3(lhs < rhs.x, lhs < rhs.y, lhs < rhs.z); } +[[nodiscard]] inline __device__ constexpr auto operator<(lc_ulong4 lhs, lc_ulong4 rhs) noexcept { return lc_make_bool4(lhs.x < rhs.x, lhs.y < rhs.y, lhs.z < rhs.z, lhs.w < rhs.w); } +[[nodiscard]] inline __device__ constexpr auto operator<(lc_ulong4 lhs, lc_ulong rhs) noexcept { return lc_make_bool4(lhs.x < rhs, lhs.y < rhs, lhs.z < rhs, lhs.w < rhs); } +[[nodiscard]] inline __device__ constexpr auto operator<(lc_ulong lhs, lc_ulong4 rhs) noexcept { return lc_make_bool4(lhs < rhs.x, lhs < rhs.y, lhs < rhs.z, lhs < rhs.w); } + +[[nodiscard]] inline __device__ constexpr auto operator>(lc_short2 lhs, lc_short2 rhs) noexcept { return lc_make_bool2(lhs.x > rhs.x, lhs.y > rhs.y); } +[[nodiscard]] inline __device__ constexpr auto operator>(lc_short2 lhs, lc_short rhs) noexcept { return lc_make_bool2(lhs.x > rhs, lhs.y > rhs); } +[[nodiscard]] inline __device__ constexpr auto operator>(lc_short lhs, lc_short2 rhs) noexcept { return lc_make_bool2(lhs > rhs.x, lhs > rhs.y); } +[[nodiscard]] inline __device__ constexpr auto operator>(lc_short3 lhs, lc_short3 rhs) noexcept { return lc_make_bool3(lhs.x > rhs.x, lhs.y > rhs.y, lhs.z > rhs.z); } +[[nodiscard]] inline __device__ constexpr auto operator>(lc_short3 lhs, lc_short rhs) noexcept { return lc_make_bool3(lhs.x > rhs, lhs.y > rhs, lhs.z > rhs); } +[[nodiscard]] inline __device__ constexpr auto operator>(lc_short lhs, lc_short3 rhs) noexcept { return lc_make_bool3(lhs > rhs.x, lhs > rhs.y, lhs > rhs.z); } +[[nodiscard]] inline __device__ constexpr auto operator>(lc_short4 lhs, lc_short4 rhs) noexcept { return lc_make_bool4(lhs.x > rhs.x, lhs.y > rhs.y, lhs.z > rhs.z, lhs.w > rhs.w); } +[[nodiscard]] inline __device__ constexpr auto operator>(lc_short4 lhs, lc_short rhs) noexcept { return lc_make_bool4(lhs.x > rhs, lhs.y > rhs, lhs.z > rhs, lhs.w > rhs); } +[[nodiscard]] inline __device__ constexpr auto operator>(lc_short lhs, lc_short4 rhs) noexcept { return lc_make_bool4(lhs > rhs.x, lhs > rhs.y, lhs > rhs.z, lhs > rhs.w); } +[[nodiscard]] inline __device__ constexpr auto operator>(lc_ushort2 lhs, lc_ushort2 rhs) noexcept { return lc_make_bool2(lhs.x > rhs.x, lhs.y > rhs.y); } +[[nodiscard]] inline __device__ constexpr auto operator>(lc_ushort2 lhs, lc_ushort rhs) noexcept { return lc_make_bool2(lhs.x > rhs, lhs.y > rhs); } +[[nodiscard]] inline __device__ constexpr auto operator>(lc_ushort lhs, lc_ushort2 rhs) noexcept { return lc_make_bool2(lhs > rhs.x, lhs > rhs.y); } +[[nodiscard]] inline __device__ constexpr auto operator>(lc_ushort3 lhs, lc_ushort3 rhs) noexcept { return lc_make_bool3(lhs.x > rhs.x, lhs.y > rhs.y, lhs.z > rhs.z); } +[[nodiscard]] inline __device__ constexpr auto operator>(lc_ushort3 lhs, lc_ushort rhs) noexcept { return lc_make_bool3(lhs.x > rhs, lhs.y > rhs, lhs.z > rhs); } +[[nodiscard]] inline __device__ constexpr auto operator>(lc_ushort lhs, lc_ushort3 rhs) noexcept { return lc_make_bool3(lhs > rhs.x, lhs > rhs.y, lhs > rhs.z); } +[[nodiscard]] inline __device__ constexpr auto operator>(lc_ushort4 lhs, lc_ushort4 rhs) noexcept { return lc_make_bool4(lhs.x > rhs.x, lhs.y > rhs.y, lhs.z > rhs.z, lhs.w > rhs.w); } +[[nodiscard]] inline __device__ constexpr auto operator>(lc_ushort4 lhs, lc_ushort rhs) noexcept { return lc_make_bool4(lhs.x > rhs, lhs.y > rhs, lhs.z > rhs, lhs.w > rhs); } +[[nodiscard]] inline __device__ constexpr auto operator>(lc_ushort lhs, lc_ushort4 rhs) noexcept { return lc_make_bool4(lhs > rhs.x, lhs > rhs.y, lhs > rhs.z, lhs > rhs.w); } +[[nodiscard]] inline __device__ constexpr auto operator>(lc_int2 lhs, lc_int2 rhs) noexcept { return lc_make_bool2(lhs.x > rhs.x, lhs.y > rhs.y); } +[[nodiscard]] inline __device__ constexpr auto operator>(lc_int2 lhs, lc_int rhs) noexcept { return lc_make_bool2(lhs.x > rhs, lhs.y > rhs); } +[[nodiscard]] inline __device__ constexpr auto operator>(lc_int lhs, lc_int2 rhs) noexcept { return lc_make_bool2(lhs > rhs.x, lhs > rhs.y); } +[[nodiscard]] inline __device__ constexpr auto operator>(lc_int3 lhs, lc_int3 rhs) noexcept { return lc_make_bool3(lhs.x > rhs.x, lhs.y > rhs.y, lhs.z > rhs.z); } +[[nodiscard]] inline __device__ constexpr auto operator>(lc_int3 lhs, lc_int rhs) noexcept { return lc_make_bool3(lhs.x > rhs, lhs.y > rhs, lhs.z > rhs); } +[[nodiscard]] inline __device__ constexpr auto operator>(lc_int lhs, lc_int3 rhs) noexcept { return lc_make_bool3(lhs > rhs.x, lhs > rhs.y, lhs > rhs.z); } +[[nodiscard]] inline __device__ constexpr auto operator>(lc_int4 lhs, lc_int4 rhs) noexcept { return lc_make_bool4(lhs.x > rhs.x, lhs.y > rhs.y, lhs.z > rhs.z, lhs.w > rhs.w); } +[[nodiscard]] inline __device__ constexpr auto operator>(lc_int4 lhs, lc_int rhs) noexcept { return lc_make_bool4(lhs.x > rhs, lhs.y > rhs, lhs.z > rhs, lhs.w > rhs); } +[[nodiscard]] inline __device__ constexpr auto operator>(lc_int lhs, lc_int4 rhs) noexcept { return lc_make_bool4(lhs > rhs.x, lhs > rhs.y, lhs > rhs.z, lhs > rhs.w); } +[[nodiscard]] inline __device__ constexpr auto operator>(lc_uint2 lhs, lc_uint2 rhs) noexcept { return lc_make_bool2(lhs.x > rhs.x, lhs.y > rhs.y); } +[[nodiscard]] inline __device__ constexpr auto operator>(lc_uint2 lhs, lc_uint rhs) noexcept { return lc_make_bool2(lhs.x > rhs, lhs.y > rhs); } +[[nodiscard]] inline __device__ constexpr auto operator>(lc_uint lhs, lc_uint2 rhs) noexcept { return lc_make_bool2(lhs > rhs.x, lhs > rhs.y); } +[[nodiscard]] inline __device__ constexpr auto operator>(lc_uint3 lhs, lc_uint3 rhs) noexcept { return lc_make_bool3(lhs.x > rhs.x, lhs.y > rhs.y, lhs.z > rhs.z); } +[[nodiscard]] inline __device__ constexpr auto operator>(lc_uint3 lhs, lc_uint rhs) noexcept { return lc_make_bool3(lhs.x > rhs, lhs.y > rhs, lhs.z > rhs); } +[[nodiscard]] inline __device__ constexpr auto operator>(lc_uint lhs, lc_uint3 rhs) noexcept { return lc_make_bool3(lhs > rhs.x, lhs > rhs.y, lhs > rhs.z); } +[[nodiscard]] inline __device__ constexpr auto operator>(lc_uint4 lhs, lc_uint4 rhs) noexcept { return lc_make_bool4(lhs.x > rhs.x, lhs.y > rhs.y, lhs.z > rhs.z, lhs.w > rhs.w); } +[[nodiscard]] inline __device__ constexpr auto operator>(lc_uint4 lhs, lc_uint rhs) noexcept { return lc_make_bool4(lhs.x > rhs, lhs.y > rhs, lhs.z > rhs, lhs.w > rhs); } +[[nodiscard]] inline __device__ constexpr auto operator>(lc_uint lhs, lc_uint4 rhs) noexcept { return lc_make_bool4(lhs > rhs.x, lhs > rhs.y, lhs > rhs.z, lhs > rhs.w); } +[[nodiscard]] inline __device__ constexpr auto operator>(lc_half2 lhs, lc_half2 rhs) noexcept { return lc_make_bool2(lhs.x > rhs.x, lhs.y > rhs.y); } +[[nodiscard]] inline __device__ constexpr auto operator>(lc_half2 lhs, lc_half rhs) noexcept { return lc_make_bool2(lhs.x > rhs, lhs.y > rhs); } +[[nodiscard]] inline __device__ constexpr auto operator>(lc_half lhs, lc_half2 rhs) noexcept { return lc_make_bool2(lhs > rhs.x, lhs > rhs.y); } +[[nodiscard]] inline __device__ constexpr auto operator>(lc_half3 lhs, lc_half3 rhs) noexcept { return lc_make_bool3(lhs.x > rhs.x, lhs.y > rhs.y, lhs.z > rhs.z); } +[[nodiscard]] inline __device__ constexpr auto operator>(lc_half3 lhs, lc_half rhs) noexcept { return lc_make_bool3(lhs.x > rhs, lhs.y > rhs, lhs.z > rhs); } +[[nodiscard]] inline __device__ constexpr auto operator>(lc_half lhs, lc_half3 rhs) noexcept { return lc_make_bool3(lhs > rhs.x, lhs > rhs.y, lhs > rhs.z); } +[[nodiscard]] inline __device__ constexpr auto operator>(lc_half4 lhs, lc_half4 rhs) noexcept { return lc_make_bool4(lhs.x > rhs.x, lhs.y > rhs.y, lhs.z > rhs.z, lhs.w > rhs.w); } +[[nodiscard]] inline __device__ constexpr auto operator>(lc_half4 lhs, lc_half rhs) noexcept { return lc_make_bool4(lhs.x > rhs, lhs.y > rhs, lhs.z > rhs, lhs.w > rhs); } +[[nodiscard]] inline __device__ constexpr auto operator>(lc_half lhs, lc_half4 rhs) noexcept { return lc_make_bool4(lhs > rhs.x, lhs > rhs.y, lhs > rhs.z, lhs > rhs.w); } +[[nodiscard]] inline __device__ constexpr auto operator>(lc_float2 lhs, lc_float2 rhs) noexcept { return lc_make_bool2(lhs.x > rhs.x, lhs.y > rhs.y); } +[[nodiscard]] inline __device__ constexpr auto operator>(lc_float2 lhs, lc_float rhs) noexcept { return lc_make_bool2(lhs.x > rhs, lhs.y > rhs); } +[[nodiscard]] inline __device__ constexpr auto operator>(lc_float lhs, lc_float2 rhs) noexcept { return lc_make_bool2(lhs > rhs.x, lhs > rhs.y); } +[[nodiscard]] inline __device__ constexpr auto operator>(lc_float3 lhs, lc_float3 rhs) noexcept { return lc_make_bool3(lhs.x > rhs.x, lhs.y > rhs.y, lhs.z > rhs.z); } +[[nodiscard]] inline __device__ constexpr auto operator>(lc_float3 lhs, lc_float rhs) noexcept { return lc_make_bool3(lhs.x > rhs, lhs.y > rhs, lhs.z > rhs); } +[[nodiscard]] inline __device__ constexpr auto operator>(lc_float lhs, lc_float3 rhs) noexcept { return lc_make_bool3(lhs > rhs.x, lhs > rhs.y, lhs > rhs.z); } +[[nodiscard]] inline __device__ constexpr auto operator>(lc_float4 lhs, lc_float4 rhs) noexcept { return lc_make_bool4(lhs.x > rhs.x, lhs.y > rhs.y, lhs.z > rhs.z, lhs.w > rhs.w); } +[[nodiscard]] inline __device__ constexpr auto operator>(lc_float4 lhs, lc_float rhs) noexcept { return lc_make_bool4(lhs.x > rhs, lhs.y > rhs, lhs.z > rhs, lhs.w > rhs); } +[[nodiscard]] inline __device__ constexpr auto operator>(lc_float lhs, lc_float4 rhs) noexcept { return lc_make_bool4(lhs > rhs.x, lhs > rhs.y, lhs > rhs.z, lhs > rhs.w); } +[[nodiscard]] inline __device__ constexpr auto operator>(lc_long2 lhs, lc_long2 rhs) noexcept { return lc_make_bool2(lhs.x > rhs.x, lhs.y > rhs.y); } +[[nodiscard]] inline __device__ constexpr auto operator>(lc_long2 lhs, lc_long rhs) noexcept { return lc_make_bool2(lhs.x > rhs, lhs.y > rhs); } +[[nodiscard]] inline __device__ constexpr auto operator>(lc_long lhs, lc_long2 rhs) noexcept { return lc_make_bool2(lhs > rhs.x, lhs > rhs.y); } +[[nodiscard]] inline __device__ constexpr auto operator>(lc_long3 lhs, lc_long3 rhs) noexcept { return lc_make_bool3(lhs.x > rhs.x, lhs.y > rhs.y, lhs.z > rhs.z); } +[[nodiscard]] inline __device__ constexpr auto operator>(lc_long3 lhs, lc_long rhs) noexcept { return lc_make_bool3(lhs.x > rhs, lhs.y > rhs, lhs.z > rhs); } +[[nodiscard]] inline __device__ constexpr auto operator>(lc_long lhs, lc_long3 rhs) noexcept { return lc_make_bool3(lhs > rhs.x, lhs > rhs.y, lhs > rhs.z); } +[[nodiscard]] inline __device__ constexpr auto operator>(lc_long4 lhs, lc_long4 rhs) noexcept { return lc_make_bool4(lhs.x > rhs.x, lhs.y > rhs.y, lhs.z > rhs.z, lhs.w > rhs.w); } +[[nodiscard]] inline __device__ constexpr auto operator>(lc_long4 lhs, lc_long rhs) noexcept { return lc_make_bool4(lhs.x > rhs, lhs.y > rhs, lhs.z > rhs, lhs.w > rhs); } +[[nodiscard]] inline __device__ constexpr auto operator>(lc_long lhs, lc_long4 rhs) noexcept { return lc_make_bool4(lhs > rhs.x, lhs > rhs.y, lhs > rhs.z, lhs > rhs.w); } +[[nodiscard]] inline __device__ constexpr auto operator>(lc_ulong2 lhs, lc_ulong2 rhs) noexcept { return lc_make_bool2(lhs.x > rhs.x, lhs.y > rhs.y); } +[[nodiscard]] inline __device__ constexpr auto operator>(lc_ulong2 lhs, lc_ulong rhs) noexcept { return lc_make_bool2(lhs.x > rhs, lhs.y > rhs); } +[[nodiscard]] inline __device__ constexpr auto operator>(lc_ulong lhs, lc_ulong2 rhs) noexcept { return lc_make_bool2(lhs > rhs.x, lhs > rhs.y); } +[[nodiscard]] inline __device__ constexpr auto operator>(lc_ulong3 lhs, lc_ulong3 rhs) noexcept { return lc_make_bool3(lhs.x > rhs.x, lhs.y > rhs.y, lhs.z > rhs.z); } +[[nodiscard]] inline __device__ constexpr auto operator>(lc_ulong3 lhs, lc_ulong rhs) noexcept { return lc_make_bool3(lhs.x > rhs, lhs.y > rhs, lhs.z > rhs); } +[[nodiscard]] inline __device__ constexpr auto operator>(lc_ulong lhs, lc_ulong3 rhs) noexcept { return lc_make_bool3(lhs > rhs.x, lhs > rhs.y, lhs > rhs.z); } +[[nodiscard]] inline __device__ constexpr auto operator>(lc_ulong4 lhs, lc_ulong4 rhs) noexcept { return lc_make_bool4(lhs.x > rhs.x, lhs.y > rhs.y, lhs.z > rhs.z, lhs.w > rhs.w); } +[[nodiscard]] inline __device__ constexpr auto operator>(lc_ulong4 lhs, lc_ulong rhs) noexcept { return lc_make_bool4(lhs.x > rhs, lhs.y > rhs, lhs.z > rhs, lhs.w > rhs); } +[[nodiscard]] inline __device__ constexpr auto operator>(lc_ulong lhs, lc_ulong4 rhs) noexcept { return lc_make_bool4(lhs > rhs.x, lhs > rhs.y, lhs > rhs.z, lhs > rhs.w); } + +[[nodiscard]] inline __device__ constexpr auto operator<=(lc_short2 lhs, lc_short2 rhs) noexcept { return lc_make_bool2(lhs.x <= rhs.x, lhs.y <= rhs.y); } +[[nodiscard]] inline __device__ constexpr auto operator<=(lc_short2 lhs, lc_short rhs) noexcept { return lc_make_bool2(lhs.x <= rhs, lhs.y <= rhs); } +[[nodiscard]] inline __device__ constexpr auto operator<=(lc_short lhs, lc_short2 rhs) noexcept { return lc_make_bool2(lhs <= rhs.x, lhs <= rhs.y); } +[[nodiscard]] inline __device__ constexpr auto operator<=(lc_short3 lhs, lc_short3 rhs) noexcept { return lc_make_bool3(lhs.x <= rhs.x, lhs.y <= rhs.y, lhs.z <= rhs.z); } +[[nodiscard]] inline __device__ constexpr auto operator<=(lc_short3 lhs, lc_short rhs) noexcept { return lc_make_bool3(lhs.x <= rhs, lhs.y <= rhs, lhs.z <= rhs); } +[[nodiscard]] inline __device__ constexpr auto operator<=(lc_short lhs, lc_short3 rhs) noexcept { return lc_make_bool3(lhs <= rhs.x, lhs <= rhs.y, lhs <= rhs.z); } +[[nodiscard]] inline __device__ constexpr auto operator<=(lc_short4 lhs, lc_short4 rhs) noexcept { return lc_make_bool4(lhs.x <= rhs.x, lhs.y <= rhs.y, lhs.z <= rhs.z, lhs.w <= rhs.w); } +[[nodiscard]] inline __device__ constexpr auto operator<=(lc_short4 lhs, lc_short rhs) noexcept { return lc_make_bool4(lhs.x <= rhs, lhs.y <= rhs, lhs.z <= rhs, lhs.w <= rhs); } +[[nodiscard]] inline __device__ constexpr auto operator<=(lc_short lhs, lc_short4 rhs) noexcept { return lc_make_bool4(lhs <= rhs.x, lhs <= rhs.y, lhs <= rhs.z, lhs <= rhs.w); } +[[nodiscard]] inline __device__ constexpr auto operator<=(lc_ushort2 lhs, lc_ushort2 rhs) noexcept { return lc_make_bool2(lhs.x <= rhs.x, lhs.y <= rhs.y); } +[[nodiscard]] inline __device__ constexpr auto operator<=(lc_ushort2 lhs, lc_ushort rhs) noexcept { return lc_make_bool2(lhs.x <= rhs, lhs.y <= rhs); } +[[nodiscard]] inline __device__ constexpr auto operator<=(lc_ushort lhs, lc_ushort2 rhs) noexcept { return lc_make_bool2(lhs <= rhs.x, lhs <= rhs.y); } +[[nodiscard]] inline __device__ constexpr auto operator<=(lc_ushort3 lhs, lc_ushort3 rhs) noexcept { return lc_make_bool3(lhs.x <= rhs.x, lhs.y <= rhs.y, lhs.z <= rhs.z); } +[[nodiscard]] inline __device__ constexpr auto operator<=(lc_ushort3 lhs, lc_ushort rhs) noexcept { return lc_make_bool3(lhs.x <= rhs, lhs.y <= rhs, lhs.z <= rhs); } +[[nodiscard]] inline __device__ constexpr auto operator<=(lc_ushort lhs, lc_ushort3 rhs) noexcept { return lc_make_bool3(lhs <= rhs.x, lhs <= rhs.y, lhs <= rhs.z); } +[[nodiscard]] inline __device__ constexpr auto operator<=(lc_ushort4 lhs, lc_ushort4 rhs) noexcept { return lc_make_bool4(lhs.x <= rhs.x, lhs.y <= rhs.y, lhs.z <= rhs.z, lhs.w <= rhs.w); } +[[nodiscard]] inline __device__ constexpr auto operator<=(lc_ushort4 lhs, lc_ushort rhs) noexcept { return lc_make_bool4(lhs.x <= rhs, lhs.y <= rhs, lhs.z <= rhs, lhs.w <= rhs); } +[[nodiscard]] inline __device__ constexpr auto operator<=(lc_ushort lhs, lc_ushort4 rhs) noexcept { return lc_make_bool4(lhs <= rhs.x, lhs <= rhs.y, lhs <= rhs.z, lhs <= rhs.w); } +[[nodiscard]] inline __device__ constexpr auto operator<=(lc_int2 lhs, lc_int2 rhs) noexcept { return lc_make_bool2(lhs.x <= rhs.x, lhs.y <= rhs.y); } +[[nodiscard]] inline __device__ constexpr auto operator<=(lc_int2 lhs, lc_int rhs) noexcept { return lc_make_bool2(lhs.x <= rhs, lhs.y <= rhs); } +[[nodiscard]] inline __device__ constexpr auto operator<=(lc_int lhs, lc_int2 rhs) noexcept { return lc_make_bool2(lhs <= rhs.x, lhs <= rhs.y); } +[[nodiscard]] inline __device__ constexpr auto operator<=(lc_int3 lhs, lc_int3 rhs) noexcept { return lc_make_bool3(lhs.x <= rhs.x, lhs.y <= rhs.y, lhs.z <= rhs.z); } +[[nodiscard]] inline __device__ constexpr auto operator<=(lc_int3 lhs, lc_int rhs) noexcept { return lc_make_bool3(lhs.x <= rhs, lhs.y <= rhs, lhs.z <= rhs); } +[[nodiscard]] inline __device__ constexpr auto operator<=(lc_int lhs, lc_int3 rhs) noexcept { return lc_make_bool3(lhs <= rhs.x, lhs <= rhs.y, lhs <= rhs.z); } +[[nodiscard]] inline __device__ constexpr auto operator<=(lc_int4 lhs, lc_int4 rhs) noexcept { return lc_make_bool4(lhs.x <= rhs.x, lhs.y <= rhs.y, lhs.z <= rhs.z, lhs.w <= rhs.w); } +[[nodiscard]] inline __device__ constexpr auto operator<=(lc_int4 lhs, lc_int rhs) noexcept { return lc_make_bool4(lhs.x <= rhs, lhs.y <= rhs, lhs.z <= rhs, lhs.w <= rhs); } +[[nodiscard]] inline __device__ constexpr auto operator<=(lc_int lhs, lc_int4 rhs) noexcept { return lc_make_bool4(lhs <= rhs.x, lhs <= rhs.y, lhs <= rhs.z, lhs <= rhs.w); } +[[nodiscard]] inline __device__ constexpr auto operator<=(lc_uint2 lhs, lc_uint2 rhs) noexcept { return lc_make_bool2(lhs.x <= rhs.x, lhs.y <= rhs.y); } +[[nodiscard]] inline __device__ constexpr auto operator<=(lc_uint2 lhs, lc_uint rhs) noexcept { return lc_make_bool2(lhs.x <= rhs, lhs.y <= rhs); } +[[nodiscard]] inline __device__ constexpr auto operator<=(lc_uint lhs, lc_uint2 rhs) noexcept { return lc_make_bool2(lhs <= rhs.x, lhs <= rhs.y); } +[[nodiscard]] inline __device__ constexpr auto operator<=(lc_uint3 lhs, lc_uint3 rhs) noexcept { return lc_make_bool3(lhs.x <= rhs.x, lhs.y <= rhs.y, lhs.z <= rhs.z); } +[[nodiscard]] inline __device__ constexpr auto operator<=(lc_uint3 lhs, lc_uint rhs) noexcept { return lc_make_bool3(lhs.x <= rhs, lhs.y <= rhs, lhs.z <= rhs); } +[[nodiscard]] inline __device__ constexpr auto operator<=(lc_uint lhs, lc_uint3 rhs) noexcept { return lc_make_bool3(lhs <= rhs.x, lhs <= rhs.y, lhs <= rhs.z); } +[[nodiscard]] inline __device__ constexpr auto operator<=(lc_uint4 lhs, lc_uint4 rhs) noexcept { return lc_make_bool4(lhs.x <= rhs.x, lhs.y <= rhs.y, lhs.z <= rhs.z, lhs.w <= rhs.w); } +[[nodiscard]] inline __device__ constexpr auto operator<=(lc_uint4 lhs, lc_uint rhs) noexcept { return lc_make_bool4(lhs.x <= rhs, lhs.y <= rhs, lhs.z <= rhs, lhs.w <= rhs); } +[[nodiscard]] inline __device__ constexpr auto operator<=(lc_uint lhs, lc_uint4 rhs) noexcept { return lc_make_bool4(lhs <= rhs.x, lhs <= rhs.y, lhs <= rhs.z, lhs <= rhs.w); } +[[nodiscard]] inline __device__ constexpr auto operator<=(lc_half2 lhs, lc_half2 rhs) noexcept { return lc_make_bool2(lhs.x <= rhs.x, lhs.y <= rhs.y); } +[[nodiscard]] inline __device__ constexpr auto operator<=(lc_half2 lhs, lc_half rhs) noexcept { return lc_make_bool2(lhs.x <= rhs, lhs.y <= rhs); } +[[nodiscard]] inline __device__ constexpr auto operator<=(lc_half lhs, lc_half2 rhs) noexcept { return lc_make_bool2(lhs <= rhs.x, lhs <= rhs.y); } +[[nodiscard]] inline __device__ constexpr auto operator<=(lc_half3 lhs, lc_half3 rhs) noexcept { return lc_make_bool3(lhs.x <= rhs.x, lhs.y <= rhs.y, lhs.z <= rhs.z); } +[[nodiscard]] inline __device__ constexpr auto operator<=(lc_half3 lhs, lc_half rhs) noexcept { return lc_make_bool3(lhs.x <= rhs, lhs.y <= rhs, lhs.z <= rhs); } +[[nodiscard]] inline __device__ constexpr auto operator<=(lc_half lhs, lc_half3 rhs) noexcept { return lc_make_bool3(lhs <= rhs.x, lhs <= rhs.y, lhs <= rhs.z); } +[[nodiscard]] inline __device__ constexpr auto operator<=(lc_half4 lhs, lc_half4 rhs) noexcept { return lc_make_bool4(lhs.x <= rhs.x, lhs.y <= rhs.y, lhs.z <= rhs.z, lhs.w <= rhs.w); } +[[nodiscard]] inline __device__ constexpr auto operator<=(lc_half4 lhs, lc_half rhs) noexcept { return lc_make_bool4(lhs.x <= rhs, lhs.y <= rhs, lhs.z <= rhs, lhs.w <= rhs); } +[[nodiscard]] inline __device__ constexpr auto operator<=(lc_half lhs, lc_half4 rhs) noexcept { return lc_make_bool4(lhs <= rhs.x, lhs <= rhs.y, lhs <= rhs.z, lhs <= rhs.w); } +[[nodiscard]] inline __device__ constexpr auto operator<=(lc_float2 lhs, lc_float2 rhs) noexcept { return lc_make_bool2(lhs.x <= rhs.x, lhs.y <= rhs.y); } +[[nodiscard]] inline __device__ constexpr auto operator<=(lc_float2 lhs, lc_float rhs) noexcept { return lc_make_bool2(lhs.x <= rhs, lhs.y <= rhs); } +[[nodiscard]] inline __device__ constexpr auto operator<=(lc_float lhs, lc_float2 rhs) noexcept { return lc_make_bool2(lhs <= rhs.x, lhs <= rhs.y); } +[[nodiscard]] inline __device__ constexpr auto operator<=(lc_float3 lhs, lc_float3 rhs) noexcept { return lc_make_bool3(lhs.x <= rhs.x, lhs.y <= rhs.y, lhs.z <= rhs.z); } +[[nodiscard]] inline __device__ constexpr auto operator<=(lc_float3 lhs, lc_float rhs) noexcept { return lc_make_bool3(lhs.x <= rhs, lhs.y <= rhs, lhs.z <= rhs); } +[[nodiscard]] inline __device__ constexpr auto operator<=(lc_float lhs, lc_float3 rhs) noexcept { return lc_make_bool3(lhs <= rhs.x, lhs <= rhs.y, lhs <= rhs.z); } +[[nodiscard]] inline __device__ constexpr auto operator<=(lc_float4 lhs, lc_float4 rhs) noexcept { return lc_make_bool4(lhs.x <= rhs.x, lhs.y <= rhs.y, lhs.z <= rhs.z, lhs.w <= rhs.w); } +[[nodiscard]] inline __device__ constexpr auto operator<=(lc_float4 lhs, lc_float rhs) noexcept { return lc_make_bool4(lhs.x <= rhs, lhs.y <= rhs, lhs.z <= rhs, lhs.w <= rhs); } +[[nodiscard]] inline __device__ constexpr auto operator<=(lc_float lhs, lc_float4 rhs) noexcept { return lc_make_bool4(lhs <= rhs.x, lhs <= rhs.y, lhs <= rhs.z, lhs <= rhs.w); } +[[nodiscard]] inline __device__ constexpr auto operator<=(lc_long2 lhs, lc_long2 rhs) noexcept { return lc_make_bool2(lhs.x <= rhs.x, lhs.y <= rhs.y); } +[[nodiscard]] inline __device__ constexpr auto operator<=(lc_long2 lhs, lc_long rhs) noexcept { return lc_make_bool2(lhs.x <= rhs, lhs.y <= rhs); } +[[nodiscard]] inline __device__ constexpr auto operator<=(lc_long lhs, lc_long2 rhs) noexcept { return lc_make_bool2(lhs <= rhs.x, lhs <= rhs.y); } +[[nodiscard]] inline __device__ constexpr auto operator<=(lc_long3 lhs, lc_long3 rhs) noexcept { return lc_make_bool3(lhs.x <= rhs.x, lhs.y <= rhs.y, lhs.z <= rhs.z); } +[[nodiscard]] inline __device__ constexpr auto operator<=(lc_long3 lhs, lc_long rhs) noexcept { return lc_make_bool3(lhs.x <= rhs, lhs.y <= rhs, lhs.z <= rhs); } +[[nodiscard]] inline __device__ constexpr auto operator<=(lc_long lhs, lc_long3 rhs) noexcept { return lc_make_bool3(lhs <= rhs.x, lhs <= rhs.y, lhs <= rhs.z); } +[[nodiscard]] inline __device__ constexpr auto operator<=(lc_long4 lhs, lc_long4 rhs) noexcept { return lc_make_bool4(lhs.x <= rhs.x, lhs.y <= rhs.y, lhs.z <= rhs.z, lhs.w <= rhs.w); } +[[nodiscard]] inline __device__ constexpr auto operator<=(lc_long4 lhs, lc_long rhs) noexcept { return lc_make_bool4(lhs.x <= rhs, lhs.y <= rhs, lhs.z <= rhs, lhs.w <= rhs); } +[[nodiscard]] inline __device__ constexpr auto operator<=(lc_long lhs, lc_long4 rhs) noexcept { return lc_make_bool4(lhs <= rhs.x, lhs <= rhs.y, lhs <= rhs.z, lhs <= rhs.w); } +[[nodiscard]] inline __device__ constexpr auto operator<=(lc_ulong2 lhs, lc_ulong2 rhs) noexcept { return lc_make_bool2(lhs.x <= rhs.x, lhs.y <= rhs.y); } +[[nodiscard]] inline __device__ constexpr auto operator<=(lc_ulong2 lhs, lc_ulong rhs) noexcept { return lc_make_bool2(lhs.x <= rhs, lhs.y <= rhs); } +[[nodiscard]] inline __device__ constexpr auto operator<=(lc_ulong lhs, lc_ulong2 rhs) noexcept { return lc_make_bool2(lhs <= rhs.x, lhs <= rhs.y); } +[[nodiscard]] inline __device__ constexpr auto operator<=(lc_ulong3 lhs, lc_ulong3 rhs) noexcept { return lc_make_bool3(lhs.x <= rhs.x, lhs.y <= rhs.y, lhs.z <= rhs.z); } +[[nodiscard]] inline __device__ constexpr auto operator<=(lc_ulong3 lhs, lc_ulong rhs) noexcept { return lc_make_bool3(lhs.x <= rhs, lhs.y <= rhs, lhs.z <= rhs); } +[[nodiscard]] inline __device__ constexpr auto operator<=(lc_ulong lhs, lc_ulong3 rhs) noexcept { return lc_make_bool3(lhs <= rhs.x, lhs <= rhs.y, lhs <= rhs.z); } +[[nodiscard]] inline __device__ constexpr auto operator<=(lc_ulong4 lhs, lc_ulong4 rhs) noexcept { return lc_make_bool4(lhs.x <= rhs.x, lhs.y <= rhs.y, lhs.z <= rhs.z, lhs.w <= rhs.w); } +[[nodiscard]] inline __device__ constexpr auto operator<=(lc_ulong4 lhs, lc_ulong rhs) noexcept { return lc_make_bool4(lhs.x <= rhs, lhs.y <= rhs, lhs.z <= rhs, lhs.w <= rhs); } +[[nodiscard]] inline __device__ constexpr auto operator<=(lc_ulong lhs, lc_ulong4 rhs) noexcept { return lc_make_bool4(lhs <= rhs.x, lhs <= rhs.y, lhs <= rhs.z, lhs <= rhs.w); } + +[[nodiscard]] inline __device__ constexpr auto operator>=(lc_short2 lhs, lc_short2 rhs) noexcept { return lc_make_bool2(lhs.x >= rhs.x, lhs.y >= rhs.y); } +[[nodiscard]] inline __device__ constexpr auto operator>=(lc_short2 lhs, lc_short rhs) noexcept { return lc_make_bool2(lhs.x >= rhs, lhs.y >= rhs); } +[[nodiscard]] inline __device__ constexpr auto operator>=(lc_short lhs, lc_short2 rhs) noexcept { return lc_make_bool2(lhs >= rhs.x, lhs >= rhs.y); } +[[nodiscard]] inline __device__ constexpr auto operator>=(lc_short3 lhs, lc_short3 rhs) noexcept { return lc_make_bool3(lhs.x >= rhs.x, lhs.y >= rhs.y, lhs.z >= rhs.z); } +[[nodiscard]] inline __device__ constexpr auto operator>=(lc_short3 lhs, lc_short rhs) noexcept { return lc_make_bool3(lhs.x >= rhs, lhs.y >= rhs, lhs.z >= rhs); } +[[nodiscard]] inline __device__ constexpr auto operator>=(lc_short lhs, lc_short3 rhs) noexcept { return lc_make_bool3(lhs >= rhs.x, lhs >= rhs.y, lhs >= rhs.z); } +[[nodiscard]] inline __device__ constexpr auto operator>=(lc_short4 lhs, lc_short4 rhs) noexcept { return lc_make_bool4(lhs.x >= rhs.x, lhs.y >= rhs.y, lhs.z >= rhs.z, lhs.w >= rhs.w); } +[[nodiscard]] inline __device__ constexpr auto operator>=(lc_short4 lhs, lc_short rhs) noexcept { return lc_make_bool4(lhs.x >= rhs, lhs.y >= rhs, lhs.z >= rhs, lhs.w >= rhs); } +[[nodiscard]] inline __device__ constexpr auto operator>=(lc_short lhs, lc_short4 rhs) noexcept { return lc_make_bool4(lhs >= rhs.x, lhs >= rhs.y, lhs >= rhs.z, lhs >= rhs.w); } +[[nodiscard]] inline __device__ constexpr auto operator>=(lc_ushort2 lhs, lc_ushort2 rhs) noexcept { return lc_make_bool2(lhs.x >= rhs.x, lhs.y >= rhs.y); } +[[nodiscard]] inline __device__ constexpr auto operator>=(lc_ushort2 lhs, lc_ushort rhs) noexcept { return lc_make_bool2(lhs.x >= rhs, lhs.y >= rhs); } +[[nodiscard]] inline __device__ constexpr auto operator>=(lc_ushort lhs, lc_ushort2 rhs) noexcept { return lc_make_bool2(lhs >= rhs.x, lhs >= rhs.y); } +[[nodiscard]] inline __device__ constexpr auto operator>=(lc_ushort3 lhs, lc_ushort3 rhs) noexcept { return lc_make_bool3(lhs.x >= rhs.x, lhs.y >= rhs.y, lhs.z >= rhs.z); } +[[nodiscard]] inline __device__ constexpr auto operator>=(lc_ushort3 lhs, lc_ushort rhs) noexcept { return lc_make_bool3(lhs.x >= rhs, lhs.y >= rhs, lhs.z >= rhs); } +[[nodiscard]] inline __device__ constexpr auto operator>=(lc_ushort lhs, lc_ushort3 rhs) noexcept { return lc_make_bool3(lhs >= rhs.x, lhs >= rhs.y, lhs >= rhs.z); } +[[nodiscard]] inline __device__ constexpr auto operator>=(lc_ushort4 lhs, lc_ushort4 rhs) noexcept { return lc_make_bool4(lhs.x >= rhs.x, lhs.y >= rhs.y, lhs.z >= rhs.z, lhs.w >= rhs.w); } +[[nodiscard]] inline __device__ constexpr auto operator>=(lc_ushort4 lhs, lc_ushort rhs) noexcept { return lc_make_bool4(lhs.x >= rhs, lhs.y >= rhs, lhs.z >= rhs, lhs.w >= rhs); } +[[nodiscard]] inline __device__ constexpr auto operator>=(lc_ushort lhs, lc_ushort4 rhs) noexcept { return lc_make_bool4(lhs >= rhs.x, lhs >= rhs.y, lhs >= rhs.z, lhs >= rhs.w); } +[[nodiscard]] inline __device__ constexpr auto operator>=(lc_int2 lhs, lc_int2 rhs) noexcept { return lc_make_bool2(lhs.x >= rhs.x, lhs.y >= rhs.y); } +[[nodiscard]] inline __device__ constexpr auto operator>=(lc_int2 lhs, lc_int rhs) noexcept { return lc_make_bool2(lhs.x >= rhs, lhs.y >= rhs); } +[[nodiscard]] inline __device__ constexpr auto operator>=(lc_int lhs, lc_int2 rhs) noexcept { return lc_make_bool2(lhs >= rhs.x, lhs >= rhs.y); } +[[nodiscard]] inline __device__ constexpr auto operator>=(lc_int3 lhs, lc_int3 rhs) noexcept { return lc_make_bool3(lhs.x >= rhs.x, lhs.y >= rhs.y, lhs.z >= rhs.z); } +[[nodiscard]] inline __device__ constexpr auto operator>=(lc_int3 lhs, lc_int rhs) noexcept { return lc_make_bool3(lhs.x >= rhs, lhs.y >= rhs, lhs.z >= rhs); } +[[nodiscard]] inline __device__ constexpr auto operator>=(lc_int lhs, lc_int3 rhs) noexcept { return lc_make_bool3(lhs >= rhs.x, lhs >= rhs.y, lhs >= rhs.z); } +[[nodiscard]] inline __device__ constexpr auto operator>=(lc_int4 lhs, lc_int4 rhs) noexcept { return lc_make_bool4(lhs.x >= rhs.x, lhs.y >= rhs.y, lhs.z >= rhs.z, lhs.w >= rhs.w); } +[[nodiscard]] inline __device__ constexpr auto operator>=(lc_int4 lhs, lc_int rhs) noexcept { return lc_make_bool4(lhs.x >= rhs, lhs.y >= rhs, lhs.z >= rhs, lhs.w >= rhs); } +[[nodiscard]] inline __device__ constexpr auto operator>=(lc_int lhs, lc_int4 rhs) noexcept { return lc_make_bool4(lhs >= rhs.x, lhs >= rhs.y, lhs >= rhs.z, lhs >= rhs.w); } +[[nodiscard]] inline __device__ constexpr auto operator>=(lc_uint2 lhs, lc_uint2 rhs) noexcept { return lc_make_bool2(lhs.x >= rhs.x, lhs.y >= rhs.y); } +[[nodiscard]] inline __device__ constexpr auto operator>=(lc_uint2 lhs, lc_uint rhs) noexcept { return lc_make_bool2(lhs.x >= rhs, lhs.y >= rhs); } +[[nodiscard]] inline __device__ constexpr auto operator>=(lc_uint lhs, lc_uint2 rhs) noexcept { return lc_make_bool2(lhs >= rhs.x, lhs >= rhs.y); } +[[nodiscard]] inline __device__ constexpr auto operator>=(lc_uint3 lhs, lc_uint3 rhs) noexcept { return lc_make_bool3(lhs.x >= rhs.x, lhs.y >= rhs.y, lhs.z >= rhs.z); } +[[nodiscard]] inline __device__ constexpr auto operator>=(lc_uint3 lhs, lc_uint rhs) noexcept { return lc_make_bool3(lhs.x >= rhs, lhs.y >= rhs, lhs.z >= rhs); } +[[nodiscard]] inline __device__ constexpr auto operator>=(lc_uint lhs, lc_uint3 rhs) noexcept { return lc_make_bool3(lhs >= rhs.x, lhs >= rhs.y, lhs >= rhs.z); } +[[nodiscard]] inline __device__ constexpr auto operator>=(lc_uint4 lhs, lc_uint4 rhs) noexcept { return lc_make_bool4(lhs.x >= rhs.x, lhs.y >= rhs.y, lhs.z >= rhs.z, lhs.w >= rhs.w); } +[[nodiscard]] inline __device__ constexpr auto operator>=(lc_uint4 lhs, lc_uint rhs) noexcept { return lc_make_bool4(lhs.x >= rhs, lhs.y >= rhs, lhs.z >= rhs, lhs.w >= rhs); } +[[nodiscard]] inline __device__ constexpr auto operator>=(lc_uint lhs, lc_uint4 rhs) noexcept { return lc_make_bool4(lhs >= rhs.x, lhs >= rhs.y, lhs >= rhs.z, lhs >= rhs.w); } +[[nodiscard]] inline __device__ constexpr auto operator>=(lc_half2 lhs, lc_half2 rhs) noexcept { return lc_make_bool2(lhs.x >= rhs.x, lhs.y >= rhs.y); } +[[nodiscard]] inline __device__ constexpr auto operator>=(lc_half2 lhs, lc_half rhs) noexcept { return lc_make_bool2(lhs.x >= rhs, lhs.y >= rhs); } +[[nodiscard]] inline __device__ constexpr auto operator>=(lc_half lhs, lc_half2 rhs) noexcept { return lc_make_bool2(lhs >= rhs.x, lhs >= rhs.y); } +[[nodiscard]] inline __device__ constexpr auto operator>=(lc_half3 lhs, lc_half3 rhs) noexcept { return lc_make_bool3(lhs.x >= rhs.x, lhs.y >= rhs.y, lhs.z >= rhs.z); } +[[nodiscard]] inline __device__ constexpr auto operator>=(lc_half3 lhs, lc_half rhs) noexcept { return lc_make_bool3(lhs.x >= rhs, lhs.y >= rhs, lhs.z >= rhs); } +[[nodiscard]] inline __device__ constexpr auto operator>=(lc_half lhs, lc_half3 rhs) noexcept { return lc_make_bool3(lhs >= rhs.x, lhs >= rhs.y, lhs >= rhs.z); } +[[nodiscard]] inline __device__ constexpr auto operator>=(lc_half4 lhs, lc_half4 rhs) noexcept { return lc_make_bool4(lhs.x >= rhs.x, lhs.y >= rhs.y, lhs.z >= rhs.z, lhs.w >= rhs.w); } +[[nodiscard]] inline __device__ constexpr auto operator>=(lc_half4 lhs, lc_half rhs) noexcept { return lc_make_bool4(lhs.x >= rhs, lhs.y >= rhs, lhs.z >= rhs, lhs.w >= rhs); } +[[nodiscard]] inline __device__ constexpr auto operator>=(lc_half lhs, lc_half4 rhs) noexcept { return lc_make_bool4(lhs >= rhs.x, lhs >= rhs.y, lhs >= rhs.z, lhs >= rhs.w); } +[[nodiscard]] inline __device__ constexpr auto operator>=(lc_float2 lhs, lc_float2 rhs) noexcept { return lc_make_bool2(lhs.x >= rhs.x, lhs.y >= rhs.y); } +[[nodiscard]] inline __device__ constexpr auto operator>=(lc_float2 lhs, lc_float rhs) noexcept { return lc_make_bool2(lhs.x >= rhs, lhs.y >= rhs); } +[[nodiscard]] inline __device__ constexpr auto operator>=(lc_float lhs, lc_float2 rhs) noexcept { return lc_make_bool2(lhs >= rhs.x, lhs >= rhs.y); } +[[nodiscard]] inline __device__ constexpr auto operator>=(lc_float3 lhs, lc_float3 rhs) noexcept { return lc_make_bool3(lhs.x >= rhs.x, lhs.y >= rhs.y, lhs.z >= rhs.z); } +[[nodiscard]] inline __device__ constexpr auto operator>=(lc_float3 lhs, lc_float rhs) noexcept { return lc_make_bool3(lhs.x >= rhs, lhs.y >= rhs, lhs.z >= rhs); } +[[nodiscard]] inline __device__ constexpr auto operator>=(lc_float lhs, lc_float3 rhs) noexcept { return lc_make_bool3(lhs >= rhs.x, lhs >= rhs.y, lhs >= rhs.z); } +[[nodiscard]] inline __device__ constexpr auto operator>=(lc_float4 lhs, lc_float4 rhs) noexcept { return lc_make_bool4(lhs.x >= rhs.x, lhs.y >= rhs.y, lhs.z >= rhs.z, lhs.w >= rhs.w); } +[[nodiscard]] inline __device__ constexpr auto operator>=(lc_float4 lhs, lc_float rhs) noexcept { return lc_make_bool4(lhs.x >= rhs, lhs.y >= rhs, lhs.z >= rhs, lhs.w >= rhs); } +[[nodiscard]] inline __device__ constexpr auto operator>=(lc_float lhs, lc_float4 rhs) noexcept { return lc_make_bool4(lhs >= rhs.x, lhs >= rhs.y, lhs >= rhs.z, lhs >= rhs.w); } +[[nodiscard]] inline __device__ constexpr auto operator>=(lc_long2 lhs, lc_long2 rhs) noexcept { return lc_make_bool2(lhs.x >= rhs.x, lhs.y >= rhs.y); } +[[nodiscard]] inline __device__ constexpr auto operator>=(lc_long2 lhs, lc_long rhs) noexcept { return lc_make_bool2(lhs.x >= rhs, lhs.y >= rhs); } +[[nodiscard]] inline __device__ constexpr auto operator>=(lc_long lhs, lc_long2 rhs) noexcept { return lc_make_bool2(lhs >= rhs.x, lhs >= rhs.y); } +[[nodiscard]] inline __device__ constexpr auto operator>=(lc_long3 lhs, lc_long3 rhs) noexcept { return lc_make_bool3(lhs.x >= rhs.x, lhs.y >= rhs.y, lhs.z >= rhs.z); } +[[nodiscard]] inline __device__ constexpr auto operator>=(lc_long3 lhs, lc_long rhs) noexcept { return lc_make_bool3(lhs.x >= rhs, lhs.y >= rhs, lhs.z >= rhs); } +[[nodiscard]] inline __device__ constexpr auto operator>=(lc_long lhs, lc_long3 rhs) noexcept { return lc_make_bool3(lhs >= rhs.x, lhs >= rhs.y, lhs >= rhs.z); } +[[nodiscard]] inline __device__ constexpr auto operator>=(lc_long4 lhs, lc_long4 rhs) noexcept { return lc_make_bool4(lhs.x >= rhs.x, lhs.y >= rhs.y, lhs.z >= rhs.z, lhs.w >= rhs.w); } +[[nodiscard]] inline __device__ constexpr auto operator>=(lc_long4 lhs, lc_long rhs) noexcept { return lc_make_bool4(lhs.x >= rhs, lhs.y >= rhs, lhs.z >= rhs, lhs.w >= rhs); } +[[nodiscard]] inline __device__ constexpr auto operator>=(lc_long lhs, lc_long4 rhs) noexcept { return lc_make_bool4(lhs >= rhs.x, lhs >= rhs.y, lhs >= rhs.z, lhs >= rhs.w); } +[[nodiscard]] inline __device__ constexpr auto operator>=(lc_ulong2 lhs, lc_ulong2 rhs) noexcept { return lc_make_bool2(lhs.x >= rhs.x, lhs.y >= rhs.y); } +[[nodiscard]] inline __device__ constexpr auto operator>=(lc_ulong2 lhs, lc_ulong rhs) noexcept { return lc_make_bool2(lhs.x >= rhs, lhs.y >= rhs); } +[[nodiscard]] inline __device__ constexpr auto operator>=(lc_ulong lhs, lc_ulong2 rhs) noexcept { return lc_make_bool2(lhs >= rhs.x, lhs >= rhs.y); } +[[nodiscard]] inline __device__ constexpr auto operator>=(lc_ulong3 lhs, lc_ulong3 rhs) noexcept { return lc_make_bool3(lhs.x >= rhs.x, lhs.y >= rhs.y, lhs.z >= rhs.z); } +[[nodiscard]] inline __device__ constexpr auto operator>=(lc_ulong3 lhs, lc_ulong rhs) noexcept { return lc_make_bool3(lhs.x >= rhs, lhs.y >= rhs, lhs.z >= rhs); } +[[nodiscard]] inline __device__ constexpr auto operator>=(lc_ulong lhs, lc_ulong3 rhs) noexcept { return lc_make_bool3(lhs >= rhs.x, lhs >= rhs.y, lhs >= rhs.z); } +[[nodiscard]] inline __device__ constexpr auto operator>=(lc_ulong4 lhs, lc_ulong4 rhs) noexcept { return lc_make_bool4(lhs.x >= rhs.x, lhs.y >= rhs.y, lhs.z >= rhs.z, lhs.w >= rhs.w); } +[[nodiscard]] inline __device__ constexpr auto operator>=(lc_ulong4 lhs, lc_ulong rhs) noexcept { return lc_make_bool4(lhs.x >= rhs, lhs.y >= rhs, lhs.z >= rhs, lhs.w >= rhs); } +[[nodiscard]] inline __device__ constexpr auto operator>=(lc_ulong lhs, lc_ulong4 rhs) noexcept { return lc_make_bool4(lhs >= rhs.x, lhs >= rhs.y, lhs >= rhs.z, lhs >= rhs.w); } + +[[nodiscard]] inline __device__ constexpr auto operator+(lc_short2 lhs, lc_short2 rhs) noexcept { return lc_make_short2(lhs.x + rhs.x, lhs.y + rhs.y); } +[[nodiscard]] inline __device__ constexpr auto operator+(lc_short2 lhs, lc_short rhs) noexcept { return lc_make_short2(lhs.x + rhs, lhs.y + rhs); } +[[nodiscard]] inline __device__ constexpr auto operator+(lc_short lhs, lc_short2 rhs) noexcept { return lc_make_short2(lhs + rhs.x, lhs + rhs.y); } +[[nodiscard]] inline __device__ constexpr auto operator+(lc_short3 lhs, lc_short3 rhs) noexcept { return lc_make_short3(lhs.x + rhs.x, lhs.y + rhs.y, lhs.z + rhs.z); } +[[nodiscard]] inline __device__ constexpr auto operator+(lc_short3 lhs, lc_short rhs) noexcept { return lc_make_short3(lhs.x + rhs, lhs.y + rhs, lhs.z + rhs); } +[[nodiscard]] inline __device__ constexpr auto operator+(lc_short lhs, lc_short3 rhs) noexcept { return lc_make_short3(lhs + rhs.x, lhs + rhs.y, lhs + rhs.z); } +[[nodiscard]] inline __device__ constexpr auto operator+(lc_short4 lhs, lc_short4 rhs) noexcept { return lc_make_short4(lhs.x + rhs.x, lhs.y + rhs.y, lhs.z + rhs.z, lhs.w + rhs.w); } +[[nodiscard]] inline __device__ constexpr auto operator+(lc_short4 lhs, lc_short rhs) noexcept { return lc_make_short4(lhs.x + rhs, lhs.y + rhs, lhs.z + rhs, lhs.w + rhs); } +[[nodiscard]] inline __device__ constexpr auto operator+(lc_short lhs, lc_short4 rhs) noexcept { return lc_make_short4(lhs + rhs.x, lhs + rhs.y, lhs + rhs.z, lhs + rhs.w); } +[[nodiscard]] inline __device__ constexpr auto operator+(lc_ushort2 lhs, lc_ushort2 rhs) noexcept { return lc_make_ushort2(lhs.x + rhs.x, lhs.y + rhs.y); } +[[nodiscard]] inline __device__ constexpr auto operator+(lc_ushort2 lhs, lc_ushort rhs) noexcept { return lc_make_ushort2(lhs.x + rhs, lhs.y + rhs); } +[[nodiscard]] inline __device__ constexpr auto operator+(lc_ushort lhs, lc_ushort2 rhs) noexcept { return lc_make_ushort2(lhs + rhs.x, lhs + rhs.y); } +[[nodiscard]] inline __device__ constexpr auto operator+(lc_ushort3 lhs, lc_ushort3 rhs) noexcept { return lc_make_ushort3(lhs.x + rhs.x, lhs.y + rhs.y, lhs.z + rhs.z); } +[[nodiscard]] inline __device__ constexpr auto operator+(lc_ushort3 lhs, lc_ushort rhs) noexcept { return lc_make_ushort3(lhs.x + rhs, lhs.y + rhs, lhs.z + rhs); } +[[nodiscard]] inline __device__ constexpr auto operator+(lc_ushort lhs, lc_ushort3 rhs) noexcept { return lc_make_ushort3(lhs + rhs.x, lhs + rhs.y, lhs + rhs.z); } +[[nodiscard]] inline __device__ constexpr auto operator+(lc_ushort4 lhs, lc_ushort4 rhs) noexcept { return lc_make_ushort4(lhs.x + rhs.x, lhs.y + rhs.y, lhs.z + rhs.z, lhs.w + rhs.w); } +[[nodiscard]] inline __device__ constexpr auto operator+(lc_ushort4 lhs, lc_ushort rhs) noexcept { return lc_make_ushort4(lhs.x + rhs, lhs.y + rhs, lhs.z + rhs, lhs.w + rhs); } +[[nodiscard]] inline __device__ constexpr auto operator+(lc_ushort lhs, lc_ushort4 rhs) noexcept { return lc_make_ushort4(lhs + rhs.x, lhs + rhs.y, lhs + rhs.z, lhs + rhs.w); } +[[nodiscard]] inline __device__ constexpr auto operator+(lc_int2 lhs, lc_int2 rhs) noexcept { return lc_make_int2(lhs.x + rhs.x, lhs.y + rhs.y); } +[[nodiscard]] inline __device__ constexpr auto operator+(lc_int2 lhs, lc_int rhs) noexcept { return lc_make_int2(lhs.x + rhs, lhs.y + rhs); } +[[nodiscard]] inline __device__ constexpr auto operator+(lc_int lhs, lc_int2 rhs) noexcept { return lc_make_int2(lhs + rhs.x, lhs + rhs.y); } +[[nodiscard]] inline __device__ constexpr auto operator+(lc_int3 lhs, lc_int3 rhs) noexcept { return lc_make_int3(lhs.x + rhs.x, lhs.y + rhs.y, lhs.z + rhs.z); } +[[nodiscard]] inline __device__ constexpr auto operator+(lc_int3 lhs, lc_int rhs) noexcept { return lc_make_int3(lhs.x + rhs, lhs.y + rhs, lhs.z + rhs); } +[[nodiscard]] inline __device__ constexpr auto operator+(lc_int lhs, lc_int3 rhs) noexcept { return lc_make_int3(lhs + rhs.x, lhs + rhs.y, lhs + rhs.z); } +[[nodiscard]] inline __device__ constexpr auto operator+(lc_int4 lhs, lc_int4 rhs) noexcept { return lc_make_int4(lhs.x + rhs.x, lhs.y + rhs.y, lhs.z + rhs.z, lhs.w + rhs.w); } +[[nodiscard]] inline __device__ constexpr auto operator+(lc_int4 lhs, lc_int rhs) noexcept { return lc_make_int4(lhs.x + rhs, lhs.y + rhs, lhs.z + rhs, lhs.w + rhs); } +[[nodiscard]] inline __device__ constexpr auto operator+(lc_int lhs, lc_int4 rhs) noexcept { return lc_make_int4(lhs + rhs.x, lhs + rhs.y, lhs + rhs.z, lhs + rhs.w); } +[[nodiscard]] inline __device__ constexpr auto operator+(lc_uint2 lhs, lc_uint2 rhs) noexcept { return lc_make_uint2(lhs.x + rhs.x, lhs.y + rhs.y); } +[[nodiscard]] inline __device__ constexpr auto operator+(lc_uint2 lhs, lc_uint rhs) noexcept { return lc_make_uint2(lhs.x + rhs, lhs.y + rhs); } +[[nodiscard]] inline __device__ constexpr auto operator+(lc_uint lhs, lc_uint2 rhs) noexcept { return lc_make_uint2(lhs + rhs.x, lhs + rhs.y); } +[[nodiscard]] inline __device__ constexpr auto operator+(lc_uint3 lhs, lc_uint3 rhs) noexcept { return lc_make_uint3(lhs.x + rhs.x, lhs.y + rhs.y, lhs.z + rhs.z); } +[[nodiscard]] inline __device__ constexpr auto operator+(lc_uint3 lhs, lc_uint rhs) noexcept { return lc_make_uint3(lhs.x + rhs, lhs.y + rhs, lhs.z + rhs); } +[[nodiscard]] inline __device__ constexpr auto operator+(lc_uint lhs, lc_uint3 rhs) noexcept { return lc_make_uint3(lhs + rhs.x, lhs + rhs.y, lhs + rhs.z); } +[[nodiscard]] inline __device__ constexpr auto operator+(lc_uint4 lhs, lc_uint4 rhs) noexcept { return lc_make_uint4(lhs.x + rhs.x, lhs.y + rhs.y, lhs.z + rhs.z, lhs.w + rhs.w); } +[[nodiscard]] inline __device__ constexpr auto operator+(lc_uint4 lhs, lc_uint rhs) noexcept { return lc_make_uint4(lhs.x + rhs, lhs.y + rhs, lhs.z + rhs, lhs.w + rhs); } +[[nodiscard]] inline __device__ constexpr auto operator+(lc_uint lhs, lc_uint4 rhs) noexcept { return lc_make_uint4(lhs + rhs.x, lhs + rhs.y, lhs + rhs.z, lhs + rhs.w); } +[[nodiscard]] inline __device__ constexpr auto operator+(lc_half2 lhs, lc_half2 rhs) noexcept { return lc_make_half2(lhs.x + rhs.x, lhs.y + rhs.y); } +[[nodiscard]] inline __device__ constexpr auto operator+(lc_half2 lhs, lc_half rhs) noexcept { return lc_make_half2(lhs.x + rhs, lhs.y + rhs); } +[[nodiscard]] inline __device__ constexpr auto operator+(lc_half lhs, lc_half2 rhs) noexcept { return lc_make_half2(lhs + rhs.x, lhs + rhs.y); } +[[nodiscard]] inline __device__ constexpr auto operator+(lc_half3 lhs, lc_half3 rhs) noexcept { return lc_make_half3(lhs.x + rhs.x, lhs.y + rhs.y, lhs.z + rhs.z); } +[[nodiscard]] inline __device__ constexpr auto operator+(lc_half3 lhs, lc_half rhs) noexcept { return lc_make_half3(lhs.x + rhs, lhs.y + rhs, lhs.z + rhs); } +[[nodiscard]] inline __device__ constexpr auto operator+(lc_half lhs, lc_half3 rhs) noexcept { return lc_make_half3(lhs + rhs.x, lhs + rhs.y, lhs + rhs.z); } +[[nodiscard]] inline __device__ constexpr auto operator+(lc_half4 lhs, lc_half4 rhs) noexcept { return lc_make_half4(lhs.x + rhs.x, lhs.y + rhs.y, lhs.z + rhs.z, lhs.w + rhs.w); } +[[nodiscard]] inline __device__ constexpr auto operator+(lc_half4 lhs, lc_half rhs) noexcept { return lc_make_half4(lhs.x + rhs, lhs.y + rhs, lhs.z + rhs, lhs.w + rhs); } +[[nodiscard]] inline __device__ constexpr auto operator+(lc_half lhs, lc_half4 rhs) noexcept { return lc_make_half4(lhs + rhs.x, lhs + rhs.y, lhs + rhs.z, lhs + rhs.w); } +[[nodiscard]] inline __device__ constexpr auto operator+(lc_float2 lhs, lc_float2 rhs) noexcept { return lc_make_float2(lhs.x + rhs.x, lhs.y + rhs.y); } +[[nodiscard]] inline __device__ constexpr auto operator+(lc_float2 lhs, lc_float rhs) noexcept { return lc_make_float2(lhs.x + rhs, lhs.y + rhs); } +[[nodiscard]] inline __device__ constexpr auto operator+(lc_float lhs, lc_float2 rhs) noexcept { return lc_make_float2(lhs + rhs.x, lhs + rhs.y); } +[[nodiscard]] inline __device__ constexpr auto operator+(lc_float3 lhs, lc_float3 rhs) noexcept { return lc_make_float3(lhs.x + rhs.x, lhs.y + rhs.y, lhs.z + rhs.z); } +[[nodiscard]] inline __device__ constexpr auto operator+(lc_float3 lhs, lc_float rhs) noexcept { return lc_make_float3(lhs.x + rhs, lhs.y + rhs, lhs.z + rhs); } +[[nodiscard]] inline __device__ constexpr auto operator+(lc_float lhs, lc_float3 rhs) noexcept { return lc_make_float3(lhs + rhs.x, lhs + rhs.y, lhs + rhs.z); } +[[nodiscard]] inline __device__ constexpr auto operator+(lc_float4 lhs, lc_float4 rhs) noexcept { return lc_make_float4(lhs.x + rhs.x, lhs.y + rhs.y, lhs.z + rhs.z, lhs.w + rhs.w); } +[[nodiscard]] inline __device__ constexpr auto operator+(lc_float4 lhs, lc_float rhs) noexcept { return lc_make_float4(lhs.x + rhs, lhs.y + rhs, lhs.z + rhs, lhs.w + rhs); } +[[nodiscard]] inline __device__ constexpr auto operator+(lc_float lhs, lc_float4 rhs) noexcept { return lc_make_float4(lhs + rhs.x, lhs + rhs.y, lhs + rhs.z, lhs + rhs.w); } +[[nodiscard]] inline __device__ constexpr auto operator+(lc_long2 lhs, lc_long2 rhs) noexcept { return lc_make_long2(lhs.x + rhs.x, lhs.y + rhs.y); } +[[nodiscard]] inline __device__ constexpr auto operator+(lc_long2 lhs, lc_long rhs) noexcept { return lc_make_long2(lhs.x + rhs, lhs.y + rhs); } +[[nodiscard]] inline __device__ constexpr auto operator+(lc_long lhs, lc_long2 rhs) noexcept { return lc_make_long2(lhs + rhs.x, lhs + rhs.y); } +[[nodiscard]] inline __device__ constexpr auto operator+(lc_long3 lhs, lc_long3 rhs) noexcept { return lc_make_long3(lhs.x + rhs.x, lhs.y + rhs.y, lhs.z + rhs.z); } +[[nodiscard]] inline __device__ constexpr auto operator+(lc_long3 lhs, lc_long rhs) noexcept { return lc_make_long3(lhs.x + rhs, lhs.y + rhs, lhs.z + rhs); } +[[nodiscard]] inline __device__ constexpr auto operator+(lc_long lhs, lc_long3 rhs) noexcept { return lc_make_long3(lhs + rhs.x, lhs + rhs.y, lhs + rhs.z); } +[[nodiscard]] inline __device__ constexpr auto operator+(lc_long4 lhs, lc_long4 rhs) noexcept { return lc_make_long4(lhs.x + rhs.x, lhs.y + rhs.y, lhs.z + rhs.z, lhs.w + rhs.w); } +[[nodiscard]] inline __device__ constexpr auto operator+(lc_long4 lhs, lc_long rhs) noexcept { return lc_make_long4(lhs.x + rhs, lhs.y + rhs, lhs.z + rhs, lhs.w + rhs); } +[[nodiscard]] inline __device__ constexpr auto operator+(lc_long lhs, lc_long4 rhs) noexcept { return lc_make_long4(lhs + rhs.x, lhs + rhs.y, lhs + rhs.z, lhs + rhs.w); } +[[nodiscard]] inline __device__ constexpr auto operator+(lc_ulong2 lhs, lc_ulong2 rhs) noexcept { return lc_make_ulong2(lhs.x + rhs.x, lhs.y + rhs.y); } +[[nodiscard]] inline __device__ constexpr auto operator+(lc_ulong2 lhs, lc_ulong rhs) noexcept { return lc_make_ulong2(lhs.x + rhs, lhs.y + rhs); } +[[nodiscard]] inline __device__ constexpr auto operator+(lc_ulong lhs, lc_ulong2 rhs) noexcept { return lc_make_ulong2(lhs + rhs.x, lhs + rhs.y); } +[[nodiscard]] inline __device__ constexpr auto operator+(lc_ulong3 lhs, lc_ulong3 rhs) noexcept { return lc_make_ulong3(lhs.x + rhs.x, lhs.y + rhs.y, lhs.z + rhs.z); } +[[nodiscard]] inline __device__ constexpr auto operator+(lc_ulong3 lhs, lc_ulong rhs) noexcept { return lc_make_ulong3(lhs.x + rhs, lhs.y + rhs, lhs.z + rhs); } +[[nodiscard]] inline __device__ constexpr auto operator+(lc_ulong lhs, lc_ulong3 rhs) noexcept { return lc_make_ulong3(lhs + rhs.x, lhs + rhs.y, lhs + rhs.z); } +[[nodiscard]] inline __device__ constexpr auto operator+(lc_ulong4 lhs, lc_ulong4 rhs) noexcept { return lc_make_ulong4(lhs.x + rhs.x, lhs.y + rhs.y, lhs.z + rhs.z, lhs.w + rhs.w); } +[[nodiscard]] inline __device__ constexpr auto operator+(lc_ulong4 lhs, lc_ulong rhs) noexcept { return lc_make_ulong4(lhs.x + rhs, lhs.y + rhs, lhs.z + rhs, lhs.w + rhs); } +[[nodiscard]] inline __device__ constexpr auto operator+(lc_ulong lhs, lc_ulong4 rhs) noexcept { return lc_make_ulong4(lhs + rhs.x, lhs + rhs.y, lhs + rhs.z, lhs + rhs.w); } + +[[nodiscard]] inline __device__ constexpr auto operator-(lc_short2 lhs, lc_short2 rhs) noexcept { return lc_make_short2(lhs.x - rhs.x, lhs.y - rhs.y); } +[[nodiscard]] inline __device__ constexpr auto operator-(lc_short2 lhs, lc_short rhs) noexcept { return lc_make_short2(lhs.x - rhs, lhs.y - rhs); } +[[nodiscard]] inline __device__ constexpr auto operator-(lc_short lhs, lc_short2 rhs) noexcept { return lc_make_short2(lhs - rhs.x, lhs - rhs.y); } +[[nodiscard]] inline __device__ constexpr auto operator-(lc_short3 lhs, lc_short3 rhs) noexcept { return lc_make_short3(lhs.x - rhs.x, lhs.y - rhs.y, lhs.z - rhs.z); } +[[nodiscard]] inline __device__ constexpr auto operator-(lc_short3 lhs, lc_short rhs) noexcept { return lc_make_short3(lhs.x - rhs, lhs.y - rhs, lhs.z - rhs); } +[[nodiscard]] inline __device__ constexpr auto operator-(lc_short lhs, lc_short3 rhs) noexcept { return lc_make_short3(lhs - rhs.x, lhs - rhs.y, lhs - rhs.z); } +[[nodiscard]] inline __device__ constexpr auto operator-(lc_short4 lhs, lc_short4 rhs) noexcept { return lc_make_short4(lhs.x - rhs.x, lhs.y - rhs.y, lhs.z - rhs.z, lhs.w - rhs.w); } +[[nodiscard]] inline __device__ constexpr auto operator-(lc_short4 lhs, lc_short rhs) noexcept { return lc_make_short4(lhs.x - rhs, lhs.y - rhs, lhs.z - rhs, lhs.w - rhs); } +[[nodiscard]] inline __device__ constexpr auto operator-(lc_short lhs, lc_short4 rhs) noexcept { return lc_make_short4(lhs - rhs.x, lhs - rhs.y, lhs - rhs.z, lhs - rhs.w); } +[[nodiscard]] inline __device__ constexpr auto operator-(lc_ushort2 lhs, lc_ushort2 rhs) noexcept { return lc_make_ushort2(lhs.x - rhs.x, lhs.y - rhs.y); } +[[nodiscard]] inline __device__ constexpr auto operator-(lc_ushort2 lhs, lc_ushort rhs) noexcept { return lc_make_ushort2(lhs.x - rhs, lhs.y - rhs); } +[[nodiscard]] inline __device__ constexpr auto operator-(lc_ushort lhs, lc_ushort2 rhs) noexcept { return lc_make_ushort2(lhs - rhs.x, lhs - rhs.y); } +[[nodiscard]] inline __device__ constexpr auto operator-(lc_ushort3 lhs, lc_ushort3 rhs) noexcept { return lc_make_ushort3(lhs.x - rhs.x, lhs.y - rhs.y, lhs.z - rhs.z); } +[[nodiscard]] inline __device__ constexpr auto operator-(lc_ushort3 lhs, lc_ushort rhs) noexcept { return lc_make_ushort3(lhs.x - rhs, lhs.y - rhs, lhs.z - rhs); } +[[nodiscard]] inline __device__ constexpr auto operator-(lc_ushort lhs, lc_ushort3 rhs) noexcept { return lc_make_ushort3(lhs - rhs.x, lhs - rhs.y, lhs - rhs.z); } +[[nodiscard]] inline __device__ constexpr auto operator-(lc_ushort4 lhs, lc_ushort4 rhs) noexcept { return lc_make_ushort4(lhs.x - rhs.x, lhs.y - rhs.y, lhs.z - rhs.z, lhs.w - rhs.w); } +[[nodiscard]] inline __device__ constexpr auto operator-(lc_ushort4 lhs, lc_ushort rhs) noexcept { return lc_make_ushort4(lhs.x - rhs, lhs.y - rhs, lhs.z - rhs, lhs.w - rhs); } +[[nodiscard]] inline __device__ constexpr auto operator-(lc_ushort lhs, lc_ushort4 rhs) noexcept { return lc_make_ushort4(lhs - rhs.x, lhs - rhs.y, lhs - rhs.z, lhs - rhs.w); } +[[nodiscard]] inline __device__ constexpr auto operator-(lc_int2 lhs, lc_int2 rhs) noexcept { return lc_make_int2(lhs.x - rhs.x, lhs.y - rhs.y); } +[[nodiscard]] inline __device__ constexpr auto operator-(lc_int2 lhs, lc_int rhs) noexcept { return lc_make_int2(lhs.x - rhs, lhs.y - rhs); } +[[nodiscard]] inline __device__ constexpr auto operator-(lc_int lhs, lc_int2 rhs) noexcept { return lc_make_int2(lhs - rhs.x, lhs - rhs.y); } +[[nodiscard]] inline __device__ constexpr auto operator-(lc_int3 lhs, lc_int3 rhs) noexcept { return lc_make_int3(lhs.x - rhs.x, lhs.y - rhs.y, lhs.z - rhs.z); } +[[nodiscard]] inline __device__ constexpr auto operator-(lc_int3 lhs, lc_int rhs) noexcept { return lc_make_int3(lhs.x - rhs, lhs.y - rhs, lhs.z - rhs); } +[[nodiscard]] inline __device__ constexpr auto operator-(lc_int lhs, lc_int3 rhs) noexcept { return lc_make_int3(lhs - rhs.x, lhs - rhs.y, lhs - rhs.z); } +[[nodiscard]] inline __device__ constexpr auto operator-(lc_int4 lhs, lc_int4 rhs) noexcept { return lc_make_int4(lhs.x - rhs.x, lhs.y - rhs.y, lhs.z - rhs.z, lhs.w - rhs.w); } +[[nodiscard]] inline __device__ constexpr auto operator-(lc_int4 lhs, lc_int rhs) noexcept { return lc_make_int4(lhs.x - rhs, lhs.y - rhs, lhs.z - rhs, lhs.w - rhs); } +[[nodiscard]] inline __device__ constexpr auto operator-(lc_int lhs, lc_int4 rhs) noexcept { return lc_make_int4(lhs - rhs.x, lhs - rhs.y, lhs - rhs.z, lhs - rhs.w); } +[[nodiscard]] inline __device__ constexpr auto operator-(lc_uint2 lhs, lc_uint2 rhs) noexcept { return lc_make_uint2(lhs.x - rhs.x, lhs.y - rhs.y); } +[[nodiscard]] inline __device__ constexpr auto operator-(lc_uint2 lhs, lc_uint rhs) noexcept { return lc_make_uint2(lhs.x - rhs, lhs.y - rhs); } +[[nodiscard]] inline __device__ constexpr auto operator-(lc_uint lhs, lc_uint2 rhs) noexcept { return lc_make_uint2(lhs - rhs.x, lhs - rhs.y); } +[[nodiscard]] inline __device__ constexpr auto operator-(lc_uint3 lhs, lc_uint3 rhs) noexcept { return lc_make_uint3(lhs.x - rhs.x, lhs.y - rhs.y, lhs.z - rhs.z); } +[[nodiscard]] inline __device__ constexpr auto operator-(lc_uint3 lhs, lc_uint rhs) noexcept { return lc_make_uint3(lhs.x - rhs, lhs.y - rhs, lhs.z - rhs); } +[[nodiscard]] inline __device__ constexpr auto operator-(lc_uint lhs, lc_uint3 rhs) noexcept { return lc_make_uint3(lhs - rhs.x, lhs - rhs.y, lhs - rhs.z); } +[[nodiscard]] inline __device__ constexpr auto operator-(lc_uint4 lhs, lc_uint4 rhs) noexcept { return lc_make_uint4(lhs.x - rhs.x, lhs.y - rhs.y, lhs.z - rhs.z, lhs.w - rhs.w); } +[[nodiscard]] inline __device__ constexpr auto operator-(lc_uint4 lhs, lc_uint rhs) noexcept { return lc_make_uint4(lhs.x - rhs, lhs.y - rhs, lhs.z - rhs, lhs.w - rhs); } +[[nodiscard]] inline __device__ constexpr auto operator-(lc_uint lhs, lc_uint4 rhs) noexcept { return lc_make_uint4(lhs - rhs.x, lhs - rhs.y, lhs - rhs.z, lhs - rhs.w); } +[[nodiscard]] inline __device__ constexpr auto operator-(lc_half2 lhs, lc_half2 rhs) noexcept { return lc_make_half2(lhs.x - rhs.x, lhs.y - rhs.y); } +[[nodiscard]] inline __device__ constexpr auto operator-(lc_half2 lhs, lc_half rhs) noexcept { return lc_make_half2(lhs.x - rhs, lhs.y - rhs); } +[[nodiscard]] inline __device__ constexpr auto operator-(lc_half lhs, lc_half2 rhs) noexcept { return lc_make_half2(lhs - rhs.x, lhs - rhs.y); } +[[nodiscard]] inline __device__ constexpr auto operator-(lc_half3 lhs, lc_half3 rhs) noexcept { return lc_make_half3(lhs.x - rhs.x, lhs.y - rhs.y, lhs.z - rhs.z); } +[[nodiscard]] inline __device__ constexpr auto operator-(lc_half3 lhs, lc_half rhs) noexcept { return lc_make_half3(lhs.x - rhs, lhs.y - rhs, lhs.z - rhs); } +[[nodiscard]] inline __device__ constexpr auto operator-(lc_half lhs, lc_half3 rhs) noexcept { return lc_make_half3(lhs - rhs.x, lhs - rhs.y, lhs - rhs.z); } +[[nodiscard]] inline __device__ constexpr auto operator-(lc_half4 lhs, lc_half4 rhs) noexcept { return lc_make_half4(lhs.x - rhs.x, lhs.y - rhs.y, lhs.z - rhs.z, lhs.w - rhs.w); } +[[nodiscard]] inline __device__ constexpr auto operator-(lc_half4 lhs, lc_half rhs) noexcept { return lc_make_half4(lhs.x - rhs, lhs.y - rhs, lhs.z - rhs, lhs.w - rhs); } +[[nodiscard]] inline __device__ constexpr auto operator-(lc_half lhs, lc_half4 rhs) noexcept { return lc_make_half4(lhs - rhs.x, lhs - rhs.y, lhs - rhs.z, lhs - rhs.w); } +[[nodiscard]] inline __device__ constexpr auto operator-(lc_float2 lhs, lc_float2 rhs) noexcept { return lc_make_float2(lhs.x - rhs.x, lhs.y - rhs.y); } +[[nodiscard]] inline __device__ constexpr auto operator-(lc_float2 lhs, lc_float rhs) noexcept { return lc_make_float2(lhs.x - rhs, lhs.y - rhs); } +[[nodiscard]] inline __device__ constexpr auto operator-(lc_float lhs, lc_float2 rhs) noexcept { return lc_make_float2(lhs - rhs.x, lhs - rhs.y); } +[[nodiscard]] inline __device__ constexpr auto operator-(lc_float3 lhs, lc_float3 rhs) noexcept { return lc_make_float3(lhs.x - rhs.x, lhs.y - rhs.y, lhs.z - rhs.z); } +[[nodiscard]] inline __device__ constexpr auto operator-(lc_float3 lhs, lc_float rhs) noexcept { return lc_make_float3(lhs.x - rhs, lhs.y - rhs, lhs.z - rhs); } +[[nodiscard]] inline __device__ constexpr auto operator-(lc_float lhs, lc_float3 rhs) noexcept { return lc_make_float3(lhs - rhs.x, lhs - rhs.y, lhs - rhs.z); } +[[nodiscard]] inline __device__ constexpr auto operator-(lc_float4 lhs, lc_float4 rhs) noexcept { return lc_make_float4(lhs.x - rhs.x, lhs.y - rhs.y, lhs.z - rhs.z, lhs.w - rhs.w); } +[[nodiscard]] inline __device__ constexpr auto operator-(lc_float4 lhs, lc_float rhs) noexcept { return lc_make_float4(lhs.x - rhs, lhs.y - rhs, lhs.z - rhs, lhs.w - rhs); } +[[nodiscard]] inline __device__ constexpr auto operator-(lc_float lhs, lc_float4 rhs) noexcept { return lc_make_float4(lhs - rhs.x, lhs - rhs.y, lhs - rhs.z, lhs - rhs.w); } +[[nodiscard]] inline __device__ constexpr auto operator-(lc_long2 lhs, lc_long2 rhs) noexcept { return lc_make_long2(lhs.x - rhs.x, lhs.y - rhs.y); } +[[nodiscard]] inline __device__ constexpr auto operator-(lc_long2 lhs, lc_long rhs) noexcept { return lc_make_long2(lhs.x - rhs, lhs.y - rhs); } +[[nodiscard]] inline __device__ constexpr auto operator-(lc_long lhs, lc_long2 rhs) noexcept { return lc_make_long2(lhs - rhs.x, lhs - rhs.y); } +[[nodiscard]] inline __device__ constexpr auto operator-(lc_long3 lhs, lc_long3 rhs) noexcept { return lc_make_long3(lhs.x - rhs.x, lhs.y - rhs.y, lhs.z - rhs.z); } +[[nodiscard]] inline __device__ constexpr auto operator-(lc_long3 lhs, lc_long rhs) noexcept { return lc_make_long3(lhs.x - rhs, lhs.y - rhs, lhs.z - rhs); } +[[nodiscard]] inline __device__ constexpr auto operator-(lc_long lhs, lc_long3 rhs) noexcept { return lc_make_long3(lhs - rhs.x, lhs - rhs.y, lhs - rhs.z); } +[[nodiscard]] inline __device__ constexpr auto operator-(lc_long4 lhs, lc_long4 rhs) noexcept { return lc_make_long4(lhs.x - rhs.x, lhs.y - rhs.y, lhs.z - rhs.z, lhs.w - rhs.w); } +[[nodiscard]] inline __device__ constexpr auto operator-(lc_long4 lhs, lc_long rhs) noexcept { return lc_make_long4(lhs.x - rhs, lhs.y - rhs, lhs.z - rhs, lhs.w - rhs); } +[[nodiscard]] inline __device__ constexpr auto operator-(lc_long lhs, lc_long4 rhs) noexcept { return lc_make_long4(lhs - rhs.x, lhs - rhs.y, lhs - rhs.z, lhs - rhs.w); } +[[nodiscard]] inline __device__ constexpr auto operator-(lc_ulong2 lhs, lc_ulong2 rhs) noexcept { return lc_make_ulong2(lhs.x - rhs.x, lhs.y - rhs.y); } +[[nodiscard]] inline __device__ constexpr auto operator-(lc_ulong2 lhs, lc_ulong rhs) noexcept { return lc_make_ulong2(lhs.x - rhs, lhs.y - rhs); } +[[nodiscard]] inline __device__ constexpr auto operator-(lc_ulong lhs, lc_ulong2 rhs) noexcept { return lc_make_ulong2(lhs - rhs.x, lhs - rhs.y); } +[[nodiscard]] inline __device__ constexpr auto operator-(lc_ulong3 lhs, lc_ulong3 rhs) noexcept { return lc_make_ulong3(lhs.x - rhs.x, lhs.y - rhs.y, lhs.z - rhs.z); } +[[nodiscard]] inline __device__ constexpr auto operator-(lc_ulong3 lhs, lc_ulong rhs) noexcept { return lc_make_ulong3(lhs.x - rhs, lhs.y - rhs, lhs.z - rhs); } +[[nodiscard]] inline __device__ constexpr auto operator-(lc_ulong lhs, lc_ulong3 rhs) noexcept { return lc_make_ulong3(lhs - rhs.x, lhs - rhs.y, lhs - rhs.z); } +[[nodiscard]] inline __device__ constexpr auto operator-(lc_ulong4 lhs, lc_ulong4 rhs) noexcept { return lc_make_ulong4(lhs.x - rhs.x, lhs.y - rhs.y, lhs.z - rhs.z, lhs.w - rhs.w); } +[[nodiscard]] inline __device__ constexpr auto operator-(lc_ulong4 lhs, lc_ulong rhs) noexcept { return lc_make_ulong4(lhs.x - rhs, lhs.y - rhs, lhs.z - rhs, lhs.w - rhs); } +[[nodiscard]] inline __device__ constexpr auto operator-(lc_ulong lhs, lc_ulong4 rhs) noexcept { return lc_make_ulong4(lhs - rhs.x, lhs - rhs.y, lhs - rhs.z, lhs - rhs.w); } + +[[nodiscard]] inline __device__ constexpr auto operator*(lc_short2 lhs, lc_short2 rhs) noexcept { return lc_make_short2(lhs.x * rhs.x, lhs.y * rhs.y); } +[[nodiscard]] inline __device__ constexpr auto operator*(lc_short2 lhs, lc_short rhs) noexcept { return lc_make_short2(lhs.x * rhs, lhs.y * rhs); } +[[nodiscard]] inline __device__ constexpr auto operator*(lc_short lhs, lc_short2 rhs) noexcept { return lc_make_short2(lhs * rhs.x, lhs * rhs.y); } +[[nodiscard]] inline __device__ constexpr auto operator*(lc_short3 lhs, lc_short3 rhs) noexcept { return lc_make_short3(lhs.x * rhs.x, lhs.y * rhs.y, lhs.z * rhs.z); } +[[nodiscard]] inline __device__ constexpr auto operator*(lc_short3 lhs, lc_short rhs) noexcept { return lc_make_short3(lhs.x * rhs, lhs.y * rhs, lhs.z * rhs); } +[[nodiscard]] inline __device__ constexpr auto operator*(lc_short lhs, lc_short3 rhs) noexcept { return lc_make_short3(lhs * rhs.x, lhs * rhs.y, lhs * rhs.z); } +[[nodiscard]] inline __device__ constexpr auto operator*(lc_short4 lhs, lc_short4 rhs) noexcept { return lc_make_short4(lhs.x * rhs.x, lhs.y * rhs.y, lhs.z * rhs.z, lhs.w * rhs.w); } +[[nodiscard]] inline __device__ constexpr auto operator*(lc_short4 lhs, lc_short rhs) noexcept { return lc_make_short4(lhs.x * rhs, lhs.y * rhs, lhs.z * rhs, lhs.w * rhs); } +[[nodiscard]] inline __device__ constexpr auto operator*(lc_short lhs, lc_short4 rhs) noexcept { return lc_make_short4(lhs * rhs.x, lhs * rhs.y, lhs * rhs.z, lhs * rhs.w); } +[[nodiscard]] inline __device__ constexpr auto operator*(lc_ushort2 lhs, lc_ushort2 rhs) noexcept { return lc_make_ushort2(lhs.x * rhs.x, lhs.y * rhs.y); } +[[nodiscard]] inline __device__ constexpr auto operator*(lc_ushort2 lhs, lc_ushort rhs) noexcept { return lc_make_ushort2(lhs.x * rhs, lhs.y * rhs); } +[[nodiscard]] inline __device__ constexpr auto operator*(lc_ushort lhs, lc_ushort2 rhs) noexcept { return lc_make_ushort2(lhs * rhs.x, lhs * rhs.y); } +[[nodiscard]] inline __device__ constexpr auto operator*(lc_ushort3 lhs, lc_ushort3 rhs) noexcept { return lc_make_ushort3(lhs.x * rhs.x, lhs.y * rhs.y, lhs.z * rhs.z); } +[[nodiscard]] inline __device__ constexpr auto operator*(lc_ushort3 lhs, lc_ushort rhs) noexcept { return lc_make_ushort3(lhs.x * rhs, lhs.y * rhs, lhs.z * rhs); } +[[nodiscard]] inline __device__ constexpr auto operator*(lc_ushort lhs, lc_ushort3 rhs) noexcept { return lc_make_ushort3(lhs * rhs.x, lhs * rhs.y, lhs * rhs.z); } +[[nodiscard]] inline __device__ constexpr auto operator*(lc_ushort4 lhs, lc_ushort4 rhs) noexcept { return lc_make_ushort4(lhs.x * rhs.x, lhs.y * rhs.y, lhs.z * rhs.z, lhs.w * rhs.w); } +[[nodiscard]] inline __device__ constexpr auto operator*(lc_ushort4 lhs, lc_ushort rhs) noexcept { return lc_make_ushort4(lhs.x * rhs, lhs.y * rhs, lhs.z * rhs, lhs.w * rhs); } +[[nodiscard]] inline __device__ constexpr auto operator*(lc_ushort lhs, lc_ushort4 rhs) noexcept { return lc_make_ushort4(lhs * rhs.x, lhs * rhs.y, lhs * rhs.z, lhs * rhs.w); } +[[nodiscard]] inline __device__ constexpr auto operator*(lc_int2 lhs, lc_int2 rhs) noexcept { return lc_make_int2(lhs.x * rhs.x, lhs.y * rhs.y); } +[[nodiscard]] inline __device__ constexpr auto operator*(lc_int2 lhs, lc_int rhs) noexcept { return lc_make_int2(lhs.x * rhs, lhs.y * rhs); } +[[nodiscard]] inline __device__ constexpr auto operator*(lc_int lhs, lc_int2 rhs) noexcept { return lc_make_int2(lhs * rhs.x, lhs * rhs.y); } +[[nodiscard]] inline __device__ constexpr auto operator*(lc_int3 lhs, lc_int3 rhs) noexcept { return lc_make_int3(lhs.x * rhs.x, lhs.y * rhs.y, lhs.z * rhs.z); } +[[nodiscard]] inline __device__ constexpr auto operator*(lc_int3 lhs, lc_int rhs) noexcept { return lc_make_int3(lhs.x * rhs, lhs.y * rhs, lhs.z * rhs); } +[[nodiscard]] inline __device__ constexpr auto operator*(lc_int lhs, lc_int3 rhs) noexcept { return lc_make_int3(lhs * rhs.x, lhs * rhs.y, lhs * rhs.z); } +[[nodiscard]] inline __device__ constexpr auto operator*(lc_int4 lhs, lc_int4 rhs) noexcept { return lc_make_int4(lhs.x * rhs.x, lhs.y * rhs.y, lhs.z * rhs.z, lhs.w * rhs.w); } +[[nodiscard]] inline __device__ constexpr auto operator*(lc_int4 lhs, lc_int rhs) noexcept { return lc_make_int4(lhs.x * rhs, lhs.y * rhs, lhs.z * rhs, lhs.w * rhs); } +[[nodiscard]] inline __device__ constexpr auto operator*(lc_int lhs, lc_int4 rhs) noexcept { return lc_make_int4(lhs * rhs.x, lhs * rhs.y, lhs * rhs.z, lhs * rhs.w); } +[[nodiscard]] inline __device__ constexpr auto operator*(lc_uint2 lhs, lc_uint2 rhs) noexcept { return lc_make_uint2(lhs.x * rhs.x, lhs.y * rhs.y); } +[[nodiscard]] inline __device__ constexpr auto operator*(lc_uint2 lhs, lc_uint rhs) noexcept { return lc_make_uint2(lhs.x * rhs, lhs.y * rhs); } +[[nodiscard]] inline __device__ constexpr auto operator*(lc_uint lhs, lc_uint2 rhs) noexcept { return lc_make_uint2(lhs * rhs.x, lhs * rhs.y); } +[[nodiscard]] inline __device__ constexpr auto operator*(lc_uint3 lhs, lc_uint3 rhs) noexcept { return lc_make_uint3(lhs.x * rhs.x, lhs.y * rhs.y, lhs.z * rhs.z); } +[[nodiscard]] inline __device__ constexpr auto operator*(lc_uint3 lhs, lc_uint rhs) noexcept { return lc_make_uint3(lhs.x * rhs, lhs.y * rhs, lhs.z * rhs); } +[[nodiscard]] inline __device__ constexpr auto operator*(lc_uint lhs, lc_uint3 rhs) noexcept { return lc_make_uint3(lhs * rhs.x, lhs * rhs.y, lhs * rhs.z); } +[[nodiscard]] inline __device__ constexpr auto operator*(lc_uint4 lhs, lc_uint4 rhs) noexcept { return lc_make_uint4(lhs.x * rhs.x, lhs.y * rhs.y, lhs.z * rhs.z, lhs.w * rhs.w); } +[[nodiscard]] inline __device__ constexpr auto operator*(lc_uint4 lhs, lc_uint rhs) noexcept { return lc_make_uint4(lhs.x * rhs, lhs.y * rhs, lhs.z * rhs, lhs.w * rhs); } +[[nodiscard]] inline __device__ constexpr auto operator*(lc_uint lhs, lc_uint4 rhs) noexcept { return lc_make_uint4(lhs * rhs.x, lhs * rhs.y, lhs * rhs.z, lhs * rhs.w); } +[[nodiscard]] inline __device__ constexpr auto operator*(lc_half2 lhs, lc_half2 rhs) noexcept { return lc_make_half2(lhs.x * rhs.x, lhs.y * rhs.y); } +[[nodiscard]] inline __device__ constexpr auto operator*(lc_half2 lhs, lc_half rhs) noexcept { return lc_make_half2(lhs.x * rhs, lhs.y * rhs); } +[[nodiscard]] inline __device__ constexpr auto operator*(lc_half lhs, lc_half2 rhs) noexcept { return lc_make_half2(lhs * rhs.x, lhs * rhs.y); } +[[nodiscard]] inline __device__ constexpr auto operator*(lc_half3 lhs, lc_half3 rhs) noexcept { return lc_make_half3(lhs.x * rhs.x, lhs.y * rhs.y, lhs.z * rhs.z); } +[[nodiscard]] inline __device__ constexpr auto operator*(lc_half3 lhs, lc_half rhs) noexcept { return lc_make_half3(lhs.x * rhs, lhs.y * rhs, lhs.z * rhs); } +[[nodiscard]] inline __device__ constexpr auto operator*(lc_half lhs, lc_half3 rhs) noexcept { return lc_make_half3(lhs * rhs.x, lhs * rhs.y, lhs * rhs.z); } +[[nodiscard]] inline __device__ constexpr auto operator*(lc_half4 lhs, lc_half4 rhs) noexcept { return lc_make_half4(lhs.x * rhs.x, lhs.y * rhs.y, lhs.z * rhs.z, lhs.w * rhs.w); } +[[nodiscard]] inline __device__ constexpr auto operator*(lc_half4 lhs, lc_half rhs) noexcept { return lc_make_half4(lhs.x * rhs, lhs.y * rhs, lhs.z * rhs, lhs.w * rhs); } +[[nodiscard]] inline __device__ constexpr auto operator*(lc_half lhs, lc_half4 rhs) noexcept { return lc_make_half4(lhs * rhs.x, lhs * rhs.y, lhs * rhs.z, lhs * rhs.w); } +[[nodiscard]] inline __device__ constexpr auto operator*(lc_float2 lhs, lc_float2 rhs) noexcept { return lc_make_float2(lhs.x * rhs.x, lhs.y * rhs.y); } +[[nodiscard]] inline __device__ constexpr auto operator*(lc_float2 lhs, lc_float rhs) noexcept { return lc_make_float2(lhs.x * rhs, lhs.y * rhs); } +[[nodiscard]] inline __device__ constexpr auto operator*(lc_float lhs, lc_float2 rhs) noexcept { return lc_make_float2(lhs * rhs.x, lhs * rhs.y); } +[[nodiscard]] inline __device__ constexpr auto operator*(lc_float3 lhs, lc_float3 rhs) noexcept { return lc_make_float3(lhs.x * rhs.x, lhs.y * rhs.y, lhs.z * rhs.z); } +[[nodiscard]] inline __device__ constexpr auto operator*(lc_float3 lhs, lc_float rhs) noexcept { return lc_make_float3(lhs.x * rhs, lhs.y * rhs, lhs.z * rhs); } +[[nodiscard]] inline __device__ constexpr auto operator*(lc_float lhs, lc_float3 rhs) noexcept { return lc_make_float3(lhs * rhs.x, lhs * rhs.y, lhs * rhs.z); } +[[nodiscard]] inline __device__ constexpr auto operator*(lc_float4 lhs, lc_float4 rhs) noexcept { return lc_make_float4(lhs.x * rhs.x, lhs.y * rhs.y, lhs.z * rhs.z, lhs.w * rhs.w); } +[[nodiscard]] inline __device__ constexpr auto operator*(lc_float4 lhs, lc_float rhs) noexcept { return lc_make_float4(lhs.x * rhs, lhs.y * rhs, lhs.z * rhs, lhs.w * rhs); } +[[nodiscard]] inline __device__ constexpr auto operator*(lc_float lhs, lc_float4 rhs) noexcept { return lc_make_float4(lhs * rhs.x, lhs * rhs.y, lhs * rhs.z, lhs * rhs.w); } +[[nodiscard]] inline __device__ constexpr auto operator*(lc_long2 lhs, lc_long2 rhs) noexcept { return lc_make_long2(lhs.x * rhs.x, lhs.y * rhs.y); } +[[nodiscard]] inline __device__ constexpr auto operator*(lc_long2 lhs, lc_long rhs) noexcept { return lc_make_long2(lhs.x * rhs, lhs.y * rhs); } +[[nodiscard]] inline __device__ constexpr auto operator*(lc_long lhs, lc_long2 rhs) noexcept { return lc_make_long2(lhs * rhs.x, lhs * rhs.y); } +[[nodiscard]] inline __device__ constexpr auto operator*(lc_long3 lhs, lc_long3 rhs) noexcept { return lc_make_long3(lhs.x * rhs.x, lhs.y * rhs.y, lhs.z * rhs.z); } +[[nodiscard]] inline __device__ constexpr auto operator*(lc_long3 lhs, lc_long rhs) noexcept { return lc_make_long3(lhs.x * rhs, lhs.y * rhs, lhs.z * rhs); } +[[nodiscard]] inline __device__ constexpr auto operator*(lc_long lhs, lc_long3 rhs) noexcept { return lc_make_long3(lhs * rhs.x, lhs * rhs.y, lhs * rhs.z); } +[[nodiscard]] inline __device__ constexpr auto operator*(lc_long4 lhs, lc_long4 rhs) noexcept { return lc_make_long4(lhs.x * rhs.x, lhs.y * rhs.y, lhs.z * rhs.z, lhs.w * rhs.w); } +[[nodiscard]] inline __device__ constexpr auto operator*(lc_long4 lhs, lc_long rhs) noexcept { return lc_make_long4(lhs.x * rhs, lhs.y * rhs, lhs.z * rhs, lhs.w * rhs); } +[[nodiscard]] inline __device__ constexpr auto operator*(lc_long lhs, lc_long4 rhs) noexcept { return lc_make_long4(lhs * rhs.x, lhs * rhs.y, lhs * rhs.z, lhs * rhs.w); } +[[nodiscard]] inline __device__ constexpr auto operator*(lc_ulong2 lhs, lc_ulong2 rhs) noexcept { return lc_make_ulong2(lhs.x * rhs.x, lhs.y * rhs.y); } +[[nodiscard]] inline __device__ constexpr auto operator*(lc_ulong2 lhs, lc_ulong rhs) noexcept { return lc_make_ulong2(lhs.x * rhs, lhs.y * rhs); } +[[nodiscard]] inline __device__ constexpr auto operator*(lc_ulong lhs, lc_ulong2 rhs) noexcept { return lc_make_ulong2(lhs * rhs.x, lhs * rhs.y); } +[[nodiscard]] inline __device__ constexpr auto operator*(lc_ulong3 lhs, lc_ulong3 rhs) noexcept { return lc_make_ulong3(lhs.x * rhs.x, lhs.y * rhs.y, lhs.z * rhs.z); } +[[nodiscard]] inline __device__ constexpr auto operator*(lc_ulong3 lhs, lc_ulong rhs) noexcept { return lc_make_ulong3(lhs.x * rhs, lhs.y * rhs, lhs.z * rhs); } +[[nodiscard]] inline __device__ constexpr auto operator*(lc_ulong lhs, lc_ulong3 rhs) noexcept { return lc_make_ulong3(lhs * rhs.x, lhs * rhs.y, lhs * rhs.z); } +[[nodiscard]] inline __device__ constexpr auto operator*(lc_ulong4 lhs, lc_ulong4 rhs) noexcept { return lc_make_ulong4(lhs.x * rhs.x, lhs.y * rhs.y, lhs.z * rhs.z, lhs.w * rhs.w); } +[[nodiscard]] inline __device__ constexpr auto operator*(lc_ulong4 lhs, lc_ulong rhs) noexcept { return lc_make_ulong4(lhs.x * rhs, lhs.y * rhs, lhs.z * rhs, lhs.w * rhs); } +[[nodiscard]] inline __device__ constexpr auto operator*(lc_ulong lhs, lc_ulong4 rhs) noexcept { return lc_make_ulong4(lhs * rhs.x, lhs * rhs.y, lhs * rhs.z, lhs * rhs.w); } + +[[nodiscard]] inline __device__ constexpr auto operator/(lc_short2 lhs, lc_short2 rhs) noexcept { return lc_make_short2(lhs.x / rhs.x, lhs.y / rhs.y); } +[[nodiscard]] inline __device__ constexpr auto operator/(lc_short2 lhs, lc_short rhs) noexcept { return lc_make_short2(lhs.x / rhs, lhs.y / rhs); } +[[nodiscard]] inline __device__ constexpr auto operator/(lc_short lhs, lc_short2 rhs) noexcept { return lc_make_short2(lhs / rhs.x, lhs / rhs.y); } +[[nodiscard]] inline __device__ constexpr auto operator/(lc_short3 lhs, lc_short3 rhs) noexcept { return lc_make_short3(lhs.x / rhs.x, lhs.y / rhs.y, lhs.z / rhs.z); } +[[nodiscard]] inline __device__ constexpr auto operator/(lc_short3 lhs, lc_short rhs) noexcept { return lc_make_short3(lhs.x / rhs, lhs.y / rhs, lhs.z / rhs); } +[[nodiscard]] inline __device__ constexpr auto operator/(lc_short lhs, lc_short3 rhs) noexcept { return lc_make_short3(lhs / rhs.x, lhs / rhs.y, lhs / rhs.z); } +[[nodiscard]] inline __device__ constexpr auto operator/(lc_short4 lhs, lc_short4 rhs) noexcept { return lc_make_short4(lhs.x / rhs.x, lhs.y / rhs.y, lhs.z / rhs.z, lhs.w / rhs.w); } +[[nodiscard]] inline __device__ constexpr auto operator/(lc_short4 lhs, lc_short rhs) noexcept { return lc_make_short4(lhs.x / rhs, lhs.y / rhs, lhs.z / rhs, lhs.w / rhs); } +[[nodiscard]] inline __device__ constexpr auto operator/(lc_short lhs, lc_short4 rhs) noexcept { return lc_make_short4(lhs / rhs.x, lhs / rhs.y, lhs / rhs.z, lhs / rhs.w); } +[[nodiscard]] inline __device__ constexpr auto operator/(lc_ushort2 lhs, lc_ushort2 rhs) noexcept { return lc_make_ushort2(lhs.x / rhs.x, lhs.y / rhs.y); } +[[nodiscard]] inline __device__ constexpr auto operator/(lc_ushort2 lhs, lc_ushort rhs) noexcept { return lc_make_ushort2(lhs.x / rhs, lhs.y / rhs); } +[[nodiscard]] inline __device__ constexpr auto operator/(lc_ushort lhs, lc_ushort2 rhs) noexcept { return lc_make_ushort2(lhs / rhs.x, lhs / rhs.y); } +[[nodiscard]] inline __device__ constexpr auto operator/(lc_ushort3 lhs, lc_ushort3 rhs) noexcept { return lc_make_ushort3(lhs.x / rhs.x, lhs.y / rhs.y, lhs.z / rhs.z); } +[[nodiscard]] inline __device__ constexpr auto operator/(lc_ushort3 lhs, lc_ushort rhs) noexcept { return lc_make_ushort3(lhs.x / rhs, lhs.y / rhs, lhs.z / rhs); } +[[nodiscard]] inline __device__ constexpr auto operator/(lc_ushort lhs, lc_ushort3 rhs) noexcept { return lc_make_ushort3(lhs / rhs.x, lhs / rhs.y, lhs / rhs.z); } +[[nodiscard]] inline __device__ constexpr auto operator/(lc_ushort4 lhs, lc_ushort4 rhs) noexcept { return lc_make_ushort4(lhs.x / rhs.x, lhs.y / rhs.y, lhs.z / rhs.z, lhs.w / rhs.w); } +[[nodiscard]] inline __device__ constexpr auto operator/(lc_ushort4 lhs, lc_ushort rhs) noexcept { return lc_make_ushort4(lhs.x / rhs, lhs.y / rhs, lhs.z / rhs, lhs.w / rhs); } +[[nodiscard]] inline __device__ constexpr auto operator/(lc_ushort lhs, lc_ushort4 rhs) noexcept { return lc_make_ushort4(lhs / rhs.x, lhs / rhs.y, lhs / rhs.z, lhs / rhs.w); } +[[nodiscard]] inline __device__ constexpr auto operator/(lc_int2 lhs, lc_int2 rhs) noexcept { return lc_make_int2(lhs.x / rhs.x, lhs.y / rhs.y); } +[[nodiscard]] inline __device__ constexpr auto operator/(lc_int2 lhs, lc_int rhs) noexcept { return lc_make_int2(lhs.x / rhs, lhs.y / rhs); } +[[nodiscard]] inline __device__ constexpr auto operator/(lc_int lhs, lc_int2 rhs) noexcept { return lc_make_int2(lhs / rhs.x, lhs / rhs.y); } +[[nodiscard]] inline __device__ constexpr auto operator/(lc_int3 lhs, lc_int3 rhs) noexcept { return lc_make_int3(lhs.x / rhs.x, lhs.y / rhs.y, lhs.z / rhs.z); } +[[nodiscard]] inline __device__ constexpr auto operator/(lc_int3 lhs, lc_int rhs) noexcept { return lc_make_int3(lhs.x / rhs, lhs.y / rhs, lhs.z / rhs); } +[[nodiscard]] inline __device__ constexpr auto operator/(lc_int lhs, lc_int3 rhs) noexcept { return lc_make_int3(lhs / rhs.x, lhs / rhs.y, lhs / rhs.z); } +[[nodiscard]] inline __device__ constexpr auto operator/(lc_int4 lhs, lc_int4 rhs) noexcept { return lc_make_int4(lhs.x / rhs.x, lhs.y / rhs.y, lhs.z / rhs.z, lhs.w / rhs.w); } +[[nodiscard]] inline __device__ constexpr auto operator/(lc_int4 lhs, lc_int rhs) noexcept { return lc_make_int4(lhs.x / rhs, lhs.y / rhs, lhs.z / rhs, lhs.w / rhs); } +[[nodiscard]] inline __device__ constexpr auto operator/(lc_int lhs, lc_int4 rhs) noexcept { return lc_make_int4(lhs / rhs.x, lhs / rhs.y, lhs / rhs.z, lhs / rhs.w); } +[[nodiscard]] inline __device__ constexpr auto operator/(lc_uint2 lhs, lc_uint2 rhs) noexcept { return lc_make_uint2(lhs.x / rhs.x, lhs.y / rhs.y); } +[[nodiscard]] inline __device__ constexpr auto operator/(lc_uint2 lhs, lc_uint rhs) noexcept { return lc_make_uint2(lhs.x / rhs, lhs.y / rhs); } +[[nodiscard]] inline __device__ constexpr auto operator/(lc_uint lhs, lc_uint2 rhs) noexcept { return lc_make_uint2(lhs / rhs.x, lhs / rhs.y); } +[[nodiscard]] inline __device__ constexpr auto operator/(lc_uint3 lhs, lc_uint3 rhs) noexcept { return lc_make_uint3(lhs.x / rhs.x, lhs.y / rhs.y, lhs.z / rhs.z); } +[[nodiscard]] inline __device__ constexpr auto operator/(lc_uint3 lhs, lc_uint rhs) noexcept { return lc_make_uint3(lhs.x / rhs, lhs.y / rhs, lhs.z / rhs); } +[[nodiscard]] inline __device__ constexpr auto operator/(lc_uint lhs, lc_uint3 rhs) noexcept { return lc_make_uint3(lhs / rhs.x, lhs / rhs.y, lhs / rhs.z); } +[[nodiscard]] inline __device__ constexpr auto operator/(lc_uint4 lhs, lc_uint4 rhs) noexcept { return lc_make_uint4(lhs.x / rhs.x, lhs.y / rhs.y, lhs.z / rhs.z, lhs.w / rhs.w); } +[[nodiscard]] inline __device__ constexpr auto operator/(lc_uint4 lhs, lc_uint rhs) noexcept { return lc_make_uint4(lhs.x / rhs, lhs.y / rhs, lhs.z / rhs, lhs.w / rhs); } +[[nodiscard]] inline __device__ constexpr auto operator/(lc_uint lhs, lc_uint4 rhs) noexcept { return lc_make_uint4(lhs / rhs.x, lhs / rhs.y, lhs / rhs.z, lhs / rhs.w); } +[[nodiscard]] inline __device__ constexpr auto operator/(lc_half2 lhs, lc_half2 rhs) noexcept { return lc_make_half2(lhs.x / rhs.x, lhs.y / rhs.y); } +[[nodiscard]] inline __device__ constexpr auto operator/(lc_half2 lhs, lc_half rhs) noexcept { return lc_make_half2(lhs.x / rhs, lhs.y / rhs); } +[[nodiscard]] inline __device__ constexpr auto operator/(lc_half lhs, lc_half2 rhs) noexcept { return lc_make_half2(lhs / rhs.x, lhs / rhs.y); } +[[nodiscard]] inline __device__ constexpr auto operator/(lc_half3 lhs, lc_half3 rhs) noexcept { return lc_make_half3(lhs.x / rhs.x, lhs.y / rhs.y, lhs.z / rhs.z); } +[[nodiscard]] inline __device__ constexpr auto operator/(lc_half3 lhs, lc_half rhs) noexcept { return lc_make_half3(lhs.x / rhs, lhs.y / rhs, lhs.z / rhs); } +[[nodiscard]] inline __device__ constexpr auto operator/(lc_half lhs, lc_half3 rhs) noexcept { return lc_make_half3(lhs / rhs.x, lhs / rhs.y, lhs / rhs.z); } +[[nodiscard]] inline __device__ constexpr auto operator/(lc_half4 lhs, lc_half4 rhs) noexcept { return lc_make_half4(lhs.x / rhs.x, lhs.y / rhs.y, lhs.z / rhs.z, lhs.w / rhs.w); } +[[nodiscard]] inline __device__ constexpr auto operator/(lc_half4 lhs, lc_half rhs) noexcept { return lc_make_half4(lhs.x / rhs, lhs.y / rhs, lhs.z / rhs, lhs.w / rhs); } +[[nodiscard]] inline __device__ constexpr auto operator/(lc_half lhs, lc_half4 rhs) noexcept { return lc_make_half4(lhs / rhs.x, lhs / rhs.y, lhs / rhs.z, lhs / rhs.w); } +[[nodiscard]] inline __device__ constexpr auto operator/(lc_float2 lhs, lc_float2 rhs) noexcept { return lc_make_float2(lhs.x / rhs.x, lhs.y / rhs.y); } +[[nodiscard]] inline __device__ constexpr auto operator/(lc_float2 lhs, lc_float rhs) noexcept { return lc_make_float2(lhs.x / rhs, lhs.y / rhs); } +[[nodiscard]] inline __device__ constexpr auto operator/(lc_float lhs, lc_float2 rhs) noexcept { return lc_make_float2(lhs / rhs.x, lhs / rhs.y); } +[[nodiscard]] inline __device__ constexpr auto operator/(lc_float3 lhs, lc_float3 rhs) noexcept { return lc_make_float3(lhs.x / rhs.x, lhs.y / rhs.y, lhs.z / rhs.z); } +[[nodiscard]] inline __device__ constexpr auto operator/(lc_float3 lhs, lc_float rhs) noexcept { return lc_make_float3(lhs.x / rhs, lhs.y / rhs, lhs.z / rhs); } +[[nodiscard]] inline __device__ constexpr auto operator/(lc_float lhs, lc_float3 rhs) noexcept { return lc_make_float3(lhs / rhs.x, lhs / rhs.y, lhs / rhs.z); } +[[nodiscard]] inline __device__ constexpr auto operator/(lc_float4 lhs, lc_float4 rhs) noexcept { return lc_make_float4(lhs.x / rhs.x, lhs.y / rhs.y, lhs.z / rhs.z, lhs.w / rhs.w); } +[[nodiscard]] inline __device__ constexpr auto operator/(lc_float4 lhs, lc_float rhs) noexcept { return lc_make_float4(lhs.x / rhs, lhs.y / rhs, lhs.z / rhs, lhs.w / rhs); } +[[nodiscard]] inline __device__ constexpr auto operator/(lc_float lhs, lc_float4 rhs) noexcept { return lc_make_float4(lhs / rhs.x, lhs / rhs.y, lhs / rhs.z, lhs / rhs.w); } +[[nodiscard]] inline __device__ constexpr auto operator/(lc_long2 lhs, lc_long2 rhs) noexcept { return lc_make_long2(lhs.x / rhs.x, lhs.y / rhs.y); } +[[nodiscard]] inline __device__ constexpr auto operator/(lc_long2 lhs, lc_long rhs) noexcept { return lc_make_long2(lhs.x / rhs, lhs.y / rhs); } +[[nodiscard]] inline __device__ constexpr auto operator/(lc_long lhs, lc_long2 rhs) noexcept { return lc_make_long2(lhs / rhs.x, lhs / rhs.y); } +[[nodiscard]] inline __device__ constexpr auto operator/(lc_long3 lhs, lc_long3 rhs) noexcept { return lc_make_long3(lhs.x / rhs.x, lhs.y / rhs.y, lhs.z / rhs.z); } +[[nodiscard]] inline __device__ constexpr auto operator/(lc_long3 lhs, lc_long rhs) noexcept { return lc_make_long3(lhs.x / rhs, lhs.y / rhs, lhs.z / rhs); } +[[nodiscard]] inline __device__ constexpr auto operator/(lc_long lhs, lc_long3 rhs) noexcept { return lc_make_long3(lhs / rhs.x, lhs / rhs.y, lhs / rhs.z); } +[[nodiscard]] inline __device__ constexpr auto operator/(lc_long4 lhs, lc_long4 rhs) noexcept { return lc_make_long4(lhs.x / rhs.x, lhs.y / rhs.y, lhs.z / rhs.z, lhs.w / rhs.w); } +[[nodiscard]] inline __device__ constexpr auto operator/(lc_long4 lhs, lc_long rhs) noexcept { return lc_make_long4(lhs.x / rhs, lhs.y / rhs, lhs.z / rhs, lhs.w / rhs); } +[[nodiscard]] inline __device__ constexpr auto operator/(lc_long lhs, lc_long4 rhs) noexcept { return lc_make_long4(lhs / rhs.x, lhs / rhs.y, lhs / rhs.z, lhs / rhs.w); } +[[nodiscard]] inline __device__ constexpr auto operator/(lc_ulong2 lhs, lc_ulong2 rhs) noexcept { return lc_make_ulong2(lhs.x / rhs.x, lhs.y / rhs.y); } +[[nodiscard]] inline __device__ constexpr auto operator/(lc_ulong2 lhs, lc_ulong rhs) noexcept { return lc_make_ulong2(lhs.x / rhs, lhs.y / rhs); } +[[nodiscard]] inline __device__ constexpr auto operator/(lc_ulong lhs, lc_ulong2 rhs) noexcept { return lc_make_ulong2(lhs / rhs.x, lhs / rhs.y); } +[[nodiscard]] inline __device__ constexpr auto operator/(lc_ulong3 lhs, lc_ulong3 rhs) noexcept { return lc_make_ulong3(lhs.x / rhs.x, lhs.y / rhs.y, lhs.z / rhs.z); } +[[nodiscard]] inline __device__ constexpr auto operator/(lc_ulong3 lhs, lc_ulong rhs) noexcept { return lc_make_ulong3(lhs.x / rhs, lhs.y / rhs, lhs.z / rhs); } +[[nodiscard]] inline __device__ constexpr auto operator/(lc_ulong lhs, lc_ulong3 rhs) noexcept { return lc_make_ulong3(lhs / rhs.x, lhs / rhs.y, lhs / rhs.z); } +[[nodiscard]] inline __device__ constexpr auto operator/(lc_ulong4 lhs, lc_ulong4 rhs) noexcept { return lc_make_ulong4(lhs.x / rhs.x, lhs.y / rhs.y, lhs.z / rhs.z, lhs.w / rhs.w); } +[[nodiscard]] inline __device__ constexpr auto operator/(lc_ulong4 lhs, lc_ulong rhs) noexcept { return lc_make_ulong4(lhs.x / rhs, lhs.y / rhs, lhs.z / rhs, lhs.w / rhs); } +[[nodiscard]] inline __device__ constexpr auto operator/(lc_ulong lhs, lc_ulong4 rhs) noexcept { return lc_make_ulong4(lhs / rhs.x, lhs / rhs.y, lhs / rhs.z, lhs / rhs.w); } + +[[nodiscard]] inline __device__ constexpr auto operator%(lc_short2 lhs, lc_short2 rhs) noexcept { return lc_make_short2(lhs.x % rhs.x, lhs.y % rhs.y); } +[[nodiscard]] inline __device__ constexpr auto operator%(lc_short2 lhs, lc_short rhs) noexcept { return lc_make_short2(lhs.x % rhs, lhs.y % rhs); } +[[nodiscard]] inline __device__ constexpr auto operator%(lc_short lhs, lc_short2 rhs) noexcept { return lc_make_short2(lhs % rhs.x, lhs % rhs.y); } +[[nodiscard]] inline __device__ constexpr auto operator%(lc_short3 lhs, lc_short3 rhs) noexcept { return lc_make_short3(lhs.x % rhs.x, lhs.y % rhs.y, lhs.z % rhs.z); } +[[nodiscard]] inline __device__ constexpr auto operator%(lc_short3 lhs, lc_short rhs) noexcept { return lc_make_short3(lhs.x % rhs, lhs.y % rhs, lhs.z % rhs); } +[[nodiscard]] inline __device__ constexpr auto operator%(lc_short lhs, lc_short3 rhs) noexcept { return lc_make_short3(lhs % rhs.x, lhs % rhs.y, lhs % rhs.z); } +[[nodiscard]] inline __device__ constexpr auto operator%(lc_short4 lhs, lc_short4 rhs) noexcept { return lc_make_short4(lhs.x % rhs.x, lhs.y % rhs.y, lhs.z % rhs.z, lhs.w % rhs.w); } +[[nodiscard]] inline __device__ constexpr auto operator%(lc_short4 lhs, lc_short rhs) noexcept { return lc_make_short4(lhs.x % rhs, lhs.y % rhs, lhs.z % rhs, lhs.w % rhs); } +[[nodiscard]] inline __device__ constexpr auto operator%(lc_short lhs, lc_short4 rhs) noexcept { return lc_make_short4(lhs % rhs.x, lhs % rhs.y, lhs % rhs.z, lhs % rhs.w); } +[[nodiscard]] inline __device__ constexpr auto operator%(lc_ushort2 lhs, lc_ushort2 rhs) noexcept { return lc_make_ushort2(lhs.x % rhs.x, lhs.y % rhs.y); } +[[nodiscard]] inline __device__ constexpr auto operator%(lc_ushort2 lhs, lc_ushort rhs) noexcept { return lc_make_ushort2(lhs.x % rhs, lhs.y % rhs); } +[[nodiscard]] inline __device__ constexpr auto operator%(lc_ushort lhs, lc_ushort2 rhs) noexcept { return lc_make_ushort2(lhs % rhs.x, lhs % rhs.y); } +[[nodiscard]] inline __device__ constexpr auto operator%(lc_ushort3 lhs, lc_ushort3 rhs) noexcept { return lc_make_ushort3(lhs.x % rhs.x, lhs.y % rhs.y, lhs.z % rhs.z); } +[[nodiscard]] inline __device__ constexpr auto operator%(lc_ushort3 lhs, lc_ushort rhs) noexcept { return lc_make_ushort3(lhs.x % rhs, lhs.y % rhs, lhs.z % rhs); } +[[nodiscard]] inline __device__ constexpr auto operator%(lc_ushort lhs, lc_ushort3 rhs) noexcept { return lc_make_ushort3(lhs % rhs.x, lhs % rhs.y, lhs % rhs.z); } +[[nodiscard]] inline __device__ constexpr auto operator%(lc_ushort4 lhs, lc_ushort4 rhs) noexcept { return lc_make_ushort4(lhs.x % rhs.x, lhs.y % rhs.y, lhs.z % rhs.z, lhs.w % rhs.w); } +[[nodiscard]] inline __device__ constexpr auto operator%(lc_ushort4 lhs, lc_ushort rhs) noexcept { return lc_make_ushort4(lhs.x % rhs, lhs.y % rhs, lhs.z % rhs, lhs.w % rhs); } +[[nodiscard]] inline __device__ constexpr auto operator%(lc_ushort lhs, lc_ushort4 rhs) noexcept { return lc_make_ushort4(lhs % rhs.x, lhs % rhs.y, lhs % rhs.z, lhs % rhs.w); } +[[nodiscard]] inline __device__ constexpr auto operator%(lc_int2 lhs, lc_int2 rhs) noexcept { return lc_make_int2(lhs.x % rhs.x, lhs.y % rhs.y); } +[[nodiscard]] inline __device__ constexpr auto operator%(lc_int2 lhs, lc_int rhs) noexcept { return lc_make_int2(lhs.x % rhs, lhs.y % rhs); } +[[nodiscard]] inline __device__ constexpr auto operator%(lc_int lhs, lc_int2 rhs) noexcept { return lc_make_int2(lhs % rhs.x, lhs % rhs.y); } +[[nodiscard]] inline __device__ constexpr auto operator%(lc_int3 lhs, lc_int3 rhs) noexcept { return lc_make_int3(lhs.x % rhs.x, lhs.y % rhs.y, lhs.z % rhs.z); } +[[nodiscard]] inline __device__ constexpr auto operator%(lc_int3 lhs, lc_int rhs) noexcept { return lc_make_int3(lhs.x % rhs, lhs.y % rhs, lhs.z % rhs); } +[[nodiscard]] inline __device__ constexpr auto operator%(lc_int lhs, lc_int3 rhs) noexcept { return lc_make_int3(lhs % rhs.x, lhs % rhs.y, lhs % rhs.z); } +[[nodiscard]] inline __device__ constexpr auto operator%(lc_int4 lhs, lc_int4 rhs) noexcept { return lc_make_int4(lhs.x % rhs.x, lhs.y % rhs.y, lhs.z % rhs.z, lhs.w % rhs.w); } +[[nodiscard]] inline __device__ constexpr auto operator%(lc_int4 lhs, lc_int rhs) noexcept { return lc_make_int4(lhs.x % rhs, lhs.y % rhs, lhs.z % rhs, lhs.w % rhs); } +[[nodiscard]] inline __device__ constexpr auto operator%(lc_int lhs, lc_int4 rhs) noexcept { return lc_make_int4(lhs % rhs.x, lhs % rhs.y, lhs % rhs.z, lhs % rhs.w); } +[[nodiscard]] inline __device__ constexpr auto operator%(lc_uint2 lhs, lc_uint2 rhs) noexcept { return lc_make_uint2(lhs.x % rhs.x, lhs.y % rhs.y); } +[[nodiscard]] inline __device__ constexpr auto operator%(lc_uint2 lhs, lc_uint rhs) noexcept { return lc_make_uint2(lhs.x % rhs, lhs.y % rhs); } +[[nodiscard]] inline __device__ constexpr auto operator%(lc_uint lhs, lc_uint2 rhs) noexcept { return lc_make_uint2(lhs % rhs.x, lhs % rhs.y); } +[[nodiscard]] inline __device__ constexpr auto operator%(lc_uint3 lhs, lc_uint3 rhs) noexcept { return lc_make_uint3(lhs.x % rhs.x, lhs.y % rhs.y, lhs.z % rhs.z); } +[[nodiscard]] inline __device__ constexpr auto operator%(lc_uint3 lhs, lc_uint rhs) noexcept { return lc_make_uint3(lhs.x % rhs, lhs.y % rhs, lhs.z % rhs); } +[[nodiscard]] inline __device__ constexpr auto operator%(lc_uint lhs, lc_uint3 rhs) noexcept { return lc_make_uint3(lhs % rhs.x, lhs % rhs.y, lhs % rhs.z); } +[[nodiscard]] inline __device__ constexpr auto operator%(lc_uint4 lhs, lc_uint4 rhs) noexcept { return lc_make_uint4(lhs.x % rhs.x, lhs.y % rhs.y, lhs.z % rhs.z, lhs.w % rhs.w); } +[[nodiscard]] inline __device__ constexpr auto operator%(lc_uint4 lhs, lc_uint rhs) noexcept { return lc_make_uint4(lhs.x % rhs, lhs.y % rhs, lhs.z % rhs, lhs.w % rhs); } +[[nodiscard]] inline __device__ constexpr auto operator%(lc_uint lhs, lc_uint4 rhs) noexcept { return lc_make_uint4(lhs % rhs.x, lhs % rhs.y, lhs % rhs.z, lhs % rhs.w); } +[[nodiscard]] inline __device__ constexpr auto operator%(lc_long2 lhs, lc_long2 rhs) noexcept { return lc_make_long2(lhs.x % rhs.x, lhs.y % rhs.y); } +[[nodiscard]] inline __device__ constexpr auto operator%(lc_long2 lhs, lc_long rhs) noexcept { return lc_make_long2(lhs.x % rhs, lhs.y % rhs); } +[[nodiscard]] inline __device__ constexpr auto operator%(lc_long lhs, lc_long2 rhs) noexcept { return lc_make_long2(lhs % rhs.x, lhs % rhs.y); } +[[nodiscard]] inline __device__ constexpr auto operator%(lc_long3 lhs, lc_long3 rhs) noexcept { return lc_make_long3(lhs.x % rhs.x, lhs.y % rhs.y, lhs.z % rhs.z); } +[[nodiscard]] inline __device__ constexpr auto operator%(lc_long3 lhs, lc_long rhs) noexcept { return lc_make_long3(lhs.x % rhs, lhs.y % rhs, lhs.z % rhs); } +[[nodiscard]] inline __device__ constexpr auto operator%(lc_long lhs, lc_long3 rhs) noexcept { return lc_make_long3(lhs % rhs.x, lhs % rhs.y, lhs % rhs.z); } +[[nodiscard]] inline __device__ constexpr auto operator%(lc_long4 lhs, lc_long4 rhs) noexcept { return lc_make_long4(lhs.x % rhs.x, lhs.y % rhs.y, lhs.z % rhs.z, lhs.w % rhs.w); } +[[nodiscard]] inline __device__ constexpr auto operator%(lc_long4 lhs, lc_long rhs) noexcept { return lc_make_long4(lhs.x % rhs, lhs.y % rhs, lhs.z % rhs, lhs.w % rhs); } +[[nodiscard]] inline __device__ constexpr auto operator%(lc_long lhs, lc_long4 rhs) noexcept { return lc_make_long4(lhs % rhs.x, lhs % rhs.y, lhs % rhs.z, lhs % rhs.w); } +[[nodiscard]] inline __device__ constexpr auto operator%(lc_ulong2 lhs, lc_ulong2 rhs) noexcept { return lc_make_ulong2(lhs.x % rhs.x, lhs.y % rhs.y); } +[[nodiscard]] inline __device__ constexpr auto operator%(lc_ulong2 lhs, lc_ulong rhs) noexcept { return lc_make_ulong2(lhs.x % rhs, lhs.y % rhs); } +[[nodiscard]] inline __device__ constexpr auto operator%(lc_ulong lhs, lc_ulong2 rhs) noexcept { return lc_make_ulong2(lhs % rhs.x, lhs % rhs.y); } +[[nodiscard]] inline __device__ constexpr auto operator%(lc_ulong3 lhs, lc_ulong3 rhs) noexcept { return lc_make_ulong3(lhs.x % rhs.x, lhs.y % rhs.y, lhs.z % rhs.z); } +[[nodiscard]] inline __device__ constexpr auto operator%(lc_ulong3 lhs, lc_ulong rhs) noexcept { return lc_make_ulong3(lhs.x % rhs, lhs.y % rhs, lhs.z % rhs); } +[[nodiscard]] inline __device__ constexpr auto operator%(lc_ulong lhs, lc_ulong3 rhs) noexcept { return lc_make_ulong3(lhs % rhs.x, lhs % rhs.y, lhs % rhs.z); } +[[nodiscard]] inline __device__ constexpr auto operator%(lc_ulong4 lhs, lc_ulong4 rhs) noexcept { return lc_make_ulong4(lhs.x % rhs.x, lhs.y % rhs.y, lhs.z % rhs.z, lhs.w % rhs.w); } +[[nodiscard]] inline __device__ constexpr auto operator%(lc_ulong4 lhs, lc_ulong rhs) noexcept { return lc_make_ulong4(lhs.x % rhs, lhs.y % rhs, lhs.z % rhs, lhs.w % rhs); } +[[nodiscard]] inline __device__ constexpr auto operator%(lc_ulong lhs, lc_ulong4 rhs) noexcept { return lc_make_ulong4(lhs % rhs.x, lhs % rhs.y, lhs % rhs.z, lhs % rhs.w); } + +[[nodiscard]] inline __device__ constexpr auto operator<<(lc_short2 lhs, lc_short2 rhs) noexcept { return lc_make_short2(lhs.x << rhs.x, lhs.y << rhs.y); } +[[nodiscard]] inline __device__ constexpr auto operator<<(lc_short2 lhs, lc_short rhs) noexcept { return lc_make_short2(lhs.x << rhs, lhs.y << rhs); } +[[nodiscard]] inline __device__ constexpr auto operator<<(lc_short lhs, lc_short2 rhs) noexcept { return lc_make_short2(lhs << rhs.x, lhs << rhs.y); } +[[nodiscard]] inline __device__ constexpr auto operator<<(lc_short3 lhs, lc_short3 rhs) noexcept { return lc_make_short3(lhs.x << rhs.x, lhs.y << rhs.y, lhs.z << rhs.z); } +[[nodiscard]] inline __device__ constexpr auto operator<<(lc_short3 lhs, lc_short rhs) noexcept { return lc_make_short3(lhs.x << rhs, lhs.y << rhs, lhs.z << rhs); } +[[nodiscard]] inline __device__ constexpr auto operator<<(lc_short lhs, lc_short3 rhs) noexcept { return lc_make_short3(lhs << rhs.x, lhs << rhs.y, lhs << rhs.z); } +[[nodiscard]] inline __device__ constexpr auto operator<<(lc_short4 lhs, lc_short4 rhs) noexcept { return lc_make_short4(lhs.x << rhs.x, lhs.y << rhs.y, lhs.z << rhs.z, lhs.w << rhs.w); } +[[nodiscard]] inline __device__ constexpr auto operator<<(lc_short4 lhs, lc_short rhs) noexcept { return lc_make_short4(lhs.x << rhs, lhs.y << rhs, lhs.z << rhs, lhs.w << rhs); } +[[nodiscard]] inline __device__ constexpr auto operator<<(lc_short lhs, lc_short4 rhs) noexcept { return lc_make_short4(lhs << rhs.x, lhs << rhs.y, lhs << rhs.z, lhs << rhs.w); } +[[nodiscard]] inline __device__ constexpr auto operator<<(lc_ushort2 lhs, lc_ushort2 rhs) noexcept { return lc_make_ushort2(lhs.x << rhs.x, lhs.y << rhs.y); } +[[nodiscard]] inline __device__ constexpr auto operator<<(lc_ushort2 lhs, lc_ushort rhs) noexcept { return lc_make_ushort2(lhs.x << rhs, lhs.y << rhs); } +[[nodiscard]] inline __device__ constexpr auto operator<<(lc_ushort lhs, lc_ushort2 rhs) noexcept { return lc_make_ushort2(lhs << rhs.x, lhs << rhs.y); } +[[nodiscard]] inline __device__ constexpr auto operator<<(lc_ushort3 lhs, lc_ushort3 rhs) noexcept { return lc_make_ushort3(lhs.x << rhs.x, lhs.y << rhs.y, lhs.z << rhs.z); } +[[nodiscard]] inline __device__ constexpr auto operator<<(lc_ushort3 lhs, lc_ushort rhs) noexcept { return lc_make_ushort3(lhs.x << rhs, lhs.y << rhs, lhs.z << rhs); } +[[nodiscard]] inline __device__ constexpr auto operator<<(lc_ushort lhs, lc_ushort3 rhs) noexcept { return lc_make_ushort3(lhs << rhs.x, lhs << rhs.y, lhs << rhs.z); } +[[nodiscard]] inline __device__ constexpr auto operator<<(lc_ushort4 lhs, lc_ushort4 rhs) noexcept { return lc_make_ushort4(lhs.x << rhs.x, lhs.y << rhs.y, lhs.z << rhs.z, lhs.w << rhs.w); } +[[nodiscard]] inline __device__ constexpr auto operator<<(lc_ushort4 lhs, lc_ushort rhs) noexcept { return lc_make_ushort4(lhs.x << rhs, lhs.y << rhs, lhs.z << rhs, lhs.w << rhs); } +[[nodiscard]] inline __device__ constexpr auto operator<<(lc_ushort lhs, lc_ushort4 rhs) noexcept { return lc_make_ushort4(lhs << rhs.x, lhs << rhs.y, lhs << rhs.z, lhs << rhs.w); } +[[nodiscard]] inline __device__ constexpr auto operator<<(lc_int2 lhs, lc_int2 rhs) noexcept { return lc_make_int2(lhs.x << rhs.x, lhs.y << rhs.y); } +[[nodiscard]] inline __device__ constexpr auto operator<<(lc_int2 lhs, lc_int rhs) noexcept { return lc_make_int2(lhs.x << rhs, lhs.y << rhs); } +[[nodiscard]] inline __device__ constexpr auto operator<<(lc_int lhs, lc_int2 rhs) noexcept { return lc_make_int2(lhs << rhs.x, lhs << rhs.y); } +[[nodiscard]] inline __device__ constexpr auto operator<<(lc_int3 lhs, lc_int3 rhs) noexcept { return lc_make_int3(lhs.x << rhs.x, lhs.y << rhs.y, lhs.z << rhs.z); } +[[nodiscard]] inline __device__ constexpr auto operator<<(lc_int3 lhs, lc_int rhs) noexcept { return lc_make_int3(lhs.x << rhs, lhs.y << rhs, lhs.z << rhs); } +[[nodiscard]] inline __device__ constexpr auto operator<<(lc_int lhs, lc_int3 rhs) noexcept { return lc_make_int3(lhs << rhs.x, lhs << rhs.y, lhs << rhs.z); } +[[nodiscard]] inline __device__ constexpr auto operator<<(lc_int4 lhs, lc_int4 rhs) noexcept { return lc_make_int4(lhs.x << rhs.x, lhs.y << rhs.y, lhs.z << rhs.z, lhs.w << rhs.w); } +[[nodiscard]] inline __device__ constexpr auto operator<<(lc_int4 lhs, lc_int rhs) noexcept { return lc_make_int4(lhs.x << rhs, lhs.y << rhs, lhs.z << rhs, lhs.w << rhs); } +[[nodiscard]] inline __device__ constexpr auto operator<<(lc_int lhs, lc_int4 rhs) noexcept { return lc_make_int4(lhs << rhs.x, lhs << rhs.y, lhs << rhs.z, lhs << rhs.w); } +[[nodiscard]] inline __device__ constexpr auto operator<<(lc_uint2 lhs, lc_uint2 rhs) noexcept { return lc_make_uint2(lhs.x << rhs.x, lhs.y << rhs.y); } +[[nodiscard]] inline __device__ constexpr auto operator<<(lc_uint2 lhs, lc_uint rhs) noexcept { return lc_make_uint2(lhs.x << rhs, lhs.y << rhs); } +[[nodiscard]] inline __device__ constexpr auto operator<<(lc_uint lhs, lc_uint2 rhs) noexcept { return lc_make_uint2(lhs << rhs.x, lhs << rhs.y); } +[[nodiscard]] inline __device__ constexpr auto operator<<(lc_uint3 lhs, lc_uint3 rhs) noexcept { return lc_make_uint3(lhs.x << rhs.x, lhs.y << rhs.y, lhs.z << rhs.z); } +[[nodiscard]] inline __device__ constexpr auto operator<<(lc_uint3 lhs, lc_uint rhs) noexcept { return lc_make_uint3(lhs.x << rhs, lhs.y << rhs, lhs.z << rhs); } +[[nodiscard]] inline __device__ constexpr auto operator<<(lc_uint lhs, lc_uint3 rhs) noexcept { return lc_make_uint3(lhs << rhs.x, lhs << rhs.y, lhs << rhs.z); } +[[nodiscard]] inline __device__ constexpr auto operator<<(lc_uint4 lhs, lc_uint4 rhs) noexcept { return lc_make_uint4(lhs.x << rhs.x, lhs.y << rhs.y, lhs.z << rhs.z, lhs.w << rhs.w); } +[[nodiscard]] inline __device__ constexpr auto operator<<(lc_uint4 lhs, lc_uint rhs) noexcept { return lc_make_uint4(lhs.x << rhs, lhs.y << rhs, lhs.z << rhs, lhs.w << rhs); } +[[nodiscard]] inline __device__ constexpr auto operator<<(lc_uint lhs, lc_uint4 rhs) noexcept { return lc_make_uint4(lhs << rhs.x, lhs << rhs.y, lhs << rhs.z, lhs << rhs.w); } +[[nodiscard]] inline __device__ constexpr auto operator<<(lc_long2 lhs, lc_long2 rhs) noexcept { return lc_make_long2(lhs.x << rhs.x, lhs.y << rhs.y); } +[[nodiscard]] inline __device__ constexpr auto operator<<(lc_long2 lhs, lc_long rhs) noexcept { return lc_make_long2(lhs.x << rhs, lhs.y << rhs); } +[[nodiscard]] inline __device__ constexpr auto operator<<(lc_long lhs, lc_long2 rhs) noexcept { return lc_make_long2(lhs << rhs.x, lhs << rhs.y); } +[[nodiscard]] inline __device__ constexpr auto operator<<(lc_long3 lhs, lc_long3 rhs) noexcept { return lc_make_long3(lhs.x << rhs.x, lhs.y << rhs.y, lhs.z << rhs.z); } +[[nodiscard]] inline __device__ constexpr auto operator<<(lc_long3 lhs, lc_long rhs) noexcept { return lc_make_long3(lhs.x << rhs, lhs.y << rhs, lhs.z << rhs); } +[[nodiscard]] inline __device__ constexpr auto operator<<(lc_long lhs, lc_long3 rhs) noexcept { return lc_make_long3(lhs << rhs.x, lhs << rhs.y, lhs << rhs.z); } +[[nodiscard]] inline __device__ constexpr auto operator<<(lc_long4 lhs, lc_long4 rhs) noexcept { return lc_make_long4(lhs.x << rhs.x, lhs.y << rhs.y, lhs.z << rhs.z, lhs.w << rhs.w); } +[[nodiscard]] inline __device__ constexpr auto operator<<(lc_long4 lhs, lc_long rhs) noexcept { return lc_make_long4(lhs.x << rhs, lhs.y << rhs, lhs.z << rhs, lhs.w << rhs); } +[[nodiscard]] inline __device__ constexpr auto operator<<(lc_long lhs, lc_long4 rhs) noexcept { return lc_make_long4(lhs << rhs.x, lhs << rhs.y, lhs << rhs.z, lhs << rhs.w); } +[[nodiscard]] inline __device__ constexpr auto operator<<(lc_ulong2 lhs, lc_ulong2 rhs) noexcept { return lc_make_ulong2(lhs.x << rhs.x, lhs.y << rhs.y); } +[[nodiscard]] inline __device__ constexpr auto operator<<(lc_ulong2 lhs, lc_ulong rhs) noexcept { return lc_make_ulong2(lhs.x << rhs, lhs.y << rhs); } +[[nodiscard]] inline __device__ constexpr auto operator<<(lc_ulong lhs, lc_ulong2 rhs) noexcept { return lc_make_ulong2(lhs << rhs.x, lhs << rhs.y); } +[[nodiscard]] inline __device__ constexpr auto operator<<(lc_ulong3 lhs, lc_ulong3 rhs) noexcept { return lc_make_ulong3(lhs.x << rhs.x, lhs.y << rhs.y, lhs.z << rhs.z); } +[[nodiscard]] inline __device__ constexpr auto operator<<(lc_ulong3 lhs, lc_ulong rhs) noexcept { return lc_make_ulong3(lhs.x << rhs, lhs.y << rhs, lhs.z << rhs); } +[[nodiscard]] inline __device__ constexpr auto operator<<(lc_ulong lhs, lc_ulong3 rhs) noexcept { return lc_make_ulong3(lhs << rhs.x, lhs << rhs.y, lhs << rhs.z); } +[[nodiscard]] inline __device__ constexpr auto operator<<(lc_ulong4 lhs, lc_ulong4 rhs) noexcept { return lc_make_ulong4(lhs.x << rhs.x, lhs.y << rhs.y, lhs.z << rhs.z, lhs.w << rhs.w); } +[[nodiscard]] inline __device__ constexpr auto operator<<(lc_ulong4 lhs, lc_ulong rhs) noexcept { return lc_make_ulong4(lhs.x << rhs, lhs.y << rhs, lhs.z << rhs, lhs.w << rhs); } +[[nodiscard]] inline __device__ constexpr auto operator<<(lc_ulong lhs, lc_ulong4 rhs) noexcept { return lc_make_ulong4(lhs << rhs.x, lhs << rhs.y, lhs << rhs.z, lhs << rhs.w); } + +[[nodiscard]] inline __device__ constexpr auto operator>>(lc_short2 lhs, lc_short2 rhs) noexcept { return lc_make_short2(lhs.x >> rhs.x, lhs.y >> rhs.y); } +[[nodiscard]] inline __device__ constexpr auto operator>>(lc_short2 lhs, lc_short rhs) noexcept { return lc_make_short2(lhs.x >> rhs, lhs.y >> rhs); } +[[nodiscard]] inline __device__ constexpr auto operator>>(lc_short lhs, lc_short2 rhs) noexcept { return lc_make_short2(lhs >> rhs.x, lhs >> rhs.y); } +[[nodiscard]] inline __device__ constexpr auto operator>>(lc_short3 lhs, lc_short3 rhs) noexcept { return lc_make_short3(lhs.x >> rhs.x, lhs.y >> rhs.y, lhs.z >> rhs.z); } +[[nodiscard]] inline __device__ constexpr auto operator>>(lc_short3 lhs, lc_short rhs) noexcept { return lc_make_short3(lhs.x >> rhs, lhs.y >> rhs, lhs.z >> rhs); } +[[nodiscard]] inline __device__ constexpr auto operator>>(lc_short lhs, lc_short3 rhs) noexcept { return lc_make_short3(lhs >> rhs.x, lhs >> rhs.y, lhs >> rhs.z); } +[[nodiscard]] inline __device__ constexpr auto operator>>(lc_short4 lhs, lc_short4 rhs) noexcept { return lc_make_short4(lhs.x >> rhs.x, lhs.y >> rhs.y, lhs.z >> rhs.z, lhs.w >> rhs.w); } +[[nodiscard]] inline __device__ constexpr auto operator>>(lc_short4 lhs, lc_short rhs) noexcept { return lc_make_short4(lhs.x >> rhs, lhs.y >> rhs, lhs.z >> rhs, lhs.w >> rhs); } +[[nodiscard]] inline __device__ constexpr auto operator>>(lc_short lhs, lc_short4 rhs) noexcept { return lc_make_short4(lhs >> rhs.x, lhs >> rhs.y, lhs >> rhs.z, lhs >> rhs.w); } +[[nodiscard]] inline __device__ constexpr auto operator>>(lc_ushort2 lhs, lc_ushort2 rhs) noexcept { return lc_make_ushort2(lhs.x >> rhs.x, lhs.y >> rhs.y); } +[[nodiscard]] inline __device__ constexpr auto operator>>(lc_ushort2 lhs, lc_ushort rhs) noexcept { return lc_make_ushort2(lhs.x >> rhs, lhs.y >> rhs); } +[[nodiscard]] inline __device__ constexpr auto operator>>(lc_ushort lhs, lc_ushort2 rhs) noexcept { return lc_make_ushort2(lhs >> rhs.x, lhs >> rhs.y); } +[[nodiscard]] inline __device__ constexpr auto operator>>(lc_ushort3 lhs, lc_ushort3 rhs) noexcept { return lc_make_ushort3(lhs.x >> rhs.x, lhs.y >> rhs.y, lhs.z >> rhs.z); } +[[nodiscard]] inline __device__ constexpr auto operator>>(lc_ushort3 lhs, lc_ushort rhs) noexcept { return lc_make_ushort3(lhs.x >> rhs, lhs.y >> rhs, lhs.z >> rhs); } +[[nodiscard]] inline __device__ constexpr auto operator>>(lc_ushort lhs, lc_ushort3 rhs) noexcept { return lc_make_ushort3(lhs >> rhs.x, lhs >> rhs.y, lhs >> rhs.z); } +[[nodiscard]] inline __device__ constexpr auto operator>>(lc_ushort4 lhs, lc_ushort4 rhs) noexcept { return lc_make_ushort4(lhs.x >> rhs.x, lhs.y >> rhs.y, lhs.z >> rhs.z, lhs.w >> rhs.w); } +[[nodiscard]] inline __device__ constexpr auto operator>>(lc_ushort4 lhs, lc_ushort rhs) noexcept { return lc_make_ushort4(lhs.x >> rhs, lhs.y >> rhs, lhs.z >> rhs, lhs.w >> rhs); } +[[nodiscard]] inline __device__ constexpr auto operator>>(lc_ushort lhs, lc_ushort4 rhs) noexcept { return lc_make_ushort4(lhs >> rhs.x, lhs >> rhs.y, lhs >> rhs.z, lhs >> rhs.w); } +[[nodiscard]] inline __device__ constexpr auto operator>>(lc_int2 lhs, lc_int2 rhs) noexcept { return lc_make_int2(lhs.x >> rhs.x, lhs.y >> rhs.y); } +[[nodiscard]] inline __device__ constexpr auto operator>>(lc_int2 lhs, lc_int rhs) noexcept { return lc_make_int2(lhs.x >> rhs, lhs.y >> rhs); } +[[nodiscard]] inline __device__ constexpr auto operator>>(lc_int lhs, lc_int2 rhs) noexcept { return lc_make_int2(lhs >> rhs.x, lhs >> rhs.y); } +[[nodiscard]] inline __device__ constexpr auto operator>>(lc_int3 lhs, lc_int3 rhs) noexcept { return lc_make_int3(lhs.x >> rhs.x, lhs.y >> rhs.y, lhs.z >> rhs.z); } +[[nodiscard]] inline __device__ constexpr auto operator>>(lc_int3 lhs, lc_int rhs) noexcept { return lc_make_int3(lhs.x >> rhs, lhs.y >> rhs, lhs.z >> rhs); } +[[nodiscard]] inline __device__ constexpr auto operator>>(lc_int lhs, lc_int3 rhs) noexcept { return lc_make_int3(lhs >> rhs.x, lhs >> rhs.y, lhs >> rhs.z); } +[[nodiscard]] inline __device__ constexpr auto operator>>(lc_int4 lhs, lc_int4 rhs) noexcept { return lc_make_int4(lhs.x >> rhs.x, lhs.y >> rhs.y, lhs.z >> rhs.z, lhs.w >> rhs.w); } +[[nodiscard]] inline __device__ constexpr auto operator>>(lc_int4 lhs, lc_int rhs) noexcept { return lc_make_int4(lhs.x >> rhs, lhs.y >> rhs, lhs.z >> rhs, lhs.w >> rhs); } +[[nodiscard]] inline __device__ constexpr auto operator>>(lc_int lhs, lc_int4 rhs) noexcept { return lc_make_int4(lhs >> rhs.x, lhs >> rhs.y, lhs >> rhs.z, lhs >> rhs.w); } +[[nodiscard]] inline __device__ constexpr auto operator>>(lc_uint2 lhs, lc_uint2 rhs) noexcept { return lc_make_uint2(lhs.x >> rhs.x, lhs.y >> rhs.y); } +[[nodiscard]] inline __device__ constexpr auto operator>>(lc_uint2 lhs, lc_uint rhs) noexcept { return lc_make_uint2(lhs.x >> rhs, lhs.y >> rhs); } +[[nodiscard]] inline __device__ constexpr auto operator>>(lc_uint lhs, lc_uint2 rhs) noexcept { return lc_make_uint2(lhs >> rhs.x, lhs >> rhs.y); } +[[nodiscard]] inline __device__ constexpr auto operator>>(lc_uint3 lhs, lc_uint3 rhs) noexcept { return lc_make_uint3(lhs.x >> rhs.x, lhs.y >> rhs.y, lhs.z >> rhs.z); } +[[nodiscard]] inline __device__ constexpr auto operator>>(lc_uint3 lhs, lc_uint rhs) noexcept { return lc_make_uint3(lhs.x >> rhs, lhs.y >> rhs, lhs.z >> rhs); } +[[nodiscard]] inline __device__ constexpr auto operator>>(lc_uint lhs, lc_uint3 rhs) noexcept { return lc_make_uint3(lhs >> rhs.x, lhs >> rhs.y, lhs >> rhs.z); } +[[nodiscard]] inline __device__ constexpr auto operator>>(lc_uint4 lhs, lc_uint4 rhs) noexcept { return lc_make_uint4(lhs.x >> rhs.x, lhs.y >> rhs.y, lhs.z >> rhs.z, lhs.w >> rhs.w); } +[[nodiscard]] inline __device__ constexpr auto operator>>(lc_uint4 lhs, lc_uint rhs) noexcept { return lc_make_uint4(lhs.x >> rhs, lhs.y >> rhs, lhs.z >> rhs, lhs.w >> rhs); } +[[nodiscard]] inline __device__ constexpr auto operator>>(lc_uint lhs, lc_uint4 rhs) noexcept { return lc_make_uint4(lhs >> rhs.x, lhs >> rhs.y, lhs >> rhs.z, lhs >> rhs.w); } +[[nodiscard]] inline __device__ constexpr auto operator>>(lc_long2 lhs, lc_long2 rhs) noexcept { return lc_make_long2(lhs.x >> rhs.x, lhs.y >> rhs.y); } +[[nodiscard]] inline __device__ constexpr auto operator>>(lc_long2 lhs, lc_long rhs) noexcept { return lc_make_long2(lhs.x >> rhs, lhs.y >> rhs); } +[[nodiscard]] inline __device__ constexpr auto operator>>(lc_long lhs, lc_long2 rhs) noexcept { return lc_make_long2(lhs >> rhs.x, lhs >> rhs.y); } +[[nodiscard]] inline __device__ constexpr auto operator>>(lc_long3 lhs, lc_long3 rhs) noexcept { return lc_make_long3(lhs.x >> rhs.x, lhs.y >> rhs.y, lhs.z >> rhs.z); } +[[nodiscard]] inline __device__ constexpr auto operator>>(lc_long3 lhs, lc_long rhs) noexcept { return lc_make_long3(lhs.x >> rhs, lhs.y >> rhs, lhs.z >> rhs); } +[[nodiscard]] inline __device__ constexpr auto operator>>(lc_long lhs, lc_long3 rhs) noexcept { return lc_make_long3(lhs >> rhs.x, lhs >> rhs.y, lhs >> rhs.z); } +[[nodiscard]] inline __device__ constexpr auto operator>>(lc_long4 lhs, lc_long4 rhs) noexcept { return lc_make_long4(lhs.x >> rhs.x, lhs.y >> rhs.y, lhs.z >> rhs.z, lhs.w >> rhs.w); } +[[nodiscard]] inline __device__ constexpr auto operator>>(lc_long4 lhs, lc_long rhs) noexcept { return lc_make_long4(lhs.x >> rhs, lhs.y >> rhs, lhs.z >> rhs, lhs.w >> rhs); } +[[nodiscard]] inline __device__ constexpr auto operator>>(lc_long lhs, lc_long4 rhs) noexcept { return lc_make_long4(lhs >> rhs.x, lhs >> rhs.y, lhs >> rhs.z, lhs >> rhs.w); } +[[nodiscard]] inline __device__ constexpr auto operator>>(lc_ulong2 lhs, lc_ulong2 rhs) noexcept { return lc_make_ulong2(lhs.x >> rhs.x, lhs.y >> rhs.y); } +[[nodiscard]] inline __device__ constexpr auto operator>>(lc_ulong2 lhs, lc_ulong rhs) noexcept { return lc_make_ulong2(lhs.x >> rhs, lhs.y >> rhs); } +[[nodiscard]] inline __device__ constexpr auto operator>>(lc_ulong lhs, lc_ulong2 rhs) noexcept { return lc_make_ulong2(lhs >> rhs.x, lhs >> rhs.y); } +[[nodiscard]] inline __device__ constexpr auto operator>>(lc_ulong3 lhs, lc_ulong3 rhs) noexcept { return lc_make_ulong3(lhs.x >> rhs.x, lhs.y >> rhs.y, lhs.z >> rhs.z); } +[[nodiscard]] inline __device__ constexpr auto operator>>(lc_ulong3 lhs, lc_ulong rhs) noexcept { return lc_make_ulong3(lhs.x >> rhs, lhs.y >> rhs, lhs.z >> rhs); } +[[nodiscard]] inline __device__ constexpr auto operator>>(lc_ulong lhs, lc_ulong3 rhs) noexcept { return lc_make_ulong3(lhs >> rhs.x, lhs >> rhs.y, lhs >> rhs.z); } +[[nodiscard]] inline __device__ constexpr auto operator>>(lc_ulong4 lhs, lc_ulong4 rhs) noexcept { return lc_make_ulong4(lhs.x >> rhs.x, lhs.y >> rhs.y, lhs.z >> rhs.z, lhs.w >> rhs.w); } +[[nodiscard]] inline __device__ constexpr auto operator>>(lc_ulong4 lhs, lc_ulong rhs) noexcept { return lc_make_ulong4(lhs.x >> rhs, lhs.y >> rhs, lhs.z >> rhs, lhs.w >> rhs); } +[[nodiscard]] inline __device__ constexpr auto operator>>(lc_ulong lhs, lc_ulong4 rhs) noexcept { return lc_make_ulong4(lhs >> rhs.x, lhs >> rhs.y, lhs >> rhs.z, lhs >> rhs.w); } + +[[nodiscard]] inline __device__ constexpr auto operator|(lc_short2 lhs, lc_short2 rhs) noexcept { return lc_make_short2(lhs.x | rhs.x, lhs.y | rhs.y); } +[[nodiscard]] inline __device__ constexpr auto operator|(lc_short2 lhs, lc_short rhs) noexcept { return lc_make_short2(lhs.x | rhs, lhs.y | rhs); } +[[nodiscard]] inline __device__ constexpr auto operator|(lc_short lhs, lc_short2 rhs) noexcept { return lc_make_short2(lhs | rhs.x, lhs | rhs.y); } +[[nodiscard]] inline __device__ constexpr auto operator|(lc_short3 lhs, lc_short3 rhs) noexcept { return lc_make_short3(lhs.x | rhs.x, lhs.y | rhs.y, lhs.z | rhs.z); } +[[nodiscard]] inline __device__ constexpr auto operator|(lc_short3 lhs, lc_short rhs) noexcept { return lc_make_short3(lhs.x | rhs, lhs.y | rhs, lhs.z | rhs); } +[[nodiscard]] inline __device__ constexpr auto operator|(lc_short lhs, lc_short3 rhs) noexcept { return lc_make_short3(lhs | rhs.x, lhs | rhs.y, lhs | rhs.z); } +[[nodiscard]] inline __device__ constexpr auto operator|(lc_short4 lhs, lc_short4 rhs) noexcept { return lc_make_short4(lhs.x | rhs.x, lhs.y | rhs.y, lhs.z | rhs.z, lhs.w | rhs.w); } +[[nodiscard]] inline __device__ constexpr auto operator|(lc_short4 lhs, lc_short rhs) noexcept { return lc_make_short4(lhs.x | rhs, lhs.y | rhs, lhs.z | rhs, lhs.w | rhs); } +[[nodiscard]] inline __device__ constexpr auto operator|(lc_short lhs, lc_short4 rhs) noexcept { return lc_make_short4(lhs | rhs.x, lhs | rhs.y, lhs | rhs.z, lhs | rhs.w); } +[[nodiscard]] inline __device__ constexpr auto operator|(lc_ushort2 lhs, lc_ushort2 rhs) noexcept { return lc_make_ushort2(lhs.x | rhs.x, lhs.y | rhs.y); } +[[nodiscard]] inline __device__ constexpr auto operator|(lc_ushort2 lhs, lc_ushort rhs) noexcept { return lc_make_ushort2(lhs.x | rhs, lhs.y | rhs); } +[[nodiscard]] inline __device__ constexpr auto operator|(lc_ushort lhs, lc_ushort2 rhs) noexcept { return lc_make_ushort2(lhs | rhs.x, lhs | rhs.y); } +[[nodiscard]] inline __device__ constexpr auto operator|(lc_ushort3 lhs, lc_ushort3 rhs) noexcept { return lc_make_ushort3(lhs.x | rhs.x, lhs.y | rhs.y, lhs.z | rhs.z); } +[[nodiscard]] inline __device__ constexpr auto operator|(lc_ushort3 lhs, lc_ushort rhs) noexcept { return lc_make_ushort3(lhs.x | rhs, lhs.y | rhs, lhs.z | rhs); } +[[nodiscard]] inline __device__ constexpr auto operator|(lc_ushort lhs, lc_ushort3 rhs) noexcept { return lc_make_ushort3(lhs | rhs.x, lhs | rhs.y, lhs | rhs.z); } +[[nodiscard]] inline __device__ constexpr auto operator|(lc_ushort4 lhs, lc_ushort4 rhs) noexcept { return lc_make_ushort4(lhs.x | rhs.x, lhs.y | rhs.y, lhs.z | rhs.z, lhs.w | rhs.w); } +[[nodiscard]] inline __device__ constexpr auto operator|(lc_ushort4 lhs, lc_ushort rhs) noexcept { return lc_make_ushort4(lhs.x | rhs, lhs.y | rhs, lhs.z | rhs, lhs.w | rhs); } +[[nodiscard]] inline __device__ constexpr auto operator|(lc_ushort lhs, lc_ushort4 rhs) noexcept { return lc_make_ushort4(lhs | rhs.x, lhs | rhs.y, lhs | rhs.z, lhs | rhs.w); } +[[nodiscard]] inline __device__ constexpr auto operator|(lc_int2 lhs, lc_int2 rhs) noexcept { return lc_make_int2(lhs.x | rhs.x, lhs.y | rhs.y); } +[[nodiscard]] inline __device__ constexpr auto operator|(lc_int2 lhs, lc_int rhs) noexcept { return lc_make_int2(lhs.x | rhs, lhs.y | rhs); } +[[nodiscard]] inline __device__ constexpr auto operator|(lc_int lhs, lc_int2 rhs) noexcept { return lc_make_int2(lhs | rhs.x, lhs | rhs.y); } +[[nodiscard]] inline __device__ constexpr auto operator|(lc_int3 lhs, lc_int3 rhs) noexcept { return lc_make_int3(lhs.x | rhs.x, lhs.y | rhs.y, lhs.z | rhs.z); } +[[nodiscard]] inline __device__ constexpr auto operator|(lc_int3 lhs, lc_int rhs) noexcept { return lc_make_int3(lhs.x | rhs, lhs.y | rhs, lhs.z | rhs); } +[[nodiscard]] inline __device__ constexpr auto operator|(lc_int lhs, lc_int3 rhs) noexcept { return lc_make_int3(lhs | rhs.x, lhs | rhs.y, lhs | rhs.z); } +[[nodiscard]] inline __device__ constexpr auto operator|(lc_int4 lhs, lc_int4 rhs) noexcept { return lc_make_int4(lhs.x | rhs.x, lhs.y | rhs.y, lhs.z | rhs.z, lhs.w | rhs.w); } +[[nodiscard]] inline __device__ constexpr auto operator|(lc_int4 lhs, lc_int rhs) noexcept { return lc_make_int4(lhs.x | rhs, lhs.y | rhs, lhs.z | rhs, lhs.w | rhs); } +[[nodiscard]] inline __device__ constexpr auto operator|(lc_int lhs, lc_int4 rhs) noexcept { return lc_make_int4(lhs | rhs.x, lhs | rhs.y, lhs | rhs.z, lhs | rhs.w); } +[[nodiscard]] inline __device__ constexpr auto operator|(lc_uint2 lhs, lc_uint2 rhs) noexcept { return lc_make_uint2(lhs.x | rhs.x, lhs.y | rhs.y); } +[[nodiscard]] inline __device__ constexpr auto operator|(lc_uint2 lhs, lc_uint rhs) noexcept { return lc_make_uint2(lhs.x | rhs, lhs.y | rhs); } +[[nodiscard]] inline __device__ constexpr auto operator|(lc_uint lhs, lc_uint2 rhs) noexcept { return lc_make_uint2(lhs | rhs.x, lhs | rhs.y); } +[[nodiscard]] inline __device__ constexpr auto operator|(lc_uint3 lhs, lc_uint3 rhs) noexcept { return lc_make_uint3(lhs.x | rhs.x, lhs.y | rhs.y, lhs.z | rhs.z); } +[[nodiscard]] inline __device__ constexpr auto operator|(lc_uint3 lhs, lc_uint rhs) noexcept { return lc_make_uint3(lhs.x | rhs, lhs.y | rhs, lhs.z | rhs); } +[[nodiscard]] inline __device__ constexpr auto operator|(lc_uint lhs, lc_uint3 rhs) noexcept { return lc_make_uint3(lhs | rhs.x, lhs | rhs.y, lhs | rhs.z); } +[[nodiscard]] inline __device__ constexpr auto operator|(lc_uint4 lhs, lc_uint4 rhs) noexcept { return lc_make_uint4(lhs.x | rhs.x, lhs.y | rhs.y, lhs.z | rhs.z, lhs.w | rhs.w); } +[[nodiscard]] inline __device__ constexpr auto operator|(lc_uint4 lhs, lc_uint rhs) noexcept { return lc_make_uint4(lhs.x | rhs, lhs.y | rhs, lhs.z | rhs, lhs.w | rhs); } +[[nodiscard]] inline __device__ constexpr auto operator|(lc_uint lhs, lc_uint4 rhs) noexcept { return lc_make_uint4(lhs | rhs.x, lhs | rhs.y, lhs | rhs.z, lhs | rhs.w); } +[[nodiscard]] inline __device__ constexpr auto operator|(lc_bool2 lhs, lc_bool2 rhs) noexcept { return lc_make_bool2(lhs.x | rhs.x, lhs.y | rhs.y); } +[[nodiscard]] inline __device__ constexpr auto operator|(lc_bool2 lhs, lc_bool rhs) noexcept { return lc_make_bool2(lhs.x | rhs, lhs.y | rhs); } +[[nodiscard]] inline __device__ constexpr auto operator|(lc_bool lhs, lc_bool2 rhs) noexcept { return lc_make_bool2(lhs | rhs.x, lhs | rhs.y); } +[[nodiscard]] inline __device__ constexpr auto operator|(lc_bool3 lhs, lc_bool3 rhs) noexcept { return lc_make_bool3(lhs.x | rhs.x, lhs.y | rhs.y, lhs.z | rhs.z); } +[[nodiscard]] inline __device__ constexpr auto operator|(lc_bool3 lhs, lc_bool rhs) noexcept { return lc_make_bool3(lhs.x | rhs, lhs.y | rhs, lhs.z | rhs); } +[[nodiscard]] inline __device__ constexpr auto operator|(lc_bool lhs, lc_bool3 rhs) noexcept { return lc_make_bool3(lhs | rhs.x, lhs | rhs.y, lhs | rhs.z); } +[[nodiscard]] inline __device__ constexpr auto operator|(lc_bool4 lhs, lc_bool4 rhs) noexcept { return lc_make_bool4(lhs.x | rhs.x, lhs.y | rhs.y, lhs.z | rhs.z, lhs.w | rhs.w); } +[[nodiscard]] inline __device__ constexpr auto operator|(lc_bool4 lhs, lc_bool rhs) noexcept { return lc_make_bool4(lhs.x | rhs, lhs.y | rhs, lhs.z | rhs, lhs.w | rhs); } +[[nodiscard]] inline __device__ constexpr auto operator|(lc_bool lhs, lc_bool4 rhs) noexcept { return lc_make_bool4(lhs | rhs.x, lhs | rhs.y, lhs | rhs.z, lhs | rhs.w); } +[[nodiscard]] inline __device__ constexpr auto operator|(lc_long2 lhs, lc_long2 rhs) noexcept { return lc_make_long2(lhs.x | rhs.x, lhs.y | rhs.y); } +[[nodiscard]] inline __device__ constexpr auto operator|(lc_long2 lhs, lc_long rhs) noexcept { return lc_make_long2(lhs.x | rhs, lhs.y | rhs); } +[[nodiscard]] inline __device__ constexpr auto operator|(lc_long lhs, lc_long2 rhs) noexcept { return lc_make_long2(lhs | rhs.x, lhs | rhs.y); } +[[nodiscard]] inline __device__ constexpr auto operator|(lc_long3 lhs, lc_long3 rhs) noexcept { return lc_make_long3(lhs.x | rhs.x, lhs.y | rhs.y, lhs.z | rhs.z); } +[[nodiscard]] inline __device__ constexpr auto operator|(lc_long3 lhs, lc_long rhs) noexcept { return lc_make_long3(lhs.x | rhs, lhs.y | rhs, lhs.z | rhs); } +[[nodiscard]] inline __device__ constexpr auto operator|(lc_long lhs, lc_long3 rhs) noexcept { return lc_make_long3(lhs | rhs.x, lhs | rhs.y, lhs | rhs.z); } +[[nodiscard]] inline __device__ constexpr auto operator|(lc_long4 lhs, lc_long4 rhs) noexcept { return lc_make_long4(lhs.x | rhs.x, lhs.y | rhs.y, lhs.z | rhs.z, lhs.w | rhs.w); } +[[nodiscard]] inline __device__ constexpr auto operator|(lc_long4 lhs, lc_long rhs) noexcept { return lc_make_long4(lhs.x | rhs, lhs.y | rhs, lhs.z | rhs, lhs.w | rhs); } +[[nodiscard]] inline __device__ constexpr auto operator|(lc_long lhs, lc_long4 rhs) noexcept { return lc_make_long4(lhs | rhs.x, lhs | rhs.y, lhs | rhs.z, lhs | rhs.w); } +[[nodiscard]] inline __device__ constexpr auto operator|(lc_ulong2 lhs, lc_ulong2 rhs) noexcept { return lc_make_ulong2(lhs.x | rhs.x, lhs.y | rhs.y); } +[[nodiscard]] inline __device__ constexpr auto operator|(lc_ulong2 lhs, lc_ulong rhs) noexcept { return lc_make_ulong2(lhs.x | rhs, lhs.y | rhs); } +[[nodiscard]] inline __device__ constexpr auto operator|(lc_ulong lhs, lc_ulong2 rhs) noexcept { return lc_make_ulong2(lhs | rhs.x, lhs | rhs.y); } +[[nodiscard]] inline __device__ constexpr auto operator|(lc_ulong3 lhs, lc_ulong3 rhs) noexcept { return lc_make_ulong3(lhs.x | rhs.x, lhs.y | rhs.y, lhs.z | rhs.z); } +[[nodiscard]] inline __device__ constexpr auto operator|(lc_ulong3 lhs, lc_ulong rhs) noexcept { return lc_make_ulong3(lhs.x | rhs, lhs.y | rhs, lhs.z | rhs); } +[[nodiscard]] inline __device__ constexpr auto operator|(lc_ulong lhs, lc_ulong3 rhs) noexcept { return lc_make_ulong3(lhs | rhs.x, lhs | rhs.y, lhs | rhs.z); } +[[nodiscard]] inline __device__ constexpr auto operator|(lc_ulong4 lhs, lc_ulong4 rhs) noexcept { return lc_make_ulong4(lhs.x | rhs.x, lhs.y | rhs.y, lhs.z | rhs.z, lhs.w | rhs.w); } +[[nodiscard]] inline __device__ constexpr auto operator|(lc_ulong4 lhs, lc_ulong rhs) noexcept { return lc_make_ulong4(lhs.x | rhs, lhs.y | rhs, lhs.z | rhs, lhs.w | rhs); } +[[nodiscard]] inline __device__ constexpr auto operator|(lc_ulong lhs, lc_ulong4 rhs) noexcept { return lc_make_ulong4(lhs | rhs.x, lhs | rhs.y, lhs | rhs.z, lhs | rhs.w); } + +[[nodiscard]] inline __device__ constexpr auto operator&(lc_short2 lhs, lc_short2 rhs) noexcept { return lc_make_short2(lhs.x & rhs.x, lhs.y & rhs.y); } +[[nodiscard]] inline __device__ constexpr auto operator&(lc_short2 lhs, lc_short rhs) noexcept { return lc_make_short2(lhs.x & rhs, lhs.y & rhs); } +[[nodiscard]] inline __device__ constexpr auto operator&(lc_short lhs, lc_short2 rhs) noexcept { return lc_make_short2(lhs & rhs.x, lhs & rhs.y); } +[[nodiscard]] inline __device__ constexpr auto operator&(lc_short3 lhs, lc_short3 rhs) noexcept { return lc_make_short3(lhs.x & rhs.x, lhs.y & rhs.y, lhs.z & rhs.z); } +[[nodiscard]] inline __device__ constexpr auto operator&(lc_short3 lhs, lc_short rhs) noexcept { return lc_make_short3(lhs.x & rhs, lhs.y & rhs, lhs.z & rhs); } +[[nodiscard]] inline __device__ constexpr auto operator&(lc_short lhs, lc_short3 rhs) noexcept { return lc_make_short3(lhs & rhs.x, lhs & rhs.y, lhs & rhs.z); } +[[nodiscard]] inline __device__ constexpr auto operator&(lc_short4 lhs, lc_short4 rhs) noexcept { return lc_make_short4(lhs.x & rhs.x, lhs.y & rhs.y, lhs.z & rhs.z, lhs.w & rhs.w); } +[[nodiscard]] inline __device__ constexpr auto operator&(lc_short4 lhs, lc_short rhs) noexcept { return lc_make_short4(lhs.x & rhs, lhs.y & rhs, lhs.z & rhs, lhs.w & rhs); } +[[nodiscard]] inline __device__ constexpr auto operator&(lc_short lhs, lc_short4 rhs) noexcept { return lc_make_short4(lhs & rhs.x, lhs & rhs.y, lhs & rhs.z, lhs & rhs.w); } +[[nodiscard]] inline __device__ constexpr auto operator&(lc_ushort2 lhs, lc_ushort2 rhs) noexcept { return lc_make_ushort2(lhs.x & rhs.x, lhs.y & rhs.y); } +[[nodiscard]] inline __device__ constexpr auto operator&(lc_ushort2 lhs, lc_ushort rhs) noexcept { return lc_make_ushort2(lhs.x & rhs, lhs.y & rhs); } +[[nodiscard]] inline __device__ constexpr auto operator&(lc_ushort lhs, lc_ushort2 rhs) noexcept { return lc_make_ushort2(lhs & rhs.x, lhs & rhs.y); } +[[nodiscard]] inline __device__ constexpr auto operator&(lc_ushort3 lhs, lc_ushort3 rhs) noexcept { return lc_make_ushort3(lhs.x & rhs.x, lhs.y & rhs.y, lhs.z & rhs.z); } +[[nodiscard]] inline __device__ constexpr auto operator&(lc_ushort3 lhs, lc_ushort rhs) noexcept { return lc_make_ushort3(lhs.x & rhs, lhs.y & rhs, lhs.z & rhs); } +[[nodiscard]] inline __device__ constexpr auto operator&(lc_ushort lhs, lc_ushort3 rhs) noexcept { return lc_make_ushort3(lhs & rhs.x, lhs & rhs.y, lhs & rhs.z); } +[[nodiscard]] inline __device__ constexpr auto operator&(lc_ushort4 lhs, lc_ushort4 rhs) noexcept { return lc_make_ushort4(lhs.x & rhs.x, lhs.y & rhs.y, lhs.z & rhs.z, lhs.w & rhs.w); } +[[nodiscard]] inline __device__ constexpr auto operator&(lc_ushort4 lhs, lc_ushort rhs) noexcept { return lc_make_ushort4(lhs.x & rhs, lhs.y & rhs, lhs.z & rhs, lhs.w & rhs); } +[[nodiscard]] inline __device__ constexpr auto operator&(lc_ushort lhs, lc_ushort4 rhs) noexcept { return lc_make_ushort4(lhs & rhs.x, lhs & rhs.y, lhs & rhs.z, lhs & rhs.w); } +[[nodiscard]] inline __device__ constexpr auto operator&(lc_int2 lhs, lc_int2 rhs) noexcept { return lc_make_int2(lhs.x & rhs.x, lhs.y & rhs.y); } +[[nodiscard]] inline __device__ constexpr auto operator&(lc_int2 lhs, lc_int rhs) noexcept { return lc_make_int2(lhs.x & rhs, lhs.y & rhs); } +[[nodiscard]] inline __device__ constexpr auto operator&(lc_int lhs, lc_int2 rhs) noexcept { return lc_make_int2(lhs & rhs.x, lhs & rhs.y); } +[[nodiscard]] inline __device__ constexpr auto operator&(lc_int3 lhs, lc_int3 rhs) noexcept { return lc_make_int3(lhs.x & rhs.x, lhs.y & rhs.y, lhs.z & rhs.z); } +[[nodiscard]] inline __device__ constexpr auto operator&(lc_int3 lhs, lc_int rhs) noexcept { return lc_make_int3(lhs.x & rhs, lhs.y & rhs, lhs.z & rhs); } +[[nodiscard]] inline __device__ constexpr auto operator&(lc_int lhs, lc_int3 rhs) noexcept { return lc_make_int3(lhs & rhs.x, lhs & rhs.y, lhs & rhs.z); } +[[nodiscard]] inline __device__ constexpr auto operator&(lc_int4 lhs, lc_int4 rhs) noexcept { return lc_make_int4(lhs.x & rhs.x, lhs.y & rhs.y, lhs.z & rhs.z, lhs.w & rhs.w); } +[[nodiscard]] inline __device__ constexpr auto operator&(lc_int4 lhs, lc_int rhs) noexcept { return lc_make_int4(lhs.x & rhs, lhs.y & rhs, lhs.z & rhs, lhs.w & rhs); } +[[nodiscard]] inline __device__ constexpr auto operator&(lc_int lhs, lc_int4 rhs) noexcept { return lc_make_int4(lhs & rhs.x, lhs & rhs.y, lhs & rhs.z, lhs & rhs.w); } +[[nodiscard]] inline __device__ constexpr auto operator&(lc_uint2 lhs, lc_uint2 rhs) noexcept { return lc_make_uint2(lhs.x & rhs.x, lhs.y & rhs.y); } +[[nodiscard]] inline __device__ constexpr auto operator&(lc_uint2 lhs, lc_uint rhs) noexcept { return lc_make_uint2(lhs.x & rhs, lhs.y & rhs); } +[[nodiscard]] inline __device__ constexpr auto operator&(lc_uint lhs, lc_uint2 rhs) noexcept { return lc_make_uint2(lhs & rhs.x, lhs & rhs.y); } +[[nodiscard]] inline __device__ constexpr auto operator&(lc_uint3 lhs, lc_uint3 rhs) noexcept { return lc_make_uint3(lhs.x & rhs.x, lhs.y & rhs.y, lhs.z & rhs.z); } +[[nodiscard]] inline __device__ constexpr auto operator&(lc_uint3 lhs, lc_uint rhs) noexcept { return lc_make_uint3(lhs.x & rhs, lhs.y & rhs, lhs.z & rhs); } +[[nodiscard]] inline __device__ constexpr auto operator&(lc_uint lhs, lc_uint3 rhs) noexcept { return lc_make_uint3(lhs & rhs.x, lhs & rhs.y, lhs & rhs.z); } +[[nodiscard]] inline __device__ constexpr auto operator&(lc_uint4 lhs, lc_uint4 rhs) noexcept { return lc_make_uint4(lhs.x & rhs.x, lhs.y & rhs.y, lhs.z & rhs.z, lhs.w & rhs.w); } +[[nodiscard]] inline __device__ constexpr auto operator&(lc_uint4 lhs, lc_uint rhs) noexcept { return lc_make_uint4(lhs.x & rhs, lhs.y & rhs, lhs.z & rhs, lhs.w & rhs); } +[[nodiscard]] inline __device__ constexpr auto operator&(lc_uint lhs, lc_uint4 rhs) noexcept { return lc_make_uint4(lhs & rhs.x, lhs & rhs.y, lhs & rhs.z, lhs & rhs.w); } +[[nodiscard]] inline __device__ constexpr auto operator&(lc_bool2 lhs, lc_bool2 rhs) noexcept { return lc_make_bool2(lhs.x & rhs.x, lhs.y & rhs.y); } +[[nodiscard]] inline __device__ constexpr auto operator&(lc_bool2 lhs, lc_bool rhs) noexcept { return lc_make_bool2(lhs.x & rhs, lhs.y & rhs); } +[[nodiscard]] inline __device__ constexpr auto operator&(lc_bool lhs, lc_bool2 rhs) noexcept { return lc_make_bool2(lhs & rhs.x, lhs & rhs.y); } +[[nodiscard]] inline __device__ constexpr auto operator&(lc_bool3 lhs, lc_bool3 rhs) noexcept { return lc_make_bool3(lhs.x & rhs.x, lhs.y & rhs.y, lhs.z & rhs.z); } +[[nodiscard]] inline __device__ constexpr auto operator&(lc_bool3 lhs, lc_bool rhs) noexcept { return lc_make_bool3(lhs.x & rhs, lhs.y & rhs, lhs.z & rhs); } +[[nodiscard]] inline __device__ constexpr auto operator&(lc_bool lhs, lc_bool3 rhs) noexcept { return lc_make_bool3(lhs & rhs.x, lhs & rhs.y, lhs & rhs.z); } +[[nodiscard]] inline __device__ constexpr auto operator&(lc_bool4 lhs, lc_bool4 rhs) noexcept { return lc_make_bool4(lhs.x & rhs.x, lhs.y & rhs.y, lhs.z & rhs.z, lhs.w & rhs.w); } +[[nodiscard]] inline __device__ constexpr auto operator&(lc_bool4 lhs, lc_bool rhs) noexcept { return lc_make_bool4(lhs.x & rhs, lhs.y & rhs, lhs.z & rhs, lhs.w & rhs); } +[[nodiscard]] inline __device__ constexpr auto operator&(lc_bool lhs, lc_bool4 rhs) noexcept { return lc_make_bool4(lhs & rhs.x, lhs & rhs.y, lhs & rhs.z, lhs & rhs.w); } +[[nodiscard]] inline __device__ constexpr auto operator&(lc_long2 lhs, lc_long2 rhs) noexcept { return lc_make_long2(lhs.x & rhs.x, lhs.y & rhs.y); } +[[nodiscard]] inline __device__ constexpr auto operator&(lc_long2 lhs, lc_long rhs) noexcept { return lc_make_long2(lhs.x & rhs, lhs.y & rhs); } +[[nodiscard]] inline __device__ constexpr auto operator&(lc_long lhs, lc_long2 rhs) noexcept { return lc_make_long2(lhs & rhs.x, lhs & rhs.y); } +[[nodiscard]] inline __device__ constexpr auto operator&(lc_long3 lhs, lc_long3 rhs) noexcept { return lc_make_long3(lhs.x & rhs.x, lhs.y & rhs.y, lhs.z & rhs.z); } +[[nodiscard]] inline __device__ constexpr auto operator&(lc_long3 lhs, lc_long rhs) noexcept { return lc_make_long3(lhs.x & rhs, lhs.y & rhs, lhs.z & rhs); } +[[nodiscard]] inline __device__ constexpr auto operator&(lc_long lhs, lc_long3 rhs) noexcept { return lc_make_long3(lhs & rhs.x, lhs & rhs.y, lhs & rhs.z); } +[[nodiscard]] inline __device__ constexpr auto operator&(lc_long4 lhs, lc_long4 rhs) noexcept { return lc_make_long4(lhs.x & rhs.x, lhs.y & rhs.y, lhs.z & rhs.z, lhs.w & rhs.w); } +[[nodiscard]] inline __device__ constexpr auto operator&(lc_long4 lhs, lc_long rhs) noexcept { return lc_make_long4(lhs.x & rhs, lhs.y & rhs, lhs.z & rhs, lhs.w & rhs); } +[[nodiscard]] inline __device__ constexpr auto operator&(lc_long lhs, lc_long4 rhs) noexcept { return lc_make_long4(lhs & rhs.x, lhs & rhs.y, lhs & rhs.z, lhs & rhs.w); } +[[nodiscard]] inline __device__ constexpr auto operator&(lc_ulong2 lhs, lc_ulong2 rhs) noexcept { return lc_make_ulong2(lhs.x & rhs.x, lhs.y & rhs.y); } +[[nodiscard]] inline __device__ constexpr auto operator&(lc_ulong2 lhs, lc_ulong rhs) noexcept { return lc_make_ulong2(lhs.x & rhs, lhs.y & rhs); } +[[nodiscard]] inline __device__ constexpr auto operator&(lc_ulong lhs, lc_ulong2 rhs) noexcept { return lc_make_ulong2(lhs & rhs.x, lhs & rhs.y); } +[[nodiscard]] inline __device__ constexpr auto operator&(lc_ulong3 lhs, lc_ulong3 rhs) noexcept { return lc_make_ulong3(lhs.x & rhs.x, lhs.y & rhs.y, lhs.z & rhs.z); } +[[nodiscard]] inline __device__ constexpr auto operator&(lc_ulong3 lhs, lc_ulong rhs) noexcept { return lc_make_ulong3(lhs.x & rhs, lhs.y & rhs, lhs.z & rhs); } +[[nodiscard]] inline __device__ constexpr auto operator&(lc_ulong lhs, lc_ulong3 rhs) noexcept { return lc_make_ulong3(lhs & rhs.x, lhs & rhs.y, lhs & rhs.z); } +[[nodiscard]] inline __device__ constexpr auto operator&(lc_ulong4 lhs, lc_ulong4 rhs) noexcept { return lc_make_ulong4(lhs.x & rhs.x, lhs.y & rhs.y, lhs.z & rhs.z, lhs.w & rhs.w); } +[[nodiscard]] inline __device__ constexpr auto operator&(lc_ulong4 lhs, lc_ulong rhs) noexcept { return lc_make_ulong4(lhs.x & rhs, lhs.y & rhs, lhs.z & rhs, lhs.w & rhs); } +[[nodiscard]] inline __device__ constexpr auto operator&(lc_ulong lhs, lc_ulong4 rhs) noexcept { return lc_make_ulong4(lhs & rhs.x, lhs & rhs.y, lhs & rhs.z, lhs & rhs.w); } + +[[nodiscard]] inline __device__ constexpr auto operator^(lc_short2 lhs, lc_short2 rhs) noexcept { return lc_make_short2(lhs.x ^ rhs.x, lhs.y ^ rhs.y); } +[[nodiscard]] inline __device__ constexpr auto operator^(lc_short2 lhs, lc_short rhs) noexcept { return lc_make_short2(lhs.x ^ rhs, lhs.y ^ rhs); } +[[nodiscard]] inline __device__ constexpr auto operator^(lc_short lhs, lc_short2 rhs) noexcept { return lc_make_short2(lhs ^ rhs.x, lhs ^ rhs.y); } +[[nodiscard]] inline __device__ constexpr auto operator^(lc_short3 lhs, lc_short3 rhs) noexcept { return lc_make_short3(lhs.x ^ rhs.x, lhs.y ^ rhs.y, lhs.z ^ rhs.z); } +[[nodiscard]] inline __device__ constexpr auto operator^(lc_short3 lhs, lc_short rhs) noexcept { return lc_make_short3(lhs.x ^ rhs, lhs.y ^ rhs, lhs.z ^ rhs); } +[[nodiscard]] inline __device__ constexpr auto operator^(lc_short lhs, lc_short3 rhs) noexcept { return lc_make_short3(lhs ^ rhs.x, lhs ^ rhs.y, lhs ^ rhs.z); } +[[nodiscard]] inline __device__ constexpr auto operator^(lc_short4 lhs, lc_short4 rhs) noexcept { return lc_make_short4(lhs.x ^ rhs.x, lhs.y ^ rhs.y, lhs.z ^ rhs.z, lhs.w ^ rhs.w); } +[[nodiscard]] inline __device__ constexpr auto operator^(lc_short4 lhs, lc_short rhs) noexcept { return lc_make_short4(lhs.x ^ rhs, lhs.y ^ rhs, lhs.z ^ rhs, lhs.w ^ rhs); } +[[nodiscard]] inline __device__ constexpr auto operator^(lc_short lhs, lc_short4 rhs) noexcept { return lc_make_short4(lhs ^ rhs.x, lhs ^ rhs.y, lhs ^ rhs.z, lhs ^ rhs.w); } +[[nodiscard]] inline __device__ constexpr auto operator^(lc_ushort2 lhs, lc_ushort2 rhs) noexcept { return lc_make_ushort2(lhs.x ^ rhs.x, lhs.y ^ rhs.y); } +[[nodiscard]] inline __device__ constexpr auto operator^(lc_ushort2 lhs, lc_ushort rhs) noexcept { return lc_make_ushort2(lhs.x ^ rhs, lhs.y ^ rhs); } +[[nodiscard]] inline __device__ constexpr auto operator^(lc_ushort lhs, lc_ushort2 rhs) noexcept { return lc_make_ushort2(lhs ^ rhs.x, lhs ^ rhs.y); } +[[nodiscard]] inline __device__ constexpr auto operator^(lc_ushort3 lhs, lc_ushort3 rhs) noexcept { return lc_make_ushort3(lhs.x ^ rhs.x, lhs.y ^ rhs.y, lhs.z ^ rhs.z); } +[[nodiscard]] inline __device__ constexpr auto operator^(lc_ushort3 lhs, lc_ushort rhs) noexcept { return lc_make_ushort3(lhs.x ^ rhs, lhs.y ^ rhs, lhs.z ^ rhs); } +[[nodiscard]] inline __device__ constexpr auto operator^(lc_ushort lhs, lc_ushort3 rhs) noexcept { return lc_make_ushort3(lhs ^ rhs.x, lhs ^ rhs.y, lhs ^ rhs.z); } +[[nodiscard]] inline __device__ constexpr auto operator^(lc_ushort4 lhs, lc_ushort4 rhs) noexcept { return lc_make_ushort4(lhs.x ^ rhs.x, lhs.y ^ rhs.y, lhs.z ^ rhs.z, lhs.w ^ rhs.w); } +[[nodiscard]] inline __device__ constexpr auto operator^(lc_ushort4 lhs, lc_ushort rhs) noexcept { return lc_make_ushort4(lhs.x ^ rhs, lhs.y ^ rhs, lhs.z ^ rhs, lhs.w ^ rhs); } +[[nodiscard]] inline __device__ constexpr auto operator^(lc_ushort lhs, lc_ushort4 rhs) noexcept { return lc_make_ushort4(lhs ^ rhs.x, lhs ^ rhs.y, lhs ^ rhs.z, lhs ^ rhs.w); } +[[nodiscard]] inline __device__ constexpr auto operator^(lc_int2 lhs, lc_int2 rhs) noexcept { return lc_make_int2(lhs.x ^ rhs.x, lhs.y ^ rhs.y); } +[[nodiscard]] inline __device__ constexpr auto operator^(lc_int2 lhs, lc_int rhs) noexcept { return lc_make_int2(lhs.x ^ rhs, lhs.y ^ rhs); } +[[nodiscard]] inline __device__ constexpr auto operator^(lc_int lhs, lc_int2 rhs) noexcept { return lc_make_int2(lhs ^ rhs.x, lhs ^ rhs.y); } +[[nodiscard]] inline __device__ constexpr auto operator^(lc_int3 lhs, lc_int3 rhs) noexcept { return lc_make_int3(lhs.x ^ rhs.x, lhs.y ^ rhs.y, lhs.z ^ rhs.z); } +[[nodiscard]] inline __device__ constexpr auto operator^(lc_int3 lhs, lc_int rhs) noexcept { return lc_make_int3(lhs.x ^ rhs, lhs.y ^ rhs, lhs.z ^ rhs); } +[[nodiscard]] inline __device__ constexpr auto operator^(lc_int lhs, lc_int3 rhs) noexcept { return lc_make_int3(lhs ^ rhs.x, lhs ^ rhs.y, lhs ^ rhs.z); } +[[nodiscard]] inline __device__ constexpr auto operator^(lc_int4 lhs, lc_int4 rhs) noexcept { return lc_make_int4(lhs.x ^ rhs.x, lhs.y ^ rhs.y, lhs.z ^ rhs.z, lhs.w ^ rhs.w); } +[[nodiscard]] inline __device__ constexpr auto operator^(lc_int4 lhs, lc_int rhs) noexcept { return lc_make_int4(lhs.x ^ rhs, lhs.y ^ rhs, lhs.z ^ rhs, lhs.w ^ rhs); } +[[nodiscard]] inline __device__ constexpr auto operator^(lc_int lhs, lc_int4 rhs) noexcept { return lc_make_int4(lhs ^ rhs.x, lhs ^ rhs.y, lhs ^ rhs.z, lhs ^ rhs.w); } +[[nodiscard]] inline __device__ constexpr auto operator^(lc_uint2 lhs, lc_uint2 rhs) noexcept { return lc_make_uint2(lhs.x ^ rhs.x, lhs.y ^ rhs.y); } +[[nodiscard]] inline __device__ constexpr auto operator^(lc_uint2 lhs, lc_uint rhs) noexcept { return lc_make_uint2(lhs.x ^ rhs, lhs.y ^ rhs); } +[[nodiscard]] inline __device__ constexpr auto operator^(lc_uint lhs, lc_uint2 rhs) noexcept { return lc_make_uint2(lhs ^ rhs.x, lhs ^ rhs.y); } +[[nodiscard]] inline __device__ constexpr auto operator^(lc_uint3 lhs, lc_uint3 rhs) noexcept { return lc_make_uint3(lhs.x ^ rhs.x, lhs.y ^ rhs.y, lhs.z ^ rhs.z); } +[[nodiscard]] inline __device__ constexpr auto operator^(lc_uint3 lhs, lc_uint rhs) noexcept { return lc_make_uint3(lhs.x ^ rhs, lhs.y ^ rhs, lhs.z ^ rhs); } +[[nodiscard]] inline __device__ constexpr auto operator^(lc_uint lhs, lc_uint3 rhs) noexcept { return lc_make_uint3(lhs ^ rhs.x, lhs ^ rhs.y, lhs ^ rhs.z); } +[[nodiscard]] inline __device__ constexpr auto operator^(lc_uint4 lhs, lc_uint4 rhs) noexcept { return lc_make_uint4(lhs.x ^ rhs.x, lhs.y ^ rhs.y, lhs.z ^ rhs.z, lhs.w ^ rhs.w); } +[[nodiscard]] inline __device__ constexpr auto operator^(lc_uint4 lhs, lc_uint rhs) noexcept { return lc_make_uint4(lhs.x ^ rhs, lhs.y ^ rhs, lhs.z ^ rhs, lhs.w ^ rhs); } +[[nodiscard]] inline __device__ constexpr auto operator^(lc_uint lhs, lc_uint4 rhs) noexcept { return lc_make_uint4(lhs ^ rhs.x, lhs ^ rhs.y, lhs ^ rhs.z, lhs ^ rhs.w); } +[[nodiscard]] inline __device__ constexpr auto operator^(lc_bool2 lhs, lc_bool2 rhs) noexcept { return lc_make_bool2(lhs.x ^ rhs.x, lhs.y ^ rhs.y); } +[[nodiscard]] inline __device__ constexpr auto operator^(lc_bool2 lhs, lc_bool rhs) noexcept { return lc_make_bool2(lhs.x ^ rhs, lhs.y ^ rhs); } +[[nodiscard]] inline __device__ constexpr auto operator^(lc_bool lhs, lc_bool2 rhs) noexcept { return lc_make_bool2(lhs ^ rhs.x, lhs ^ rhs.y); } +[[nodiscard]] inline __device__ constexpr auto operator^(lc_bool3 lhs, lc_bool3 rhs) noexcept { return lc_make_bool3(lhs.x ^ rhs.x, lhs.y ^ rhs.y, lhs.z ^ rhs.z); } +[[nodiscard]] inline __device__ constexpr auto operator^(lc_bool3 lhs, lc_bool rhs) noexcept { return lc_make_bool3(lhs.x ^ rhs, lhs.y ^ rhs, lhs.z ^ rhs); } +[[nodiscard]] inline __device__ constexpr auto operator^(lc_bool lhs, lc_bool3 rhs) noexcept { return lc_make_bool3(lhs ^ rhs.x, lhs ^ rhs.y, lhs ^ rhs.z); } +[[nodiscard]] inline __device__ constexpr auto operator^(lc_bool4 lhs, lc_bool4 rhs) noexcept { return lc_make_bool4(lhs.x ^ rhs.x, lhs.y ^ rhs.y, lhs.z ^ rhs.z, lhs.w ^ rhs.w); } +[[nodiscard]] inline __device__ constexpr auto operator^(lc_bool4 lhs, lc_bool rhs) noexcept { return lc_make_bool4(lhs.x ^ rhs, lhs.y ^ rhs, lhs.z ^ rhs, lhs.w ^ rhs); } +[[nodiscard]] inline __device__ constexpr auto operator^(lc_bool lhs, lc_bool4 rhs) noexcept { return lc_make_bool4(lhs ^ rhs.x, lhs ^ rhs.y, lhs ^ rhs.z, lhs ^ rhs.w); } +[[nodiscard]] inline __device__ constexpr auto operator^(lc_long2 lhs, lc_long2 rhs) noexcept { return lc_make_long2(lhs.x ^ rhs.x, lhs.y ^ rhs.y); } +[[nodiscard]] inline __device__ constexpr auto operator^(lc_long2 lhs, lc_long rhs) noexcept { return lc_make_long2(lhs.x ^ rhs, lhs.y ^ rhs); } +[[nodiscard]] inline __device__ constexpr auto operator^(lc_long lhs, lc_long2 rhs) noexcept { return lc_make_long2(lhs ^ rhs.x, lhs ^ rhs.y); } +[[nodiscard]] inline __device__ constexpr auto operator^(lc_long3 lhs, lc_long3 rhs) noexcept { return lc_make_long3(lhs.x ^ rhs.x, lhs.y ^ rhs.y, lhs.z ^ rhs.z); } +[[nodiscard]] inline __device__ constexpr auto operator^(lc_long3 lhs, lc_long rhs) noexcept { return lc_make_long3(lhs.x ^ rhs, lhs.y ^ rhs, lhs.z ^ rhs); } +[[nodiscard]] inline __device__ constexpr auto operator^(lc_long lhs, lc_long3 rhs) noexcept { return lc_make_long3(lhs ^ rhs.x, lhs ^ rhs.y, lhs ^ rhs.z); } +[[nodiscard]] inline __device__ constexpr auto operator^(lc_long4 lhs, lc_long4 rhs) noexcept { return lc_make_long4(lhs.x ^ rhs.x, lhs.y ^ rhs.y, lhs.z ^ rhs.z, lhs.w ^ rhs.w); } +[[nodiscard]] inline __device__ constexpr auto operator^(lc_long4 lhs, lc_long rhs) noexcept { return lc_make_long4(lhs.x ^ rhs, lhs.y ^ rhs, lhs.z ^ rhs, lhs.w ^ rhs); } +[[nodiscard]] inline __device__ constexpr auto operator^(lc_long lhs, lc_long4 rhs) noexcept { return lc_make_long4(lhs ^ rhs.x, lhs ^ rhs.y, lhs ^ rhs.z, lhs ^ rhs.w); } +[[nodiscard]] inline __device__ constexpr auto operator^(lc_ulong2 lhs, lc_ulong2 rhs) noexcept { return lc_make_ulong2(lhs.x ^ rhs.x, lhs.y ^ rhs.y); } +[[nodiscard]] inline __device__ constexpr auto operator^(lc_ulong2 lhs, lc_ulong rhs) noexcept { return lc_make_ulong2(lhs.x ^ rhs, lhs.y ^ rhs); } +[[nodiscard]] inline __device__ constexpr auto operator^(lc_ulong lhs, lc_ulong2 rhs) noexcept { return lc_make_ulong2(lhs ^ rhs.x, lhs ^ rhs.y); } +[[nodiscard]] inline __device__ constexpr auto operator^(lc_ulong3 lhs, lc_ulong3 rhs) noexcept { return lc_make_ulong3(lhs.x ^ rhs.x, lhs.y ^ rhs.y, lhs.z ^ rhs.z); } +[[nodiscard]] inline __device__ constexpr auto operator^(lc_ulong3 lhs, lc_ulong rhs) noexcept { return lc_make_ulong3(lhs.x ^ rhs, lhs.y ^ rhs, lhs.z ^ rhs); } +[[nodiscard]] inline __device__ constexpr auto operator^(lc_ulong lhs, lc_ulong3 rhs) noexcept { return lc_make_ulong3(lhs ^ rhs.x, lhs ^ rhs.y, lhs ^ rhs.z); } +[[nodiscard]] inline __device__ constexpr auto operator^(lc_ulong4 lhs, lc_ulong4 rhs) noexcept { return lc_make_ulong4(lhs.x ^ rhs.x, lhs.y ^ rhs.y, lhs.z ^ rhs.z, lhs.w ^ rhs.w); } +[[nodiscard]] inline __device__ constexpr auto operator^(lc_ulong4 lhs, lc_ulong rhs) noexcept { return lc_make_ulong4(lhs.x ^ rhs, lhs.y ^ rhs, lhs.z ^ rhs, lhs.w ^ rhs); } +[[nodiscard]] inline __device__ constexpr auto operator^(lc_ulong lhs, lc_ulong4 rhs) noexcept { return lc_make_ulong4(lhs ^ rhs.x, lhs ^ rhs.y, lhs ^ rhs.z, lhs ^ rhs.w); } + +[[nodiscard]] inline __device__ constexpr auto operator||(lc_bool2 lhs, lc_bool2 rhs) noexcept { return lc_make_bool2(lhs.x || rhs.x, lhs.y || rhs.y); } +[[nodiscard]] inline __device__ constexpr auto operator||(lc_bool2 lhs, lc_bool rhs) noexcept { return lc_make_bool2(lhs.x || rhs, lhs.y || rhs); } +[[nodiscard]] inline __device__ constexpr auto operator||(lc_bool lhs, lc_bool2 rhs) noexcept { return lc_make_bool2(lhs || rhs.x, lhs || rhs.y); } +[[nodiscard]] inline __device__ constexpr auto operator||(lc_bool3 lhs, lc_bool3 rhs) noexcept { return lc_make_bool3(lhs.x || rhs.x, lhs.y || rhs.y, lhs.z || rhs.z); } +[[nodiscard]] inline __device__ constexpr auto operator||(lc_bool3 lhs, lc_bool rhs) noexcept { return lc_make_bool3(lhs.x || rhs, lhs.y || rhs, lhs.z || rhs); } +[[nodiscard]] inline __device__ constexpr auto operator||(lc_bool lhs, lc_bool3 rhs) noexcept { return lc_make_bool3(lhs || rhs.x, lhs || rhs.y, lhs || rhs.z); } +[[nodiscard]] inline __device__ constexpr auto operator||(lc_bool4 lhs, lc_bool4 rhs) noexcept { return lc_make_bool4(lhs.x || rhs.x, lhs.y || rhs.y, lhs.z || rhs.z, lhs.w || rhs.w); } +[[nodiscard]] inline __device__ constexpr auto operator||(lc_bool4 lhs, lc_bool rhs) noexcept { return lc_make_bool4(lhs.x || rhs, lhs.y || rhs, lhs.z || rhs, lhs.w || rhs); } +[[nodiscard]] inline __device__ constexpr auto operator||(lc_bool lhs, lc_bool4 rhs) noexcept { return lc_make_bool4(lhs || rhs.x, lhs || rhs.y, lhs || rhs.z, lhs || rhs.w); } + +[[nodiscard]] inline __device__ constexpr auto operator&&(lc_bool2 lhs, lc_bool2 rhs) noexcept { return lc_make_bool2(lhs.x && rhs.x, lhs.y && rhs.y); } +[[nodiscard]] inline __device__ constexpr auto operator&&(lc_bool2 lhs, lc_bool rhs) noexcept { return lc_make_bool2(lhs.x && rhs, lhs.y && rhs); } +[[nodiscard]] inline __device__ constexpr auto operator&&(lc_bool lhs, lc_bool2 rhs) noexcept { return lc_make_bool2(lhs && rhs.x, lhs && rhs.y); } +[[nodiscard]] inline __device__ constexpr auto operator&&(lc_bool3 lhs, lc_bool3 rhs) noexcept { return lc_make_bool3(lhs.x && rhs.x, lhs.y && rhs.y, lhs.z && rhs.z); } +[[nodiscard]] inline __device__ constexpr auto operator&&(lc_bool3 lhs, lc_bool rhs) noexcept { return lc_make_bool3(lhs.x && rhs, lhs.y && rhs, lhs.z && rhs); } +[[nodiscard]] inline __device__ constexpr auto operator&&(lc_bool lhs, lc_bool3 rhs) noexcept { return lc_make_bool3(lhs && rhs.x, lhs && rhs.y, lhs && rhs.z); } +[[nodiscard]] inline __device__ constexpr auto operator&&(lc_bool4 lhs, lc_bool4 rhs) noexcept { return lc_make_bool4(lhs.x && rhs.x, lhs.y && rhs.y, lhs.z && rhs.z, lhs.w && rhs.w); } +[[nodiscard]] inline __device__ constexpr auto operator&&(lc_bool4 lhs, lc_bool rhs) noexcept { return lc_make_bool4(lhs.x && rhs, lhs.y && rhs, lhs.z && rhs, lhs.w && rhs); } +[[nodiscard]] inline __device__ constexpr auto operator&&(lc_bool lhs, lc_bool4 rhs) noexcept { return lc_make_bool4(lhs && rhs.x, lhs && rhs.y, lhs && rhs.z, lhs && rhs.w); } + +[[nodiscard]] __device__ inline constexpr auto lc_any(lc_bool2 v) noexcept { return v.x || v.y; } +[[nodiscard]] __device__ inline constexpr auto lc_any(lc_bool3 v) noexcept { return v.x || v.y || v.z; } +[[nodiscard]] __device__ inline constexpr auto lc_any(lc_bool4 v) noexcept { return v.x || v.y || v.z || v.w; } +[[nodiscard]] __device__ inline constexpr auto lc_all(lc_bool2 v) noexcept { return v.x && v.y; } +[[nodiscard]] __device__ inline constexpr auto lc_all(lc_bool3 v) noexcept { return v.x && v.y && v.z; } +[[nodiscard]] __device__ inline constexpr auto lc_all(lc_bool4 v) noexcept { return v.x && v.y && v.z && v.w; } +[[nodiscard]] __device__ inline constexpr auto lc_none(lc_bool2 v) noexcept { return !v.x && !v.y; } +[[nodiscard]] __device__ inline constexpr auto lc_none(lc_bool3 v) noexcept { return !v.x && !v.y && !v.z; } +[[nodiscard]] __device__ inline constexpr auto lc_none(lc_bool4 v) noexcept { return !v.x && !v.y && !v.z && !v.w; } + +struct lc_float2x2 { +lc_float2 cols[2]; +__device__ inline constexpr lc_float2x2() noexcept : cols{} {} +__device__ inline explicit constexpr lc_float2x2(lc_float s) noexcept + : cols{lc_make_float2(s, 0.0f), lc_make_float2(0.0f, s)} {} +__device__ inline constexpr static auto full(lc_float s) noexcept { return lc_float2x2{lc_float2(s), lc_float2(s)}; } +__device__ inline constexpr static auto zero() noexcept { return lc_float2x2{lc_float2::zero(), lc_float2::zero()}; } +__device__ inline constexpr static auto one() noexcept { return lc_float2x2{lc_float2::one(), lc_float2::one()}; } +__device__ inline constexpr lc_float2x2(lc_float2 c0, lc_float2 c1) noexcept + : cols{c0, c1} {} +[[nodiscard]] __device__ inline constexpr auto &operator[](lc_uint i) noexcept { return cols[i]; } +[[nodiscard]] __device__ inline constexpr auto operator[](lc_uint i) const noexcept { return cols[i]; } +[[nodiscard]] __device__ inline constexpr auto comp_mul(const lc_float2x2 &rhs) const noexcept { return lc_float2x2{cols[0] * rhs[0], cols[1] * rhs[1]}; } +}; + +struct lc_float3x3 { +lc_float3 cols[3]; +__device__ inline constexpr lc_float3x3() noexcept : cols{} {} +__device__ inline explicit constexpr lc_float3x3(lc_float s) noexcept + : cols{lc_make_float3(s, 0.0f, 0.0f), lc_make_float3(0.0f, s, 0.0f), lc_make_float3(0.0f, 0.0f, s)} {} +__device__ inline constexpr static auto full(lc_float s) noexcept { return lc_float3x3{lc_float3(s), lc_float3(s), lc_float3(s)}; } +__device__ inline constexpr static auto zero() noexcept { return lc_float3x3{lc_float3::zero(), lc_float3::zero(), lc_float3::zero()}; } +__device__ inline constexpr static auto one() noexcept { return lc_float3x3{lc_float3::one(), lc_float3::one(), lc_float3::one()}; } +__device__ inline constexpr lc_float3x3(lc_float3 c0, lc_float3 c1, lc_float3 c2) noexcept + : cols{c0, c1, c2} {} +[[nodiscard]] __device__ inline constexpr auto &operator[](lc_uint i) noexcept { return cols[i]; } +[[nodiscard]] __device__ inline constexpr auto operator[](lc_uint i) const noexcept { return cols[i]; } +[[nodiscard]] __device__ inline constexpr auto comp_mul(const lc_float3x3 &rhs) const noexcept { return lc_float3x3{cols[0] * rhs[0], cols[1] * rhs[1], cols[2] * rhs[2]}; } +}; + +struct lc_float4x4 { +lc_float4 cols[4]; +__device__ inline constexpr lc_float4x4() noexcept : cols{} {} +__device__ inline explicit constexpr lc_float4x4(lc_float s) noexcept + : cols{lc_make_float4(s, 0.0f, 0.0f, 0.0f), lc_make_float4(0.0f, s, 0.0f, 0.0f), lc_make_float4(0.0f, 0.0f, s, 0.0f), lc_make_float4(0.0f, 0.0f, 0.0f, s)} {} +__device__ inline constexpr static auto full(lc_float s) noexcept { return lc_float4x4{lc_float4(s), lc_float4(s), lc_float4(s), lc_float4(s)}; } +__device__ inline constexpr static auto zero() noexcept { return lc_float4x4{lc_float4::zero(), lc_float4::zero(), lc_float4::zero(), lc_float4::zero()}; } +__device__ inline constexpr static auto one() noexcept { return lc_float4x4{lc_float4::one(), lc_float4::one(), lc_float4::one(), lc_float4::one()}; } +__device__ inline constexpr lc_float4x4(lc_float4 c0, lc_float4 c1, lc_float4 c2, lc_float4 c3) noexcept + : cols{c0, c1, c2, c3} {} +[[nodiscard]] __device__ inline constexpr auto &operator[](lc_uint i) noexcept { return cols[i]; } +[[nodiscard]] __device__ inline constexpr auto operator[](lc_uint i) const noexcept { return cols[i]; } +[[nodiscard]] __device__ inline constexpr auto comp_mul(const lc_float4x4 &rhs) const noexcept { return lc_float4x4{cols[0] * rhs[0], cols[1] * rhs[1], cols[2] * rhs[2], cols[3] * rhs[3]}; } +}; + +[[nodiscard]] __device__ inline constexpr auto operator*(const lc_float2x2 m, lc_float s) noexcept { return lc_float2x2{m[0] * s, m[1] * s}; } +[[nodiscard]] __device__ inline constexpr auto operator*(lc_float s, const lc_float2x2 m) noexcept { return m * s; } +[[nodiscard]] __device__ inline constexpr auto operator/(const lc_float2x2 m, lc_float s) noexcept { return m * (1.0f / s); } +[[nodiscard]] __device__ inline constexpr auto operator*(const lc_float2x2 m, const lc_float2 v) noexcept { return v.x * m[0] + v.y * m[1]; } +[[nodiscard]] __device__ inline constexpr auto operator*(const lc_float2x2 lhs, const lc_float2x2 rhs) noexcept { return lc_float2x2{lhs * rhs[0], lhs * rhs[1]}; } +[[nodiscard]] __device__ inline constexpr auto operator+(const lc_float2x2 lhs, const lc_float2x2 rhs) noexcept { return lc_float2x2{lhs[0] + rhs[0], lhs[1] + rhs[1]}; } +[[nodiscard]] __device__ inline constexpr auto operator-(const lc_float2x2 lhs, const lc_float2x2 rhs) noexcept { return lc_float2x2{lhs[0] - rhs[0], lhs[1] - rhs[1]}; } + +[[nodiscard]] __device__ inline constexpr auto operator*(const lc_float3x3 m, lc_float s) noexcept { return lc_float3x3{m[0] * s, m[1] * s, m[2] * s}; } +[[nodiscard]] __device__ inline constexpr auto operator*(lc_float s, const lc_float3x3 m) noexcept { return m * s; } +[[nodiscard]] __device__ inline constexpr auto operator/(const lc_float3x3 m, lc_float s) noexcept { return m * (1.0f / s); } +[[nodiscard]] __device__ inline constexpr auto operator*(const lc_float3x3 m, const lc_float3 v) noexcept { return v.x * m[0] + v.y * m[1] + v.z * m[2]; } +[[nodiscard]] __device__ inline constexpr auto operator*(const lc_float3x3 lhs, const lc_float3x3 rhs) noexcept { return lc_float3x3{lhs * rhs[0], lhs * rhs[1], lhs * rhs[2]}; } +[[nodiscard]] __device__ inline constexpr auto operator+(const lc_float3x3 lhs, const lc_float3x3 rhs) noexcept { return lc_float3x3{lhs[0] + rhs[0], lhs[1] + rhs[1], lhs[2] + rhs[2]}; } +[[nodiscard]] __device__ inline constexpr auto operator-(const lc_float3x3 lhs, const lc_float3x3 rhs) noexcept { return lc_float3x3{lhs[0] - rhs[0], lhs[1] - rhs[1], lhs[2] - rhs[2]}; } + +[[nodiscard]] __device__ inline constexpr auto operator*(const lc_float4x4 m, lc_float s) noexcept { return lc_float4x4{m[0] * s, m[1] * s, m[2] * s, m[3] * s}; } +[[nodiscard]] __device__ inline constexpr auto operator*(lc_float s, const lc_float4x4 m) noexcept { return m * s; } +[[nodiscard]] __device__ inline constexpr auto operator/(const lc_float4x4 m, lc_float s) noexcept { return m * (1.0f / s); } +[[nodiscard]] __device__ inline constexpr auto operator*(const lc_float4x4 m, const lc_float4 v) noexcept { return v.x * m[0] + v.y * m[1] + v.z * m[2] + v.w * m[3]; } +[[nodiscard]] __device__ inline constexpr auto operator*(const lc_float4x4 lhs, const lc_float4x4 rhs) noexcept { return lc_float4x4{lhs * rhs[0], lhs * rhs[1], lhs * rhs[2], lhs * rhs[3]}; } +[[nodiscard]] __device__ inline constexpr auto operator+(const lc_float4x4 lhs, const lc_float4x4 rhs) noexcept { return lc_float4x4{lhs[0] + rhs[0], lhs[1] + rhs[1], lhs[2] + rhs[2], lhs[3] + rhs[3]}; } +[[nodiscard]] __device__ inline constexpr auto operator-(const lc_float4x4 lhs, const lc_float4x4 rhs) noexcept { return lc_float4x4{lhs[0] - rhs[0], lhs[1] - rhs[1], lhs[2] - rhs[2], lhs[3] - rhs[3]}; } + +[[nodiscard]] __device__ inline constexpr auto lc_make_float2x2(lc_float s = 1.0f) noexcept { return lc_float2x2{lc_make_float2(s, 0.0f), lc_make_float2(0.0f, s)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_float2x2(lc_float m00, lc_float m01, lc_float m10, lc_float m11) noexcept { return lc_float2x2{lc_make_float2(m00, m01), lc_make_float2(m10, m11)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_float2x2(lc_float2 c0, lc_float2 c1) noexcept { return lc_float2x2{c0, c1}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_float2x2(lc_float2x2 m) noexcept { return m; } +[[nodiscard]] __device__ inline constexpr auto lc_make_float2x2(lc_float3x3 m) noexcept { return lc_float2x2{lc_make_float2(m[0]), lc_make_float2(m[1])}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_float2x2(lc_float4x4 m) noexcept { return lc_float2x2{lc_make_float2(m[0]), lc_make_float2(m[1])}; } + +[[nodiscard]] __device__ inline constexpr auto lc_make_float3x3(lc_float s = 1.0f) noexcept { return lc_float3x3{lc_make_float3(s, 0.0f, 0.0f), lc_make_float3(0.0f, s, 0.0f), lc_make_float3(0.0f, 0.0f, s)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_float3x3(lc_float m00, lc_float m01, lc_float m02, lc_float m10, lc_float m11, lc_float m12, lc_float m20, lc_float m21, lc_float m22) noexcept { return lc_float3x3{lc_make_float3(m00, m01, m02), lc_make_float3(m10, m11, m12), lc_make_float3(m20, m21, m22)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_float3x3(lc_float3 c0, lc_float3 c1, lc_float3 c2) noexcept { return lc_float3x3{c0, c1, c2}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_float3x3(lc_float2x2 m) noexcept { return lc_float3x3{lc_make_float3(m[0], 0.0f), lc_make_float3(m[1], 0.0f), lc_make_float3(0.0f, 0.0f, 1.0f)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_float3x3(lc_float3x3 m) noexcept { return m; } +[[nodiscard]] __device__ inline constexpr auto lc_make_float3x3(lc_float4x4 m) noexcept { return lc_float3x3{lc_make_float3(m[0]), lc_make_float3(m[1]), lc_make_float3(m[2])}; } + +[[nodiscard]] __device__ inline constexpr auto lc_make_float4x4(lc_float s = 1.0f) noexcept { return lc_float4x4{lc_make_float4(s, 0.0f, 0.0f, 0.0f), lc_make_float4(0.0f, s, 0.0f, 0.0f), lc_make_float4(0.0f, 0.0f, s, 0.0f), lc_make_float4(0.0f, 0.0f, 0.0f, s)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_float4x4(lc_float m00, lc_float m01, lc_float m02, lc_float m03, lc_float m10, lc_float m11, lc_float m12, lc_float m13, lc_float m20, lc_float m21, lc_float m22, lc_float m23, lc_float m30, lc_float m31, lc_float m32, lc_float m33) noexcept { return lc_float4x4{lc_make_float4(m00, m01, m02, m03), lc_make_float4(m10, m11, m12, m13), lc_make_float4(m20, m21, m22, m23), lc_make_float4(m30, m31, m32, m33)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_float4x4(lc_float4 c0, lc_float4 c1, lc_float4 c2, lc_float4 c3) noexcept { return lc_float4x4{c0, c1, c2, c3}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_float4x4(lc_float2x2 m) noexcept { return lc_float4x4{lc_make_float4(m[0], 0.0f, 0.0f), lc_make_float4(m[1], 0.0f, 0.0f), lc_make_float4(0.0f, 0.0f, 0.0f, 0.0f), lc_make_float4(0.0f, 0.0f, 0.0f, 1.0f)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_float4x4(lc_float3x3 m) noexcept { return lc_float4x4{lc_make_float4(m[0], 0.0f), lc_make_float4(m[1], 0.0f), lc_make_float4(m[2], 0.0f), lc_make_float4(0.0f, 0.0f, 0.0f, 1.0f)}; } +[[nodiscard]] __device__ inline constexpr auto lc_make_float4x4(lc_float4x4 m) noexcept { return m; } + +template +[[nodiscard]] __device__ inline auto lc_select(T f, T t, bool p) noexcept { return p ? t : f; } +[[nodiscard]] __device__ inline auto lc_select(lc_short2 f, lc_short2 t, lc_bool2 p) noexcept { return lc_make_short2(lc_select(f.x, t.x, p.x), lc_select(f.y, t.y, p.y)); } +[[nodiscard]] __device__ inline auto lc_select(lc_short3 f, lc_short3 t, lc_bool3 p) noexcept { return lc_make_short3(lc_select(f.x, t.x, p.x), lc_select(f.y, t.y, p.y), lc_select(f.z, t.z, p.z)); } +[[nodiscard]] __device__ inline auto lc_select(lc_short4 f, lc_short4 t, lc_bool4 p) noexcept { return lc_make_short4(lc_select(f.x, t.x, p.x), lc_select(f.y, t.y, p.y), lc_select(f.z, t.z, p.z), lc_select(f.w, t.w, p.w)); } +[[nodiscard]] __device__ inline auto lc_select(lc_ushort2 f, lc_ushort2 t, lc_bool2 p) noexcept { return lc_make_ushort2(lc_select(f.x, t.x, p.x), lc_select(f.y, t.y, p.y)); } +[[nodiscard]] __device__ inline auto lc_select(lc_ushort3 f, lc_ushort3 t, lc_bool3 p) noexcept { return lc_make_ushort3(lc_select(f.x, t.x, p.x), lc_select(f.y, t.y, p.y), lc_select(f.z, t.z, p.z)); } +[[nodiscard]] __device__ inline auto lc_select(lc_ushort4 f, lc_ushort4 t, lc_bool4 p) noexcept { return lc_make_ushort4(lc_select(f.x, t.x, p.x), lc_select(f.y, t.y, p.y), lc_select(f.z, t.z, p.z), lc_select(f.w, t.w, p.w)); } +[[nodiscard]] __device__ inline auto lc_select(lc_int2 f, lc_int2 t, lc_bool2 p) noexcept { return lc_make_int2(lc_select(f.x, t.x, p.x), lc_select(f.y, t.y, p.y)); } +[[nodiscard]] __device__ inline auto lc_select(lc_int3 f, lc_int3 t, lc_bool3 p) noexcept { return lc_make_int3(lc_select(f.x, t.x, p.x), lc_select(f.y, t.y, p.y), lc_select(f.z, t.z, p.z)); } +[[nodiscard]] __device__ inline auto lc_select(lc_int4 f, lc_int4 t, lc_bool4 p) noexcept { return lc_make_int4(lc_select(f.x, t.x, p.x), lc_select(f.y, t.y, p.y), lc_select(f.z, t.z, p.z), lc_select(f.w, t.w, p.w)); } +[[nodiscard]] __device__ inline auto lc_select(lc_uint2 f, lc_uint2 t, lc_bool2 p) noexcept { return lc_make_uint2(lc_select(f.x, t.x, p.x), lc_select(f.y, t.y, p.y)); } +[[nodiscard]] __device__ inline auto lc_select(lc_uint3 f, lc_uint3 t, lc_bool3 p) noexcept { return lc_make_uint3(lc_select(f.x, t.x, p.x), lc_select(f.y, t.y, p.y), lc_select(f.z, t.z, p.z)); } +[[nodiscard]] __device__ inline auto lc_select(lc_uint4 f, lc_uint4 t, lc_bool4 p) noexcept { return lc_make_uint4(lc_select(f.x, t.x, p.x), lc_select(f.y, t.y, p.y), lc_select(f.z, t.z, p.z), lc_select(f.w, t.w, p.w)); } +[[nodiscard]] __device__ inline auto lc_select(lc_half2 f, lc_half2 t, lc_bool2 p) noexcept { return lc_make_half2(lc_select(f.x, t.x, p.x), lc_select(f.y, t.y, p.y)); } +[[nodiscard]] __device__ inline auto lc_select(lc_half3 f, lc_half3 t, lc_bool3 p) noexcept { return lc_make_half3(lc_select(f.x, t.x, p.x), lc_select(f.y, t.y, p.y), lc_select(f.z, t.z, p.z)); } +[[nodiscard]] __device__ inline auto lc_select(lc_half4 f, lc_half4 t, lc_bool4 p) noexcept { return lc_make_half4(lc_select(f.x, t.x, p.x), lc_select(f.y, t.y, p.y), lc_select(f.z, t.z, p.z), lc_select(f.w, t.w, p.w)); } +[[nodiscard]] __device__ inline auto lc_select(lc_float2 f, lc_float2 t, lc_bool2 p) noexcept { return lc_make_float2(lc_select(f.x, t.x, p.x), lc_select(f.y, t.y, p.y)); } +[[nodiscard]] __device__ inline auto lc_select(lc_float3 f, lc_float3 t, lc_bool3 p) noexcept { return lc_make_float3(lc_select(f.x, t.x, p.x), lc_select(f.y, t.y, p.y), lc_select(f.z, t.z, p.z)); } +[[nodiscard]] __device__ inline auto lc_select(lc_float4 f, lc_float4 t, lc_bool4 p) noexcept { return lc_make_float4(lc_select(f.x, t.x, p.x), lc_select(f.y, t.y, p.y), lc_select(f.z, t.z, p.z), lc_select(f.w, t.w, p.w)); } +[[nodiscard]] __device__ inline auto lc_select(lc_bool2 f, lc_bool2 t, lc_bool2 p) noexcept { return lc_make_bool2(lc_select(f.x, t.x, p.x), lc_select(f.y, t.y, p.y)); } +[[nodiscard]] __device__ inline auto lc_select(lc_bool3 f, lc_bool3 t, lc_bool3 p) noexcept { return lc_make_bool3(lc_select(f.x, t.x, p.x), lc_select(f.y, t.y, p.y), lc_select(f.z, t.z, p.z)); } +[[nodiscard]] __device__ inline auto lc_select(lc_bool4 f, lc_bool4 t, lc_bool4 p) noexcept { return lc_make_bool4(lc_select(f.x, t.x, p.x), lc_select(f.y, t.y, p.y), lc_select(f.z, t.z, p.z), lc_select(f.w, t.w, p.w)); } +[[nodiscard]] __device__ inline auto lc_select(lc_long2 f, lc_long2 t, lc_bool2 p) noexcept { return lc_make_long2(lc_select(f.x, t.x, p.x), lc_select(f.y, t.y, p.y)); } +[[nodiscard]] __device__ inline auto lc_select(lc_long3 f, lc_long3 t, lc_bool3 p) noexcept { return lc_make_long3(lc_select(f.x, t.x, p.x), lc_select(f.y, t.y, p.y), lc_select(f.z, t.z, p.z)); } +[[nodiscard]] __device__ inline auto lc_select(lc_long4 f, lc_long4 t, lc_bool4 p) noexcept { return lc_make_long4(lc_select(f.x, t.x, p.x), lc_select(f.y, t.y, p.y), lc_select(f.z, t.z, p.z), lc_select(f.w, t.w, p.w)); } +[[nodiscard]] __device__ inline auto lc_select(lc_ulong2 f, lc_ulong2 t, lc_bool2 p) noexcept { return lc_make_ulong2(lc_select(f.x, t.x, p.x), lc_select(f.y, t.y, p.y)); } +[[nodiscard]] __device__ inline auto lc_select(lc_ulong3 f, lc_ulong3 t, lc_bool3 p) noexcept { return lc_make_ulong3(lc_select(f.x, t.x, p.x), lc_select(f.y, t.y, p.y), lc_select(f.z, t.z, p.z)); } +[[nodiscard]] __device__ inline auto lc_select(lc_ulong4 f, lc_ulong4 t, lc_bool4 p) noexcept { return lc_make_ulong4(lc_select(f.x, t.x, p.x), lc_select(f.y, t.y, p.y), lc_select(f.z, t.z, p.z), lc_select(f.w, t.w, p.w)); } + +[[nodiscard]] __device__ inline auto lc_outer_product(lc_float2 a, lc_float2 b) noexcept { return lc_float2x2(a * b.x, a * b.y); } +[[nodiscard]] __device__ inline auto lc_outer_product(lc_float3 a, lc_float3 b) noexcept { return lc_float3x3(a * b.x, a * b.y, a * b.z); } +[[nodiscard]] __device__ inline auto lc_outer_product(lc_float4 a, lc_float4 b) noexcept { return lc_float4x4(a * b.x, a * b.y, a * b.z, a * b.w); } +[[nodiscard]] __device__ inline lc_float lc_min(lc_float a, lc_float b) noexcept { return fminf(a, b); } +[[nodiscard]] __device__ inline lc_float2 lc_min(lc_float2 a, lc_float2 b) noexcept { return lc_make_float2(fminf(a.x, b.x), fminf(a.y, b.y)); } +[[nodiscard]] __device__ inline lc_float3 lc_min(lc_float3 a, lc_float3 b) noexcept { return lc_make_float3(fminf(a.x, b.x), fminf(a.y, b.y), fminf(a.z, b.z)); } +[[nodiscard]] __device__ inline lc_float4 lc_min(lc_float4 a, lc_float4 b) noexcept { return lc_make_float4(fminf(a.x, b.x), fminf(a.y, b.y), fminf(a.z, b.z), fminf(a.w, b.w)); } + +[[nodiscard]] __device__ inline lc_half lc_min(lc_half a, lc_half b) noexcept { return __hmin(a, b); } +[[nodiscard]] __device__ inline lc_half2 lc_min(lc_half2 a, lc_half2 b) noexcept { return lc_make_half2(__hmin(a.x, b.x), __hmin(a.y, b.y)); } +[[nodiscard]] __device__ inline lc_half3 lc_min(lc_half3 a, lc_half3 b) noexcept { return lc_make_half3(__hmin(a.x, b.x), __hmin(a.y, b.y), __hmin(a.z, b.z)); } +[[nodiscard]] __device__ inline lc_half4 lc_min(lc_half4 a, lc_half4 b) noexcept { return lc_make_half4(__hmin(a.x, b.x), __hmin(a.y, b.y), __hmin(a.z, b.z), __hmin(a.w, b.w)); } + +[[nodiscard]] __device__ inline lc_float lc_max(lc_float a, lc_float b) noexcept { return fmaxf(a, b); } +[[nodiscard]] __device__ inline lc_float2 lc_max(lc_float2 a, lc_float2 b) noexcept { return lc_make_float2(fmaxf(a.x, b.x), fmaxf(a.y, b.y)); } +[[nodiscard]] __device__ inline lc_float3 lc_max(lc_float3 a, lc_float3 b) noexcept { return lc_make_float3(fmaxf(a.x, b.x), fmaxf(a.y, b.y), fmaxf(a.z, b.z)); } +[[nodiscard]] __device__ inline lc_float4 lc_max(lc_float4 a, lc_float4 b) noexcept { return lc_make_float4(fmaxf(a.x, b.x), fmaxf(a.y, b.y), fmaxf(a.z, b.z), fmaxf(a.w, b.w)); } + +[[nodiscard]] __device__ inline lc_half lc_max(lc_half a, lc_half b) noexcept { return __hmax(a, b); } +[[nodiscard]] __device__ inline lc_half2 lc_max(lc_half2 a, lc_half2 b) noexcept { return lc_make_half2(__hmax(a.x, b.x), __hmax(a.y, b.y)); } +[[nodiscard]] __device__ inline lc_half3 lc_max(lc_half3 a, lc_half3 b) noexcept { return lc_make_half3(__hmax(a.x, b.x), __hmax(a.y, b.y), __hmax(a.z, b.z)); } +[[nodiscard]] __device__ inline lc_half4 lc_max(lc_half4 a, lc_half4 b) noexcept { return lc_make_half4(__hmax(a.x, b.x), __hmax(a.y, b.y), __hmax(a.z, b.z), __hmax(a.w, b.w)); } + +[[nodiscard]] __device__ inline lc_float lc_abs(lc_float x) noexcept { return fabsf(x); } +[[nodiscard]] __device__ inline lc_float2 lc_abs(lc_float2 x) noexcept { return lc_make_float2(fabsf(x.x), fabsf(x.y)); } +[[nodiscard]] __device__ inline lc_float3 lc_abs(lc_float3 x) noexcept { return lc_make_float3(fabsf(x.x), fabsf(x.y), fabsf(x.z)); } +[[nodiscard]] __device__ inline lc_float4 lc_abs(lc_float4 x) noexcept { return lc_make_float4(fabsf(x.x), fabsf(x.y), fabsf(x.z), fabsf(x.w)); } + +[[nodiscard]] __device__ inline lc_int lc_abs(lc_int x) noexcept { return abs(x); } +[[nodiscard]] __device__ inline lc_int2 lc_abs(lc_int2 x) noexcept { return lc_make_int2(abs(x.x), abs(x.y)); } +[[nodiscard]] __device__ inline lc_int3 lc_abs(lc_int3 x) noexcept { return lc_make_int3(abs(x.x), abs(x.y), abs(x.z)); } +[[nodiscard]] __device__ inline lc_int4 lc_abs(lc_int4 x) noexcept { return lc_make_int4(abs(x.x), abs(x.y), abs(x.z), abs(x.w)); } + +[[nodiscard]] __device__ inline lc_long lc_abs(lc_long x) noexcept { return llabs(x); } +[[nodiscard]] __device__ inline lc_long2 lc_abs(lc_long2 x) noexcept { return lc_make_long2(llabs(x.x), llabs(x.y)); } +[[nodiscard]] __device__ inline lc_long3 lc_abs(lc_long3 x) noexcept { return lc_make_long3(llabs(x.x), llabs(x.y), llabs(x.z)); } +[[nodiscard]] __device__ inline lc_long4 lc_abs(lc_long4 x) noexcept { return lc_make_long4(llabs(x.x), llabs(x.y), llabs(x.z), llabs(x.w)); } + +[[nodiscard]] __device__ inline lc_half lc_abs(lc_half x) noexcept { return __habs(x); } +[[nodiscard]] __device__ inline lc_half2 lc_abs(lc_half2 x) noexcept { return lc_make_half2(__habs(x.x), __habs(x.y)); } +[[nodiscard]] __device__ inline lc_half3 lc_abs(lc_half3 x) noexcept { return lc_make_half3(__habs(x.x), __habs(x.y), __habs(x.z)); } +[[nodiscard]] __device__ inline lc_half4 lc_abs(lc_half4 x) noexcept { return lc_make_half4(__habs(x.x), __habs(x.y), __habs(x.z), __habs(x.w)); } + +[[nodiscard]] __device__ inline lc_half lc_acos(lc_half x) noexcept { return acosf(x); } +[[nodiscard]] __device__ inline lc_half2 lc_acos(lc_half2 x) noexcept { return lc_make_half2(acosf(x.x), acosf(x.y)); } +[[nodiscard]] __device__ inline lc_half3 lc_acos(lc_half3 x) noexcept { return lc_make_half3(acosf(x.x), acosf(x.y), acosf(x.z)); } +[[nodiscard]] __device__ inline lc_half4 lc_acos(lc_half4 x) noexcept { return lc_make_half4(acosf(x.x), acosf(x.y), acosf(x.z), acosf(x.w)); } +[[nodiscard]] __device__ inline lc_float lc_acos(lc_float x) noexcept { return acosf(x); } +[[nodiscard]] __device__ inline lc_float2 lc_acos(lc_float2 x) noexcept { return lc_make_float2(acosf(x.x), acosf(x.y)); } +[[nodiscard]] __device__ inline lc_float3 lc_acos(lc_float3 x) noexcept { return lc_make_float3(acosf(x.x), acosf(x.y), acosf(x.z)); } +[[nodiscard]] __device__ inline lc_float4 lc_acos(lc_float4 x) noexcept { return lc_make_float4(acosf(x.x), acosf(x.y), acosf(x.z), acosf(x.w)); } + +[[nodiscard]] __device__ inline lc_half lc_asin(lc_half x) noexcept { return asinf(x); } +[[nodiscard]] __device__ inline lc_half2 lc_asin(lc_half2 x) noexcept { return lc_make_half2(asinf(x.x), asinf(x.y)); } +[[nodiscard]] __device__ inline lc_half3 lc_asin(lc_half3 x) noexcept { return lc_make_half3(asinf(x.x), asinf(x.y), asinf(x.z)); } +[[nodiscard]] __device__ inline lc_half4 lc_asin(lc_half4 x) noexcept { return lc_make_half4(asinf(x.x), asinf(x.y), asinf(x.z), asinf(x.w)); } +[[nodiscard]] __device__ inline lc_float lc_asin(lc_float x) noexcept { return asinf(x); } +[[nodiscard]] __device__ inline lc_float2 lc_asin(lc_float2 x) noexcept { return lc_make_float2(asinf(x.x), asinf(x.y)); } +[[nodiscard]] __device__ inline lc_float3 lc_asin(lc_float3 x) noexcept { return lc_make_float3(asinf(x.x), asinf(x.y), asinf(x.z)); } +[[nodiscard]] __device__ inline lc_float4 lc_asin(lc_float4 x) noexcept { return lc_make_float4(asinf(x.x), asinf(x.y), asinf(x.z), asinf(x.w)); } + +[[nodiscard]] __device__ inline lc_half lc_atan(lc_half x) noexcept { return atanf(x); } +[[nodiscard]] __device__ inline lc_half2 lc_atan(lc_half2 x) noexcept { return lc_make_half2(atanf(x.x), atanf(x.y)); } +[[nodiscard]] __device__ inline lc_half3 lc_atan(lc_half3 x) noexcept { return lc_make_half3(atanf(x.x), atanf(x.y), atanf(x.z)); } +[[nodiscard]] __device__ inline lc_half4 lc_atan(lc_half4 x) noexcept { return lc_make_half4(atanf(x.x), atanf(x.y), atanf(x.z), atanf(x.w)); } +[[nodiscard]] __device__ inline lc_float lc_atan(lc_float x) noexcept { return atanf(x); } +[[nodiscard]] __device__ inline lc_float2 lc_atan(lc_float2 x) noexcept { return lc_make_float2(atanf(x.x), atanf(x.y)); } +[[nodiscard]] __device__ inline lc_float3 lc_atan(lc_float3 x) noexcept { return lc_make_float3(atanf(x.x), atanf(x.y), atanf(x.z)); } +[[nodiscard]] __device__ inline lc_float4 lc_atan(lc_float4 x) noexcept { return lc_make_float4(atanf(x.x), atanf(x.y), atanf(x.z), atanf(x.w)); } + +[[nodiscard]] __device__ inline lc_half lc_acosh(lc_half x) noexcept { return acoshf(x); } +[[nodiscard]] __device__ inline lc_half2 lc_acosh(lc_half2 x) noexcept { return lc_make_half2(acoshf(x.x), acoshf(x.y)); } +[[nodiscard]] __device__ inline lc_half3 lc_acosh(lc_half3 x) noexcept { return lc_make_half3(acoshf(x.x), acoshf(x.y), acoshf(x.z)); } +[[nodiscard]] __device__ inline lc_half4 lc_acosh(lc_half4 x) noexcept { return lc_make_half4(acoshf(x.x), acoshf(x.y), acoshf(x.z), acoshf(x.w)); } +[[nodiscard]] __device__ inline lc_float lc_acosh(lc_float x) noexcept { return acoshf(x); } +[[nodiscard]] __device__ inline lc_float2 lc_acosh(lc_float2 x) noexcept { return lc_make_float2(acoshf(x.x), acoshf(x.y)); } +[[nodiscard]] __device__ inline lc_float3 lc_acosh(lc_float3 x) noexcept { return lc_make_float3(acoshf(x.x), acoshf(x.y), acoshf(x.z)); } +[[nodiscard]] __device__ inline lc_float4 lc_acosh(lc_float4 x) noexcept { return lc_make_float4(acoshf(x.x), acoshf(x.y), acoshf(x.z), acoshf(x.w)); } + +[[nodiscard]] __device__ inline lc_half lc_asinh(lc_half x) noexcept { return asinhf(x); } +[[nodiscard]] __device__ inline lc_half2 lc_asinh(lc_half2 x) noexcept { return lc_make_half2(asinhf(x.x), asinhf(x.y)); } +[[nodiscard]] __device__ inline lc_half3 lc_asinh(lc_half3 x) noexcept { return lc_make_half3(asinhf(x.x), asinhf(x.y), asinhf(x.z)); } +[[nodiscard]] __device__ inline lc_half4 lc_asinh(lc_half4 x) noexcept { return lc_make_half4(asinhf(x.x), asinhf(x.y), asinhf(x.z), asinhf(x.w)); } +[[nodiscard]] __device__ inline lc_float lc_asinh(lc_float x) noexcept { return asinhf(x); } +[[nodiscard]] __device__ inline lc_float2 lc_asinh(lc_float2 x) noexcept { return lc_make_float2(asinhf(x.x), asinhf(x.y)); } +[[nodiscard]] __device__ inline lc_float3 lc_asinh(lc_float3 x) noexcept { return lc_make_float3(asinhf(x.x), asinhf(x.y), asinhf(x.z)); } +[[nodiscard]] __device__ inline lc_float4 lc_asinh(lc_float4 x) noexcept { return lc_make_float4(asinhf(x.x), asinhf(x.y), asinhf(x.z), asinhf(x.w)); } + +[[nodiscard]] __device__ inline lc_half lc_atanh(lc_half x) noexcept { return atanhf(x); } +[[nodiscard]] __device__ inline lc_half2 lc_atanh(lc_half2 x) noexcept { return lc_make_half2(atanhf(x.x), atanhf(x.y)); } +[[nodiscard]] __device__ inline lc_half3 lc_atanh(lc_half3 x) noexcept { return lc_make_half3(atanhf(x.x), atanhf(x.y), atanhf(x.z)); } +[[nodiscard]] __device__ inline lc_half4 lc_atanh(lc_half4 x) noexcept { return lc_make_half4(atanhf(x.x), atanhf(x.y), atanhf(x.z), atanhf(x.w)); } +[[nodiscard]] __device__ inline lc_float lc_atanh(lc_float x) noexcept { return atanhf(x); } +[[nodiscard]] __device__ inline lc_float2 lc_atanh(lc_float2 x) noexcept { return lc_make_float2(atanhf(x.x), atanhf(x.y)); } +[[nodiscard]] __device__ inline lc_float3 lc_atanh(lc_float3 x) noexcept { return lc_make_float3(atanhf(x.x), atanhf(x.y), atanhf(x.z)); } +[[nodiscard]] __device__ inline lc_float4 lc_atanh(lc_float4 x) noexcept { return lc_make_float4(atanhf(x.x), atanhf(x.y), atanhf(x.z), atanhf(x.w)); } + +[[nodiscard]] __device__ inline lc_half lc_atan2(lc_half y, lc_half x) noexcept { return atan2f(y, x); } +[[nodiscard]] __device__ inline lc_half2 lc_atan2(lc_half2 y, lc_half2 x) noexcept { return lc_make_half2(atan2f(y.x, x.x), atan2f(y.y, x.y)); } +[[nodiscard]] __device__ inline lc_half3 lc_atan2(lc_half3 y, lc_half3 x) noexcept { return lc_make_half3(atan2f(y.x, x.x), atan2f(y.y, x.y), atan2f(y.z, x.z)); } +[[nodiscard]] __device__ inline lc_half4 lc_atan2(lc_half4 y, lc_half4 x) noexcept { return lc_make_half4(atan2f(y.x, x.x), atan2f(y.y, x.y), atan2f(y.z, x.z), atan2f(y.w, x.w)); } +[[nodiscard]] __device__ inline lc_float lc_atan2(lc_float y, lc_float x) noexcept { return atan2f(y, x); } +[[nodiscard]] __device__ inline lc_float2 lc_atan2(lc_float2 y, lc_float2 x) noexcept { return lc_make_float2(atan2f(y.x, x.x), atan2f(y.y, x.y)); } +[[nodiscard]] __device__ inline lc_float3 lc_atan2(lc_float3 y, lc_float3 x) noexcept { return lc_make_float3(atan2f(y.x, x.x), atan2f(y.y, x.y), atan2f(y.z, x.z)); } +[[nodiscard]] __device__ inline lc_float4 lc_atan2(lc_float4 y, lc_float4 x) noexcept { return lc_make_float4(atan2f(y.x, x.x), atan2f(y.y, x.y), atan2f(y.z, x.z), atan2f(y.w, x.w)); } + +[[nodiscard]] __device__ inline lc_half lc_cosh(lc_half x) noexcept { return coshf(x); } +[[nodiscard]] __device__ inline lc_half2 lc_cosh(lc_half2 x) noexcept { return lc_make_half2(coshf(x.x), coshf(x.y)); } +[[nodiscard]] __device__ inline lc_half3 lc_cosh(lc_half3 x) noexcept { return lc_make_half3(coshf(x.x), coshf(x.y), coshf(x.z)); } +[[nodiscard]] __device__ inline lc_half4 lc_cosh(lc_half4 x) noexcept { return lc_make_half4(coshf(x.x), coshf(x.y), coshf(x.z), coshf(x.w)); } +[[nodiscard]] __device__ inline lc_float lc_cosh(lc_float x) noexcept { return coshf(x); } +[[nodiscard]] __device__ inline lc_float2 lc_cosh(lc_float2 x) noexcept { return lc_make_float2(coshf(x.x), coshf(x.y)); } +[[nodiscard]] __device__ inline lc_float3 lc_cosh(lc_float3 x) noexcept { return lc_make_float3(coshf(x.x), coshf(x.y), coshf(x.z)); } +[[nodiscard]] __device__ inline lc_float4 lc_cosh(lc_float4 x) noexcept { return lc_make_float4(coshf(x.x), coshf(x.y), coshf(x.z), coshf(x.w)); } + +[[nodiscard]] __device__ inline lc_half lc_sinh(lc_half x) noexcept { return sinhf(x); } +[[nodiscard]] __device__ inline lc_half2 lc_sinh(lc_half2 x) noexcept { return lc_make_half2(sinhf(x.x), sinhf(x.y)); } +[[nodiscard]] __device__ inline lc_half3 lc_sinh(lc_half3 x) noexcept { return lc_make_half3(sinhf(x.x), sinhf(x.y), sinhf(x.z)); } +[[nodiscard]] __device__ inline lc_half4 lc_sinh(lc_half4 x) noexcept { return lc_make_half4(sinhf(x.x), sinhf(x.y), sinhf(x.z), sinhf(x.w)); } +[[nodiscard]] __device__ inline lc_float lc_sinh(lc_float x) noexcept { return sinhf(x); } +[[nodiscard]] __device__ inline lc_float2 lc_sinh(lc_float2 x) noexcept { return lc_make_float2(sinhf(x.x), sinhf(x.y)); } +[[nodiscard]] __device__ inline lc_float3 lc_sinh(lc_float3 x) noexcept { return lc_make_float3(sinhf(x.x), sinhf(x.y), sinhf(x.z)); } +[[nodiscard]] __device__ inline lc_float4 lc_sinh(lc_float4 x) noexcept { return lc_make_float4(sinhf(x.x), sinhf(x.y), sinhf(x.z), sinhf(x.w)); } + +[[nodiscard]] __device__ inline lc_half lc_tanh(lc_half x) noexcept { return tanhf(x); } +[[nodiscard]] __device__ inline lc_half2 lc_tanh(lc_half2 x) noexcept { return lc_make_half2(tanhf(x.x), tanhf(x.y)); } +[[nodiscard]] __device__ inline lc_half3 lc_tanh(lc_half3 x) noexcept { return lc_make_half3(tanhf(x.x), tanhf(x.y), tanhf(x.z)); } +[[nodiscard]] __device__ inline lc_half4 lc_tanh(lc_half4 x) noexcept { return lc_make_half4(tanhf(x.x), tanhf(x.y), tanhf(x.z), tanhf(x.w)); } +[[nodiscard]] __device__ inline lc_float lc_tanh(lc_float x) noexcept { return tanhf(x); } +[[nodiscard]] __device__ inline lc_float2 lc_tanh(lc_float2 x) noexcept { return lc_make_float2(tanhf(x.x), tanhf(x.y)); } +[[nodiscard]] __device__ inline lc_float3 lc_tanh(lc_float3 x) noexcept { return lc_make_float3(tanhf(x.x), tanhf(x.y), tanhf(x.z)); } +[[nodiscard]] __device__ inline lc_float4 lc_tanh(lc_float4 x) noexcept { return lc_make_float4(tanhf(x.x), tanhf(x.y), tanhf(x.z), tanhf(x.w)); } + +[[nodiscard]] __device__ inline lc_half lc_cos(lc_half x) noexcept { return cosf(x); } +[[nodiscard]] __device__ inline lc_half2 lc_cos(lc_half2 x) noexcept { return lc_make_half2(cosf(x.x), cosf(x.y)); } +[[nodiscard]] __device__ inline lc_half3 lc_cos(lc_half3 x) noexcept { return lc_make_half3(cosf(x.x), cosf(x.y), cosf(x.z)); } +[[nodiscard]] __device__ inline lc_half4 lc_cos(lc_half4 x) noexcept { return lc_make_half4(cosf(x.x), cosf(x.y), cosf(x.z), cosf(x.w)); } +[[nodiscard]] __device__ inline lc_float lc_cos(lc_float x) noexcept { return cosf(x); } +[[nodiscard]] __device__ inline lc_float2 lc_cos(lc_float2 x) noexcept { return lc_make_float2(cosf(x.x), cosf(x.y)); } +[[nodiscard]] __device__ inline lc_float3 lc_cos(lc_float3 x) noexcept { return lc_make_float3(cosf(x.x), cosf(x.y), cosf(x.z)); } +[[nodiscard]] __device__ inline lc_float4 lc_cos(lc_float4 x) noexcept { return lc_make_float4(cosf(x.x), cosf(x.y), cosf(x.z), cosf(x.w)); } + +[[nodiscard]] __device__ inline lc_half lc_sin(lc_half x) noexcept { return sinf(x); } +[[nodiscard]] __device__ inline lc_half2 lc_sin(lc_half2 x) noexcept { return lc_make_half2(sinf(x.x), sinf(x.y)); } +[[nodiscard]] __device__ inline lc_half3 lc_sin(lc_half3 x) noexcept { return lc_make_half3(sinf(x.x), sinf(x.y), sinf(x.z)); } +[[nodiscard]] __device__ inline lc_half4 lc_sin(lc_half4 x) noexcept { return lc_make_half4(sinf(x.x), sinf(x.y), sinf(x.z), sinf(x.w)); } +[[nodiscard]] __device__ inline lc_float lc_sin(lc_float x) noexcept { return sinf(x); } +[[nodiscard]] __device__ inline lc_float2 lc_sin(lc_float2 x) noexcept { return lc_make_float2(sinf(x.x), sinf(x.y)); } +[[nodiscard]] __device__ inline lc_float3 lc_sin(lc_float3 x) noexcept { return lc_make_float3(sinf(x.x), sinf(x.y), sinf(x.z)); } +[[nodiscard]] __device__ inline lc_float4 lc_sin(lc_float4 x) noexcept { return lc_make_float4(sinf(x.x), sinf(x.y), sinf(x.z), sinf(x.w)); } + +[[nodiscard]] __device__ inline lc_half lc_tan(lc_half x) noexcept { return tanf(x); } +[[nodiscard]] __device__ inline lc_half2 lc_tan(lc_half2 x) noexcept { return lc_make_half2(tanf(x.x), tanf(x.y)); } +[[nodiscard]] __device__ inline lc_half3 lc_tan(lc_half3 x) noexcept { return lc_make_half3(tanf(x.x), tanf(x.y), tanf(x.z)); } +[[nodiscard]] __device__ inline lc_half4 lc_tan(lc_half4 x) noexcept { return lc_make_half4(tanf(x.x), tanf(x.y), tanf(x.z), tanf(x.w)); } +[[nodiscard]] __device__ inline lc_float lc_tan(lc_float x) noexcept { return tanf(x); } +[[nodiscard]] __device__ inline lc_float2 lc_tan(lc_float2 x) noexcept { return lc_make_float2(tanf(x.x), tanf(x.y)); } +[[nodiscard]] __device__ inline lc_float3 lc_tan(lc_float3 x) noexcept { return lc_make_float3(tanf(x.x), tanf(x.y), tanf(x.z)); } +[[nodiscard]] __device__ inline lc_float4 lc_tan(lc_float4 x) noexcept { return lc_make_float4(tanf(x.x), tanf(x.y), tanf(x.z), tanf(x.w)); } + +[[nodiscard]] __device__ inline lc_half lc_exp(lc_half x) noexcept { return expf(x); } +[[nodiscard]] __device__ inline lc_half2 lc_exp(lc_half2 x) noexcept { return lc_make_half2(expf(x.x), expf(x.y)); } +[[nodiscard]] __device__ inline lc_half3 lc_exp(lc_half3 x) noexcept { return lc_make_half3(expf(x.x), expf(x.y), expf(x.z)); } +[[nodiscard]] __device__ inline lc_half4 lc_exp(lc_half4 x) noexcept { return lc_make_half4(expf(x.x), expf(x.y), expf(x.z), expf(x.w)); } +[[nodiscard]] __device__ inline lc_float lc_exp(lc_float x) noexcept { return expf(x); } +[[nodiscard]] __device__ inline lc_float2 lc_exp(lc_float2 x) noexcept { return lc_make_float2(expf(x.x), expf(x.y)); } +[[nodiscard]] __device__ inline lc_float3 lc_exp(lc_float3 x) noexcept { return lc_make_float3(expf(x.x), expf(x.y), expf(x.z)); } +[[nodiscard]] __device__ inline lc_float4 lc_exp(lc_float4 x) noexcept { return lc_make_float4(expf(x.x), expf(x.y), expf(x.z), expf(x.w)); } + +[[nodiscard]] __device__ inline lc_float lc_exp2(lc_float x) noexcept { return exp2f(x); } +[[nodiscard]] __device__ inline lc_float2 lc_exp2(lc_float2 x) noexcept { return lc_make_float2(exp2f(x.x), exp2f(x.y)); } +[[nodiscard]] __device__ inline lc_float3 lc_exp2(lc_float3 x) noexcept { return lc_make_float3(exp2f(x.x), exp2f(x.y), exp2f(x.z)); } +[[nodiscard]] __device__ inline lc_float4 lc_exp2(lc_float4 x) noexcept { return lc_make_float4(exp2f(x.x), exp2f(x.y), exp2f(x.z), exp2f(x.w)); } + +[[nodiscard]] __device__ inline lc_half lc_exp2(lc_half x) noexcept { return hexp2(x); } +[[nodiscard]] __device__ inline lc_half2 lc_exp2(lc_half2 x) noexcept { return lc_make_half2(hexp2(x.x), hexp2(x.y)); } +[[nodiscard]] __device__ inline lc_half3 lc_exp2(lc_half3 x) noexcept { return lc_make_half3(hexp2(x.x), hexp2(x.y), hexp2(x.z)); } +[[nodiscard]] __device__ inline lc_half4 lc_exp2(lc_half4 x) noexcept { return lc_make_half4(hexp2(x.x), hexp2(x.y), hexp2(x.z), hexp2(x.w)); } + +[[nodiscard]] __device__ inline lc_half lc_exp10(lc_half x) noexcept { return exp10f(x); } +[[nodiscard]] __device__ inline lc_half2 lc_exp10(lc_half2 x) noexcept { return lc_make_half2(exp10f(x.x), exp10f(x.y)); } +[[nodiscard]] __device__ inline lc_half3 lc_exp10(lc_half3 x) noexcept { return lc_make_half3(exp10f(x.x), exp10f(x.y), exp10f(x.z)); } +[[nodiscard]] __device__ inline lc_half4 lc_exp10(lc_half4 x) noexcept { return lc_make_half4(exp10f(x.x), exp10f(x.y), exp10f(x.z), exp10f(x.w)); } +[[nodiscard]] __device__ inline lc_float lc_exp10(lc_float x) noexcept { return exp10f(x); } +[[nodiscard]] __device__ inline lc_float2 lc_exp10(lc_float2 x) noexcept { return lc_make_float2(exp10f(x.x), exp10f(x.y)); } +[[nodiscard]] __device__ inline lc_float3 lc_exp10(lc_float3 x) noexcept { return lc_make_float3(exp10f(x.x), exp10f(x.y), exp10f(x.z)); } +[[nodiscard]] __device__ inline lc_float4 lc_exp10(lc_float4 x) noexcept { return lc_make_float4(exp10f(x.x), exp10f(x.y), exp10f(x.z), exp10f(x.w)); } + +[[nodiscard]] __device__ inline lc_half lc_log(lc_half x) noexcept { return logf(x); } +[[nodiscard]] __device__ inline lc_half2 lc_log(lc_half2 x) noexcept { return lc_make_half2(logf(x.x), logf(x.y)); } +[[nodiscard]] __device__ inline lc_half3 lc_log(lc_half3 x) noexcept { return lc_make_half3(logf(x.x), logf(x.y), logf(x.z)); } +[[nodiscard]] __device__ inline lc_half4 lc_log(lc_half4 x) noexcept { return lc_make_half4(logf(x.x), logf(x.y), logf(x.z), logf(x.w)); } +[[nodiscard]] __device__ inline lc_float lc_log(lc_float x) noexcept { return logf(x); } +[[nodiscard]] __device__ inline lc_float2 lc_log(lc_float2 x) noexcept { return lc_make_float2(logf(x.x), logf(x.y)); } +[[nodiscard]] __device__ inline lc_float3 lc_log(lc_float3 x) noexcept { return lc_make_float3(logf(x.x), logf(x.y), logf(x.z)); } +[[nodiscard]] __device__ inline lc_float4 lc_log(lc_float4 x) noexcept { return lc_make_float4(logf(x.x), logf(x.y), logf(x.z), logf(x.w)); } + +[[nodiscard]] __device__ inline lc_half lc_log2(lc_half x) noexcept { return log2f(x); } +[[nodiscard]] __device__ inline lc_half2 lc_log2(lc_half2 x) noexcept { return lc_make_half2(log2f(x.x), log2f(x.y)); } +[[nodiscard]] __device__ inline lc_half3 lc_log2(lc_half3 x) noexcept { return lc_make_half3(log2f(x.x), log2f(x.y), log2f(x.z)); } +[[nodiscard]] __device__ inline lc_half4 lc_log2(lc_half4 x) noexcept { return lc_make_half4(log2f(x.x), log2f(x.y), log2f(x.z), log2f(x.w)); } +[[nodiscard]] __device__ inline lc_float lc_log2(lc_float x) noexcept { return log2f(x); } +[[nodiscard]] __device__ inline lc_float2 lc_log2(lc_float2 x) noexcept { return lc_make_float2(log2f(x.x), log2f(x.y)); } +[[nodiscard]] __device__ inline lc_float3 lc_log2(lc_float3 x) noexcept { return lc_make_float3(log2f(x.x), log2f(x.y), log2f(x.z)); } +[[nodiscard]] __device__ inline lc_float4 lc_log2(lc_float4 x) noexcept { return lc_make_float4(log2f(x.x), log2f(x.y), log2f(x.z), log2f(x.w)); } + +[[nodiscard]] __device__ inline lc_half lc_log10(lc_half x) noexcept { return log10f(x); } +[[nodiscard]] __device__ inline lc_half2 lc_log10(lc_half2 x) noexcept { return lc_make_half2(log10f(x.x), log10f(x.y)); } +[[nodiscard]] __device__ inline lc_half3 lc_log10(lc_half3 x) noexcept { return lc_make_half3(log10f(x.x), log10f(x.y), log10f(x.z)); } +[[nodiscard]] __device__ inline lc_half4 lc_log10(lc_half4 x) noexcept { return lc_make_half4(log10f(x.x), log10f(x.y), log10f(x.z), log10f(x.w)); } +[[nodiscard]] __device__ inline lc_float lc_log10(lc_float x) noexcept { return log10f(x); } +[[nodiscard]] __device__ inline lc_float2 lc_log10(lc_float2 x) noexcept { return lc_make_float2(log10f(x.x), log10f(x.y)); } +[[nodiscard]] __device__ inline lc_float3 lc_log10(lc_float3 x) noexcept { return lc_make_float3(log10f(x.x), log10f(x.y), log10f(x.z)); } +[[nodiscard]] __device__ inline lc_float4 lc_log10(lc_float4 x) noexcept { return lc_make_float4(log10f(x.x), log10f(x.y), log10f(x.z), log10f(x.w)); } + +[[nodiscard]] __device__ inline lc_half lc_pow(lc_half x, lc_half a) noexcept { return powf_impl(x, a); } +[[nodiscard]] __device__ inline lc_half2 lc_pow(lc_half2 x, lc_half2 a) noexcept { return lc_make_half2(powf_impl(x.x, a.x), powf_impl(x.y, a.y)); } +[[nodiscard]] __device__ inline lc_half3 lc_pow(lc_half3 x, lc_half3 a) noexcept { return lc_make_half3(powf_impl(x.x, a.x), powf_impl(x.y, a.y), powf_impl(x.z, a.z)); } +[[nodiscard]] __device__ inline lc_half4 lc_pow(lc_half4 x, lc_half4 a) noexcept { return lc_make_half4(powf_impl(x.x, a.x), powf_impl(x.y, a.y), powf_impl(x.z, a.z), powf_impl(x.w, a.w)); } +[[nodiscard]] __device__ inline lc_float lc_pow(lc_float x, lc_float a) noexcept { return powf_impl(x, a); } +[[nodiscard]] __device__ inline lc_float2 lc_pow(lc_float2 x, lc_float2 a) noexcept { return lc_make_float2(powf_impl(x.x, a.x), powf_impl(x.y, a.y)); } +[[nodiscard]] __device__ inline lc_float3 lc_pow(lc_float3 x, lc_float3 a) noexcept { return lc_make_float3(powf_impl(x.x, a.x), powf_impl(x.y, a.y), powf_impl(x.z, a.z)); } +[[nodiscard]] __device__ inline lc_float4 lc_pow(lc_float4 x, lc_float4 a) noexcept { return lc_make_float4(powf_impl(x.x, a.x), powf_impl(x.y, a.y), powf_impl(x.z, a.z), powf_impl(x.w, a.w)); } + +[[nodiscard]] __device__ inline lc_half lc_powi(lc_half x, lc_half a) noexcept { return powi_impl(x, a); } +[[nodiscard]] __device__ inline lc_half2 lc_powi(lc_half2 x, lc_half2 a) noexcept { return lc_make_half2(powi_impl(x.x, a.x), powi_impl(x.y, a.y)); } +[[nodiscard]] __device__ inline lc_half3 lc_powi(lc_half3 x, lc_half3 a) noexcept { return lc_make_half3(powi_impl(x.x, a.x), powi_impl(x.y, a.y), powi_impl(x.z, a.z)); } +[[nodiscard]] __device__ inline lc_half4 lc_powi(lc_half4 x, lc_half4 a) noexcept { return lc_make_half4(powi_impl(x.x, a.x), powi_impl(x.y, a.y), powi_impl(x.z, a.z), powi_impl(x.w, a.w)); } +[[nodiscard]] __device__ inline lc_float lc_powi(lc_float x, lc_float a) noexcept { return powi_impl(x, a); } +[[nodiscard]] __device__ inline lc_float2 lc_powi(lc_float2 x, lc_float2 a) noexcept { return lc_make_float2(powi_impl(x.x, a.x), powi_impl(x.y, a.y)); } +[[nodiscard]] __device__ inline lc_float3 lc_powi(lc_float3 x, lc_float3 a) noexcept { return lc_make_float3(powi_impl(x.x, a.x), powi_impl(x.y, a.y), powi_impl(x.z, a.z)); } +[[nodiscard]] __device__ inline lc_float4 lc_powi(lc_float4 x, lc_float4 a) noexcept { return lc_make_float4(powi_impl(x.x, a.x), powi_impl(x.y, a.y), powi_impl(x.z, a.z), powi_impl(x.w, a.w)); } + +[[nodiscard]] __device__ inline lc_float lc_sqrt(lc_float x) noexcept { return sqrtf(x); } +[[nodiscard]] __device__ inline lc_float2 lc_sqrt(lc_float2 x) noexcept { return lc_make_float2(sqrtf(x.x), sqrtf(x.y)); } +[[nodiscard]] __device__ inline lc_float3 lc_sqrt(lc_float3 x) noexcept { return lc_make_float3(sqrtf(x.x), sqrtf(x.y), sqrtf(x.z)); } +[[nodiscard]] __device__ inline lc_float4 lc_sqrt(lc_float4 x) noexcept { return lc_make_float4(sqrtf(x.x), sqrtf(x.y), sqrtf(x.z), sqrtf(x.w)); } + +[[nodiscard]] __device__ inline lc_half lc_sqrt(lc_half x) noexcept { return hsqrt(x); } +[[nodiscard]] __device__ inline lc_half2 lc_sqrt(lc_half2 x) noexcept { return lc_make_half2(hsqrt(x.x), hsqrt(x.y)); } +[[nodiscard]] __device__ inline lc_half3 lc_sqrt(lc_half3 x) noexcept { return lc_make_half3(hsqrt(x.x), hsqrt(x.y), hsqrt(x.z)); } +[[nodiscard]] __device__ inline lc_half4 lc_sqrt(lc_half4 x) noexcept { return lc_make_half4(hsqrt(x.x), hsqrt(x.y), hsqrt(x.z), hsqrt(x.w)); } + +[[nodiscard]] __device__ inline lc_float lc_rsqrt(lc_float x) noexcept { return rsqrtf(x); } +[[nodiscard]] __device__ inline lc_float2 lc_rsqrt(lc_float2 x) noexcept { return lc_make_float2(rsqrtf(x.x), rsqrtf(x.y)); } +[[nodiscard]] __device__ inline lc_float3 lc_rsqrt(lc_float3 x) noexcept { return lc_make_float3(rsqrtf(x.x), rsqrtf(x.y), rsqrtf(x.z)); } +[[nodiscard]] __device__ inline lc_float4 lc_rsqrt(lc_float4 x) noexcept { return lc_make_float4(rsqrtf(x.x), rsqrtf(x.y), rsqrtf(x.z), rsqrtf(x.w)); } + +[[nodiscard]] __device__ inline lc_half lc_rsqrt(lc_half x) noexcept { return hrsqrt(x); } +[[nodiscard]] __device__ inline lc_half2 lc_rsqrt(lc_half2 x) noexcept { return lc_make_half2(hrsqrt(x.x), hrsqrt(x.y)); } +[[nodiscard]] __device__ inline lc_half3 lc_rsqrt(lc_half3 x) noexcept { return lc_make_half3(hrsqrt(x.x), hrsqrt(x.y), hrsqrt(x.z)); } +[[nodiscard]] __device__ inline lc_half4 lc_rsqrt(lc_half4 x) noexcept { return lc_make_half4(hrsqrt(x.x), hrsqrt(x.y), hrsqrt(x.z), hrsqrt(x.w)); } + +[[nodiscard]] __device__ inline lc_float lc_ceil(lc_float x) noexcept { return ceilf(x); } +[[nodiscard]] __device__ inline lc_float2 lc_ceil(lc_float2 x) noexcept { return lc_make_float2(ceilf(x.x), ceilf(x.y)); } +[[nodiscard]] __device__ inline lc_float3 lc_ceil(lc_float3 x) noexcept { return lc_make_float3(ceilf(x.x), ceilf(x.y), ceilf(x.z)); } +[[nodiscard]] __device__ inline lc_float4 lc_ceil(lc_float4 x) noexcept { return lc_make_float4(ceilf(x.x), ceilf(x.y), ceilf(x.z), ceilf(x.w)); } + +[[nodiscard]] __device__ inline lc_half lc_ceil(lc_half x) noexcept { return hceil(x); } +[[nodiscard]] __device__ inline lc_half2 lc_ceil(lc_half2 x) noexcept { return lc_make_half2(hceil(x.x), hceil(x.y)); } +[[nodiscard]] __device__ inline lc_half3 lc_ceil(lc_half3 x) noexcept { return lc_make_half3(hceil(x.x), hceil(x.y), hceil(x.z)); } +[[nodiscard]] __device__ inline lc_half4 lc_ceil(lc_half4 x) noexcept { return lc_make_half4(hceil(x.x), hceil(x.y), hceil(x.z), hceil(x.w)); } + +[[nodiscard]] __device__ inline lc_float lc_floor(lc_float x) noexcept { return floorf(x); } +[[nodiscard]] __device__ inline lc_float2 lc_floor(lc_float2 x) noexcept { return lc_make_float2(floorf(x.x), floorf(x.y)); } +[[nodiscard]] __device__ inline lc_float3 lc_floor(lc_float3 x) noexcept { return lc_make_float3(floorf(x.x), floorf(x.y), floorf(x.z)); } +[[nodiscard]] __device__ inline lc_float4 lc_floor(lc_float4 x) noexcept { return lc_make_float4(floorf(x.x), floorf(x.y), floorf(x.z), floorf(x.w)); } + +[[nodiscard]] __device__ inline lc_half lc_floor(lc_half x) noexcept { return hfloor(x); } +[[nodiscard]] __device__ inline lc_half2 lc_floor(lc_half2 x) noexcept { return lc_make_half2(hfloor(x.x), hfloor(x.y)); } +[[nodiscard]] __device__ inline lc_half3 lc_floor(lc_half3 x) noexcept { return lc_make_half3(hfloor(x.x), hfloor(x.y), hfloor(x.z)); } +[[nodiscard]] __device__ inline lc_half4 lc_floor(lc_half4 x) noexcept { return lc_make_half4(hfloor(x.x), hfloor(x.y), hfloor(x.z), hfloor(x.w)); } + +[[nodiscard]] __device__ inline lc_float lc_trunc(lc_float x) noexcept { return truncf(x); } +[[nodiscard]] __device__ inline lc_float2 lc_trunc(lc_float2 x) noexcept { return lc_make_float2(truncf(x.x), truncf(x.y)); } +[[nodiscard]] __device__ inline lc_float3 lc_trunc(lc_float3 x) noexcept { return lc_make_float3(truncf(x.x), truncf(x.y), truncf(x.z)); } +[[nodiscard]] __device__ inline lc_float4 lc_trunc(lc_float4 x) noexcept { return lc_make_float4(truncf(x.x), truncf(x.y), truncf(x.z), truncf(x.w)); } + +[[nodiscard]] __device__ inline lc_half lc_trunc(lc_half x) noexcept { return htrunc(x); } +[[nodiscard]] __device__ inline lc_half2 lc_trunc(lc_half2 x) noexcept { return lc_make_half2(htrunc(x.x), htrunc(x.y)); } +[[nodiscard]] __device__ inline lc_half3 lc_trunc(lc_half3 x) noexcept { return lc_make_half3(htrunc(x.x), htrunc(x.y), htrunc(x.z)); } +[[nodiscard]] __device__ inline lc_half4 lc_trunc(lc_half4 x) noexcept { return lc_make_half4(htrunc(x.x), htrunc(x.y), htrunc(x.z), htrunc(x.w)); } + +[[nodiscard]] __device__ inline lc_half lc_round(lc_half x) noexcept { return roundf(x); } +[[nodiscard]] __device__ inline lc_half2 lc_round(lc_half2 x) noexcept { return lc_make_half2(roundf(x.x), roundf(x.y)); } +[[nodiscard]] __device__ inline lc_half3 lc_round(lc_half3 x) noexcept { return lc_make_half3(roundf(x.x), roundf(x.y), roundf(x.z)); } +[[nodiscard]] __device__ inline lc_half4 lc_round(lc_half4 x) noexcept { return lc_make_half4(roundf(x.x), roundf(x.y), roundf(x.z), roundf(x.w)); } +[[nodiscard]] __device__ inline lc_float lc_round(lc_float x) noexcept { return roundf(x); } +[[nodiscard]] __device__ inline lc_float2 lc_round(lc_float2 x) noexcept { return lc_make_float2(roundf(x.x), roundf(x.y)); } +[[nodiscard]] __device__ inline lc_float3 lc_round(lc_float3 x) noexcept { return lc_make_float3(roundf(x.x), roundf(x.y), roundf(x.z)); } +[[nodiscard]] __device__ inline lc_float4 lc_round(lc_float4 x) noexcept { return lc_make_float4(roundf(x.x), roundf(x.y), roundf(x.z), roundf(x.w)); } + +[[nodiscard]] __device__ inline lc_float lc_fma(lc_float x, lc_float y, lc_float z) noexcept { return fmaf(x, y, z); } +[[nodiscard]] __device__ inline lc_float2 lc_fma(lc_float2 x, lc_float2 y, lc_float2 z) noexcept { return lc_make_float2(fmaf(x.x, y.x, z.x), fmaf(x.y, y.y, z.y)); } +[[nodiscard]] __device__ inline lc_float3 lc_fma(lc_float3 x, lc_float3 y, lc_float3 z) noexcept { return lc_make_float3(fmaf(x.x, y.x, z.x), fmaf(x.y, y.y, z.y), fmaf(x.z, y.z, z.z)); } +[[nodiscard]] __device__ inline lc_float4 lc_fma(lc_float4 x, lc_float4 y, lc_float4 z) noexcept { return lc_make_float4(fmaf(x.x, y.x, z.x), fmaf(x.y, y.y, z.y), fmaf(x.z, y.z, z.z), fmaf(x.w, y.w, z.w)); } + +[[nodiscard]] __device__ inline lc_half lc_fma(lc_half x, lc_half y, lc_half z) noexcept { return __hfma(x, y, z); } +[[nodiscard]] __device__ inline lc_half2 lc_fma(lc_half2 x, lc_half2 y, lc_half2 z) noexcept { return lc_make_half2(__hfma(x.x, y.x, z.x), __hfma(x.y, y.y, z.y)); } +[[nodiscard]] __device__ inline lc_half3 lc_fma(lc_half3 x, lc_half3 y, lc_half3 z) noexcept { return lc_make_half3(__hfma(x.x, y.x, z.x), __hfma(x.y, y.y, z.y), __hfma(x.z, y.z, z.z)); } +[[nodiscard]] __device__ inline lc_half4 lc_fma(lc_half4 x, lc_half4 y, lc_half4 z) noexcept { return lc_make_half4(__hfma(x.x, y.x, z.x), __hfma(x.y, y.y, z.y), __hfma(x.z, y.z, z.z), __hfma(x.w, y.w, z.w)); } + + +[[nodiscard]] __device__ inline auto lc_copysign_impl(lc_half x, lc_half y) noexcept { +auto ux = __half_as_short(x); +auto uy = __half_as_short(y); +return __short_as_half((ux & 0x7fffu) | (uy & 0x8000u)); } -template -requires requires(T a, T b) { a - b; } -T __builtin____sub__(T x, T y) -{ - return x - y; +[[nodiscard]] __device__ inline lc_float lc_copysign(lc_float x, lc_float y) noexcept { return copysignf(x, y); } +[[nodiscard]] __device__ inline lc_float2 lc_copysign(lc_float2 x, lc_float2 y) noexcept { return lc_make_float2(copysignf(x.x, y.x), copysignf(x.y, y.y)); } +[[nodiscard]] __device__ inline lc_float3 lc_copysign(lc_float3 x, lc_float3 y) noexcept { return lc_make_float3(copysignf(x.x, y.x), copysignf(x.y, y.y), copysignf(x.z, y.z)); } +[[nodiscard]] __device__ inline lc_float4 lc_copysign(lc_float4 x, lc_float4 y) noexcept { return lc_make_float4(copysignf(x.x, y.x), copysignf(x.y, y.y), copysignf(x.z, y.z), copysignf(x.w, y.w)); } + +[[nodiscard]] __device__ inline lc_half lc_copysign(lc_half x, lc_half y) noexcept { return lc_copysign_impl(x, y); } +[[nodiscard]] __device__ inline lc_half2 lc_copysign(lc_half2 x, lc_half2 y) noexcept { return lc_make_half2(lc_copysign_impl(x.x, y.x), lc_copysign_impl(x.y, y.y)); } +[[nodiscard]] __device__ inline lc_half3 lc_copysign(lc_half3 x, lc_half3 y) noexcept { return lc_make_half3(lc_copysign_impl(x.x, y.x), lc_copysign_impl(x.y, y.y), lc_copysign_impl(x.z, y.z)); } +[[nodiscard]] __device__ inline lc_half4 lc_copysign(lc_half4 x, lc_half4 y) noexcept { return lc_make_half4(lc_copysign_impl(x.x, y.x), lc_copysign_impl(x.y, y.y), lc_copysign_impl(x.z, y.z), lc_copysign_impl(x.w, y.w)); } + +[[nodiscard]] __device__ inline lc_bool lc_isinf(lc_float x) noexcept { return isinf_impl(x); } +[[nodiscard]] __device__ inline lc_bool2 lc_isinf(lc_float2 x) noexcept { return lc_make_bool2(isinf_impl(x.x), isinf_impl(x.y)); } +[[nodiscard]] __device__ inline lc_bool3 lc_isinf(lc_float3 x) noexcept { return lc_make_bool3(isinf_impl(x.x), isinf_impl(x.y), isinf_impl(x.z)); } +[[nodiscard]] __device__ inline lc_bool4 lc_isinf(lc_float4 x) noexcept { return lc_make_bool4(isinf_impl(x.x), isinf_impl(x.y), isinf_impl(x.z), isinf_impl(x.w)); } + +[[nodiscard]] __device__ inline lc_bool lc_isnan(lc_float x) noexcept { return isnan_impl(x); } +[[nodiscard]] __device__ inline lc_bool2 lc_isnan(lc_float2 x) noexcept { return lc_make_bool2(isnan_impl(x.x), isnan_impl(x.y)); } +[[nodiscard]] __device__ inline lc_bool3 lc_isnan(lc_float3 x) noexcept { return lc_make_bool3(isnan_impl(x.x), isnan_impl(x.y), isnan_impl(x.z)); } +[[nodiscard]] __device__ inline lc_bool4 lc_isnan(lc_float4 x) noexcept { return lc_make_bool4(isnan_impl(x.x), isnan_impl(x.y), isnan_impl(x.z), isnan_impl(x.w)); } + +[[nodiscard]] __device__ inline lc_bool lc_isinf(lc_half x) noexcept { return __hisinf(x); } +[[nodiscard]] __device__ inline lc_bool2 lc_isinf(lc_half2 x) noexcept { return lc_make_bool2(__hisinf(x.x), __hisinf(x.y)); } +[[nodiscard]] __device__ inline lc_bool3 lc_isinf(lc_half3 x) noexcept { return lc_make_bool3(__hisinf(x.x), __hisinf(x.y), __hisinf(x.z)); } +[[nodiscard]] __device__ inline lc_bool4 lc_isinf(lc_half4 x) noexcept { return lc_make_bool4(__hisinf(x.x), __hisinf(x.y), __hisinf(x.z), __hisinf(x.w)); } + +[[nodiscard]] __device__ inline lc_bool lc_isnan(lc_half x) noexcept { return __hisnan(x); } +[[nodiscard]] __device__ inline lc_bool2 lc_isnan(lc_half2 x) noexcept { return lc_make_bool2(__hisnan(x.x), __hisnan(x.y)); } +[[nodiscard]] __device__ inline lc_bool3 lc_isnan(lc_half3 x) noexcept { return lc_make_bool3(__hisnan(x.x), __hisnan(x.y), __hisnan(x.z)); } +[[nodiscard]] __device__ inline lc_bool4 lc_isnan(lc_half4 x) noexcept { return lc_make_bool4(__hisnan(x.x), __hisnan(x.y), __hisnan(x.z), __hisnan(x.w)); } + +[[nodiscard]] __device__ inline auto lc_reduce_sum(lc_short2 v) noexcept { return lc_short(v.x+v.y); } +[[nodiscard]] __device__ inline auto lc_reduce_prod(lc_short2 v) noexcept { return lc_short(v.x*v.y); } +[[nodiscard]] __device__ inline auto lc_reduce_min(lc_short2 v) noexcept { return lc_short(lc_min(v.x, v.y)); } +[[nodiscard]] __device__ inline auto lc_reduce_max(lc_short2 v) noexcept { return lc_short(lc_max(v.x, v.y)); } +[[nodiscard]] __device__ inline auto lc_reduce_sum(lc_short3 v) noexcept { return lc_short(v.x+v.y+v.z); } +[[nodiscard]] __device__ inline auto lc_reduce_prod(lc_short3 v) noexcept { return lc_short(v.x*v.y*v.z); } +[[nodiscard]] __device__ inline auto lc_reduce_min(lc_short3 v) noexcept { return lc_short(lc_min(v.x, lc_min(v.y, v.z))); } +[[nodiscard]] __device__ inline auto lc_reduce_max(lc_short3 v) noexcept { return lc_short(lc_max(v.x, lc_max(v.y, v.z))); } +[[nodiscard]] __device__ inline auto lc_reduce_sum(lc_short4 v) noexcept { return lc_short(v.x+v.y+v.z+v.w); } +[[nodiscard]] __device__ inline auto lc_reduce_prod(lc_short4 v) noexcept { return lc_short(v.x*v.y*v.z*v.w); } +[[nodiscard]] __device__ inline auto lc_reduce_min(lc_short4 v) noexcept { return lc_short(lc_min(v.x, lc_min(v.y, lc_min(v.z, v.w)))); } +[[nodiscard]] __device__ inline auto lc_reduce_max(lc_short4 v) noexcept { return lc_short(lc_max(v.x, lc_max(v.y, lc_max(v.z, v.w)))); } +[[nodiscard]] __device__ inline auto lc_reduce_sum(lc_ushort2 v) noexcept { return lc_ushort(v.x+v.y); } +[[nodiscard]] __device__ inline auto lc_reduce_prod(lc_ushort2 v) noexcept { return lc_ushort(v.x*v.y); } +[[nodiscard]] __device__ inline auto lc_reduce_min(lc_ushort2 v) noexcept { return lc_ushort(lc_min(v.x, v.y)); } +[[nodiscard]] __device__ inline auto lc_reduce_max(lc_ushort2 v) noexcept { return lc_ushort(lc_max(v.x, v.y)); } +[[nodiscard]] __device__ inline auto lc_reduce_sum(lc_ushort3 v) noexcept { return lc_ushort(v.x+v.y+v.z); } +[[nodiscard]] __device__ inline auto lc_reduce_prod(lc_ushort3 v) noexcept { return lc_ushort(v.x*v.y*v.z); } +[[nodiscard]] __device__ inline auto lc_reduce_min(lc_ushort3 v) noexcept { return lc_ushort(lc_min(v.x, lc_min(v.y, v.z))); } +[[nodiscard]] __device__ inline auto lc_reduce_max(lc_ushort3 v) noexcept { return lc_ushort(lc_max(v.x, lc_max(v.y, v.z))); } +[[nodiscard]] __device__ inline auto lc_reduce_sum(lc_ushort4 v) noexcept { return lc_ushort(v.x+v.y+v.z+v.w); } +[[nodiscard]] __device__ inline auto lc_reduce_prod(lc_ushort4 v) noexcept { return lc_ushort(v.x*v.y*v.z*v.w); } +[[nodiscard]] __device__ inline auto lc_reduce_min(lc_ushort4 v) noexcept { return lc_ushort(lc_min(v.x, lc_min(v.y, lc_min(v.z, v.w)))); } +[[nodiscard]] __device__ inline auto lc_reduce_max(lc_ushort4 v) noexcept { return lc_ushort(lc_max(v.x, lc_max(v.y, lc_max(v.z, v.w)))); } +[[nodiscard]] __device__ inline auto lc_reduce_sum(lc_int2 v) noexcept { return lc_int(v.x+v.y); } +[[nodiscard]] __device__ inline auto lc_reduce_prod(lc_int2 v) noexcept { return lc_int(v.x*v.y); } +[[nodiscard]] __device__ inline auto lc_reduce_min(lc_int2 v) noexcept { return lc_int(lc_min(v.x, v.y)); } +[[nodiscard]] __device__ inline auto lc_reduce_max(lc_int2 v) noexcept { return lc_int(lc_max(v.x, v.y)); } +[[nodiscard]] __device__ inline auto lc_reduce_sum(lc_int3 v) noexcept { return lc_int(v.x+v.y+v.z); } +[[nodiscard]] __device__ inline auto lc_reduce_prod(lc_int3 v) noexcept { return lc_int(v.x*v.y*v.z); } +[[nodiscard]] __device__ inline auto lc_reduce_min(lc_int3 v) noexcept { return lc_int(lc_min(v.x, lc_min(v.y, v.z))); } +[[nodiscard]] __device__ inline auto lc_reduce_max(lc_int3 v) noexcept { return lc_int(lc_max(v.x, lc_max(v.y, v.z))); } +[[nodiscard]] __device__ inline auto lc_reduce_sum(lc_int4 v) noexcept { return lc_int(v.x+v.y+v.z+v.w); } +[[nodiscard]] __device__ inline auto lc_reduce_prod(lc_int4 v) noexcept { return lc_int(v.x*v.y*v.z*v.w); } +[[nodiscard]] __device__ inline auto lc_reduce_min(lc_int4 v) noexcept { return lc_int(lc_min(v.x, lc_min(v.y, lc_min(v.z, v.w)))); } +[[nodiscard]] __device__ inline auto lc_reduce_max(lc_int4 v) noexcept { return lc_int(lc_max(v.x, lc_max(v.y, lc_max(v.z, v.w)))); } +[[nodiscard]] __device__ inline auto lc_reduce_sum(lc_uint2 v) noexcept { return lc_uint(v.x+v.y); } +[[nodiscard]] __device__ inline auto lc_reduce_prod(lc_uint2 v) noexcept { return lc_uint(v.x*v.y); } +[[nodiscard]] __device__ inline auto lc_reduce_min(lc_uint2 v) noexcept { return lc_uint(lc_min(v.x, v.y)); } +[[nodiscard]] __device__ inline auto lc_reduce_max(lc_uint2 v) noexcept { return lc_uint(lc_max(v.x, v.y)); } +[[nodiscard]] __device__ inline auto lc_reduce_sum(lc_uint3 v) noexcept { return lc_uint(v.x+v.y+v.z); } +[[nodiscard]] __device__ inline auto lc_reduce_prod(lc_uint3 v) noexcept { return lc_uint(v.x*v.y*v.z); } +[[nodiscard]] __device__ inline auto lc_reduce_min(lc_uint3 v) noexcept { return lc_uint(lc_min(v.x, lc_min(v.y, v.z))); } +[[nodiscard]] __device__ inline auto lc_reduce_max(lc_uint3 v) noexcept { return lc_uint(lc_max(v.x, lc_max(v.y, v.z))); } +[[nodiscard]] __device__ inline auto lc_reduce_sum(lc_uint4 v) noexcept { return lc_uint(v.x+v.y+v.z+v.w); } +[[nodiscard]] __device__ inline auto lc_reduce_prod(lc_uint4 v) noexcept { return lc_uint(v.x*v.y*v.z*v.w); } +[[nodiscard]] __device__ inline auto lc_reduce_min(lc_uint4 v) noexcept { return lc_uint(lc_min(v.x, lc_min(v.y, lc_min(v.z, v.w)))); } +[[nodiscard]] __device__ inline auto lc_reduce_max(lc_uint4 v) noexcept { return lc_uint(lc_max(v.x, lc_max(v.y, lc_max(v.z, v.w)))); } +[[nodiscard]] __device__ inline auto lc_reduce_sum(lc_half2 v) noexcept { return lc_half(v.x+v.y); } +[[nodiscard]] __device__ inline auto lc_reduce_prod(lc_half2 v) noexcept { return lc_half(v.x*v.y); } +[[nodiscard]] __device__ inline auto lc_reduce_min(lc_half2 v) noexcept { return lc_half(lc_min(v.x, v.y)); } +[[nodiscard]] __device__ inline auto lc_reduce_max(lc_half2 v) noexcept { return lc_half(lc_max(v.x, v.y)); } +[[nodiscard]] __device__ inline auto lc_reduce_sum(lc_half3 v) noexcept { return lc_half(v.x+v.y+v.z); } +[[nodiscard]] __device__ inline auto lc_reduce_prod(lc_half3 v) noexcept { return lc_half(v.x*v.y*v.z); } +[[nodiscard]] __device__ inline auto lc_reduce_min(lc_half3 v) noexcept { return lc_half(lc_min(v.x, lc_min(v.y, v.z))); } +[[nodiscard]] __device__ inline auto lc_reduce_max(lc_half3 v) noexcept { return lc_half(lc_max(v.x, lc_max(v.y, v.z))); } +[[nodiscard]] __device__ inline auto lc_reduce_sum(lc_half4 v) noexcept { return lc_half(v.x+v.y+v.z+v.w); } +[[nodiscard]] __device__ inline auto lc_reduce_prod(lc_half4 v) noexcept { return lc_half(v.x*v.y*v.z*v.w); } +[[nodiscard]] __device__ inline auto lc_reduce_min(lc_half4 v) noexcept { return lc_half(lc_min(v.x, lc_min(v.y, lc_min(v.z, v.w)))); } +[[nodiscard]] __device__ inline auto lc_reduce_max(lc_half4 v) noexcept { return lc_half(lc_max(v.x, lc_max(v.y, lc_max(v.z, v.w)))); } +[[nodiscard]] __device__ inline auto lc_reduce_sum(lc_float2 v) noexcept { return lc_float(v.x+v.y); } +[[nodiscard]] __device__ inline auto lc_reduce_prod(lc_float2 v) noexcept { return lc_float(v.x*v.y); } +[[nodiscard]] __device__ inline auto lc_reduce_min(lc_float2 v) noexcept { return lc_float(lc_min(v.x, v.y)); } +[[nodiscard]] __device__ inline auto lc_reduce_max(lc_float2 v) noexcept { return lc_float(lc_max(v.x, v.y)); } +[[nodiscard]] __device__ inline auto lc_reduce_sum(lc_float3 v) noexcept { return lc_float(v.x+v.y+v.z); } +[[nodiscard]] __device__ inline auto lc_reduce_prod(lc_float3 v) noexcept { return lc_float(v.x*v.y*v.z); } +[[nodiscard]] __device__ inline auto lc_reduce_min(lc_float3 v) noexcept { return lc_float(lc_min(v.x, lc_min(v.y, v.z))); } +[[nodiscard]] __device__ inline auto lc_reduce_max(lc_float3 v) noexcept { return lc_float(lc_max(v.x, lc_max(v.y, v.z))); } +[[nodiscard]] __device__ inline auto lc_reduce_sum(lc_float4 v) noexcept { return lc_float(v.x+v.y+v.z+v.w); } +[[nodiscard]] __device__ inline auto lc_reduce_prod(lc_float4 v) noexcept { return lc_float(v.x*v.y*v.z*v.w); } +[[nodiscard]] __device__ inline auto lc_reduce_min(lc_float4 v) noexcept { return lc_float(lc_min(v.x, lc_min(v.y, lc_min(v.z, v.w)))); } +[[nodiscard]] __device__ inline auto lc_reduce_max(lc_float4 v) noexcept { return lc_float(lc_max(v.x, lc_max(v.y, lc_max(v.z, v.w)))); } +[[nodiscard]] __device__ inline auto lc_reduce_sum(lc_long2 v) noexcept { return lc_long(v.x+v.y); } +[[nodiscard]] __device__ inline auto lc_reduce_prod(lc_long2 v) noexcept { return lc_long(v.x*v.y); } +[[nodiscard]] __device__ inline auto lc_reduce_min(lc_long2 v) noexcept { return lc_long(lc_min(v.x, v.y)); } +[[nodiscard]] __device__ inline auto lc_reduce_max(lc_long2 v) noexcept { return lc_long(lc_max(v.x, v.y)); } +[[nodiscard]] __device__ inline auto lc_reduce_sum(lc_long3 v) noexcept { return lc_long(v.x+v.y+v.z); } +[[nodiscard]] __device__ inline auto lc_reduce_prod(lc_long3 v) noexcept { return lc_long(v.x*v.y*v.z); } +[[nodiscard]] __device__ inline auto lc_reduce_min(lc_long3 v) noexcept { return lc_long(lc_min(v.x, lc_min(v.y, v.z))); } +[[nodiscard]] __device__ inline auto lc_reduce_max(lc_long3 v) noexcept { return lc_long(lc_max(v.x, lc_max(v.y, v.z))); } +[[nodiscard]] __device__ inline auto lc_reduce_sum(lc_long4 v) noexcept { return lc_long(v.x+v.y+v.z+v.w); } +[[nodiscard]] __device__ inline auto lc_reduce_prod(lc_long4 v) noexcept { return lc_long(v.x*v.y*v.z*v.w); } +[[nodiscard]] __device__ inline auto lc_reduce_min(lc_long4 v) noexcept { return lc_long(lc_min(v.x, lc_min(v.y, lc_min(v.z, v.w)))); } +[[nodiscard]] __device__ inline auto lc_reduce_max(lc_long4 v) noexcept { return lc_long(lc_max(v.x, lc_max(v.y, lc_max(v.z, v.w)))); } +[[nodiscard]] __device__ inline auto lc_reduce_sum(lc_ulong2 v) noexcept { return lc_ulong(v.x+v.y); } +[[nodiscard]] __device__ inline auto lc_reduce_prod(lc_ulong2 v) noexcept { return lc_ulong(v.x*v.y); } +[[nodiscard]] __device__ inline auto lc_reduce_min(lc_ulong2 v) noexcept { return lc_ulong(lc_min(v.x, v.y)); } +[[nodiscard]] __device__ inline auto lc_reduce_max(lc_ulong2 v) noexcept { return lc_ulong(lc_max(v.x, v.y)); } +[[nodiscard]] __device__ inline auto lc_reduce_sum(lc_ulong3 v) noexcept { return lc_ulong(v.x+v.y+v.z); } +[[nodiscard]] __device__ inline auto lc_reduce_prod(lc_ulong3 v) noexcept { return lc_ulong(v.x*v.y*v.z); } +[[nodiscard]] __device__ inline auto lc_reduce_min(lc_ulong3 v) noexcept { return lc_ulong(lc_min(v.x, lc_min(v.y, v.z))); } +[[nodiscard]] __device__ inline auto lc_reduce_max(lc_ulong3 v) noexcept { return lc_ulong(lc_max(v.x, lc_max(v.y, v.z))); } +[[nodiscard]] __device__ inline auto lc_reduce_sum(lc_ulong4 v) noexcept { return lc_ulong(v.x+v.y+v.z+v.w); } +[[nodiscard]] __device__ inline auto lc_reduce_prod(lc_ulong4 v) noexcept { return lc_ulong(v.x*v.y*v.z*v.w); } +[[nodiscard]] __device__ inline auto lc_reduce_min(lc_ulong4 v) noexcept { return lc_ulong(lc_min(v.x, lc_min(v.y, lc_min(v.z, v.w)))); } +[[nodiscard]] __device__ inline auto lc_reduce_max(lc_ulong4 v) noexcept { return lc_ulong(lc_max(v.x, lc_max(v.y, lc_max(v.z, v.w)))); } +[[nodiscard]] __device__ inline auto lc_min_impl(lc_short a, lc_short b) noexcept { return a < b ? a : b; } +[[nodiscard]] __device__ inline auto lc_max_impl(lc_short a, lc_short b) noexcept { return a > b ? a : b; } +[[nodiscard]] __device__ inline auto lc_min_impl(lc_ushort a, lc_ushort b) noexcept { return a < b ? a : b; } +[[nodiscard]] __device__ inline auto lc_max_impl(lc_ushort a, lc_ushort b) noexcept { return a > b ? a : b; } +[[nodiscard]] __device__ inline auto lc_min_impl(lc_int a, lc_int b) noexcept { return a < b ? a : b; } +[[nodiscard]] __device__ inline auto lc_max_impl(lc_int a, lc_int b) noexcept { return a > b ? a : b; } +[[nodiscard]] __device__ inline auto lc_min_impl(lc_uint a, lc_uint b) noexcept { return a < b ? a : b; } +[[nodiscard]] __device__ inline auto lc_max_impl(lc_uint a, lc_uint b) noexcept { return a > b ? a : b; } +[[nodiscard]] __device__ inline auto lc_min_impl(lc_long a, lc_long b) noexcept { return a < b ? a : b; } +[[nodiscard]] __device__ inline auto lc_max_impl(lc_long a, lc_long b) noexcept { return a > b ? a : b; } +[[nodiscard]] __device__ inline auto lc_min_impl(lc_ulong a, lc_ulong b) noexcept { return a < b ? a : b; } +[[nodiscard]] __device__ inline auto lc_max_impl(lc_ulong a, lc_ulong b) noexcept { return a > b ? a : b; } +[[nodiscard]] __device__ inline lc_short lc_min(lc_short a, lc_short b) noexcept { return lc_min_impl(a, b); } +[[nodiscard]] __device__ inline lc_short2 lc_min(lc_short2 a, lc_short2 b) noexcept { return lc_make_short2(lc_min_impl(a.x, b.x), lc_min_impl(a.y, b.y)); } +[[nodiscard]] __device__ inline lc_short3 lc_min(lc_short3 a, lc_short3 b) noexcept { return lc_make_short3(lc_min_impl(a.x, b.x), lc_min_impl(a.y, b.y), lc_min_impl(a.z, b.z)); } +[[nodiscard]] __device__ inline lc_short4 lc_min(lc_short4 a, lc_short4 b) noexcept { return lc_make_short4(lc_min_impl(a.x, b.x), lc_min_impl(a.y, b.y), lc_min_impl(a.z, b.z), lc_min_impl(a.w, b.w)); } +[[nodiscard]] __device__ inline lc_ushort lc_min(lc_ushort a, lc_ushort b) noexcept { return lc_min_impl(a, b); } +[[nodiscard]] __device__ inline lc_ushort2 lc_min(lc_ushort2 a, lc_ushort2 b) noexcept { return lc_make_ushort2(lc_min_impl(a.x, b.x), lc_min_impl(a.y, b.y)); } +[[nodiscard]] __device__ inline lc_ushort3 lc_min(lc_ushort3 a, lc_ushort3 b) noexcept { return lc_make_ushort3(lc_min_impl(a.x, b.x), lc_min_impl(a.y, b.y), lc_min_impl(a.z, b.z)); } +[[nodiscard]] __device__ inline lc_ushort4 lc_min(lc_ushort4 a, lc_ushort4 b) noexcept { return lc_make_ushort4(lc_min_impl(a.x, b.x), lc_min_impl(a.y, b.y), lc_min_impl(a.z, b.z), lc_min_impl(a.w, b.w)); } +[[nodiscard]] __device__ inline lc_int lc_min(lc_int a, lc_int b) noexcept { return lc_min_impl(a, b); } +[[nodiscard]] __device__ inline lc_int2 lc_min(lc_int2 a, lc_int2 b) noexcept { return lc_make_int2(lc_min_impl(a.x, b.x), lc_min_impl(a.y, b.y)); } +[[nodiscard]] __device__ inline lc_int3 lc_min(lc_int3 a, lc_int3 b) noexcept { return lc_make_int3(lc_min_impl(a.x, b.x), lc_min_impl(a.y, b.y), lc_min_impl(a.z, b.z)); } +[[nodiscard]] __device__ inline lc_int4 lc_min(lc_int4 a, lc_int4 b) noexcept { return lc_make_int4(lc_min_impl(a.x, b.x), lc_min_impl(a.y, b.y), lc_min_impl(a.z, b.z), lc_min_impl(a.w, b.w)); } +[[nodiscard]] __device__ inline lc_uint lc_min(lc_uint a, lc_uint b) noexcept { return lc_min_impl(a, b); } +[[nodiscard]] __device__ inline lc_uint2 lc_min(lc_uint2 a, lc_uint2 b) noexcept { return lc_make_uint2(lc_min_impl(a.x, b.x), lc_min_impl(a.y, b.y)); } +[[nodiscard]] __device__ inline lc_uint3 lc_min(lc_uint3 a, lc_uint3 b) noexcept { return lc_make_uint3(lc_min_impl(a.x, b.x), lc_min_impl(a.y, b.y), lc_min_impl(a.z, b.z)); } +[[nodiscard]] __device__ inline lc_uint4 lc_min(lc_uint4 a, lc_uint4 b) noexcept { return lc_make_uint4(lc_min_impl(a.x, b.x), lc_min_impl(a.y, b.y), lc_min_impl(a.z, b.z), lc_min_impl(a.w, b.w)); } +[[nodiscard]] __device__ inline lc_long lc_min(lc_long a, lc_long b) noexcept { return lc_min_impl(a, b); } +[[nodiscard]] __device__ inline lc_long2 lc_min(lc_long2 a, lc_long2 b) noexcept { return lc_make_long2(lc_min_impl(a.x, b.x), lc_min_impl(a.y, b.y)); } +[[nodiscard]] __device__ inline lc_long3 lc_min(lc_long3 a, lc_long3 b) noexcept { return lc_make_long3(lc_min_impl(a.x, b.x), lc_min_impl(a.y, b.y), lc_min_impl(a.z, b.z)); } +[[nodiscard]] __device__ inline lc_long4 lc_min(lc_long4 a, lc_long4 b) noexcept { return lc_make_long4(lc_min_impl(a.x, b.x), lc_min_impl(a.y, b.y), lc_min_impl(a.z, b.z), lc_min_impl(a.w, b.w)); } +[[nodiscard]] __device__ inline lc_ulong lc_min(lc_ulong a, lc_ulong b) noexcept { return lc_min_impl(a, b); } +[[nodiscard]] __device__ inline lc_ulong2 lc_min(lc_ulong2 a, lc_ulong2 b) noexcept { return lc_make_ulong2(lc_min_impl(a.x, b.x), lc_min_impl(a.y, b.y)); } +[[nodiscard]] __device__ inline lc_ulong3 lc_min(lc_ulong3 a, lc_ulong3 b) noexcept { return lc_make_ulong3(lc_min_impl(a.x, b.x), lc_min_impl(a.y, b.y), lc_min_impl(a.z, b.z)); } +[[nodiscard]] __device__ inline lc_ulong4 lc_min(lc_ulong4 a, lc_ulong4 b) noexcept { return lc_make_ulong4(lc_min_impl(a.x, b.x), lc_min_impl(a.y, b.y), lc_min_impl(a.z, b.z), lc_min_impl(a.w, b.w)); } + +[[nodiscard]] __device__ inline lc_short lc_max(lc_short a, lc_short b) noexcept { return lc_max_impl(a, b); } +[[nodiscard]] __device__ inline lc_short2 lc_max(lc_short2 a, lc_short2 b) noexcept { return lc_make_short2(lc_max_impl(a.x, b.x), lc_max_impl(a.y, b.y)); } +[[nodiscard]] __device__ inline lc_short3 lc_max(lc_short3 a, lc_short3 b) noexcept { return lc_make_short3(lc_max_impl(a.x, b.x), lc_max_impl(a.y, b.y), lc_max_impl(a.z, b.z)); } +[[nodiscard]] __device__ inline lc_short4 lc_max(lc_short4 a, lc_short4 b) noexcept { return lc_make_short4(lc_max_impl(a.x, b.x), lc_max_impl(a.y, b.y), lc_max_impl(a.z, b.z), lc_max_impl(a.w, b.w)); } +[[nodiscard]] __device__ inline lc_ushort lc_max(lc_ushort a, lc_ushort b) noexcept { return lc_max_impl(a, b); } +[[nodiscard]] __device__ inline lc_ushort2 lc_max(lc_ushort2 a, lc_ushort2 b) noexcept { return lc_make_ushort2(lc_max_impl(a.x, b.x), lc_max_impl(a.y, b.y)); } +[[nodiscard]] __device__ inline lc_ushort3 lc_max(lc_ushort3 a, lc_ushort3 b) noexcept { return lc_make_ushort3(lc_max_impl(a.x, b.x), lc_max_impl(a.y, b.y), lc_max_impl(a.z, b.z)); } +[[nodiscard]] __device__ inline lc_ushort4 lc_max(lc_ushort4 a, lc_ushort4 b) noexcept { return lc_make_ushort4(lc_max_impl(a.x, b.x), lc_max_impl(a.y, b.y), lc_max_impl(a.z, b.z), lc_max_impl(a.w, b.w)); } +[[nodiscard]] __device__ inline lc_int lc_max(lc_int a, lc_int b) noexcept { return lc_max_impl(a, b); } +[[nodiscard]] __device__ inline lc_int2 lc_max(lc_int2 a, lc_int2 b) noexcept { return lc_make_int2(lc_max_impl(a.x, b.x), lc_max_impl(a.y, b.y)); } +[[nodiscard]] __device__ inline lc_int3 lc_max(lc_int3 a, lc_int3 b) noexcept { return lc_make_int3(lc_max_impl(a.x, b.x), lc_max_impl(a.y, b.y), lc_max_impl(a.z, b.z)); } +[[nodiscard]] __device__ inline lc_int4 lc_max(lc_int4 a, lc_int4 b) noexcept { return lc_make_int4(lc_max_impl(a.x, b.x), lc_max_impl(a.y, b.y), lc_max_impl(a.z, b.z), lc_max_impl(a.w, b.w)); } +[[nodiscard]] __device__ inline lc_uint lc_max(lc_uint a, lc_uint b) noexcept { return lc_max_impl(a, b); } +[[nodiscard]] __device__ inline lc_uint2 lc_max(lc_uint2 a, lc_uint2 b) noexcept { return lc_make_uint2(lc_max_impl(a.x, b.x), lc_max_impl(a.y, b.y)); } +[[nodiscard]] __device__ inline lc_uint3 lc_max(lc_uint3 a, lc_uint3 b) noexcept { return lc_make_uint3(lc_max_impl(a.x, b.x), lc_max_impl(a.y, b.y), lc_max_impl(a.z, b.z)); } +[[nodiscard]] __device__ inline lc_uint4 lc_max(lc_uint4 a, lc_uint4 b) noexcept { return lc_make_uint4(lc_max_impl(a.x, b.x), lc_max_impl(a.y, b.y), lc_max_impl(a.z, b.z), lc_max_impl(a.w, b.w)); } +[[nodiscard]] __device__ inline lc_long lc_max(lc_long a, lc_long b) noexcept { return lc_max_impl(a, b); } +[[nodiscard]] __device__ inline lc_long2 lc_max(lc_long2 a, lc_long2 b) noexcept { return lc_make_long2(lc_max_impl(a.x, b.x), lc_max_impl(a.y, b.y)); } +[[nodiscard]] __device__ inline lc_long3 lc_max(lc_long3 a, lc_long3 b) noexcept { return lc_make_long3(lc_max_impl(a.x, b.x), lc_max_impl(a.y, b.y), lc_max_impl(a.z, b.z)); } +[[nodiscard]] __device__ inline lc_long4 lc_max(lc_long4 a, lc_long4 b) noexcept { return lc_make_long4(lc_max_impl(a.x, b.x), lc_max_impl(a.y, b.y), lc_max_impl(a.z, b.z), lc_max_impl(a.w, b.w)); } +[[nodiscard]] __device__ inline lc_ulong lc_max(lc_ulong a, lc_ulong b) noexcept { return lc_max_impl(a, b); } +[[nodiscard]] __device__ inline lc_ulong2 lc_max(lc_ulong2 a, lc_ulong2 b) noexcept { return lc_make_ulong2(lc_max_impl(a.x, b.x), lc_max_impl(a.y, b.y)); } +[[nodiscard]] __device__ inline lc_ulong3 lc_max(lc_ulong3 a, lc_ulong3 b) noexcept { return lc_make_ulong3(lc_max_impl(a.x, b.x), lc_max_impl(a.y, b.y), lc_max_impl(a.z, b.z)); } +[[nodiscard]] __device__ inline lc_ulong4 lc_max(lc_ulong4 a, lc_ulong4 b) noexcept { return lc_make_ulong4(lc_max_impl(a.x, b.x), lc_max_impl(a.y, b.y), lc_max_impl(a.z, b.z), lc_max_impl(a.w, b.w)); } + +[[nodiscard]] __device__ inline auto lc_clamp_impl(lc_short v, lc_short lo, lc_short hi) noexcept { return lc_min(lc_max(v, lo), hi); } +[[nodiscard]] __device__ inline auto lc_clamp_impl(lc_ushort v, lc_ushort lo, lc_ushort hi) noexcept { return lc_min(lc_max(v, lo), hi); } +[[nodiscard]] __device__ inline auto lc_clamp_impl(lc_int v, lc_int lo, lc_int hi) noexcept { return lc_min(lc_max(v, lo), hi); } +[[nodiscard]] __device__ inline auto lc_clamp_impl(lc_uint v, lc_uint lo, lc_uint hi) noexcept { return lc_min(lc_max(v, lo), hi); } +[[nodiscard]] __device__ inline auto lc_clamp_impl(lc_half v, lc_half lo, lc_half hi) noexcept { return lc_min(lc_max(v, lo), hi); } +[[nodiscard]] __device__ inline auto lc_clamp_impl(lc_float v, lc_float lo, lc_float hi) noexcept { return lc_min(lc_max(v, lo), hi); } +[[nodiscard]] __device__ inline auto lc_clamp_impl(lc_long v, lc_long lo, lc_long hi) noexcept { return lc_min(lc_max(v, lo), hi); } +[[nodiscard]] __device__ inline auto lc_clamp_impl(lc_ulong v, lc_ulong lo, lc_ulong hi) noexcept { return lc_min(lc_max(v, lo), hi); } +[[nodiscard]] __device__ inline lc_short lc_clamp(lc_short v, lc_short lo, lc_short hi) noexcept { return lc_clamp_impl(v, lo, hi); } +[[nodiscard]] __device__ inline lc_short2 lc_clamp(lc_short2 v, lc_short2 lo, lc_short2 hi) noexcept { return lc_make_short2(lc_clamp_impl(v.x, lo.x, hi.x), lc_clamp_impl(v.y, lo.y, hi.y)); } +[[nodiscard]] __device__ inline lc_short3 lc_clamp(lc_short3 v, lc_short3 lo, lc_short3 hi) noexcept { return lc_make_short3(lc_clamp_impl(v.x, lo.x, hi.x), lc_clamp_impl(v.y, lo.y, hi.y), lc_clamp_impl(v.z, lo.z, hi.z)); } +[[nodiscard]] __device__ inline lc_short4 lc_clamp(lc_short4 v, lc_short4 lo, lc_short4 hi) noexcept { return lc_make_short4(lc_clamp_impl(v.x, lo.x, hi.x), lc_clamp_impl(v.y, lo.y, hi.y), lc_clamp_impl(v.z, lo.z, hi.z), lc_clamp_impl(v.w, lo.w, hi.w)); } +[[nodiscard]] __device__ inline lc_ushort lc_clamp(lc_ushort v, lc_ushort lo, lc_ushort hi) noexcept { return lc_clamp_impl(v, lo, hi); } +[[nodiscard]] __device__ inline lc_ushort2 lc_clamp(lc_ushort2 v, lc_ushort2 lo, lc_ushort2 hi) noexcept { return lc_make_ushort2(lc_clamp_impl(v.x, lo.x, hi.x), lc_clamp_impl(v.y, lo.y, hi.y)); } +[[nodiscard]] __device__ inline lc_ushort3 lc_clamp(lc_ushort3 v, lc_ushort3 lo, lc_ushort3 hi) noexcept { return lc_make_ushort3(lc_clamp_impl(v.x, lo.x, hi.x), lc_clamp_impl(v.y, lo.y, hi.y), lc_clamp_impl(v.z, lo.z, hi.z)); } +[[nodiscard]] __device__ inline lc_ushort4 lc_clamp(lc_ushort4 v, lc_ushort4 lo, lc_ushort4 hi) noexcept { return lc_make_ushort4(lc_clamp_impl(v.x, lo.x, hi.x), lc_clamp_impl(v.y, lo.y, hi.y), lc_clamp_impl(v.z, lo.z, hi.z), lc_clamp_impl(v.w, lo.w, hi.w)); } +[[nodiscard]] __device__ inline lc_int lc_clamp(lc_int v, lc_int lo, lc_int hi) noexcept { return lc_clamp_impl(v, lo, hi); } +[[nodiscard]] __device__ inline lc_int2 lc_clamp(lc_int2 v, lc_int2 lo, lc_int2 hi) noexcept { return lc_make_int2(lc_clamp_impl(v.x, lo.x, hi.x), lc_clamp_impl(v.y, lo.y, hi.y)); } +[[nodiscard]] __device__ inline lc_int3 lc_clamp(lc_int3 v, lc_int3 lo, lc_int3 hi) noexcept { return lc_make_int3(lc_clamp_impl(v.x, lo.x, hi.x), lc_clamp_impl(v.y, lo.y, hi.y), lc_clamp_impl(v.z, lo.z, hi.z)); } +[[nodiscard]] __device__ inline lc_int4 lc_clamp(lc_int4 v, lc_int4 lo, lc_int4 hi) noexcept { return lc_make_int4(lc_clamp_impl(v.x, lo.x, hi.x), lc_clamp_impl(v.y, lo.y, hi.y), lc_clamp_impl(v.z, lo.z, hi.z), lc_clamp_impl(v.w, lo.w, hi.w)); } +[[nodiscard]] __device__ inline lc_uint lc_clamp(lc_uint v, lc_uint lo, lc_uint hi) noexcept { return lc_clamp_impl(v, lo, hi); } +[[nodiscard]] __device__ inline lc_uint2 lc_clamp(lc_uint2 v, lc_uint2 lo, lc_uint2 hi) noexcept { return lc_make_uint2(lc_clamp_impl(v.x, lo.x, hi.x), lc_clamp_impl(v.y, lo.y, hi.y)); } +[[nodiscard]] __device__ inline lc_uint3 lc_clamp(lc_uint3 v, lc_uint3 lo, lc_uint3 hi) noexcept { return lc_make_uint3(lc_clamp_impl(v.x, lo.x, hi.x), lc_clamp_impl(v.y, lo.y, hi.y), lc_clamp_impl(v.z, lo.z, hi.z)); } +[[nodiscard]] __device__ inline lc_uint4 lc_clamp(lc_uint4 v, lc_uint4 lo, lc_uint4 hi) noexcept { return lc_make_uint4(lc_clamp_impl(v.x, lo.x, hi.x), lc_clamp_impl(v.y, lo.y, hi.y), lc_clamp_impl(v.z, lo.z, hi.z), lc_clamp_impl(v.w, lo.w, hi.w)); } +[[nodiscard]] __device__ inline lc_long lc_clamp(lc_long v, lc_long lo, lc_long hi) noexcept { return lc_clamp_impl(v, lo, hi); } +[[nodiscard]] __device__ inline lc_long2 lc_clamp(lc_long2 v, lc_long2 lo, lc_long2 hi) noexcept { return lc_make_long2(lc_clamp_impl(v.x, lo.x, hi.x), lc_clamp_impl(v.y, lo.y, hi.y)); } +[[nodiscard]] __device__ inline lc_long3 lc_clamp(lc_long3 v, lc_long3 lo, lc_long3 hi) noexcept { return lc_make_long3(lc_clamp_impl(v.x, lo.x, hi.x), lc_clamp_impl(v.y, lo.y, hi.y), lc_clamp_impl(v.z, lo.z, hi.z)); } +[[nodiscard]] __device__ inline lc_long4 lc_clamp(lc_long4 v, lc_long4 lo, lc_long4 hi) noexcept { return lc_make_long4(lc_clamp_impl(v.x, lo.x, hi.x), lc_clamp_impl(v.y, lo.y, hi.y), lc_clamp_impl(v.z, lo.z, hi.z), lc_clamp_impl(v.w, lo.w, hi.w)); } +[[nodiscard]] __device__ inline lc_ulong lc_clamp(lc_ulong v, lc_ulong lo, lc_ulong hi) noexcept { return lc_clamp_impl(v, lo, hi); } +[[nodiscard]] __device__ inline lc_ulong2 lc_clamp(lc_ulong2 v, lc_ulong2 lo, lc_ulong2 hi) noexcept { return lc_make_ulong2(lc_clamp_impl(v.x, lo.x, hi.x), lc_clamp_impl(v.y, lo.y, hi.y)); } +[[nodiscard]] __device__ inline lc_ulong3 lc_clamp(lc_ulong3 v, lc_ulong3 lo, lc_ulong3 hi) noexcept { return lc_make_ulong3(lc_clamp_impl(v.x, lo.x, hi.x), lc_clamp_impl(v.y, lo.y, hi.y), lc_clamp_impl(v.z, lo.z, hi.z)); } +[[nodiscard]] __device__ inline lc_ulong4 lc_clamp(lc_ulong4 v, lc_ulong4 lo, lc_ulong4 hi) noexcept { return lc_make_ulong4(lc_clamp_impl(v.x, lo.x, hi.x), lc_clamp_impl(v.y, lo.y, hi.y), lc_clamp_impl(v.z, lo.z, hi.z), lc_clamp_impl(v.w, lo.w, hi.w)); } +[[nodiscard]] __device__ inline lc_half lc_clamp(lc_half v, lc_half lo, lc_half hi) noexcept { return lc_clamp_impl(v, lo, hi); } +[[nodiscard]] __device__ inline lc_half2 lc_clamp(lc_half2 v, lc_half2 lo, lc_half2 hi) noexcept { return lc_make_half2(lc_clamp_impl(v.x, lo.x, hi.x), lc_clamp_impl(v.y, lo.y, hi.y)); } +[[nodiscard]] __device__ inline lc_half3 lc_clamp(lc_half3 v, lc_half3 lo, lc_half3 hi) noexcept { return lc_make_half3(lc_clamp_impl(v.x, lo.x, hi.x), lc_clamp_impl(v.y, lo.y, hi.y), lc_clamp_impl(v.z, lo.z, hi.z)); } +[[nodiscard]] __device__ inline lc_half4 lc_clamp(lc_half4 v, lc_half4 lo, lc_half4 hi) noexcept { return lc_make_half4(lc_clamp_impl(v.x, lo.x, hi.x), lc_clamp_impl(v.y, lo.y, hi.y), lc_clamp_impl(v.z, lo.z, hi.z), lc_clamp_impl(v.w, lo.w, hi.w)); } +[[nodiscard]] __device__ inline lc_float lc_clamp(lc_float v, lc_float lo, lc_float hi) noexcept { return lc_clamp_impl(v, lo, hi); } +[[nodiscard]] __device__ inline lc_float2 lc_clamp(lc_float2 v, lc_float2 lo, lc_float2 hi) noexcept { return lc_make_float2(lc_clamp_impl(v.x, lo.x, hi.x), lc_clamp_impl(v.y, lo.y, hi.y)); } +[[nodiscard]] __device__ inline lc_float3 lc_clamp(lc_float3 v, lc_float3 lo, lc_float3 hi) noexcept { return lc_make_float3(lc_clamp_impl(v.x, lo.x, hi.x), lc_clamp_impl(v.y, lo.y, hi.y), lc_clamp_impl(v.z, lo.z, hi.z)); } +[[nodiscard]] __device__ inline lc_float4 lc_clamp(lc_float4 v, lc_float4 lo, lc_float4 hi) noexcept { return lc_make_float4(lc_clamp_impl(v.x, lo.x, hi.x), lc_clamp_impl(v.y, lo.y, hi.y), lc_clamp_impl(v.z, lo.z, hi.z), lc_clamp_impl(v.w, lo.w, hi.w)); } + +[[nodiscard]] __device__ inline auto lc_lerp_impl(lc_half a, lc_half b, lc_half t) noexcept { return t * (b - a) + a; } +[[nodiscard]] __device__ inline auto lc_saturate(lc_half x) noexcept { return lc_clamp(x, lc_half(0.0f), lc_half(1.0f)); } +[[nodiscard]] __device__ inline auto lc_saturate(lc_half2 x) noexcept { return lc_clamp(x, lc_make_half2(0.0f), lc_make_half2(1.0f)); } +[[nodiscard]] __device__ inline auto lc_saturate(lc_half3 x) noexcept { return lc_clamp(x, lc_make_half3(0.0f), lc_make_half3(1.0f)); } +[[nodiscard]] __device__ inline auto lc_saturate(lc_half4 x) noexcept { return lc_clamp(x, lc_make_half4(0.0f), lc_make_half4(1.0f)); } + +[[nodiscard]] __device__ inline auto lc_degrees_impl(lc_half rad) noexcept { return rad * (lc_half)(180.0f * 0.318309886183790671537767526745028724f); } +[[nodiscard]] __device__ inline auto lc_radians_impl(lc_half deg) noexcept { return deg * (lc_half)(3.14159265358979323846264338327950288f / 180.0f); } +[[nodiscard]] __device__ inline auto lc_step_impl(lc_half edge, lc_half x) noexcept { return lc_select(lc_half(1.f), lc_half(0.f), x < edge); } +[[nodiscard]] __device__ inline auto lc_smoothstep_impl(lc_half edge0, lc_half edge1, lc_half x) noexcept { +auto t = lc_clamp((x - edge0) / (edge1 - edge0), lc_half(0.0f), lc_half(1.0f)); +return t * t * (lc_half(3.f) - lc_half(2.f) * t); +} +[[nodiscard]] __device__ inline auto lc_mod_impl(lc_half x, lc_half y) noexcept { return x - y * lc_floor(x / y); } +[[nodiscard]] __device__ inline auto lc_fmod_impl(lc_half x, lc_half y) noexcept { return x - y * lc_trunc(x / y); } +[[nodiscard]] __device__ inline auto lc_fract_impl(lc_half x) noexcept { return x - lc_floor(x); } +[[nodiscard]] __device__ inline auto lc_lerp_impl(lc_float a, lc_float b, lc_float t) noexcept { return t * (b - a) + a; } +[[nodiscard]] __device__ inline auto lc_saturate(lc_float x) noexcept { return lc_clamp(x, lc_float(0.0f), lc_float(1.0f)); } +[[nodiscard]] __device__ inline auto lc_saturate(lc_float2 x) noexcept { return lc_clamp(x, lc_make_float2(0.0f), lc_make_float2(1.0f)); } +[[nodiscard]] __device__ inline auto lc_saturate(lc_float3 x) noexcept { return lc_clamp(x, lc_make_float3(0.0f), lc_make_float3(1.0f)); } +[[nodiscard]] __device__ inline auto lc_saturate(lc_float4 x) noexcept { return lc_clamp(x, lc_make_float4(0.0f), lc_make_float4(1.0f)); } + +[[nodiscard]] __device__ inline auto lc_degrees_impl(lc_float rad) noexcept { return rad * (lc_float)(180.0f * 0.318309886183790671537767526745028724f); } +[[nodiscard]] __device__ inline auto lc_radians_impl(lc_float deg) noexcept { return deg * (lc_float)(3.14159265358979323846264338327950288f / 180.0f); } +[[nodiscard]] __device__ inline auto lc_step_impl(lc_float edge, lc_float x) noexcept { return lc_select(lc_float(1.f), lc_float(0.f), x < edge); } +[[nodiscard]] __device__ inline auto lc_smoothstep_impl(lc_float edge0, lc_float edge1, lc_float x) noexcept { +auto t = lc_clamp((x - edge0) / (edge1 - edge0), lc_float(0.0f), lc_float(1.0f)); +return t * t * (lc_float(3.f) - lc_float(2.f) * t); +} +[[nodiscard]] __device__ inline auto lc_mod_impl(lc_float x, lc_float y) noexcept { return x - y * lc_floor(x / y); } +[[nodiscard]] __device__ inline auto lc_fmod_impl(lc_float x, lc_float y) noexcept { return fmodf(x, y); } +[[nodiscard]] __device__ inline auto lc_fract_impl(lc_float x) noexcept { return x - lc_floor(x); } +[[nodiscard]] __device__ inline lc_half lc_lerp(lc_half a, lc_half b, lc_half t) noexcept { return lc_lerp_impl(a, b, t); } +[[nodiscard]] __device__ inline lc_half2 lc_lerp(lc_half2 a, lc_half2 b, lc_half2 t) noexcept { return lc_make_half2(lc_lerp_impl(a.x, b.x, t.x), lc_lerp_impl(a.y, b.y, t.y)); } +[[nodiscard]] __device__ inline lc_half3 lc_lerp(lc_half3 a, lc_half3 b, lc_half3 t) noexcept { return lc_make_half3(lc_lerp_impl(a.x, b.x, t.x), lc_lerp_impl(a.y, b.y, t.y), lc_lerp_impl(a.z, b.z, t.z)); } +[[nodiscard]] __device__ inline lc_half4 lc_lerp(lc_half4 a, lc_half4 b, lc_half4 t) noexcept { return lc_make_half4(lc_lerp_impl(a.x, b.x, t.x), lc_lerp_impl(a.y, b.y, t.y), lc_lerp_impl(a.z, b.z, t.z), lc_lerp_impl(a.w, b.w, t.w)); } +[[nodiscard]] __device__ inline lc_float lc_lerp(lc_float a, lc_float b, lc_float t) noexcept { return lc_lerp_impl(a, b, t); } +[[nodiscard]] __device__ inline lc_float2 lc_lerp(lc_float2 a, lc_float2 b, lc_float2 t) noexcept { return lc_make_float2(lc_lerp_impl(a.x, b.x, t.x), lc_lerp_impl(a.y, b.y, t.y)); } +[[nodiscard]] __device__ inline lc_float3 lc_lerp(lc_float3 a, lc_float3 b, lc_float3 t) noexcept { return lc_make_float3(lc_lerp_impl(a.x, b.x, t.x), lc_lerp_impl(a.y, b.y, t.y), lc_lerp_impl(a.z, b.z, t.z)); } +[[nodiscard]] __device__ inline lc_float4 lc_lerp(lc_float4 a, lc_float4 b, lc_float4 t) noexcept { return lc_make_float4(lc_lerp_impl(a.x, b.x, t.x), lc_lerp_impl(a.y, b.y, t.y), lc_lerp_impl(a.z, b.z, t.z), lc_lerp_impl(a.w, b.w, t.w)); } + +[[nodiscard]] __device__ inline lc_half lc_degrees(lc_half rad) noexcept { return lc_degrees_impl(rad); } +[[nodiscard]] __device__ inline lc_half2 lc_degrees(lc_half2 rad) noexcept { return lc_make_half2(lc_degrees_impl(rad.x), lc_degrees_impl(rad.y)); } +[[nodiscard]] __device__ inline lc_half3 lc_degrees(lc_half3 rad) noexcept { return lc_make_half3(lc_degrees_impl(rad.x), lc_degrees_impl(rad.y), lc_degrees_impl(rad.z)); } +[[nodiscard]] __device__ inline lc_half4 lc_degrees(lc_half4 rad) noexcept { return lc_make_half4(lc_degrees_impl(rad.x), lc_degrees_impl(rad.y), lc_degrees_impl(rad.z), lc_degrees_impl(rad.w)); } +[[nodiscard]] __device__ inline lc_float lc_degrees(lc_float rad) noexcept { return lc_degrees_impl(rad); } +[[nodiscard]] __device__ inline lc_float2 lc_degrees(lc_float2 rad) noexcept { return lc_make_float2(lc_degrees_impl(rad.x), lc_degrees_impl(rad.y)); } +[[nodiscard]] __device__ inline lc_float3 lc_degrees(lc_float3 rad) noexcept { return lc_make_float3(lc_degrees_impl(rad.x), lc_degrees_impl(rad.y), lc_degrees_impl(rad.z)); } +[[nodiscard]] __device__ inline lc_float4 lc_degrees(lc_float4 rad) noexcept { return lc_make_float4(lc_degrees_impl(rad.x), lc_degrees_impl(rad.y), lc_degrees_impl(rad.z), lc_degrees_impl(rad.w)); } + +[[nodiscard]] __device__ inline lc_half lc_radians(lc_half deg) noexcept { return lc_radians_impl(deg); } +[[nodiscard]] __device__ inline lc_half2 lc_radians(lc_half2 deg) noexcept { return lc_make_half2(lc_radians_impl(deg.x), lc_radians_impl(deg.y)); } +[[nodiscard]] __device__ inline lc_half3 lc_radians(lc_half3 deg) noexcept { return lc_make_half3(lc_radians_impl(deg.x), lc_radians_impl(deg.y), lc_radians_impl(deg.z)); } +[[nodiscard]] __device__ inline lc_half4 lc_radians(lc_half4 deg) noexcept { return lc_make_half4(lc_radians_impl(deg.x), lc_radians_impl(deg.y), lc_radians_impl(deg.z), lc_radians_impl(deg.w)); } +[[nodiscard]] __device__ inline lc_float lc_radians(lc_float deg) noexcept { return lc_radians_impl(deg); } +[[nodiscard]] __device__ inline lc_float2 lc_radians(lc_float2 deg) noexcept { return lc_make_float2(lc_radians_impl(deg.x), lc_radians_impl(deg.y)); } +[[nodiscard]] __device__ inline lc_float3 lc_radians(lc_float3 deg) noexcept { return lc_make_float3(lc_radians_impl(deg.x), lc_radians_impl(deg.y), lc_radians_impl(deg.z)); } +[[nodiscard]] __device__ inline lc_float4 lc_radians(lc_float4 deg) noexcept { return lc_make_float4(lc_radians_impl(deg.x), lc_radians_impl(deg.y), lc_radians_impl(deg.z), lc_radians_impl(deg.w)); } + +[[nodiscard]] __device__ inline lc_half lc_step(lc_half edge, lc_half x) noexcept { return lc_step_impl(edge, x); } +[[nodiscard]] __device__ inline lc_half2 lc_step(lc_half2 edge, lc_half2 x) noexcept { return lc_make_half2(lc_step_impl(edge.x, x.x), lc_step_impl(edge.y, x.y)); } +[[nodiscard]] __device__ inline lc_half3 lc_step(lc_half3 edge, lc_half3 x) noexcept { return lc_make_half3(lc_step_impl(edge.x, x.x), lc_step_impl(edge.y, x.y), lc_step_impl(edge.z, x.z)); } +[[nodiscard]] __device__ inline lc_half4 lc_step(lc_half4 edge, lc_half4 x) noexcept { return lc_make_half4(lc_step_impl(edge.x, x.x), lc_step_impl(edge.y, x.y), lc_step_impl(edge.z, x.z), lc_step_impl(edge.w, x.w)); } +[[nodiscard]] __device__ inline lc_float lc_step(lc_float edge, lc_float x) noexcept { return lc_step_impl(edge, x); } +[[nodiscard]] __device__ inline lc_float2 lc_step(lc_float2 edge, lc_float2 x) noexcept { return lc_make_float2(lc_step_impl(edge.x, x.x), lc_step_impl(edge.y, x.y)); } +[[nodiscard]] __device__ inline lc_float3 lc_step(lc_float3 edge, lc_float3 x) noexcept { return lc_make_float3(lc_step_impl(edge.x, x.x), lc_step_impl(edge.y, x.y), lc_step_impl(edge.z, x.z)); } +[[nodiscard]] __device__ inline lc_float4 lc_step(lc_float4 edge, lc_float4 x) noexcept { return lc_make_float4(lc_step_impl(edge.x, x.x), lc_step_impl(edge.y, x.y), lc_step_impl(edge.z, x.z), lc_step_impl(edge.w, x.w)); } + +[[nodiscard]] __device__ inline lc_half lc_smoothstep(lc_half e0, lc_half e1, lc_half x) noexcept { return lc_smoothstep_impl(e0, e1, x); } +[[nodiscard]] __device__ inline lc_half2 lc_smoothstep(lc_half2 e0, lc_half2 e1, lc_half2 x) noexcept { return lc_make_half2(lc_smoothstep_impl(e0.x, e1.x, x.x), lc_smoothstep_impl(e0.y, e1.y, x.y)); } +[[nodiscard]] __device__ inline lc_half3 lc_smoothstep(lc_half3 e0, lc_half3 e1, lc_half3 x) noexcept { return lc_make_half3(lc_smoothstep_impl(e0.x, e1.x, x.x), lc_smoothstep_impl(e0.y, e1.y, x.y), lc_smoothstep_impl(e0.z, e1.z, x.z)); } +[[nodiscard]] __device__ inline lc_half4 lc_smoothstep(lc_half4 e0, lc_half4 e1, lc_half4 x) noexcept { return lc_make_half4(lc_smoothstep_impl(e0.x, e1.x, x.x), lc_smoothstep_impl(e0.y, e1.y, x.y), lc_smoothstep_impl(e0.z, e1.z, x.z), lc_smoothstep_impl(e0.w, e1.w, x.w)); } +[[nodiscard]] __device__ inline lc_float lc_smoothstep(lc_float e0, lc_float e1, lc_float x) noexcept { return lc_smoothstep_impl(e0, e1, x); } +[[nodiscard]] __device__ inline lc_float2 lc_smoothstep(lc_float2 e0, lc_float2 e1, lc_float2 x) noexcept { return lc_make_float2(lc_smoothstep_impl(e0.x, e1.x, x.x), lc_smoothstep_impl(e0.y, e1.y, x.y)); } +[[nodiscard]] __device__ inline lc_float3 lc_smoothstep(lc_float3 e0, lc_float3 e1, lc_float3 x) noexcept { return lc_make_float3(lc_smoothstep_impl(e0.x, e1.x, x.x), lc_smoothstep_impl(e0.y, e1.y, x.y), lc_smoothstep_impl(e0.z, e1.z, x.z)); } +[[nodiscard]] __device__ inline lc_float4 lc_smoothstep(lc_float4 e0, lc_float4 e1, lc_float4 x) noexcept { return lc_make_float4(lc_smoothstep_impl(e0.x, e1.x, x.x), lc_smoothstep_impl(e0.y, e1.y, x.y), lc_smoothstep_impl(e0.z, e1.z, x.z), lc_smoothstep_impl(e0.w, e1.w, x.w)); } + +[[nodiscard]] __device__ inline lc_half lc_mod(lc_half x, lc_half y) noexcept { return lc_mod_impl(x, y); } +[[nodiscard]] __device__ inline lc_half2 lc_mod(lc_half2 x, lc_half2 y) noexcept { return lc_make_half2(lc_mod_impl(x.x, y.x), lc_mod_impl(x.y, y.y)); } +[[nodiscard]] __device__ inline lc_half3 lc_mod(lc_half3 x, lc_half3 y) noexcept { return lc_make_half3(lc_mod_impl(x.x, y.x), lc_mod_impl(x.y, y.y), lc_mod_impl(x.z, y.z)); } +[[nodiscard]] __device__ inline lc_half4 lc_mod(lc_half4 x, lc_half4 y) noexcept { return lc_make_half4(lc_mod_impl(x.x, y.x), lc_mod_impl(x.y, y.y), lc_mod_impl(x.z, y.z), lc_mod_impl(x.w, y.w)); } +[[nodiscard]] __device__ inline lc_float lc_mod(lc_float x, lc_float y) noexcept { return lc_mod_impl(x, y); } +[[nodiscard]] __device__ inline lc_float2 lc_mod(lc_float2 x, lc_float2 y) noexcept { return lc_make_float2(lc_mod_impl(x.x, y.x), lc_mod_impl(x.y, y.y)); } +[[nodiscard]] __device__ inline lc_float3 lc_mod(lc_float3 x, lc_float3 y) noexcept { return lc_make_float3(lc_mod_impl(x.x, y.x), lc_mod_impl(x.y, y.y), lc_mod_impl(x.z, y.z)); } +[[nodiscard]] __device__ inline lc_float4 lc_mod(lc_float4 x, lc_float4 y) noexcept { return lc_make_float4(lc_mod_impl(x.x, y.x), lc_mod_impl(x.y, y.y), lc_mod_impl(x.z, y.z), lc_mod_impl(x.w, y.w)); } + +[[nodiscard]] __device__ inline lc_half lc_fmod(lc_half x, lc_half y) noexcept { return lc_fmod_impl(x, y); } +[[nodiscard]] __device__ inline lc_half2 lc_fmod(lc_half2 x, lc_half2 y) noexcept { return lc_make_half2(lc_fmod_impl(x.x, y.x), lc_fmod_impl(x.y, y.y)); } +[[nodiscard]] __device__ inline lc_half3 lc_fmod(lc_half3 x, lc_half3 y) noexcept { return lc_make_half3(lc_fmod_impl(x.x, y.x), lc_fmod_impl(x.y, y.y), lc_fmod_impl(x.z, y.z)); } +[[nodiscard]] __device__ inline lc_half4 lc_fmod(lc_half4 x, lc_half4 y) noexcept { return lc_make_half4(lc_fmod_impl(x.x, y.x), lc_fmod_impl(x.y, y.y), lc_fmod_impl(x.z, y.z), lc_fmod_impl(x.w, y.w)); } +[[nodiscard]] __device__ inline lc_float lc_fmod(lc_float x, lc_float y) noexcept { return lc_fmod_impl(x, y); } +[[nodiscard]] __device__ inline lc_float2 lc_fmod(lc_float2 x, lc_float2 y) noexcept { return lc_make_float2(lc_fmod_impl(x.x, y.x), lc_fmod_impl(x.y, y.y)); } +[[nodiscard]] __device__ inline lc_float3 lc_fmod(lc_float3 x, lc_float3 y) noexcept { return lc_make_float3(lc_fmod_impl(x.x, y.x), lc_fmod_impl(x.y, y.y), lc_fmod_impl(x.z, y.z)); } +[[nodiscard]] __device__ inline lc_float4 lc_fmod(lc_float4 x, lc_float4 y) noexcept { return lc_make_float4(lc_fmod_impl(x.x, y.x), lc_fmod_impl(x.y, y.y), lc_fmod_impl(x.z, y.z), lc_fmod_impl(x.w, y.w)); } + +[[nodiscard]] __device__ inline lc_half lc_fract(lc_half x) noexcept { return lc_fract_impl(x); } +[[nodiscard]] __device__ inline lc_half2 lc_fract(lc_half2 x) noexcept { return lc_make_half2(lc_fract_impl(x.x), lc_fract_impl(x.y)); } +[[nodiscard]] __device__ inline lc_half3 lc_fract(lc_half3 x) noexcept { return lc_make_half3(lc_fract_impl(x.x), lc_fract_impl(x.y), lc_fract_impl(x.z)); } +[[nodiscard]] __device__ inline lc_half4 lc_fract(lc_half4 x) noexcept { return lc_make_half4(lc_fract_impl(x.x), lc_fract_impl(x.y), lc_fract_impl(x.z), lc_fract_impl(x.w)); } +[[nodiscard]] __device__ inline lc_float lc_fract(lc_float x) noexcept { return lc_fract_impl(x); } +[[nodiscard]] __device__ inline lc_float2 lc_fract(lc_float2 x) noexcept { return lc_make_float2(lc_fract_impl(x.x), lc_fract_impl(x.y)); } +[[nodiscard]] __device__ inline lc_float3 lc_fract(lc_float3 x) noexcept { return lc_make_float3(lc_fract_impl(x.x), lc_fract_impl(x.y), lc_fract_impl(x.z)); } +[[nodiscard]] __device__ inline lc_float4 lc_fract(lc_float4 x) noexcept { return lc_make_float4(lc_fract_impl(x.x), lc_fract_impl(x.y), lc_fract_impl(x.z), lc_fract_impl(x.w)); } + +[[nodiscard]] __device__ inline lc_uint lc_clz(lc_uint x) noexcept { return __clz(x); } +[[nodiscard]] __device__ inline lc_uint2 lc_clz(lc_uint2 x) noexcept { return lc_make_uint2(__clz(x.x), __clz(x.y)); } +[[nodiscard]] __device__ inline lc_uint3 lc_clz(lc_uint3 x) noexcept { return lc_make_uint3(__clz(x.x), __clz(x.y), __clz(x.z)); } +[[nodiscard]] __device__ inline lc_uint4 lc_clz(lc_uint4 x) noexcept { return lc_make_uint4(__clz(x.x), __clz(x.y), __clz(x.z), __clz(x.w)); } + +[[nodiscard]] __device__ inline lc_ulong lc_clz(lc_ulong x) noexcept { return __clzll(x); } +[[nodiscard]] __device__ inline lc_ulong2 lc_clz(lc_ulong2 x) noexcept { return lc_make_ulong2(__clzll(x.x), __clzll(x.y)); } +[[nodiscard]] __device__ inline lc_ulong3 lc_clz(lc_ulong3 x) noexcept { return lc_make_ulong3(__clzll(x.x), __clzll(x.y), __clzll(x.z)); } +[[nodiscard]] __device__ inline lc_ulong4 lc_clz(lc_ulong4 x) noexcept { return lc_make_ulong4(__clzll(x.x), __clzll(x.y), __clzll(x.z), __clzll(x.w)); } + +[[nodiscard]] __device__ inline lc_uint lc_popcount(lc_uint x) noexcept { return __popc(x); } +[[nodiscard]] __device__ inline lc_uint2 lc_popcount(lc_uint2 x) noexcept { return lc_make_uint2(__popc(x.x), __popc(x.y)); } +[[nodiscard]] __device__ inline lc_uint3 lc_popcount(lc_uint3 x) noexcept { return lc_make_uint3(__popc(x.x), __popc(x.y), __popc(x.z)); } +[[nodiscard]] __device__ inline lc_uint4 lc_popcount(lc_uint4 x) noexcept { return lc_make_uint4(__popc(x.x), __popc(x.y), __popc(x.z), __popc(x.w)); } + +[[nodiscard]] __device__ inline lc_ulong lc_popcount(lc_ulong x) noexcept { return __popcll(x); } +[[nodiscard]] __device__ inline lc_ulong2 lc_popcount(lc_ulong2 x) noexcept { return lc_make_ulong2(__popcll(x.x), __popcll(x.y)); } +[[nodiscard]] __device__ inline lc_ulong3 lc_popcount(lc_ulong3 x) noexcept { return lc_make_ulong3(__popcll(x.x), __popcll(x.y), __popcll(x.z)); } +[[nodiscard]] __device__ inline lc_ulong4 lc_popcount(lc_ulong4 x) noexcept { return lc_make_ulong4(__popcll(x.x), __popcll(x.y), __popcll(x.z), __popcll(x.w)); } + +[[nodiscard]] __device__ inline lc_uint lc_reverse(lc_uint x) noexcept { return __brev(x); } +[[nodiscard]] __device__ inline lc_uint2 lc_reverse(lc_uint2 x) noexcept { return lc_make_uint2(__brev(x.x), __brev(x.y)); } +[[nodiscard]] __device__ inline lc_uint3 lc_reverse(lc_uint3 x) noexcept { return lc_make_uint3(__brev(x.x), __brev(x.y), __brev(x.z)); } +[[nodiscard]] __device__ inline lc_uint4 lc_reverse(lc_uint4 x) noexcept { return lc_make_uint4(__brev(x.x), __brev(x.y), __brev(x.z), __brev(x.w)); } + +[[nodiscard]] __device__ inline lc_ulong lc_reverse(lc_ulong x) noexcept { return __brevll(x); } +[[nodiscard]] __device__ inline lc_ulong2 lc_reverse(lc_ulong2 x) noexcept { return lc_make_ulong2(__brevll(x.x), __brevll(x.y)); } +[[nodiscard]] __device__ inline lc_ulong3 lc_reverse(lc_ulong3 x) noexcept { return lc_make_ulong3(__brevll(x.x), __brevll(x.y), __brevll(x.z)); } +[[nodiscard]] __device__ inline lc_ulong4 lc_reverse(lc_ulong4 x) noexcept { return lc_make_ulong4(__brevll(x.x), __brevll(x.y), __brevll(x.z), __brevll(x.w)); } + +[[nodiscard]] __device__ inline auto lc_ctz_impl(lc_uint x) noexcept { return (__ffs(x) - 1u) % 32u; } +[[nodiscard]] __device__ inline auto lc_ctz_impl(lc_ulong x) noexcept { return (__ffsll(x) - 1u) % 64u; } +[[nodiscard]] __device__ inline lc_uint lc_ctz(lc_uint x) noexcept { return lc_ctz_impl(x); } +[[nodiscard]] __device__ inline lc_uint2 lc_ctz(lc_uint2 x) noexcept { return lc_make_uint2(lc_ctz_impl(x.x), lc_ctz_impl(x.y)); } +[[nodiscard]] __device__ inline lc_uint3 lc_ctz(lc_uint3 x) noexcept { return lc_make_uint3(lc_ctz_impl(x.x), lc_ctz_impl(x.y), lc_ctz_impl(x.z)); } +[[nodiscard]] __device__ inline lc_uint4 lc_ctz(lc_uint4 x) noexcept { return lc_make_uint4(lc_ctz_impl(x.x), lc_ctz_impl(x.y), lc_ctz_impl(x.z), lc_ctz_impl(x.w)); } +[[nodiscard]] __device__ inline lc_ulong lc_ctz(lc_ulong x) noexcept { return lc_ctz_impl(x); } +[[nodiscard]] __device__ inline lc_ulong2 lc_ctz(lc_ulong2 x) noexcept { return lc_make_ulong2(lc_ctz_impl(x.x), lc_ctz_impl(x.y)); } +[[nodiscard]] __device__ inline lc_ulong3 lc_ctz(lc_ulong3 x) noexcept { return lc_make_ulong3(lc_ctz_impl(x.x), lc_ctz_impl(x.y), lc_ctz_impl(x.z)); } +[[nodiscard]] __device__ inline lc_ulong4 lc_ctz(lc_ulong4 x) noexcept { return lc_make_ulong4(lc_ctz_impl(x.x), lc_ctz_impl(x.y), lc_ctz_impl(x.z), lc_ctz_impl(x.w)); } + +[[nodiscard]] __device__ inline constexpr auto lc_cross(lc_float3 u, lc_float3 v) noexcept { +return lc_make_float3(u.y * v.z - v.y * u.z, + u.z * v.x - v.z * u.x, + u.x * v.y - v.x * u.y); +} + +[[nodiscard]] __device__ inline auto lc_dot(lc_float2 a, lc_float2 b) noexcept { +return a.x * b.x + a.y * b.y; +} +[[nodiscard]] __device__ inline auto lc_dot(lc_float3 a, lc_float3 b) noexcept { +return a.x * b.x + a.y * b.y + a.z * b.z; +} +[[nodiscard]] __device__ inline auto lc_dot(lc_float4 a, lc_float4 b) noexcept { +return a.x * b.x + a.y * b.y + a.z * b.z + a.w * b.w; +} + +[[nodiscard]] __device__ inline auto lc_length(lc_float2 v) noexcept { return lc_sqrt(lc_dot(v, v)); } +[[nodiscard]] __device__ inline auto lc_length(lc_float3 v) noexcept { return lc_sqrt(lc_dot(v, v)); } +[[nodiscard]] __device__ inline auto lc_length(lc_float4 v) noexcept { return lc_sqrt(lc_dot(v, v)); } + +[[nodiscard]] __device__ inline auto lc_length_squared(lc_float2 v) noexcept { return lc_dot(v, v); } +[[nodiscard]] __device__ inline auto lc_length_squared(lc_float3 v) noexcept { return lc_dot(v, v); } +[[nodiscard]] __device__ inline auto lc_length_squared(lc_float4 v) noexcept { return lc_dot(v, v); } + +[[nodiscard]] __device__ inline auto lc_distance(lc_float2 a, lc_float2 b) noexcept { return lc_length(a - b); } +[[nodiscard]] __device__ inline auto lc_distance(lc_float3 a, lc_float3 b) noexcept { return lc_length(a - b); } +[[nodiscard]] __device__ inline auto lc_distance(lc_float4 a, lc_float4 b) noexcept { return lc_length(a - b); } + +[[nodiscard]] __device__ inline auto lc_distance_squared(lc_float2 a, lc_float2 b) noexcept { return lc_length_squared(a - b); } +[[nodiscard]] __device__ inline auto lc_distance_squared(lc_float3 a, lc_float3 b) noexcept { return lc_length_squared(a - b); } +[[nodiscard]] __device__ inline auto lc_distance_squared(lc_float4 a, lc_float4 b) noexcept { return lc_length_squared(a - b); } + +[[nodiscard]] __device__ inline auto lc_faceforward(lc_float3 n, lc_float3 i, lc_float3 n_ref) noexcept { return lc_select(-n, n, lc_dot(n_ref, i) < lc_float(0.f)); } + +[[nodiscard]] __device__ inline auto lc_normalize(lc_float2 v) noexcept { return v * lc_rsqrt(lc_dot(v, v)); } +[[nodiscard]] __device__ inline auto lc_normalize(lc_float3 v) noexcept { return v * lc_rsqrt(lc_dot(v, v)); } +[[nodiscard]] __device__ inline auto lc_normalize(lc_float4 v) noexcept { return v * lc_rsqrt(lc_dot(v, v)); } + +[[nodiscard]] __device__ inline constexpr auto lc_cross(lc_half3 u, lc_half3 v) noexcept { +return lc_make_half3(u.y * v.z - v.y * u.z, + u.z * v.x - v.z * u.x, + u.x * v.y - v.x * u.y); +} + +[[nodiscard]] __device__ inline auto lc_dot(lc_half2 a, lc_half2 b) noexcept { +return a.x * b.x + a.y * b.y; +} +[[nodiscard]] __device__ inline auto lc_dot(lc_half3 a, lc_half3 b) noexcept { +return a.x * b.x + a.y * b.y + a.z * b.z; +} +[[nodiscard]] __device__ inline auto lc_dot(lc_half4 a, lc_half4 b) noexcept { +return a.x * b.x + a.y * b.y + a.z * b.z + a.w * b.w; +} + +[[nodiscard]] __device__ inline auto lc_length(lc_half2 v) noexcept { return lc_sqrt(lc_dot(v, v)); } +[[nodiscard]] __device__ inline auto lc_length(lc_half3 v) noexcept { return lc_sqrt(lc_dot(v, v)); } +[[nodiscard]] __device__ inline auto lc_length(lc_half4 v) noexcept { return lc_sqrt(lc_dot(v, v)); } + +[[nodiscard]] __device__ inline auto lc_length_squared(lc_half2 v) noexcept { return lc_dot(v, v); } +[[nodiscard]] __device__ inline auto lc_length_squared(lc_half3 v) noexcept { return lc_dot(v, v); } +[[nodiscard]] __device__ inline auto lc_length_squared(lc_half4 v) noexcept { return lc_dot(v, v); } + +[[nodiscard]] __device__ inline auto lc_distance(lc_half2 a, lc_half2 b) noexcept { return lc_length(a - b); } +[[nodiscard]] __device__ inline auto lc_distance(lc_half3 a, lc_half3 b) noexcept { return lc_length(a - b); } +[[nodiscard]] __device__ inline auto lc_distance(lc_half4 a, lc_half4 b) noexcept { return lc_length(a - b); } + +[[nodiscard]] __device__ inline auto lc_distance_squared(lc_half2 a, lc_half2 b) noexcept { return lc_length_squared(a - b); } +[[nodiscard]] __device__ inline auto lc_distance_squared(lc_half3 a, lc_half3 b) noexcept { return lc_length_squared(a - b); } +[[nodiscard]] __device__ inline auto lc_distance_squared(lc_half4 a, lc_half4 b) noexcept { return lc_length_squared(a - b); } + +[[nodiscard]] __device__ inline auto lc_faceforward(lc_half3 n, lc_half3 i, lc_half3 n_ref) noexcept { return lc_select(-n, n, lc_dot(n_ref, i) < lc_half(0.f)); } + +[[nodiscard]] __device__ inline auto lc_normalize(lc_half2 v) noexcept { return v * lc_rsqrt(lc_dot(v, v)); } +[[nodiscard]] __device__ inline auto lc_normalize(lc_half3 v) noexcept { return v * lc_rsqrt(lc_dot(v, v)); } +[[nodiscard]] __device__ inline auto lc_normalize(lc_half4 v) noexcept { return v * lc_rsqrt(lc_dot(v, v)); } + +[[nodiscard]] __device__ inline constexpr auto lc_transpose(const lc_float2x2 m) noexcept { return lc_make_float2x2(m[0].x, m[1].x, m[0].y, m[1].y); } +[[nodiscard]] __device__ inline constexpr auto lc_transpose(const lc_float3x3 m) noexcept { return lc_make_float3x3(m[0].x, m[1].x, m[2].x, m[0].y, m[1].y, m[2].y, m[0].z, m[1].z, m[2].z); } +[[nodiscard]] __device__ inline constexpr auto lc_transpose(const lc_float4x4 m) noexcept { return lc_make_float4x4(m[0].x, m[1].x, m[2].x, m[3].x, m[0].y, m[1].y, m[2].y, m[3].y, m[0].z, m[1].z, m[2].z, m[3].z, m[0].w, m[1].w, m[2].w, m[3].w); } + +[[nodiscard]] __device__ inline constexpr auto lc_determinant(const lc_float2x2 m) noexcept { +return m[0][0] * m[1][1] - m[1][0] * m[0][1]; +} + +[[nodiscard]] __device__ constexpr auto lc_determinant(const lc_float3x3 m) noexcept {// from GLM +return m[0].x * (m[1].y * m[2].z - m[2].y * m[1].z) + - m[1].x * (m[0].y * m[2].z - m[2].y * m[0].z) + + m[2].x * (m[0].y * m[1].z - m[1].y * m[0].z); +} + +[[nodiscard]] __device__ inline constexpr auto lc_determinant(const lc_float4x4 m) noexcept {// from GLM +const auto coef00 = m[2].z * m[3].w - m[3].z * m[2].w; +const auto coef02 = m[1].z * m[3].w - m[3].z * m[1].w; +const auto coef03 = m[1].z * m[2].w - m[2].z * m[1].w; +const auto coef04 = m[2].y * m[3].w - m[3].y * m[2].w; +const auto coef06 = m[1].y * m[3].w - m[3].y * m[1].w; +const auto coef07 = m[1].y * m[2].w - m[2].y * m[1].w; +const auto coef08 = m[2].y * m[3].z - m[3].y * m[2].z; +const auto coef10 = m[1].y * m[3].z - m[3].y * m[1].z; +const auto coef11 = m[1].y * m[2].z - m[2].y * m[1].z; +const auto coef12 = m[2].x * m[3].w - m[3].x * m[2].w; +const auto coef14 = m[1].x * m[3].w - m[3].x * m[1].w; +const auto coef15 = m[1].x * m[2].w - m[2].x * m[1].w; +const auto coef16 = m[2].x * m[3].z - m[3].x * m[2].z; +const auto coef18 = m[1].x * m[3].z - m[3].x * m[1].z; +const auto coef19 = m[1].x * m[2].z - m[2].x * m[1].z; +const auto coef20 = m[2].x * m[3].y - m[3].x * m[2].y; +const auto coef22 = m[1].x * m[3].y - m[3].x * m[1].y; +const auto coef23 = m[1].x * m[2].y - m[2].x * m[1].y; +const auto fac0 = lc_make_float4(coef00, coef00, coef02, coef03); +const auto fac1 = lc_make_float4(coef04, coef04, coef06, coef07); +const auto fac2 = lc_make_float4(coef08, coef08, coef10, coef11); +const auto fac3 = lc_make_float4(coef12, coef12, coef14, coef15); +const auto fac4 = lc_make_float4(coef16, coef16, coef18, coef19); +const auto fac5 = lc_make_float4(coef20, coef20, coef22, coef23); +const auto Vec0 = lc_make_float4(m[1].x, m[0].x, m[0].x, m[0].x); +const auto Vec1 = lc_make_float4(m[1].y, m[0].y, m[0].y, m[0].y); +const auto Vec2 = lc_make_float4(m[1].z, m[0].z, m[0].z, m[0].z); +const auto Vec3 = lc_make_float4(m[1].w, m[0].w, m[0].w, m[0].w); +const auto inv0 = Vec1 * fac0 - Vec2 * fac1 + Vec3 * fac2; +const auto inv1 = Vec0 * fac0 - Vec2 * fac3 + Vec3 * fac4; +const auto inv2 = Vec0 * fac1 - Vec1 * fac3 + Vec3 * fac5; +const auto inv3 = Vec0 * fac2 - Vec1 * fac4 + Vec2 * fac5; +constexpr auto sign_a = lc_make_float4(+1.0f, -1.0f, +1.0f, -1.0f); +constexpr auto sign_b = lc_make_float4(-1.0f, +1.0f, -1.0f, +1.0f); +const auto inv_0 = inv0 * sign_a; +const auto inv_1 = inv1 * sign_b; +const auto inv_2 = inv2 * sign_a; +const auto inv_3 = inv3 * sign_b; +const auto dot0 = m[0] * lc_make_float4(inv_0.x, inv_1.x, inv_2.x, inv_3.x); +return dot0.x + dot0.y + dot0.z + dot0.w; +} + +[[nodiscard]] __device__ inline constexpr auto lc_inverse(const lc_float2x2 m) noexcept { +const auto one_over_determinant = 1.0f / (m[0][0] * m[1][1] - m[1][0] * m[0][1]); +return lc_make_float2x2(m[1][1] * one_over_determinant, + - m[0][1] * one_over_determinant, + - m[1][0] * one_over_determinant, + + m[0][0] * one_over_determinant); +} + +[[nodiscard]] __device__ inline constexpr auto lc_inverse(const lc_float3x3 m) noexcept {// from GLM +const auto one_over_determinant = 1.0f + / (m[0].x * (m[1].y * m[2].z - m[2].y * m[1].z) + - m[1].x * (m[0].y * m[2].z - m[2].y * m[0].z) + + m[2].x * (m[0].y * m[1].z - m[1].y * m[0].z)); +return lc_make_float3x3( + (m[1].y * m[2].z - m[2].y * m[1].z) * one_over_determinant, + (m[2].y * m[0].z - m[0].y * m[2].z) * one_over_determinant, + (m[0].y * m[1].z - m[1].y * m[0].z) * one_over_determinant, + (m[2].x * m[1].z - m[1].x * m[2].z) * one_over_determinant, + (m[0].x * m[2].z - m[2].x * m[0].z) * one_over_determinant, + (m[1].x * m[0].z - m[0].x * m[1].z) * one_over_determinant, + (m[1].x * m[2].y - m[2].x * m[1].y) * one_over_determinant, + (m[2].x * m[0].y - m[0].x * m[2].y) * one_over_determinant, + (m[0].x * m[1].y - m[1].x * m[0].y) * one_over_determinant); +} + +[[nodiscard]] __device__ inline constexpr auto lc_inverse(const lc_float4x4 m) noexcept {// from GLM +const auto coef00 = m[2].z * m[3].w - m[3].z * m[2].w; +const auto coef02 = m[1].z * m[3].w - m[3].z * m[1].w; +const auto coef03 = m[1].z * m[2].w - m[2].z * m[1].w; +const auto coef04 = m[2].y * m[3].w - m[3].y * m[2].w; +const auto coef06 = m[1].y * m[3].w - m[3].y * m[1].w; +const auto coef07 = m[1].y * m[2].w - m[2].y * m[1].w; +const auto coef08 = m[2].y * m[3].z - m[3].y * m[2].z; +const auto coef10 = m[1].y * m[3].z - m[3].y * m[1].z; +const auto coef11 = m[1].y * m[2].z - m[2].y * m[1].z; +const auto coef12 = m[2].x * m[3].w - m[3].x * m[2].w; +const auto coef14 = m[1].x * m[3].w - m[3].x * m[1].w; +const auto coef15 = m[1].x * m[2].w - m[2].x * m[1].w; +const auto coef16 = m[2].x * m[3].z - m[3].x * m[2].z; +const auto coef18 = m[1].x * m[3].z - m[3].x * m[1].z; +const auto coef19 = m[1].x * m[2].z - m[2].x * m[1].z; +const auto coef20 = m[2].x * m[3].y - m[3].x * m[2].y; +const auto coef22 = m[1].x * m[3].y - m[3].x * m[1].y; +const auto coef23 = m[1].x * m[2].y - m[2].x * m[1].y; +const auto fac0 = lc_make_float4(coef00, coef00, coef02, coef03); +const auto fac1 = lc_make_float4(coef04, coef04, coef06, coef07); +const auto fac2 = lc_make_float4(coef08, coef08, coef10, coef11); +const auto fac3 = lc_make_float4(coef12, coef12, coef14, coef15); +const auto fac4 = lc_make_float4(coef16, coef16, coef18, coef19); +const auto fac5 = lc_make_float4(coef20, coef20, coef22, coef23); +const auto Vec0 = lc_make_float4(m[1].x, m[0].x, m[0].x, m[0].x); +const auto Vec1 = lc_make_float4(m[1].y, m[0].y, m[0].y, m[0].y); +const auto Vec2 = lc_make_float4(m[1].z, m[0].z, m[0].z, m[0].z); +const auto Vec3 = lc_make_float4(m[1].w, m[0].w, m[0].w, m[0].w); +const auto inv0 = Vec1 * fac0 - Vec2 * fac1 + Vec3 * fac2; +const auto inv1 = Vec0 * fac0 - Vec2 * fac3 + Vec3 * fac4; +const auto inv2 = Vec0 * fac1 - Vec1 * fac3 + Vec3 * fac5; +const auto inv3 = Vec0 * fac2 - Vec1 * fac4 + Vec2 * fac5; +constexpr auto sign_a = lc_make_float4(+1.0f, -1.0f, +1.0f, -1.0f); +constexpr auto sign_b = lc_make_float4(-1.0f, +1.0f, -1.0f, +1.0f); +const auto inv_0 = inv0 * sign_a; +const auto inv_1 = inv1 * sign_b; +const auto inv_2 = inv2 * sign_a; +const auto inv_3 = inv3 * sign_b; +const auto dot0 = m[0] * lc_make_float4(inv_0.x, inv_1.x, inv_2.x, inv_3.x); +const auto dot1 = dot0.x + dot0.y + dot0.z + dot0.w; +const auto one_over_determinant = 1.0f / dot1; +return lc_make_float4x4(inv_0 * one_over_determinant, + inv_1 * one_over_determinant, + inv_2 * one_over_determinant, + inv_3 * one_over_determinant); +} + +[[nodiscard]] __device__ inline auto lc_reflect(const lc_float3 v, const lc_float3 n) noexcept { +return v - 2.0f * lc_dot(v, n) * n; +} + +template +[[nodiscard]] __device__ inline auto lc_bit_cast(S s) noexcept { +static_assert(sizeof(D) == sizeof(S)); +return reinterpret_cast(s); } template -requires requires(T a, T b) { a * b; } -T __builtin____mul__(T x, T y) -{ - return x * y; +[[nodiscard]] __device__ inline constexpr auto lc_zero() noexcept { +return T{}; } template -requires requires(T a, T b) { a / b; } -T __builtin____truediv__(T x, T y) -{ - return x / y; +[[nodiscard]] __device__ inline constexpr auto lc_one() noexcept { +return T::one(); +} +template<> +[[nodiscard]] __device__ inline constexpr auto lc_one() noexcept { +return lc_int(1); +} +template<> +[[nodiscard]] __device__ inline constexpr auto lc_one() noexcept { +return lc_float(1.0f); +} +template<> +[[nodiscard]] __device__ inline auto lc_one() noexcept { +return lc_half(1.0f); +} +template<> +[[nodiscard]] __device__ inline constexpr auto lc_one() noexcept { +return lc_uint(1u); +} +template<> +[[nodiscard]] __device__ inline constexpr auto lc_one() noexcept { +return lc_long(1); +} +template<> +[[nodiscard]] __device__ inline constexpr auto lc_one() noexcept { +return lc_ulong(1); } +template<> +[[nodiscard]] __device__ inline constexpr auto lc_one() noexcept { +return lc_short(1); +} +template<> +[[nodiscard]] __device__ inline constexpr auto lc_one() noexcept { +return lc_ushort(1); +} +template<> +[[nodiscard]] __device__ inline constexpr auto lc_one() noexcept { +return lc_byte(1); +} +template<> +[[nodiscard]] __device__ inline constexpr auto lc_one() noexcept { +return lc_ubyte(1); +} +template<> +[[nodiscard]] __device__ inline constexpr auto lc_one() noexcept { +return true; +} +template +class lc_array { + +private: +T _data[N]; + +public: +template +__device__ constexpr lc_array(Elem... elem) noexcept : _data{elem...} {} +__device__ constexpr lc_array(lc_array &&) noexcept = default; +__device__ constexpr lc_array(const lc_array &) noexcept = default; +__device__ constexpr lc_array &operator=(lc_array &&) noexcept = default; +__device__ constexpr lc_array &operator=(const lc_array &) noexcept = default; +[[nodiscard]] __device__ T &operator[](size_t i) noexcept { return _data[i]; } +[[nodiscard]] __device__ T operator[](size_t i) const noexcept { return _data[i]; } + +public: +[[nodiscard]] __device__ static auto one() noexcept { + lc_array ret; + #pragma unroll + for (auto i = 0u; i < N; i++) { ret[i] = lc_one(); } + return ret; +} +}; + +[[nodiscard]] __device__ inline auto lc_mat_comp_mul(lc_float2x2 lhs, lc_float2x2 rhs) noexcept { +return lc_make_float2x2(lhs[0] * rhs[0], + lhs[1] * rhs[1]); +} + +[[nodiscard]] __device__ inline auto lc_mat_comp_mul(lc_float3x3 lhs, lc_float3x3 rhs) noexcept { +return lc_make_float3x3(lhs[0] * rhs[0], + lhs[1] * rhs[1], + lhs[2] * rhs[2]); +} + +[[nodiscard]] __device__ inline auto lc_mat_comp_mul(lc_float4x4 lhs, lc_float4x4 rhs) noexcept { +return lc_make_float4x4(lhs[0] * rhs[0], + lhs[1] * rhs[1], + lhs[2] * rhs[2], + lhs[3] * rhs[3]); +} + +template struct element_type_{using type = void;}; +template using element_type = typename element_type_::type; + +template<> struct element_type_ { using type = lc_float; }; +template<> struct element_type_ { using type = lc_float; }; +template<> struct element_type_ { using type = lc_float; }; +template<> struct element_type_ { using type = lc_half; }; +template<> struct element_type_ { using type = lc_half; }; +template<> struct element_type_ { using type = lc_half; }; +template<> struct element_type_ { using type = lc_short; }; +template<> struct element_type_ { using type = lc_short; }; +template<> struct element_type_ { using type = lc_short; }; +template<> struct element_type_ { using type = lc_ushort; }; +template<> struct element_type_ { using type = lc_ushort; }; +template<> struct element_type_ { using type = lc_ushort; }; +template<> struct element_type_ { using type = lc_byte; }; +template<> struct element_type_ { using type = lc_byte; }; +template<> struct element_type_ { using type = lc_byte; }; +template<> struct element_type_ { using type = lc_ubyte; }; +template<> struct element_type_ { using type = lc_ubyte; }; +template<> struct element_type_ { using type = lc_ubyte; }; +template<> struct element_type_ { using type = lc_int; }; +template<> struct element_type_ { using type = lc_int; }; +template<> struct element_type_ { using type = lc_int; }; +template<> struct element_type_ { using type = lc_uint; }; +template<> struct element_type_ { using type = lc_uint; }; +template<> struct element_type_ { using type = lc_uint; }; +template<> struct element_type_ { using type = lc_long; }; +template<> struct element_type_ { using type = lc_long; }; +template<> struct element_type_ { using type = lc_long; }; +template<> struct element_type_ { using type = lc_ulong; }; +template<> struct element_type_ { using type = lc_ulong; }; +template<> struct element_type_ { using type = lc_ulong; }; diff --git a/scripts/gen_cpp_lib.py b/scripts/gen_cpp_lib.py index d941bf2..d9850ee 100644 --- a/scripts/gen_cpp_lib.py +++ b/scripts/gen_cpp_lib.py @@ -1,3 +1,7 @@ + +# mypy: ignore-errors +from sys import argv +from os.path import realpath, dirname import bz2 import base64 import io @@ -10,117 +14,953 @@ def compress(s: str) -> str: CPP_LIB_SRC = io.StringIO() -print(""" -using i8 = char; -using u8 = unsigned char; -using i16 = short; -using u16 = unsigned short; -using i32 = int; -using u32 = unsigned int; -using i64 = long long; -using u64 = unsigned long long; -using f32 = float; -using f64 = double; - -template -constexpr bool is_same_v = false; -template -constexpr bool is_same_v = true; -template -constexpr int compute_alignment() noexcept { +def gen_cpp_lib(): + print(""" +#define __device__ +#include +#include + +// inline directives + // if msvc +#ifdef _MSC_VER +#define __lc_always_inline__ __forceinline +#define __lc_never_inline__ __declspec(noinline) +#else +#define __lc_always_inline__ __attribute__((always_inline)) +#define __lc_never_inline__ __attribute__((noinline)) +#endif + + +int __float_as_int(float x) noexcept { return std::bit_cast(x); } +float __int_as_float(int x) noexcept { return std::bit_cast(x); } +float exp10f(float x) noexcept { return std::pow(10.0f, x); } +float rsqrtf(float x) noexcept { return 1.0f / std::sqrt(x); } +inline int __clz(unsigned int x) { + return __builtin_clz(x); +} +inline int __ctz(unsigned int x) { + return __builtin_ctz(x); +} +inline int __clzll(unsigned long long x) { + return __builtin_clzll(x); +} +inline int __ctzll(unsigned long long x) { + return __builtin_ctzll(x); +} +inline int __ffs(unsigned int x) { + return __builtin_ffs(x); +} +inline int __ffsll(unsigned long long x) { + return __builtin_ffsll(x); +} +inline int __popc(unsigned int x) { + return __builtin_popcount(x); +} +inline int __brev(unsigned int x) { + return __builtin_bswap32(x); +} +inline int __popcll(unsigned long long x) { + return __builtin_popcountll(x); +} +inline int __brevll(unsigned long long x) { + return __builtin_bswap64(x); +} +""", + file=CPP_LIB_SRC) + HALF_IMPL = ''' + +struct lc_half { +private: + union U { __fp16 h; lc_ushort bits; }; +public: + lc_ushort bits; + inline constexpr lc_half() noexcept : bits{0} {} + [[nodiscard]] static inline constexpr auto from_bits(lc_ushort bits) noexcept { + lc_half h; + h.bits = bits; + return h; + } + inline constexpr lc_half(float x) noexcept { + U u; + u.h = x; + bits = u.bits; + } + template + inline constexpr operator T() const noexcept { + U u; + u.bits = bits; + return static_cast(static_cast(u.h)); + } + inline constexpr auto operator-() const noexcept { return from_bits(bits ^ 0x8000u); } + inline constexpr auto operator+() const noexcept { return *this; } + inline constexpr auto operator!() const noexcept { return bits == 0u || bits == 0x8000u; } +#define IMPL_HALF_BINOP(op) \ + inline constexpr auto operator op(lc_half rhs) const noexcept { \ + U u_lhs; u_lhs.bits = bits; \ + U u_rhs; u_rhs.bits = rhs.bits; \ + return lc_half{lc_float(u_lhs.h op u_rhs.h)}; \ + } + IMPL_HALF_BINOP(+) + IMPL_HALF_BINOP(-) + IMPL_HALF_BINOP(*) + IMPL_HALF_BINOP(/) +#undef IMPL_HALF_BINOP +#define IMPL_HALF_CMP(op) inline constexpr auto operator op(lc_half rhs) const noexcept { return float(*this) op float(rhs); } + IMPL_HALF_CMP(==) + IMPL_HALF_CMP(!=) + IMPL_HALF_CMP(<) + IMPL_HALF_CMP(<=) + IMPL_HALF_CMP(>) + IMPL_HALF_CMP(>=) + +}; +static_assert(sizeof(lc_half) == 2); +[[nodiscard]] inline lc_short __half_as_short(lc_half x) noexcept { + return x.bits; +} +[[nodiscard]] inline lc_half __short_as_half(lc_short x) noexcept { + return lc_half::from_bits(x); +} +[[nodiscard]] inline lc_half __hmax(lc_half x, lc_half y) noexcept { return lc_half{lc_float(x) > lc_float(y) ? x : y}; } +[[nodiscard]] inline lc_half __hmin(lc_half x, lc_half y) noexcept { return lc_half{lc_float(x) < lc_float(y) ? x : y}; } +[[nodiscard]] inline lc_half __habs(lc_half x) noexcept { return lc_half{lc_float(x) < 0.0f ? -x : x}; } +[[nodiscard]] inline lc_half hexp2(lc_half x) noexcept { return lc_half{exp2f(lc_float(x))}; } +[[nodiscard]] inline lc_half hceil(lc_half x) noexcept { return lc_half{ceilf(lc_float(x))}; } +[[nodiscard]] inline lc_half hfloor(lc_half x) noexcept { return lc_half{floorf(lc_float(x))}; } +[[nodiscard]] inline lc_half htrunc(lc_half x) noexcept { return lc_half{truncf(lc_float(x))}; } +[[nodiscard]] inline lc_half hround(lc_half x) noexcept { return lc_half{roundf(lc_float(x))}; } +[[nodiscard]] inline lc_half hsqrt(lc_half x) noexcept { return lc_half{sqrtf(lc_float(x))}; } +[[nodiscard]] inline lc_half hrsqrt(lc_half x) noexcept { return lc_half{rsqrtf(lc_float(x))}; } +[[nodiscard]] inline lc_half __hfma(lc_half x, lc_half y, lc_half z) noexcept { return lc_half{fmaf(lc_float(x), lc_float(y), lc_float(z))}; } +[[nodiscard]] inline bool __hisnan(lc_half x) noexcept { return isnan_impl(lc_float(x)); } +[[nodiscard]] inline bool __hisinf(lc_half x) noexcept { return isinf_impl(lc_float(x)); } + ''' + + is_cpu = True + # scalar types + scalar_types = ["byte", "ubyte", "short", "ushort", "int", + "uint", "half", "float", "bool", "long", "ulong"] + native_types = ["char", "unsigned char", "short", "unsigned short", "int", "unsigned int", + "half", "float", "bool", "long long", "unsigned long long"] + scalar_alignments = { + "byte": 1, + "ubyte": 1, + "short": 2, + "ushort": 2, + "int": 4, + "uint": 4, + "half": 2, + "float": 4, + "bool": 1, + "long": 8, + "ulong": 8, + } + for t, native_t in zip(scalar_types, native_types): + if t == 'half' and is_cpu: + continue + print(f"using lc_{t} = {native_t};", file=CPP_LIB_SRC) + print(file=CPP_LIB_SRC) + print('''[[nodiscard]] __device__ inline bool isinf_impl(lc_float x) noexcept { +auto u = __float_as_int(x); +return u == 0x7f800000u | u == 0xff800000u; +} +[[nodiscard]] __device__ inline bool isnan_impl(lc_float x) noexcept { +auto u = __float_as_int(x); +return ((u & 0x7F800000u) == 0x7F800000u) & ((u & 0x7FFFFFu) != 0u); +} +[[nodiscard]] __device__ inline lc_float powi_impl(lc_float x, lc_int y) noexcept { +lc_float r = 1.0f; +auto is_y_neg = y < 0; +auto y_abs = is_y_neg ? -y : y; + +while (y_abs) { + if (y_abs & 1) r *= x; + x *= x; + y_abs >>= 1; +} +return is_y_neg ? 1.0f / r : r; +} +[[nodiscard]] __device__ inline lc_float powf_impl(lc_float x, lc_float y) noexcept { +auto y_int = static_cast(y); +return y_int == y ? powi_impl(x, y_int) : powf(x, y); +} +''', file=CPP_LIB_SRC) + if is_cpu: + print(HALF_IMPL, file=CPP_LIB_SRC) + # vector types + for type in scalar_types: + for i in range(2, 5): + align = min(16, scalar_alignments[type] * (i if i != 3 else 4)) + elements = ["x", "y", "z", "w"][:i] + print( + f"""struct alignas({align}) lc_{type}{i} {{ +lc_{type} {', '.join(elements[:i + 1])}; +__device__ inline constexpr lc_{type}{i}() noexcept + : {', '.join(f"{m}{{}}" for m in elements)} {{}} +__device__ inline constexpr static auto zero() noexcept {{ return lc_{type}{i}{{}}; }} +__device__ inline constexpr static auto one() noexcept {{ return lc_{type}{i}{{{', '.join('1' for _ in elements)}}}; }} +__device__ inline explicit constexpr lc_{type}{i}(lc_{type} s) noexcept + : {', '.join(f"{m}{{s}}" for m in elements)} {{}} +__device__ inline constexpr lc_{type}{i}({', '.join(f"lc_{type} {m}" for m in elements)}) noexcept + : {', '.join(f"{m}{{{m}}}" for m in elements)} {{}} +__device__ inline constexpr auto &operator[](lc_uint i) noexcept {{ return (&x)[i]; }} +__device__ inline constexpr auto operator[](lc_uint i) const noexcept {{ return (&x)[i]; }} +}}; """, file=CPP_LIB_SRC) -TYPES = ['i8', 'u8', 'i16', 'u16', 'i32', 'u32', 'i64', 'u64', 'f32', 'f64'] + # make type[n] + for type in scalar_types: + # make type2 + print( + f"""[[nodiscard]] __device__ inline constexpr auto lc_make_{type}2(lc_{type} s = 0) noexcept {{ return lc_{type}2{{s, s}}; }} +[[nodiscard]] __device__ inline constexpr auto lc_make_{type}2(lc_{type} x, lc_{type} y) noexcept {{ return lc_{type}2{{x, y}}; }}""", + file=CPP_LIB_SRC) + for t in scalar_types: + for l in range(2, 5): + print( + f"[[nodiscard]] __device__ inline constexpr auto lc_make_{type}2(lc_{t}{l} v) noexcept {{ return lc_{type}2{{static_cast(v.x), static_cast(v.y)}}; }}", + file=CPP_LIB_SRC) + # make type3 + print( + f"""[[nodiscard]] inline __device__ constexpr auto lc_make_{type}3(lc_{type} s = 0) noexcept {{ return lc_{type}3{{s, s, s}}; }} +[[nodiscard]] __device__ inline constexpr auto lc_make_{type}3(lc_{type} x, lc_{type} y, lc_{type} z) noexcept {{ return lc_{type}3{{x, y, z}}; }} +[[nodiscard]] __device__ inline constexpr auto lc_make_{type}3(lc_{type} x, lc_{type}2 yz) noexcept {{ return lc_{type}3{{x, yz.x, yz.y}}; }} +[[nodiscard]] __device__ inline constexpr auto lc_make_{type}3(lc_{type}2 xy, lc_{type} z) noexcept {{ return lc_{type}3{{xy.x, xy.y, z}}; }}""", + file=CPP_LIB_SRC) + for t in scalar_types: + for l in range(3, 5): + print( + f"[[nodiscard]] __device__ constexpr auto lc_make_{type}3(lc_{t}{l} v) noexcept {{ return lc_{type}3{{static_cast(v.x), static_cast(v.y), static_cast(v.z)}}; }}", + file=CPP_LIB_SRC) + # make type4 + print( + f"""[[nodiscard]] inline __device__ constexpr auto lc_make_{type}4(lc_{type} s = 0) noexcept {{ return lc_{type}4{{s, s, s, s}}; }} +[[nodiscard]] __device__ inline constexpr auto lc_make_{type}4(lc_{type} x, lc_{type} y, lc_{type} z, lc_{type} w) noexcept {{ return lc_{type}4{{x, y, z, w}}; }} +[[nodiscard]] __device__ inline constexpr auto lc_make_{type}4(lc_{type} x, lc_{type} y, lc_{type}2 zw) noexcept {{ return lc_{type}4{{x, y, zw.x, zw.y}}; }} +[[nodiscard]] __device__ inline constexpr auto lc_make_{type}4(lc_{type} x, lc_{type}2 yz, lc_{type} w) noexcept {{ return lc_{type}4{{x, yz.x, yz.y, w}}; }} +[[nodiscard]] __device__ inline constexpr auto lc_make_{type}4(lc_{type}2 xy, lc_{type} z, lc_{type} w) noexcept {{ return lc_{type}4{{xy.x, xy.y, z, w}}; }} +[[nodiscard]] __device__ inline constexpr auto lc_make_{type}4(lc_{type}2 xy, lc_{type}2 zw) noexcept {{ return lc_{type}4{{xy.x, xy.y, zw.x, zw.y}}; }} +[[nodiscard]] __device__ inline constexpr auto lc_make_{type}4(lc_{type} x, lc_{type}3 yzw) noexcept {{ return lc_{type}4{{x, yzw.x, yzw.y, yzw.z}}; }} +[[nodiscard]] __device__ inline constexpr auto lc_make_{type}4(lc_{type}3 xyz, lc_{type} w) noexcept {{ return lc_{type}4{{xyz.x, xyz.y, xyz.z, w}}; }}""", + file=CPP_LIB_SRC) + for t in scalar_types: + print( + f"[[nodiscard]] inline __device__ constexpr auto lc_make_{type}4(lc_{t}4 v) noexcept {{ return lc_{type}4{{static_cast(v.x), static_cast(v.y), static_cast(v.z), static_cast(v.w)}}; }}", + file=CPP_LIB_SRC) + print(file=CPP_LIB_SRC) + # unary operators + for type in scalar_types: + for i in range(2, 5): + elements = ["x", "y", "z", "w"][:i] + print( + f"[[nodiscard]] inline __device__ constexpr auto operator!(lc_{type}{i} v) noexcept {{ return lc_make_bool{i}({', '.join(f'!v.{m}' for m in elements)}); }}", + file=CPP_LIB_SRC) + if type != "bool": + print( + f"[[nodiscard]] inline __device__ constexpr auto operator+(lc_{type}{i} v) noexcept {{ return lc_make_{type}{i}({', '.join(f'+v.{m}' for m in elements)}); }}", + file=CPP_LIB_SRC) + print( + f"[[nodiscard]] inline __device__ constexpr auto operator-(lc_{type}{i} v) noexcept {{ return lc_make_{type}{i}({', '.join(f'-v.{m}' for m in elements)}); }}", + file=CPP_LIB_SRC) + if type != "float" and type != "half": + print( + f"[[nodiscard]] inline __device__ constexpr auto operator~(lc_{type}{i} v) noexcept {{ return lc_make_{type}{i}({', '.join(f'~v.{m}' for m in elements)}); }}", + file=CPP_LIB_SRC) + print(file=CPP_LIB_SRC) -def gen_alignment(ty: str, c: int, a: int): - print(f''' if constexpr (is_same_v && N == {c}) {{ - return alignof({ty}) * {a}; - }}''', file=CPP_LIB_SRC) + def gen_binary_op(arg_t, ret_t, op): + for i in range(2, 5): + elements = ["x", "y", "z", "w"][:i] + # vector-vector + print( + f"[[nodiscard]] inline __device__ constexpr auto operator{op}(lc_{arg_t}{i} lhs, lc_{arg_t}{i} rhs) noexcept {{ return lc_make_{ret_t}{i}({', '.join(f'lhs.{m} {op} rhs.{m}' for m in elements)}); }}", + file=CPP_LIB_SRC) + # vector-scalar + operation = ", ".join(f"lhs.{e} {op} rhs" for e in "xyzw"[:i]) + print( + f"[[nodiscard]] inline __device__ constexpr auto operator{op}(lc_{arg_t}{i} lhs, lc_{arg_t} rhs) noexcept {{ return lc_make_{ret_t}{i}({operation}); }}", + file=CPP_LIB_SRC) + # scalar-vector + operation = ", ".join(f"lhs {op} rhs.{e}" for e in "xyzw"[:i]) + print( + f"[[nodiscard]] inline __device__ constexpr auto operator{op}(lc_{arg_t} lhs, lc_{arg_t}{i} rhs) noexcept {{ return lc_make_{ret_t}{i}({operation}); }}", + file=CPP_LIB_SRC) + # binary operators + for op in ["==", "!="]: + for type in scalar_types: + gen_binary_op(type, "bool", op) + print(file=CPP_LIB_SRC) + for op in ["<", ">", "<=", ">="]: + for type in ["short", "ushort", "int", "uint", "half", "float", "long", "ulong"]: + gen_binary_op(type, "bool", op) + print(file=CPP_LIB_SRC) + for op in ["+", "-", "*", "/"]: + for type in ["short", "ushort", "int", "uint", "half", "float", "long", "ulong"]: + gen_binary_op(type, type, op) + print(file=CPP_LIB_SRC) + for op in ["%", "<<", ">>"]: + for type in ["short", "ushort", "int", "uint", "long", "ulong"]: + gen_binary_op(type, type, op) + print(file=CPP_LIB_SRC) + for op in ["|", "&", "^"]: + for type in ["short", "ushort", "int", "uint", "bool", "long", "ulong"]: + gen_binary_op(type, type, op) + print(file=CPP_LIB_SRC) + for op in ["||", "&&"]: + gen_binary_op("bool", "bool", op) + print(file=CPP_LIB_SRC) -for t in TYPES: - for c in [3]: - gen_alignment(t, c, 4) + # any, all, none + for f, uop, bop in [("any", "", "||"), ("all", "", "&&"), ("none", "!", "&&")]: + for i in range(2, 5): + elements = ["x", "y", "z", "w"][:i] + print( + f"[[nodiscard]] __device__ inline constexpr auto lc_{f}(lc_bool{i} v) noexcept {{ return {f' {bop} '.join(f'{uop}v.{m}' for m in elements)}; }}", + file=CPP_LIB_SRC) -print('return alignof(T) * N;\n}', file=CPP_LIB_SRC) + # matrix types + for i in range(2, 5): + def init(j): + return ', '.join(["0.0f", "0.0f", "0.0f", "s", "0.0f", "0.0f", "0.0f"][3 - j:3 + i - j]) + print(f""" +struct lc_float{i}x{i} {{ +lc_float{i} cols[{i}]; +__device__ inline constexpr lc_float{i}x{i}() noexcept : cols{{}} {{}} +__device__ inline explicit constexpr lc_float{i}x{i}(lc_float s) noexcept + : cols{{{", ".join(f"lc_make_float{i}({init(j)})" for j in range(i))}}} {{}} +__device__ inline constexpr static auto full(lc_float s) noexcept {{ return lc_float{i}x{i}{{{", ".join(f"lc_float{i}(s)" for j in range(i))}}}; }} +__device__ inline constexpr static auto zero() noexcept {{ return lc_float{i}x{i}{{{", ".join(f"lc_float{i}::zero()" for j in range(i))}}}; }} +__device__ inline constexpr static auto one() noexcept {{ return lc_float{i}x{i}{{{", ".join(f"lc_float{i}::one()" for j in range(i))}}}; }} +__device__ inline constexpr lc_float{i}x{i}({", ".join(f"lc_float{i} c{j}" for j in range(i))}) noexcept + : cols{{{", ".join(f"c{j}" for j in range(i))}}} {{}} +[[nodiscard]] __device__ inline constexpr auto &operator[](lc_uint i) noexcept {{ return cols[i]; }} +[[nodiscard]] __device__ inline constexpr auto operator[](lc_uint i) const noexcept {{ return cols[i]; }} +[[nodiscard]] __device__ inline constexpr auto comp_mul(const lc_float{i}x{i} &rhs) const noexcept {{ return lc_float{i}x{i}{{{", ".join(f"cols[{j}] * rhs[{j}]" for j in range(i))}}}; }} +}};""", file=CPP_LIB_SRC) -print(""" -template -struct alignas(compute_alignment()) vec { - T data[N]{}; - vec() noexcept = default; - explicit vec(T value) noexcept { - for (int i = 0; i < N; ++i) { - data[i] = value; - } - } - T& operator[](int i) noexcept { - return data[i]; - } - T operator[](int i) const noexcept{ - return data[i]; - } -#define VEC_OP(op, op_assign) \\ - vec operator op(const vec& other) const noexcept \\ - requires requires(T a, T b) { a op b; } { \\ - vec result{}; \\ - for (int i = 0; i < N; ++i) { \\ - result[i] = data[i] op other.data[i]; \\ - } \\ - return result; \\ - } \\ - vec operator op(T scalar) const noexcept \\ - requires requires(T a, T b) { a op b; } { \\ - vec result{}; \\ - for (int i = 0; i < N; ++i) { \\ - result[i] = data[i] op scalar; \\ - } \\ - return result; \\ - } \\ - friend vec operator op(T scalar, const vec& v) noexcept \\ - requires requires(T a, T b) { a op b; } { \\ - return vec{scalar} op v; \\ - } \\ - vec operator op_assign(const vec& other) noexcept \\ - requires requires(T a, T b) { a op_assign b; } { \\ - for (int i = 0; i < N; ++i) { \\ - data[i] op_assign other.data[i]; \\ - } \\ - return *this; \\ - } \\ - vec operator op_assign(T scalar) noexcept \\ - requires requires(T a, T b) { a op_assign b; }{ \\ - for (int i = 0; i < N; ++i) { \\ - data[i] op_assign scalar; \\ - } \\ - return *this; \\ - } - VEC_OP(+, +=) - VEC_OP(-, -=) - VEC_OP(*, *=) - VEC_OP(/, /=) - VEC_OP(%, %=) - + for i in range(2, 5): + elements = ["x", "y", "z", "w"][:i] + print(f""" +[[nodiscard]] __device__ inline constexpr auto operator*(const lc_float{i}x{i} m, lc_float s) noexcept {{ return lc_float{i}x{i}{{{", ".join(f"m[{j}] * s" for j in range(i))}}}; }} +[[nodiscard]] __device__ inline constexpr auto operator*(lc_float s, const lc_float{i}x{i} m) noexcept {{ return m * s; }} +[[nodiscard]] __device__ inline constexpr auto operator/(const lc_float{i}x{i} m, lc_float s) noexcept {{ return m * (1.0f / s); }} +[[nodiscard]] __device__ inline constexpr auto operator*(const lc_float{i}x{i} m, const lc_float{i} v) noexcept {{ return {' + '.join(f"v.{e} * m[{j}]" for j, e in enumerate(elements))}; }} +[[nodiscard]] __device__ inline constexpr auto operator*(const lc_float{i}x{i} lhs, const lc_float{i}x{i} rhs) noexcept {{ return lc_float{i}x{i}{{{', '.join(f"lhs * rhs[{j}]" for j in range(i))}}}; }} +[[nodiscard]] __device__ inline constexpr auto operator+(const lc_float{i}x{i} lhs, const lc_float{i}x{i} rhs) noexcept {{ return lc_float{i}x{i}{{{", ".join(f"lhs[{j}] + rhs[{j}]" for j in range(i))}}}; }} +[[nodiscard]] __device__ inline constexpr auto operator-(const lc_float{i}x{i} lhs, const lc_float{i}x{i} rhs) noexcept {{ return lc_float{i}x{i}{{{", ".join(f"lhs[{j}] - rhs[{j}]" for j in range(i))}}}; }}""", + file=CPP_LIB_SRC) + + for i in range(2, 5): + def init(j): + return ', '.join(["0.0f", "0.0f", "0.0f", "s", "0.0f", "0.0f", "0.0f"][3 - j:3 + i - j]) + + print(f""" +[[nodiscard]] __device__ inline constexpr auto lc_make_float{i}x{i}(lc_float s = 1.0f) noexcept {{ return lc_float{i}x{i}{{{", ".join(f"lc_make_float{i}({init(j)})" for j in range(i))}}}; }} +[[nodiscard]] __device__ inline constexpr auto lc_make_float{i}x{i}({', '.join(', '.join(f"lc_float m{j}{k}" for k in range(i)) for j in range(i))}) noexcept {{ return lc_float{i}x{i}{{{", ".join(f"lc_make_float{i}({', '.join(f'm{j}{k}' for k in range(i))})" for j in range(i))}}}; }} +[[nodiscard]] __device__ inline constexpr auto lc_make_float{i}x{i}({", ".join(f"lc_float{i} c{j}" for j in range(i))}) noexcept {{ return lc_float{i}x{i}{{{", ".join(f"c{j}" for j in range(i))}}}; }}""", + file=CPP_LIB_SRC) + if i == 3: + print( + f"[[nodiscard]] __device__ inline constexpr auto lc_make_float{i}x{i}(lc_float2x2 m) noexcept {{ return lc_float3x3{{lc_make_float3(m[0], 0.0f), lc_make_float3(m[1], 0.0f), lc_make_float3(0.0f, 0.0f, 1.0f)}}; }}", + file=CPP_LIB_SRC) + if i == 4: + print( + f"[[nodiscard]] __device__ inline constexpr auto lc_make_float{i}x{i}(lc_float2x2 m) noexcept {{ return lc_float4x4{{lc_make_float4(m[0], 0.0f, 0.0f), lc_make_float4(m[1], 0.0f, 0.0f), lc_make_float4(0.0f, 0.0f, 0.0f, 0.0f), lc_make_float4(0.0f, 0.0f, 0.0f, 1.0f)}}; }}", + file=CPP_LIB_SRC) + print( + f"[[nodiscard]] __device__ inline constexpr auto lc_make_float{i}x{i}(lc_float3x3 m) noexcept {{ return lc_float4x4{{lc_make_float4(m[0], 0.0f), lc_make_float4(m[1], 0.0f), lc_make_float4(m[2], 0.0f), lc_make_float4(0.0f, 0.0f, 0.0f, 1.0f)}}; }}", + file=CPP_LIB_SRC) + print( + f"[[nodiscard]] __device__ inline constexpr auto lc_make_float{i}x{i}(lc_float{i}x{i} m) noexcept {{ return m; }}", + file=CPP_LIB_SRC) + for t in range(i + 1, 5): + print( + f"[[nodiscard]] __device__ inline constexpr auto lc_make_float{i}x{i}(lc_float{t}x{t} m) noexcept {{ return lc_float{i}x{i}{{{', '.join(f'lc_make_float{i}(m[{j}])' for j in range(i))}}}; }}", + file=CPP_LIB_SRC) + print(file=CPP_LIB_SRC) + + def generate_vector_call(name, c, types, args): + types = [{ + "s": "short", + "r": "ushort", + "i": "int", + "u": "uint", + "h": "half", + "f": "float", + "b": "bool", + "l": "long", + "z": "ulong"}[t] for t in types] + + def call(i): + e = "xyzw"[i] + return f"{c}(" + ", ".join(f"{a}.{e}" for a in args) + ")" + + for t in types: + ret = t if name not in ['isnan', 'isinf'] else 'bool' + print( + f"[[nodiscard]] __device__ inline lc_{ret} lc_{name}({', '.join(f'lc_{t} {a}' for a in args)}) noexcept {{ return {c}({', '.join(args)}); }}", + file=CPP_LIB_SRC) + for n in range(2, 5): + print( + f"[[nodiscard]] __device__ inline lc_{ret}{n} lc_{name}({', '.join(f'lc_{t}{n} {a}' for a in args)}) noexcept {{ return lc_make_{ret}{n}({', '.join(call(i) for i in range(n))}); }}", + file=CPP_LIB_SRC) + print(file=CPP_LIB_SRC) + + # select + print( + "template\n[[nodiscard]] __device__ inline auto lc_select(T f, T t, bool p) noexcept { return p ? t : f; }", + file=CPP_LIB_SRC) + for t in ["short", "ushort", "int", "uint", "half", "float", "bool", "long", "ulong"]: + for n in range(2, 5): + print( + f"[[nodiscard]] __device__ inline auto lc_select(lc_{t}{n} f, lc_{t}{n} t, lc_bool{n} p) noexcept {{ return lc_make_{t}{n}({', '.join(f'lc_select(f.{e}, t.{e}, p.{e})' for e in 'xyzw'[:n])}); }}", + file=CPP_LIB_SRC) + print(file=CPP_LIB_SRC) + + # outer product + for t in ["float"]: + for n in range(2, 5): + print( + f"[[nodiscard]] __device__ inline auto lc_outer_product(lc_{t}{n} a, lc_{t}{n} b) noexcept {{ return lc_{t}{n}x{n}({', '.join(f'a * b.{f}' for f in 'xyzw'[:n])}); }}", + file=CPP_LIB_SRC) + # min/max/abs/acos/asin/asinh/acosh/atan/atanh/atan2/ + # cos/cosh/sin/sinh/tan/tanh/exp/exp2/exp10/log/log2/ + # log10/sqrt/rsqrt/ceil/floor/trunc/round/fma/copysignf/ + # isinf/isnan + generate_vector_call("min", "fminf", "f", ["a", "b"]) + generate_vector_call("min", "__hmin", "h", ["a", "b"]) + generate_vector_call("max", "fmaxf", "f", ["a", "b"]) + generate_vector_call("max", "__hmax", "h", ["a", "b"]) + generate_vector_call("abs", "fabsf", "f", ["x"]) + generate_vector_call("abs", "abs", "i", ["x"]) + generate_vector_call("abs", "llabs", "l", ["x"]) + generate_vector_call("abs", "__habs", "h", ["x"]) + + generate_vector_call("acos", "acosf", "hf", ["x"]) + generate_vector_call("asin", "asinf", "hf", ["x"]) + generate_vector_call("atan", "atanf", "hf", ["x"]) + generate_vector_call("acosh", "acoshf", "hf", ["x"]) + generate_vector_call("asinh", "asinhf", "hf", ["x"]) + generate_vector_call("atanh", "atanhf", "hf", ["x"]) + generate_vector_call("atan2", "atan2f", "hf", ["y", "x"]) + + generate_vector_call("cosh", "coshf", "hf", ["x"]) + generate_vector_call("sinh", "sinhf", "hf", ["x"]) + generate_vector_call("tanh", "tanhf", "hf", ["x"]) + + generate_vector_call("cos", "cosf", "hf", ["x"]) + generate_vector_call("sin", "sinf", "hf", ["x"]) + generate_vector_call("tan", "tanf", "hf", ["x"]) + generate_vector_call("exp", "expf", "hf", ["x"]) + generate_vector_call("exp2", "exp2f", "f", ["x"]) + generate_vector_call("exp2", "hexp2", "h", ["x"]) + generate_vector_call("exp10", "exp10f", "hf", ["x"]) + generate_vector_call("log", "logf", "hf", ["x"]) + generate_vector_call("log2", "log2f", "hf", ["x"]) + generate_vector_call("log10", "log10f", "hf", ["x"]) + generate_vector_call("pow", "powf_impl", "hf", ["x", "a"]) + generate_vector_call("powi", "powi_impl", "hf", ["x", "a"]) + + generate_vector_call("sqrt", "sqrtf", "f", ["x"]) + generate_vector_call("sqrt", "hsqrt", "h", ["x"]) + + generate_vector_call("rsqrt", "rsqrtf", "f", ["x"]) + generate_vector_call("rsqrt", "hrsqrt", "h", ["x"]) + + generate_vector_call("ceil", "ceilf", "f", ["x"]) + generate_vector_call("ceil", "hceil", "h", ["x"]) + + generate_vector_call("floor", "floorf", "f", ["x"]) + generate_vector_call("floor", "hfloor", "h", ["x"]) + + generate_vector_call("trunc", "truncf", "f", ["x"]) + generate_vector_call("trunc", "htrunc", "h", ["x"]) + + generate_vector_call("round", "roundf", "hf", ["x"]) + + generate_vector_call("fma", "fmaf", "f", ["x", "y", "z"]) + generate_vector_call("fma", "__hfma", "h", ["x", "y", "z"]) + + print(""" +[[nodiscard]] __device__ inline auto lc_copysign_impl(lc_half x, lc_half y) noexcept { +auto ux = __half_as_short(x); +auto uy = __half_as_short(y); +return __short_as_half((ux & 0x7fffu) | (uy & 0x8000u)); +}""", file=CPP_LIB_SRC) + + generate_vector_call("copysign", "copysignf", "f", ["x", "y"]) + generate_vector_call("copysign", "lc_copysign_impl", "h", ["x", "y"]) + + generate_vector_call("isinf", "isinf_impl", "f", ["x"]) + generate_vector_call("isnan", "isnan_impl", "f", ["x"]) + generate_vector_call("isinf", "__hisinf", "h", ["x"]) + generate_vector_call("isnan", "__hisnan", "h", ["x"]) + # TODO: half + + # reduce operations + for t in ["short", "ushort", "int", "uint", "half", "float", "long", "ulong"]: + for n in range(2, 5): + print( + f"[[nodiscard]] __device__ inline auto lc_reduce_sum(lc_{t}{n} v) noexcept {{ return lc_{t}({'+'.join(f'v.{e}' for e in 'xyzw'[:n])}); }}", + file=CPP_LIB_SRC) + print( + f"[[nodiscard]] __device__ inline auto lc_reduce_prod(lc_{t}{n} v) noexcept {{ return lc_{t}({'*'.join(f'v.{e}' for e in 'xyzw'[:n])}); }}", + file=CPP_LIB_SRC) + print( + f"[[nodiscard]] __device__ inline auto lc_reduce_min(lc_{t}{n} v) noexcept {{ return lc_{t}({', '.join(f'lc_min(v.{e}' for e in 'xyzw'[:n - 1])}, v.{'xyzw'[n - 1]}{')' * (n)}; }}", + file=CPP_LIB_SRC) + print( + f"[[nodiscard]] __device__ inline auto lc_reduce_max(lc_{t}{n} v) noexcept {{ return lc_{t}({', '.join(f'lc_max(v.{e}' for e in 'xyzw'[:n - 1])}, v.{'xyzw'[n - 1]}{')' * (n)}; }}", + file=CPP_LIB_SRC) + + # min/max for int + for t in ["short", "ushort", "int", "uint", "long", "ulong"]: + # lc_min_impl/lc_max_impl + print( + f"[[nodiscard]] __device__ inline auto lc_min_impl(lc_{t} a, lc_{t} b) noexcept {{ return a < b ? a : b; }}", + file=CPP_LIB_SRC) + print( + f"[[nodiscard]] __device__ inline auto lc_max_impl(lc_{t} a, lc_{t} b) noexcept {{ return a > b ? a : b; }}", + file=CPP_LIB_SRC) + generate_vector_call("min", "lc_min_impl", "sriulz", ["a", "b"]) + generate_vector_call("max", "lc_max_impl", "sriulz", ["a", "b"]) + + # clamp + for t in ["short", "ushort", "int", "uint", "half", "float", "long", "ulong"]: + print( + f"[[nodiscard]] __device__ inline auto lc_clamp_impl(lc_{t} v, lc_{t} lo, lc_{t} hi) noexcept {{ return lc_min(lc_max(v, lo), hi); }}", + file=CPP_LIB_SRC) + generate_vector_call("clamp", "lc_clamp_impl", + "sriulzhf", ["v", "lo", "hi"]) + + for t in ["half", "float"]: + # lerp + print( + f"[[nodiscard]] __device__ inline auto lc_lerp_impl(lc_{t} a, lc_{t} b, lc_{t} t) noexcept {{ return t * (b - a) + a; }}", + file=CPP_LIB_SRC) + + # saturate + print( + f"[[nodiscard]] __device__ inline auto lc_saturate(lc_{t} x) noexcept {{ return lc_clamp(x, lc_{t}(0.0f), lc_{t}(1.0f)); }}", + file=CPP_LIB_SRC) + for n in range(2, 5): + print( + f"[[nodiscard]] __device__ inline auto lc_saturate(lc_{t}{n} x) noexcept {{ return lc_clamp(x, lc_make_{t}{n}(0.0f), lc_make_{t}{n}(1.0f)); }}", + file=CPP_LIB_SRC) + print(file=CPP_LIB_SRC) + + # degrees/radians + print( + f"[[nodiscard]] __device__ inline auto lc_degrees_impl(lc_{t} rad) noexcept {{ return rad * (lc_{t})(180.0f * 0.318309886183790671537767526745028724f); }}", + file=CPP_LIB_SRC) + print( + f"[[nodiscard]] __device__ inline auto lc_radians_impl(lc_{t} deg) noexcept {{ return deg * (lc_{t})(3.14159265358979323846264338327950288f / 180.0f); }}", + file=CPP_LIB_SRC) + + # step + print( + f"[[nodiscard]] __device__ inline auto lc_step_impl(lc_{t} edge, lc_{t} x) noexcept {{ return lc_select(lc_{t}(1.f), lc_{t}(0.f), x < edge); }}", + file=CPP_LIB_SRC) + + # smoothstep + print( + f"""[[nodiscard]] __device__ inline auto lc_smoothstep_impl(lc_{t} edge0, lc_{t} edge1, lc_{t} x) noexcept {{ +auto t = lc_clamp((x - edge0) / (edge1 - edge0), lc_{t}(0.0f), lc_{t}(1.0f)); +return t * t * (lc_{t}(3.f) - lc_{t}(2.f) * t); +}}""", + file=CPP_LIB_SRC) + + # mod + print( + f"[[nodiscard]] __device__ inline auto lc_mod_impl(lc_{t} x, lc_{t} y) noexcept {{ return x - y * lc_floor(x / y); }}", + file=CPP_LIB_SRC) + + # fmod + if t == "half": + print( + f"[[nodiscard]] __device__ inline auto lc_fmod_impl(lc_{t} x, lc_{t} y) noexcept {{ return x - y * lc_trunc(x / y); }}", + file=CPP_LIB_SRC) + else: + print( + f"[[nodiscard]] __device__ inline auto lc_fmod_impl(lc_{t} x, lc_{t} y) noexcept {{ return fmodf(x, y); }}", + file=CPP_LIB_SRC) + + # fract + print( + f"[[nodiscard]] __device__ inline auto lc_fract_impl(lc_{t} x) noexcept {{ return x - lc_floor(x); }}", + file=CPP_LIB_SRC) + + generate_vector_call("lerp", "lc_lerp_impl", "hf", ["a", "b", "t"]) + generate_vector_call("degrees", "lc_degrees_impl", "hf", ["rad"]) + generate_vector_call("radians", "lc_radians_impl", "hf", ["deg"]) + generate_vector_call("step", "lc_step_impl", "hf", ["edge", "x"]) + generate_vector_call("smoothstep", "lc_smoothstep_impl", + "hf", ["e0", "e1", "x"]) + generate_vector_call("mod", "lc_mod_impl", "hf", ["x", "y"]) + generate_vector_call("fmod", "lc_fmod_impl", "hf", ["x", "y"]) + generate_vector_call("fract", "lc_fract_impl", "hf", ["x"]) + + # clz/popcount/reverse + generate_vector_call("clz", "__clz", "u", ["x"]) + generate_vector_call("clz", "__clzll", "z", ["x"]) + generate_vector_call("popcount", "__popc", "u", ["x"]) + generate_vector_call("popcount", "__popcll", "z", ["x"]) + generate_vector_call("reverse", "__brev", "u", ["x"]) + generate_vector_call("reverse", "__brevll", "z", ["x"]) + + # ctz + print( + f"[[nodiscard]] __device__ inline auto lc_ctz_impl(lc_uint x) noexcept {{ return (__ffs(x) - 1u) % 32u; }}", + file=CPP_LIB_SRC) + print( + f"[[nodiscard]] __device__ inline auto lc_ctz_impl(lc_ulong x) noexcept {{ return (__ffsll(x) - 1u) % 64u; }}", + file=CPP_LIB_SRC) + generate_vector_call("ctz", "lc_ctz_impl", "uz", ["x"]) + + for t in ["float", "half"]: + # cross + print(f"""[[nodiscard]] __device__ inline constexpr auto lc_cross(lc_{t}3 u, lc_{t}3 v) noexcept {{ +return lc_make_{t}3(u.y * v.z - v.y * u.z, + u.z * v.x - v.z * u.x, + u.x * v.y - v.x * u.y); +}}""", file=CPP_LIB_SRC) + print(file=CPP_LIB_SRC) + + # dot + print(f"""[[nodiscard]] __device__ inline auto lc_dot(lc_{t}2 a, lc_{t}2 b) noexcept {{ +return a.x * b.x + a.y * b.y; +}}""", file=CPP_LIB_SRC) + print(f"""[[nodiscard]] __device__ inline auto lc_dot(lc_{t}3 a, lc_{t}3 b) noexcept {{ +return a.x * b.x + a.y * b.y + a.z * b.z; +}}""", file=CPP_LIB_SRC) + print(f"""[[nodiscard]] __device__ inline auto lc_dot(lc_{t}4 a, lc_{t}4 b) noexcept {{ +return a.x * b.x + a.y * b.y + a.z * b.z + a.w * b.w; +}}""", file=CPP_LIB_SRC) + print(file=CPP_LIB_SRC) + + # length + print( + f"[[nodiscard]] __device__ inline auto lc_length(lc_{t}2 v) noexcept {{ return lc_sqrt(lc_dot(v, v)); }}", + file=CPP_LIB_SRC) + print( + f"[[nodiscard]] __device__ inline auto lc_length(lc_{t}3 v) noexcept {{ return lc_sqrt(lc_dot(v, v)); }}", + file=CPP_LIB_SRC) + print( + f"[[nodiscard]] __device__ inline auto lc_length(lc_{t}4 v) noexcept {{ return lc_sqrt(lc_dot(v, v)); }}", + file=CPP_LIB_SRC) + print(file=CPP_LIB_SRC) + + # length_squared + for n in range(2, 5): + print( + f"[[nodiscard]] __device__ inline auto lc_length_squared(lc_{t}{n} v) noexcept {{ return lc_dot(v, v); }}", + file=CPP_LIB_SRC) + print(file=CPP_LIB_SRC) + + # distance + for n in range(2, 5): + print( + f"[[nodiscard]] __device__ inline auto lc_distance(lc_{t}{n} a, lc_{t}{n} b) noexcept {{ return lc_length(a - b); }}", + file=CPP_LIB_SRC) + print(file=CPP_LIB_SRC) + + # distance_squared + for n in range(2, 5): + print( + f"[[nodiscard]] __device__ inline auto lc_distance_squared(lc_{t}{n} a, lc_{t}{n} b) noexcept {{ return lc_length_squared(a - b); }}", + file=CPP_LIB_SRC) + print(file=CPP_LIB_SRC) + + # faceforward + print( + f"[[nodiscard]] __device__ inline auto lc_faceforward(lc_{t}3 n, lc_{t}3 i, lc_{t}3 n_ref) noexcept {{ return lc_select(-n, n, lc_dot(n_ref, i) < lc_{t}(0.f)); }}", + file=CPP_LIB_SRC) + print(file=CPP_LIB_SRC) + + # normalize + for n in range(2, 5): + print( + f"[[nodiscard]] __device__ inline auto lc_normalize(lc_{t}{n} v) noexcept {{ return v * lc_rsqrt(lc_dot(v, v)); }}", + file=CPP_LIB_SRC) + print(file=CPP_LIB_SRC) + + # transpose + print("""[[nodiscard]] __device__ inline constexpr auto lc_transpose(const lc_float2x2 m) noexcept { return lc_make_float2x2(m[0].x, m[1].x, m[0].y, m[1].y); } +[[nodiscard]] __device__ inline constexpr auto lc_transpose(const lc_float3x3 m) noexcept { return lc_make_float3x3(m[0].x, m[1].x, m[2].x, m[0].y, m[1].y, m[2].y, m[0].z, m[1].z, m[2].z); } +[[nodiscard]] __device__ inline constexpr auto lc_transpose(const lc_float4x4 m) noexcept { return lc_make_float4x4(m[0].x, m[1].x, m[2].x, m[3].x, m[0].y, m[1].y, m[2].y, m[3].y, m[0].z, m[1].z, m[2].z, m[3].z, m[0].w, m[1].w, m[2].w, m[3].w); } +""", file=CPP_LIB_SRC) + + # determinant/inverse + print("""[[nodiscard]] __device__ inline constexpr auto lc_determinant(const lc_float2x2 m) noexcept { +return m[0][0] * m[1][1] - m[1][0] * m[0][1]; +} + +[[nodiscard]] __device__ constexpr auto lc_determinant(const lc_float3x3 m) noexcept {// from GLM +return m[0].x * (m[1].y * m[2].z - m[2].y * m[1].z) + - m[1].x * (m[0].y * m[2].z - m[2].y * m[0].z) + + m[2].x * (m[0].y * m[1].z - m[1].y * m[0].z); +} + +[[nodiscard]] __device__ inline constexpr auto lc_determinant(const lc_float4x4 m) noexcept {// from GLM +const auto coef00 = m[2].z * m[3].w - m[3].z * m[2].w; +const auto coef02 = m[1].z * m[3].w - m[3].z * m[1].w; +const auto coef03 = m[1].z * m[2].w - m[2].z * m[1].w; +const auto coef04 = m[2].y * m[3].w - m[3].y * m[2].w; +const auto coef06 = m[1].y * m[3].w - m[3].y * m[1].w; +const auto coef07 = m[1].y * m[2].w - m[2].y * m[1].w; +const auto coef08 = m[2].y * m[3].z - m[3].y * m[2].z; +const auto coef10 = m[1].y * m[3].z - m[3].y * m[1].z; +const auto coef11 = m[1].y * m[2].z - m[2].y * m[1].z; +const auto coef12 = m[2].x * m[3].w - m[3].x * m[2].w; +const auto coef14 = m[1].x * m[3].w - m[3].x * m[1].w; +const auto coef15 = m[1].x * m[2].w - m[2].x * m[1].w; +const auto coef16 = m[2].x * m[3].z - m[3].x * m[2].z; +const auto coef18 = m[1].x * m[3].z - m[3].x * m[1].z; +const auto coef19 = m[1].x * m[2].z - m[2].x * m[1].z; +const auto coef20 = m[2].x * m[3].y - m[3].x * m[2].y; +const auto coef22 = m[1].x * m[3].y - m[3].x * m[1].y; +const auto coef23 = m[1].x * m[2].y - m[2].x * m[1].y; +const auto fac0 = lc_make_float4(coef00, coef00, coef02, coef03); +const auto fac1 = lc_make_float4(coef04, coef04, coef06, coef07); +const auto fac2 = lc_make_float4(coef08, coef08, coef10, coef11); +const auto fac3 = lc_make_float4(coef12, coef12, coef14, coef15); +const auto fac4 = lc_make_float4(coef16, coef16, coef18, coef19); +const auto fac5 = lc_make_float4(coef20, coef20, coef22, coef23); +const auto Vec0 = lc_make_float4(m[1].x, m[0].x, m[0].x, m[0].x); +const auto Vec1 = lc_make_float4(m[1].y, m[0].y, m[0].y, m[0].y); +const auto Vec2 = lc_make_float4(m[1].z, m[0].z, m[0].z, m[0].z); +const auto Vec3 = lc_make_float4(m[1].w, m[0].w, m[0].w, m[0].w); +const auto inv0 = Vec1 * fac0 - Vec2 * fac1 + Vec3 * fac2; +const auto inv1 = Vec0 * fac0 - Vec2 * fac3 + Vec3 * fac4; +const auto inv2 = Vec0 * fac1 - Vec1 * fac3 + Vec3 * fac5; +const auto inv3 = Vec0 * fac2 - Vec1 * fac4 + Vec2 * fac5; +constexpr auto sign_a = lc_make_float4(+1.0f, -1.0f, +1.0f, -1.0f); +constexpr auto sign_b = lc_make_float4(-1.0f, +1.0f, -1.0f, +1.0f); +const auto inv_0 = inv0 * sign_a; +const auto inv_1 = inv1 * sign_b; +const auto inv_2 = inv2 * sign_a; +const auto inv_3 = inv3 * sign_b; +const auto dot0 = m[0] * lc_make_float4(inv_0.x, inv_1.x, inv_2.x, inv_3.x); +return dot0.x + dot0.y + dot0.z + dot0.w; +} + +[[nodiscard]] __device__ inline constexpr auto lc_inverse(const lc_float2x2 m) noexcept { +const auto one_over_determinant = 1.0f / (m[0][0] * m[1][1] - m[1][0] * m[0][1]); +return lc_make_float2x2(m[1][1] * one_over_determinant, + - m[0][1] * one_over_determinant, + - m[1][0] * one_over_determinant, + + m[0][0] * one_over_determinant); +} + +[[nodiscard]] __device__ inline constexpr auto lc_inverse(const lc_float3x3 m) noexcept {// from GLM +const auto one_over_determinant = 1.0f + / (m[0].x * (m[1].y * m[2].z - m[2].y * m[1].z) + - m[1].x * (m[0].y * m[2].z - m[2].y * m[0].z) + + m[2].x * (m[0].y * m[1].z - m[1].y * m[0].z)); +return lc_make_float3x3( + (m[1].y * m[2].z - m[2].y * m[1].z) * one_over_determinant, + (m[2].y * m[0].z - m[0].y * m[2].z) * one_over_determinant, + (m[0].y * m[1].z - m[1].y * m[0].z) * one_over_determinant, + (m[2].x * m[1].z - m[1].x * m[2].z) * one_over_determinant, + (m[0].x * m[2].z - m[2].x * m[0].z) * one_over_determinant, + (m[1].x * m[0].z - m[0].x * m[1].z) * one_over_determinant, + (m[1].x * m[2].y - m[2].x * m[1].y) * one_over_determinant, + (m[2].x * m[0].y - m[0].x * m[2].y) * one_over_determinant, + (m[0].x * m[1].y - m[1].x * m[0].y) * one_over_determinant); +} + +[[nodiscard]] __device__ inline constexpr auto lc_inverse(const lc_float4x4 m) noexcept {// from GLM +const auto coef00 = m[2].z * m[3].w - m[3].z * m[2].w; +const auto coef02 = m[1].z * m[3].w - m[3].z * m[1].w; +const auto coef03 = m[1].z * m[2].w - m[2].z * m[1].w; +const auto coef04 = m[2].y * m[3].w - m[3].y * m[2].w; +const auto coef06 = m[1].y * m[3].w - m[3].y * m[1].w; +const auto coef07 = m[1].y * m[2].w - m[2].y * m[1].w; +const auto coef08 = m[2].y * m[3].z - m[3].y * m[2].z; +const auto coef10 = m[1].y * m[3].z - m[3].y * m[1].z; +const auto coef11 = m[1].y * m[2].z - m[2].y * m[1].z; +const auto coef12 = m[2].x * m[3].w - m[3].x * m[2].w; +const auto coef14 = m[1].x * m[3].w - m[3].x * m[1].w; +const auto coef15 = m[1].x * m[2].w - m[2].x * m[1].w; +const auto coef16 = m[2].x * m[3].z - m[3].x * m[2].z; +const auto coef18 = m[1].x * m[3].z - m[3].x * m[1].z; +const auto coef19 = m[1].x * m[2].z - m[2].x * m[1].z; +const auto coef20 = m[2].x * m[3].y - m[3].x * m[2].y; +const auto coef22 = m[1].x * m[3].y - m[3].x * m[1].y; +const auto coef23 = m[1].x * m[2].y - m[2].x * m[1].y; +const auto fac0 = lc_make_float4(coef00, coef00, coef02, coef03); +const auto fac1 = lc_make_float4(coef04, coef04, coef06, coef07); +const auto fac2 = lc_make_float4(coef08, coef08, coef10, coef11); +const auto fac3 = lc_make_float4(coef12, coef12, coef14, coef15); +const auto fac4 = lc_make_float4(coef16, coef16, coef18, coef19); +const auto fac5 = lc_make_float4(coef20, coef20, coef22, coef23); +const auto Vec0 = lc_make_float4(m[1].x, m[0].x, m[0].x, m[0].x); +const auto Vec1 = lc_make_float4(m[1].y, m[0].y, m[0].y, m[0].y); +const auto Vec2 = lc_make_float4(m[1].z, m[0].z, m[0].z, m[0].z); +const auto Vec3 = lc_make_float4(m[1].w, m[0].w, m[0].w, m[0].w); +const auto inv0 = Vec1 * fac0 - Vec2 * fac1 + Vec3 * fac2; +const auto inv1 = Vec0 * fac0 - Vec2 * fac3 + Vec3 * fac4; +const auto inv2 = Vec0 * fac1 - Vec1 * fac3 + Vec3 * fac5; +const auto inv3 = Vec0 * fac2 - Vec1 * fac4 + Vec2 * fac5; +constexpr auto sign_a = lc_make_float4(+1.0f, -1.0f, +1.0f, -1.0f); +constexpr auto sign_b = lc_make_float4(-1.0f, +1.0f, -1.0f, +1.0f); +const auto inv_0 = inv0 * sign_a; +const auto inv_1 = inv1 * sign_b; +const auto inv_2 = inv2 * sign_a; +const auto inv_3 = inv3 * sign_b; +const auto dot0 = m[0] * lc_make_float4(inv_0.x, inv_1.x, inv_2.x, inv_3.x); +const auto dot1 = dot0.x + dot0.y + dot0.z + dot0.w; +const auto one_over_determinant = 1.0f / dot1; +return lc_make_float4x4(inv_0 * one_over_determinant, + inv_1 * one_over_determinant, + inv_2 * one_over_determinant, + inv_3 * one_over_determinant); +} + +[[nodiscard]] __device__ inline auto lc_reflect(const lc_float3 v, const lc_float3 n) noexcept { +return v - 2.0f * lc_dot(v, n) * n; +} + +template +[[nodiscard]] __device__ inline auto lc_bit_cast(S s) noexcept { +static_assert(sizeof(D) == sizeof(S)); +return reinterpret_cast(s); +} +template +[[nodiscard]] __device__ inline constexpr auto lc_zero() noexcept { +return T{}; +} +template +[[nodiscard]] __device__ inline constexpr auto lc_one() noexcept { +return T::one(); +} +template<> +[[nodiscard]] __device__ inline constexpr auto lc_one() noexcept { +return lc_int(1); +} +template<> +[[nodiscard]] __device__ inline constexpr auto lc_one() noexcept { +return lc_float(1.0f); +} +template<> +[[nodiscard]] __device__ inline auto lc_one() noexcept { +return lc_half(1.0f); +} +template<> +[[nodiscard]] __device__ inline constexpr auto lc_one() noexcept { +return lc_uint(1u); +} +template<> +[[nodiscard]] __device__ inline constexpr auto lc_one() noexcept { +return lc_long(1); +} +template<> +[[nodiscard]] __device__ inline constexpr auto lc_one() noexcept { +return lc_ulong(1); +} +template<> +[[nodiscard]] __device__ inline constexpr auto lc_one() noexcept { +return lc_short(1); +} +template<> +[[nodiscard]] __device__ inline constexpr auto lc_one() noexcept { +return lc_ushort(1); +} +template<> +[[nodiscard]] __device__ inline constexpr auto lc_one() noexcept { +return lc_byte(1); +} +template<> +[[nodiscard]] __device__ inline constexpr auto lc_one() noexcept { +return lc_ubyte(1); +} +template<> +[[nodiscard]] __device__ inline constexpr auto lc_one() noexcept { +return true; +} +template +class lc_array { + +private: +T _data[N]; + +public: +template +__device__ constexpr lc_array(Elem... elem) noexcept : _data{elem...} {} +__device__ constexpr lc_array(lc_array &&) noexcept = default; +__device__ constexpr lc_array(const lc_array &) noexcept = default; +__device__ constexpr lc_array &operator=(lc_array &&) noexcept = default; +__device__ constexpr lc_array &operator=(const lc_array &) noexcept = default; +[[nodiscard]] __device__ T &operator[](size_t i) noexcept { return _data[i]; } +[[nodiscard]] __device__ T operator[](size_t i) const noexcept { return _data[i]; } + +public: +[[nodiscard]] __device__ static auto one() noexcept { + lc_array ret; + #pragma unroll + for (auto i = 0u; i < N; i++) { ret[i] = lc_one(); } + return ret; +} }; + +[[nodiscard]] __device__ inline auto lc_mat_comp_mul(lc_float2x2 lhs, lc_float2x2 rhs) noexcept { +return lc_make_float2x2(lhs[0] * rhs[0], + lhs[1] * rhs[1]); +} + +[[nodiscard]] __device__ inline auto lc_mat_comp_mul(lc_float3x3 lhs, lc_float3x3 rhs) noexcept { +return lc_make_float3x3(lhs[0] * rhs[0], + lhs[1] * rhs[1], + lhs[2] * rhs[2]); +} + +[[nodiscard]] __device__ inline auto lc_mat_comp_mul(lc_float4x4 lhs, lc_float4x4 rhs) noexcept { +return lc_make_float4x4(lhs[0] * rhs[0], + lhs[1] * rhs[1], + lhs[2] * rhs[2], + lhs[3] * rhs[3]); +} """, file=CPP_LIB_SRC) + print('''template struct element_type_{using type = void;}; +template using element_type = typename element_type_::type; +''', file=CPP_LIB_SRC) + + def gen_element_type(vt, et): + print( + f'''template<> struct element_type_<{vt}> {{ using type = {et}; }};''', file=CPP_LIB_SRC) + + for vt in ['lc_float2', 'lc_float3', 'lc_float4']: + gen_element_type(vt, "lc_float") + for vt in ['lc_half2', 'lc_half3', 'lc_half4']: + gen_element_type(vt, "lc_half") + for vt in ['lc_short2', 'lc_short3', 'lc_short4']: + gen_element_type(vt, 'lc_short') + for vt in ['lc_ushort2', 'lc_ushort3', 'lc_ushort4']: + gen_element_type(vt, 'lc_ushort') + for vt in ['lc_byte2', 'lc_byte3', 'lc_byte4']: + gen_element_type(vt, 'lc_byte') + for vt in ['lc_ubyte2', 'lc_ubyte3', 'lc_ubyte4']: + gen_element_type(vt, 'lc_ubyte') + for vt in ['lc_int2', 'lc_int3', 'lc_int4']: + gen_element_type(vt, 'lc_int') + for vt in ['lc_uint2', 'lc_uint3', 'lc_uint4']: + gen_element_type(vt, 'lc_uint') + for vt in ['lc_long2', 'lc_long3', 'lc_long4']: + gen_element_type(vt, 'lc_long') + for vt in ['lc_ulong2', 'lc_ulong3', 'lc_ulong4']: + gen_element_type(vt, 'lc_ulong') + + +gen_cpp_lib() -_OPERATORS: Dict[str, str] = { - '__add__': '+', - '__sub__': '-', - '__mul__': '*', - '__truediv__': '/', -} -for op, cpp_op in _OPERATORS.items(): - print(f"""template -requires requires(T a, T b) {{ a {cpp_op} b; }} -T __builtin__{op}(T x, T y) -{{ - return x {cpp_op} y; -}}""", file=CPP_LIB_SRC) with open('scripts/cpp_lib.hpp', 'w') as f: f.write(CPP_LIB_SRC.getvalue()) +compressed = compress(CPP_LIB_SRC.getvalue()) +with open('luisa_lang/codegen/cpp_lib.py', 'w') as f: + f.write(f'CPP_LIB_COMPRESSED = """{compressed}"""') diff --git a/scripts/gen_math_types.py b/scripts/gen_math_types.py index 67f9f77..b9ccfa4 100644 --- a/scripts/gen_math_types.py +++ b/scripts/gen_math_types.py @@ -52,7 +52,7 @@ def print(s: str) -> None: print("# fmt: off") print("import typing as tp") print( - "from luisa_lang._builtin_decor import intrinsic, func, builtin_type", + "from luisa_lang._builtin_decor import intrinsic, func, builtin_type, byref", ) print( "from luisa_lang.classinfo import register_class", @@ -63,10 +63,12 @@ def print(s: str) -> None: def gen_float_builtins(): print("class FloatBuiltin(tp.Generic[_F]):") for builtin in FLOAT_BULTINS_1: - print(f" def {builtin}(self: _F) -> _F: return intrinsic('{builtin}', _F) # type: ignore") + print(" @func(inline='always')") + print(f" def {builtin}(self: _F) -> _F: return intrinsic('math.{builtin}', _F, self) # type: ignore") for builtin in FLOAT_BULTINS_2: + print(" @func(inline='always')") print( - f" def {builtin}(self: _F, _other: _F) -> _F: return intrinsic('{builtin}', _F) # type: ignore" + f" def {builtin}(self: _F, _other: _F) -> _F: return intrinsic('math.{builtin}', _F, self, other) # type: ignore" ) print("") for builtin in FLOAT_BULTINS_1: @@ -79,17 +81,19 @@ def gen_float_builtins(): ) print("register_class(FloatBuiltin)") - def gen_binop(op: str, ty: str, operand_ty: str): + def gen_binop(op: str, ty: str, operand_ty: str, inplace=False): print( f""" - def {op}(self, _other: {operand_ty}) -> '{ty}': return intrinsic("{op}.{ty}", {ty}, _other) + @func(inline='always') + def {op}(self, _other: {operand_ty}) -> '{ty}': return intrinsic("binop.{op}.{ty}", {ty}, {'self' if not inplace else 'byref(self)'}, _other) """ ) def gen_cmpop(op: str, ty: str, operand_ty: str,retrun_ty:str): print( f""" - def {op}(self, _other: {operand_ty}) -> '{retrun_ty}': return intrinsic("{op}.{ty}", {retrun_ty}, _other) # type: ignore[override] + @func(inline='always') + def {op}(self, _other: {operand_ty}) -> '{retrun_ty}': return intrinsic("cmp.{op}.{ty}", {retrun_ty}, self, _other) # type: ignore[override] """ ) @@ -99,7 +103,7 @@ def gen(op: str, inplace: bool = True): gen_binop(f"__r{op}__", ty, operand_ty) # gen in-place version if inplace: - gen_binop(f"__i{op}__", ty, operand_ty) + gen_binop(f"__i{op}__", ty, operand_ty, inplace=True) if kind != Kind.BOOL: gen("add") @@ -129,7 +133,8 @@ def gen(op: str, inplace: bool = True): def gen_unaryop(op: str, ty: str): print( f""" - def __{op}__(self) -> '{ty}': return intrinsic("{op}.{ty}", {ty}) + @func(inline='always') + def __{op}__(self) -> '{ty}': return intrinsic("unary.__{op}__.{ty}", {ty}, self) """) def gen_scalar_type(ty: str, literal_ty: str, kind: Kind): @@ -148,6 +153,7 @@ def gen_scalar_type(ty: str, literal_ty: str, kind: Kind): print( f"""@builtin_type({hir_ty}) class {ty}{inherits_str}: + @func(inline='always') def __init__(self, _value: tp.Union['{ty}', {literal_ty}]) -> None: self = intrinsic("init.{ty}", {ty}, _value) """ diff --git a/src/compiler.rs b/src/compiler.rs deleted file mode 100644 index 79cf694..0000000 --- a/src/compiler.rs +++ /dev/null @@ -1,3 +0,0 @@ -pub struct Compiler { - -} \ No newline at end of file diff --git a/src/hir.rs b/src/hir.rs deleted file mode 100644 index 7431b8e..0000000 --- a/src/hir.rs +++ /dev/null @@ -1,12 +0,0 @@ -use serde::{Deserialize, Serialize}; -pub type StringPool = Vec; -#[derive(Serialize, Deserialize, Clone, Debug)] -pub struct Module { - pub name: StringRef, - pub functions: Vec, -} -#[derive(Serialize, Deserialize, Clone, Debug)] -pub struct StringRef(pub u32); - -#[derive(Serialize, Deserialize, Clone, Debug)] -pub struct Function {} diff --git a/src/lib.rs b/src/lib.rs index 00da515..dd198c6 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -1,2 +1 @@ -pub mod hir; -pub mod compiler; \ No newline at end of file +pub mod types; \ No newline at end of file diff --git a/src/types.rs b/src/types.rs new file mode 100644 index 0000000..c491af1 --- /dev/null +++ b/src/types.rs @@ -0,0 +1,182 @@ +#[cfg(feature = "glam")] +use glam::{Mat2, Mat3, Mat4}; + +pub type Byte = i8; +pub type Ubyte = u8; +pub type Short = i16; +pub type Ushort = u16; +pub type Int = i32; +pub type Uint = u32; +pub type Long = i64; +pub type Ulong = u64; +pub type Float = f32; +pub type Double = f64; + +macro_rules! define_vector { + ($name:ident, $scalar:ty, $glam_name:ty, $align:literal, $($comps:ident),+) => { + #[repr(C, align($align))] + pub struct $name { + $(pub $comps: $scalar),+ + } + impl $name { + pub fn new($($comps: $scalar),+) -> Self { + Self { + $($comps),+ + } + } + } + #[cfg(feature = "glam")] + impl From<$name> for $glam_name { + fn from(v: $name) -> Self { + Self::new($(v.$comps),+) + } + } + #[cfg(feature = "glam")] + impl From<$glam_name> for $name { + fn from(v: $glam_name) -> Self { + Self::new($(v.$comps as $scalar),+) + } + } + }; + ($name:ident, $scalar:ty, $align:literal, $($comps:ident),+) => { + #[repr(C, align($align))] + pub struct $name { + $(pub $comps: $scalar),+ + } + impl $name { + pub fn new($($comps: $scalar),+) -> Self { + Self { + $($comps),+ + } + } + } + } +} +define_vector!(Byte2, Byte, glam::I8Vec2, 2, x, y); +define_vector!(Byte3, Byte, glam::I8Vec3, 4, x, y, z); +define_vector!(Byte4, Byte, glam::I8Vec4, 4, x, y, z, w); + +define_vector!(Ubyte2, Ubyte, glam::U8Vec2, 2, x, y); +define_vector!(Ubyte3, Ubyte, glam::U8Vec3, 4, x, y, z); +define_vector!(Ubyte4, Ubyte, glam::U8Vec4, 4, x, y, z, w); + +define_vector!(Short2, Short, glam::I16Vec2, 4, x, y); +define_vector!(Short3, Short, glam::I16Vec3, 8, x, y, z); +define_vector!(Short4, Short, glam::I16Vec4, 8, x, y, z, w); + +define_vector!(Ushort2, Ushort, glam::U16Vec2, 4, x, y); +define_vector!(Ushort3, Ushort, glam::U16Vec3, 8, x, y, z); +define_vector!(Ushort4, Ushort, glam::U16Vec4, 8, x, y, z, w); + +define_vector!(Int2, Int, glam::IVec2, 8, x, y); +define_vector!(Int3, Int, glam::IVec3, 16, x, y, z); +define_vector!(Int4, Int, glam::IVec4, 16, x, y, z, w); + +define_vector!(Uint2, Uint, glam::UVec2, 8, x, y); +define_vector!(Uint3, Uint, glam::UVec3, 16, x, y, z); +define_vector!(Uint4, Uint, glam::UVec4, 16, x, y, z, w); + +define_vector!(Float2, Float, glam::Vec2, 8, x, y); +define_vector!(Float3, Float, glam::Vec3, 16, x, y, z); +define_vector!(Float4, Float, glam::Vec4, 16, x, y, z, w); + +define_vector!(Double2, Double, glam::DVec2, 16, x, y); +define_vector!(Double3, Double, glam::DVec3, 32, x, y, z); +define_vector!(Double4, Double, glam::DVec4, 32, x, y, z, w); + +define_vector!(Float2x2, Float2, 8, x, y); +define_vector!(Float3x3, Float3, 16, x, y, z); +define_vector!(Float4x4, Float4, 16, x, y, z, w); + +define_vector!(Double2x2, Double2, 16, x, y); +define_vector!(Double3x3, Double3, 32, x, y, z); +define_vector!(Double4x4, Double4, 32, x, y, z, w); + +#[cfg(feature = "glam")] +mod _convert { + use super::*; + impl From for Float2x2 { + fn from(m: Mat2) -> Self { + Self::new( + Float2::new(m.x_axis.x, m.x_axis.y), + Float2::new(m.y_axis.x, m.y_axis.y), + ) + } + } + impl From for Mat2 { + fn from(m: Float2x2) -> Self { + Mat2::from_cols(m.x.into(), m.y.into()) + } + } + impl From for Float3x3 { + fn from(m: Mat3) -> Self { + Self::new( + Float3::new(m.x_axis.x, m.x_axis.y, m.x_axis.z), + Float3::new(m.y_axis.x, m.y_axis.y, m.y_axis.z), + Float3::new(m.z_axis.x, m.z_axis.y, m.z_axis.z), + ) + } + } + impl From for Mat3 { + fn from(m: Float3x3) -> Self { + Mat3::from_cols(m.x.into(), m.y.into(), m.z.into()) + } + } + impl From for Float4x4 { + fn from(m: Mat4) -> Self { + Self::new( + Float4::new(m.x_axis.x, m.x_axis.y, m.x_axis.z, m.x_axis.w), + Float4::new(m.y_axis.x, m.y_axis.y, m.y_axis.z, m.y_axis.w), + Float4::new(m.z_axis.x, m.z_axis.y, m.z_axis.z, m.z_axis.w), + Float4::new(m.w_axis.x, m.w_axis.y, m.w_axis.z, m.w_axis.w), + ) + } + } + impl From for Mat4 { + fn from(m: Float4x4) -> Self { + Mat4::from_cols(m.x.into(), m.y.into(), m.z.into(), m.w.into()) + } + } + impl From for Double2x2 { + fn from(m: glam::DMat2) -> Self { + Self::new( + Double2::new(m.x_axis.x, m.x_axis.y), + Double2::new(m.y_axis.x, m.y_axis.y), + ) + } + } + impl From for glam::DMat2 { + fn from(m: Double2x2) -> Self { + glam::DMat2::from_cols(m.x.into(), m.y.into()) + } + } + impl From for Double3x3 { + fn from(m: glam::DMat3) -> Self { + Self::new( + Double3::new(m.x_axis.x, m.x_axis.y, m.x_axis.z), + Double3::new(m.y_axis.x, m.y_axis.y, m.y_axis.z), + Double3::new(m.z_axis.x, m.z_axis.y, m.z_axis.z), + ) + } + } + impl From for glam::DMat3 { + fn from(m: Double3x3) -> Self { + glam::DMat3::from_cols(m.x.into(), m.y.into(), m.z.into()) + } + } + impl From for Double4x4 { + fn from(m: glam::DMat4) -> Self { + Self::new( + Double4::new(m.x_axis.x, m.x_axis.y, m.x_axis.z, m.x_axis.w), + Double4::new(m.y_axis.x, m.y_axis.y, m.y_axis.z, m.y_axis.w), + Double4::new(m.z_axis.x, m.z_axis.y, m.z_axis.z, m.z_axis.w), + Double4::new(m.w_axis.x, m.w_axis.y, m.w_axis.z, m.w_axis.w), + ) + } + } + impl From for glam::DMat4 { + fn from(m: Double4x4) -> Self { + glam::DMat4::from_cols(m.x.into(), m.y.into(), m.z.into(), m.w.into()) + } + } +}