Support FP16 (#471)

This change is the initial step for supporting fp16.

Support half type with /no-min-precision option. This switch can be moved to other master switch in the future as we refine our spec for half support. 
min16float will be treated as half with warnings.
Fix compiler test to take additional arguments, and fix regression tests.
TODO: we need to make decisions on what triggers low precision instead of min precision. Also need to change signature packing and constant buffers for half.

include/dxc/Support/HLSLOptions.h

@@ -132,6 +132,7 @@ public:
   bool HLSL2015;  // OPT_hlsl_version (=2015)
   bool HLSL2016;  // OPT_hlsl_version (=2016)
   bool HLSL2017;  // OPT_hlsl_version (=2017)
+  bool NoMinPrecision; // OPT_no_min_precision
   bool OptDump; // OPT_ODump - dump optimizer commands
   bool OutputWarnings = true; // OPT_no_warnings
   bool ShowHelp = false;  // OPT_help

include/dxc/Support/HLSLOptions.td

@@ -229,7 +229,8 @@ def no_warnings : Flag<["-", "/"], "no-warnings">, Group<hlslcomp_Group>, Flags<
   HelpText<"Suppress warnings">;
 def rootsig_define : Separate<["-", "/"], "rootsig-define">, Group<hlslcomp_Group>, Flags<[CoreOption]>,
   HelpText<"Read root signature from a #define">;
-
+def no_min_precision: Flag<["-", "/"], "no-min-precision">, Flags<[CoreOption, DriverOption, HelpHidden]>,
+  HelpText<"Do not use min precision but use strict precision types.">;
 //////////////////////////////////////////////////////////////////////////////
 // fxc-based flags that don't match those previously defined.
 

lib/DxcSupport/HLSLOptions.cpp

@@ -268,6 +268,7 @@ int ReadDxcOpts(const OptTable *optionTable, unsigned flagsToInclude,
   opts.AssemblyCode = Args.getLastArgValue(OPT_Fc);
   opts.DebugFile = Args.getLastArgValue(OPT_Fd);
   opts.ExtractPrivateFile = Args.getLastArgValue(OPT_getprivate);
+  opts.NoMinPrecision = Args.hasFlag(OPT_no_min_precision, OPT_INVALID, false);
   opts.OutputObject = Args.getLastArgValue(OPT_Fo);
   opts.OutputHeader = Args.getLastArgValue(OPT_Fh);
   opts.OutputWarningsFile = Args.getLastArgValue(OPT_Fe);

tools/clang/include/clang/Basic/LangOptions.h

@@ -156,6 +156,7 @@ public:
   unsigned RootSigMajor;
   unsigned RootSigMinor;
   bool IsHLSLLibrary;
+  bool NoMinPrecision; // use strict precision, not min precision.
   // MS Change Ends
   
   bool isSignedOverflowDefined() const {

tools/clang/include/clang/Driver/Options.td

@@ -678,6 +678,8 @@ def fmsc_version : Joined<["-"], "fmsc-version=">, Group<f_Group>, Flags<[Driver
   HelpText<"Microsoft compiler version number to report in _MSC_VER (0 = don't define it (default))">;
 def hlsl_version : Separate<["-", "/"], "HV">, Group<f_Group>, Flags<[DriverOption, CoreOption, CC1Option]>,
   HelpText<"HLSL version (2015, 2016, 2017)">; // HLSL Change - mimic the HLSLOptions.td flag
+def no_min_precision : Flag<["-", "/"], "no-min-precision">, Group<f_Group>, Flags<[CoreOption, DriverOption, HelpHidden, CC1Option]>,
+  HelpText<"Do not use min precision but use strict precision types.">; // HLSL Change - mimic the HLSLOptions.td flag
 def fms_compatibility_version
     : Joined<["-"], "fms-compatibility-version=">,
       Group<f_Group>,

tools/clang/include/clang/Lex/LiteralSupport.h

@@ -62,6 +62,9 @@ public:
   bool isLong : 1;          // This is *not* set for long long.
   bool isLongLong : 1;
   bool isFloat : 1;         // 1.0f
+  // HLSL Change Begin
+  bool isHalf : 1;          // 1.0h
+  // HLSL Change End
   bool isImaginary : 1;     // 1.0i
   uint8_t MicrosoftInteger; // Microsoft suffix extension i8, i16, i32, or i64.
 

tools/clang/lib/Frontend/CompilerInvocation.cpp

@@ -1730,6 +1730,10 @@ static void ParseLangArgs(LangOptions &Opts, ArgList &Args, InputKind IK,
       << Args.getLastArg(OPT_hlsl_version)->getAsString(Args)
       << ver;
   }
+
+  // Enable low precision for HLSL 2018
+  // TODO: should we tie low precision to HLSL2018 only?
+  Opts.NoMinPrecision = Args.hasArg(options::OPT_no_min_precision);
 #endif // #ifdef MS_SUPPORT_VARIABLE_LANGOPTS
 }
 

tools/clang/lib/Lex/LiteralSupport.cpp

@@ -523,6 +523,7 @@ NumericLiteralParser::NumericLiteralParser(StringRef TokSpelling,
   isUnsigned = false;
   isLongLong = false;
   isFloat = false;
+  isHalf = false; // HLSL Change
   isImaginary = false;
   MicrosoftInteger = 0;
   hadError = false;
@@ -581,15 +582,19 @@ NumericLiteralParser::NumericLiteralParser(StringRef TokSpelling,
     switch (*s) {
     case 'f':      // FP Suffix for "float"
     case 'F':
+     if (!isFPConstant) break;  // Error for integer constant.
+      if (isFloat || isLong) break; // FF, LF invalid.
+      isFloat = true;
+      continue;  // Success.
 // HLSL Change Starts
 // TODO : When we support true half type, these suffixes should be treated differently from f/F
     case 'h':
     case 'H':
+      if (!isFPConstant) break;
+        if (isHalf) break;
+        isHalf = true;
+        continue;
 // HLSL Change Ends
-      if (!isFPConstant) break;  // Error for integer constant.
-      if (isFloat || isLong) break; // FF, LF invalid.
-      isFloat = true;
-      continue;  // Success.
     case 'u':
     case 'U':
       if (isFPConstant) break;  // Error for floating constant.

tools/clang/lib/Sema/SemaExpr.cpp

@@ -3362,12 +3362,16 @@ ExprResult Sema::ActOnNumericConstant(const Token &Tok, Scope *UDLScope) {
   if (Literal.isFloatingLiteral()) {
     QualType Ty;
     if (Literal.isFloat)
+
       Ty = Context.FloatTy;
     // HLSL Change Starts
-    else if (getLangOpts().HLSL && !Literal.isLong)
+    else if (getLangOpts().HLSL && !Literal.isLong && !Literal.isHalf)
       Ty = Context.LitFloatTy;
     else if (getLangOpts().HLSL && Literal.isLong)
       Ty = Context.DoubleTy;
+    else if (getLangOpts().HLSL && Literal.isHalf) {
+      Ty = getLangOpts().NoMinPrecision ? Context.HalfTy : Context.FloatTy;
+    }
     // HLSL Change Ends
     else if (!Literal.isLong)
       Ty = Context.DoubleTy;

tools/clang/lib/Sema/SemaHLSL.cpp

@@ -894,7 +894,7 @@ static const ArBasicKind g_AnyFloatCT[] =
 {
   AR_BASIC_FLOAT32,
   AR_BASIC_FLOAT32_PARTIAL_PRECISION,
-  // TODO - AR_BASIC_FLOAT16,
+  AR_BASIC_FLOAT16,
   AR_BASIC_FLOAT64,
   AR_BASIC_LITERAL_FLOAT,
   AR_BASIC_MIN10FLOAT,
@@ -906,6 +906,7 @@ static const ArBasicKind g_FloatLikeCT[] =
 {
   AR_BASIC_FLOAT32,
   AR_BASIC_FLOAT32_PARTIAL_PRECISION,
+  AR_BASIC_FLOAT16,
   AR_BASIC_LITERAL_FLOAT,
   AR_BASIC_MIN10FLOAT,
   AR_BASIC_MIN16FLOAT,
@@ -940,7 +941,7 @@ static const ArBasicKind g_NumericCT[] =
   AR_BASIC_LITERAL_FLOAT,
   AR_BASIC_FLOAT32,
   AR_BASIC_FLOAT32_PARTIAL_PRECISION,
-  // TODO - AR_BASIC_FLOAT16,
+  AR_BASIC_FLOAT16,
   AR_BASIC_FLOAT64,
   AR_BASIC_MIN10FLOAT,
   AR_BASIC_MIN16FLOAT,
@@ -983,7 +984,7 @@ static const ArBasicKind g_AnyCT[] =
   AR_BASIC_LITERAL_FLOAT,
   AR_BASIC_FLOAT32,
   AR_BASIC_FLOAT32_PARTIAL_PRECISION,
-  // TODO - AR_BASIC_FLOAT16,
+  AR_BASIC_FLOAT16,
   AR_BASIC_FLOAT64,
   AR_BASIC_MIN10FLOAT,
   AR_BASIC_MIN16FLOAT,
@@ -1299,7 +1300,7 @@ C_ASSERT(_countof(g_ArBasicKindsAsTypes) == _countof(g_ArBasicKindsSubscripts));
 static
 const char* g_ArBasicTypeNames[] =
 {
-  "bool", "float", "<float16>", "half", "float", "double",
+  "bool", "float", "half", "half", "float", "double",
   "int", "sbyte", "byte", "short", "ushort",
   "int", "uint", "long", "ulong",
   "min10float", "min16float",
@@ -3036,25 +3037,28 @@ public:
 
   void WarnMinPrecision(HLSLScalarType type, SourceLocation loc) {
     // TODO: enalbe this once we introduce precise master option
-    bool isMinPrecisionAllowed = true;
+    bool NoMinPrecision = m_context->getLangOpts().NoMinPrecision;
     if (type == HLSLScalarType_int_min12) {
-      const char *PromotedType = isMinPrecisionAllowed? "min16int" : "int16";
+      const char *PromotedType = "min16int"; // TODO: print int16 once we support true int16/uint16 support.
       m_sema->Diag(loc, diag::warn_hlsl_sema_minprecision_promotion) << "min12int" << PromotedType;
     }
     else if (type == HLSLScalarType_float_min10) {
-      const char *PromotedType =  isMinPrecisionAllowed? "min16float" : "half";
+      const char *PromotedType = NoMinPrecision ? "half": "min16float";
       m_sema->Diag(loc, diag::warn_hlsl_sema_minprecision_promotion) << "min10float" << PromotedType;
     }
-    if (!isMinPrecisionAllowed) {
+    if (NoMinPrecision) {
       if (type == HLSLScalarType_float_min16) {
         m_sema->Diag(loc, diag::warn_hlsl_sema_minprecision_promotion) << "min16float" << "half";
       }
+// TODO: Enable this once we support true int16/uint16 support.
+#if 0
       else if (type == HLSLScalarType_int_min16) {
         m_sema->Diag(loc, diag::warn_hlsl_sema_minprecision_promotion) << "min16int" << "int16";
       }
       else if (type == HLSLScalarType_uint_min16) {
         m_sema->Diag(loc, diag::warn_hlsl_sema_minprecision_promotion) << "min16uint" << "uint16";
       }
+#endif
     }
   }
 
@@ -3283,7 +3287,7 @@ public:
       case BuiltinType::Bool: return AR_BASIC_BOOL;
       case BuiltinType::Double: return AR_BASIC_FLOAT64;
       case BuiltinType::Float: return AR_BASIC_FLOAT32;
-      case BuiltinType::Half: return AR_BASIC_MIN16FLOAT;  // rather than AR_BASIC_FLOAT16
+      case BuiltinType::Half: return m_context->getLangOpts().NoMinPrecision ? AR_BASIC_FLOAT16 : AR_BASIC_MIN16FLOAT;
       case BuiltinType::Int: return AR_BASIC_INT32;
       case BuiltinType::UInt: return AR_BASIC_UINT32;
       case BuiltinType::Short: return AR_BASIC_MIN16INT;    // rather than AR_BASIC_INT16
@@ -3390,7 +3394,7 @@ public:
     case AR_OBJECT_NULL:          return m_context->VoidTy;
     case AR_BASIC_BOOL:           return m_context->BoolTy;
     case AR_BASIC_LITERAL_FLOAT:  return m_context->LitFloatTy;
-    case AR_BASIC_FLOAT16:        return m_context->FloatTy;
+    case AR_BASIC_FLOAT16:        return m_context->getLangOpts().NoMinPrecision ? m_context->HalfTy : m_context->FloatTy;
     case AR_BASIC_FLOAT32_PARTIAL_PRECISION: return m_context->FloatTy;
     case AR_BASIC_FLOAT32:        return m_context->FloatTy;
     case AR_BASIC_FLOAT64:        return m_context->DoubleTy;
@@ -4420,7 +4424,7 @@ void HLSLExternalSource::AddBaseTypes()
   m_baseTypes[HLSLScalarType_int] = m_context->IntTy;
   m_baseTypes[HLSLScalarType_uint] = m_context->UnsignedIntTy;
   m_baseTypes[HLSLScalarType_dword] = m_context->UnsignedIntTy;
-  m_baseTypes[HLSLScalarType_half] = m_context->FloatTy;
+  m_baseTypes[HLSLScalarType_half] = m_context->getLangOpts().NoMinPrecision ? m_context->HalfTy : m_context->FloatTy;
   m_baseTypes[HLSLScalarType_float] = m_context->FloatTy;
   m_baseTypes[HLSLScalarType_double] = m_context->DoubleTy;
   m_baseTypes[HLSLScalarType_float_min10] = m_context->HalfTy;
@@ -5623,6 +5627,7 @@ bool HLSLExternalSource::IsPromotion(ArBasicKind leftKind, ArBasicKind rightKind
   case AR_BASIC_MIN10FLOAT:
     switch (leftKind) {
     case AR_BASIC_MIN16FLOAT:
+    case AR_BASIC_FLOAT16:
     case AR_BASIC_FLOAT32:
     case AR_BASIC_FLOAT32_PARTIAL_PRECISION:
     case AR_BASIC_FLOAT64:
@@ -5631,6 +5636,7 @@ bool HLSLExternalSource::IsPromotion(ArBasicKind leftKind, ArBasicKind rightKind
     break;
   case AR_BASIC_MIN16FLOAT:
     switch (leftKind) {
+    case AR_BASIC_FLOAT16:
     case AR_BASIC_FLOAT32:
     case AR_BASIC_FLOAT32_PARTIAL_PRECISION:
     case AR_BASIC_FLOAT64:

tools/clang/test/CodeGenHLSL/if6.hlsl

@@ -1,4 +1,4 @@
-// RUN: %dxc -E main -T ps_6_0 /Gfa %s
+// RUN: %dxc -E main -T ps_6_0 /Gfa /all_resources_bound %s | FileCheck %s
 
 // CHECK: !"dx.controlflow.hints", i32 2
 // CHECK: !"dx.controlflow.hints", i32 2

tools/clang/test/CodeGenHLSL/if7.hlsl

@@ -1,4 +1,4 @@
-// RUN: %dxc -E main -T ps_6_0 /Gfp %s
+// RUN: %dxc -E main -T ps_6_0 /Gfp %s | FileCheck %s
 
 // CHECK: !"dx.controlflow.hints", i32 1
 // CHECK: !"dx.controlflow.hints", i32 1

tools/clang/test/CodeGenHLSL/literals_exact_precision_Mod.hlsl

@@ -0,0 +1,122 @@
+// RUN: %dxc -no-min-precision -E test -T vs_6_0 %s
+
+// To test with the classic compiler, run
+// %sdxroot%\tools\x86\fxc.exe /T ps_5_1 literals.hlsl
+
+// without also putting them in a static assertion
+
+// __decltype is the GCC way of saying 'decltype', but doesn't require C++11
+#define VERIFY_FXC
+#ifdef VERIFY_FXC
+#define VERIFY_TYPES(typ, exp) {typ _tmp_var_ = exp;}
+#else
+#endif
+
+float overload1(float v) { return (float)100; }             /* expected-note {{candidate function}} expected-note {{candidate function}} expected-note {{candidate function}} expected-note {{candidate function}} fxc-pass {{}} */
+int overload1(int v) { return (int)200; }                   /* expected-note {{candidate function}} expected-note {{candidate function}} expected-note {{candidate function}} expected-note {{candidate function}} fxc-pass {{}} */
+uint overload1(uint v) { return (uint)300; }                /* expected-note {{candidate function}} expected-note {{candidate function}} expected-note {{candidate function}} expected-note {{candidate function}} fxc-pass {{}} */
+bool overload1(bool v) { return (bool)400; }                /* expected-note {{candidate function}} expected-note {{candidate function}} expected-note {{candidate function}} expected-note {{candidate function}} fxc-pass {{}} */
+double overload1(double v) { return (double)500; }          /* expected-note {{candidate function}} expected-note {{candidate function}} expected-note {{candidate function}} expected-note {{candidate function}} fxc-pass {{}} */
+int64_t overload1(int64_t v) { return (int64_t)600; }                   /* expected-note {{candidate function}} expected-note {{candidate function}} expected-note {{candidate function}} expected-note {{candidate function}} fxc-pass {{}} */
+uint64_t overload1(uint64_t v) { return (uint64_t)700; }                /* expected-note {{candidate function}} expected-note {{candidate function}} expected-note {{candidate function}} expected-note {{candidate function}} fxc-pass {{}} */
+half overload1(half v) { return (half)800; }
+
+float overload2(float v1, float v2) { return (float)100; }
+int overload2(int v1, int v2) { return (int)200; }
+uint overload2(uint v1, uint v2) { return (uint)300; }
+bool overload2(bool v1, bool v2) { return (bool)400; }
+double overload2(double v1, double v2) { return (double)500; }
+int64_t overload2(int64_t v1, int64_t v2) { return (int64_t)600; }
+uint64_t overload2(uint64_t v1, uint64_t v2) { return (uint64_t)700; }
+half overload2(half v1, half v2) { return (half)800; }
+
+min16float m16f;
+min16float4x4 m16f4x4;
+
+float test() :Foo {
+  // Ambiguous due to literal int and literal float:
+  // Single-digit literals take a special path:
+
+  // ambiguous to fxc, since it ignores 'L' on literal int
+
+  // Not ambiguous due to literal suffix:
+  VERIFY_TYPES(float, overload1(1.5f));
+  VERIFY_TYPES(float, overload1(1.5F));
+  VERIFY_TYPES(double, overload1(1.5l));
+  VERIFY_TYPES(double, overload1(1.5L));
+  VERIFY_TYPES(uint, overload1(2u));
+  VERIFY_TYPES(uint, overload1(2U));
+  VERIFY_TYPES(uint, overload1(2UL));
+  VERIFY_TYPES(uint64_t, overload1(2ull));
+  VERIFY_TYPES(uint64_t, overload1(2ULL));
+  VERIFY_TYPES(int64_t, overload1(2ll));
+  VERIFY_TYPES(int64_t, overload1(2LL));
+  VERIFY_TYPES(half, overload1(1.0h));
+  VERIFY_TYPES(half, overload1(1.0H));
+
+  
+  // Not ambiguous due to one literal and one specific:
+  VERIFY_TYPES(float, overload2(1.5, 1.5f));
+  VERIFY_TYPES(float, overload2(1.5f, 1.5));
+  VERIFY_TYPES(double, overload2(1.5, 1.5l));
+  VERIFY_TYPES(double, overload2(1.5l, 1.5));
+  VERIFY_TYPES(uint, overload2(2, 2u));
+  VERIFY_TYPES(uint, overload2(2u, 2));
+  VERIFY_TYPES(uint, overload2(2, 2ul));
+  VERIFY_TYPES(uint, overload2(2ul, 2));
+  VERIFY_TYPES(half, overload2(1.0h, 1.0));;
+  VERIFY_TYPES(half, overload2(1.0, 1.0H));
+  
+  VERIFY_TYPES(uint64_t, overload2(2, 2ull));
+  VERIFY_TYPES(uint64_t, overload2(2ull, 2));
+  VERIFY_TYPES(uint64_t, overload2(2, 2ULL));
+  VERIFY_TYPES(uint64_t, overload2(2ULL, 2));  
+  
+  VERIFY_TYPES(int64_t, overload2(2, 2ll));
+  VERIFY_TYPES(int64_t, overload2(2ll, 2));
+  VERIFY_TYPES(int64_t, overload2(2, 2LL));
+  VERIFY_TYPES(int64_t, overload2(2LL, 2));
+
+  // Verify that intrinsics will accept 64-bit overloads properly.
+  VERIFY_TYPES(uint64_t, abs(100ULL));
+  VERIFY_TYPES(uint, countbits(101ULL));
+  VERIFY_TYPES(uint2, countbits(uint64_t2(104ULL, 105ULL)));
+  VERIFY_TYPES(uint, firstbithigh(106ULL));
+  VERIFY_TYPES(uint2, firstbithigh(uint64_t2(107ULL, 108ULL)));
+  VERIFY_TYPES(uint, firstbitlow(109ULL));
+  VERIFY_TYPES(uint2, firstbitlow(uint64_t2(110ULL, 111ULL)));
+  VERIFY_TYPES(uint, reversebits(113u));
+  VERIFY_TYPES(uint64_t, reversebits(114ULL));
+
+  // fxc thinks these are ambiguous since it ignores the 'l' suffix:
+
+  VERIFY_TYPES(double, overload1(2ULL * 1.5));
+  VERIFY_TYPES(double, overload1(2LL * 1.5));
+
+  // ensure operator combinations produce the right literal types and concrete types
+  VERIFY_TYPES(float, 1.5 * 2 * 1.5f);
+  VERIFY_TYPES(float, 1.5 * 2 * 1.5F);
+  VERIFY_TYPES(double, 1.5 * 2 * 1.5l);
+  VERIFY_TYPES(double, 1.5 * 2 * 1.5L);
+  VERIFY_TYPES(int, 2 * 2L);
+  VERIFY_TYPES(uint, 2 * 2U);
+  VERIFY_TYPES(uint, 2 * 2UL);
+  VERIFY_TYPES(int64_t, 2 * 2LL);
+  VERIFY_TYPES(uint64_t, 2 * 2ULL);
+  VERIFY_TYPES(half, 1.0 * 2 * 1.5h);
+  VERIFY_TYPES(half, 1.0 * 2 * 1.5H);
+
+  // Specific width int forces float to be specific-width
+  VERIFY_TYPES(float, 1.5 * 2 * 2L);
+  VERIFY_TYPES(float, 1.5 * 2 * 2U);
+  VERIFY_TYPES(float, 1.5 * 2 * 2UL);
+  VERIFY_TYPES(float, 1.5 * 2 * 2L);
+  VERIFY_TYPES(float, m16f * (1.5 * 2 * 2L));
+
+  // Combination of literal float + literal int to literal float, then combined with
+  // min-precision float matrix to produce min-precision float matrix - ensures that
+  // literal combination results in literal that doesn't override the min-precision type.
+  VERIFY_TYPES(min16float4x4, m16f4x4 * (0.5 + 1));
+
+  return 0.0f;
+}

tools/clang/test/HLSL/matrix-syntax-exact-precision.hlsl

@@ -0,0 +1,160 @@
+// RUN: %clang_cc1 -no-min-precision -fsyntax-only -ffreestanding -verify %s
+
+
+// To test with the classic compiler, run
+// %sdxroot%\tools\x86\fxc.exe /T vs_5_1 matrix-syntax.hlsl
+
+matrix m;
+
+void abs_without_using_result() {
+    matrix<float, 4, 4> mymatrix;
+    abs(mymatrix);            /* expected-warning {{ignoring return value of function declared with const attribute}} fxc-pass {{}} */
+
+    matrix<float, 1, 4> mymatrix2;
+    abs(mymatrix2);           /* expected-warning {{ignoring return value of function declared with const attribute}} fxc-pass {{}} */
+}
+
+void abs_with_assignment() {
+    matrix<float, 4, 4> mymatrix;
+    matrix<float, 4, 4> absMatrix;
+    absMatrix = abs(mymatrix);
+}
+
+matrix<float, 4, 4> abs_for_result(matrix<float, 4, 4> value) {
+    return abs(value);
+}
+
+void fn_use_matrix(matrix<float, 4, 4> value) { }
+
+void abs_in_argument() {
+    matrix<float, 4, 4> mymatrix;
+    fn_use_matrix(abs(mymatrix));
+    /*verify-ast
+      CallExpr <col:5, col:32> 'void'
+      |-ImplicitCastExpr <col:5> 'void (*)(matrix<float, 4, 4>)' <FunctionToPointerDecay>
+      | `-DeclRefExpr <col:5> 'void (matrix<float, 4, 4>)' lvalue Function 'fn_use_matrix' 'void (matrix<float, 4, 4>)'
+      `-CallExpr <col:19, col:31> 'matrix<float, 4, 4>':'matrix<float, 4, 4>'
+        |-ImplicitCastExpr <col:19> 'matrix<float, 4, 4> (*)(matrix<float, 4, 4>)' <FunctionToPointerDecay>
+        | `-DeclRefExpr <col:19> 'matrix<float, 4, 4> (matrix<float, 4, 4>)' lvalue Function 'abs' 'matrix<float, 4, 4> (matrix<float, 4, 4>)'
+        `-ImplicitCastExpr <col:23> 'matrix<float, 4, 4>':'matrix<float, 4, 4>' <LValueToRValue>
+          `-DeclRefExpr <col:23> 'matrix<float, 4, 4>':'matrix<float, 4, 4>' lvalue Var 'mymatrix' 'matrix<float, 4, 4>':'matrix<float, 4, 4>'
+    */
+}
+
+void matrix_on_demand() {
+    float4x4 thematrix;
+    float4x4 anotherMatrix;
+    bool2x1 boolMatrix;
+    unsigned int4x2 unsignedMatrix;
+}
+
+void abs_on_demand() {
+   float1x2 f12;
+   float1x2 result = abs(f12);
+}
+
+void matrix_out_of_bounds() {
+  matrix<float, 1, 8> matrix_oob_0; // expected-error {{invalid value, valid range is between 1 and 4 inclusive}} fxc-error {{X3053: matrix dimensions must be between 1 and 4}}
+  matrix<float, 0, 1> matrix_oob_1; // expected-error {{invalid value, valid range is between 1 and 4 inclusive}} fxc-error {{X3053: matrix dimensions must be between 1 and 4}}
+  matrix<float, -1, 1> matrix_oob_2; // expected-error {{invalid value, valid range is between 1 and 4 inclusive}} fxc-error {{X3053: matrix dimensions must be between 1 and 4}}
+}
+
+void matrix_unsigned() {
+   unsigned int4x2 intMatrix;
+   unsigned min16int4x3 min16Matrix;
+   unsigned int64_t3x3 int64Matrix;
+   unsigned uint3x4 uintMatrix;
+   unsigned min16uint4x1 min16uintMatrix;
+   unsigned uint64_t2x2 int64uintMatrix;
+   unsigned dword3x2 dwordvector; /* fxc-error {{X3000: unrecognized identifier 'dword3x1'}} */
+
+   unsigned float2x3 floatMatrix; /* expected-error {{'float' cannot be signed or unsigned}} fxc-error {{X3085: unsigned can not be used with type}} */
+   unsigned bool3x4 boolvector;   /* expected-error {{'bool' cannot be signed or unsigned}} fxc-error {{X3085: unsigned can not be used with type}} */
+   unsigned half4x1 halfvector;   /* expected-error {{'half' cannot be signed or unsigned}} fxc-error {{X3085: unsigned can not be used with type}} */
+   unsigned double1x2 doublevector;                           /* expected-error {{'double' cannot be signed or unsigned}} fxc-error {{X3085: unsigned can not be used with type}} */
+   unsigned min12int2x3 min12intvector;                       /* expected-warning {{min12int is promoted to min16int}} fxc-error {{X3085: unsigned can not be used with type}} */
+   unsigned min16float3x4 min16floatvector;                   /* expected-error {{'half' cannot be signed or unsigned}} expected-warning {{min16float is promoted to half}} fxc-error {{X3085: unsigned can not be used with type}} */
+
+}
+
+void main() {
+    // Multiple assignments in a chain.
+    matrix<float, 4, 4> mymatrix;
+    matrix<float, 4, 4> absMatrix = abs(mymatrix);
+    matrix<float, 4, 4> absMatrix2 = abs(absMatrix);
+    const matrix<float, 4, 4> myConstMatrix = mymatrix;                /* expected-note {{variable 'myConstMatrix' declared const here}} expected-note {{variable 'myConstMatrix' declared const here}} fxc-pass {{}} */
+
+    matrix<float, 2, 4> f24;
+    float f;
+    float2 f2;
+    float3 f3;
+    float4 f4;
+    float farr2[2];
+
+    // zero-based positions.
+    f = mymatrix._m00;
+    f2 = mymatrix._m00_m11;
+    f4 = mymatrix._m00_m11_m00_m11;
+    /*verify-ast
+      BinaryOperator <col:5, col:19> 'float4':'vector<float, 4>' '='
+      |-DeclRefExpr <col:5> 'float4':'vector<float, 4>' lvalue Var 'f4' 'float4':'vector<float, 4>'
+      `-ExtMatrixElementExpr <col:10, col:19> 'vector<float, 4>':'vector<float, 4>' _m00_m11_m00_m11
+        `-DeclRefExpr <col:10> 'matrix<float, 4, 4>':'matrix<float, 4, 4>' lvalue Var 'mymatrix' 'matrix<float, 4, 4>':'matrix<float, 4, 4>'
+    */
+    //fxc error X3018 : invalid subscript '_m00_11'
+    f2 = mymatrix._m00_11; // expected-error {{matrix subscript '_m00_11' mixes one-based and zero-based references}} fxc-error {{X3018: invalid subscript '_m00_11'}}
+    //fxc error X3018: invalid subscript '_m00_m11_m00_m11_m00_m11_m00_m11'
+    f24 = mymatrix._m00_m11_m00_m11_m00_m11_m00_m11; // expected-error {{more than four positions are referenced in '_m00_m11_m00_m11_m00_m11_m00_m11'}} fxc-error {{X3018: invalid subscript '_m00_m11_m00_m11_m00_m11_m00_m11'}}
+    //fxc error X3017: cannot convert from 'float2' to 'float[2]'
+    farr2 = mymatrix._m00_m01; // expected-error {{cannot implicitly convert from 'vector<float, 2>' to 'float [2]'}} fxc-error {{X3017: cannot convert from 'float2' to 'float[2]'}}
+    //fxc error X3018: invalid subscript '_m04'
+    f = mymatrix._m04; // expected-error {{the digit '4' is used in '_m04', but the syntax is for zero-based rows and columns}} fxc-error {{X3018: invalid subscript '_m04'}}
+    f2 = mymatrix._m00_m01;
+    //fxc error X3017: cannot implicitly convert from 'float2' to 'float3'
+    f3 = mymatrix._m00_m01; // expected-error {{cannot convert from 'vector<float, 2>' to 'float3'}} fxc-error {{X3017: cannot implicitly convert from 'float2' to 'float3'}}
+    //fxc warning X3206: implicit truncation of vector type
+    f2 = mymatrix._m00_m01_m00; // expected-warning {{implicit truncation of vector type}} fxc-warning {{X3206: implicit truncation of vector type}}
+    mymatrix._m00 = mymatrix._m01;
+    mymatrix._m00_m11_m02_m13 = mymatrix._m10_m21_m10_m21;
+    /*verify-ast
+      BinaryOperator <col:5, col:42> 'vector<float, 4>':'vector<float, 4>' '='
+      |-ExtMatrixElementExpr <col:5, col:14> 'vector<float, 4>':'vector<float, 4>' lvalue vectorcomponent _m00_m11_m02_m13
+      | `-DeclRefExpr <col:5> 'matrix<float, 4, 4>':'matrix<float, 4, 4>' lvalue Var 'mymatrix' 'matrix<float, 4, 4>':'matrix<float, 4, 4>'
+      `-ExtMatrixElementExpr <col:33, col:42> 'vector<float, 4>':'vector<float, 4>' _m10_m21_m10_m21
+        `-DeclRefExpr <col:33> 'matrix<float, 4, 4>':'matrix<float, 4, 4>' lvalue Var 'mymatrix' 'matrix<float, 4, 4>':'matrix<float, 4, 4>'
+    */
+    //fxc error X3025: l-value specifies const object
+    mymatrix._m00_m11_m00_m11 = mymatrix._m10_m21_m10_m21; // expected-error {{matrix is not assignable (contains duplicate components)}} fxc-error {{X3025: l-value specifies const object}}
+
+    // one-based positions.
+    //fxc error X3018: invalid subscript '_00'
+    f = mymatrix._00; // expected-error {{the digit '0' is used in '_00', but the syntax is for one-based rows and columns}} fxc-error {{X3018: invalid subscript '_00'}}
+    f = mymatrix._11;
+    f2 = mymatrix._11_11;
+    f4 = mymatrix._11_11_44_44;
+    /*verify-ast
+      BinaryOperator <col:5, col:19> 'float4':'vector<float, 4>' '='
+      |-DeclRefExpr <col:5> 'float4':'vector<float, 4>' lvalue Var 'f4' 'float4':'vector<float, 4>'
+      `-ExtMatrixElementExpr <col:10, col:19> 'vector<float, 4>':'vector<float, 4>' _11_11_44_44
+        `-DeclRefExpr <col:10> 'matrix<float, 4, 4>':'matrix<float, 4, 4>' lvalue Var 'mymatrix' 'matrix<float, 4, 4>':'matrix<float, 4, 4>'
+    */
+    // member assignment using subscript syntax
+    f = mymatrix[0][0];
+    f = mymatrix[1][1];
+    f2 = mymatrix[1].xx;
+    f4 = mymatrix[2];
+
+    f = mymatrix[0][4];                                     /* expected-error {{vector element index '4' is out of bounds}} fxc-pass {{}} */
+    f = mymatrix[-1][3];                                    /* expected-error {{matrix row index '-1' is out of bounds}} fxc-pass {{}} */
+    f4 = mymatrix[10];                                      /* expected-error {{matrix row index '10' is out of bounds}} fxc-pass {{}} */
+
+    // accessing const member
+    f = myConstMatrix[0][0];
+    f = myConstMatrix[1][1];
+    f2 = myConstMatrix[1].xx;
+    f4 = myConstMatrix[2];
+
+    myConstMatrix[0][0] = 3;                                /* expected-error {{cannot assign to variable 'myConstMatrix' with const-qualified type 'const matrix<float, 4, 4>'}} fxc-error {{X3025: l-value specifies const object}} */
+    myConstMatrix[3] = float4(1,2,3,4);                     /* expected-error {{cannot assign to variable 'myConstMatrix' with const-qualified type 'const matrix<float, 4, 4>'}} fxc-error {{X3025: l-value specifies const object}} */
+
+}

tools/clang/test/HLSL/scalar-assignments-exact-precision.hlsl

@@ -0,0 +1,324 @@
+// RUN: %clang_cc1 -no-min-precision -fsyntax-only -ffreestanding -verify %s
+
+// To test with the classic compiler, run
+// %sdxroot%\tools\x86\fxc.exe /T vs_5_1 scalar-assignments.hlsl
+// with vs_2_0 (the default) min16float usage produces a complaint that it's not supported
+
+void main() {
+
+snorm snorm float ssf; // expected-warning {{attribute 'snorm' is already applied}} fxc-error {{X3000: syntax error: unexpected token 'snorm'}}
+snorm unorm float suf; // expected-error {{'unorm' and 'snorm' attributes are not compatible}} fxc-error {{X3000: syntax error: unexpected token 'unorm'}}
+snorm bool sb;         // expected-error {{snorm and unorm qualifier can only be used on floating-point types}} fxc-error {{X3085: snorm can not be used with type}}
+
+// Used to generate this undesirable error:
+// cannot initialize a variable of type 'min16float' (aka 'half') with an lvalue of type 'const char [4]'
+min16float foobar = "foo"; // expected-error {{cannot initialize a variable of type 'min16float' with an lvalue of type 'const char [4]'}} expected-warning {{min16float is promoted to half}} fxc-error {{X3017: cannot implicitly convert from 'const string' to 'min16float'}}
+
+/*
+(let (
+      (values '(bool int uint dword half float double min16float min10float min16int min12int min16uint))
+      (vi 0)
+      )
+  (dolist (v0 values)
+        (dolist (v1 values)
+              (progn
+                (princ (format "%s left%d; %s right%d; left%d = right%d;\n" v0 vi v1 vi vi vi))
+                (set 'vi (+ 1 vi))
+                ))))
+*/
+
+// fxc errors look like this:
+// warning X3205: conversion from larger type to smaller, possible loss of data
+
+bool left0; bool right0; left0 = right0;
+bool left1; int right1; left1 = right1;
+bool left2; uint right2; left2 = right2;
+bool left3; dword right3; left3 = right3;
+bool left4; half right4; left4 = right4;
+bool left5; float right5; left5 = right5;
+bool left6; double right6; left6 = right6;
+bool left7; min16float right7; left7 = right7;              /* expected-warning {{min16float is promoted to half}} */
+bool left8; min10float right8; left8 = right8;  // expected-warning {{min10float is promoted to half}}
+bool left9; min16int right9; left9 = right9;
+bool left10; min12int right10; left10 = right10;  // expected-warning {{min12int is promoted to min16int}}
+bool left11; min16uint right11; left11 = right11;
+int left12; bool right12; left12 = right12;
+int left13; int right13; left13 = right13;
+int left14; uint right14; left14 = right14;
+int left15; dword right15; left15 = right15;
+int left16; half right16; left16 = right16;
+int left17; float right17; left17 = right17;
+int left18; double right18; left18 = right18; // expected-warning {{conversion from larger type 'double' to smaller type 'int', possible loss of data}} fxc-warning {{X3205: conversion from larger type to smaller, possible loss of data}}
+int left19; min16float right19; left19 = right19;           /* expected-warning {{min16float is promoted to half}} */
+int left20; min10float right20; left20 = right20;  // expected-warning {{min10float is promoted to half}}
+int left21; min16int right21; left21 = right21;
+int left22; min12int right22; left22 = right22;  // expected-warning {{min12int is promoted to min16int}}
+int left23; min16uint right23; left23 = right23;
+uint left24; bool right24; left24 = right24;
+uint left25; int right25; left25 = right25;
+uint left26; uint right26; left26 = right26;
+uint left27; dword right27; left27 = right27;
+uint left28; half right28; left28 = right28;
+uint left29; float right29; left29 = right29;
+uint left30; double right30; left30 = right30; // expected-warning {{conversion from larger type 'double' to smaller type 'uint', possible loss of data}} fxc-warning {{X3205: conversion from larger type to smaller, possible loss of data}}
+uint left31; min16float right31; left31 = right31;          /* expected-warning {{min16float is promoted to half}} */
+uint left32; min10float right32; left32 = right32;  // expected-warning {{min10float is promoted to half}}
+uint left33; min16int right33; left33 = right33;
+uint left34; min12int right34; left34 = right34;  // expected-warning {{min12int is promoted to min16int}}
+uint left35; min16uint right35; left35 = right35;
+dword left36; bool right36; left36 = right36;
+dword left37; int right37; left37 = right37;
+dword left38; uint right38; left38 = right38;
+dword left39; dword right39; left39 = right39;
+dword left40; half right40; left40 = right40;
+dword left41; float right41; left41 = right41;
+dword left42; double right42; left42 = right42; // expected-warning {{conversion from larger type 'double' to smaller type 'dword', possible loss of data}} fxc-warning {{X3205: conversion from larger type to smaller, possible loss of data}}
+dword left43; min16float right43; left43 = right43;         /* expected-warning {{min16float is promoted to half}} */
+dword left44; min10float right44; left44 = right44;  // expected-warning {{min10float is promoted to half}}
+dword left45; min16int right45; left45 = right45;
+dword left46; min12int right46; left46 = right46;  // expected-warning {{min12int is promoted to min16int}}
+dword left47; min16uint right47; left47 = right47;
+half left48; bool right48; left48 = right48;
+half left49; int right49; left49 = right49;        /* expected-warning {{conversion from larger type 'int' to smaller type 'half', possible loss of data}} */
+half left50; uint right50; left50 = right50;       /* expected-warning {{conversion from larger type 'uint' to smaller type 'half', possible loss of data}} */
+half left51; dword right51; left51 = right51;      /* expected-warning {{conversion from larger type 'dword' to smaller type 'half', possible loss of data}} */
+half left52; half right52; left52 = right52;
+half left53; float right53; left53 = right53;      /* expected-warning {{conversion from larger type 'float' to smaller type 'half', possible loss of data}} */
+half left54; double right54; left54 = right54; // expected-warning {{conversion from larger type 'double' to smaller type 'half', possible loss of data}} fxc-warning {{X3205: conversion from larger type to smaller, possible loss of data}}
+half left55; min16float right55; left55 = right55;          /* expected-warning {{min16float is promoted to half}} */
+half left56; min10float right56; left56 = right56;  // expected-warning {{min10float is promoted to half}}
+half left57; min16int right57; left57 = right57;
+half left58; min12int right58; left58 = right58;  // expected-warning {{min12int is promoted to min16int}}
+half left59; min16uint right59; left59 = right59;
+float left60; bool right60; left60 = right60;
+float left61; int right61; left61 = right61;
+float left62; uint right62; left62 = right62;
+float left63; dword right63; left63 = right63;
+float left64; half right64; left64 = right64;
+float left65; float right65; left65 = right65;
+float left66; double right66; left66 = right66; // expected-warning {{conversion from larger type 'double' to smaller type 'float', possible loss of data}} fxc-warning {{X3205: conversion from larger type to smaller, possible loss of data}}
+float left67; min16float right67; left67 = right67;         /* expected-warning {{min16float is promoted to half}} */
+float left68; min10float right68; left68 = right68;  // expected-warning {{min10float is promoted to half}}
+float left69; min16int right69; left69 = right69;
+float left70; min12int right70; left70 = right70;  // expected-warning {{min12int is promoted to min16int}}
+float left71; min16uint right71; left71 = right71;
+double left72; bool right72; left72 = right72;
+double left73; int right73; left73 = right73;
+double left74; uint right74; left74 = right74;
+double left75; dword right75; left75 = right75;
+double left76; half right76; left76 = right76;
+double left77; float right77; left77 = right77;
+double left78; double right78; left78 = right78;
+double left79; min16float right79; left79 = right79;        /* expected-warning {{min16float is promoted to half}} */
+double left80; min10float right80; left80 = right80;  // expected-warning {{min10float is promoted to half}}
+double left81; min16int right81; left81 = right81;
+double left82; min12int right82; left82 = right82;  // expected-warning {{min12int is promoted to min16int}}
+double left83; min16uint right83; left83 = right83;
+min16float left84; bool right84; left84 = right84;  /* expected-warning {{min16float is promoted to half}} */
+min16float left85; int right85; left85 = right85; // expected-warning {{conversion from larger type 'int' to smaller type 'min16float', possible loss of data}} expected-warning {{min16float is promoted to half}} fxc-warning {{X3205: conversion from larger type to smaller, possible loss of data}}
+min16float left86; uint right86; left86 = right86; // expected-warning {{conversion from larger type 'uint' to smaller type 'min16float', possible loss of data}} expected-warning {{min16float is promoted to half}} fxc-warning {{X3205: conversion from larger type to smaller, possible loss of data}}
+min16float left87; dword right87; left87 = right87; // expected-warning {{conversion from larger type 'dword' to smaller type 'min16float', possible loss of data}} expected-warning {{min16float is promoted to half}} fxc-warning {{X3205: conversion from larger type to smaller, possible loss of data}}
+min16float left88; half right88; left88 = right88; // expected-warning {{min16float is promoted to half}} fxc-warning {{X3205: conversion from larger type to smaller, possible loss of data}}
+min16float left89; float right89; left89 = right89; // expected-warning {{conversion from larger type 'float' to smaller type 'min16float', possible loss of data}} expected-warning {{min16float is promoted to half}} fxc-warning {{X3205: conversion from larger type to smaller, possible loss of data}}
+min16float left90; double right90; left90 = right90; // expected-warning {{conversion from larger type 'double' to smaller type 'min16float', possible loss of data}} expected-warning {{min16float is promoted to half}} fxc-warning {{X3205: conversion from larger type to smaller, possible loss of data}}
+min16float left91; min16float right91; left91 = right91;    /* expected-warning {{min16float is promoted to half}} expected-warning {{min16float is promoted to half}} */
+min16float left92; min10float right92; left92 = right92;  // expected-warning {{min10float is promoted to half}} expected-warning {{min16float is promoted to half}}
+min16float left93; min16int right93; left93 = right93;    /* expected-warning {{min16float is promoted to half}} */
+min16float left94; min12int right94; left94 = right94;  // expected-warning {{min12int is promoted to min16int}} expected-warning {{min16float is promoted to half}}
+min16float left95; min16uint right95; left95 = right95; /* expected-warning {{min16float is promoted to half}} */
+min10float left96; bool right96; left96 = right96;  // expected-warning {{min10float is promoted to half}}
+min10float left97; int right97; left97 = right97; // expected-warning {{conversion from larger type 'int' to smaller type 'min10float', possible loss of data}} expected-warning {{min10float is promoted to half}} fxc-warning {{X3205: conversion from larger type to smaller, possible loss of data}} //
+min10float left98; uint right98; left98 = right98; // expected-warning {{conversion from larger type 'uint' to smaller type 'min10float', possible loss of data}} expected-warning {{min10float is promoted to half}} fxc-warning {{X3205: conversion from larger type to smaller, possible loss of data}} //
+min10float left99; dword right99; left99 = right99; // expected-warning {{conversion from larger type 'dword' to smaller type 'min10float', possible loss of data}} expected-warning {{min10float is promoted to half}} fxc-warning {{X3205: conversion from larger type to smaller, possible loss of data}} //
+min10float left100; half right100; left100 = right100; // expected-warning {{min10float is promoted to half}} fxc-warning {{X3205: conversion from larger type to smaller, possible loss of data}} //
+min10float left101; float right101; left101 = right101; // expected-warning {{conversion from larger type 'float' to smaller type 'min10float', possible loss of data}} expected-warning {{min10float is promoted to half}} fxc-warning {{X3205: conversion from larger type to smaller, possible loss of data}} //
+min10float left102; double right102; left102 = right102; // expected-warning {{conversion from larger type 'double' to smaller type 'min10float', possible loss of data}} expected-warning {{min10float is promoted to half}} fxc-warning {{X3205: conversion from larger type to smaller, possible loss of data}} //
+min10float left103; min16float right103; left103 = right103; // expected-warning {{min10float is promoted to half}} expected-warning {{min16float is promoted to half}} fxc-warning {{X3205: conversion from larger type to smaller, possible loss of data}} //
+min10float left104; min10float right104; left104 = right104;  // expected-warning {{min10float is promoted to half}} expected-warning {{min10float is promoted to half}} //
+min10float left105; min16int right105; left105 = right105; // expected-warning {{min10float is promoted to half}} fxc-warning {{X3205: conversion from larger type to smaller, possible loss of data}} //
+min10float left106; min12int right106; left106 = right106; // expected-warning {{min10float is promoted to half}} expected-warning {{min12int is promoted to min16int}} fxc-warning {{X3205: conversion from larger type to smaller, possible loss of data}} //
+min10float left107; min16uint right107; left107 = right107; // expected-warning {{min10float is promoted to half}} fxc-warning {{X3205: conversion from larger type to smaller, possible loss of data}} //
+min16int left108; bool right108; left108 = right108;
+min16int left109; int right109; left109 = right109; // expected-warning {{conversion from larger type 'int' to smaller type 'min16int', possible loss of data}} fxc-warning {{X3205: conversion from larger type to smaller, possible loss of data}}
+min16int left110; uint right110; left110 = right110; // expected-warning {{conversion from larger type 'uint' to smaller type 'min16int', possible loss of data}} fxc-warning {{X3205: conversion from larger type to smaller, possible loss of data}}
+min16int left111; dword right111; left111 = right111; // expected-warning {{conversion from larger type 'dword' to smaller type 'min16int', possible loss of data}} fxc-warning {{X3205: conversion from larger type to smaller, possible loss of data}}
+min16int left112; half right112; left112 = right112; // fxc-warning {{X3205: conversion from larger type to smaller, possible loss of data}}
+min16int left113; float right113; left113 = right113; // expected-warning {{conversion from larger type 'float' to smaller type 'min16int', possible loss of data}} fxc-warning {{X3205: conversion from larger type to smaller, possible loss of data}}
+min16int left114; double right114; left114 = right114; // expected-warning {{conversion from larger type 'double' to smaller type 'min16int', possible loss of data}} fxc-warning {{X3205: conversion from larger type to smaller, possible loss of data}}
+min16int left115; min16float right115; left115 = right115;    /* expected-warning {{min16float is promoted to half}} */
+min16int left116; min10float right116; left116 = right116;  // expected-warning {{min10float is promoted to half}}
+min16int left117; min16int right117; left117 = right117;
+min16int left118; min12int right118; left118 = right118;  // expected-warning {{min12int is promoted to min16int}}
+min16int left119; min16uint right119; left119 = right119;
+min12int left120; bool right120; left120 = right120;  // expected-warning {{min12int is promoted to min16int}}
+min12int left121; int right121; left121 = right121; // expected-warning {{conversion from larger type 'int' to smaller type 'min12int', possible loss of data}} expected-warning {{min12int is promoted to min16int}} fxc-warning {{X3205: conversion from larger type to smaller, possible loss of data}} //
+min12int left122; uint right122; left122 = right122; // expected-warning {{conversion from larger type 'uint' to smaller type 'min12int', possible loss of data}} expected-warning {{min12int is promoted to min16int}} fxc-warning {{X3205: conversion from larger type to smaller, possible loss of data}} //
+min12int left123; dword right123; left123 = right123; // expected-warning {{conversion from larger type 'dword' to smaller type 'min12int', possible loss of data}} expected-warning {{min12int is promoted to min16int}} fxc-warning {{X3205: conversion from larger type to smaller, possible loss of data}} //
+min12int left124; half right124; left124 = right124; // expected-warning {{min12int is promoted to min16int}} fxc-warning {{X3205: conversion from larger type to smaller, possible loss of data}} //
+min12int left125; float right125; left125 = right125; // expected-warning {{conversion from larger type 'float' to smaller type 'min12int', possible loss of data}} expected-warning {{min12int is promoted to min16int}} fxc-warning {{X3205: conversion from larger type to smaller, possible loss of data}} //
+min12int left126; double right126; left126 = right126; // expected-warning {{conversion from larger type 'double' to smaller type 'min12int', possible loss of data}} expected-warning {{min12int is promoted to min16int}} fxc-warning {{X3205: conversion from larger type to smaller, possible loss of data}} //
+min12int left127; min16float right127; left127 = right127; // expected-warning {{min12int is promoted to min16int}} expected-warning {{min16float is promoted to half}} fxc-warning {{X3205: conversion from larger type to smaller, possible loss of data}} //
+min12int left128; min10float right128; left128 = right128;  // expected-warning {{min10float is promoted to half}} expected-warning {{min12int is promoted to min16int}} //
+min12int left129; min16int right129; left129 = right129; // expected-warning {{min12int is promoted to min16int}} fxc-warning {{X3205: conversion from larger type to smaller, possible loss of data}} //
+min12int left130; min12int right130; left130 = right130;  // expected-warning {{min12int is promoted to min16int}} expected-warning {{min12int is promoted to min16int}} //
+min12int left131; min16uint right131; left131 = right131; // expected-warning {{min12int is promoted to min16int}} fxc-warning {{X3205: conversion from larger type to smaller, possible loss of data}} //
+min16uint left132; bool right132; left132 = right132;
+min16uint left133; int right133; left133 = right133; // expected-warning {{conversion from larger type 'int' to smaller type 'min16uint', possible loss of data}} fxc-warning {{X3205: conversion from larger type to smaller, possible loss of data}}
+min16uint left134; uint right134; left134 = right134; // expected-warning {{conversion from larger type 'uint' to smaller type 'min16uint', possible loss of data}} fxc-warning {{X3205: conversion from larger type to smaller, possible loss of data}}
+min16uint left135; dword right135; left135 = right135; // expected-warning {{conversion from larger type 'dword' to smaller type 'min16uint', possible loss of data}} fxc-warning {{X3205: conversion from larger type to smaller, possible loss of data}}
+min16uint left136; half right136; left136 = right136; // fxc-warning {{X3205: conversion from larger type to smaller, possible loss of data}}
+min16uint left137; float right137; left137 = right137; // expected-warning {{conversion from larger type 'float' to smaller type 'min16uint', possible loss of data}} fxc-warning {{X3205: conversion from larger type to smaller, possible loss of data}}
+min16uint left138; double right138; left138 = right138; // expected-warning {{conversion from larger type 'double' to smaller type 'min16uint', possible loss of data}} fxc-warning {{X3205: conversion from larger type to smaller, possible loss of data}}
+min16uint left139; min16float right139; left139 = right139;    /* expected-warning {{min16float is promoted to half}} */
+min16uint left140; min10float right140; left140 = right140;  // expected-warning {{min10float is promoted to half}}
+min16uint left141; min16int right141; left141 = right141;
+min16uint left142; min12int right142; left142 = right142;  // expected-warning {{min12int is promoted to min16int}}
+min16uint left143; min16uint right143; left143 = right143;
+
+// Now with unorm and snorm modifiers.
+/*
+(let (
+      (floats '(float double min16float min10float))
+      (modifiers '("" "snorm" "unorm"))
+      (vi 1000)
+      )
+  (loop for v0 in floats do
+        (loop for m0 in modifiers do
+              (loop for v1 in floats do
+                    (loop for m1 in modifiers do
+                          (when (not (and (eq m0 "") (eq m1 "")))
+                            (princ (format "%s %s left%d; %s %s right%d; left%d = right%d;\n" m0 v0 vi m1 v1 vi vi vi))
+                            (set 'vi (+ 1 vi))
+                            ))))))
+*/
+
+ float left1000; snorm float right1000; left1000 = right1000;
+ float left1001; unorm float right1001; left1001 = right1001;
+// float left1002; snorm double right1002; left1002 = right1002;
+// float left1003; unorm double right1003; left1003 = right1003;
+ float left1004; snorm min16float right1004; left1004 = right1004;    /* expected-warning {{min16float is promoted to half}} */
+ float left1005; unorm min16float right1005; left1005 = right1005;    /* expected-warning {{min16float is promoted to half}} */
+ float left1006; snorm min10float right1006; left1006 = right1006;  // expected-warning {{min10float is promoted to half}}
+ float left1007; unorm min10float right1007; left1007 = right1007;  // expected-warning {{min10float is promoted to half}}
+snorm float left1008;  float right1008; left1008 = right1008;
+snorm float left1009; snorm float right1009; left1009 = right1009;
+snorm float left1010; unorm float right1010; left1010 = right1010;
+// snorm float left1011;  double right1011; left1011 = right1011;
+// snorm float left1012; snorm double right1012; left1012 = right1012;
+// snorm float left1013; unorm double right1013; left1013 = right1013;
+snorm float left1014;  min16float right1014; left1014 = right1014;  /* expected-warning {{min16float is promoted to half}} */
+snorm float left1015; snorm min16float right1015; left1015 = right1015;    /* expected-warning {{min16float is promoted to half}} */
+snorm float left1016; unorm min16float right1016; left1016 = right1016;    /* expected-warning {{min16float is promoted to half}} */
+snorm float left1017;  min10float right1017; left1017 = right1017;  // expected-warning {{min10float is promoted to half}}
+snorm float left1018; snorm min10float right1018; left1018 = right1018;  // expected-warning {{min10float is promoted to half}}
+snorm float left1019; unorm min10float right1019; left1019 = right1019;  // expected-warning {{min10float is promoted to half}}
+unorm float left1020;  float right1020; left1020 = right1020;
+unorm float left1021; snorm float right1021; left1021 = right1021;
+unorm float left1022; unorm float right1022; left1022 = right1022;
+// unorm float left1023;  double right1023; left1023 = right1023;
+// unorm float left1024; snorm double right1024; left1024 = right1024;
+// unorm float left1025; unorm double right1025; left1025 = right1025;
+unorm float left1026;  min16float right1026; left1026 = right1026;       /* expected-warning {{min16float is promoted to half}} */
+unorm float left1027; snorm min16float right1027; left1027 = right1027;  /* expected-warning {{min16float is promoted to half}} */
+unorm float left1028; unorm min16float right1028; left1028 = right1028;  /* expected-warning {{min16float is promoted to half}} */
+unorm float left1029;  min10float right1029; left1029 = right1029;  // expected-warning {{min10float is promoted to half}}
+unorm float left1030; snorm min10float right1030; left1030 = right1030;  // expected-warning {{min10float is promoted to half}}
+unorm float left1031; unorm min10float right1031; left1031 = right1031;  // expected-warning {{min10float is promoted to half}}
+ double left1032; snorm float right1032; left1032 = right1032;
+ double left1033; unorm float right1033; left1033 = right1033;
+ double left1034; snorm double right1034; left1034 = right1034;
+ double left1035; unorm double right1035; left1035 = right1035;
+ double left1036; snorm min16float right1036; left1036 = right1036;      /* expected-warning {{min16float is promoted to half}} */
+ double left1037; unorm min16float right1037; left1037 = right1037;      /* expected-warning {{min16float is promoted to half}} */
+ double left1038; snorm min10float right1038; left1038 = right1038;  // expected-warning {{min10float is promoted to half}}
+ double left1039; unorm min10float right1039; left1039 = right1039;  // expected-warning {{min10float is promoted to half}}
+snorm double left1040;  float right1040; left1040 = right1040;
+snorm double left1041; snorm float right1041; left1041 = right1041;
+snorm double left1042; unorm float right1042; left1042 = right1042;
+snorm double left1043;  double right1043; left1043 = right1043;
+snorm double left1044; snorm double right1044; left1044 = right1044;
+snorm double left1045; unorm double right1045; left1045 = right1045;
+snorm double left1046;  min16float right1046; left1046 = right1046;  /* expected-warning {{min16float is promoted to half}} */
+snorm double left1047; snorm min16float right1047; left1047 = right1047;    /* expected-warning {{min16float is promoted to half}} */
+snorm double left1048; unorm min16float right1048; left1048 = right1048;    /* expected-warning {{min16float is promoted to half}} */
+snorm double left1049;  min10float right1049; left1049 = right1049;  // expected-warning {{min10float is promoted to half}}
+snorm double left1050; snorm min10float right1050; left1050 = right1050;  // expected-warning {{min10float is promoted to half}}
+snorm double left1051; unorm min10float right1051; left1051 = right1051;  // expected-warning {{min10float is promoted to half}}
+unorm double left1052;  float right1052; left1052 = right1052;
+unorm double left1053; snorm float right1053; left1053 = right1053;
+unorm double left1054; unorm float right1054; left1054 = right1054;
+unorm double left1055;  double right1055; left1055 = right1055;
+unorm double left1056; snorm double right1056; left1056 = right1056;
+unorm double left1057; unorm double right1057; left1057 = right1057;
+unorm double left1058;  min16float right1058; left1058 = right1058;       /* expected-warning {{min16float is promoted to half}} */
+unorm double left1059; snorm min16float right1059; left1059 = right1059;  /* expected-warning {{min16float is promoted to half}} */
+unorm double left1060; unorm min16float right1060; left1060 = right1060;  /* expected-warning {{min16float is promoted to half}} */
+unorm double left1061;  min10float right1061; left1061 = right1061;  // expected-warning {{min10float is promoted to half}}
+unorm double left1062; snorm min10float right1062; left1062 = right1062;  // expected-warning {{min10float is promoted to half}}
+unorm double left1063; unorm min10float right1063; left1063 = right1063;  // expected-warning {{min10float is promoted to half}}
+// min16float left1064; snorm float right1064; left1064 = right1064;
+// min16float left1065; unorm float right1065; left1065 = right1065;
+// min16float left1066; snorm double right1066; left1066 = right1066;
+// min16float left1067; unorm double right1067; left1067 = right1067;
+ min16float left1068; snorm min16float right1068; left1068 = right1068;   /* expected-warning {{min16float is promoted to half}} expected-warning {{min16float is promoted to half}} */
+ min16float left1069; unorm min16float right1069; left1069 = right1069;   /* expected-warning {{min16float is promoted to half}} expected-warning {{min16float is promoted to half}} */
+ min16float left1070; snorm min10float right1070; left1070 = right1070;  // expected-warning {{min10float is promoted to half}} expected-warning {{min16float is promoted to half}}
+ min16float left1071; unorm min10float right1071; left1071 = right1071;  // expected-warning {{min10float is promoted to half}} expected-warning {{min16float is promoted to half}}
+// snorm min16float left1072;  float right1072; left1072 = right1072;
+// snorm min16float left1073; snorm float right1073; left1073 = right1073;
+// snorm min16float left1074; unorm float right1074; left1074 = right1074;
+// snorm min16float left1075;  double right1075; left1075 = right1075;
+// snorm min16float left1076; snorm double right1076; left1076 = right1076;
+// snorm min16float left1077; unorm double right1077; left1077 = right1077;
+snorm min16float left1078;  min16float right1078; left1078 = right1078;  /* expected-warning {{min16float is promoted to half}} expected-warning {{min16float is promoted to half}} */
+snorm min16float left1079; snorm min16float right1079; left1079 = right1079;    /* expected-warning {{min16float is promoted to half}} expected-warning {{min16float is promoted to half}} */
+snorm min16float left1080; unorm min16float right1080; left1080 = right1080;    /* expected-warning {{min16float is promoted to half}} expected-warning {{min16float is promoted to half}} */
+snorm min16float left1081;  min10float right1081; left1081 = right1081;  // expected-warning {{min10float is promoted to half}} expected-warning {{min16float is promoted to half}}
+snorm min16float left1082; snorm min10float right1082; left1082 = right1082;  // expected-warning {{min10float is promoted to half}} expected-warning {{min16float is promoted to half}}
+snorm min16float left1083; unorm min10float right1083; left1083 = right1083;  // expected-warning {{min10float is promoted to half}} expected-warning {{min16float is promoted to half}}
+// unorm min16float left1084;  float right1084; left1084 = right1084;
+// unorm min16float left1085; snorm float right1085; left1085 = right1085;
+// unorm min16float left1086; unorm float right1086; left1086 = right1086;
+// unorm min16float left1087;  double right1087; left1087 = right1087;
+// unorm min16float left1088; snorm double right1088; left1088 = right1088;
+// unorm min16float left1089; unorm double right1089; left1089 = right1089;
+unorm min16float left1090;  min16float right1090; left1090 = right1090;       /* expected-warning {{min16float is promoted to half}} expected-warning {{min16float is promoted to half}} */
+unorm min16float left1091; snorm min16float right1091; left1091 = right1091;  /* expected-warning {{min16float is promoted to half}} expected-warning {{min16float is promoted to half}} */
+unorm min16float left1092; unorm min16float right1092; left1092 = right1092;  /* expected-warning {{min16float is promoted to half}} expected-warning {{min16float is promoted to half}} */
+unorm min16float left1093;  min10float right1093; left1093 = right1093;  // expected-warning {{min10float is promoted to half}} expected-warning {{min16float is promoted to half}}
+unorm min16float left1094; snorm min10float right1094; left1094 = right1094;  // expected-warning {{min10float is promoted to half}} expected-warning {{min16float is promoted to half}}
+unorm min16float left1095; unorm min10float right1095; left1095 = right1095;  // expected-warning {{min10float is promoted to half}} expected-warning {{min16float is promoted to half}}
+// min10float left1096; snorm float right1096; left1096 = right1096;
+// min10float left1097; unorm float right1097; left1097 = right1097;
+// min10float left1098; snorm double right1098; left1098 = right1098;
+// min10float left1099; unorm double right1099; left1099 = right1099;
+// min10float left1100; snorm min16float right1100; left1100 = right1100;
+// min10float left1101; unorm min16float right1101; left1101 = right1101;
+ min10float left1102; snorm min10float right1102; left1102 = right1102;  // expected-warning {{min10float is promoted to half}} expected-warning {{min10float is promoted to half}} //
+ min10float left1103; unorm min10float right1103; left1103 = right1103;  // expected-warning {{min10float is promoted to half}} expected-warning {{min10float is promoted to half}} //
+// snorm min10float left1104;  float right1104; left1104 = right1104;
+// snorm min10float left1105; snorm float right1105; left1105 = right1105;
+// snorm min10float left1106; unorm float right1106; left1106 = right1106;
+// snorm min10float left1107;  double right1107; left1107 = right1107;
+// snorm min10float left1108; snorm double right1108; left1108 = right1108;
+// snorm min10float left1109; unorm double right1109; left1109 = right1109;
+// snorm min10float left1110;  min16float right1110; left1110 = right1110;
+// snorm min10float left1111; snorm min16float right1111; left1111 = right1111;
+// snorm min10float left1112; unorm min16float right1112; left1112 = right1112;
+snorm min10float left1113;  min10float right1113; left1113 = right1113;  // expected-warning {{min10float is promoted to half}} expected-warning {{min10float is promoted to half}} //
+snorm min10float left1114; snorm min10float right1114; left1114 = right1114;  // expected-warning {{min10float is promoted to half}} expected-warning {{min10float is promoted to half}} //
+snorm min10float left1115; unorm min10float right1115; left1115 = right1115;  // expected-warning {{min10float is promoted to half}} expected-warning {{min10float is promoted to half}} //
+// unorm min10float left1116;  float right1116; left1116 = right1116;
+// unorm min10float left1117; snorm float right1117; left1117 = right1117;
+// unorm min10float left1118; unorm float right1118; left1118 = right1118;
+// unorm min10float left1119;  double right1119; left1119 = right1119;
+// unorm min10float left1120; snorm double right1120; left1120 = right1120;
+// unorm min10float left1121; unorm double right1121; left1121 = right1121;
+// unorm min10float left1122;  min16float right1122; left1122 = right1122;
+// unorm min10float left1123; snorm min16float right1123; left1123 = right1123;
+// unorm min10float left1124; unorm min16float right1124; left1124 = right1124;
+unorm min10float left1125;  min10float right1125; left1125 = right1125;  // expected-warning {{min10float is promoted to half}} expected-warning {{min10float is promoted to half}} //
+unorm min10float left1126; snorm min10float right1126; left1126 = right1126;  // expected-warning {{min10float is promoted to half}} expected-warning {{min10float is promoted to half}} //
+unorm min10float left1127; unorm min10float right1127; left1127 = right1127;  // expected-warning {{min10float is promoted to half}} expected-warning {{min10float is promoted to half}} //
+
+}

tools/clang/test/HLSL/scalar-assignments.hlsl

@@ -133,11 +133,11 @@ min10float left99; dword right99; left99 = right99; // expected-warning {{conver
 min10float left100; half right100; left100 = right100; // expected-warning {{conversion from larger type 'half' to smaller type 'min10float', possible loss of data}} fxc-warning {{X3205: conversion from larger type to smaller, possible loss of data}} // expected-warning {{min10float is promoted to min16float}}
 min10float left101; float right101; left101 = right101; // expected-warning {{conversion from larger type 'float' to smaller type 'min10float', possible loss of data}} fxc-warning {{X3205: conversion from larger type to smaller, possible loss of data}} // expected-warning {{min10float is promoted to min16float}}
 min10float left102; double right102; left102 = right102; // expected-warning {{conversion from larger type 'double' to smaller type 'min10float', possible loss of data}} fxc-warning {{X3205: conversion from larger type to smaller, possible loss of data}} // expected-warning {{min10float is promoted to min16float}}
-min10float left103; min16float right103; left103 = right103; // fxc-warning {{X3205: conversion from larger type to smaller, possible loss of data}} // expected-warning {{min10float is promoted to min16float}}
+min10float left103; min16float right103; left103 = right103; // expected-warning {{min10float is promoted to min16float}} fxc-warning {{X3205: conversion from larger type to smaller, possible loss of data}}
 min10float left104; min10float right104; left104 = right104;  // expected-warning {{min10float is promoted to min16float}} // expected-warning {{min10float is promoted to min16float}}
-min10float left105; min16int right105; left105 = right105; // fxc-warning {{X3205: conversion from larger type to smaller, possible loss of data}} // expected-warning {{min10float is promoted to min16float}}
-min10float left106; min12int right106; left106 = right106; // expected-warning {{min12int is promoted to min16int}} fxc-warning {{X3205: conversion from larger type to smaller, possible loss of data}} // expected-warning {{min10float is promoted to min16float}}
-min10float left107; min16uint right107; left107 = right107; // fxc-warning {{X3205: conversion from larger type to smaller, possible loss of data}} // expected-warning {{min10float is promoted to min16float}}
+min10float left105; min16int right105; left105 = right105; // expected-warning {{min10float is promoted to min16float}} fxc-warning {{X3205: conversion from larger type to smaller, possible loss of data}}
+min10float left106; min12int right106; left106 = right106; // expected-warning {{min10float is promoted to min16float}} expected-warning {{min12int is promoted to min16int}} fxc-warning {{X3205: conversion from larger type to smaller, possible loss of data}}
+min10float left107; min16uint right107; left107 = right107; // expected-warning {{min10float is promoted to min16float}} fxc-warning {{X3205: conversion from larger type to smaller, possible loss of data}}
 min16int left108; bool right108; left108 = right108;
 min16int left109; int right109; left109 = right109; // expected-warning {{conversion from larger type 'int' to smaller type 'min16int', possible loss of data}} fxc-warning {{X3205: conversion from larger type to smaller, possible loss of data}}
 min16int left110; uint right110; left110 = right110; // expected-warning {{conversion from larger type 'uint' to smaller type 'min16int', possible loss of data}} fxc-warning {{X3205: conversion from larger type to smaller, possible loss of data}}
@@ -157,11 +157,11 @@ min12int left123; dword right123; left123 = right123; // expected-warning {{conv
 min12int left124; half right124; left124 = right124; // expected-warning {{conversion from larger type 'half' to smaller type 'min12int', possible loss of data}} fxc-warning {{X3205: conversion from larger type to smaller, possible loss of data}}  // expected-warning {{min12int is promoted to min16int}}
 min12int left125; float right125; left125 = right125; // expected-warning {{conversion from larger type 'float' to smaller type 'min12int', possible loss of data}} fxc-warning {{X3205: conversion from larger type to smaller, possible loss of data}}  // expected-warning {{min12int is promoted to min16int}}
 min12int left126; double right126; left126 = right126; // expected-warning {{conversion from larger type 'double' to smaller type 'min12int', possible loss of data}} fxc-warning {{X3205: conversion from larger type to smaller, possible loss of data}}  // expected-warning {{min12int is promoted to min16int}}
-min12int left127; min16float right127; left127 = right127; // fxc-warning {{X3205: conversion from larger type to smaller, possible loss of data}}  // expected-warning {{min12int is promoted to min16int}}
+min12int left127; min16float right127; left127 = right127; // expected-warning {{min12int is promoted to min16int}} fxc-warning {{X3205: conversion from larger type to smaller, possible loss of data}}  
 min12int left128; min10float right128; left128 = right128;  // expected-warning {{min10float is promoted to min16float}}  // expected-warning {{min12int is promoted to min16int}}
-min12int left129; min16int right129; left129 = right129; // fxc-warning {{X3205: conversion from larger type to smaller, possible loss of data}}  // expected-warning {{min12int is promoted to min16int}}
+min12int left129; min16int right129; left129 = right129; // expected-warning {{min12int is promoted to min16int}} fxc-warning {{X3205: conversion from larger type to smaller, possible loss of data}}  
 min12int left130; min12int right130; left130 = right130;  // expected-warning {{min12int is promoted to min16int}}  // expected-warning {{min12int is promoted to min16int}}
-min12int left131; min16uint right131; left131 = right131; // fxc-warning {{X3205: conversion from larger type to smaller, possible loss of data}}  // expected-warning {{min12int is promoted to min16int}}
+min12int left131; min16uint right131; left131 = right131; // expected-warning {{min12int is promoted to min16int}}  fxc-warning {{X3205: conversion from larger type to smaller, possible loss of data}} 
 min16uint left132; bool right132; left132 = right132;
 min16uint left133; int right133; left133 = right133; // expected-warning {{conversion from larger type 'int' to smaller type 'min16uint', possible loss of data}} fxc-warning {{X3205: conversion from larger type to smaller, possible loss of data}}
 min16uint left134; uint right134; left134 = right134; // expected-warning {{conversion from larger type 'uint' to smaller type 'min16uint', possible loss of data}} fxc-warning {{X3205: conversion from larger type to smaller, possible loss of data}}

tools/clang/test/HLSL/scalar-operators-exact-precision.hlsl

@@ -0,0 +1,2591 @@
+// RUN: %clang_cc1 -no-min-precision -fsyntax-only -Wno-unused-value -ffreestanding -verify %s
+
+// we use -Wno-unused-value because we generate some no-op expressions to yield errors
+// without also putting them in a static assertion
+
+// __decltype is the GCC way of saying 'decltype', but doesn't require C++11
+// _Static_assert is the C11 way of saying 'static_assert', but doesn't require C++11
+#ifdef VERIFY_FXC
+#define _Static_assert(a,b,c) ;
+#endif
+
+// :FXC_VERIFY_ARGUMENTS: /E plain /T vs_5_1
+
+// To test with the classic compiler, run
+// %sdxroot%\tools\x86\fxc.exe /T vs_5_1 scalar-operators.hlsl
+// with vs_2_0 (the default) min16float usage produces a complaint that it's not supported
+
+float4 plain(float4 param4 : FOO) : FOO {
+    bool        bools       = 0;
+    int         ints        = 0;
+    uint        uints       = 0;
+    dword       dwords      = 0;
+    half        halfs       = 0;
+    float       floats      = 0;
+    double      doubles     = 0;
+    min16float  min16floats = 0; /* expected-warning {{min16float is promoted to half}} */
+    min10float  min10floats = 0; // expected-warning {{min10float is promoted to half}}
+    min16int    min16ints   = 0;
+    min12int    min12ints   = 0; // expected-warning {{min12int is promoted to min16int}}
+    min16uint   min16uints  = 0;
+
+    // _Static_assert(std::is_same<bool, bool>::value, "bool, bool failed");
+    _Static_assert(std::is_same<bool, __decltype(bools)>::value, "bool, __decltype(bools) failed");
+    _Static_assert(std::is_same<bool, __decltype(bools < bools)>::value, "bool, __decltype(bools < bools) failed");
+
+
+    // float result = ints + floats;
+    _Static_assert(std::is_same<min16uint, __decltype(min16ints  + min16uints)>::value, "");
+
+    // Promotion cases with addition.
+    // Two unsigned types will widen to widest type.
+    _Static_assert(std::is_same<uint, __decltype(uints      + min16uints)>::value, "");
+    _Static_assert(std::is_same<uint, __decltype(min16uints + uints     )>::value, "");
+
+    // Two signed types will widen to widest type, but remain minprecision if either is.
+    _Static_assert(std::is_same<int, __decltype(ints      + min12ints)>::value, "");
+    _Static_assert(std::is_same<int, __decltype(min12ints + ints     )>::value, "");
+
+    // Mixed signed-unsigned will widen to largest unsigned.
+    _Static_assert(std::is_same<uint, __decltype(ints  + uints)>::value, "");
+    _Static_assert(std::is_same<uint, __decltype(uints + ints )>::value, "");
+    _Static_assert(std::is_same<min16uint, __decltype(min16ints  + min16uints)>::value, "");
+    _Static_assert(std::is_same<min16uint, __decltype(min16uints + min16ints )>::value, "");
+
+    // Mixed integral/floating point will turn to floating-point.
+    _Static_assert(std::is_same<float, __decltype(ints    + floats)>::value, "");
+    _Static_assert(std::is_same<float, __decltype(uints   + floats)>::value, "");
+    _Static_assert(std::is_same<double, __decltype(doubles + ints)>::value, "");
+    _Static_assert(std::is_same<double, __decltype(uints   + doubles)>::value, "");
+
+    // For two floating-point types, they will widen to the largest one.
+    _Static_assert(std::is_same<double, __decltype(doubles + floats)>::value, "");
+    _Static_assert(std::is_same<double, __decltype(floats  + doubles)>::value, "");
+    _Static_assert(std::is_same<double, __decltype(doubles     + min16floats)>::value, "");
+    _Static_assert(std::is_same<double, __decltype(min16floats + doubles)>::value, "");
+    _Static_assert(std::is_same<double, __decltype(doubles     + min10floats)>::value, "");
+    _Static_assert(std::is_same<double, __decltype(min10floats + doubles)>::value, "");
+    _Static_assert(std::is_same<float , __decltype(floats      + min16floats)>::value, "");
+    _Static_assert(std::is_same<float , __decltype(min16floats + floats)>::value, "");
+    _Static_assert(std::is_same<float , __decltype(floats      + min10floats)>::value, "");
+    _Static_assert(std::is_same<float , __decltype(min10floats + floats)>::value, "");
+
+  // Generated by running and modifying %sdxroot%\windows\directx\dxg\HLSL\test\lib\HLSL\operators.js
+  _Static_assert(std::is_same<int, __decltype(bools + bools)>::value, "");
+  _Static_assert(std::is_same<int, __decltype(bools + ints)>::value, "");
+  _Static_assert(std::is_same<uint, __decltype(bools + uints)>::value, "");
+  _Static_assert(std::is_same<half, __decltype(bools + halfs)>::value, "");
+  _Static_assert(std::is_same<float, __decltype(bools + floats)>::value, "");
+  _Static_assert(std::is_same<double, __decltype(bools + doubles)>::value, "");
+  _Static_assert(std::is_same<min16float, __decltype(bools + min16floats)>::value, "");    /* expected-warning {{min16float is promoted to half}} */
+  _Static_assert(std::is_same<min10float, __decltype(bools + min10floats)>::value, ""); // expected-warning {{min10float is promoted to half}}
+  _Static_assert(std::is_same<int, __decltype(bools + min16ints)>::value, "");
+  _Static_assert(std::is_same<int, __decltype(bools + min12ints)>::value, "");
+  _Static_assert(std::is_same<uint, __decltype(bools + min16uints)>::value, "");
+  _Static_assert(std::is_same<int, __decltype(ints + bools)>::value, "");
+  _Static_assert(std::is_same<int, __decltype(ints + ints)>::value, "");
+  _Static_assert(std::is_same<uint, __decltype(ints + uints)>::value, "");
+  _Static_assert(std::is_same<half, __decltype(ints + halfs)>::value, "");
+  _Static_assert(std::is_same<float, __decltype(ints + floats)>::value, "");
+  _Static_assert(std::is_same<double, __decltype(ints + doubles)>::value, "");
+  _Static_assert(std::is_same<min16float, __decltype(ints + min16floats)>::value, "");  /* expected-warning {{min16float is promoted to half}} */
+  _Static_assert(std::is_same<min10float, __decltype(ints + min10floats)>::value, "");  // expected-warning {{min10float is promoted to half}}
+  _Static_assert(std::is_same<int, __decltype(ints + min16ints)>::value, "");
+  _Static_assert(std::is_same<int, __decltype(ints + min12ints)>::value, "");
+  _Static_assert(std::is_same<uint, __decltype(ints + min16uints)>::value, "");
+  _Static_assert(std::is_same<uint, __decltype(uints + bools)>::value, "");
+  _Static_assert(std::is_same<uint, __decltype(uints + ints)>::value, "");
+  _Static_assert(std::is_same<uint, __decltype(uints + uints)>::value, "");
+  _Static_assert(std::is_same<half, __decltype(uints + halfs)>::value, "");
+  _Static_assert(std::is_same<float, __decltype(uints + floats)>::value, "");
+  _Static_assert(std::is_same<double, __decltype(uints + doubles)>::value, "");
+  _Static_assert(std::is_same<min16float, __decltype(uints + min16floats)>::value, ""); /* expected-warning {{min16float is promoted to half}} */
+  _Static_assert(std::is_same<min10float, __decltype(uints + min10floats)>::value, "");  // expected-warning {{min10float is promoted to half}}
+  _Static_assert(std::is_same<uint, __decltype(uints + min16ints)>::value, "");
+  _Static_assert(std::is_same<uint, __decltype(uints + min12ints)>::value, "");
+  _Static_assert(std::is_same<uint, __decltype(uints + min16uints)>::value, "");
+  _Static_assert(std::is_same<half, __decltype(halfs + bools)>::value, "");
+  _Static_assert(std::is_same<half, __decltype(halfs + ints)>::value, "");
+  _Static_assert(std::is_same<half, __decltype(halfs + uints)>::value, "");
+  _Static_assert(std::is_same<half, __decltype(halfs + halfs)>::value, "");
+  _Static_assert(std::is_same<float, __decltype(halfs + floats)>::value, "");
+  _Static_assert(std::is_same<double, __decltype(halfs + doubles)>::value, "");
+  _Static_assert(std::is_same<half, __decltype(halfs + min16floats)>::value, "");
+  _Static_assert(std::is_same<half, __decltype(halfs + min10floats)>::value, "");
+  _Static_assert(std::is_same<half, __decltype(halfs + min16ints)>::value, "");
+  _Static_assert(std::is_same<half, __decltype(halfs + min12ints)>::value, "");
+  _Static_assert(std::is_same<half, __decltype(halfs + min16uints)>::value, "");
+  _Static_assert(std::is_same<float, __decltype(floats + bools)>::value, "");
+  _Static_assert(std::is_same<float, __decltype(floats + ints)>::value, "");
+  _Static_assert(std::is_same<float, __decltype(floats + uints)>::value, "");
+  _Static_assert(std::is_same<float, __decltype(floats + halfs)>::value, "");
+  _Static_assert(std::is_same<float, __decltype(floats + floats)>::value, "");
+  _Static_assert(std::is_same<double, __decltype(floats + doubles)>::value, "");
+  _Static_assert(std::is_same<float, __decltype(floats + min16floats)>::value, "");
+  _Static_assert(std::is_same<float, __decltype(floats + min10floats)>::value, "");
+  _Static_assert(std::is_same<float, __decltype(floats + min16ints)>::value, "");
+  _Static_assert(std::is_same<float, __decltype(floats + min12ints)>::value, "");
+  _Static_assert(std::is_same<float, __decltype(floats + min16uints)>::value, "");
+  _Static_assert(std::is_same<double, __decltype(doubles + bools)>::value, "");
+  _Static_assert(std::is_same<double, __decltype(doubles + ints)>::value, "");
+  _Static_assert(std::is_same<double, __decltype(doubles + uints)>::value, "");
+  _Static_assert(std::is_same<double, __decltype(doubles + halfs)>::value, "");
+  _Static_assert(std::is_same<double, __decltype(doubles + floats)>::value, "");
+  _Static_assert(std::is_same<double, __decltype(doubles + doubles)>::value, "");
+  _Static_assert(std::is_same<double, __decltype(doubles + min16floats)>::value, "");
+  _Static_assert(std::is_same<double, __decltype(doubles + min10floats)>::value, "");
+  _Static_assert(std::is_same<double, __decltype(doubles + min16ints)>::value, "");
+  _Static_assert(std::is_same<double, __decltype(doubles + min12ints)>::value, "");
+  _Static_assert(std::is_same<double, __decltype(doubles + min16uints)>::value, "");
+  _Static_assert(std::is_same<min16float, __decltype(min16floats + bools)>::value, "");  /* expected-warning {{min16float is promoted to half}} */
+  _Static_assert(std::is_same<min16float, __decltype(min16floats + ints)>::value, "");   /* expected-warning {{min16float is promoted to half}} */
+  _Static_assert(std::is_same<min16float, __decltype(min16floats + uints)>::value, "");  /* expected-warning {{min16float is promoted to half}} */
+  _Static_assert(std::is_same<half, __decltype(min16floats + halfs)>::value, "");
+  _Static_assert(std::is_same<float, __decltype(min16floats + floats)>::value, "");
+  _Static_assert(std::is_same<double, __decltype(min16floats + doubles)>::value, "");
+  _Static_assert(std::is_same<min16float, __decltype(min16floats + min16floats)>::value, "");    /* expected-warning {{min16float is promoted to half}} */
+  _Static_assert(std::is_same<min16float, __decltype(min16floats + min10floats)>::value, "");    /* expected-warning {{min16float is promoted to half}} */
+  _Static_assert(std::is_same<min16float, __decltype(min16floats + min16ints)>::value, "");    /* expected-warning {{min16float is promoted to half}} */
+  _Static_assert(std::is_same<min16float, __decltype(min16floats + min12ints)>::value, "");    /* expected-warning {{min16float is promoted to half}} */
+  _Static_assert(std::is_same<min16float, __decltype(min16floats + min16uints)>::value, "");    /* expected-warning {{min16float is promoted to half}} */
+  _Static_assert(std::is_same<min10float, __decltype(min10floats + bools)>::value, "");  // expected-warning {{min10float is promoted to half}}
+  _Static_assert(std::is_same<min10float, __decltype(min10floats + ints)>::value, "");   // expected-warning {{min10float is promoted to half}}
+  _Static_assert(std::is_same<min10float, __decltype(min10floats + uints)>::value, "");  // expected-warning {{min10float is promoted to half}}
+  _Static_assert(std::is_same<half, __decltype(min10floats + halfs)>::value, "");
+  _Static_assert(std::is_same<float, __decltype(min10floats + floats)>::value, "");
+  _Static_assert(std::is_same<double, __decltype(min10floats + doubles)>::value, "");
+  _Static_assert(std::is_same<min16float, __decltype(min10floats + min16floats)>::value, "");    /* expected-warning {{min16float is promoted to half}} */
+  _Static_assert(std::is_same<min10float, __decltype(min10floats + min10floats)>::value, ""); // expected-warning {{min10float is promoted to half}}
+  _Static_assert(std::is_same<min10float, __decltype(min10floats + min16ints)>::value, "");  // expected-warning {{min10float is promoted to half}}
+  _Static_assert(std::is_same<min10float, __decltype(min10floats + min12ints)>::value, "");  // expected-warning {{min10float is promoted to half}}
+  _Static_assert(std::is_same<min10float, __decltype(min10floats + min16uints)>::value, ""); // expected-warning {{min10float is promoted to half}}
+  _Static_assert(std::is_same<min16int, __decltype(min16ints + bools)>::value, "");
+  _Static_assert(std::is_same<int, __decltype(min16ints + ints)>::value, "");
+  _Static_assert(std::is_same<uint, __decltype(min16ints + uints)>::value, "");
+  _Static_assert(std::is_same<half, __decltype(min16ints + halfs)>::value, "");
+  _Static_assert(std::is_same<float, __decltype(min16ints + floats)>::value, "");
+  _Static_assert(std::is_same<double, __decltype(min16ints + doubles)>::value, "");
+  _Static_assert(std::is_same<min16float, __decltype(min16ints + min16floats)>::value, "");  /* expected-warning {{min16float is promoted to half}} */
+  _Static_assert(std::is_same<min10float, __decltype(min16ints + min10floats)>::value, "");  // expected-warning {{min10float is promoted to half}}
+  _Static_assert(std::is_same<min16int, __decltype(min16ints + min16ints)>::value, "");
+  _Static_assert(std::is_same<min16int, __decltype(min16ints + min12ints)>::value, "");
+  _Static_assert(std::is_same<min16uint, __decltype(min16ints + min16uints)>::value, "");
+  _Static_assert(std::is_same<min12int, __decltype(min12ints + bools)>::value, "");   // expected-warning {{min12int is promoted to min16int}}
+  _Static_assert(std::is_same<int, __decltype(min12ints + ints)>::value, "");
+  _Static_assert(std::is_same<uint, __decltype(min12ints + uints)>::value, "");
+  _Static_assert(std::is_same<half, __decltype(min12ints + halfs)>::value, "");
+  _Static_assert(std::is_same<float, __decltype(min12ints + floats)>::value, "");
+  _Static_assert(std::is_same<double, __decltype(min12ints + doubles)>::value, "");
+  _Static_assert(std::is_same<min16float, __decltype(min12ints + min16floats)>::value, "");    /* expected-warning {{min16float is promoted to half}} */
+  _Static_assert(std::is_same<min10float, __decltype(min12ints + min10floats)>::value, "");  // expected-warning {{min10float is promoted to half}}
+  _Static_assert(std::is_same<min16int, __decltype(min12ints + min16ints)>::value, "");
+  _Static_assert(std::is_same<min12int, __decltype(min12ints + min12ints)>::value, "");    // expected-warning {{min12int is promoted to min16int}}
+  _Static_assert(std::is_same<min16uint, __decltype(min12ints + min16uints)>::value, "");
+  _Static_assert(std::is_same<min16uint, __decltype(min16uints + bools)>::value, "");
+  _Static_assert(std::is_same<uint, __decltype(min16uints + ints)>::value, "");
+  _Static_assert(std::is_same<uint, __decltype(min16uints + uints)>::value, "");
+  _Static_assert(std::is_same<half, __decltype(min16uints + halfs)>::value, "");
+  _Static_assert(std::is_same<float, __decltype(min16uints + floats)>::value, "");
+  _Static_assert(std::is_same<double, __decltype(min16uints + doubles)>::value, "");
+  _Static_assert(std::is_same<min16float, __decltype(min16uints + min16floats)>::value, "");    /* expected-warning {{min16float is promoted to half}} */
+  _Static_assert(std::is_same<min10float, __decltype(min16uints + min10floats)>::value, "");   // expected-warning {{min10float is promoted to half}}
+  _Static_assert(std::is_same<min16uint, __decltype(min16uints + min16ints)>::value, "");
+  _Static_assert(std::is_same<min16uint, __decltype(min16uints + min12ints)>::value, "");
+  _Static_assert(std::is_same<min16uint, __decltype(min16uints + min16uints)>::value, "");
+  _Static_assert(std::is_same<int, __decltype(bools - bools)>::value, "");
+  _Static_assert(std::is_same<int, __decltype(bools - ints)>::value, "");
+  _Static_assert(std::is_same<uint, __decltype(bools - uints)>::value, "");
+  _Static_assert(std::is_same<half, __decltype(bools - halfs)>::value, "");
+  _Static_assert(std::is_same<float, __decltype(bools - floats)>::value, "");
+  _Static_assert(std::is_same<double, __decltype(bools - doubles)>::value, "");
+  _Static_assert(std::is_same<min16float, __decltype(bools - min16floats)>::value, "");        /* expected-warning {{min16float is promoted to half}} */
+  _Static_assert(std::is_same<min10float, __decltype(bools - min10floats)>::value, "");  // expected-warning {{min10float is promoted to half}}
+  _Static_assert(std::is_same<int, __decltype(bools - min16ints)>::value, "");
+  _Static_assert(std::is_same<int, __decltype(bools - min12ints)>::value, "");
+  _Static_assert(std::is_same<uint, __decltype(bools - min16uints)>::value, "");
+  _Static_assert(std::is_same<int, __decltype(ints - bools)>::value, "");
+  _Static_assert(std::is_same<int, __decltype(ints - ints)>::value, "");
+  _Static_assert(std::is_same<uint, __decltype(ints - uints)>::value, "");
+  _Static_assert(std::is_same<half, __decltype(ints - halfs)>::value, "");
+  _Static_assert(std::is_same<float, __decltype(ints - floats)>::value, "");
+  _Static_assert(std::is_same<double, __decltype(ints - doubles)>::value, "");
+  _Static_assert(std::is_same<min16float, __decltype(ints - min16floats)>::value, "");   /* expected-warning {{min16float is promoted to half}} */
+  _Static_assert(std::is_same<min10float, __decltype(ints - min10floats)>::value, "");  // expected-warning {{min10float is promoted to half}}
+  _Static_assert(std::is_same<int, __decltype(ints - min16ints)>::value, "");
+  _Static_assert(std::is_same<int, __decltype(ints - min12ints)>::value, "");
+  _Static_assert(std::is_same<uint, __decltype(ints - min16uints)>::value, "");
+  _Static_assert(std::is_same<uint, __decltype(uints - bools)>::value, "");
+  _Static_assert(std::is_same<uint, __decltype(uints - ints)>::value, "");
+  _Static_assert(std::is_same<uint, __decltype(uints - uints)>::value, "");
+  _Static_assert(std::is_same<half, __decltype(uints - halfs)>::value, "");
+  _Static_assert(std::is_same<float, __decltype(uints - floats)>::value, "");
+  _Static_assert(std::is_same<double, __decltype(uints - doubles)>::value, "");
+  _Static_assert(std::is_same<min16float, __decltype(uints - min16floats)>::value, ""); /* expected-warning {{min16float is promoted to half}} */
+  _Static_assert(std::is_same<min10float, __decltype(uints - min10floats)>::value, "");  // expected-warning {{min10float is promoted to half}}
+  _Static_assert(std::is_same<uint, __decltype(uints - min16ints)>::value, "");
+  _Static_assert(std::is_same<uint, __decltype(uints - min12ints)>::value, "");
+  _Static_assert(std::is_same<uint, __decltype(uints - min16uints)>::value, "");
+  _Static_assert(std::is_same<half, __decltype(halfs - bools)>::value, "");
+  _Static_assert(std::is_same<half, __decltype(halfs - ints)>::value, "");
+  _Static_assert(std::is_same<half, __decltype(halfs - uints)>::value, "");
+  _Static_assert(std::is_same<half, __decltype(halfs - halfs)>::value, "");
+  _Static_assert(std::is_same<float, __decltype(halfs - floats)>::value, "");
+  _Static_assert(std::is_same<double, __decltype(halfs - doubles)>::value, "");
+  _Static_assert(std::is_same<half, __decltype(halfs - min16floats)>::value, "");
+  _Static_assert(std::is_same<half, __decltype(halfs - min10floats)>::value, "");
+  _Static_assert(std::is_same<half, __decltype(halfs - min16ints)>::value, "");
+  _Static_assert(std::is_same<half, __decltype(halfs - min12ints)>::value, "");
+  _Static_assert(std::is_same<half, __decltype(halfs - min16uints)>::value, "");
+  _Static_assert(std::is_same<float, __decltype(floats - bools)>::value, "");
+  _Static_assert(std::is_same<float, __decltype(floats - ints)>::value, "");
+  _Static_assert(std::is_same<float, __decltype(floats - uints)>::value, "");
+  _Static_assert(std::is_same<float, __decltype(floats - halfs)>::value, "");
+  _Static_assert(std::is_same<float, __decltype(floats - floats)>::value, "");
+  _Static_assert(std::is_same<double, __decltype(floats - doubles)>::value, "");
+  _Static_assert(std::is_same<float, __decltype(floats - min16floats)>::value, "");
+  _Static_assert(std::is_same<float, __decltype(floats - min10floats)>::value, "");
+  _Static_assert(std::is_same<float, __decltype(floats - min16ints)>::value, "");
+  _Static_assert(std::is_same<float, __decltype(floats - min12ints)>::value, "");
+  _Static_assert(std::is_same<float, __decltype(floats - min16uints)>::value, "");
+  _Static_assert(std::is_same<double, __decltype(doubles - bools)>::value, "");
+  _Static_assert(std::is_same<double, __decltype(doubles - ints)>::value, "");
+  _Static_assert(std::is_same<double, __decltype(doubles - uints)>::value, "");
+  _Static_assert(std::is_same<double, __decltype(doubles - halfs)>::value, "");
+  _Static_assert(std::is_same<double, __decltype(doubles - floats)>::value, "");
+  _Static_assert(std::is_same<double, __decltype(doubles - doubles)>::value, "");
+  _Static_assert(std::is_same<double, __decltype(doubles - min16floats)>::value, "");
+  _Static_assert(std::is_same<double, __decltype(doubles - min10floats)>::value, "");
+  _Static_assert(std::is_same<double, __decltype(doubles - min16ints)>::value, "");
+  _Static_assert(std::is_same<double, __decltype(doubles - min12ints)>::value, "");
+  _Static_assert(std::is_same<double, __decltype(doubles - min16uints)>::value, "");
+  _Static_assert(std::is_same<min16float, __decltype(min16floats - bools)>::value, "");  /* expected-warning {{min16float is promoted to half}} */
+  _Static_assert(std::is_same<min16float, __decltype(min16floats - ints)>::value, "");   /* expected-warning {{min16float is promoted to half}} */
+  _Static_assert(std::is_same<min16float, __decltype(min16floats - uints)>::value, "");  /* expected-warning {{min16float is promoted to half}} */
+  _Static_assert(std::is_same<half, __decltype(min16floats - halfs)>::value, "");
+  _Static_assert(std::is_same<float, __decltype(min16floats - floats)>::value, "");
+  _Static_assert(std::is_same<double, __decltype(min16floats - doubles)>::value, "");
+  _Static_assert(std::is_same<min16float, __decltype(min16floats - min16floats)>::value, "");    /* expected-warning {{min16float is promoted to half}} */
+  _Static_assert(std::is_same<min16float, __decltype(min16floats - min10floats)>::value, "");    /* expected-warning {{min16float is promoted to half}} */
+  _Static_assert(std::is_same<min16float, __decltype(min16floats - min16ints)>::value, "");    /* expected-warning {{min16float is promoted to half}} */
+  _Static_assert(std::is_same<min16float, __decltype(min16floats - min12ints)>::value, "");    /* expected-warning {{min16float is promoted to half}} */
+  _Static_assert(std::is_same<min16float, __decltype(min16floats - min16uints)>::value, "");    /* expected-warning {{min16float is promoted to half}} */
+  _Static_assert(std::is_same<min10float, __decltype(min10floats - bools)>::value, "");   // expected-warning {{min10float is promoted to half}}
+  _Static_assert(std::is_same<min10float, __decltype(min10floats - ints)>::value, "");    // expected-warning {{min10float is promoted to half}}
+  _Static_assert(std::is_same<min10float, __decltype(min10floats - uints)>::value, "");   // expected-warning {{min10float is promoted to half}}
+  _Static_assert(std::is_same<half, __decltype(min10floats - halfs)>::value, "");
+  _Static_assert(std::is_same<float, __decltype(min10floats - floats)>::value, "");
+  _Static_assert(std::is_same<double, __decltype(min10floats - doubles)>::value, "");
+  _Static_assert(std::is_same<min16float, __decltype(min10floats - min16floats)>::value, "");    /* expected-warning {{min16float is promoted to half}} */
+  _Static_assert(std::is_same<min10float, __decltype(min10floats - min10floats)>::value, "");  // expected-warning {{min10float is promoted to half}}
+  _Static_assert(std::is_same<min10float, __decltype(min10floats - min16ints)>::value, "");    // expected-warning {{min10float is promoted to half}}
+  _Static_assert(std::is_same<min10float, __decltype(min10floats - min12ints)>::value, "");    // expected-warning {{min10float is promoted to half}}
+  _Static_assert(std::is_same<min10float, __decltype(min10floats - min16uints)>::value, "");   // expected-warning {{min10float is promoted to half}}
+  _Static_assert(std::is_same<min16int, __decltype(min16ints - bools)>::value, "");
+  _Static_assert(std::is_same<int, __decltype(min16ints - ints)>::value, "");
+  _Static_assert(std::is_same<uint, __decltype(min16ints - uints)>::value, "");
+  _Static_assert(std::is_same<half, __decltype(min16ints - halfs)>::value, "");
+  _Static_assert(std::is_same<float, __decltype(min16ints - floats)>::value, "");
+  _Static_assert(std::is_same<double, __decltype(min16ints - doubles)>::value, "");
+  _Static_assert(std::is_same<min16float, __decltype(min16ints - min16floats)>::value, "");    /* expected-warning {{min16float is promoted to half}} */
+  _Static_assert(std::is_same<min10float, __decltype(min16ints - min10floats)>::value, "");   // expected-warning {{min10float is promoted to half}}
+  _Static_assert(std::is_same<min16int, __decltype(min16ints - min16ints)>::value, "");
+  _Static_assert(std::is_same<min16int, __decltype(min16ints - min12ints)>::value, "");
+  _Static_assert(std::is_same<min16uint, __decltype(min16ints - min16uints)>::value, "");
+  _Static_assert(std::is_same<min12int, __decltype(min12ints - bools)>::value, "");  // expected-warning {{min12int is promoted to min16int}}
+  _Static_assert(std::is_same<int, __decltype(min12ints - ints)>::value, "");
+  _Static_assert(std::is_same<uint, __decltype(min12ints - uints)>::value, "");
+  _Static_assert(std::is_same<half, __decltype(min12ints - halfs)>::value, "");
+  _Static_assert(std::is_same<float, __decltype(min12ints - floats)>::value, "");
+  _Static_assert(std::is_same<double, __decltype(min12ints - doubles)>::value, "");
+  _Static_assert(std::is_same<min16float, __decltype(min12ints - min16floats)>::value, "");    /* expected-warning {{min16float is promoted to half}} */
+  _Static_assert(std::is_same<min10float, __decltype(min12ints - min10floats)>::value, "");   // expected-warning {{min10float is promoted to half}}
+  _Static_assert(std::is_same<min16int, __decltype(min12ints - min16ints)>::value, "");
+  _Static_assert(std::is_same<min12int, __decltype(min12ints - min12ints)>::value, "");  // expected-warning {{min12int is promoted to min16int}}
+  _Static_assert(std::is_same<min16uint, __decltype(min12ints - min16uints)>::value, "");
+  _Static_assert(std::is_same<min16uint, __decltype(min16uints - bools)>::value, "");
+  _Static_assert(std::is_same<uint, __decltype(min16uints - ints)>::value, "");
+  _Static_assert(std::is_same<uint, __decltype(min16uints - uints)>::value, "");
+  _Static_assert(std::is_same<half, __decltype(min16uints - halfs)>::value, "");
+  _Static_assert(std::is_same<float, __decltype(min16uints - floats)>::value, "");
+  _Static_assert(std::is_same<double, __decltype(min16uints - doubles)>::value, "");
+  _Static_assert(std::is_same<min16float, __decltype(min16uints - min16floats)>::value, "");    /* expected-warning {{min16float is promoted to half}} */
+  _Static_assert(std::is_same<min10float, __decltype(min16uints - min10floats)>::value, "");   // expected-warning {{min10float is promoted to half}}
+  _Static_assert(std::is_same<min16uint, __decltype(min16uints - min16ints)>::value, "");
+  _Static_assert(std::is_same<min16uint, __decltype(min16uints - min12ints)>::value, "");
+  _Static_assert(std::is_same<min16uint, __decltype(min16uints - min16uints)>::value, "");
+  _Static_assert(std::is_same<int, __decltype(bools / bools)>::value, "");
+  _Static_assert(std::is_same<int, __decltype(bools / ints)>::value, "");
+  _Static_assert(std::is_same<uint, __decltype(bools / uints)>::value, "");
+  _Static_assert(std::is_same<half, __decltype(bools / halfs)>::value, "");
+  _Static_assert(std::is_same<float, __decltype(bools / floats)>::value, "");
+  _Static_assert(std::is_same<double, __decltype(bools / doubles)>::value, "");
+  _Static_assert(std::is_same<min16float, __decltype(bools / min16floats)>::value, "");        /* expected-warning {{min16float is promoted to half}} */
+  _Static_assert(std::is_same<min10float, __decltype(bools / min10floats)>::value, "");   // expected-warning {{min10float is promoted to half}}
+  _Static_assert(std::is_same<int, __decltype(bools / min16ints)>::value, "");
+  _Static_assert(std::is_same<int, __decltype(bools / min12ints)>::value, "");
+  _Static_assert(std::is_same<uint, __decltype(bools / min16uints)>::value, "");
+  _Static_assert(std::is_same<int, __decltype(ints / bools)>::value, "");
+  _Static_assert(std::is_same<int, __decltype(ints / ints)>::value, "");
+  _Static_assert(std::is_same<uint, __decltype(ints / uints)>::value, "");
+  _Static_assert(std::is_same<half, __decltype(ints / halfs)>::value, "");
+  _Static_assert(std::is_same<float, __decltype(ints / floats)>::value, "");
+  _Static_assert(std::is_same<double, __decltype(ints / doubles)>::value, "");
+  _Static_assert(std::is_same<min16float, __decltype(ints / min16floats)>::value, "");    /* expected-warning {{min16float is promoted to half}} */
+  _Static_assert(std::is_same<min10float, __decltype(ints / min10floats)>::value, "");   // expected-warning {{min10float is promoted to half}}
+  _Static_assert(std::is_same<int, __decltype(ints / min16ints)>::value, "");
+  _Static_assert(std::is_same<int, __decltype(ints / min12ints)>::value, "");
+  _Static_assert(std::is_same<uint, __decltype(ints / min16uints)>::value, "");
+  _Static_assert(std::is_same<uint, __decltype(uints / bools)>::value, "");
+  _Static_assert(std::is_same<uint, __decltype(uints / ints)>::value, "");
+  _Static_assert(std::is_same<uint, __decltype(uints / uints)>::value, "");
+  _Static_assert(std::is_same<half, __decltype(uints / halfs)>::value, "");
+  _Static_assert(std::is_same<float, __decltype(uints / floats)>::value, "");
+  _Static_assert(std::is_same<double, __decltype(uints / doubles)>::value, "");
+  _Static_assert(std::is_same<min16float, __decltype(uints / min16floats)>::value, "");  /* expected-warning {{min16float is promoted to half}} */
+  _Static_assert(std::is_same<min10float, __decltype(uints / min10floats)>::value, "");  // expected-warning {{min10float is promoted to half}}
+  _Static_assert(std::is_same<uint, __decltype(uints / min16ints)>::value, "");
+  _Static_assert(std::is_same<uint, __decltype(uints / min12ints)>::value, "");
+  _Static_assert(std::is_same<uint, __decltype(uints / min16uints)>::value, "");
+  _Static_assert(std::is_same<half, __decltype(halfs / bools)>::value, "");
+  _Static_assert(std::is_same<half, __decltype(halfs / ints)>::value, "");
+  _Static_assert(std::is_same<half, __decltype(halfs / uints)>::value, "");
+  _Static_assert(std::is_same<half, __decltype(halfs / halfs)>::value, "");
+  _Static_assert(std::is_same<float, __decltype(halfs / floats)>::value, "");
+  _Static_assert(std::is_same<double, __decltype(halfs / doubles)>::value, "");
+  _Static_assert(std::is_same<half, __decltype(halfs / min16floats)>::value, "");
+  _Static_assert(std::is_same<half, __decltype(halfs / min10floats)>::value, "");
+  _Static_assert(std::is_same<half, __decltype(halfs / min16ints)>::value, "");
+  _Static_assert(std::is_same<half, __decltype(halfs / min12ints)>::value, "");
+  _Static_assert(std::is_same<half, __decltype(halfs / min16uints)>::value, "");
+  _Static_assert(std::is_same<float, __decltype(floats / bools)>::value, "");
+  _Static_assert(std::is_same<float, __decltype(floats / ints)>::value, "");
+  _Static_assert(std::is_same<float, __decltype(floats / uints)>::value, "");
+  _Static_assert(std::is_same<float, __decltype(floats / halfs)>::value, "");
+  _Static_assert(std::is_same<float, __decltype(floats / floats)>::value, "");
+  _Static_assert(std::is_same<double, __decltype(floats / doubles)>::value, "");
+  _Static_assert(std::is_same<float, __decltype(floats / min16floats)>::value, "");
+  _Static_assert(std::is_same<float, __decltype(floats / min10floats)>::value, "");
+  _Static_assert(std::is_same<float, __decltype(floats / min16ints)>::value, "");
+  _Static_assert(std::is_same<float, __decltype(floats / min12ints)>::value, "");
+  _Static_assert(std::is_same<float, __decltype(floats / min16uints)>::value, "");
+  _Static_assert(std::is_same<double, __decltype(doubles / bools)>::value, "");
+  _Static_assert(std::is_same<double, __decltype(doubles / ints)>::value, "");
+  _Static_assert(std::is_same<double, __decltype(doubles / uints)>::value, "");
+  _Static_assert(std::is_same<double, __decltype(doubles / halfs)>::value, "");
+  _Static_assert(std::is_same<double, __decltype(doubles / floats)>::value, "");
+  _Static_assert(std::is_same<double, __decltype(doubles / doubles)>::value, "");
+  _Static_assert(std::is_same<double, __decltype(doubles / min16floats)>::value, "");
+  _Static_assert(std::is_same<double, __decltype(doubles / min10floats)>::value, "");
+  _Static_assert(std::is_same<double, __decltype(doubles / min16ints)>::value, "");
+  _Static_assert(std::is_same<double, __decltype(doubles / min12ints)>::value, "");
+  _Static_assert(std::is_same<double, __decltype(doubles / min16uints)>::value, "");
+  _Static_assert(std::is_same<min16float, __decltype(min16floats / bools)>::value, "");  /* expected-warning {{min16float is promoted to half}} */
+  _Static_assert(std::is_same<min16float, __decltype(min16floats / ints)>::value, "");   /* expected-warning {{min16float is promoted to half}} */
+  _Static_assert(std::is_same<min16float, __decltype(min16floats / uints)>::value, "");  /* expected-warning {{min16float is promoted to half}} */
+  _Static_assert(std::is_same<half, __decltype(min16floats / halfs)>::value, "");
+  _Static_assert(std::is_same<float, __decltype(min16floats / floats)>::value, "");
+  _Static_assert(std::is_same<double, __decltype(min16floats / doubles)>::value, "");
+  _Static_assert(std::is_same<min16float, __decltype(min16floats / min16floats)>::value, "");    /* expected-warning {{min16float is promoted to half}} */
+  _Static_assert(std::is_same<min16float, __decltype(min16floats / min10floats)>::value, "");    /* expected-warning {{min16float is promoted to half}} */
+  _Static_assert(std::is_same<min16float, __decltype(min16floats / min16ints)>::value, "");    /* expected-warning {{min16float is promoted to half}} */
+  _Static_assert(std::is_same<min16float, __decltype(min16floats / min12ints)>::value, "");    /* expected-warning {{min16float is promoted to half}} */
+  _Static_assert(std::is_same<min16float, __decltype(min16floats / min16uints)>::value, "");    /* expected-warning {{min16float is promoted to half}} */
+  _Static_assert(std::is_same<min10float, __decltype(min10floats / bools)>::value, "");   // expected-warning {{min10float is promoted to half}}
+  _Static_assert(std::is_same<min10float, __decltype(min10floats / ints)>::value, "");    // expected-warning {{min10float is promoted to half}}
+  _Static_assert(std::is_same<min10float, __decltype(min10floats / uints)>::value, "");   // expected-warning {{min10float is promoted to half}}
+  _Static_assert(std::is_same<half, __decltype(min10floats / halfs)>::value, "");
+  _Static_assert(std::is_same<float, __decltype(min10floats / floats)>::value, "");
+  _Static_assert(std::is_same<double, __decltype(min10floats / doubles)>::value, "");
+  _Static_assert(std::is_same<min16float, __decltype(min10floats / min16floats)>::value, "");    /* expected-warning {{min16float is promoted to half}} */
+  _Static_assert(std::is_same<min10float, __decltype(min10floats / min10floats)>::value, "");  // expected-warning {{min10float is promoted to half}}
+  _Static_assert(std::is_same<min10float, __decltype(min10floats / min16ints)>::value, "");    // expected-warning {{min10float is promoted to half}}
+  _Static_assert(std::is_same<min10float, __decltype(min10floats / min12ints)>::value, "");    // expected-warning {{min10float is promoted to half}}
+  _Static_assert(std::is_same<min10float, __decltype(min10floats / min16uints)>::value, "");   // expected-warning {{min10float is promoted to half}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-52): error X3706: signed integer division is not supported on minimum-precision types. Cast to int to use 32-bit division.;compilation failed; no code produced;
+  min16ints = (min16ints / bools); // expected-error {{signed integer division is not supported on minimum-precision types, cast to int to use 32-bit division}} fxc-error {{X3706: signed integer division is not supported on minimum-precision types. Cast to int to use 32-bit division.}}
+  _Static_assert(std::is_same<int, __decltype(min16ints / ints)>::value, "");
+  _Static_assert(std::is_same<uint, __decltype(min16ints / uints)>::value, "");
+  _Static_assert(std::is_same<half, __decltype(min16ints / halfs)>::value, "");
+  _Static_assert(std::is_same<float, __decltype(min16ints / floats)>::value, "");
+  _Static_assert(std::is_same<double, __decltype(min16ints / doubles)>::value, "");
+  _Static_assert(std::is_same<min16float, __decltype(min16ints / min16floats)>::value, "");    /* expected-warning {{min16float is promoted to half}} */
+  _Static_assert(std::is_same<min10float, __decltype(min16ints / min10floats)>::value, "");  // expected-warning {{min10float is promoted to half}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-56): error X3706: signed integer division is not supported on minimum-precision types. Cast to int to use 32-bit division.;compilation failed; no code produced;
+  min16ints = (min16ints / min16ints); // expected-error {{signed integer division is not supported on minimum-precision types, cast to int to use 32-bit division}} fxc-error {{X3706: signed integer division is not supported on minimum-precision types. Cast to int to use 32-bit division.}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-56): error X3706: signed integer division is not supported on minimum-precision types. Cast to int to use 32-bit division.;compilation failed; no code produced;
+  min16ints = (min16ints / min12ints); // expected-error {{signed integer division is not supported on minimum-precision types, cast to int to use 32-bit division}} fxc-error {{X3706: signed integer division is not supported on minimum-precision types. Cast to int to use 32-bit division.}}
+  _Static_assert(std::is_same<min16uint, __decltype(min16ints / min16uints)>::value, "");
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-52): error X3706: signed integer division is not supported on minimum-precision types. Cast to int to use 32-bit division.;compilation failed; no code produced;
+  min12ints = (min12ints / bools); // expected-error {{signed integer division is not supported on minimum-precision types, cast to int to use 32-bit division}} fxc-error {{X3706: signed integer division is not supported on minimum-precision types. Cast to int to use 32-bit division.}}
+  _Static_assert(std::is_same<int, __decltype(min12ints / ints)>::value, "");
+  _Static_assert(std::is_same<uint, __decltype(min12ints / uints)>::value, "");
+  _Static_assert(std::is_same<half, __decltype(min12ints / halfs)>::value, "");
+  _Static_assert(std::is_same<float, __decltype(min12ints / floats)>::value, "");
+  _Static_assert(std::is_same<double, __decltype(min12ints / doubles)>::value, "");
+  _Static_assert(std::is_same<min16float, __decltype(min12ints / min16floats)>::value, "");    /* expected-warning {{min16float is promoted to half}} */
+  _Static_assert(std::is_same<min10float, __decltype(min12ints / min10floats)>::value, "");  // expected-warning {{min10float is promoted to half}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-56): error X3706: signed integer division is not supported on minimum-precision types. Cast to int to use 32-bit division.;compilation failed; no code produced;
+  min12ints = (min12ints / min16ints); // expected-error {{signed integer division is not supported on minimum-precision types, cast to int to use 32-bit division}} fxc-error {{X3706: signed integer division is not supported on minimum-precision types. Cast to int to use 32-bit division.}} fxc-warning {{X3205: conversion from larger type to smaller, possible loss of data}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-56): error X3706: signed integer division is not supported on minimum-precision types. Cast to int to use 32-bit division.;compilation failed; no code produced;
+  min12ints = (min12ints / min12ints); // expected-error {{signed integer division is not supported on minimum-precision types, cast to int to use 32-bit division}} fxc-error {{X3706: signed integer division is not supported on minimum-precision types. Cast to int to use 32-bit division.}}
+  _Static_assert(std::is_same<min16uint, __decltype(min12ints / min16uints)>::value, "");
+  _Static_assert(std::is_same<min16uint, __decltype(min16uints / bools)>::value, "");
+  _Static_assert(std::is_same<uint, __decltype(min16uints / ints)>::value, "");
+  _Static_assert(std::is_same<uint, __decltype(min16uints / uints)>::value, "");
+  _Static_assert(std::is_same<half, __decltype(min16uints / halfs)>::value, "");
+  _Static_assert(std::is_same<float, __decltype(min16uints / floats)>::value, "");
+  _Static_assert(std::is_same<double, __decltype(min16uints / doubles)>::value, "");
+  _Static_assert(std::is_same<min16float, __decltype(min16uints / min16floats)>::value, "");    /* expected-warning {{min16float is promoted to half}} */
+  _Static_assert(std::is_same<min10float, __decltype(min16uints / min10floats)>::value, "");  // expected-warning {{min10float is promoted to half}}
+  _Static_assert(std::is_same<min16uint, __decltype(min16uints / min16ints)>::value, "");
+  _Static_assert(std::is_same<min16uint, __decltype(min16uints / min12ints)>::value, "");
+  _Static_assert(std::is_same<min16uint, __decltype(min16uints / min16uints)>::value, "");
+  _Static_assert(std::is_same<int, __decltype(bools % bools)>::value, "");
+  _Static_assert(std::is_same<int, __decltype(bools % ints)>::value, "");
+  _Static_assert(std::is_same<uint, __decltype(bools % uints)>::value, "");
+  _Static_assert(std::is_same<half, __decltype(bools % halfs)>::value, "");
+  _Static_assert(std::is_same<float, __decltype(bools % floats)>::value, "");
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-50): error X3684: modulo cannot be used with doubles, cast to float first;compilation failed; no code produced;
+  bools = (bools % doubles); // expected-error {{modulo cannot be used with doubles, cast to float first}} fxc-error {{X3684: modulo cannot be used with doubles, cast to float first}}
+  _Static_assert(std::is_same<min16float, __decltype(bools % min16floats)>::value, "");    /* expected-warning {{min16float is promoted to half}} */
+  _Static_assert(std::is_same<min10float, __decltype(bools % min10floats)>::value, "");  // expected-warning {{min10float is promoted to half}}
+  _Static_assert(std::is_same<int, __decltype(bools % min16ints)>::value, "");
+  _Static_assert(std::is_same<int, __decltype(bools % min12ints)>::value, "");
+  _Static_assert(std::is_same<uint, __decltype(bools % min16uints)>::value, "");
+  _Static_assert(std::is_same<int, __decltype(ints % bools)>::value, "");
+  _Static_assert(std::is_same<int, __decltype(ints % ints)>::value, "");
+  _Static_assert(std::is_same<uint, __decltype(ints % uints)>::value, "");
+  _Static_assert(std::is_same<half, __decltype(ints % halfs)>::value, "");
+  _Static_assert(std::is_same<float, __decltype(ints % floats)>::value, "");
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-49): error X3684: modulo cannot be used with doubles, cast to float first;compilation failed; no code produced;
+  ints = (ints % doubles); // expected-error {{modulo cannot be used with doubles, cast to float first}} expected-warning {{conversion from larger type 'double' to smaller type 'int', possible loss of data}} fxc-error {{X3684: modulo cannot be used with doubles, cast to float first}} fxc-warning {{X3205: conversion from larger type to smaller, possible loss of data}}
+  _Static_assert(std::is_same<min16float, __decltype(ints % min16floats)>::value, "");    /* expected-warning {{min16float is promoted to half}} */
+  _Static_assert(std::is_same<min10float, __decltype(ints % min10floats)>::value, "");  // expected-warning {{min10float is promoted to half}}
+  _Static_assert(std::is_same<int, __decltype(ints % min16ints)>::value, "");
+  _Static_assert(std::is_same<int, __decltype(ints % min12ints)>::value, "");
+  _Static_assert(std::is_same<uint, __decltype(ints % min16uints)>::value, "");
+  _Static_assert(std::is_same<uint, __decltype(uints % bools)>::value, "");
+  _Static_assert(std::is_same<uint, __decltype(uints % ints)>::value, "");
+  _Static_assert(std::is_same<uint, __decltype(uints % uints)>::value, "");
+  _Static_assert(std::is_same<half, __decltype(uints % halfs)>::value, "");
+  _Static_assert(std::is_same<float, __decltype(uints % floats)>::value, "");
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-50): error X3684: modulo cannot be used with doubles, cast to float first;compilation failed; no code produced;
+  uints = (uints % doubles); // expected-error {{modulo cannot be used with doubles, cast to float first}} expected-warning {{conversion from larger type 'double' to smaller type 'uint', possible loss of data}} fxc-error {{X3684: modulo cannot be used with doubles, cast to float first}} fxc-warning {{X3205: conversion from larger type to smaller, possible loss of data}}
+  _Static_assert(std::is_same<min16float, __decltype(uints % min16floats)>::value, "");    /* expected-warning {{min16float is promoted to half}} */
+  _Static_assert(std::is_same<min10float, __decltype(uints % min10floats)>::value, "");  // expected-warning {{min10float is promoted to half}}
+  _Static_assert(std::is_same<uint, __decltype(uints % min16ints)>::value, "");
+  _Static_assert(std::is_same<uint, __decltype(uints % min12ints)>::value, "");
+  _Static_assert(std::is_same<uint, __decltype(uints % min16uints)>::value, "");
+  _Static_assert(std::is_same<half, __decltype(halfs % bools)>::value, "");
+  _Static_assert(std::is_same<half, __decltype(halfs % ints)>::value, "");
+  _Static_assert(std::is_same<half, __decltype(halfs % uints)>::value, "");
+  _Static_assert(std::is_same<half, __decltype(halfs % halfs)>::value, "");
+  _Static_assert(std::is_same<float, __decltype(halfs % floats)>::value, "");
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-50): error X3684: modulo cannot be used with doubles, cast to float first;compilation failed; no code produced;
+  halfs = (halfs % doubles); // expected-error {{modulo cannot be used with doubles, cast to float first}} expected-warning {{conversion from larger type 'double' to smaller type 'half', possible loss of data}} fxc-error {{X3684: modulo cannot be used with doubles, cast to float first}} fxc-warning {{X3205: conversion from larger type to smaller, possible loss of data}}
+  _Static_assert(std::is_same<half, __decltype(halfs % min16floats)>::value, "");
+  _Static_assert(std::is_same<half, __decltype(halfs % min10floats)>::value, "");
+  _Static_assert(std::is_same<half, __decltype(halfs % min16ints)>::value, "");
+  _Static_assert(std::is_same<half, __decltype(halfs % min12ints)>::value, "");
+  _Static_assert(std::is_same<half, __decltype(halfs % min16uints)>::value, "");
+  _Static_assert(std::is_same<float, __decltype(floats % bools)>::value, "");
+  _Static_assert(std::is_same<float, __decltype(floats % ints)>::value, "");
+  _Static_assert(std::is_same<float, __decltype(floats % uints)>::value, "");
+  _Static_assert(std::is_same<float, __decltype(floats % halfs)>::value, "");
+  _Static_assert(std::is_same<float, __decltype(floats % floats)>::value, "");
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-51): error X3684: modulo cannot be used with doubles, cast to float first;compilation failed; no code produced;
+  floats = (floats % doubles); // expected-error {{modulo cannot be used with doubles, cast to float first}} expected-warning {{conversion from larger type 'double' to smaller type 'float', possible loss of data}} fxc-error {{X3684: modulo cannot be used with doubles, cast to float first}} fxc-warning {{X3205: conversion from larger type to smaller, possible loss of data}}
+  _Static_assert(std::is_same<float, __decltype(floats % min16floats)>::value, "");
+  _Static_assert(std::is_same<float, __decltype(floats % min10floats)>::value, "");
+  _Static_assert(std::is_same<float, __decltype(floats % min16ints)>::value, "");
+  _Static_assert(std::is_same<float, __decltype(floats % min12ints)>::value, "");
+  _Static_assert(std::is_same<float, __decltype(floats % min16uints)>::value, "");
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-50): error X3684: modulo cannot be used with doubles, cast to float first;compilation failed; no code produced;
+  doubles = (doubles % bools); // expected-error {{modulo cannot be used with doubles, cast to float first}} fxc-error {{X3684: modulo cannot be used with doubles, cast to float first}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-49): error X3684: modulo cannot be used with doubles, cast to float first;compilation failed; no code produced;
+  doubles = (doubles % ints); // expected-error {{modulo cannot be used with doubles, cast to float first}} fxc-error {{X3684: modulo cannot be used with doubles, cast to float first}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-50): error X3684: modulo cannot be used with doubles, cast to float first;compilation failed; no code produced;
+  doubles = (doubles % uints); // expected-error {{modulo cannot be used with doubles, cast to float first}} fxc-error {{X3684: modulo cannot be used with doubles, cast to float first}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-50): error X3684: modulo cannot be used with doubles, cast to float first;compilation failed; no code produced;
+  doubles = (doubles % halfs); // expected-error {{modulo cannot be used with doubles, cast to float first}} fxc-error {{X3684: modulo cannot be used with doubles, cast to float first}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-51): error X3684: modulo cannot be used with doubles, cast to float first;compilation failed; no code produced;
+  doubles = (doubles % floats); // expected-error {{modulo cannot be used with doubles, cast to float first}} fxc-error {{X3684: modulo cannot be used with doubles, cast to float first}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-52): error X3684: modulo cannot be used with doubles, cast to float first;compilation failed; no code produced;
+  doubles = (doubles % doubles); // expected-error {{modulo cannot be used with doubles, cast to float first}} fxc-error {{X3684: modulo cannot be used with doubles, cast to float first}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-56): error X3684: modulo cannot be used with doubles, cast to float first;compilation failed; no code produced;
+  doubles = (doubles % min16floats); // expected-error {{modulo cannot be used with doubles, cast to float first}} fxc-error {{X3684: modulo cannot be used with doubles, cast to float first}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-56): error X3684: modulo cannot be used with doubles, cast to float first;compilation failed; no code produced;
+  doubles = (doubles % min10floats); // expected-error {{modulo cannot be used with doubles, cast to float first}} fxc-error {{X3684: modulo cannot be used with doubles, cast to float first}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-54): error X3684: modulo cannot be used with doubles, cast to float first;compilation failed; no code produced;
+  doubles = (doubles % min16ints); // expected-error {{modulo cannot be used with doubles, cast to float first}} fxc-error {{X3684: modulo cannot be used with doubles, cast to float first}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-54): error X3684: modulo cannot be used with doubles, cast to float first;compilation failed; no code produced;
+  doubles = (doubles % min12ints); // expected-error {{modulo cannot be used with doubles, cast to float first}} fxc-error {{X3684: modulo cannot be used with doubles, cast to float first}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-55): error X3684: modulo cannot be used with doubles, cast to float first;compilation failed; no code produced;
+  doubles = (doubles % min16uints); // expected-error {{modulo cannot be used with doubles, cast to float first}} fxc-error {{X3684: modulo cannot be used with doubles, cast to float first}}
+  _Static_assert(std::is_same<min16float, __decltype(min16floats % bools)>::value, "");    /* expected-warning {{min16float is promoted to half}} */
+  _Static_assert(std::is_same<min16float, __decltype(min16floats % ints)>::value, "");    /* expected-warning {{min16float is promoted to half}} */
+  _Static_assert(std::is_same<min16float, __decltype(min16floats % uints)>::value, "");    /* expected-warning {{min16float is promoted to half}} */
+  _Static_assert(std::is_same<half, __decltype(min16floats % halfs)>::value, "");
+  _Static_assert(std::is_same<float, __decltype(min16floats % floats)>::value, "");
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-56): error X3684: modulo cannot be used with doubles, cast to float first;compilation failed; no code produced;
+  min16floats = (min16floats % doubles); // expected-error {{modulo cannot be used with doubles, cast to float first}} expected-warning {{conversion from larger type 'double' to smaller type 'min16float', possible loss of data}} fxc-error {{X3684: modulo cannot be used with doubles, cast to float first}} fxc-warning {{X3205: conversion from larger type to smaller, possible loss of data}}
+  _Static_assert(std::is_same<min16float, __decltype(min16floats % min16floats)>::value, "");    /* expected-warning {{min16float is promoted to half}} */
+  _Static_assert(std::is_same<min16float, __decltype(min16floats % min10floats)>::value, "");    /* expected-warning {{min16float is promoted to half}} */
+  _Static_assert(std::is_same<min16float, __decltype(min16floats % min16ints)>::value, "");    /* expected-warning {{min16float is promoted to half}} */
+  _Static_assert(std::is_same<min16float, __decltype(min16floats % min12ints)>::value, "");    /* expected-warning {{min16float is promoted to half}} */
+  _Static_assert(std::is_same<min16float, __decltype(min16floats % min16uints)>::value, "");    /* expected-warning {{min16float is promoted to half}} */
+  _Static_assert(std::is_same<min10float, __decltype(min10floats % bools)>::value, "");  // expected-warning {{min10float is promoted to half}}
+  _Static_assert(std::is_same<min10float, __decltype(min10floats % ints)>::value, "");  // expected-warning {{min10float is promoted to half}}
+  _Static_assert(std::is_same<min10float, __decltype(min10floats % uints)>::value, "");  // expected-warning {{min10float is promoted to half}}
+  _Static_assert(std::is_same<half, __decltype(min10floats % halfs)>::value, "");
+  _Static_assert(std::is_same<float, __decltype(min10floats % floats)>::value, "");
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-56): error X3684: modulo cannot be used with doubles, cast to float first;compilation failed; no code produced;
+  min10floats = (min10floats % doubles); // expected-error {{modulo cannot be used with doubles, cast to float first}} expected-warning {{conversion from larger type 'double' to smaller type 'min10float', possible loss of data}} fxc-error {{X3684: modulo cannot be used with doubles, cast to float first}} fxc-warning {{X3205: conversion from larger type to smaller, possible loss of data}}
+  _Static_assert(std::is_same<min16float, __decltype(min10floats % min16floats)>::value, "");    /* expected-warning {{min16float is promoted to half}} */
+  _Static_assert(std::is_same<min10float, __decltype(min10floats % min10floats)>::value, "");  // expected-warning {{min10float is promoted to half}}
+  _Static_assert(std::is_same<min10float, __decltype(min10floats % min16ints)>::value, "");  // expected-warning {{min10float is promoted to half}}
+  _Static_assert(std::is_same<min10float, __decltype(min10floats % min12ints)>::value, "");  // expected-warning {{min10float is promoted to half}}
+  _Static_assert(std::is_same<min10float, __decltype(min10floats % min16uints)>::value, "");  // expected-warning {{min10float is promoted to half}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-52): error X3706: signed integer remainder is not supported on minimum-precision types. Cast to int to use 32-bit division.;compilation failed; no code produced;
+  min16ints = (min16ints % bools); // expected-error {{signed integer division is not supported on minimum-precision types, cast to int to use 32-bit division}} fxc-error {{X3706: signed integer remainder is not supported on minimum-precision types. Cast to int to use 32-bit division.}}
+  _Static_assert(std::is_same<int, __decltype(min16ints % ints)>::value, "");
+  _Static_assert(std::is_same<uint, __decltype(min16ints % uints)>::value, "");
+  _Static_assert(std::is_same<half, __decltype(min16ints % halfs)>::value, "");
+  _Static_assert(std::is_same<float, __decltype(min16ints % floats)>::value, "");
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-54): error X3684: modulo cannot be used with doubles, cast to float first;compilation failed; no code produced;
+  min16ints = (min16ints % doubles); // expected-error {{modulo cannot be used with doubles, cast to float first}} expected-warning {{conversion from larger type 'double' to smaller type 'min16int', possible loss of data}} fxc-error {{X3684: modulo cannot be used with doubles, cast to float first}} fxc-warning {{X3205: conversion from larger type to smaller, possible loss of data}}
+  _Static_assert(std::is_same<min16float, __decltype(min16ints % min16floats)>::value, "");    /* expected-warning {{min16float is promoted to half}} */
+  _Static_assert(std::is_same<min10float, __decltype(min16ints % min10floats)>::value, "");  // expected-warning {{min10float is promoted to half}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-56): error X3706: signed integer remainder is not supported on minimum-precision types. Cast to int to use 32-bit division.;compilation failed; no code produced;
+  min16ints = (min16ints % min16ints); // expected-error {{signed integer division is not supported on minimum-precision types, cast to int to use 32-bit division}} fxc-error {{X3706: signed integer remainder is not supported on minimum-precision types. Cast to int to use 32-bit division.}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-56): error X3706: signed integer remainder is not supported on minimum-precision types. Cast to int to use 32-bit division.;compilation failed; no code produced;
+  min16ints = (min16ints % min12ints); // expected-error {{signed integer division is not supported on minimum-precision types, cast to int to use 32-bit division}} fxc-error {{X3706: signed integer remainder is not supported on minimum-precision types. Cast to int to use 32-bit division.}}
+  _Static_assert(std::is_same<min16uint, __decltype(min16ints % min16uints)>::value, "");
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-52): error X3706: signed integer remainder is not supported on minimum-precision types. Cast to int to use 32-bit division.;compilation failed; no code produced;
+  min16ints = (min12ints % bools); // expected-error {{signed integer division is not supported on minimum-precision types, cast to int to use 32-bit division}} fxc-error {{X3706: signed integer remainder is not supported on minimum-precision types. Cast to int to use 32-bit division.}}
+  _Static_assert(std::is_same<int, __decltype(min12ints % ints)>::value, "");
+  _Static_assert(std::is_same<uint, __decltype(min12ints % uints)>::value, "");
+  _Static_assert(std::is_same<half, __decltype(min12ints % halfs)>::value, "");
+  _Static_assert(std::is_same<float, __decltype(min12ints % floats)>::value, "");
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-54): error X3684: modulo cannot be used with doubles, cast to float first;compilation failed; no code produced;
+  min16ints = (min12ints % doubles); // expected-error {{modulo cannot be used with doubles, cast to float first}} expected-warning {{conversion from larger type 'double' to smaller type 'min16int', possible loss of data}} fxc-error {{X3684: modulo cannot be used with doubles, cast to float first}} fxc-warning {{X3205: conversion from larger type to smaller, possible loss of data}}
+  _Static_assert(std::is_same<min16float, __decltype(min12ints % min16floats)>::value, "");    /* expected-warning {{min16float is promoted to half}} */
+  _Static_assert(std::is_same<min10float, __decltype(min12ints % min10floats)>::value, "");  // expected-warning {{min10float is promoted to half}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-56): error X3706: signed integer remainder is not supported on minimum-precision types. Cast to int to use 32-bit division.;compilation failed; no code produced;
+  min16ints = (min12ints % min16ints); // expected-error {{signed integer division is not supported on minimum-precision types, cast to int to use 32-bit division}} fxc-error {{X3706: signed integer remainder is not supported on minimum-precision types. Cast to int to use 32-bit division.}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-56): error X3706: signed integer remainder is not supported on minimum-precision types. Cast to int to use 32-bit division.;compilation failed; no code produced;
+  min16ints = (min12ints % min12ints); // expected-error {{signed integer division is not supported on minimum-precision types, cast to int to use 32-bit division}} fxc-error {{X3706: signed integer remainder is not supported on minimum-precision types. Cast to int to use 32-bit division.}}
+  _Static_assert(std::is_same<min16uint, __decltype(min12ints % min16uints)>::value, "");
+  _Static_assert(std::is_same<min16uint, __decltype(min16uints % bools)>::value, "");
+  _Static_assert(std::is_same<uint, __decltype(min16uints % ints)>::value, "");
+  _Static_assert(std::is_same<uint, __decltype(min16uints % uints)>::value, "");
+  _Static_assert(std::is_same<half, __decltype(min16uints % halfs)>::value, "");
+  _Static_assert(std::is_same<float, __decltype(min16uints % floats)>::value, "");
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-55): error X3684: modulo cannot be used with doubles, cast to float first;compilation failed; no code produced;
+  min16ints = (min16uints % doubles); // expected-error {{modulo cannot be used with doubles, cast to float first}} expected-warning {{conversion from larger type 'double' to smaller type 'min16int', possible loss of data}} fxc-error {{X3684: modulo cannot be used with doubles, cast to float first}} fxc-warning {{X3205: conversion from larger type to smaller, possible loss of data}}
+  _Static_assert(std::is_same<min16float, __decltype(min16uints % min16floats)>::value, "");    /* expected-warning {{min16float is promoted to half}} */
+  _Static_assert(std::is_same<min10float, __decltype(min16uints % min10floats)>::value, "");  // expected-warning {{min10float is promoted to half}}
+  _Static_assert(std::is_same<min16uint, __decltype(min16uints % min16ints)>::value, "");
+  _Static_assert(std::is_same<min16uint, __decltype(min16uints % min12ints)>::value, "");
+  _Static_assert(std::is_same<min16uint, __decltype(min16uints % min16uints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(bools < bools)>::value, "bool, __decltype(bools < bools) failed");
+  _Static_assert(std::is_same<bool, __decltype(bools < ints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(bools < uints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(bools < halfs)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(bools < floats)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(bools < doubles)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(bools < min16floats)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(bools < min10floats)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(bools < min16ints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(bools < min12ints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(bools < min16uints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(ints < bools)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(ints < ints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(ints < uints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(ints < halfs)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(ints < floats)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(ints < doubles)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(ints < min16floats)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(ints < min10floats)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(ints < min16ints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(ints < min12ints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(ints < min16uints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(uints < bools)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(uints < ints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(uints < uints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(uints < halfs)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(uints < floats)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(uints < doubles)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(uints < min16floats)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(uints < min10floats)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(uints < min16ints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(uints < min12ints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(uints < min16uints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(halfs < bools)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(halfs < ints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(halfs < uints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(halfs < halfs)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(halfs < floats)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(halfs < doubles)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(halfs < min16floats)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(halfs < min10floats)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(halfs < min16ints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(halfs < min12ints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(halfs < min16uints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(floats < bools)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(floats < ints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(floats < uints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(floats < halfs)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(floats < floats)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(floats < doubles)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(floats < min16floats)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(floats < min10floats)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(floats < min16ints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(floats < min12ints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(floats < min16uints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(doubles < bools)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(doubles < ints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(doubles < uints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(doubles < halfs)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(doubles < floats)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(doubles < doubles)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(doubles < min16floats)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(doubles < min10floats)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(doubles < min16ints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(doubles < min12ints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(doubles < min16uints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min16floats < bools)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min16floats < ints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min16floats < uints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min16floats < halfs)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min16floats < floats)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min16floats < doubles)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min16floats < min16floats)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min16floats < min10floats)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min16floats < min16ints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min16floats < min12ints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min16floats < min16uints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min10floats < bools)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min10floats < ints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min10floats < uints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min10floats < halfs)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min10floats < floats)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min10floats < doubles)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min10floats < min16floats)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min10floats < min10floats)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min10floats < min16ints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min10floats < min12ints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min10floats < min16uints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min16ints < bools)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min16ints < ints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min16ints < uints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min16ints < halfs)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min16ints < floats)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min16ints < doubles)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min16ints < min16floats)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min16ints < min10floats)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min16ints < min16ints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min16ints < min12ints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min16ints < min16uints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min12ints < bools)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min12ints < ints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min12ints < uints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min12ints < halfs)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min12ints < floats)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min12ints < doubles)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min12ints < min16floats)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min12ints < min10floats)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min12ints < min16ints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min12ints < min12ints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min12ints < min16uints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min16uints < bools)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min16uints < ints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min16uints < uints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min16uints < halfs)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min16uints < floats)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min16uints < doubles)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min16uints < min16floats)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min16uints < min10floats)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min16uints < min16ints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min16uints < min12ints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min16uints < min16uints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(bools <= bools)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(bools <= ints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(bools <= uints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(bools <= halfs)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(bools <= floats)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(bools <= doubles)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(bools <= min16floats)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(bools <= min10floats)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(bools <= min16ints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(bools <= min12ints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(bools <= min16uints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(ints <= bools)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(ints <= ints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(ints <= uints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(ints <= halfs)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(ints <= floats)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(ints <= doubles)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(ints <= min16floats)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(ints <= min10floats)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(ints <= min16ints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(ints <= min12ints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(ints <= min16uints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(uints <= bools)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(uints <= ints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(uints <= uints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(uints <= halfs)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(uints <= floats)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(uints <= doubles)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(uints <= min16floats)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(uints <= min10floats)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(uints <= min16ints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(uints <= min12ints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(uints <= min16uints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(halfs <= bools)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(halfs <= ints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(halfs <= uints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(halfs <= halfs)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(halfs <= floats)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(halfs <= doubles)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(halfs <= min16floats)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(halfs <= min10floats)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(halfs <= min16ints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(halfs <= min12ints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(halfs <= min16uints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(floats <= bools)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(floats <= ints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(floats <= uints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(floats <= halfs)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(floats <= floats)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(floats <= doubles)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(floats <= min16floats)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(floats <= min10floats)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(floats <= min16ints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(floats <= min12ints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(floats <= min16uints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(doubles <= bools)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(doubles <= ints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(doubles <= uints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(doubles <= halfs)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(doubles <= floats)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(doubles <= doubles)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(doubles <= min16floats)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(doubles <= min10floats)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(doubles <= min16ints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(doubles <= min12ints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(doubles <= min16uints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min16floats <= bools)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min16floats <= ints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min16floats <= uints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min16floats <= halfs)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min16floats <= floats)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min16floats <= doubles)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min16floats <= min16floats)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min16floats <= min10floats)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min16floats <= min16ints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min16floats <= min12ints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min16floats <= min16uints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min10floats <= bools)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min10floats <= ints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min10floats <= uints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min10floats <= halfs)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min10floats <= floats)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min10floats <= doubles)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min10floats <= min16floats)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min10floats <= min10floats)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min10floats <= min16ints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min10floats <= min12ints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min10floats <= min16uints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min16ints <= bools)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min16ints <= ints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min16ints <= uints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min16ints <= halfs)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min16ints <= floats)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min16ints <= doubles)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min16ints <= min16floats)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min16ints <= min10floats)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min16ints <= min16ints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min16ints <= min12ints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min16ints <= min16uints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min12ints <= bools)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min12ints <= ints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min12ints <= uints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min12ints <= halfs)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min12ints <= floats)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min12ints <= doubles)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min12ints <= min16floats)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min12ints <= min10floats)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min12ints <= min16ints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min12ints <= min12ints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min12ints <= min16uints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min16uints <= bools)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min16uints <= ints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min16uints <= uints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min16uints <= halfs)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min16uints <= floats)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min16uints <= doubles)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min16uints <= min16floats)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min16uints <= min10floats)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min16uints <= min16ints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min16uints <= min12ints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min16uints <= min16uints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(bools > bools)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(bools > ints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(bools > uints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(bools > halfs)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(bools > floats)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(bools > doubles)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(bools > min16floats)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(bools > min10floats)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(bools > min16ints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(bools > min12ints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(bools > min16uints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(ints > bools)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(ints > ints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(ints > uints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(ints > halfs)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(ints > floats)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(ints > doubles)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(ints > min16floats)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(ints > min10floats)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(ints > min16ints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(ints > min12ints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(ints > min16uints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(uints > bools)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(uints > ints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(uints > uints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(uints > halfs)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(uints > floats)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(uints > doubles)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(uints > min16floats)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(uints > min10floats)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(uints > min16ints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(uints > min12ints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(uints > min16uints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(halfs > bools)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(halfs > ints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(halfs > uints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(halfs > halfs)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(halfs > floats)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(halfs > doubles)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(halfs > min16floats)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(halfs > min10floats)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(halfs > min16ints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(halfs > min12ints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(halfs > min16uints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(floats > bools)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(floats > ints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(floats > uints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(floats > halfs)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(floats > floats)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(floats > doubles)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(floats > min16floats)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(floats > min10floats)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(floats > min16ints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(floats > min12ints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(floats > min16uints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(doubles > bools)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(doubles > ints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(doubles > uints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(doubles > halfs)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(doubles > floats)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(doubles > doubles)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(doubles > min16floats)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(doubles > min10floats)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(doubles > min16ints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(doubles > min12ints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(doubles > min16uints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min16floats > bools)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min16floats > ints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min16floats > uints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min16floats > halfs)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min16floats > floats)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min16floats > doubles)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min16floats > min16floats)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min16floats > min10floats)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min16floats > min16ints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min16floats > min12ints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min16floats > min16uints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min10floats > bools)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min10floats > ints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min10floats > uints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min10floats > halfs)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min10floats > floats)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min10floats > doubles)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min10floats > min16floats)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min10floats > min10floats)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min10floats > min16ints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min10floats > min12ints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min10floats > min16uints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min16ints > bools)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min16ints > ints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min16ints > uints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min16ints > halfs)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min16ints > floats)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min16ints > doubles)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min16ints > min16floats)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min16ints > min10floats)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min16ints > min16ints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min16ints > min12ints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min16ints > min16uints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min12ints > bools)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min12ints > ints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min12ints > uints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min12ints > halfs)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min12ints > floats)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min12ints > doubles)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min12ints > min16floats)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min12ints > min10floats)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min12ints > min16ints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min12ints > min12ints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min12ints > min16uints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min16uints > bools)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min16uints > ints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min16uints > uints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min16uints > halfs)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min16uints > floats)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min16uints > doubles)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min16uints > min16floats)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min16uints > min10floats)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min16uints > min16ints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min16uints > min12ints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min16uints > min16uints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(bools >= bools)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(bools >= ints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(bools >= uints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(bools >= halfs)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(bools >= floats)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(bools >= doubles)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(bools >= min16floats)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(bools >= min10floats)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(bools >= min16ints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(bools >= min12ints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(bools >= min16uints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(ints >= bools)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(ints >= ints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(ints >= uints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(ints >= halfs)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(ints >= floats)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(ints >= doubles)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(ints >= min16floats)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(ints >= min10floats)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(ints >= min16ints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(ints >= min12ints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(ints >= min16uints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(uints >= bools)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(uints >= ints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(uints >= uints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(uints >= halfs)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(uints >= floats)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(uints >= doubles)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(uints >= min16floats)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(uints >= min10floats)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(uints >= min16ints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(uints >= min12ints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(uints >= min16uints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(halfs >= bools)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(halfs >= ints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(halfs >= uints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(halfs >= halfs)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(halfs >= floats)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(halfs >= doubles)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(halfs >= min16floats)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(halfs >= min10floats)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(halfs >= min16ints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(halfs >= min12ints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(halfs >= min16uints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(floats >= bools)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(floats >= ints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(floats >= uints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(floats >= halfs)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(floats >= floats)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(floats >= doubles)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(floats >= min16floats)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(floats >= min10floats)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(floats >= min16ints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(floats >= min12ints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(floats >= min16uints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(doubles >= bools)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(doubles >= ints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(doubles >= uints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(doubles >= halfs)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(doubles >= floats)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(doubles >= doubles)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(doubles >= min16floats)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(doubles >= min10floats)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(doubles >= min16ints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(doubles >= min12ints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(doubles >= min16uints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min16floats >= bools)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min16floats >= ints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min16floats >= uints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min16floats >= halfs)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min16floats >= floats)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min16floats >= doubles)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min16floats >= min16floats)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min16floats >= min10floats)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min16floats >= min16ints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min16floats >= min12ints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min16floats >= min16uints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min10floats >= bools)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min10floats >= ints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min10floats >= uints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min10floats >= halfs)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min10floats >= floats)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min10floats >= doubles)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min10floats >= min16floats)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min10floats >= min10floats)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min10floats >= min16ints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min10floats >= min12ints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min10floats >= min16uints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min16ints >= bools)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min16ints >= ints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min16ints >= uints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min16ints >= halfs)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min16ints >= floats)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min16ints >= doubles)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min16ints >= min16floats)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min16ints >= min10floats)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min16ints >= min16ints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min16ints >= min12ints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min16ints >= min16uints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min12ints >= bools)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min12ints >= ints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min12ints >= uints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min12ints >= halfs)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min12ints >= floats)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min12ints >= doubles)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min12ints >= min16floats)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min12ints >= min10floats)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min12ints >= min16ints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min12ints >= min12ints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min12ints >= min16uints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min16uints >= bools)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min16uints >= ints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min16uints >= uints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min16uints >= halfs)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min16uints >= floats)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min16uints >= doubles)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min16uints >= min16floats)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min16uints >= min10floats)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min16uints >= min16ints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min16uints >= min12ints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min16uints >= min16uints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(bools == bools)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(bools == ints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(bools == uints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(bools == halfs)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(bools == floats)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(bools == doubles)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(bools == min16floats)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(bools == min10floats)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(bools == min16ints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(bools == min12ints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(bools == min16uints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(ints == bools)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(ints == ints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(ints == uints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(ints == halfs)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(ints == floats)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(ints == doubles)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(ints == min16floats)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(ints == min10floats)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(ints == min16ints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(ints == min12ints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(ints == min16uints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(uints == bools)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(uints == ints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(uints == uints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(uints == halfs)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(uints == floats)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(uints == doubles)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(uints == min16floats)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(uints == min10floats)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(uints == min16ints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(uints == min12ints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(uints == min16uints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(halfs == bools)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(halfs == ints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(halfs == uints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(halfs == halfs)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(halfs == floats)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(halfs == doubles)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(halfs == min16floats)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(halfs == min10floats)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(halfs == min16ints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(halfs == min12ints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(halfs == min16uints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(floats == bools)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(floats == ints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(floats == uints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(floats == halfs)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(floats == floats)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(floats == doubles)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(floats == min16floats)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(floats == min10floats)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(floats == min16ints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(floats == min12ints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(floats == min16uints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(doubles == bools)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(doubles == ints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(doubles == uints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(doubles == halfs)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(doubles == floats)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(doubles == doubles)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(doubles == min16floats)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(doubles == min10floats)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(doubles == min16ints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(doubles == min12ints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(doubles == min16uints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min16floats == bools)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min16floats == ints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min16floats == uints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min16floats == halfs)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min16floats == floats)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min16floats == doubles)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min16floats == min16floats)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min16floats == min10floats)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min16floats == min16ints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min16floats == min12ints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min16floats == min16uints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min10floats == bools)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min10floats == ints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min10floats == uints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min10floats == halfs)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min10floats == floats)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min10floats == doubles)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min10floats == min16floats)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min10floats == min10floats)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min10floats == min16ints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min10floats == min12ints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min10floats == min16uints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min16ints == bools)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min16ints == ints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min16ints == uints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min16ints == halfs)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min16ints == floats)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min16ints == doubles)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min16ints == min16floats)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min16ints == min10floats)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min16ints == min16ints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min16ints == min12ints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min16ints == min16uints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min12ints == bools)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min12ints == ints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min12ints == uints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min12ints == halfs)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min12ints == floats)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min12ints == doubles)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min12ints == min16floats)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min12ints == min10floats)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min12ints == min16ints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min12ints == min12ints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min12ints == min16uints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min16uints == bools)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min16uints == ints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min16uints == uints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min16uints == halfs)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min16uints == floats)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min16uints == doubles)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min16uints == min16floats)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min16uints == min10floats)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min16uints == min16ints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min16uints == min12ints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min16uints == min16uints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(bools != bools)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(bools != ints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(bools != uints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(bools != halfs)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(bools != floats)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(bools != doubles)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(bools != min16floats)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(bools != min10floats)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(bools != min16ints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(bools != min12ints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(bools != min16uints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(ints != bools)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(ints != ints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(ints != uints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(ints != halfs)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(ints != floats)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(ints != doubles)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(ints != min16floats)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(ints != min10floats)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(ints != min16ints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(ints != min12ints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(ints != min16uints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(uints != bools)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(uints != ints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(uints != uints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(uints != halfs)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(uints != floats)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(uints != doubles)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(uints != min16floats)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(uints != min10floats)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(uints != min16ints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(uints != min12ints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(uints != min16uints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(halfs != bools)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(halfs != ints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(halfs != uints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(halfs != halfs)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(halfs != floats)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(halfs != doubles)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(halfs != min16floats)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(halfs != min10floats)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(halfs != min16ints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(halfs != min12ints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(halfs != min16uints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(floats != bools)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(floats != ints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(floats != uints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(floats != halfs)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(floats != floats)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(floats != doubles)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(floats != min16floats)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(floats != min10floats)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(floats != min16ints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(floats != min12ints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(floats != min16uints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(doubles != bools)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(doubles != ints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(doubles != uints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(doubles != halfs)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(doubles != floats)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(doubles != doubles)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(doubles != min16floats)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(doubles != min10floats)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(doubles != min16ints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(doubles != min12ints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(doubles != min16uints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min16floats != bools)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min16floats != ints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min16floats != uints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min16floats != halfs)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min16floats != floats)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min16floats != doubles)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min16floats != min16floats)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min16floats != min10floats)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min16floats != min16ints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min16floats != min12ints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min16floats != min16uints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min10floats != bools)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min10floats != ints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min10floats != uints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min10floats != halfs)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min10floats != floats)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min10floats != doubles)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min10floats != min16floats)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min10floats != min10floats)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min10floats != min16ints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min10floats != min12ints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min10floats != min16uints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min16ints != bools)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min16ints != ints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min16ints != uints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min16ints != halfs)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min16ints != floats)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min16ints != doubles)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min16ints != min16floats)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min16ints != min10floats)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min16ints != min16ints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min16ints != min12ints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min16ints != min16uints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min12ints != bools)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min12ints != ints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min12ints != uints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min12ints != halfs)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min12ints != floats)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min12ints != doubles)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min12ints != min16floats)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min12ints != min10floats)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min12ints != min16ints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min12ints != min12ints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min12ints != min16uints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min16uints != bools)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min16uints != ints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min16uints != uints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min16uints != halfs)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min16uints != floats)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min16uints != doubles)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min16uints != min16floats)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min16uints != min10floats)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min16uints != min16ints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min16uints != min12ints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min16uints != min16uints)>::value, "");
+  _Static_assert(std::is_same<int, __decltype(bools << bools)>::value, "");
+  _Static_assert(std::is_same<int, __decltype(bools << ints)>::value, "");
+  _Static_assert(std::is_same<int, __decltype(bools << uints)>::value, "");
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-49): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-50): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  bools = (bools << halfs); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-50): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-51): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  bools = (bools << floats); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-51): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-52): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  bools = (bools << doubles); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-55): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-56): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  bools = (bools << min16floats); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-55): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-56): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  bools = (bools << min10floats); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  _Static_assert(std::is_same<int, __decltype(bools << min16ints)>::value, "");
+  _Static_assert(std::is_same<int, __decltype(bools << min12ints)>::value, "");
+  _Static_assert(std::is_same<int, __decltype(bools << min16uints)>::value, "");
+  _Static_assert(std::is_same<int, __decltype(ints << bools)>::value, "");
+  _Static_assert(std::is_same<int, __decltype(ints << ints)>::value, "");
+  _Static_assert(std::is_same<int, __decltype(ints << uints)>::value, "");
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-48): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-49): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  ints = (ints << halfs); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-49): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-50): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  ints = (ints << floats); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-50): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-51): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  ints = (ints << doubles); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-54): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-55): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  ints = (ints << min16floats); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-54): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-55): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  ints = (ints << min10floats); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  _Static_assert(std::is_same<int, __decltype(ints << min16ints)>::value, "");
+  _Static_assert(std::is_same<int, __decltype(ints << min12ints)>::value, "");
+  _Static_assert(std::is_same<int, __decltype(ints << min16uints)>::value, "");
+  _Static_assert(std::is_same<uint, __decltype(uints << bools)>::value, "");
+  _Static_assert(std::is_same<uint, __decltype(uints << ints)>::value, "");
+  _Static_assert(std::is_same<uint, __decltype(uints << uints)>::value, "");
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-49): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-50): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  uints = (uints << halfs); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-50): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-51): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  uints = (uints << floats); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-51): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-52): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  uints = (uints << doubles); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-55): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-56): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  uints = (uints << min16floats); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-55): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-56): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  uints = (uints << min10floats); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  _Static_assert(std::is_same<uint, __decltype(uints << min16ints)>::value, "");
+  _Static_assert(std::is_same<uint, __decltype(uints << min12ints)>::value, "");
+  _Static_assert(std::is_same<uint, __decltype(uints << min16uints)>::value, "");
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-49): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-50): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  halfs = (halfs << bools); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-48): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-49): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  halfs = (halfs << ints); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-49): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-50): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  halfs = (halfs << uints); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-49): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-50): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  halfs = (halfs << halfs); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-50): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-51): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  halfs = (halfs << floats); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-51): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-52): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  halfs = (halfs << doubles); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-55): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-56): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  halfs = (halfs << min16floats); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-55): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-56): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  halfs = (halfs << min10floats); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-53): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-54): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  halfs = (halfs << min16ints); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-53): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-54): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  halfs = (halfs << min12ints); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-54): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-55): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  halfs = (halfs << min16uints); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-50): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-51): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  floats = (floats << bools); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-49): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-50): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  floats = (floats << ints); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-50): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-51): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  floats = (floats << uints); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-50): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-51): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  floats = (floats << halfs); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-51): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-52): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  floats = (floats << floats); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-52): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-53): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  floats = (floats << doubles); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-56): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-57): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  floats = (floats << min16floats); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-56): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-57): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  floats = (floats << min10floats); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-54): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-55): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  floats = (floats << min16ints); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-54): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-55): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  floats = (floats << min12ints); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-55): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-56): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  floats = (floats << min16uints); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-51): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-52): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  doubles = (doubles << bools); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-50): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-51): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  doubles = (doubles << ints); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-51): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-52): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  doubles = (doubles << uints); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-51): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-52): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  doubles = (doubles << halfs); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-52): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-53): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  doubles = (doubles << floats); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-53): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-54): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  doubles = (doubles << doubles); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-57): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-58): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  doubles = (doubles << min16floats); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-57): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-58): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  doubles = (doubles << min10floats); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-55): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-56): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  doubles = (doubles << min16ints); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-55): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-56): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  doubles = (doubles << min12ints); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-56): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-57): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  doubles = (doubles << min16uints); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-55): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-56): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  min16floats = (min16floats << bools); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-54): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-55): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  min16floats = (min16floats << ints); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-55): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-56): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  min16floats = (min16floats << uints); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-55): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-56): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  min16floats = (min16floats << halfs); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-56): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-57): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  min16floats = (min16floats << floats); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-57): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-58): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  min16floats = (min16floats << doubles); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-61): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-62): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  min16floats = (min16floats << min16floats); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-61): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-62): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  min16floats = (min16floats << min10floats); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-59): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-60): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  min16floats = (min16floats << min16ints); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-59): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-60): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  min16floats = (min16floats << min12ints); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-60): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-61): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  min16floats = (min16floats << min16uints); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-55): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-56): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  min10floats = (min10floats << bools); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-54): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-55): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  min10floats = (min10floats << ints); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-55): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-56): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  min10floats = (min10floats << uints); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-55): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-56): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  min10floats = (min10floats << halfs); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-56): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-57): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  min10floats = (min10floats << floats); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-57): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-58): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  min10floats = (min10floats << doubles); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-61): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-62): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  min10floats = (min10floats << min16floats); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-61): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-62): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  min10floats = (min10floats << min10floats); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-59): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-60): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  min10floats = (min10floats << min16ints); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-59): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-60): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  min10floats = (min10floats << min12ints); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-60): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-61): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  min10floats = (min10floats << min16uints); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  _Static_assert(std::is_same<min16int, __decltype(min16ints << bools)>::value, "");
+  _Static_assert(std::is_same<min16int, __decltype(min16ints << ints)>::value, "");
+  _Static_assert(std::is_same<min16int, __decltype(min16ints << uints)>::value, "");
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-53): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-54): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  min16ints = (min16ints << halfs); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-54): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-55): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  min16ints = (min16ints << floats); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-55): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-56): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  min16ints = (min16ints << doubles); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-59): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-60): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  min16ints = (min16ints << min16floats); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-59): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-60): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  min16ints = (min16ints << min10floats); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  _Static_assert(std::is_same<min16int, __decltype(min16ints << min16ints)>::value, "");
+  _Static_assert(std::is_same<min16int, __decltype(min16ints << min12ints)>::value, "");
+  _Static_assert(std::is_same<min16int, __decltype(min16ints << min16uints)>::value, "");
+  _Static_assert(std::is_same<min12int, __decltype(min12ints << bools)>::value, "");  // expected-warning {{min12int is promoted to min16int}}
+  _Static_assert(std::is_same<min12int, __decltype(min12ints << ints)>::value, "");  // expected-warning {{min12int is promoted to min16int}}
+  _Static_assert(std::is_same<min12int, __decltype(min12ints << uints)>::value, "");  // expected-warning {{min12int is promoted to min16int}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-53): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-54): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  min12ints = (min12ints << halfs); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-54): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-55): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  min12ints = (min12ints << floats); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-55): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-56): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  min12ints = (min12ints << doubles); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-59): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-60): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  min12ints = (min12ints << min16floats); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-59): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-60): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  min12ints = (min12ints << min10floats); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  _Static_assert(std::is_same<min12int, __decltype(min12ints << min16ints)>::value, "");  // expected-warning {{min12int is promoted to min16int}}
+  _Static_assert(std::is_same<min12int, __decltype(min12ints << min12ints)>::value, "");  // expected-warning {{min12int is promoted to min16int}}
+  _Static_assert(std::is_same<min12int, __decltype(min12ints << min16uints)>::value, "");  // expected-warning {{min12int is promoted to min16int}}
+  _Static_assert(std::is_same<min16uint, __decltype(min16uints << bools)>::value, "");
+  _Static_assert(std::is_same<min16uint, __decltype(min16uints << ints)>::value, "");
+  _Static_assert(std::is_same<min16uint, __decltype(min16uints << uints)>::value, "");
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-54): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-55): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  min16uints = (min16uints << halfs); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-55): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-56): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  min16uints = (min16uints << floats); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-56): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-57): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  min16uints = (min16uints << doubles); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-60): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-61): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  min16uints = (min16uints << min16floats); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-60): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-61): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  min16uints = (min16uints << min10floats); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  _Static_assert(std::is_same<min16uint, __decltype(min16uints << min16ints)>::value, "");
+  _Static_assert(std::is_same<min16uint, __decltype(min16uints << min12ints)>::value, "");
+  _Static_assert(std::is_same<min16uint, __decltype(min16uints << min16uints)>::value, "");
+  _Static_assert(std::is_same<int, __decltype(bools >> bools)>::value, "");
+  _Static_assert(std::is_same<int, __decltype(bools >> ints)>::value, "");
+  _Static_assert(std::is_same<int, __decltype(bools >> uints)>::value, "");
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-49): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-50): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  bools = (bools >> halfs); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-50): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-51): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  bools = (bools >> floats); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-51): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-52): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  bools = (bools >> doubles); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-55): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-56): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  bools = (bools >> min16floats); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-55): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-56): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  bools = (bools >> min10floats); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  _Static_assert(std::is_same<int, __decltype(bools >> min16ints)>::value, "");
+  _Static_assert(std::is_same<int, __decltype(bools >> min12ints)>::value, "");
+  _Static_assert(std::is_same<int, __decltype(bools >> min16uints)>::value, "");
+  _Static_assert(std::is_same<int, __decltype(ints >> bools)>::value, "");
+  _Static_assert(std::is_same<int, __decltype(ints >> ints)>::value, "");
+  _Static_assert(std::is_same<int, __decltype(ints >> uints)>::value, "");
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-48): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-49): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  ints = (ints >> halfs); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-49): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-50): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  ints = (ints >> floats); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-50): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-51): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  ints = (ints >> doubles); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-54): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-55): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  ints = (ints >> min16floats); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-54): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-55): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  ints = (ints >> min10floats); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  _Static_assert(std::is_same<int, __decltype(ints >> min16ints)>::value, "");
+  _Static_assert(std::is_same<int, __decltype(ints >> min12ints)>::value, "");
+  _Static_assert(std::is_same<int, __decltype(ints >> min16uints)>::value, "");
+  _Static_assert(std::is_same<uint, __decltype(uints >> bools)>::value, "");
+  _Static_assert(std::is_same<uint, __decltype(uints >> ints)>::value, "");
+  _Static_assert(std::is_same<uint, __decltype(uints >> uints)>::value, "");
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-49): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-50): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  uints = (uints >> halfs); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-50): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-51): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  uints = (uints >> floats); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-51): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-52): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  uints = (uints >> doubles); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-55): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-56): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  uints = (uints >> min16floats); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-55): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-56): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  uints = (uints >> min10floats); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  _Static_assert(std::is_same<uint, __decltype(uints >> min16ints)>::value, "");
+  _Static_assert(std::is_same<uint, __decltype(uints >> min12ints)>::value, "");
+  _Static_assert(std::is_same<uint, __decltype(uints >> min16uints)>::value, "");
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-49): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-50): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  halfs = (halfs >> bools); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-48): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-49): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  halfs = (halfs >> ints); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-49): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-50): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  halfs = (halfs >> uints); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-49): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-50): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  halfs = (halfs >> halfs); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-50): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-51): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  halfs = (halfs >> floats); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-51): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-52): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  halfs = (halfs >> doubles); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-55): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-56): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  halfs = (halfs >> min16floats); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-55): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-56): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  halfs = (halfs >> min10floats); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-53): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-54): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  halfs = (halfs >> min16ints); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-53): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-54): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  halfs = (halfs >> min12ints); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-54): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-55): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  halfs = (halfs >> min16uints); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-50): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-51): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  floats = (floats >> bools); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-49): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-50): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  floats = (floats >> ints); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-50): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-51): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  floats = (floats >> uints); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-50): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-51): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  floats = (floats >> halfs); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-51): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-52): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  floats = (floats >> floats); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-52): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-53): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  floats = (floats >> doubles); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-56): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-57): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  floats = (floats >> min16floats); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-56): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-57): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  floats = (floats >> min10floats); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-54): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-55): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  floats = (floats >> min16ints); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-54): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-55): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  floats = (floats >> min12ints); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-55): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-56): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  floats = (floats >> min16uints); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-51): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-52): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  doubles = (doubles >> bools); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-50): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-51): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  doubles = (doubles >> ints); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-51): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-52): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  doubles = (doubles >> uints); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-51): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-52): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  doubles = (doubles >> halfs); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-52): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-53): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  doubles = (doubles >> floats); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-53): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-54): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  doubles = (doubles >> doubles); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-57): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-58): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  doubles = (doubles >> min16floats); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-57): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-58): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  doubles = (doubles >> min10floats); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-55): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-56): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  doubles = (doubles >> min16ints); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-55): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-56): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  doubles = (doubles >> min12ints); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-56): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-57): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  doubles = (doubles >> min16uints); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-55): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-56): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  min16floats = (min16floats >> bools); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-54): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-55): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  min16floats = (min16floats >> ints); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-55): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-56): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  min16floats = (min16floats >> uints); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-55): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-56): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  min16floats = (min16floats >> halfs); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-56): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-57): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  min16floats = (min16floats >> floats); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-57): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-58): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  min16floats = (min16floats >> doubles); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-61): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-62): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  min16floats = (min16floats >> min16floats); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-61): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-62): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  min16floats = (min16floats >> min10floats); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-59): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-60): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  min16floats = (min16floats >> min16ints); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-59): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-60): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  min16floats = (min16floats >> min12ints); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-60): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-61): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  min16floats = (min16floats >> min16uints); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-55): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-56): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  min10floats = (min10floats >> bools); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-54): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-55): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  min10floats = (min10floats >> ints); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-55): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-56): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  min10floats = (min10floats >> uints); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-55): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-56): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  min10floats = (min10floats >> halfs); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-56): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-57): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  min10floats = (min10floats >> floats); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-57): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-58): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  min10floats = (min10floats >> doubles); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-61): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-62): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  min10floats = (min10floats >> min16floats); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-61): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-62): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  min10floats = (min10floats >> min10floats); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-59): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-60): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  min10floats = (min10floats >> min16ints); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-59): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-60): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  min10floats = (min10floats >> min12ints); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-60): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-61): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  min10floats = (min10floats >> min16uints); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  _Static_assert(std::is_same<min16int, __decltype(min16ints >> bools)>::value, "");
+  _Static_assert(std::is_same<min16int, __decltype(min16ints >> ints)>::value, "");
+  _Static_assert(std::is_same<min16int, __decltype(min16ints >> uints)>::value, "");
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-53): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-54): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  min16ints = (min16ints >> halfs); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-54): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-55): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  min16ints = (min16ints >> floats); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-55): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-56): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  min16ints = (min16ints >> doubles); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-59): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-60): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  min16ints = (min16ints >> min16floats); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-59): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-60): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  min16ints = (min16ints >> min10floats); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  _Static_assert(std::is_same<min16int, __decltype(min16ints >> min16ints)>::value, "");
+  _Static_assert(std::is_same<min16int, __decltype(min16ints >> min12ints)>::value, "");
+  _Static_assert(std::is_same<min16int, __decltype(min16ints >> min16uints)>::value, "");
+  _Static_assert(std::is_same<min12int, __decltype(min12ints >> bools)>::value, "");  // expected-warning {{min12int is promoted to min16int}}
+  _Static_assert(std::is_same<min12int, __decltype(min12ints >> ints)>::value, "");  // expected-warning {{min12int is promoted to min16int}}
+  _Static_assert(std::is_same<min12int, __decltype(min12ints >> uints)>::value, "");  // expected-warning {{min12int is promoted to min16int}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-53): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-54): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  min12ints = (min12ints >> halfs); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-54): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-55): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  min12ints = (min12ints >> floats); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-55): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-56): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  min12ints = (min12ints >> doubles); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-59): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-60): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  min12ints = (min12ints >> min16floats); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-59): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-60): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  min12ints = (min12ints >> min10floats); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  _Static_assert(std::is_same<min12int, __decltype(min12ints >> min16ints)>::value, "");  // expected-warning {{min12int is promoted to min16int}}
+  _Static_assert(std::is_same<min12int, __decltype(min12ints >> min12ints)>::value, "");  // expected-warning {{min12int is promoted to min16int}}
+  _Static_assert(std::is_same<min12int, __decltype(min12ints >> min16uints)>::value, "");  // expected-warning {{min12int is promoted to min16int}}
+  _Static_assert(std::is_same<min16uint, __decltype(min16uints >> bools)>::value, "");
+  _Static_assert(std::is_same<min16uint, __decltype(min16uints >> ints)>::value, "");
+  _Static_assert(std::is_same<min16uint, __decltype(min16uints >> uints)>::value, "");
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-54): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-55): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  min16uints = (min16uints >> halfs); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-55): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-56): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  min16uints = (min16uints >> floats); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-56): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-57): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  min16uints = (min16uints >> doubles); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-60): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-61): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  min16uints = (min16uints >> min16floats); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-60): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-61): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  min16uints = (min16uints >> min10floats); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  _Static_assert(std::is_same<min16uint, __decltype(min16uints >> min16ints)>::value, "");
+  _Static_assert(std::is_same<min16uint, __decltype(min16uints >> min12ints)>::value, "");
+  _Static_assert(std::is_same<min16uint, __decltype(min16uints >> min16uints)>::value, "");
+  _Static_assert(std::is_same<int, __decltype(bools & bools)>::value, "");
+  _Static_assert(std::is_same<int, __decltype(bools & ints)>::value, "");
+  _Static_assert(std::is_same<uint, __decltype(bools & uints)>::value, "");
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-48): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-49): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  bools = (bools & halfs); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-49): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-50): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  bools = (bools & floats); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-50): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-51): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  bools = (bools & doubles); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-54): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-55): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  bools = (bools & min16floats); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-54): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-55): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  bools = (bools & min10floats); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  _Static_assert(std::is_same<int, __decltype(bools & min16ints)>::value, "");
+  _Static_assert(std::is_same<int, __decltype(bools & min12ints)>::value, "");
+  _Static_assert(std::is_same<uint, __decltype(bools & min16uints)>::value, "");
+  _Static_assert(std::is_same<int, __decltype(ints & bools)>::value, "");
+  _Static_assert(std::is_same<int, __decltype(ints & ints)>::value, "");
+  _Static_assert(std::is_same<uint, __decltype(ints & uints)>::value, "");
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-47): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-48): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  ints = (ints & halfs); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-48): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-49): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  ints = (ints & floats); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-49): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-50): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  ints = (ints & doubles); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-53): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-54): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  ints = (ints & min16floats); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-53): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-54): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  ints = (ints & min10floats); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  _Static_assert(std::is_same<int, __decltype(ints & min16ints)>::value, "");
+  _Static_assert(std::is_same<int, __decltype(ints & min12ints)>::value, "");
+  _Static_assert(std::is_same<uint, __decltype(ints & min16uints)>::value, "");
+  _Static_assert(std::is_same<uint, __decltype(uints & bools)>::value, "");
+  _Static_assert(std::is_same<uint, __decltype(uints & ints)>::value, "");
+  _Static_assert(std::is_same<uint, __decltype(uints & uints)>::value, "");
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-48): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-49): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  uints = (uints & halfs); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-49): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-50): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  uints = (uints & floats); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-50): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-51): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  uints = (uints & doubles); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-54): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-55): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  uints = (uints & min16floats); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-54): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-55): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  uints = (uints & min10floats); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  _Static_assert(std::is_same<uint, __decltype(uints & min16ints)>::value, "");
+  _Static_assert(std::is_same<uint, __decltype(uints & min12ints)>::value, "");
+  _Static_assert(std::is_same<uint, __decltype(uints & min16uints)>::value, "");
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-48): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-49): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  halfs = (halfs & bools); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-47): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-48): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  halfs = (halfs & ints); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-48): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-49): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  halfs = (halfs & uints); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-48): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-49): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  halfs = (halfs & halfs); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-49): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-50): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  halfs = (halfs & floats); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-50): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-51): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  halfs = (halfs & doubles); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-54): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-55): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  halfs = (halfs & min16floats); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-54): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-55): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  halfs = (halfs & min10floats); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-52): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-53): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  halfs = (halfs & min16ints); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-52): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-53): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  halfs = (halfs & min12ints); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-53): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-54): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  halfs = (halfs & min16uints); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-49): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-50): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  floats = (floats & bools); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-48): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-49): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  floats = (floats & ints); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-49): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-50): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  floats = (floats & uints); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-49): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-50): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  floats = (floats & halfs); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-50): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-51): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  floats = (floats & floats); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-51): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-52): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  floats = (floats & doubles); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-55): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-56): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  floats = (floats & min16floats); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-55): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-56): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  floats = (floats & min10floats); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-53): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-54): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  floats = (floats & min16ints); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-53): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-54): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  floats = (floats & min12ints); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-54): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-55): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  floats = (floats & min16uints); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-50): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-51): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  doubles = (doubles & bools); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-49): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-50): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  doubles = (doubles & ints); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-50): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-51): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  doubles = (doubles & uints); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-50): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-51): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  doubles = (doubles & halfs); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-51): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-52): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  doubles = (doubles & floats); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-52): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-53): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  doubles = (doubles & doubles); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-56): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-57): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  doubles = (doubles & min16floats); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-56): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-57): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  doubles = (doubles & min10floats); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-54): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-55): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  doubles = (doubles & min16ints); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-54): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-55): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  doubles = (doubles & min12ints); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-55): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-56): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  doubles = (doubles & min16uints); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-54): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-55): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  min16floats = (min16floats & bools); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-53): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-54): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  min16floats = (min16floats & ints); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-54): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-55): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  min16floats = (min16floats & uints); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-54): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-55): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  min16floats = (min16floats & halfs); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-55): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-56): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  min16floats = (min16floats & floats); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-56): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-57): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  min16floats = (min16floats & doubles); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-60): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-61): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  min16floats = (min16floats & min16floats); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-60): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-61): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  min16floats = (min16floats & min10floats); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-58): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-59): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  min16floats = (min16floats & min16ints); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-58): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-59): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  min16floats = (min16floats & min12ints); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-59): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-60): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  min16floats = (min16floats & min16uints); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-54): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-55): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  min10floats = (min10floats & bools); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-53): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-54): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  min10floats = (min10floats & ints); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-54): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-55): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  min10floats = (min10floats & uints); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-54): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-55): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  min10floats = (min10floats & halfs); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-55): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-56): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  min10floats = (min10floats & floats); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-56): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-57): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  min10floats = (min10floats & doubles); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-60): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-61): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  min10floats = (min10floats & min16floats); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-60): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-61): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  min10floats = (min10floats & min10floats); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-58): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-59): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  min10floats = (min10floats & min16ints); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-58): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-59): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  min10floats = (min10floats & min12ints); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-59): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-60): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  min10floats = (min10floats & min16uints); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  _Static_assert(std::is_same<min16int, __decltype(min16ints & bools)>::value, "");
+  _Static_assert(std::is_same<int, __decltype(min16ints & ints)>::value, "");
+  _Static_assert(std::is_same<uint, __decltype(min16ints & uints)>::value, "");
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-52): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-53): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  min16ints = (min16ints & halfs); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-53): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-54): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  min16ints = (min16ints & floats); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-54): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-55): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  min16ints = (min16ints & doubles); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-58): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-59): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  min16ints = (min16ints & min16floats); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-58): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-59): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  min16ints = (min16ints & min10floats); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  _Static_assert(std::is_same<min16int, __decltype(min16ints & min16ints)>::value, "");
+  _Static_assert(std::is_same<min16int, __decltype(min16ints & min12ints)>::value, "");
+  _Static_assert(std::is_same<min16uint, __decltype(min16ints & min16uints)>::value, "");
+  _Static_assert(std::is_same<min12int, __decltype(min12ints & bools)>::value, "");  // expected-warning {{min12int is promoted to min16int}}
+  _Static_assert(std::is_same<int, __decltype(min12ints & ints)>::value, "");
+  _Static_assert(std::is_same<uint, __decltype(min12ints & uints)>::value, "");
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-52): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-53): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  min12ints = (min12ints & halfs); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-53): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-54): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  min12ints = (min12ints & floats); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-54): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-55): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  min12ints = (min12ints & doubles); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-58): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-59): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  min12ints = (min12ints & min16floats); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-58): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-59): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  min12ints = (min12ints & min10floats); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  _Static_assert(std::is_same<min16int, __decltype(min12ints & min16ints)>::value, "");
+  _Static_assert(std::is_same<min12int, __decltype(min12ints & min12ints)>::value, "");  // expected-warning {{min12int is promoted to min16int}}
+  _Static_assert(std::is_same<min16uint, __decltype(min12ints & min16uints)>::value, "");
+  _Static_assert(std::is_same<min16uint, __decltype(min16uints & bools)>::value, "");
+  _Static_assert(std::is_same<uint, __decltype(min16uints & ints)>::value, "");
+  _Static_assert(std::is_same<uint, __decltype(min16uints & uints)>::value, "");
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-53): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-54): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  min16uints = (min16uints & halfs); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-54): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-55): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  min16uints = (min16uints & floats); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-55): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-56): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  min16uints = (min16uints & doubles); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-59): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-60): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  min16uints = (min16uints & min16floats); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-59): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-60): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  min16uints = (min16uints & min10floats); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  _Static_assert(std::is_same<min16uint, __decltype(min16uints & min16ints)>::value, "");
+  _Static_assert(std::is_same<min16uint, __decltype(min16uints & min12ints)>::value, "");
+  _Static_assert(std::is_same<min16uint, __decltype(min16uints & min16uints)>::value, "");
+  _Static_assert(std::is_same<int, __decltype(bools | bools)>::value, "");
+  _Static_assert(std::is_same<int, __decltype(bools | ints)>::value, "");
+  _Static_assert(std::is_same<uint, __decltype(bools | uints)>::value, "");
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-48): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-49): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  bools = (bools | halfs); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-49): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-50): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  bools = (bools | floats); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-50): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-51): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  bools = (bools | doubles); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-54): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-55): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  bools = (bools | min16floats); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-54): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-55): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  bools = (bools | min10floats); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  _Static_assert(std::is_same<int, __decltype(bools | min16ints)>::value, "");
+  _Static_assert(std::is_same<int, __decltype(bools | min12ints)>::value, "");
+  _Static_assert(std::is_same<uint, __decltype(bools | min16uints)>::value, "");
+  _Static_assert(std::is_same<int, __decltype(ints | bools)>::value, "");
+  _Static_assert(std::is_same<int, __decltype(ints | ints)>::value, "");
+  _Static_assert(std::is_same<uint, __decltype(ints | uints)>::value, "");
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-47): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-48): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  ints = (ints | halfs); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-48): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-49): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  ints = (ints | floats); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-49): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-50): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  ints = (ints | doubles); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-53): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-54): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  ints = (ints | min16floats); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-53): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-54): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  ints = (ints | min10floats); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  _Static_assert(std::is_same<int, __decltype(ints | min16ints)>::value, "");
+  _Static_assert(std::is_same<int, __decltype(ints | min12ints)>::value, "");
+  _Static_assert(std::is_same<uint, __decltype(ints | min16uints)>::value, "");
+  _Static_assert(std::is_same<uint, __decltype(uints | bools)>::value, "");
+  _Static_assert(std::is_same<uint, __decltype(uints | ints)>::value, "");
+  _Static_assert(std::is_same<uint, __decltype(uints | uints)>::value, "");
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-48): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-49): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  uints = (uints | halfs); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-49): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-50): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  uints = (uints | floats); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-50): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-51): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  uints = (uints | doubles); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-54): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-55): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  uints = (uints | min16floats); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-54): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-55): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  uints = (uints | min10floats); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  _Static_assert(std::is_same<uint, __decltype(uints | min16ints)>::value, "");
+  _Static_assert(std::is_same<uint, __decltype(uints | min12ints)>::value, "");
+  _Static_assert(std::is_same<uint, __decltype(uints | min16uints)>::value, "");
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-48): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-49): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  halfs = (halfs | bools); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-47): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-48): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  halfs = (halfs | ints); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-48): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-49): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  halfs = (halfs | uints); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-48): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-49): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  halfs = (halfs | halfs); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-49): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-50): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  halfs = (halfs | floats); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-50): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-51): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  halfs = (halfs | doubles); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-54): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-55): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  halfs = (halfs | min16floats); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-54): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-55): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  halfs = (halfs | min10floats); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-52): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-53): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  halfs = (halfs | min16ints); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-52): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-53): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  halfs = (halfs | min12ints); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-53): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-54): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  halfs = (halfs | min16uints); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-49): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-50): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  floats = (floats | bools); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-48): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-49): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  floats = (floats | ints); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-49): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-50): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  floats = (floats | uints); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-49): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-50): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  floats = (floats | halfs); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-50): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-51): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  floats = (floats | floats); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-51): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-52): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  floats = (floats | doubles); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-55): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-56): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  floats = (floats | min16floats); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-55): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-56): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  floats = (floats | min10floats); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-53): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-54): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  floats = (floats | min16ints); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-53): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-54): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  floats = (floats | min12ints); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-54): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-55): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  floats = (floats | min16uints); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-50): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-51): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  doubles = (doubles | bools); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-49): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-50): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  doubles = (doubles | ints); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-50): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-51): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  doubles = (doubles | uints); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-50): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-51): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  doubles = (doubles | halfs); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-51): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-52): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  doubles = (doubles | floats); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-52): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-53): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  doubles = (doubles | doubles); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-56): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-57): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  doubles = (doubles | min16floats); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-56): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-57): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  doubles = (doubles | min10floats); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-54): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-55): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  doubles = (doubles | min16ints); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-54): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-55): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  doubles = (doubles | min12ints); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-55): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-56): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  doubles = (doubles | min16uints); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-54): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-55): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  min16floats = (min16floats | bools); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-53): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-54): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  min16floats = (min16floats | ints); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-54): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-55): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  min16floats = (min16floats | uints); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-54): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-55): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  min16floats = (min16floats | halfs); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-55): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-56): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  min16floats = (min16floats | floats); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-56): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-57): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  min16floats = (min16floats | doubles); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-60): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-61): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  min16floats = (min16floats | min16floats); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-60): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-61): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  min16floats = (min16floats | min10floats); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-58): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-59): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  min16floats = (min16floats | min16ints); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-58): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-59): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  min16floats = (min16floats | min12ints); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-59): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-60): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  min16floats = (min16floats | min16uints); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-54): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-55): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  min10floats = (min10floats | bools); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-53): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-54): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  min10floats = (min10floats | ints); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-54): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-55): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  min10floats = (min10floats | uints); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-54): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-55): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  min10floats = (min10floats | halfs); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-55): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-56): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  min10floats = (min10floats | floats); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-56): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-57): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  min10floats = (min10floats | doubles); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-60): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-61): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  min10floats = (min10floats | min16floats); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-60): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-61): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  min10floats = (min10floats | min10floats); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-58): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-59): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  min10floats = (min10floats | min16ints); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-58): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-59): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  min10floats = (min10floats | min12ints); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-59): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-60): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  min10floats = (min10floats | min16uints); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  _Static_assert(std::is_same<min16int, __decltype(min16ints | bools)>::value, "");
+  _Static_assert(std::is_same<int, __decltype(min16ints | ints)>::value, "");
+  _Static_assert(std::is_same<uint, __decltype(min16ints | uints)>::value, "");
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-52): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-53): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  min16ints = (min16ints | halfs); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-53): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-54): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  min16ints = (min16ints | floats); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-54): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-55): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  min16ints = (min16ints | doubles); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-58): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-59): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  min16ints = (min16ints | min16floats); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-58): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-59): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  min16ints = (min16ints | min10floats); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  _Static_assert(std::is_same<min16int, __decltype(min16ints | min16ints)>::value, "");
+  _Static_assert(std::is_same<min16int, __decltype(min16ints | min12ints)>::value, "");
+  _Static_assert(std::is_same<min16uint, __decltype(min16ints | min16uints)>::value, "");
+  _Static_assert(std::is_same<min12int, __decltype(min12ints | bools)>::value, "");  // expected-warning {{min12int is promoted to min16int}}
+  _Static_assert(std::is_same<int, __decltype(min12ints | ints)>::value, "");
+  _Static_assert(std::is_same<uint, __decltype(min12ints | uints)>::value, "");
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-52): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-53): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  min12ints = (min12ints | halfs); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-53): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-54): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  min12ints = (min12ints | floats); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-54): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-55): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  min12ints = (min12ints | doubles); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-58): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-59): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  min12ints = (min12ints | min16floats); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-58): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-59): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  min12ints = (min12ints | min10floats); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  _Static_assert(std::is_same<min16int, __decltype(min12ints | min16ints)>::value, "");
+  _Static_assert(std::is_same<min12int, __decltype(min12ints | min12ints)>::value, "");  // expected-warning {{min12int is promoted to min16int}}
+  _Static_assert(std::is_same<min16uint, __decltype(min12ints | min16uints)>::value, "");
+  _Static_assert(std::is_same<min16uint, __decltype(min16uints | bools)>::value, "");
+  _Static_assert(std::is_same<uint, __decltype(min16uints | ints)>::value, "");
+  _Static_assert(std::is_same<uint, __decltype(min16uints | uints)>::value, "");
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-53): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-54): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  min16uints = (min16uints | halfs); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-54): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-55): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  min16uints = (min16uints | floats); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-55): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-56): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  min16uints = (min16uints | doubles); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-59): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-60): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  min16uints = (min16uints | min16floats); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-59): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-60): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  min16uints = (min16uints | min10floats); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  _Static_assert(std::is_same<min16uint, __decltype(min16uints | min16ints)>::value, "");
+  _Static_assert(std::is_same<min16uint, __decltype(min16uints | min12ints)>::value, "");
+  _Static_assert(std::is_same<min16uint, __decltype(min16uints | min16uints)>::value, "");
+  _Static_assert(std::is_same<int, __decltype(bools ^ bools)>::value, "");
+  _Static_assert(std::is_same<int, __decltype(bools ^ ints)>::value, "");
+  _Static_assert(std::is_same<uint, __decltype(bools ^ uints)>::value, "");
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-48): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-49): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  bools = (bools ^ halfs); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-49): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-50): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  bools = (bools ^ floats); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-50): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-51): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  bools = (bools ^ doubles); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-54): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-55): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  bools = (bools ^ min16floats); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-54): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-55): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  bools = (bools ^ min10floats); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  _Static_assert(std::is_same<int, __decltype(bools ^ min16ints)>::value, "");
+  _Static_assert(std::is_same<int, __decltype(bools ^ min12ints)>::value, "");
+  _Static_assert(std::is_same<uint, __decltype(bools ^ min16uints)>::value, "");
+  _Static_assert(std::is_same<int, __decltype(ints ^ bools)>::value, "");
+  _Static_assert(std::is_same<int, __decltype(ints ^ ints)>::value, "");
+  _Static_assert(std::is_same<uint, __decltype(ints ^ uints)>::value, "");
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-47): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-48): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  ints = (ints ^ halfs); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-48): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-49): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  ints = (ints ^ floats); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-49): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-50): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  ints = (ints ^ doubles); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-53): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-54): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  ints = (ints ^ min16floats); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-53): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-54): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  ints = (ints ^ min10floats); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  _Static_assert(std::is_same<int, __decltype(ints ^ min16ints)>::value, "");
+  _Static_assert(std::is_same<int, __decltype(ints ^ min12ints)>::value, "");
+  _Static_assert(std::is_same<uint, __decltype(ints ^ min16uints)>::value, "");
+  _Static_assert(std::is_same<uint, __decltype(uints ^ bools)>::value, "");
+  _Static_assert(std::is_same<uint, __decltype(uints ^ ints)>::value, "");
+  _Static_assert(std::is_same<uint, __decltype(uints ^ uints)>::value, "");
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-48): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-49): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  uints = (uints ^ halfs); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-49): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-50): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  uints = (uints ^ floats); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-50): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-51): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  uints = (uints ^ doubles); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-54): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-55): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  uints = (uints ^ min16floats); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-54): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-55): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  uints = (uints ^ min10floats); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  _Static_assert(std::is_same<uint, __decltype(uints ^ min16ints)>::value, "");
+  _Static_assert(std::is_same<uint, __decltype(uints ^ min12ints)>::value, "");
+  _Static_assert(std::is_same<uint, __decltype(uints ^ min16uints)>::value, "");
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-48): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-49): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  halfs = (halfs ^ bools); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-47): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-48): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  halfs = (halfs ^ ints); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-48): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-49): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  halfs = (halfs ^ uints); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-48): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-49): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  halfs = (halfs ^ halfs); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-49): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-50): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  halfs = (halfs ^ floats); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-50): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-51): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  halfs = (halfs ^ doubles); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-54): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-55): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  halfs = (halfs ^ min16floats); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-54): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-55): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  halfs = (halfs ^ min10floats); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-52): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-53): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  halfs = (halfs ^ min16ints); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-52): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-53): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  halfs = (halfs ^ min12ints); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-53): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-54): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  halfs = (halfs ^ min16uints); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-49): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-50): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  floats = (floats ^ bools); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-48): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-49): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  floats = (floats ^ ints); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-49): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-50): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  floats = (floats ^ uints); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-49): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-50): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  floats = (floats ^ halfs); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-50): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-51): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  floats = (floats ^ floats); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-51): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-52): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  floats = (floats ^ doubles); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-55): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-56): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  floats = (floats ^ min16floats); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-55): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-56): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  floats = (floats ^ min10floats); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-53): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-54): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  floats = (floats ^ min16ints); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-53): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-54): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  floats = (floats ^ min12ints); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-54): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-55): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  floats = (floats ^ min16uints); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-50): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-51): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  doubles = (doubles ^ bools); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-49): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-50): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  doubles = (doubles ^ ints); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-50): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-51): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  doubles = (doubles ^ uints); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-50): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-51): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  doubles = (doubles ^ halfs); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-51): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-52): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  doubles = (doubles ^ floats); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-52): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-53): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  doubles = (doubles ^ doubles); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-56): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-57): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  doubles = (doubles ^ min16floats); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-56): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-57): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  doubles = (doubles ^ min10floats); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-54): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-55): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  doubles = (doubles ^ min16ints); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-54): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-55): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  doubles = (doubles ^ min12ints); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-55): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-56): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  doubles = (doubles ^ min16uints); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-54): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-55): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  min16floats = (min16floats ^ bools); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-53): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-54): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  min16floats = (min16floats ^ ints); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-54): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-55): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  min16floats = (min16floats ^ uints); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-54): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-55): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  min16floats = (min16floats ^ halfs); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-55): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-56): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  min16floats = (min16floats ^ floats); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-56): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-57): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  min16floats = (min16floats ^ doubles); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-60): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-61): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  min16floats = (min16floats ^ min16floats); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-60): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-61): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  min16floats = (min16floats ^ min10floats); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-58): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-59): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  min16floats = (min16floats ^ min16ints); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-58): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-59): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  min16floats = (min16floats ^ min12ints); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-59): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-60): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  min16floats = (min16floats ^ min16uints); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-54): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-55): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  min10floats = (min10floats ^ bools); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-53): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-54): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  min10floats = (min10floats ^ ints); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-54): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-55): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  min10floats = (min10floats ^ uints); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-54): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-55): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  min10floats = (min10floats ^ halfs); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-55): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-56): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  min10floats = (min10floats ^ floats); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-56): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-57): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  min10floats = (min10floats ^ doubles); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-60): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-61): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  min10floats = (min10floats ^ min16floats); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-60): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-61): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  min10floats = (min10floats ^ min10floats); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-58): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-59): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  min10floats = (min10floats ^ min16ints); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-58): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-59): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  min10floats = (min10floats ^ min12ints); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-59): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-60): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  min10floats = (min10floats ^ min16uints); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  _Static_assert(std::is_same<min16int, __decltype(min16ints ^ bools)>::value, "");
+  _Static_assert(std::is_same<int, __decltype(min16ints ^ ints)>::value, "");
+  _Static_assert(std::is_same<uint, __decltype(min16ints ^ uints)>::value, "");
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-52): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-53): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  min16ints = (min16ints ^ halfs); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-53): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-54): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  min16ints = (min16ints ^ floats); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-54): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-55): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  min16ints = (min16ints ^ doubles); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-58): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-59): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  min16ints = (min16ints ^ min16floats); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-58): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-59): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  min16ints = (min16ints ^ min10floats); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  _Static_assert(std::is_same<min16int, __decltype(min16ints ^ min16ints)>::value, "");
+  _Static_assert(std::is_same<min16int, __decltype(min16ints ^ min12ints)>::value, "");
+  _Static_assert(std::is_same<min16uint, __decltype(min16ints ^ min16uints)>::value, "");
+  _Static_assert(std::is_same<min12int, __decltype(min12ints ^ bools)>::value, "");  // expected-warning {{min12int is promoted to min16int}}
+  _Static_assert(std::is_same<int, __decltype(min12ints ^ ints)>::value, "");
+  _Static_assert(std::is_same<uint, __decltype(min12ints ^ uints)>::value, "");
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-52): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-53): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  min12ints = (min12ints ^ halfs); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-53): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-54): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  min12ints = (min12ints ^ floats); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-54): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-55): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  min12ints = (min12ints ^ doubles); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-58): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-59): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  min12ints = (min12ints ^ min16floats); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-58): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-59): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  min12ints = (min12ints ^ min10floats); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  _Static_assert(std::is_same<min16int, __decltype(min12ints ^ min16ints)>::value, "");
+  _Static_assert(std::is_same<min12int, __decltype(min12ints ^ min12ints)>::value, "");  // expected-warning {{min12int is promoted to min16int}}
+  _Static_assert(std::is_same<min16uint, __decltype(min12ints ^ min16uints)>::value, "");
+  _Static_assert(std::is_same<min16uint, __decltype(min16uints ^ bools)>::value, "");
+  _Static_assert(std::is_same<uint, __decltype(min16uints ^ ints)>::value, "");
+  _Static_assert(std::is_same<uint, __decltype(min16uints ^ uints)>::value, "");
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-53): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-54): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  min16uints = (min16uints ^ halfs); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-54): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-55): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  min16uints = (min16uints ^ floats); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-55): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-56): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  min16uints = (min16uints ^ doubles); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-59): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-60): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  min16uints = (min16uints ^ min16floats); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-59): error X3082: int or unsigned int type required;X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,12-60): error X3013: 'get_value': no matching 1 parameter function;compilation failed; no code produced
+  min16uints = (min16uints ^ min10floats); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  _Static_assert(std::is_same<min16uint, __decltype(min16uints ^ min16ints)>::value, "");
+  _Static_assert(std::is_same<min16uint, __decltype(min16uints ^ min12ints)>::value, "");
+  _Static_assert(std::is_same<min16uint, __decltype(min16uints ^ min16uints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(bools && bools)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(bools && ints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(bools && uints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(bools && halfs)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(bools && floats)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(bools && doubles)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(bools && min16floats)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(bools && min10floats)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(bools && min16ints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(bools && min12ints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(bools && min16uints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(ints && bools)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(ints && ints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(ints && uints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(ints && halfs)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(ints && floats)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(ints && doubles)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(ints && min16floats)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(ints && min10floats)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(ints && min16ints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(ints && min12ints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(ints && min16uints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(uints && bools)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(uints && ints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(uints && uints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(uints && halfs)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(uints && floats)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(uints && doubles)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(uints && min16floats)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(uints && min10floats)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(uints && min16ints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(uints && min12ints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(uints && min16uints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(halfs && bools)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(halfs && ints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(halfs && uints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(halfs && halfs)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(halfs && floats)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(halfs && doubles)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(halfs && min16floats)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(halfs && min10floats)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(halfs && min16ints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(halfs && min12ints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(halfs && min16uints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(floats && bools)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(floats && ints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(floats && uints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(floats && halfs)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(floats && floats)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(floats && doubles)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(floats && min16floats)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(floats && min10floats)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(floats && min16ints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(floats && min12ints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(floats && min16uints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(doubles && bools)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(doubles && ints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(doubles && uints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(doubles && halfs)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(doubles && floats)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(doubles && doubles)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(doubles && min16floats)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(doubles && min10floats)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(doubles && min16ints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(doubles && min12ints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(doubles && min16uints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min16floats && bools)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min16floats && ints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min16floats && uints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min16floats && halfs)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min16floats && floats)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min16floats && doubles)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min16floats && min16floats)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min16floats && min10floats)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min16floats && min16ints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min16floats && min12ints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min16floats && min16uints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min10floats && bools)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min10floats && ints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min10floats && uints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min10floats && halfs)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min10floats && floats)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min10floats && doubles)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min10floats && min16floats)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min10floats && min10floats)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min10floats && min16ints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min10floats && min12ints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min10floats && min16uints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min16ints && bools)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min16ints && ints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min16ints && uints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min16ints && halfs)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min16ints && floats)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min16ints && doubles)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min16ints && min16floats)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min16ints && min10floats)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min16ints && min16ints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min16ints && min12ints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min16ints && min16uints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min12ints && bools)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min12ints && ints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min12ints && uints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min12ints && halfs)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min12ints && floats)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min12ints && doubles)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min12ints && min16floats)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min12ints && min10floats)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min12ints && min16ints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min12ints && min12ints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min12ints && min16uints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min16uints && bools)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min16uints && ints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min16uints && uints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min16uints && halfs)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min16uints && floats)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min16uints && doubles)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min16uints && min16floats)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min16uints && min10floats)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min16uints && min16ints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min16uints && min12ints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min16uints && min16uints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(bools || bools)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(bools || ints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(bools || uints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(bools || halfs)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(bools || floats)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(bools || doubles)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(bools || min16floats)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(bools || min10floats)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(bools || min16ints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(bools || min12ints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(bools || min16uints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(ints || bools)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(ints || ints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(ints || uints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(ints || halfs)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(ints || floats)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(ints || doubles)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(ints || min16floats)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(ints || min10floats)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(ints || min16ints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(ints || min12ints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(ints || min16uints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(uints || bools)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(uints || ints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(uints || uints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(uints || halfs)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(uints || floats)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(uints || doubles)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(uints || min16floats)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(uints || min10floats)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(uints || min16ints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(uints || min12ints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(uints || min16uints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(halfs || bools)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(halfs || ints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(halfs || uints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(halfs || halfs)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(halfs || floats)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(halfs || doubles)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(halfs || min16floats)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(halfs || min10floats)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(halfs || min16ints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(halfs || min12ints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(halfs || min16uints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(floats || bools)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(floats || ints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(floats || uints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(floats || halfs)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(floats || floats)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(floats || doubles)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(floats || min16floats)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(floats || min10floats)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(floats || min16ints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(floats || min12ints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(floats || min16uints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(doubles || bools)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(doubles || ints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(doubles || uints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(doubles || halfs)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(doubles || floats)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(doubles || doubles)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(doubles || min16floats)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(doubles || min10floats)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(doubles || min16ints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(doubles || min12ints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(doubles || min16uints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min16floats || bools)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min16floats || ints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min16floats || uints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min16floats || halfs)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min16floats || floats)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min16floats || doubles)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min16floats || min16floats)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min16floats || min10floats)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min16floats || min16ints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min16floats || min12ints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min16floats || min16uints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min10floats || bools)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min10floats || ints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min10floats || uints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min10floats || halfs)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min10floats || floats)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min10floats || doubles)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min10floats || min16floats)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min10floats || min10floats)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min10floats || min16ints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min10floats || min12ints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min10floats || min16uints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min16ints || bools)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min16ints || ints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min16ints || uints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min16ints || halfs)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min16ints || floats)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min16ints || doubles)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min16ints || min16floats)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min16ints || min10floats)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min16ints || min16ints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min16ints || min12ints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min16ints || min16uints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min12ints || bools)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min12ints || ints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min12ints || uints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min12ints || halfs)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min12ints || floats)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min12ints || doubles)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min12ints || min16floats)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min12ints || min10floats)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min12ints || min16ints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min12ints || min12ints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min12ints || min16uints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min16uints || bools)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min16uints || ints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min16uints || uints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min16uints || halfs)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min16uints || floats)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min16uints || doubles)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min16uints || min16floats)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min16uints || min10floats)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min16uints || min16ints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min16uints || min12ints)>::value, "");
+  _Static_assert(std::is_same<bool, __decltype(min16uints || min16uints)>::value, "");
+
+  return param4;
+}

tools/clang/test/HLSL/vector-syntax-exact-precision.hlsl

@@ -0,0 +1,183 @@
+// RUN: %clang_cc1 -no-min-precision -fsyntax-only -ffreestanding -verify %s
+
+float3 f3_ones = 1.0.xxx;
+float3 f3_ones_exp = 2.0e+2.rrr;
+
+vector v;
+vector<float, 1+1> v1p1;
+/*verify-ast
+  VarDecl <col:1, col:20> col:20 v1p1 'vector<float, 1 + 1>':'vector<float, 2>'
+*/
+static const int i = 1;
+vector<float, i+i> vfi;
+/*verify-ast
+  VarDecl <col:1, col:20> col:20 vfi 'vector<float, i + i>':'vector<float, 2>'
+*/
+static const int2 g_i2 = {1,2};
+/*verify-ast
+  VarDecl <col:1, col:30> col:19 used g_i2 'const int2':'const vector<int, 2>' static cinit
+  `-InitListExpr <col:26, col:30> 'const int2':'const vector<int, 2>'
+    |-ImplicitCastExpr <col:27> 'int' <IntegralCast>
+    | `-IntegerLiteral <col:27> 'literal int' 1
+    `-ImplicitCastExpr <col:29> 'int' <IntegralCast>
+      `-IntegerLiteral <col:29> 'literal int' 2
+*/
+
+// Clang front-end currently doesn't support non-basic types in constant expressions, such as below:
+vector<float, g_i2.y> v_const_vec_expr2;                    /* expected-error {{non-type template argument of type 'int' is not an integral constant expression}} fxc-pass {{}} */
+vector<float, g_i2.x + g_i2.y> v_const_vec_expr3;           /* expected-error {{non-type template argument of type 'int' is not an integral constant expression}} fxc-pass {{}} */
+
+void use_const_vec_expr() {
+    float2 f2 = v_const_vec_expr2.xy;
+    float3 f3 = v_const_vec_expr3.xyz;
+
+    // These should fail (but don't in clang, since it couldn't construct the original vectors)
+    float f_error2 = v_const_vec_expr2.z;                   /* fxc-error {{X3018: invalid subscript 'z'}} */
+    float f_error3 = v_const_vec_expr3.w;                   /* fxc-error {{X3018: invalid subscript 'w'}} */
+}
+
+void abs_without_using_result() {
+    vector<float, 4> myvector;
+    abs(myvector);                  /* expected-warning {{ignoring return value of function declared with const attribute}} fxc-pass {{}} */
+
+    vector<float, 4> myvector2;
+    abs(myvector2);                 /* expected-warning {{ignoring return value of function declared with const attribute}} fxc-pass {{}} */
+}
+
+void abs_with_assignment() {
+    vector<float, 4> myvector;
+    vector<float, 4> absvector;
+    absvector = abs(myvector);
+}
+
+vector<float, 4> abs_for_result(vector<float, 4> value) {
+    return abs(value);
+}
+
+void fn_use_vector(vector<float, 4> value) { }
+
+void abs_in_argument() {
+    vector<float, 4> myvector;
+    fn_use_vector(abs(myvector));
+    /*verify-ast
+      CallExpr <col:5, col:32> 'void'
+      |-ImplicitCastExpr <col:5> 'void (*)(vector<float, 4>)' <FunctionToPointerDecay>
+      | `-DeclRefExpr <col:5> 'void (vector<float, 4>)' lvalue Function 'fn_use_vector' 'void (vector<float, 4>)'
+      `-CallExpr <col:19, col:31> 'vector<float, 4>':'vector<float, 4>'
+        |-ImplicitCastExpr <col:19> 'vector<float, 4> (*)(vector<float, 4>)' <FunctionToPointerDecay>
+        | `-DeclRefExpr <col:19> 'vector<float, 4> (vector<float, 4>)' lvalue Function 'abs' 'vector<float, 4> (vector<float, 4>)'
+        `-ImplicitCastExpr <col:23> 'vector<float, 4>':'vector<float, 4>' <LValueToRValue>
+          `-DeclRefExpr <col:23> 'vector<float, 4>':'vector<float, 4>' lvalue Var 'myvector' 'vector<float, 4>':'vector<float, 4>'
+    */
+}
+
+void vector_on_demand() {
+    float4 thevector;
+    float4 anothervector;
+    bool2 boolvector;
+}
+
+void abs_on_demand() {
+   float2 f2;
+   float2 result = abs(f2);
+}
+
+void vector_out_of_bounds() {
+  vector<float, 8> vector_oob_0; // expected-error {{invalid value, valid range is between 1 and 4 inclusive}} fxc-error {{X3052: vector dimension must be between 1 and 4}}
+  vector<float, 0> vector_oob_1; // expected-error {{invalid value, valid range is between 1 and 4 inclusive}} fxc-error {{X3052: vector dimension must be between 1 and 4}}
+  vector<float, -1> vector_oob_2; // expected-error {{invalid value, valid range is between 1 and 4 inclusive}} fxc-error {{X3052: vector dimension must be between 1 and 4}}
+}
+
+void vector_unsigned() {
+   unsigned int4 intvector;
+   unsigned min16int4 min16vector;
+   unsigned int64_t3 int64vector;
+   unsigned uint3 uintvector;
+   unsigned min16uint4 min16uintvector;
+   unsigned uint64_t2 int64uintvector;
+   unsigned dword3 dwordvector; /* fxc-error {{X3000: unrecognized identifier 'dword3'}} */
+
+   unsigned float2 floatvector; /* expected-error {{'float' cannot be signed or unsigned}} fxc-error {{X3085: unsigned can not be used with type}} */
+   unsigned bool3 boolvector;   /* expected-error {{'bool' cannot be signed or unsigned}} fxc-error {{X3085: unsigned can not be used with type}} */
+   unsigned half4 halfvector;   /* expected-error {{'half' cannot be signed or unsigned}} fxc-error {{X3085: unsigned can not be used with type}} */
+   unsigned double1 doublevector;                           /* expected-error {{'double' cannot be signed or unsigned}} fxc-error {{X3085: unsigned can not be used with type}} */
+   unsigned min12int2 min12intvector;                       /* expected-warning {{min12int is promoted to min16int}} fxc-error {{X3085: unsigned can not be used with type}} */
+   unsigned min16float3 min16floatvector;                   /* expected-error {{'half' cannot be signed or unsigned}} expected-warning {{min16float is promoted to half}} fxc-error {{X3085: unsigned can not be used with type}} */
+}
+
+float fn() {
+    float4 myvar = float4(1,2,3,4);
+    myvar.x = 1.0f;
+    myvar.y = 1.0f;
+    myvar.z = 1.0f;
+    myvar.w = 1.0f;
+    myvar[0] = 1.0f;
+    myvar[1]= 1.0f;
+    myvar[2] = 1.0f;
+    myvar[3] = 1.0f;
+    myvar[-10] = 1.0f;            /* expected-error {{vector element index '-10' is out of bounds}} fxc-pass {{}} */
+    myvar[4] = 1.0f;              /* expected-error {{vector element index '4' is out of bounds}} fxc-pass {{}} */
+
+    float3 myvar3 = float3(1,2,3);
+    myvar3[3] = 1.0f;             /* expected-error {{vector element index '3' is out of bounds}} fxc-pass {{}} */
+
+    float2 myvar2 = float2(1,2);
+    myvar2[2] = 1.0f;             /* expected-error {{vector element index '2' is out of bounds}} fxc-pass {{}} */
+
+    float1 myvar1 = float1(1);
+    myvar1[1] = 1.0f;             /* expected-error {{vector element index '1' is out of bounds}} fxc-pass {{}} */
+
+    const float4 constMyVar = float4(1,2,3,4);              /* expected-note {{variable 'constMyVar' declared const here}} expected-note {{variable 'constMyVar' declared const here}} fxc-pass {{}} */
+    constMyVar = float4(1,1,1,1); /* expected-error {{cannot assign to variable 'constMyVar' with const-qualified type 'const float4'}} fxc-error {{X3025: l-value specifies const object}} */
+    constMyVar[0] = 2.0f;         /* expected-error {{cannot assign to variable 'constMyVar' with const-qualified type 'const float4'}} fxc-error {{X3025: l-value specifies const object}} */
+
+    float4 myothervar;
+    myothervar.rgba = myvar.xyzw;
+    /*verify-ast
+      BinaryOperator <col:5, col:29> 'vector<float, 4>':'vector<float, 4>' '='
+      |-HLSLVectorElementExpr <col:5, col:16> 'vector<float, 4>':'vector<float, 4>' lvalue vectorcomponent rgba
+      | `-DeclRefExpr <col:5> 'float4':'vector<float, 4>' lvalue Var 'myothervar' 'float4':'vector<float, 4>'
+      `-ImplicitCastExpr <col:23, col:29> 'vector<float, 4>':'vector<float, 4>' <LValueToRValue>
+        `-HLSLVectorElementExpr <col:23, col:29> 'vector<float, 4>':'vector<float, 4>' lvalue vectorcomponent xyzw
+          `-DeclRefExpr <col:23> 'float4':'vector<float, 4>' lvalue Var 'myvar' 'float4':'vector<float, 4>'
+    */
+
+    float f;
+    f.x = 1;
+
+    uint u;
+    u = f.x;
+
+    uint3 u3;
+    u3.xyz = f.xxx;
+    /*verify-ast
+      BinaryOperator <col:5, col:16> 'vector<uint, 3>':'vector<unsigned int, 3>' '='
+      |-HLSLVectorElementExpr <col:5, col:8> 'vector<uint, 3>':'vector<unsigned int, 3>' lvalue vectorcomponent xyz
+      | `-DeclRefExpr <col:5> 'uint3':'vector<unsigned int, 3>' lvalue Var 'u3' 'uint3':'vector<unsigned int, 3>'
+      `-ImplicitCastExpr <col:14, col:16> 'vector<unsigned int, 3>' <HLSLCC_FloatingToIntegral>
+        `-HLSLVectorElementExpr <col:14, col:16> 'vector<float, 3>':'vector<float, 3>' xxx
+          `-ImplicitCastExpr <col:14> 'vector<float, 1>':'vector<float, 1>' lvalue <HLSLVectorSplat>
+            `-DeclRefExpr <col:14> 'float' lvalue Var 'f' 'float'
+    */
+    u3 = (!u3).zyx;
+    /*verify-ast
+      BinaryOperator <col:5, col:16> 'uint3':'vector<unsigned int, 3>' '='
+      |-DeclRefExpr <col:5> 'uint3':'vector<unsigned int, 3>' lvalue Var 'u3' 'uint3':'vector<unsigned int, 3>'
+      `-ImplicitCastExpr <col:10, col:16> 'vector<unsigned int, 3>' <HLSLCC_IntegralCast>
+        `-HLSLVectorElementExpr <col:10, col:16> 'vector<bool, 3>':'vector<bool, 3>' zyx
+          `-ParenExpr <col:10, col:14> 'vector<bool, 3>':'vector<bool, 3>'
+            `-UnaryOperator <col:11, col:12> 'vector<bool, 3>':'vector<bool, 3>' prefix '!'
+              `-ImplicitCastExpr <col:12> 'vector<bool, 3>' <HLSLCC_IntegralToBoolean>
+                `-ImplicitCastExpr <col:12> 'uint3':'vector<unsigned int, 3>' <LValueToRValue>
+                  `-DeclRefExpr <col:12> 'uint3':'vector<unsigned int, 3>' lvalue Var 'u3' 'uint3':'vector<unsigned int, 3>'
+    */
+    f.xx = 2; // expected-error {{vector is not assignable (contains duplicate components)}} fxc-error {{X3025: l-value specifies const object}}
+    u3.x = u3.w;                                            /* expected-error {{vector swizzle 'w' is out of bounds}} fxc-error {{X3018: invalid subscript 'w'}} */
+
+    return f.x;
+}
+
+// float4 main(float4 param4 : FOO) : FOO {
+float4 plain(float4 param4 /* : FOO */) /*: FOO */{
+  return fn();
+}

tools/clang/tools/dxcompiler/dxcompilerobj.cpp

@@ -39,7 +39,6 @@
 
 #include "dxc/Support/WinIncludes.h"
 #include "dxc/HLSL/DxilContainer.h"
-
 #include "dxc/dxcapi.internal.h"
 
 #include "dxc/Support/dxcapi.use.h"
@@ -786,6 +785,8 @@ public:
     compiler.getLangOpts().HLSL2016 = Opts.HLSL2016;
     compiler.getLangOpts().HLSL2017 = Opts.HLSL2017;
 
+    compiler.getLangOpts().NoMinPrecision = Opts.NoMinPrecision;
+
     if (Opts.WarningAsError)
       compiler.getDiagnostics().setWarningsAsErrors(true);
 

tools/clang/unittests/HLSL/CompilerTest.cpp

@@ -794,6 +794,7 @@ public:
   TEST_METHOD(CodeGenIndexing_Operator_Mod)
   TEST_METHOD(CodeGenIntrinsic_Examples_Mod)
   TEST_METHOD(CodeGenLiterals_Mod)
+  TEST_METHOD(CodeGenLiterals_Exact_Precision_Mod)
   TEST_METHOD(CodeGenMatrix_Assignments_Mod)
   TEST_METHOD(CodeGenMatrix_Syntax_Mod)
   //TEST_METHOD(CodeGenMore_Operators_Mod)
@@ -1333,8 +1334,16 @@ public:
     std::wstring profile =
         Unicode::UTF8ToUTF16StringOrThrow(opts.TargetProfile.str().c_str());
 
+    std::vector<std::wstring> argLists;
+    CopyArgsToWStrings(opts.Args, hlsl::options::CoreOption, argLists);
+
+    std::vector<LPCWSTR> args;
+    args.reserve(argLists.size());
+    for (const std::wstring &a : argLists)
+      args.push_back(a.data());
+
     VERIFY_SUCCEEDED(pCompiler->Compile(
-        pSource, name, entry.c_str(), profile.c_str(), nullptr, 0,
+        pSource, name, entry.c_str(), profile.c_str(), args.data(), args.size(),
         opts.Defines.data(), opts.Defines.size(), nullptr, &pResult));
     HRESULT result;
     VERIFY_SUCCEEDED(pResult->GetStatus(&result));
@@ -3201,11 +3210,11 @@ TEST_F(CompilerTest, CodeGenIf4) { CodeGenTest(L"..\\CodeGenHLSL\\if4.hlsl"); }
 
 TEST_F(CompilerTest, CodeGenIf5) { CodeGenTest(L"..\\CodeGenHLSL\\if5.hlsl"); }
 
-TEST_F(CompilerTest, CodeGenIf6) { CodeGenTest(L"..\\CodeGenHLSL\\if6.hlsl"); }
+TEST_F(CompilerTest, CodeGenIf6) { CodeGenTestCheck(L"..\\CodeGenHLSL\\if6.hlsl"); }
 
-TEST_F(CompilerTest, CodeGenIf7) { CodeGenTest(L"..\\CodeGenHLSL\\if7.hlsl"); }
+TEST_F(CompilerTest, CodeGenIf7) { CodeGenTestCheck(L"..\\CodeGenHLSL\\if7.hlsl"); }
 
-TEST_F(CompilerTest, CodeGenIf8) { CodeGenTest(L"..\\CodeGenHLSL\\if8.hlsl"); }
+TEST_F(CompilerTest, CodeGenIf8) { CodeGenTestCheck(L"..\\CodeGenHLSL\\if8.hlsl"); }
 
 TEST_F(CompilerTest, CodeGenIf9) { CodeGenTestCheck(L"..\\CodeGenHLSL\\if9.hlsl"); }
 
@@ -4228,6 +4237,10 @@ TEST_F(CompilerTest, CodeGenLiterals_Mod) {
   CodeGenTest(L"..\\CodeGenHLSL\\literals_Mod.hlsl");
 }
 
+TEST_F(CompilerTest, CodeGenLiterals_Exact_Precision_Mod) {
+  CodeGenTest(L"..\\CodeGenHLSL\\literals_exact_precision_Mod.hlsl");
+}
+
 TEST_F(CompilerTest, CodeGenMatrix_Assignments_Mod) {
   CodeGenTest(L"..\\CodeGenHLSL\\matrix-assignments_Mod.hlsl");
 }

tools/clang/unittests/HLSL/VerifierTest.cpp

@@ -46,12 +46,15 @@ public:
   TEST_METHOD(RunIntrinsicExamples);
   TEST_METHOD(RunMatrixAssignments);
   TEST_METHOD(RunMatrixSyntax);
+  TEST_METHOD(RunMatrixSyntaxExactPrecision);
   TEST_METHOD(RunMoreOperators);
   TEST_METHOD(RunObjectOperators);
   TEST_METHOD(RunPackReg);
   TEST_METHOD(RunScalarAssignments);
+  TEST_METHOD(RunScalarAssignmentsExactPrecision);
   TEST_METHOD(RunScalarOperatorsAssign);
   TEST_METHOD(RunScalarOperators);
+  TEST_METHOD(RunScalarOperatorsExactPrecision);
   TEST_METHOD(RunString);
   TEST_METHOD(RunStructAssignments);
   TEST_METHOD(RunTemplateChecks);
@@ -59,6 +62,7 @@ public:
   TEST_METHOD(RunVectorAssignments);
   TEST_METHOD(RunVectorSyntaxMix);
   TEST_METHOD(RunVectorSyntax);
+  TEST_METHOD(RunVectorSyntaxExactPrecision);
   TEST_METHOD(RunTypemodsSyntax);
   TEST_METHOD(RunSemantics);
   TEST_METHOD(RunImplicitCasts);
@@ -183,6 +187,10 @@ TEST_F(VerifierTest, RunMatrixSyntax) {
   CheckVerifiesHLSL(L"matrix-syntax.hlsl");
 }
 
+TEST_F(VerifierTest, RunMatrixSyntaxExactPrecision) {
+  CheckVerifiesHLSL(L"matrix-syntax-exact-precision.hlsl");
+}
+
 TEST_F(VerifierTest, RunMoreOperators) {
   CheckVerifiesHLSL(L"more-operators.hlsl");
 }
@@ -199,6 +207,10 @@ TEST_F(VerifierTest, RunScalarAssignments) {
   CheckVerifiesHLSL(L"scalar-assignments.hlsl");
 }
 
+TEST_F(VerifierTest, RunScalarAssignmentsExactPrecision) {
+  CheckVerifiesHLSL(L"scalar-assignments-exact-precision.hlsl");
+}
+
 TEST_F(VerifierTest, RunScalarOperatorsAssign) {
   CheckVerifiesHLSL(L"scalar-operators-assign.hlsl");
 }
@@ -207,6 +219,10 @@ TEST_F(VerifierTest, RunScalarOperators) {
   CheckVerifiesHLSL(L"scalar-operators.hlsl");
 }
 
+TEST_F(VerifierTest, RunScalarOperatorsExactPrecision) {
+  CheckVerifiesHLSL(L"scalar-operators-exact-precision.hlsl");
+}
+
 TEST_F(VerifierTest, RunString) {
   CheckVerifiesHLSL(L"string.hlsl");
 }
@@ -235,6 +251,10 @@ TEST_F(VerifierTest, RunVectorSyntax) {
   CheckVerifiesHLSL(L"vector-syntax.hlsl");
 }
 
+TEST_F(VerifierTest, RunVectorSyntaxExactPrecision) {
+  CheckVerifiesHLSL(L"vector-syntax-exact-precision.hlsl");
+}
+
 TEST_F(VerifierTest, RunTypemodsSyntax) {
   CheckVerifiesHLSL(L"typemods-syntax.hlsl");
 }